698 lines
No EOL
34 KiB
C++
698 lines
No EOL
34 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
// (c) Copyright, Ubisoft Entertainment Inc. || Created by Harbour //
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
#include "tests/config.h"
|
|
#if defined(US_SDK_FULL)
|
|
#include "tests/common/helpers.h"
|
|
#include "tests/fixture/authenticationFixture.h"
|
|
#include "tests/fixture/loginMockFixture.h"
|
|
#include "tests/mock/mockResultHelper.h"
|
|
#include "tests/mock/parametersMockHelper.h"
|
|
#include <ubiservices/core/types/dateTimeHelper.h>
|
|
#include <ubiservices/services/battlepass/battlepass.h>
|
|
#include <ubiservices/services/battlepass/battlepassClient.h>
|
|
#include <../private/ubiservices/services/battlepass/battlepassProxy.h>
|
|
#include <ubiservices/services/battlepass/battlepassSeason.h>
|
|
#include <ubiservices/services/battlepass/battlepassSeasonProgression.h>
|
|
#include <../private/ubiservices/services/cacheManager.h>
|
|
#include <ubiservices/services/http/request/httpGet.h>
|
|
#include <ubiservices/services/parameters/parametersClient.h>
|
|
|
|
namespace US_NS {;
|
|
|
|
US_DEFINE_TEST(TestBattlepassClient);
|
|
|
|
#if !defined(US_DLL) && !defined(US_SDK_TEST_CHINA)
|
|
|
|
typedef AuthenticationFixture<1> BATTLEPASSCLIENT;
|
|
typedef LoginMockFixture<true> BATTLEPASSCLIENT_MOCK;
|
|
typedef LoginMockFixture<false> BATTLEPASSCLIENT_MOCK_NOLOGIN;
|
|
|
|
namespace TestBattlepassClientUnit_BF
|
|
{
|
|
Json getBattlepass();
|
|
Json getBattlepassSeason();
|
|
Json getBattlepassSeasonProgression();
|
|
|
|
void validateBattlepass(const Battlepass& battlepass);
|
|
void validateBattlepassSeason(BattlepassSeason& battlepassSeason);
|
|
void validateBattlepassSeasonProgression(const BattlepassSeasonProgression& battlepassSeasonProgression);
|
|
}
|
|
|
|
namespace TestBattlepassClient_BF
|
|
{
|
|
const char* const DUMMY_SPACE_ID = "11111111-2222-3333-4444-555566667777";
|
|
const char* const DUMMY_SEASON_ID = "00000000-0000-0000-0000-555566667777";
|
|
const char* const HARBOUR_XPLAY_SPACE_ID = "65b080dc-d03d-4190-b911-c90e03c4592d"; // Harbour Xplay Crossplay Retail space Id
|
|
const int32 DUMMY_PAST_SEASON_PERIOD = -2;
|
|
const uint32 DUMMY_FUTURE_SEASON_PERIOD = 1;
|
|
}
|
|
|
|
///////////////////////////////////////
|
|
// Battlepass
|
|
///////////////////////////////////////
|
|
|
|
/// @test Validate parsing works has expected with valid data
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, LOCAL_GetBattlepassValidJsonResponse)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
HttpGet request(StringUrl(""));
|
|
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(TestBattlepassClientUnit_BF::getBattlepass().renderContent());
|
|
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-battlepasses")
|
|
.WillOnce(testing::DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&request)), testing::Return(mockResult)));
|
|
}
|
|
|
|
const AsyncResult<Battlepass> result = client.getBattlepass();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const Battlepass& battlepass = result.getResult();
|
|
TestBattlepassClientUnit_BF::validateBattlepass(battlepass);
|
|
}
|
|
|
|
/// @test Validate parsing fails has expected with invalid data
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, Local_GetBattlepassInvalidJsonResponse)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
HttpGet request(StringUrl(""));
|
|
|
|
{
|
|
// Rename displayName to make extractor fails
|
|
String invalidResponse(TestBattlepassClientUnit_BF::getBattlepass().renderContent().replace("displayName", "name"));
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(invalidResponse);
|
|
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-battlepasses")
|
|
.WillOnce(testing::DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&request)), testing::Return(mockResult)));
|
|
}
|
|
|
|
const AsyncResult<Battlepass> result = client.getBattlepass();
|
|
ASSERT_FALSE(AsyncHelper::waitSuccess(result));
|
|
}
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Validate call doesn't occurs with feature switch off
|
|
TEST_F(BATTLEPASSCLIENT_MOCK_NOLOGIN, Local_BattlepassFeatureSwitchOff)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
{
|
|
setupWebsocketMock();
|
|
|
|
const MockAsyncResult parametersSpaceMock = MockResultHelper::createSuccessResult(
|
|
ParametersSpaceMockHelper().changeFeatureSwitch(FeatureSwitchId::Battlepass, FeatureSwitchState::Disabled).getParameters().renderContent());
|
|
mockFullLogin(nullptr, nullptr, ¶metersSpaceMock);
|
|
}
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(getPlayerCredentials(), {}, {})));
|
|
waitForPostLoginCompletion();
|
|
|
|
EXPECT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Battlepass));
|
|
|
|
{
|
|
const AsyncResult<Battlepass> result = getFacade().getBattlepassClient().getBattlepass();
|
|
EXPECT_FALSE(AsyncHelper::waitSuccess(result));
|
|
}
|
|
|
|
{
|
|
const AsyncResult<BattlepassSeason> result = getFacade().getBattlepassClient().getBattlepassSeason();
|
|
EXPECT_FALSE(AsyncHelper::waitSuccess(result));
|
|
}
|
|
|
|
{
|
|
const AsyncResult<BattlepassSeasonProgression> result = getFacade().getBattlepassClient().getBattlepassSeasonProgression();
|
|
EXPECT_FALSE(AsyncHelper::waitSuccess(result));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/// @test Validate URL content when passing parameter(s) in method
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, US_TestGetBattlepassParameters)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
HttpGet request(StringUrl(""));
|
|
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(TestBattlepassClientUnit_BF::getBattlepass().renderContent());
|
|
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-battlepasses")
|
|
.WillRepeatedly(testing::DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&request)), testing::Return(mockResult)));
|
|
}
|
|
|
|
// No param = Default SpaceId is use
|
|
{
|
|
const AsyncResult<Battlepass> result = client.getBattlepass();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("/spaces/" + getFacade().getWorkingSpaceId()));
|
|
}
|
|
|
|
// Use provided SpaceId
|
|
{
|
|
const AsyncResult<Battlepass> result = client.getBattlepass(SpaceId(TestBattlepassClient_BF::DUMMY_SPACE_ID));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("/spaces/" + String(TestBattlepassClient_BF::DUMMY_SPACE_ID)));
|
|
}
|
|
}
|
|
|
|
/// @test Validate calls on service
|
|
TEST_F(BATTLEPASSCLIENT, US_MINRUN_TestGetBattlepass)
|
|
{
|
|
//setupDebugLogging();
|
|
const AsyncResult<Battlepass> result = getFacade().getBattlepassClient().getBattlepass(SpaceId(TestBattlepassClient_BF::HARBOUR_XPLAY_SPACE_ID));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const Battlepass& battlepass = result.getResult();
|
|
|
|
EXPECT_EQ("SDK BattlePass Experiment", battlepass.m_displayName);
|
|
EXPECT_EQ(SeasonId("bc87959b-a95e-4d8f-a1e2-ea7d52f2830e"), battlepass.m_configs.m_currentSeasonId);
|
|
EXPECT_EQ(1, battlepass.m_configs.previousSeasonPeriodsCount);
|
|
EXPECT_EQ(0, battlepass.m_configs.m_nextSeasonPeriodsCount);
|
|
EXPECT_TRUE(battlepass.m_object.isSpecified());
|
|
}
|
|
|
|
/// @test Check that the battlepass is correctly using the cache
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, USNOT_GetBattlepassCache)
|
|
{
|
|
{
|
|
const String mockResponse = TestBattlepassClientUnit_BF::getBattlepass().renderContent();
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(mockResponse);
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "mock-battlepasses", mockResult);
|
|
}
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
{ // The first call generates a server request.
|
|
const AsyncResult<Battlepass> result = client.getBattlepass();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
Battlepass battlepass = result.getResult();
|
|
TestBattlepassClientUnit_BF::validateBattlepass(battlepass);
|
|
}
|
|
{ // The second call only involves the cache (and therefore, the result is the same!)
|
|
const AsyncResult<Battlepass> result = client.getBattlepass();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
Battlepass battlepass = result.getResult();
|
|
TestBattlepassClientUnit_BF::validateBattlepass(battlepass);
|
|
}
|
|
|
|
BattlepassProxy::invalidateCache(client, CacheUnit::Battlepass);
|
|
|
|
{
|
|
const String mockResponse = TestBattlepassClientUnit_BF::getBattlepass().renderContent();
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(mockResponse);
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "mock-battlepasses", mockResult);
|
|
}
|
|
{ // The cache was invalidated, so the The call generates a server request.
|
|
const AsyncResult<Battlepass> result = client.getBattlepass();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
Battlepass battlepass = result.getResult();
|
|
TestBattlepassClientUnit_BF::validateBattlepass(battlepass);
|
|
}
|
|
|
|
US_TEST_NS::Helper::sleep(ParametersSpaceMockHelper::s_MOCK_TIME_TO_LIVE_RESOURCE_MSEC * 2);
|
|
{
|
|
const String mockResponse = TestBattlepassClientUnit_BF::getBattlepass().renderContent();
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(mockResponse);
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "mock-battlepasses", mockResult);
|
|
}
|
|
{ // Sleeping so all entries in cache expire, there will be a service request to get the data for a all spaces
|
|
const AsyncResult<Battlepass> result = client.getBattlepass();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
Battlepass battlepass = result.getResult();
|
|
TestBattlepassClientUnit_BF::validateBattlepass(battlepass);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////
|
|
// Battlepass Season
|
|
///////////////////////////////////////
|
|
|
|
/// @test Validate parsing works has expected with valid data
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, LOCAL_GetBattlepassSeasonValidJsonResponse)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
HttpGet request(StringUrl(""));
|
|
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(TestBattlepassClientUnit_BF::getBattlepassSeason().renderContent());
|
|
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-battlepasses-seasons")
|
|
.WillOnce(testing::DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&request)), testing::Return(mockResult)));
|
|
}
|
|
|
|
const AsyncResult<BattlepassSeason> result = client.getBattlepassSeason();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
BattlepassSeason battlepassSeason = result.getResult();
|
|
TestBattlepassClientUnit_BF::validateBattlepassSeason(battlepassSeason);
|
|
}
|
|
|
|
/// @test Validate parsing fails has expected with invalid data
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, Local_GetBattlepassSeasonInvalidJsonResponse)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
HttpGet request(StringUrl(""));
|
|
|
|
{
|
|
// Rename startsAt to make extractor fails
|
|
String invalidResponse(TestBattlepassClientUnit_BF::getBattlepassSeason().renderContent().replace("startsAt", "start"));
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(invalidResponse);
|
|
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-battlepasses-seasons")
|
|
.WillOnce(testing::DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&request)), testing::Return(mockResult)));
|
|
}
|
|
|
|
const AsyncResult<BattlepassSeason> result = client.getBattlepassSeason();
|
|
ASSERT_FALSE(AsyncHelper::waitSuccess(result));
|
|
}
|
|
|
|
/// @test Validate URL content when passing parameter(s) in method
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, US_TestGetBattlepassSeasonParametersDefaultSpaceId)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
HttpGet request(StringUrl(""));
|
|
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(TestBattlepassClientUnit_BF::getBattlepassSeason().renderContent());
|
|
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-battlepasses-seasons")
|
|
.WillRepeatedly(testing::DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&request)), testing::Return(mockResult)));
|
|
}
|
|
|
|
// No param = Default SpaceId is use
|
|
{
|
|
const AsyncResult<BattlepassSeason> result = client.getBattlepassSeason();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("/spaces/" + getFacade().getWorkingSpaceId()));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("seasonId="));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("period="));
|
|
}
|
|
}
|
|
|
|
/// @test Validate URL content when passing parameter(s) in method
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, US_TestGetBattlepassSeasonParametersProvidedSpaceId)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
HttpGet request(StringUrl(""));
|
|
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(TestBattlepassClientUnit_BF::getBattlepassSeason().renderContent());
|
|
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-battlepasses-seasons")
|
|
.WillRepeatedly(testing::DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&request)), testing::Return(mockResult)));
|
|
}
|
|
|
|
// Use provided SpaceId
|
|
{
|
|
const AsyncResult<BattlepassSeason> result = client.getBattlepassSeason(SpaceId(TestBattlepassClient_BF::DUMMY_SPACE_ID));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("/spaces/" + String(TestBattlepassClient_BF::DUMMY_SPACE_ID)));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("seasonId="));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("period="));
|
|
}
|
|
}
|
|
|
|
/// @test Validate URL content when passing parameter(s) in method
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, US_TestGetBattlepassSeasonParametersProvidedSeasonId)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
HttpGet request(StringUrl(""));
|
|
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(TestBattlepassClientUnit_BF::getBattlepassSeason().renderContent());
|
|
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-battlepasses-seasons")
|
|
.WillRepeatedly(testing::DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&request)), testing::Return(mockResult)));
|
|
}
|
|
// Use provided SeasonId
|
|
{
|
|
const AsyncResult<BattlepassSeason> result = client.getBattlepassSeason(SpaceId(), SeasonId(TestBattlepassClient_BF::DUMMY_SEASON_ID));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("/spaces/" + getFacade().getWorkingSpaceId()));
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("seasonId=" + String(TestBattlepassClient_BF::DUMMY_SEASON_ID)));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("period="));
|
|
}
|
|
}
|
|
|
|
/// @test Validate URL content when passing parameter(s) in method
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, US_TestGetBattlepassSeasonParametersNegativePeriod)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
HttpGet request(StringUrl(""));
|
|
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(TestBattlepassClientUnit_BF::getBattlepassSeason().renderContent());
|
|
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-battlepasses-seasons")
|
|
.WillRepeatedly(testing::DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&request)), testing::Return(mockResult)));
|
|
}
|
|
|
|
// Use provided Period (Negative = past)
|
|
{
|
|
const AsyncResult<BattlepassSeason> result = client.getBattlepassSeason(SpaceId(), SeasonId(), TestBattlepassClient_BF::DUMMY_PAST_SEASON_PERIOD);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("/spaces/" + getFacade().getWorkingSpaceId()));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("seasonId="));
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase(String::formatText("period=%d", TestBattlepassClient_BF::DUMMY_PAST_SEASON_PERIOD)));
|
|
}
|
|
}
|
|
|
|
/// @test Validate URL content when passing parameter(s) in method
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, US_TestGetBattlepassSeasonParametersPositivePeriod)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
HttpGet request(StringUrl(""));
|
|
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(TestBattlepassClientUnit_BF::getBattlepassSeason().renderContent());
|
|
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-battlepasses-seasons")
|
|
.WillRepeatedly(testing::DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&request)), testing::Return(mockResult)));
|
|
}
|
|
|
|
// Use provided Period (Positive = future)
|
|
{
|
|
const AsyncResult<BattlepassSeason> result = client.getBattlepassSeason(SpaceId(), SeasonId(), TestBattlepassClient_BF::DUMMY_FUTURE_SEASON_PERIOD);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("/spaces/" + getFacade().getWorkingSpaceId()));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("seasonId="));
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase(String::formatText("period=%d", TestBattlepassClient_BF::DUMMY_FUTURE_SEASON_PERIOD)));
|
|
}
|
|
}
|
|
|
|
/// @test Validate calls on service
|
|
TEST_F(BATTLEPASSCLIENT, US_MINRUN_TestGetBattlepassSeason)
|
|
{
|
|
//setupDebugLogging();
|
|
const AsyncResult<BattlepassSeason> result = getFacade().getBattlepassClient().getBattlepassSeason(SpaceId(TestBattlepassClient_BF::HARBOUR_XPLAY_SPACE_ID));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const BattlepassSeason& battlepassSeason = result.getResult();
|
|
|
|
// Validate some values (no need to test all of them)
|
|
EXPECT_EQ(SeasonId("bc87959b-a95e-4d8f-a1e2-ea7d52f2830e"), battlepassSeason.m_id);
|
|
EXPECT_EQ(DateTimeHelper::parseDateISO8601("2019-07-26T00:00:00Z"), battlepassSeason.m_startAt);
|
|
EXPECT_EQ(DateTimeHelper::parseDateISO8601("2049-07-25T00:00:00Z"), battlepassSeason.m_endAt);
|
|
EXPECT_EQ("https://uat-ubiservices.cdn.ubi.com/65b080dc-d03d-4190-b911-c90e03c4592d/Battlepass/battlepass-season-image-SDK-tests.jpg", battlepassSeason.m_images.m_seasonBackground);
|
|
|
|
ASSERT_EQ(1u, battlepassSeason.m_primaryStoreLinks.size());
|
|
StringKeyMap<String>::const_iterator it = battlepassSeason.m_primaryStoreLinks.find("pc");
|
|
ASSERT_TRUE(it != battlepassSeason.m_primaryStoreLinks.end());
|
|
EXPECT_EQ("http://pc.primarystore.com", it->second);
|
|
|
|
ASSERT_TRUE(battlepassSeason.m_object.isSpecified());
|
|
ASSERT_TRUE(battlepassSeason.m_progressionOfferId.isSpecified());
|
|
EXPECT_EQ(StoreOfferId("eda745f1-3d73-404b-b702-0584d21af78d"), battlepassSeason.m_progressionOfferId.value());
|
|
EXPECT_EQ(2, battlepassSeason.m_tiersCount);
|
|
ASSERT_TRUE(battlepassSeason.m_tiers[0].m_object.isSpecified());
|
|
EXPECT_EQ(0, battlepassSeason.m_tiers[0].m_freeReward.size());
|
|
EXPECT_EQ(1, battlepassSeason.m_tiers[0].m_premiumReward.size());
|
|
EXPECT_NE(String::npos, battlepassSeason.m_tiers[0].m_premiumReward[0].m_displayName.findSubstringCase("[en] Premium reward"));
|
|
}
|
|
|
|
/// @test Check that the battlepass season is correctly using the cache
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, USNOT_GetBattlepassSeasonCache)
|
|
{
|
|
{
|
|
const String mockResponse = TestBattlepassClientUnit_BF::getBattlepassSeason().renderContent();
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(mockResponse);
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "mock-battlepasses-seasons", mockResult);
|
|
}
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
{ // The first call generates a server request.
|
|
const AsyncResult<BattlepassSeason> result = client.getBattlepassSeason();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
BattlepassSeason battlepassSeason = result.getResult();
|
|
TestBattlepassClientUnit_BF::validateBattlepassSeason(battlepassSeason);
|
|
}
|
|
{ // The second call only involves the cache (and therefore, the result is the same!)
|
|
const AsyncResult<BattlepassSeason> result = client.getBattlepassSeason();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
BattlepassSeason battlepassSeason = result.getResult();
|
|
TestBattlepassClientUnit_BF::validateBattlepassSeason(battlepassSeason);
|
|
}
|
|
|
|
BattlepassProxy::invalidateCache(client, CacheUnit::BattlepassSeason);
|
|
|
|
{
|
|
const String mockResponse = TestBattlepassClientUnit_BF::getBattlepassSeason().renderContent();
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(mockResponse);
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "mock-battlepasses-seasons", mockResult);
|
|
}
|
|
{ // The cache was invalidated, so the The call generates a server request.
|
|
const AsyncResult<BattlepassSeason> result = client.getBattlepassSeason();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
BattlepassSeason battlepassSeason = result.getResult();
|
|
TestBattlepassClientUnit_BF::validateBattlepassSeason(battlepassSeason);
|
|
}
|
|
|
|
US_TEST_NS::Helper::sleep(ParametersSpaceMockHelper::s_MOCK_TIME_TO_LIVE_RESOURCE_MSEC * 2);
|
|
{
|
|
const String mockResponse = TestBattlepassClientUnit_BF::getBattlepassSeason().renderContent();
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(mockResponse);
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "mock-battlepasses-seasons", mockResult);
|
|
}
|
|
{ // Sleeping so all entries in cache expire, there will be a service request to get the data for a all spaces
|
|
const AsyncResult<BattlepassSeason> result = client.getBattlepassSeason();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
BattlepassSeason battlepassSeason = result.getResult();
|
|
TestBattlepassClientUnit_BF::validateBattlepassSeason(battlepassSeason);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////
|
|
// Battlepass Season Progression
|
|
///////////////////////////////////////
|
|
|
|
/// @test Validate parsing works has expected with valid data
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, LOCAL_GetBattlepassSeasonProgressionValidJsonResponse)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
HttpGet request(StringUrl(""));
|
|
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(TestBattlepassClientUnit_BF::getBattlepassSeasonProgression().renderContent());
|
|
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/me/mock-battlepasses-seasons")
|
|
.WillOnce(testing::DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&request)), testing::Return(mockResult)));
|
|
}
|
|
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
BattlepassSeasonProgression BattlepassSeasonProgression = result.getResult();
|
|
TestBattlepassClientUnit_BF::validateBattlepassSeasonProgression(BattlepassSeasonProgression);
|
|
}
|
|
|
|
/// @test Validate parsing fails has expected with invalid data
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, Local_GetBattlepassSeasonProgressionInvalidJsonResponse)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
HttpGet request(StringUrl(""));
|
|
|
|
{
|
|
// Rename premiumTrackUnlocked to make extractor fails
|
|
String invalidResponse(TestBattlepassClientUnit_BF::getBattlepassSeasonProgression().renderContent().replace("premiumTrackUnlocked", "premium"));
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(invalidResponse);
|
|
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/me/mock-battlepasses-seasons")
|
|
.WillOnce(testing::DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&request)), testing::Return(mockResult)));
|
|
}
|
|
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression();
|
|
ASSERT_FALSE(AsyncHelper::waitSuccess(result));
|
|
}
|
|
|
|
/// @test Validate URL content when passing parameter(s) in method
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, US_TestGetBattlepassSeasonProgressionParameters)
|
|
{
|
|
//setupDebugLogging();
|
|
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
HttpGet request(StringUrl(""));
|
|
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(TestBattlepassClientUnit_BF::getBattlepassSeasonProgression().renderContent());
|
|
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/me/mock-battlepasses-seasons")
|
|
.WillRepeatedly(testing::DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&request)), testing::Return(mockResult)));
|
|
}
|
|
|
|
// No param = Default SpaceId is use
|
|
{
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("spaceId=" + getFacade().getWorkingSpaceId()));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("seasonId="));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("period="));
|
|
}
|
|
|
|
// Use provided SpaceId
|
|
{
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression(SpaceId(TestBattlepassClient_BF::DUMMY_SPACE_ID));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("spaceId=" + String(TestBattlepassClient_BF::DUMMY_SPACE_ID)));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("seasonId="));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("period="));
|
|
}
|
|
|
|
// Use provided SeasonId
|
|
{
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression(SpaceId(), SeasonId(TestBattlepassClient_BF::DUMMY_SEASON_ID));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("spaceId=" + getFacade().getWorkingSpaceId()));
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("seasonId=" + String(TestBattlepassClient_BF::DUMMY_SEASON_ID)));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("period="));
|
|
}
|
|
|
|
// Use provided Period (Negative = past)
|
|
{
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression(SpaceId(), SeasonId(), TestBattlepassClient_BF::DUMMY_PAST_SEASON_PERIOD);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("spaceId=" + getFacade().getWorkingSpaceId()));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("seasonId="));
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase(String::formatText("period=%d", TestBattlepassClient_BF::DUMMY_PAST_SEASON_PERIOD)));
|
|
}
|
|
|
|
// Use provided Period (Positive = future)
|
|
{
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression(SpaceId(), SeasonId(), TestBattlepassClient_BF::DUMMY_FUTURE_SEASON_PERIOD);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase("spaceId=" + getFacade().getWorkingSpaceId()));
|
|
EXPECT_EQ(String::npos, request.getUrl().findSubstringNoCase("seasonId="));
|
|
EXPECT_NE(String::npos, request.getUrl().findSubstringNoCase(String::formatText("period=%d", TestBattlepassClient_BF::DUMMY_FUTURE_SEASON_PERIOD)));
|
|
}
|
|
}
|
|
|
|
/// @test Check that the battlepass season progression is correctly using the cache
|
|
TEST_F(BATTLEPASSCLIENT_MOCK, USNOT_GetBattlepassSeasonProgressionCache)
|
|
{
|
|
const String mockResponse = TestBattlepassClientUnit_BF::getBattlepassSeasonProgression().renderContent();
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(mockResponse);
|
|
BattlepassClient& client = getFacade().getBattlepassClient();
|
|
|
|
SpaceId spaceId("11111111-1111-1111-1111-111111111111");
|
|
SeasonId defaultSeasonId;
|
|
int32 defaultPeriod(0);
|
|
|
|
using namespace TestBattlepassClientUnit_BF;
|
|
|
|
{ // The first call generates a server request.
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/me/mock-battlepasses-seasons", mockResult);
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression(spaceId, defaultSeasonId, defaultPeriod);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
validateBattlepassSeasonProgression(result.getResult());
|
|
}
|
|
|
|
{ // The second is identical and only involves the cache and doesn't generate a server request.
|
|
US_EXPECT_NO_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/me/mock-battlepasses-seasons");
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression(spaceId, defaultSeasonId, defaultPeriod);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
validateBattlepassSeasonProgression(result.getResult());
|
|
}
|
|
|
|
SpaceId otherSpaceId("22222222-2222-2222-2222-222222222222");
|
|
|
|
{ // generates a server request as the spaceId is different
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/me/mock-battlepasses-seasons", mockResult);
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression(otherSpaceId, defaultSeasonId, defaultPeriod);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
validateBattlepassSeasonProgression(result.getResult());
|
|
}
|
|
|
|
SeasonId someSeasonId("33333333-3333-3333-3333-333333333333");
|
|
|
|
{ // generates a server request as the seasonId is used to precise a particular season
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/me/mock-battlepasses-seasons", mockResult);
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression(spaceId, someSeasonId, defaultPeriod);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
validateBattlepassSeasonProgression(result.getResult());
|
|
}
|
|
|
|
int32 somePeriod(1);
|
|
|
|
{ // generates a server request as the period is used instead of seasonId to precise a particular season
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/me/mock-battlepasses-seasons", mockResult);
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression(spaceId, defaultSeasonId, somePeriod);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
validateBattlepassSeasonProgression(result.getResult());
|
|
}
|
|
|
|
{ // repeating the last one should not send a call
|
|
US_EXPECT_NO_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/me/mock-battlepasses-seasons");
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression(spaceId, defaultSeasonId, somePeriod);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
validateBattlepassSeasonProgression(result.getResult());
|
|
}
|
|
|
|
{ // repeating the first one should not send a call either
|
|
US_EXPECT_NO_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/me/mock-battlepasses-seasons");
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression(spaceId, defaultSeasonId, defaultPeriod);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
validateBattlepassSeasonProgression(result.getResult());
|
|
}
|
|
|
|
US_TEST_NS::Helper::sleep(ParametersSpaceMockHelper::s_MOCK_TIME_TO_LIVE_RESOURCE_MSEC + 1000);
|
|
|
|
{ // should send a call as we waited more than the mock TTL
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/me/mock-battlepasses-seasons", mockResult);
|
|
const AsyncResult<BattlepassSeasonProgression> result = client.getBattlepassSeasonProgression(spaceId, defaultSeasonId, defaultPeriod);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
validateBattlepassSeasonProgression(result.getResult());
|
|
}
|
|
}
|
|
|
|
/// @test Validate calls on service
|
|
TEST_F(BATTLEPASSCLIENT, US_MINRUN_TestGetBattlepassSeasonProgression)
|
|
{
|
|
//setupDebugLogging();
|
|
const AsyncResult<BattlepassSeasonProgression> result = getFacade().getBattlepassClient().getBattlepassSeasonProgression(SpaceId(TestBattlepassClient_BF::HARBOUR_XPLAY_SPACE_ID));
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const BattlepassSeasonProgression& battlepassSeasonProgression = result.getResult();
|
|
|
|
// Validate some values (no need to test all of them)
|
|
EXPECT_EQ(SeasonId("bc87959b-a95e-4d8f-a1e2-ea7d52f2830e"), battlepassSeasonProgression.m_seasonId);
|
|
EXPECT_EQ(0u, battlepassSeasonProgression.m_progression);
|
|
ASSERT_FALSE(battlepassSeasonProgression.m_premiumTrackUnlocked);
|
|
EXPECT_EQ(0u, battlepassSeasonProgression.m_lastTierPremiumBanked);
|
|
ASSERT_FALSE(battlepassSeasonProgression.m_lastTierPremiumBankedAt.isSpecified());
|
|
}
|
|
#endif //!defined(US_DLL)
|
|
};
|
|
#endif //defined(US_SDK_FULL)
|