740 lines
24 KiB
C++
740 lines
24 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
// (c) Copyright, Ubisoft Entertainment Inc. || Created by Harbour //
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
#include "tests/config.h"
|
|
#if defined(US_SDK_LIGHT_MOBILE)
|
|
#error This file shall not be part of the solution
|
|
#endif
|
|
#include "tests/fixture/loginMockFixture.h"
|
|
#include "tests/fixture/memoryCheckFixture.h"
|
|
#include <ubiservices/core/errors/errorDetails.h>
|
|
#include <ubiservices/core/helpers/resultRange.h>
|
|
#include <ubiservices/serverTimeHelper.h>
|
|
#include <ubiservices/services/authentication/credentialsExternalToken.h>
|
|
#include <ubiservices/services/authentication/credentialsType.h>
|
|
#include <ubiservices/services/club/badgeInfo.h>
|
|
#include <ubiservices/services/club/conditionInfo.h>
|
|
#include <ubiservices/services/club/rewardInfo.h>
|
|
#include <ubiservices/services/club/unitInfo.h>
|
|
#include <ubiservices/services/club/xpInfo.h>
|
|
#include <ubiservices/services/entity/entityClient.h>
|
|
#include <ubiservices/services/friend/friendInfoFacebook.h>
|
|
#include <ubiservices/services/friend/friendInfoClub.h>
|
|
#include <ubiservices/services/http/httpResponse.h>
|
|
#include <ubiservices/services/profile/profileInfoExternal.h>
|
|
#include <ubiservices/services/user/userInfo.h>
|
|
#include <ubiservices/services/user/userInfoCreation.h>
|
|
#include <ubiservices/services/user/userInfoError.h>
|
|
#include <ubiservices/services/websocket/buffers/textBuffer.h>
|
|
#include <ubiservices/services/websocket/buffers/webSocketBuffer.h>
|
|
#include <ubiservices/services/websocket/websocketConfiguration.h>
|
|
#include <ubiservices/services/websocket/websocketInformation.h>
|
|
|
|
namespace US_NS {;
|
|
US_DEFINE_TEST(TestPublicAttributes);
|
|
|
|
typedef LeakChecker PUBLIC_ATTRIBUTES;
|
|
|
|
namespace TestPublicAttributesForClub_BF
|
|
{
|
|
const char* IMAGE_INFO_URL = "dummyUrl";
|
|
const char* TAG_INFO_ID = "tagId";
|
|
const char* GROUP_INFO_ID = "groupId";
|
|
const char* REQUIREMENT_INFO_ID = "requirementId";
|
|
|
|
ClubImageInfo createClubImageInfo()
|
|
{
|
|
ClubImageInfo imageInfo;
|
|
|
|
const String description("imageDescription");
|
|
imageInfo.m_desc = description;
|
|
EXPECT_EQ(description, imageInfo.m_desc);
|
|
|
|
imageInfo.m_url = IMAGE_INFO_URL;
|
|
EXPECT_EQ(IMAGE_INFO_URL, imageInfo.m_url);
|
|
|
|
return imageInfo;
|
|
}
|
|
|
|
ClubTagInfo createClubTagInfo()
|
|
{
|
|
ClubTagInfo tagInfo;
|
|
|
|
tagInfo.m_id = TAG_INFO_ID;
|
|
EXPECT_EQ(TAG_INFO_ID, tagInfo.m_id);
|
|
|
|
const String tagName("tagName");
|
|
tagInfo.m_name = tagName;
|
|
EXPECT_EQ(tagName, tagInfo.m_name);
|
|
|
|
return tagInfo;
|
|
}
|
|
|
|
ClubGroupInfo createClubGroupInfo()
|
|
{
|
|
ClubGroupInfo groupInfo;
|
|
|
|
groupInfo.m_id = GROUP_INFO_ID;
|
|
EXPECT_EQ(GROUP_INFO_ID, groupInfo.m_id);
|
|
|
|
const String tagName("groupName");
|
|
groupInfo.m_name = tagName;
|
|
EXPECT_EQ(tagName, groupInfo.m_name);
|
|
|
|
return groupInfo;
|
|
}
|
|
|
|
RequirementInfo createClubRequirementInfo()
|
|
{
|
|
RequirementInfo requirementInfo;
|
|
|
|
requirementInfo.m_id = REQUIREMENT_INFO_ID;
|
|
EXPECT_EQ(REQUIREMENT_INFO_ID, requirementInfo.m_id);
|
|
|
|
const SpaceId spaceId("DummySpaceId");
|
|
requirementInfo.m_spaceId = spaceId;
|
|
EXPECT_EQ(spaceId, requirementInfo.m_spaceId);
|
|
|
|
return requirementInfo;
|
|
}
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_Entity)
|
|
{
|
|
EntityClient::SearchFilter filter;
|
|
|
|
const String name("name");
|
|
filter.m_name = name;
|
|
EXPECT_EQ(name, filter.m_name);
|
|
|
|
const String type("type");
|
|
filter.m_type = type;
|
|
EXPECT_EQ(type, filter.m_type);
|
|
|
|
const Vector<String> tags = { "tag1", "tag2" };
|
|
filter.m_tags = tags;
|
|
EXPECT_EQ(tags.front(), filter.m_tags.front());
|
|
EXPECT_EQ(tags.back(), filter.m_tags.back());
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_FriendInfoFacebook)
|
|
{
|
|
const FriendInfoFacebook::FacebookAccountId ACCOUNT_ID = 1234;
|
|
|
|
FriendInfoFacebook friendInfoFacebook;
|
|
friendInfoFacebook.m_accountId = ACCOUNT_ID;
|
|
EXPECT_EQ(ACCOUNT_ID, friendInfoFacebook.m_accountId);
|
|
|
|
const String username("username");
|
|
friendInfoFacebook.m_username = username;
|
|
EXPECT_EQ(username, friendInfoFacebook.m_username);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_FriendInfoClub)
|
|
{
|
|
const String userId("11112222-3333-4444-5555-2eacc1c5faaa");
|
|
const String username("username");
|
|
|
|
ProfileInfo profileInfo;
|
|
{
|
|
profileInfo.m_idOnPlatform = userId;
|
|
profileInfo.m_profileId = ProfileId(userId);
|
|
profileInfo.m_userId = UserId(userId);
|
|
profileInfo.m_nameOnPlatform = username;
|
|
}
|
|
|
|
FriendInfoClub friendInfoClub;
|
|
friendInfoClub.m_profileInfo = profileInfo;
|
|
EXPECT_EQ(profileInfo, friendInfoClub.m_profileInfo);
|
|
|
|
const FriendInfoClub::Relationship TYPE = FriendInfoClub::PendingSentInvite;
|
|
friendInfoClub.m_relation = TYPE;
|
|
EXPECT_EQ(TYPE, friendInfoClub.m_relation);
|
|
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_ProfileInfo)
|
|
{
|
|
ProfileInfo profileInfo;
|
|
|
|
const ProfileId profileId("66667777-3333-4444-5555-2eacc1c5faaa");
|
|
profileInfo.m_profileId = profileId;
|
|
EXPECT_EQ(profileId, profileInfo.m_profileId);
|
|
|
|
const UserId userId("11112222-3333-4444-5555-2eacc1c5faaa");
|
|
profileInfo.m_userId = UserId(userId);
|
|
EXPECT_EQ(userId, profileInfo.m_userId.value());
|
|
|
|
const String profileType("profile");
|
|
profileInfo.m_profileType = profileType;
|
|
EXPECT_EQ(profileType, profileInfo.m_profileType);
|
|
|
|
const String idOnPlatform("idOnplatform");
|
|
profileInfo.m_idOnPlatform = idOnPlatform;
|
|
EXPECT_EQ(idOnPlatform, profileInfo.m_idOnPlatform);
|
|
|
|
const String nameOnPlatform("nameOnPlatform");
|
|
profileInfo.m_nameOnPlatform = nameOnPlatform;
|
|
EXPECT_EQ(nameOnPlatform, profileInfo.m_nameOnPlatform);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_ProfileInfoExternal)
|
|
{
|
|
ProfileInfoExternal profileInfoExternal;
|
|
|
|
const Date dateOfBirth(1980, 12, 12);
|
|
profileInfoExternal.m_dateOfBirth = dateOfBirth;
|
|
EXPECT_EQ(dateOfBirth, profileInfoExternal.m_dateOfBirth);
|
|
|
|
const String email("UBMN-UbiServiceTest03@xboxtest.com");
|
|
profileInfoExternal.m_email = email;
|
|
EXPECT_EQ(email, profileInfoExternal.m_email);
|
|
|
|
const String country("US");
|
|
profileInfoExternal.m_country = country;
|
|
EXPECT_EQ(country, profileInfoExternal.m_country);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_UnitInfo)
|
|
{
|
|
UnitInfo unit;
|
|
|
|
const String id("id");
|
|
unit.m_id = id;
|
|
EXPECT_EQ(id, unit.m_id);
|
|
|
|
const String name("name");
|
|
unit.m_name = name;
|
|
EXPECT_EQ(name, unit.m_name);
|
|
|
|
{
|
|
const String description("description");
|
|
unit.m_description = description;
|
|
EXPECT_EQ(description, unit.m_description);
|
|
}
|
|
|
|
const uint32 VALUE = 1;
|
|
unit.m_value = VALUE;
|
|
EXPECT_EQ(VALUE, unit.m_value);
|
|
|
|
const uint32 XP = 40;
|
|
unit.m_xp = XP;
|
|
EXPECT_EQ(XP, unit.m_xp);
|
|
|
|
const bool isCompleted = true;
|
|
unit.m_isCompleted = isCompleted;
|
|
EXPECT_EQ(isCompleted, unit.m_isCompleted);
|
|
|
|
EXPECT_FALSE(unit.m_activationDate.isSpecified());
|
|
DateTime activationDate = ServerTimeHelper::getServerTime();
|
|
unit.m_activationDate = activationDate;
|
|
EXPECT_EQ(activationDate, unit.m_activationDate.value());
|
|
EXPECT_TRUE(unit.m_activationDate.isSpecified());
|
|
|
|
EXPECT_FALSE(unit.m_completionDate.isSpecified());
|
|
DateTime completionDate = ServerTimeHelper::getServerTime();
|
|
unit.m_completionDate = completionDate;
|
|
EXPECT_EQ(completionDate, unit.m_completionDate.value());
|
|
EXPECT_TRUE(unit.m_completionDate.isSpecified());
|
|
|
|
unit.m_images = { TestPublicAttributesForClub_BF::createClubImageInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::IMAGE_INFO_URL, unit.m_images.front().m_url);
|
|
|
|
unit.m_groups = { TestPublicAttributesForClub_BF::createClubGroupInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::GROUP_INFO_ID, unit.m_groups.front().m_id);
|
|
|
|
unit.m_requiredForActions = { TestPublicAttributesForClub_BF::createClubRequirementInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::REQUIREMENT_INFO_ID, unit.m_requiredForActions.front().m_id);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_XpInfo)
|
|
{
|
|
XpInfo xp;
|
|
|
|
const String id("id");
|
|
xp.m_id = id;
|
|
EXPECT_EQ(id, xp.m_id);
|
|
|
|
const String name("name");
|
|
xp.m_name = name;
|
|
EXPECT_EQ(name, xp.m_name);
|
|
|
|
{
|
|
const String description("description");
|
|
xp.m_description = description;
|
|
EXPECT_EQ(description, xp.m_description);
|
|
}
|
|
|
|
const uint32 XP = 40;
|
|
xp.m_xp = XP;
|
|
EXPECT_EQ(XP, xp.m_xp);
|
|
|
|
const bool isCompleted = true;
|
|
xp.m_isCompleted = isCompleted;
|
|
EXPECT_EQ(isCompleted, xp.m_isCompleted);
|
|
|
|
EXPECT_FALSE(xp.m_activationDate.isSpecified());
|
|
DateTime activationDate = ServerTimeHelper::getServerTime();
|
|
xp.m_activationDate = activationDate;
|
|
EXPECT_EQ(activationDate, xp.m_activationDate.value());
|
|
EXPECT_TRUE(xp.m_activationDate.isSpecified());
|
|
|
|
EXPECT_FALSE(xp.m_completionDate.isSpecified());
|
|
DateTime completionDate = ServerTimeHelper::getServerTime();
|
|
xp.m_completionDate = completionDate;
|
|
EXPECT_EQ(completionDate, xp.m_completionDate.value());
|
|
EXPECT_TRUE(xp.m_completionDate.isSpecified());
|
|
|
|
{
|
|
xp.m_images = { TestPublicAttributesForClub_BF::createClubImageInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::IMAGE_INFO_URL, xp.m_images.front().m_url);
|
|
}
|
|
|
|
{
|
|
xp.m_groups = { TestPublicAttributesForClub_BF::createClubGroupInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::GROUP_INFO_ID, xp.m_groups.front().m_id);
|
|
}
|
|
|
|
{
|
|
xp.m_requiredForActions = { TestPublicAttributesForClub_BF::createClubRequirementInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::REQUIREMENT_INFO_ID, xp.m_requiredForActions.front().m_id);
|
|
}
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_ConditionInfo)
|
|
{
|
|
ConditionInfo conditionInfo;
|
|
|
|
const String id("id");
|
|
conditionInfo.m_id = id;
|
|
EXPECT_EQ(id, conditionInfo.m_id);
|
|
|
|
const String name("name");
|
|
conditionInfo.m_name = name;
|
|
EXPECT_EQ(name, conditionInfo.m_name);
|
|
|
|
{
|
|
const String description("description");
|
|
conditionInfo.m_description = description;
|
|
EXPECT_EQ(description, conditionInfo.m_description);
|
|
}
|
|
|
|
const bool isCompleted = true;
|
|
conditionInfo.m_isCompleted = isCompleted;
|
|
EXPECT_EQ(isCompleted, conditionInfo.m_isCompleted);
|
|
|
|
EXPECT_FALSE(conditionInfo.m_activationDate.isSpecified());
|
|
DateTime activationDate = ServerTimeHelper::getServerTime();
|
|
conditionInfo.m_activationDate = activationDate;
|
|
EXPECT_EQ(activationDate, conditionInfo.m_activationDate.value());
|
|
EXPECT_TRUE(conditionInfo.m_activationDate.isSpecified());
|
|
|
|
EXPECT_FALSE(conditionInfo.m_completionDate.isSpecified());
|
|
DateTime completionDate = ServerTimeHelper::getServerTime();
|
|
conditionInfo.m_completionDate = completionDate;
|
|
EXPECT_EQ(completionDate, conditionInfo.m_completionDate.value());
|
|
EXPECT_TRUE(conditionInfo.m_completionDate.isSpecified());
|
|
|
|
{
|
|
conditionInfo.m_images = { TestPublicAttributesForClub_BF::createClubImageInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::IMAGE_INFO_URL, conditionInfo.m_images.front().m_url);
|
|
}
|
|
|
|
{
|
|
conditionInfo.m_groups = { TestPublicAttributesForClub_BF::createClubGroupInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::GROUP_INFO_ID, conditionInfo.m_groups.front().m_id);
|
|
}
|
|
|
|
{
|
|
conditionInfo.m_requiredForActions = { TestPublicAttributesForClub_BF::createClubRequirementInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::REQUIREMENT_INFO_ID, conditionInfo.m_requiredForActions.front().m_id);
|
|
}
|
|
|
|
{
|
|
conditionInfo.m_requiredForRewards = { TestPublicAttributesForClub_BF::createClubRequirementInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::REQUIREMENT_INFO_ID, conditionInfo.m_requiredForRewards.front().m_id);
|
|
}
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_BadgeInfo)
|
|
{
|
|
BadgeInfo badgeInfo;
|
|
|
|
const String id("id");
|
|
badgeInfo.m_id = id;
|
|
EXPECT_EQ(id, badgeInfo.m_id);
|
|
|
|
const String name("name");
|
|
badgeInfo.m_name = name;
|
|
EXPECT_EQ(name, badgeInfo.m_name);
|
|
|
|
{
|
|
const String description("description");
|
|
badgeInfo.m_description = description;
|
|
EXPECT_EQ(description, badgeInfo.m_description);
|
|
}
|
|
|
|
const bool isCompleted = true;
|
|
badgeInfo.m_isCompleted = isCompleted;
|
|
EXPECT_EQ(isCompleted, badgeInfo.m_isCompleted);
|
|
|
|
EXPECT_FALSE(badgeInfo.m_activationDate.isSpecified());
|
|
DateTime activationDate = ServerTimeHelper::getServerTime();
|
|
badgeInfo.m_activationDate = activationDate;
|
|
EXPECT_EQ(activationDate, badgeInfo.m_activationDate.value());
|
|
EXPECT_TRUE(badgeInfo.m_activationDate.isSpecified());
|
|
|
|
EXPECT_FALSE(badgeInfo.m_completionDate.isSpecified());
|
|
DateTime completionDate = ServerTimeHelper::getServerTime();
|
|
badgeInfo.m_completionDate = completionDate;
|
|
EXPECT_EQ(completionDate, badgeInfo.m_completionDate.value());
|
|
EXPECT_TRUE(badgeInfo.m_completionDate.isSpecified());
|
|
|
|
{
|
|
badgeInfo.m_images = { TestPublicAttributesForClub_BF::createClubImageInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::IMAGE_INFO_URL, badgeInfo.m_images.front().m_url);
|
|
}
|
|
|
|
{
|
|
badgeInfo.m_groups = { TestPublicAttributesForClub_BF::createClubGroupInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::GROUP_INFO_ID, badgeInfo.m_groups.front().m_id);
|
|
}
|
|
|
|
{
|
|
badgeInfo.m_requiredForRewards = { TestPublicAttributesForClub_BF::createClubRequirementInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::REQUIREMENT_INFO_ID, badgeInfo.m_requiredForRewards.front().m_id);
|
|
}
|
|
|
|
{
|
|
ActionRequirement actionRequirement;
|
|
actionRequirement.m_isAccomplished = true;
|
|
EXPECT_TRUE(actionRequirement.m_isAccomplished);
|
|
|
|
actionRequirement.m_requirement = TestPublicAttributesForClub_BF::createClubRequirementInfo();
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::REQUIREMENT_INFO_ID, actionRequirement.m_requirement.m_id);
|
|
|
|
RequiredActionsInfo requiredActionsInfo;
|
|
requiredActionsInfo.m_isAccomplished = true;
|
|
EXPECT_TRUE(requiredActionsInfo.m_isAccomplished);
|
|
|
|
requiredActionsInfo.m_requirements = { actionRequirement };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::REQUIREMENT_INFO_ID, requiredActionsInfo.m_requirements.front().m_requirement.m_id);
|
|
|
|
badgeInfo.m_requiredActions = requiredActionsInfo;
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::REQUIREMENT_INFO_ID, badgeInfo.m_requiredActions.m_requirements.front().m_requirement.m_id);
|
|
}
|
|
|
|
{
|
|
RequiredRewardsInfo requiredRewardsInfo;
|
|
requiredRewardsInfo.m_isAccomplished = true;
|
|
EXPECT_TRUE(requiredRewardsInfo.m_isAccomplished);
|
|
|
|
requiredRewardsInfo.m_requirements = { TestPublicAttributesForClub_BF::createClubRequirementInfo() };
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::REQUIREMENT_INFO_ID, requiredRewardsInfo.m_requirements.front().m_id);
|
|
|
|
badgeInfo.m_requiredRewards = requiredRewardsInfo;
|
|
EXPECT_EQ(TestPublicAttributesForClub_BF::REQUIREMENT_INFO_ID, badgeInfo.m_requiredRewards.m_requirements.front().m_id);
|
|
}
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_RewardInfo)
|
|
{
|
|
RewardInfo rewardInfo;
|
|
|
|
const String id("id");
|
|
rewardInfo.m_id = id;
|
|
EXPECT_EQ(id, rewardInfo.m_id);
|
|
|
|
const String name("name");
|
|
rewardInfo.m_name = name;
|
|
EXPECT_EQ(name, rewardInfo.m_name);
|
|
|
|
const String description("description");
|
|
rewardInfo.m_description = description;
|
|
EXPECT_EQ(description, rewardInfo.m_description);
|
|
|
|
const uint32 VALUE = 1;
|
|
rewardInfo.m_value = VALUE;
|
|
EXPECT_EQ(VALUE, rewardInfo.m_value);
|
|
|
|
const bool isPurchased = true;
|
|
rewardInfo.m_isPurchased = isPurchased;
|
|
EXPECT_EQ(isPurchased, rewardInfo.m_isPurchased);
|
|
|
|
const RewardInfo::Type TYPE = RewardInfo::Downloadable;
|
|
rewardInfo.m_type = TYPE;
|
|
EXPECT_EQ(TYPE, rewardInfo.m_type);
|
|
|
|
const String path("path");
|
|
rewardInfo.m_path = path;
|
|
EXPECT_EQ(path, rewardInfo.m_path);
|
|
|
|
{
|
|
ClubImageInfo imageInfo;
|
|
|
|
const String description2("imageDescription");
|
|
imageInfo.m_desc = description2;
|
|
EXPECT_EQ(description2, imageInfo.m_desc);
|
|
|
|
const String url("dummyUrl");
|
|
imageInfo.m_url = url;
|
|
EXPECT_EQ(url, imageInfo.m_url);
|
|
|
|
rewardInfo.m_images = { imageInfo };
|
|
EXPECT_EQ(url, rewardInfo.m_images.front().m_url);
|
|
}
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_UserClientLegalOptIns)
|
|
{
|
|
LegalOptIns legalOptins;
|
|
|
|
const LegalOptInsKey optInsKey("CA", "EN", "11112222-3333-4444-5555-2eacc1c5faaa");
|
|
legalOptins.m_key = optInsKey;
|
|
EXPECT_EQ(optInsKey.m_value, legalOptins.m_key.m_value);
|
|
EXPECT_EQ(optInsKey.m_country, legalOptins.m_key.m_country);
|
|
EXPECT_EQ(optInsKey.m_language, legalOptins.m_key.m_language);
|
|
|
|
const uint32 requiredAge = 12345u;
|
|
legalOptins.m_requiredAge = requiredAge;
|
|
EXPECT_EQ(requiredAge, legalOptins.m_requiredAge);
|
|
|
|
const bool communicationOptInDefaultValue = true;
|
|
legalOptins.m_communicationOptInDefaultValue = communicationOptInDefaultValue;
|
|
EXPECT_EQ(communicationOptInDefaultValue, legalOptins.m_communicationOptInDefaultValue);
|
|
|
|
const String privacyPolicyContent("dummy string");
|
|
legalOptins.m_privacyPolicyContent = privacyPolicyContent;
|
|
EXPECT_EQ(privacyPolicyContent, legalOptins.m_privacyPolicyContent);
|
|
|
|
const String privacyPolicyAcceptance("dummy string");
|
|
legalOptins.m_policyAcceptance = privacyPolicyAcceptance;
|
|
EXPECT_EQ(privacyPolicyAcceptance, legalOptins.m_policyAcceptance);
|
|
|
|
const bool privacyPolicyAcceptanceDefaultValue = true;
|
|
legalOptins.m_policyAcceptanceDefaultValue = privacyPolicyAcceptanceDefaultValue;
|
|
EXPECT_EQ(privacyPolicyAcceptanceDefaultValue, legalOptins.m_policyAcceptanceDefaultValue);
|
|
|
|
const bool isPrivacyPolicyAcceptanceRequired = true;
|
|
legalOptins.m_isPolicyAcceptanceRequired = isPrivacyPolicyAcceptanceRequired;
|
|
EXPECT_EQ(isPrivacyPolicyAcceptanceRequired, legalOptins.m_isPolicyAcceptanceRequired);
|
|
|
|
const String termOfUseContent("dummy string");
|
|
legalOptins.m_termsOfUseContent = termOfUseContent;
|
|
EXPECT_EQ(termOfUseContent, legalOptins.m_termsOfUseContent);
|
|
|
|
const String termOfSalesContent("dummy string");
|
|
legalOptins.m_termsOfSaleContent = termOfSalesContent;
|
|
EXPECT_EQ(termOfUseContent, legalOptins.m_termsOfSaleContent);
|
|
|
|
const String locale("XX-XX");
|
|
legalOptins.m_locale = locale;
|
|
EXPECT_EQ(locale, legalOptins.m_locale);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_UserInfoError)
|
|
{
|
|
UserInfoError userInfoError;
|
|
|
|
const String field("dummy string");
|
|
userInfoError.m_field = field;
|
|
EXPECT_EQ(field, userInfoError.m_field);
|
|
|
|
const UserInfoErrorCode errorCode = UserInfoErrorCode::MissingParameter;
|
|
userInfoError.m_errorCode = errorCode;
|
|
EXPECT_EQ(errorCode, userInfoError.m_errorCode);
|
|
|
|
const String message("dummy string");
|
|
userInfoError.m_message = message;
|
|
EXPECT_EQ(message, userInfoError.m_message);
|
|
|
|
const String valueSuggestion("dummy string");
|
|
userInfoError.m_valueSuggestion = valueSuggestion;
|
|
EXPECT_EQ(valueSuggestion, userInfoError.m_valueSuggestion);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_UserInfoCreation)
|
|
{
|
|
const String textValue("DummyString");
|
|
const Date birthDate(1982, 2, 20);
|
|
|
|
UserInfoCreation userInfo;
|
|
{
|
|
userInfo.m_nameOnPlatform = textValue;
|
|
userInfo.m_password = textValue;
|
|
userInfo.m_email = textValue;
|
|
userInfo.m_dateOfBirth = birthDate;
|
|
userInfo.m_firstName = textValue;
|
|
userInfo.m_lastName = textValue;
|
|
userInfo.m_gender = UserGender::Male;
|
|
}
|
|
|
|
EXPECT_EQ(textValue, userInfo.m_nameOnPlatform);
|
|
EXPECT_EQ(textValue, userInfo.m_password);
|
|
EXPECT_EQ(textValue, userInfo.m_email);
|
|
EXPECT_EQ(birthDate, userInfo.m_dateOfBirth);
|
|
EXPECT_EQ(textValue, userInfo.m_firstName);
|
|
EXPECT_EQ(textValue, userInfo.m_lastName);
|
|
EXPECT_EQ(userInfo.m_gender, UserGender::Male);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_UserInfo)
|
|
{
|
|
UserInfo userInfo;
|
|
|
|
const UserId userId("88889999-3333-4444-5555-2eacc1c5faaa");
|
|
userInfo.m_userId = userId;
|
|
EXPECT_EQ(userId, userInfo.m_userId);
|
|
|
|
ProfileInfo profileInfo;
|
|
profileInfo.m_profileType = "profile";
|
|
userInfo.m_linkedProfiles = { profileInfo };
|
|
EXPECT_EQ(profileInfo.m_profileType, userInfo.m_linkedProfiles.front().m_profileType);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_CredentialsExternalToken)
|
|
{
|
|
const CredentialsType TYPE = CredentialsType::Facebook;
|
|
const String tokenValue("DummyToken");
|
|
|
|
const CredentialsExternalToken token(tokenValue, TYPE);
|
|
|
|
EXPECT_EQ(TYPE, token.m_credentialsType);
|
|
EXPECT_EQ(tokenValue, token.m_token);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_ResultRange)
|
|
{
|
|
ResultRange resultRange;
|
|
|
|
const uint32 OFFSET = 1;
|
|
resultRange.m_offset = OFFSET;
|
|
EXPECT_EQ(OFFSET, resultRange.m_offset);
|
|
|
|
const uint32 LIMIT = 2;
|
|
resultRange.m_limit = LIMIT;
|
|
EXPECT_EQ(LIMIT, resultRange.m_limit);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_ErrorDetails)
|
|
{
|
|
ErrorDetails errorDetails;
|
|
|
|
const uint32 CODE = 1;
|
|
errorDetails.m_code = CODE;
|
|
EXPECT_EQ(CODE, errorDetails.m_code);
|
|
|
|
const String description("dummy");
|
|
errorDetails.m_description = description;
|
|
EXPECT_EQ(description, errorDetails.m_description);
|
|
|
|
#if !defined(US_RETAIL)
|
|
const char* const filename = "dummy";
|
|
errorDetails.m_filename = filename;
|
|
EXPECT_STREQ(filename, errorDetails.m_filename);
|
|
#endif
|
|
|
|
const uint32 LINE_NUMBER = __LINE__;
|
|
errorDetails.m_lineNumber = LINE_NUMBER;
|
|
EXPECT_EQ(LINE_NUMBER, errorDetails.m_lineNumber);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_HttpConfig)
|
|
{
|
|
const String host("DummyHost");
|
|
const uint32 PORT = 1234;
|
|
const String username("DummyUsername");
|
|
const String password("DummyPassword");
|
|
|
|
HttpConfig httpConfig;
|
|
httpConfig.m_proxy = HttpProxyConfig(host, PORT, username, password);
|
|
|
|
EXPECT_EQ(host, httpConfig.m_proxy.m_host);
|
|
EXPECT_EQ(PORT, httpConfig.m_proxy.m_port);
|
|
EXPECT_EQ(username, httpConfig.m_proxy.m_username);
|
|
EXPECT_EQ(password, httpConfig.m_proxy.m_password);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_GuidBinary)
|
|
{
|
|
GuidBinary guidBinary;
|
|
const uint32 part1 = 0x11111111;
|
|
guidBinary.m_data1 = part1;
|
|
EXPECT_EQ(part1, guidBinary.m_data1);
|
|
|
|
const uint16 part2 = 0x2222;
|
|
guidBinary.m_data2 = part2;
|
|
EXPECT_EQ(part2, guidBinary.m_data2);
|
|
|
|
const uint16 part3 = 0x3333;
|
|
guidBinary.m_data3 = part3;
|
|
EXPECT_EQ(part3, guidBinary.m_data3);
|
|
|
|
const uint16 part4_0 = 0x4444;
|
|
guidBinary.m_data4[0] = part4_0;
|
|
EXPECT_EQ(part4_0, guidBinary.m_data4[0]);
|
|
|
|
const uint16 part4_1 = 0x5555;
|
|
guidBinary.m_data4[1] = part4_1;
|
|
EXPECT_EQ(part4_1, guidBinary.m_data4[1]);
|
|
|
|
const uint16 part4_2 = 0x6666;
|
|
guidBinary.m_data4[2] = part4_2;
|
|
EXPECT_EQ(part4_2, guidBinary.m_data4[2]);
|
|
|
|
const uint16 part4_3 = 0x7777;
|
|
guidBinary.m_data4[3] = part4_3;
|
|
EXPECT_EQ(part4_3, guidBinary.m_data4[3]);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_WEBSOCKETBUFFER)
|
|
{
|
|
uint8 data[4] = {1,2,3,4};
|
|
WebSocketBuffer socketBuffer(data, sizeof(data));
|
|
|
|
EXPECT_EQ(WebSocketFrame::Binary, socketBuffer.getDataFrame());
|
|
EXPECT_EQ(4u, socketBuffer.getSize());
|
|
//Doesn't compile on PS3
|
|
//EXPECT_EQ(data, socketBuffer.getData());
|
|
|
|
String text("DummyString");
|
|
TextBuffer textBuffer(text);
|
|
|
|
EXPECT_EQ(text.getLength(), textBuffer.getSize());
|
|
EXPECT_EQ(WebSocketFrame::Text, textBuffer.getDataFrame());
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_WebsocketConfig)
|
|
{
|
|
WebSocketConfiguration config;
|
|
uint32 messageSize = 50;
|
|
config.m_maxMessageSize = messageSize;
|
|
|
|
const Vector<String> protocols = { "DummyProtocol1", "DummyProtocol2", "DummyProtocol3" };
|
|
config.m_supportedProtocol = protocols;
|
|
|
|
const Vector<String> extensions = { "DummyExtension1", "DummyExtension2", "DummyExtension3" };
|
|
config.m_supportedExtensions = extensions;
|
|
|
|
EXPECT_EQ(8u*1024u, config.m_sizeOutboundBufferBytesSize);
|
|
EXPECT_EQ(13u, config.m_version);
|
|
EXPECT_EQ(messageSize, config.m_maxMessageSize);
|
|
EXPECT_EQ(3u, config.m_supportedProtocol.size());
|
|
EXPECT_EQ(3u, config.m_supportedExtensions.size());
|
|
EXPECT_EQ(protocols, config.m_supportedProtocol);
|
|
EXPECT_EQ(extensions, config.m_supportedExtensions);
|
|
}
|
|
|
|
TEST_F(PUBLIC_ATTRIBUTES, LOCAL_WebSocketInformation)
|
|
{
|
|
const StringUrl url("DummyUrl");
|
|
const String subProtocol("DummySubProtocol");
|
|
|
|
WebSocketInformation info;
|
|
info.m_url = url;
|
|
info.m_subProtocol = subProtocol;
|
|
|
|
EXPECT_EQ(url, info.m_url);
|
|
EXPECT_EQ(subProtocol, info.m_subProtocol);
|
|
}
|
|
};
|