dreyndev/JD2022-TU1
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
JD2022-TU1/main/extern/UbiServices/custom/testsIntegration/testKillSwitches.cpp

1148 lines
60 KiB
C++
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
// (c) Copyright, Ubisoft Entertainment Inc. || Created by Harbour //
////////////////////////////////////////////////////////////////////////////////
#include "entityTestHelper.h"
#include "tests/config.h"
#include "tests/fixture/authenticationFixture.h"
#include "tests/fixture/loginMockFixture.h"
#include "tests/fixture/memoryCheckFixture.h"
#include "tests/fixture/paramFixture.h"
#include "tests/mock/mockLogDevice.h"
#include "tests/mock/mockResultHelper.h"
#include "tests/mock/parametersMockHelper.h"
#include "testsIntegration/event/eventsConfigMockHelper.h"
#if !defined(US_SDK_LIGHT_MOBILE) && !defined(US_SDK_S2S)
#include "testsIntegration/storeHelper.h"
#endif
#include <../private/ubiservices/core/chrono/chronometer.h>
#include <ubiservices/core/configs/config.h>
#include <../private/ubiservices/core/debug/assert.h>
#include <ubiservices/core/errors/errorCodes.h>
#include <ubiservices/core/errors/errorDetails.h>
#include <../private/ubiservices/core/helpers/instancesManager.h>
#include <ubiservices/core/helpers/resultRange.h>
#include <ubiservices/core/tasks/asyncResult.h>
#include <ubiservices/core/tasks/asyncResultBatch.h>
#include <../private/ubiservices/core/extensions/enumeration.h>
#include <../private/ubiservices/core/tasks/asyncResultInternal.h>
#include <ubiservices/core/types/containers.h>
#include <ubiservices/core/types/string.h>
#if !defined(US_SDK_S2S)
#include <ubiservices/core/types/typesId/entityId.h>
#endif
#include <ubiservices/facade.h>
#include <ubiservices/services/authentication/authenticationClient.h>
#if !defined(US_SDK_S2S)
#include <ubiservices/services/authentication/credentialsExternalToken.h>
#include <ubiservices/services/authentication/credentialsType.h>
#include <ubiservices/services/authentication/playerCredentials.h>
#endif
#include <ubiservices/services/authentication/sessionInfo.h>
#if !defined(US_SDK_S2S)
#include <ubiservices/services/club/actionsGroup.h>
#include <ubiservices/services/club/clubClient.h>
#endif
#include <ubiservices/services/http/httpClient.h>
#include <ubiservices/services/http/request/httpGet.h>
#if !defined(US_SDK_S2S)
#include <ubiservices/services/entity/entityClient.h>
#include <ubiservices/services/entity/entityCreation.h>
#include <ubiservices/services/entity/entityStreamContext.h>
#endif
#include <../private/ubiservices/services/event/eventClientImpl.h>
#include <../private/ubiservices/services/event/eventClientProxy.h>
#include <ubiservices/services/event/eventNotification.h>
#if !defined(US_SDK_S2S)
#include <ubiservices/services/event/types/eventInfoCustom.h>
#endif
#include <ubiservices/services/event/types/eventInfoService.h>
#if !defined(US_SDK_S2S)
#include <ubiservices/services/friend/friendClient.h>
#include <ubiservices/services/friend/friendInfo.h>
#endif
#include <ubiservices/services/moderation/moderationClient.h>
#include <ubiservices/services/moderation/moderationInfo.h>
#if !defined(US_SDK_S2S)
#include <ubiservices/services/news/newsClient.h>
#include <ubiservices/services/notification/connectionInfo.h>
#include <ubiservices/services/notification/notificationClient.h>
#include <../private/ubiservices/services/notification/notificationClientProxy.h>
#include <ubiservices/services/notification/notificationOutgoing.h>
#include <ubiservices/services/primaryStore/primaryStoreClient.h>
#include <ubiservices/services/primaryStore/primaryStoreInventoryItem.h>
#include <ubiservices/services/user/userClient.h>
#endif
#include <ubiservices/services/parameters/parametersClient.h>
#include <../private/ubiservices/services/parameters/featureSwitch.h>
#include <../private/ubiservices/services/parameters/parametersClientProxy.h>
#if !defined(US_SDK_S2S)
#include <ubiservices/services/populations/dynamicPopulationCustomDataRange.h>
#include <ubiservices/services/populations/populationClient.h>
#include <ubiservices/services/profile/profileClient.h>
#if defined(US_SDK_FULL)
#include <ubiservices/services/profile/profileInfoExternal.h>
#endif
#include <ubiservices/services/secondaryStore/offerSpace.h>
#include <ubiservices/services/secondaryStore/secondaryStoreClient.h>
#if defined(US_SDK_FULL)
#include <ubiservices/services/secondaryStoreInstantiation/secondaryStoreInstantiationClient.h>
#endif
#include <ubiservices/services/stats/statsClient.h>
#if defined(US_SDK_FULL)
#include <ubiservices/services/userGeneratedContents/userGeneratedContentsClient.h>
#endif
#include <ubiservices/services/websocket/websocketClient.h>
#endif
#include <usCommon/authenticationHelper.h>
#include <usCommon/options.h>
#include <usCommon/settings.h>
namespace US_NS {;
US_DEFINE_TEST(TestKillSwitches);
typedef LoginMockFixture<true> FEATURE_SWITCH_MOCK;
typedef LoginMockFixture<false> FEATURE_SWITCH_MOCK_NOLOGIN;
typedef AuthenticationFixture<1> FEATURE_SWITCH_LOGIN;
/// @cond PRIVATE_API
namespace TestKillSwitches_BF
{
MockAsyncResult GetMockAsyncResultQueueConfig()
{
const uint32 QUEUE_CONFIG = 0xFFFFFFFF;
return MockResultHelper::createSuccessResult(EventsConfigMockHelper::getBody(&QUEUE_CONFIG, NULL).renderContent());
}
}
/// @endcond
#if !defined(US_DLL)
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, USNOT_MissingFeatureSwitch)
{
{
// All but CreateSession feature switch present
const MockAsyncResult parametersSpaceMock = MockResultHelper::createSuccessResult(
ParametersSpaceMockHelper().changeFeatureSwitch(FeatureSwitchId::CreateSession, FeatureSwitchState::Removed).getParameters().renderContent());
const MockAsyncResult parametersApplicationMock = getMockedParametersApplication();
mockFullLogin(NULL, &parametersApplicationMock, &parametersSpaceMock);
}
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(GET_CREDENTIALS(), {}, {})));
ASSERT_TRUE(US_TEST_NS::Helper::waitForWebsocketInit(getFacade()));
EXPECT_TRUE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::CreateSession));
}
#endif
#if !defined(US_DLL)
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchEventOff)
{
// Waiting for login to be done so there's no blocking popUnsentEvents
waitForPostLoginCompletion();
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Event, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Event));
// Here is the list of jobs that rely on this switch:
// v JobSendEvents
// v JobSendPoppedEvents
// EventClient functions
EventClient& client = getFacade().getEventClient();
#if !defined(US_SDK_S2S)
ASSERT_EQ(PushEventResult::Success, client.pushEvent(EventInfoCustom(CUSTOM_EVENT_NAME)));
#endif
ASSERT_EQ(PushEventResult::Success, client.pushEvent(TestHelpers_BF::getServiceEvent("TestingService")));
ASSERT_TRUE(AsyncHelper::waitFailure(EventClientProxy::getEventClientImpl(getFacade().getEventClient()).sendEvents(), Errors::SKIPPED_FEATURESWITCH));
#if !defined(US_SDK_S2S)
EXPECT_TRUE(AsyncHelper::waitSuccess(getFacade().getEventClient().popUnsentEvents(String())));
#endif
}
/// @test validates that when FeatureSwitchId::CreateSession the only calls to the services
/// are the POST to session/profiles and GET configuration.
/// Also validates that the session is invalidated after that.
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, USNOT_DisableCreateSession)
{
{
const MockAsyncResult parametersSpaceMock = MockResultHelper::createSuccessResult(
ParametersSpaceMockHelper().changeFeatureSwitch(FeatureSwitchId::CreateSession, FeatureSwitchState::Disabled).getParameters().renderContent());
const MockAsyncResult parametersApplicationMock = getMockedParametersApplication();
mockLogin(getMockedLoginResponse(), parametersApplicationMock, parametersSpaceMock);
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-config-events").Times(0);
US_EXPECT_CALL(US_TEST_NS::Action::SendEvents).Times(0);
#if !defined(US_SDK_S2S)
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_PUT, "/profiles/me/mock-populations/data").Times(1);
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-spaces-primarystoremapping").Times(0);
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_POST, "/mock-profiles-inventory-primarystore").Times(0);
#endif
}
ASSERT_TRUE(AsyncHelper::waitFailureResponse(getFacade().createSession(GET_CREDENTIALS(), {}, {}), Errors::SKIPPED_FEATURESWITCH));
// Force a pop to validate that there isn't any call to the events service.
#if !defined(US_SDK_S2S)
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().getEventClient().popUnsentEvents("")));
#endif
ASSERT_FALSE(getFacade().getAuthenticationClient().getSessionInfo().hasValidSession());
// Retry a create session.
// If fails quickly since the feature switches are already available
// And CreateSession is set to disabled
ASSERT_TRUE(AsyncHelper::waitFailureResponse(getFacade().createSession(GET_CREDENTIALS(), {}, {}), Errors::SKIPPED_FEATURESWITCH));
// Just to make sure !
ASSERT_FALSE(getFacade().getAuthenticationClient().getSessionInfo().hasValidSession());
}
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchParametersRequestOff)
{
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Parameters, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Parameters));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getParametersClient().requestParametersGroupsApplication(
ApplicationId("11111111-1111-1111-1111-111111111111"), { "otherParameters" }), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getParametersClient().requestParametersGroupsSpace(
SpaceId("11111111-1111-1111-1111-111111111111"), { "otherParameters" }), Errors::SKIPPED_FEATURESWITCH));
}
#if !defined(US_SDK_S2S)
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchProfilesOff)
{
const String jsonPopulations = // "\"opaque field\": 123"
"{"
"\"populations\": ["
"{\"name\": \"dummy Name 1\",\"obj\": {},\"subject\": \"dummy Subject 1\",\"spaceId\": \"" DUMMY_GUID_ID1 "\",\"assignmentTime\": \"2012-10-15T15:46:32\"},"
"{\"name\": \"dummy Name 2\",\"obj\": {},\"subject\": \"dummy Subject 2\",\"spaceId\": \"" DUMMY_GUID_ID1 "\"},"
"{\"name\": \"dummy Name 3\",\"obj\": {},\"subject\": \"dummy Subject 3\",\"spaceId\": \"" DUMMY_GUID_ID1 "\"}"
"]"
"}";
{
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(jsonPopulations);
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_PUT, "/data", mockResult);
}
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Profiles, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Profiles));
#if defined(US_SDK_LIGHT_MOBLILE)
ProfileClient& client = getFacade().getProfileClient();
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestProfiles({ ProfileId("11111111-2222-3333-4444-555566667777") }), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestUplayProfiles({ UserId("22222222-3333-4444-5555-666677778888") }), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestProfiles({ String() }), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestUplayProfiles({ String("DummyUsername") }), Errors::SKIPPED_FEATURESWITCH));
{
HttpResponse mockHttpResult(200, HttpHeader(), "{\"applications\": []}");
MockAsyncResult mockResult("profileApplications");
mockResult.setResult(mockHttpResult);
mockResult.setToComplete(US_NS::ErrorDetails(Errors::SUCCESS, _T("MockPopulationsSuccess")));
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "profiles/mock-applications")
.Times(testing::AnyNumber())
.WillRepeatedly(testing::Return(mockResult));
}
{
// IMPORTANT: ProfileClient::requestApplicationsUsed is NOT affected by the profile switch.
EXPECT_TRUE(AsyncHelper::waitSuccess(client.requestApplicationsUsed())); // <=== Works as designed!
}
#endif
{
PopulationClient& populationsClient = getFacade().getPopulationsClient();
EXPECT_TRUE(AsyncHelper::waitSuccess(populationsClient.requestPopulations())); // <=== Works as designed!
DynamicPopulationCustomParams customData(SpaceId(MOCKED_GUID_ID1));
customData.addCustomDataRange("level", 10);
EXPECT_TRUE(AsyncHelper::waitSuccess(populationsClient.updatePopulationData(customData))); // <=== Works as designed!
}
}
#endif // !defined(US_SDK_S2S)
#endif
#if defined(US_SDK_FULL)
#if !defined(US_DLL)
TEST_F(FEATURE_SWITCH_MOCK, USNOT_RequestFriendsSwitchedOFF)
{
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::FriendsRequest, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::FriendsRequest));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getFriendClient().requestFriends(FriendClient::ClubWithConsoleInfo), Errors::SKIPPED_FEATURESWITCH));
#if defined(US_TARGET_PS4) || defined(US_TARGET_XONE) || defined(US_TARGET_KILI)
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getFriendClient().requestFriendsConsoleOnly(FriendClient::ClubWithConsoleInfo), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getFriendClient().requestFriendsConsoleWithClubInfo(FriendClient::ClubWithConsoleInfo), Errors::SKIPPED_FEATURESWITCH));
#endif
}
#if defined(US_ENABLE_CLUB_TEST)
#if defined(US_ENABLE_CLUB_LAUNCHAPP)
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchClubLaunchOff)
{
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::ClubApplication, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::ClubApplication));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getClubClient().launchClubApplication("", ClubDisplayContext::InGame), Errors::SKIPPED_FEATURESWITCH));
}
#endif
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchClubActionsOff)
{
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::ClubService, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::ClubService));
ClubClient& client = getFacade().getClubClient();
EXPECT_TRUE(AsyncHelper::waitFailure(client.completeActions({ "MyActionId" }), Errors::SKIPPED_FEATURESWITCH)); // JobCompleteActions
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestActionsAll(), Errors::SKIPPED_FEATURESWITCH)); // JobRequestActions
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestBadges(), Errors::SKIPPED_FEATURESWITCH)); // JobRequestBadges
}
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchClubChallensgeOff)
{
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::ClubService, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::ClubService));
ClubClient& client = getFacade().getClubClient();
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestChallengePoolsProfile(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestChallengeDefinitionProfile({ ChallengeId() }), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestChallengeStatusProfile(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.activateChallengeProfile(ChallengeId()), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.bankChallengeProfile(ChallengeId()), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestChallengePoolsCommunity(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestChallengeDefinitionCommunity({ ChallengeId() }), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestChallengeStatusCommunity(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.bankChallengeCommunity(ChallengeId()), Errors::SKIPPED_FEATURESWITCH));
}
#if defined(US_ENABLE_CLUB_PANEL)
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchClubDynamicPanelOff)
{
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::ClubDynamicPanel, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::ClubDynamicPanel));
ClubClient& client = getFacade().getClubClient();
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestDynamicPanelUrl(), Errors::SKIPPED_FEATURESWITCH));
}
#endif
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchClubRewardsOff)
{
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::ClubService, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::ClubService));
ClubClient& client = getFacade().getClubClient();
EXPECT_TRUE(AsyncHelper::waitFailure(client.purchaseReward("MyRewardId"), Errors::SKIPPED_FEATURESWITCH)); // JobPurchaseReward
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestRewards(), Errors::SKIPPED_FEATURESWITCH)); // JobRequestRewards
}
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchClubFriendsOff)
{
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::ClubService, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::ClubService));
FriendClient& client = getFacade().getFriendClient();
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestFriends(FriendClient::ClubWithConsoleInfo), Errors::SKIPPED_FEATURESWITCH)); // JobRequestFriendsClub
const ProfileId profileId("11111111-2222-3333-4444-555566667777");
EXPECT_TRUE(AsyncHelper::waitFailure(client.sendFriendsClubInvite({ profileId }), Errors::SKIPPED_FEATURESWITCH)); // JobInviteFriendClub
EXPECT_TRUE(AsyncHelper::waitFailure(client.acceptFriendClubInvite(profileId), Errors::SKIPPED_FEATURESWITCH)); // JobAcceptInviteClub
EXPECT_TRUE(AsyncHelper::waitFailure(client.declineFriendClubInvite(profileId), Errors::SKIPPED_FEATURESWITCH)); // JobRemoveFriendClub
EXPECT_TRUE(AsyncHelper::waitFailure(client.removeFriendClub(profileId), Errors::SKIPPED_FEATURESWITCH)); // JobRemoveFriendClub (BIS)
}
#endif // defined(US_ENABLE_CLUB_TEST)
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchFriendRequestOff)
{
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::FriendsRequest, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::FriendsRequest));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getFriendClient().requestFriends(), Errors::SKIPPED_FEATURESWITCH));
#if defined(US_TARGET_PS4) || defined(US_TARGET_XONE) || defined(US_TARGET_KILI)
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getFriendClient().requestFriendsConsoleOnly(FriendClient::ClubWithConsoleInfo), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getFriendClient().requestFriendsConsoleWithClubInfo(FriendClient::ClubWithConsoleInfo), Errors::SKIPPED_FEATURESWITCH));
#endif
}
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchModerationRequestOff)
{
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Moderation, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Moderation));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getModerationClient().requestModeration("text"), Errors::SKIPPED_FEATURESWITCH));
}
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchNewsRequestOff)
{
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::News, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::News));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getNewsClient().requestProfileNews(), Errors::SKIPPED_FEATURESWITCH));
}
#if defined(US_ENABLE_UPLAY_LOGIN)
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, USNOT_SwitchProfilesOff)
{
ProfileClient& client = getFacade().getProfileClient();
{
JsonWriter mockSessionInfo;
LoginMockFixture::getMinimalSessionInfo(mockSessionInfo);
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(mockSessionInfo.renderContent());
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_POST, "/profiles/sessions", mockResult);
const MockAsyncResult parametersSpaceMock = MockResultHelper::createSuccessResult(
ParametersSpaceMockHelper().changeFeatureSwitch(FeatureSwitchId::Profiles,
FeatureSwitchState::Disabled).getParameters().renderContent());
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "parameters")
.WillOnce(testing::Return(getMockedParametersApplication()))
.WillOnce(testing::Return(parametersSpaceMock))
.RetiresOnSaturation();
const CredentialsExternalToken externalToken("", CredentialsType::PsnAccessToken);
const AsyncResult<ProfileInfoExternal> result = client.requestProfileInfoExternal(externalToken);
EXPECT_TRUE(result.wait());
US_EXPECT_FAILURE(result, Errors::SKIPPED_FEATURESWITCH);
}
}
#endif // defined(US_ENABLE_UPLAY_LOGIN)
#if !defined(US_SDK_S2S)
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, USNOT_SwitchPopulationsOff)
{
const FeatureSwitchId FEATURE_ID = FeatureSwitchId::Populations;
{
const MockAsyncResult parametersSpaceMock = MockResultHelper::createSuccessResult(
ParametersSpaceMockHelper().changeFeatureSwitch(FEATURE_ID, FeatureSwitchState::Disabled).getParameters().renderContent());
const MockAsyncResult parametersApplicationMock = getMockedParametersApplication();
const MockAsyncResult eventsConfigMock = TestKillSwitches_BF::GetMockAsyncResultQueueConfig();
mockFullLogin(nullptr, &parametersApplicationMock, &parametersSpaceMock, nullptr, &eventsConfigMock);
}
{
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(getPlayerCredentials(), {}, {})));
waitForPostLoginCompletion();
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FEATURE_ID));
}
// The switch applies to both methods calls.
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getPopulationsClient().requestPopulations(), Errors::SKIPPED_FEATURESWITCH));
DynamicPopulationCustomParams customData(SpaceId(MOCKED_GUID_ID1));
customData.addCustomDataRange("level", 10);
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getPopulationsClient().updatePopulationData(customData), Errors::SKIPPED_FEATURESWITCH));
}
#endif
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, USNOT_SwitchApplicationsUsedOff)
{
{
const MockAsyncResult parametersSpaceMock = MockResultHelper::createSuccessResult(
ParametersSpaceMockHelper().changeFeatureSwitch(FeatureSwitchId::ApplicationUsed, FeatureSwitchState::Disabled).getParameters().renderContent());
const MockAsyncResult parametersApplicationMock = getMockedParametersApplication();
const MockAsyncResult eventsConfigMock = TestKillSwitches_BF::GetMockAsyncResultQueueConfig();
mockFullLogin(NULL, &parametersApplicationMock, &parametersSpaceMock, nullptr, &eventsConfigMock);
}
{
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(getPlayerCredentials(), {}, {})));
ASSERT_TRUE(waitForEventConfig());
ASSERT_TRUE(US_TEST_NS::Helper::waitForWebsocketInit(getFacade()));
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::ApplicationUsed));
}
ASSERT_TRUE(AsyncHelper::waitFailure(getFacade().getProfileClient().requestApplicationsUsed(), Errors::SKIPPED_FEATURESWITCH));
}
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchEntitiesOff)
{
{
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::EntitiesProfile, false);
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::EntitiesSpace, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::EntitiesProfile));
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::EntitiesSpace));
}
// Here is the list of jobs that rely on this switch:
// v JobRequestEntity
// v JobSearchEntities
// v JobCreateProfileEntity
// v JobUpdateProfileEntity
// v JobUpdateProfileEntityWithFeedback
// v JobDeleteProfileEntity
// v JobExtendedStorageCreate
// v JobExtendedStorageDelete
// v JobExtendedStorageDownload
// v JobExtendedStorageDownloadStream
// v JobExtendedStorageUpload
// Create common variables
const EntityId profileEntityId("11111111-2222-3333-4444-555566667777");
const ProfileId profileId("22222222-3333-4444-5555-666677778888");
const Vector<ProfileId> profileIds = { profileId };
const SpaceId spaceId("33333333-4444-5555-6666-777788889999");
const EntityClient::SearchFilter searchFilter = { "Pouet" };
const Vector<String> tags = { "tag1", "tag2" };
const String jsonObj("{\"testEntity\":\"jsonData\"}");
const EntityCreation entityCreation("AutomaticTestGeneratedEntity", "dummyName", jsonObj, tags);
// Build a valid entity as some methods checks that the profile Id in the entity is the same as
// the profile Id in the session information (e.g. updateProfileEntity methods)
EntityProfile validProfileEntity;
{
const SessionInfo sessionInfo = getFacade().getAuthenticationClient().getSessionInfo();
ASSERT_TRUE(sessionInfo.hasValidSession());
const ProfileId& currentProfileId = sessionInfo.getProfileId();
JsonWriter validEntityWriter;
validEntityWriter["entityId"] = "11111111-2222-3333-4444-555566667777";
validEntityWriter["spaceId"] = "22222222-3333-4444-5555-666677778888";
validEntityWriter["type"] = "AutomaticTestGeneratedEntity";
validEntityWriter["name"] = "TestEntity";
validEntityWriter["profileId"] = currentProfileId;
JsonWriter tagsWriter(JsonWriterType::Array);
tagsWriter.addItemToArray("tag1");
tagsWriter.addItemToArray("tag2");
validEntityWriter["tags"] = tagsWriter.getJson();
validEntityWriter["obj"] = "{\"testEntity\":\"jsonData\"}";
validEntityWriter["revision"] = 0;
#if !defined(US_DLL)
EntityTestHelper::parseJson(validProfileEntity, validEntityWriter.getJson());
#endif
}
EntityProfile validSpaceEntity;
{
JsonWriter validEntityWriter;
validEntityWriter["entityId"] = "11111111-2222-3333-4444-555566667777";
validEntityWriter["spaceId"] = "22222222-3333-4444-5555-666677778888";
validEntityWriter["type"] = "AutomaticTestGeneratedEntity";
validEntityWriter["name"] = "TestEntity";
JsonWriter tagsWriter(JsonWriterType::Array);
tagsWriter.addItemToArray("tag1");
tagsWriter.addItemToArray("tag2");
validEntityWriter["tags"] = tagsWriter.getJson();
validEntityWriter["obj"] = "{\"testEntity\":\"jsonData\"}";
validEntityWriter["revision"] = 0;
#if !defined(US_DLL)
EntityTestHelper::parseJson(validSpaceEntity, validEntityWriter.getJson());
#endif
}
EntityClient& client = getFacade().getEntityClient();
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestEntityProfile(profileEntityId), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.searchEntitiesProfile(searchFilter), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.searchEntitiesProfile(searchFilter, profileIds), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.searchEntitiesProfile(searchFilter, profileIds, spaceId), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.createEntityProfile(entityCreation), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.updateEntityProfile(validProfileEntity), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.deleteEntityProfile(profileEntityId), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.searchEntitiesSpace(searchFilter), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.searchEntitiesSpace(searchFilter, { spaceId }), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestEntitySpace(profileEntityId), Errors::SKIPPED_FEATURESWITCH));
// Entity extended storage
const ExtendedStorageProvider provider = ExtendedStorageProvider::S3;
const Vector<uint8> storageData = { 42u }; // Arbitrary value
EntityStreamContext context;
const uint32 CONTENT_LENGTH = 42u; // Arbitrary value
EXPECT_TRUE(AsyncHelper::waitFailure(client.createExtendedStorage(validProfileEntity), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.createExtendedStorage(validProfileEntity, provider), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.createExtendedStorage(validProfileEntity, provider, storageData), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.createExtendedStorage(validProfileEntity, provider, context, CONTENT_LENGTH), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestExtendedStorage(validProfileEntity), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestExtendedStorage(validProfileEntity, context), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestExtendedStorage(validSpaceEntity), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestExtendedStorage(validSpaceEntity, context), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.updateExtendedStorage(validProfileEntity, storageData), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.updateExtendedStorage(validProfileEntity, context, CONTENT_LENGTH), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.deleteExtendedStorage(validProfileEntity), Errors::SKIPPED_FEATURESWITCH));
}
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchUsersOff)
{
{
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
}
UserClient& userClient = getFacade().getUserClient();
const Vector<UserId> userList = { static_cast<UserId>("11111111-2222-3333-4444-555566667777") };
EXPECT_TRUE(AsyncHelper::waitFailure(userClient.requestUserInfo(userList), Errors::SKIPPED_FEATURESWITCH)); // JobRequestUsersBatch
EXPECT_TRUE(AsyncHelper::waitFailure(userClient.requestUserLocalization(), Errors::SKIPPED_FEATURESWITCH));
}
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchHttpClientOff)
{
{
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::HttpClient, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::HttpClient));
}
const HttpGet request(StringUrl(""));
HttpRetryConfig retryConfig(1u);
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getHttpClient().sendRequest(request), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getHttpClient().sendRequest(request, retryConfig), Errors::SKIPPED_FEATURESWITCH));
const MockAsyncResult mockResultInventory = MockResultHelper::createSuccessResult(StoreHelper::renderEmptyArrayResult("items"));
StringStream expectedUrlInventory;
expectedUrlInventory << "/" << getFacade().getAuthenticationClient().getSessionInfo().getProfileId() << "/mock-profiles-inventory";
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, expectedUrlInventory.getContent(), mockResultInventory);
EXPECT_TRUE(AsyncHelper::waitSuccess(getFacade().getSecondaryStoreClient().requestInventory()));
}
#if defined(US_ENABLE_UPLAY_LOGIN)
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchUsersLegalOptinsOff)
{
{
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::UsersLegalOptins, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::UsersLegalOptins));
}
UserClient& userClient = getFacade().getUserClient();
EXPECT_TRUE(AsyncHelper::waitFailure(userClient.requestUserLegalOptIns("CA", "FR"), Errors::SKIPPED_FEATURESWITCH)); // JobRequestUserLegalOptins
EXPECT_TRUE(AsyncHelper::waitFailure(userClient.acceptUserLegalOptIns(LegalOptInsKey()), Errors::SKIPPED_FEATURESWITCH)); // JobAcceptUserLegalOptins
}
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchUsersCreateAndLinkOff)
{
{
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::UsersCreateAndLink, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::UsersCreateAndLink));
}
UserClient& userClient = getFacade().getUserClient();
EXPECT_TRUE(AsyncHelper::waitFailure(userClient.linkCurrentProfileToExternalLinkedProfileUser(CredentialsExternalToken("", CredentialsType::PsnAccessToken)), Errors::SKIPPED_FEATURESWITCH)); // JobLinkCurrentProfileToExternalLinkedProfileUser
EXPECT_TRUE(AsyncHelper::waitFailure(userClient.linkExternalProfileToCurrentLinkedProfileUser(CredentialsExternalToken("", CredentialsType::PsnAccessToken)), Errors::SKIPPED_FEATURESWITCH)); // JobLinkCurrentProfileToExternalLinkedProfileUser
EXPECT_TRUE(AsyncHelper::waitFailure(userClient.validateUserCreationData(UserInfoCreation()), Errors::SKIPPED_FEATURESWITCH)); // JobValidateUserCreationData
EXPECT_TRUE(AsyncHelper::waitFailure(userClient.validateUserCreationData(UserInfoCreation(), LegalOptInsKey()), Errors::SKIPPED_FEATURESWITCH)); // JobValidateUserCreationData
EXPECT_TRUE(AsyncHelper::waitFailure(userClient.createUser(UserInfoCreation(), LegalOptInsKey()), Errors::SKIPPED_FEATURESWITCH)); // JobCreateUser
EXPECT_TRUE(AsyncHelper::waitFailure(userClient.linkCurrentProfile("DummyEmail@dummy.du", "DummyPassword"), Errors::SKIPPED_FEATURESWITCH)); // JobLinkProfile
}
#endif // defined(US_ENABLE_UPLAY_LOGIN)
#endif // !defined(US_DLL)
#if defined(US_ENABLE_UPLAY_LOGIN)
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, DISABLED_USNOT_SwitchCreateUserExternalOff)
{
UserClient& client = getFacade().getUserClient();
{
JsonWriter mockSessionInfo;
LoginMockFixture::getMinimalSessionInfo(mockSessionInfo);
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(mockSessionInfo.renderContent());
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_POST, "/profiles/sessions", mockResult);
const Json json = ParametersSpaceMockHelper().changeFeatureSwitch(FeatureSwitchId::UsersCreateAndLink, FeatureSwitchState::Disabled).getParameters();
const MockAsyncResult mockParametersSpaceMock = MockResultHelper::createSuccessResult(json.renderContent());
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "parameters")
.Times(2)
.WillOnce(testing::Return(getMockedParametersApplication()))
.WillOnce(testing::Return(mockParametersSpaceMock));
}
{
const CredentialsExternalToken externalToken("", CredentialsType::PsnAccessToken);
const AsyncResult<Empty> result = client.createUser(externalToken, UserInfoCreation(), LegalOptInsKey());
EXPECT_TRUE(result.wait());
US_EXPECT_FAILURE(result, Errors::SKIPPED_FEATURESWITCH);
}
}
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, DISABLED_USNOT_SwitchLinkProfileExternalOff)
{
UserClient& client = getFacade().getUserClient();
{
JsonWriter mockSessionInfo;
LoginMockFixture::getMinimalSessionInfo(mockSessionInfo);
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(mockSessionInfo.renderContent());
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_POST, "/profiles/sessions", mockResult);
const MockAsyncResult parametersSpaceMock = MockResultHelper::createSuccessResult(
ParametersSpaceMockHelper().changeFeatureSwitch(FeatureSwitchId::UsersCreateAndLink, FeatureSwitchState::Disabled).getParameters().renderContent());
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "parameters")
.WillOnce(testing::Return(parametersSpaceMock))
.RetiresOnSaturation();
}
{
const CredentialsExternalToken externalToken("", CredentialsType::PsnAccessToken);
EXPECT_TRUE(AsyncHelper::waitFailure(client.linkExternalProfile(externalToken, "dummy@ema.il", "dummyPassword"), Errors::SKIPPED_FEATURESWITCH));
}
}
#endif // defined(US_ENABLE_UPLAY_LOGIN)
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, USNOT_SwitchSessionTicketDefault)
{
{
const MockAsyncResult parametersSpaceMock = MockResultHelper::createSuccessResult(
ParametersSpaceMockHelper().changeFeatureSwitch(FeatureSwitchId::SessionTicket, FeatureSwitchState::Removed).getParameters().renderContent());
const MockAsyncResult parametersApplicationMock = getMockedParametersApplication();
mockFullLogin(NULL, &parametersApplicationMock, &parametersSpaceMock);
}
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(getPlayerCredentials(), {}, {})));
EXPECT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::SessionTicket));
}
#if !defined(US_DLL)
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchSecondaryStoreInstantiationOff)
{
{
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::SecondaryStoreInstantiation, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::SecondaryStoreInstantiation));
}
SecondaryStoreInstantiationClient& client = getFacade().getSecondaryStoreInstantiationClient();
// instances
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestStoreItemInstances(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.searchStoreItemInstances(), Errors::SKIPPED_FEATURESWITCH));
StoreItemInstanceId instanceId("11111111-2222-3333-4444-555566661111");
EXPECT_TRUE(AsyncHelper::waitFailure(client.deleteStoreItemInstance(instanceId), Errors::SKIPPED_FEATURESWITCH));
// attributes
EXPECT_TRUE(AsyncHelper::waitFailure(client.searchAttributes(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestAttributesAll(), Errors::SKIPPED_FEATURESWITCH));
CompressedDataAll data;
EXPECT_TRUE(AsyncHelper::waitFailure(client.decompressAttributes(data), Errors::SKIPPED_FEATURESWITCH));
// rules
EXPECT_TRUE(AsyncHelper::waitFailure(client.searchRules(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestRulesAll(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.decompressRules(data), Errors::SKIPPED_FEATURESWITCH));
// listsOfAttributes
EXPECT_TRUE(AsyncHelper::waitFailure(client.searchListsOfAttributes(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestListsOfAttributesAll(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.decompressListsOfAttributes(data), Errors::SKIPPED_FEATURESWITCH));
}
#endif // !defined(US_DLL)
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, USNOT_SwitchSyncOnResumeToForegroundForNintendoSwitchDefault)
{
{
const MockAsyncResult parametersSpaceMock = MockResultHelper::createSuccessResult(
ParametersSpaceMockHelper().changeFeatureSwitch(FeatureSwitchId::SyncOnResumeToForegroundForNintendoSwitch,
FeatureSwitchState::Removed).getParameters().renderContent());
const MockAsyncResult parametersApplicationMock = getMockedParametersApplication();
mockFullLogin(nullptr, &parametersApplicationMock, &parametersSpaceMock);
}
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(getPlayerCredentials(), {}, {})));
EXPECT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::SyncOnResumeToForegroundForNintendoSwitch));
}
#if !defined(US_DLL)
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, USNOT_SwitchSecondaryStoreOff)
{
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
{
US_EXPECT_LOG("SecondaryStore feature/service shut down", LogLevel::Error, Times(13));
});
{
const MockAsyncResult parametersSpaceMock = MockResultHelper::createSuccessResult(
ParametersSpaceMockHelper().changeFeatureSwitch(FeatureSwitchId::SecondaryStore, FeatureSwitchState::Disabled).getParameters().renderContent());
const MockAsyncResult parametersApplicationMock = getMockedParametersApplication();
const MockAsyncResult eventsConfigMock = TestKillSwitches_BF::GetMockAsyncResultQueueConfig();
mockFullLogin(NULL, &parametersApplicationMock, &parametersSpaceMock, nullptr, &eventsConfigMock);
}
{
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(getPlayerCredentials(), {}, {})));
ASSERT_TRUE(US_TEST_NS::Helper::waitForWebsocketInit(getFacade()));; // Needed to match the calls expected by "mockFullLogin"
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::SecondaryStore, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::SecondaryStore));
}
{
const Vector<StoreItemId> itemIds = { StoreItemId("11111111-2222-3333-4444-555566667777") };
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().requestItems(itemIds), Errors::SKIPPED_FEATURESWITCH));
}
{
const SecondaryStoreClient::SearchFilterItem filter = { "currency", {"weapon"} };
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().searchItems(filter), Errors::SKIPPED_FEATURESWITCH));
}
{
const Vector<StoreOfferId> offerIds = { StoreOfferId("11111111-2222-3333-4444-555566667777") };
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().requestOffersSpace(offerIds), Errors::SKIPPED_FEATURESWITCH));
}
{
SecondaryStoreClient::SearchFilterOfferSpace filter;
filter.m_type = "currency";
filter.m_tags.push_back("weapon");
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().searchOffersSpace(filter), Errors::SKIPPED_FEATURESWITCH));
}
{
const SecondaryStoreClient::SearchFilterItem filter = { "currency", {"weapon"} };
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().searchInventory(filter), Errors::SKIPPED_FEATURESWITCH));
}
{
const SecondaryStoreClient::SearchFilterItem filter = { "currency", {"weapon"} };
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().searchInventoryAll(filter), Errors::SKIPPED_FEATURESWITCH));
}
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().requestPrimaryStoreMapping(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().requestInventory(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().requestInventoryAll(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().requestInventoryItems({ StoreItemId("11111111-2222-3333-4444-555566667777") }), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().applyOffer(OfferSpace()), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().deleteInventory(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().deleteExpiredDetails(DateTime(2016, 01, 22, 12, 30, 0)), Errors::SKIPPED_FEATURESWITCH));
}
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, USNOT_SwitchSecondaryStoreTransactionsOff)
{
{
const MockAsyncResult parametersSpaceMock = MockResultHelper::createSuccessResult(
ParametersSpaceMockHelper().changeFeatureSwitch(FeatureSwitchId::SecondaryStore, FeatureSwitchState::Disabled).getParameters().renderContent());
const MockAsyncResult parametersApplicationMock = getMockedParametersApplication();
const MockAsyncResult eventsConfigMock = TestKillSwitches_BF::GetMockAsyncResultQueueConfig();
mockFullLogin(NULL, &parametersApplicationMock, &parametersSpaceMock, nullptr, &eventsConfigMock);
}
{
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(getPlayerCredentials(), {}, {})));
ASSERT_TRUE(US_TEST_NS::Helper::waitForWebsocketInit(getFacade()));; // Needed to match the calls expected by "mockFullLogin"
ASSERT_TRUE(waitForEventConfig());
//SecondaryStore feature switch if turned off by default
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::SecondaryStore, true);
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::SecondaryStoreTransactions, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::SecondaryStoreTransactions));
}
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getSecondaryStoreClient().applyOffer(OfferSpace()), Errors::SKIPPED_FEATURESWITCH));
}
#if !defined(US_TARGET_MANJARO)
/// @test Checks that PrimaryStore does not work when the switch is set off.
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchPrimaryStoreOff)
{
{
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::PrimaryStore, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::PrimaryStore));
}
#if defined(US_PRIMARY_STORE_WITHOUT_API)
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getPrimaryStoreClient().initializePrimaryStoreProducts(Vector<PrimaryStoreInventoryItem>()), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getPrimaryStoreClient().updatePrimaryStoreProducts(Vector<PrimaryStoreInventoryItem>()), Errors::SKIPPED_FEATURESWITCH));
#elif defined(US_PRIMARY_STORE_WITH_API)
#if !defined(US_TARGET_SWITCH)
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getPrimaryStoreClient().requestItemsCatalog(), Errors::SKIPPED_FEATURESWITCH));
#endif
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getPrimaryStoreClient().requestItemsInventory(), Errors::SKIPPED_FEATURESWITCH));
#endif
}
#endif
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, USNOT_SwitchStatsOff)
{
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
{
US_EXPECT_LOG("Stats feature/service shut down", LogLevel::Error, Times(6));
});
{
const MockAsyncResult parametersSpaceMock = MockResultHelper::createSuccessResult(
ParametersSpaceMockHelper().changeFeatureSwitch(FeatureSwitchId::Stats, FeatureSwitchState::Disabled).getParameters().renderContent());
const MockAsyncResult parametersApplicationMock = getMockedParametersApplication();
const MockAsyncResult eventsConfigMock = TestKillSwitches_BF::GetMockAsyncResultQueueConfig();
mockFullLogin(NULL, &parametersApplicationMock, &parametersSpaceMock, nullptr, &eventsConfigMock);
}
{
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(getPlayerCredentials(), {}, {})));
ASSERT_TRUE(US_TEST_NS::Helper::waitForWebsocketInit(getFacade()));; // Needed to match the calls expected by "mockFullLogin"
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Stats, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Stats));
}
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getStatsClient().requestStatsProfiles(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getStatsClient().requestStatProfilePeriodic("DummyStateName", 0), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getStatsClient().requestStatsCommunity(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getStatsClient().requestStatCommunityPeriodic("DummyStateName", 0), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getStatsClient().requestStatCardsProfiles(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getStatsClient().requestStatCardsProfiles(), Errors::SKIPPED_FEATURESWITCH));
}
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, USNOT_SwitchConnectionOff)
{
{
setupWebsocketMock(MockInitConnection::Twice);
mockFullLogin();
}
{
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(getPlayerCredentials(), {}, {})));
ASSERT_TRUE(waitForEventConfig());
// Without this line, terminateConnection (2) call may fail:
// It is possible to reach the call before the connection to be established!
// ConnectionClient::terminateConnection therefore returns instantly with error Errors::CONNECTION_GENERIC_FAILURE
ASSERT_TRUE(US_TEST_NS::Helper::waitForWebsocketInit(getFacade()));
}
{
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::NotificationWebsocket, false);
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::NotificationRequestConnections, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::NotificationWebsocket));
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::NotificationRequestConnections));
}
// Here is the list of jobs that rely on this switch:
// v JobManageConnection
// v JobRequestConnections
// v JobInitiateConnection
// v JobTerminateConnection
NotificationClient& client = getFacade().getNotificationClient();
{
const Vector<ProfileId> profileIdList = {
ProfileId("11111111-2222-3333-4444-555566667777"),
ProfileId("22222222-3333-4444-5555-666677778888") };
const Vector<ApplicationId> applicationIdList = {
ApplicationId("33333333-4444-5555-6666-777788889999"),
ApplicationId("44444444-5555-6666-7777-88889999AAAA") };
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestConnections(profileIdList), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestConnections(profileIdList, applicationIdList), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(client.requestConnections(profileIdList, applicationIdList, { "Pouet", "Cahuet" }), Errors::SKIPPED_FEATURESWITCH));
}
{
EXPECT_TRUE(AsyncHelper::waitFailure(NotificationClientProxy::updateNotificationTypes(client, { "Pouet", "Cahuet" }), Errors::SKIPPED_FEATURESWITCH));
}
}
// This test is very hard to mock since the connection client is not mocked by itself.
// It would need a lot a of work to do at first glance.
TEST_F(FEATURE_SWITCH_LOGIN, US_SwitchMessagingOff)
{
ASSERT_TRUE(US_TEST_NS::Helper::waitForWebsocketInit(getFacade()));
struct Local
{
static void initiateConnection(Facade& facade, const String& uniqueTestKey)
{
EXPECT_TRUE(AsyncHelper::waitSuccess(NotificationClientProxy::updateNotificationTypes(facade.getNotificationClient(), Vector<String>({ uniqueTestKey }))));
}
static const ProfileId getCurrentProfileId(Facade& facade)
{
const SessionInfo sessionInfo = facade.getAuthenticationClient().getSessionInfo();
if (!sessionInfo.hasValidSession())
{
// TODO: REVIEW: How can this case happen???
ADD_FAILURE();
return ProfileId("11111111-2222-3333-4444-555566667777");
}
return sessionInfo.getProfileId();
}
static const Vector<ConnectionInfo> getList(
Facade& facade, const ProfileId& profile, const String& uniqueTestKey)
{
const AsyncResult<Map<ProfileId, Vector<ConnectionInfo> > > resultConnectionQuery =
facade.getNotificationClient().requestConnections({ profile }, Vector<ApplicationId>(), { uniqueTestKey });
EXPECT_TRUE(resultConnectionQuery.wait());
US_EXPECT_SUCCESS(resultConnectionQuery);
const Map<ProfileId, Vector<ConnectionInfo> >& connectionList = resultConnectionQuery.getResult();
Map<ProfileId, Vector<ConnectionInfo> >::const_iterator connectionIt = connectionList.find(profile);
if (connectionIt == connectionList.end())
{
EXPECT_FALSE(connectionIt == connectionList.end());
return Vector<ConnectionInfo>();
}
else
{
return (connectionIt->second);
}
}
};
{
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::NotificationSend, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::NotificationSend));
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::NotificationSendNoBroker, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::NotificationSendNoBroker));
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::NotificationDynamicUpdate, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::NotificationDynamicUpdate));
}
// Here is the list of jobs that rely on this switch:
// v JobSendSingleNotificationNoBroker
// v JobManageConnection
// Create/Retrieve common variables
const String uniqueTestKey = getWebSocketContentTypes().front();
const NotificationOutgoing message(uniqueTestKey, "messageBody");
const ProfileId profile = Local::getCurrentProfileId(getFacade());
// Messaging needs a connection, otherwise unexpected errors will raise (in place of the SKIPPED_FEATURESWITCH error)
Local::initiateConnection(getFacade(), uniqueTestKey);
NotificationClient& client = getFacade().getNotificationClient();
EXPECT_TRUE(AsyncHelper::waitFailure(client.sendNotificationInSequence({ profile }, message), Errors::SKIPPED_FEATURESWITCH));
const Vector<ConnectionInfo> connectionList = Local::getList(getFacade(), profile, uniqueTestKey);
EXPECT_TRUE(AsyncHelper::waitFailure(client.sendNotificationInSequenceNoBroker(connectionList, message), Errors::SKIPPED_FEATURESWITCH));
}
TEST_F(FEATURE_SWITCH_LOGIN, US_RequestWebSocketSwitchedOFF)
{
EXPECT_TRUE(EventsNotificationHelper::waitForEventConfig(getHandler()));
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::WebSocketClient, false);
const AsyncResult<WebSocketConnectionPtr> result = getFacade().getWebsocketClient().openConnection("ws://mockUrl.ubiservices.ubi.com");
ASSERT_TRUE(result.wait(NS_COMMON::DEFAULT_WAIT_TIME));
US_EXPECT_FAILURE(result, Errors::SKIPPED_FEATURESWITCH);
}
TEST_F(FEATURE_SWITCH_MOCK, USNOT_SwitchUgcOff)
{
ASSERT_TRUE(waitForEventConfig());
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Ugc, false);
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Ugc));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getUserGeneratedContentsClient().searchExternalVideos(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getUserGeneratedContentsClient().requestExternalVideos({}), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getUserGeneratedContentsClient().requestRatings(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getUserGeneratedContentsClient().updateRating(UgcContentId(), UgcRatingValue::Like), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getUserGeneratedContentsClient().requestFavorites(), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getUserGeneratedContentsClient().updateFavoriteStatus(UgcContentId(), UgcFavoriteStatus::Favorite), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getUserGeneratedContentsClient().incrementViews(UgcContentId()), Errors::SKIPPED_FEATURESWITCH));
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getUserGeneratedContentsClient().requestConfigs(), Errors::SKIPPED_FEATURESWITCH));
}
/// Tests that override parameter group mechanism works for feature switches.
TEST_F(FEATURE_SWITCH_MOCK_NOLOGIN, USNOT_OverrideFeatureSwitchesParametersGroup)
{
class ParametersMockHelperOverrideFeatureSwitches : public ParametersSpaceMockHelper
{
public:
ParametersMockHelperOverrideFeatureSwitches(const StringKeyMap<bool>& overrideMap = StringKeyMap<bool>())
: m_overrideMap(overrideMap)
{
}
Json buildParametersGroupOverride() const override
{
JsonWriter fields;
if (!m_overrideMap.empty())
{
{
JsonWriter customValues;
for (const auto& value : m_overrideMap)
{
customValues[value.first] = value.second;
}
fields["us-sdkClientFeaturesSwitches"] = customValues.getJson();
}
}
return renderParameterGroup(fields.getJson());
}
private:
StringKeyMap<bool> m_overrideMap;
};
{
const MockAsyncResult parametersSpaceMock =
MockResultHelper::createSuccessResult(ParametersMockHelperOverrideFeatureSwitches().getParameters().renderContent());
mockFullLogin(nullptr, nullptr, &parametersSpaceMock);
}
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(getPlayerCredentials(), {}, {})));
{
ParametersClient& client = getFacade().getParametersClient();
ASSERT_TRUE(client.isUsFeatureSwitchEnabled(FeatureSwitchId::ClubService));
ASSERT_TRUE(client.isUsFeatureSwitchEnabled(FeatureSwitchId::FriendsRequest));
ASSERT_TRUE(client.isUsFeatureSwitchEnabled(FeatureSwitchId::Battlepass));
}
{
mockDeleteSession();
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().deleteSession()));
}
{
StringKeyMap<bool> overrideMap;
overrideMap["ClubService"] = false;
overrideMap["FriendsRequest"] = false;
const String a = ParametersMockHelperOverrideFeatureSwitches(overrideMap).getParameters().renderContent();
const MockAsyncResult parametersSpaceMock =
MockResultHelper::createSuccessResult(a);
mockFullLogin(nullptr, nullptr, &parametersSpaceMock);
}
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(getPlayerCredentials(), {}, {})));
{
ParametersClient& client = getFacade().getParametersClient();
ASSERT_FALSE(client.isUsFeatureSwitchEnabled(FeatureSwitchId::ClubService));
ASSERT_FALSE(client.isUsFeatureSwitchEnabled(FeatureSwitchId::FriendsRequest));
ASSERT_TRUE(client.isUsFeatureSwitchEnabled(FeatureSwitchId::Battlepass));
}
}
#endif // !defined(US_DLL)
#endif // defined(US_SDK_FULL)
};
Reference in a new issue View git blame Copy permalink