1495 lines
66 KiB
C++
1495 lines
66 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
// (c) Copyright, Ubisoft Entertainment Inc. || Created by Harbour //
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
#include "tests/config.h"
|
|
#include "tests/fixture/authenticationFixture.h"
|
|
#include "tests/fixture/loginMockFixture.h"
|
|
#include "tests/mock/mockLogDevice.h"
|
|
#include "tests/mock/mockResultHelper.h"
|
|
#include "tests/mock/parametersMockHelper.h"
|
|
#include <ubiservices/core/errors/errorCodes.h>
|
|
#include <../private/ubiservices/core/http/httpEntity.h>
|
|
#include <../private/ubiservices/services/cacheManager.h>
|
|
#include <../private/ubiservices/services/parameters/parametersClientProxy.h>
|
|
#include <../private/ubiservices/services/news/newsProxy.h>
|
|
#include <ubiservices/facade.h>
|
|
#include <ubiservices/localizationHelper.h>
|
|
#include <ubiservices/services/http/request/httpGet.h>
|
|
#include <ubiservices/services/http/request/httpPost.h>
|
|
#include <ubiservices/services/news/newsClient.h>
|
|
#include <ubiservices/services/news/newsInfo.h>
|
|
#include <ubiservices/services/parameters/parametersClient.h>
|
|
|
|
#define DUMMY_PROFILE_ID DUMMY_GUID_ID1
|
|
|
|
namespace US_NS {;
|
|
US_DEFINE_TEST(TestNews);
|
|
|
|
typedef AuthenticationFixture<1> NEWS;
|
|
typedef LoginMockFixture<true> NEWS_MOCK;
|
|
typedef LoginMockFixtureNoInit NEWS_MOCK_NOINIT;
|
|
|
|
namespace TestNews_BF
|
|
{
|
|
#if !defined(US_DLL)
|
|
static ::testing::AssertionResult checkResultingNews(const Vector<NewsInfo>& news)
|
|
{
|
|
if (news.size() != 6)
|
|
{
|
|
return ::testing::AssertionFailure() << "There shall be 6 news in the result list";
|
|
}
|
|
else if ((news.front().m_links.size() != 2) || (news.back().m_links.size() != 2))
|
|
{
|
|
return ::testing::AssertionFailure() << "There shall be 2 links for each news";
|
|
}
|
|
|
|
return ::testing::AssertionSuccess();
|
|
}
|
|
#endif
|
|
|
|
String createMockResult()
|
|
{
|
|
return "{"
|
|
"\"news\":"
|
|
"["
|
|
"{"
|
|
"\"profileId\":\"" DUMMY_PROFILE_ID "\","
|
|
"\"spaceId\":\"3a441107-673a-40b7-a304-0cd5fcb7ee9b\","
|
|
"\"newsId\":\"neolane.AC4_DLC_01\","
|
|
"\"type\":\"DLCOffer\","
|
|
"\"placement\":\"mainMenu1\","
|
|
"\"priority\":1,"
|
|
"\"displayTime\":20,"
|
|
"\"publicationDate\":\"2014-11-11 12:00:00Z\","
|
|
"\"locale\":\"en-US\","
|
|
"\"title\":\"New DLC Released\","
|
|
"\"body\":\"Get the Season Pass DLC from the Marketplace\","
|
|
"\"mediaURL\":\"http://static8.ubisoft.com/234224/asset34.png\","
|
|
"\"mediaType\":\"image/png\","
|
|
"\"links\":"
|
|
"["
|
|
"{"
|
|
"\"type\":\"pstore\","
|
|
"\"param\":\"0x555308796ea1e800\","
|
|
"\"actionName\":\"OpenedTheStoreForSeasonPass\","
|
|
"\"actionDescription\":\"Buy the Season Pass\""
|
|
"},"
|
|
"{"
|
|
"\"type\":\"web\","
|
|
"\"param\":\"http://acu.ubisoft.com/dlc1/description.html\","
|
|
"\"actionName\":\"MoreInfoOnSeasonPass\","
|
|
"\"actionDescription\":\"More info...\""
|
|
"}"
|
|
"],"
|
|
"\"obj\":{\"assetId\":13}"
|
|
"},"
|
|
"{"
|
|
"\"profileId\":\"" DUMMY_PROFILE_ID "\","
|
|
"\"spaceId\":\"3a441107-673a-40b7-a304-0cd5fcb7ee9b\","
|
|
"\"newsId\":\"neolane.AC4_DLC_02\","
|
|
"\"type\":\"DLCOffer\","
|
|
"\"placement\":\"mainMenu1\","
|
|
"\"priority\":2,"
|
|
"\"displayTime\":10,"
|
|
"\"publicationDate\":\"2014-11-11 13:00:00Z\","
|
|
"\"locale\":\"en-US\","
|
|
"\"title\":\"New DLC Released\","
|
|
"\"body\":\"Get the Season Pass DLC from the Marketplace\","
|
|
"\"mediaURL\":\"http://static8.ubisoft.com/234224/asset34.png\","
|
|
"\"mediaType\":\"image/png\","
|
|
"\"links\":"
|
|
"["
|
|
"{"
|
|
"\"type\":\"pstore\","
|
|
"\"param\":\"0x555308796ea1e800\","
|
|
"\"actionName\":\"OpenedTheStoreForSeasonPass\","
|
|
"\"actionDescription\":\"Buy the Season Pass\""
|
|
"},"
|
|
"{"
|
|
"\"type\":\"web\","
|
|
"\"param\":\"http://acu.ubisoft.com/dlc1/description.html\","
|
|
"\"actionName\":\"MoreInfoOnSeasonPass\","
|
|
"\"actionDescription\":\"More info...\""
|
|
"}"
|
|
"],"
|
|
"\"obj\":{\"assetId\":13}"
|
|
"},"
|
|
"{"
|
|
"\"profileId\":\"" DUMMY_PROFILE_ID "\","
|
|
"\"spaceId\":\"3a441107-673a-40b7-a304-0cd5fcb7ee9b\","
|
|
"\"newsId\":\"neolane.AC4_DLC_03\","
|
|
"\"type\":\"DLCOffer\","
|
|
"\"placement\":\"mainMenu2\","
|
|
"\"priority\":1,"
|
|
"\"displayTime\":15,"
|
|
"\"publicationDate\":\"2014-11-11 14:00:00Z\","
|
|
"\"locale\":\"en-US\","
|
|
"\"title\":\"New DLC Released\","
|
|
"\"body\":\"Get the Season Pass DLC from the Marketplace\","
|
|
"\"mediaURL\":\"http://static8.ubisoft.com/234224/asset34.png\","
|
|
"\"mediaType\":\"image/png\","
|
|
"\"links\":"
|
|
"["
|
|
"{"
|
|
"\"type\":\"pstore\","
|
|
"\"param\":\"0x555308796ea1e800\","
|
|
"\"actionName\":\"OpenedTheStoreForSeasonPass\","
|
|
"\"actionDescription\":\"Buy the Season Pass\""
|
|
"},"
|
|
"{"
|
|
"\"type\":\"web\","
|
|
"\"param\":\"http://acu.ubisoft.com/dlc1/description.html\","
|
|
"\"actionName\":\"MoreInfoOnSeasonPass\","
|
|
"\"actionDescription\":\"More info...\""
|
|
"}"
|
|
"],"
|
|
"\"obj\":{\"assetId\":13}"
|
|
"},"
|
|
"{"
|
|
"\"profileId\":\"" DUMMY_PROFILE_ID "\","
|
|
"\"spaceId\":\"3a441107-673a-40b7-a304-0cd5fcb7ee9b\","
|
|
"\"newsId\":\"neolane.AC4_DLC_04\","
|
|
"\"type\":\"DLCOffer\","
|
|
"\"placement\":\"mainMenu2\","
|
|
"\"priority\":2,"
|
|
"\"displayTime\":5,"
|
|
"\"publicationDate\":\"2014-11-11 15:00:00Z\","
|
|
"\"locale\":\"en-US\","
|
|
"\"title\":\"New DLC Released\","
|
|
"\"body\":\"Get the Season Pass DLC from the Marketplace\","
|
|
"\"mediaURL\":\"http://static8.ubisoft.com/234224/asset34.png\","
|
|
"\"mediaType\":\"image/png\","
|
|
"\"links\":"
|
|
"["
|
|
"{"
|
|
"\"type\":\"pstore\","
|
|
"\"param\":\"0x555308796ea1e800\","
|
|
"\"actionName\":\"OpenedTheStoreForSeasonPass\","
|
|
"\"actionDescription\":\"Buy the Season Pass\""
|
|
"},"
|
|
"{"
|
|
"\"type\":\"web\","
|
|
"\"param\":\"http://acu.ubisoft.com/dlc1/description.html\","
|
|
"\"actionName\":\"MoreInfoOnSeasonPass\","
|
|
"\"actionDescription\":\"More info...\""
|
|
"}"
|
|
"],"
|
|
"\"obj\":{\"assetId\":13}"
|
|
"},"
|
|
"{"
|
|
"\"profileId\":\"" DUMMY_PROFILE_ID "\","
|
|
"\"spaceId\":\"3a441107-673a-40b7-a304-0cd5fcb7ee9b\","
|
|
"\"newsId\":\"neolane2.AC4_DLC_05\","
|
|
"\"type\":\"DLCOffer\","
|
|
"\"placement\":\"mainMenu3\","
|
|
"\"priority\":1,"
|
|
"\"displayTime\":30,"
|
|
"\"publicationDate\":\"2014-11-22 16:00:00Z\","
|
|
"\"locale\":\"en-US\","
|
|
"\"title\":\"New DLC Released\","
|
|
"\"body\":\"Get the Season Pass DLC from the Marketplace\","
|
|
"\"mediaURL\":\"http://static8.ubisoft.com/234224/asset34.png\","
|
|
"\"mediaType\":\"image/png\","
|
|
"\"links\":"
|
|
"["
|
|
"{"
|
|
"\"type\":\"pstore\","
|
|
"\"param\":\"0x555308796ea1e800\","
|
|
"\"actionName\":\"OpenedTheStoreForSeasonPass\","
|
|
"\"actionDescription\":\"Buy the Season Pass\""
|
|
"},"
|
|
"{"
|
|
"\"type\":\"web\","
|
|
"\"param\":\"http://acu.ubisoft.com/dlc1/description.html\","
|
|
"\"actionName\":\"MoreInfoOnSeasonPass\","
|
|
"\"actionDescription\":\"More info...\""
|
|
"}"
|
|
"],"
|
|
"\"obj\":{\"assetId\":13}"
|
|
"},"
|
|
"{"
|
|
"\"profileId\":\"" DUMMY_PROFILE_ID "\","
|
|
"\"spaceId\":\"3a441107-673a-40b7-a304-0cd5fcb7ee9b\","
|
|
"\"newsId\":\"neolane2.AC4_DLC_06\","
|
|
"\"type\":\"DLCOffer\","
|
|
"\"placement\":\"mainMenu3\","
|
|
"\"priority\":2,"
|
|
"\"displayTime\":35,"
|
|
"\"publicationDate\":\"2014-11-22 17:00:00Z\","
|
|
"\"locale\":\"en-US\","
|
|
"\"title\":\"New DLC Released\","
|
|
"\"body\":\"Get the Season Pass DLC from the Marketplace\","
|
|
"\"mediaURL\":\"http://static8.ubisoft.com/234224/asset34.png\","
|
|
"\"mediaType\":\"image/png\","
|
|
"\"links\":"
|
|
"["
|
|
"{"
|
|
"\"type\":\"pstore\","
|
|
"\"param\":\"0x555308796ea1e800\","
|
|
"\"actionName\":\"OpenedTheStoreForSeasonPass\","
|
|
"\"actionDescription\":\"Buy the Season Pass\""
|
|
"},"
|
|
"{"
|
|
"\"type\":\"sstore\","
|
|
"\"param\":\"0x555308796ea1e801\","
|
|
"\"actionName\":\"MoreInfoOnSeasonPass\","
|
|
"\"actionDescription\":\"More info...\""
|
|
"}"
|
|
"],"
|
|
"\"obj\":{\"assetId\":13}"
|
|
"}"
|
|
"]"
|
|
"}";
|
|
}
|
|
|
|
Map<int32, String> extractEventsFromRequest(const HttpPost& eventRequest)
|
|
{
|
|
const Json requestBodyJson(eventRequest.getBodyAsString());
|
|
const Vector<Json> eventsArray = requestBodyJson["events"].getValueArray();
|
|
|
|
Map<int32, String> events;
|
|
for (const auto& it : eventsArray)
|
|
{
|
|
events[it["seqId"].getValueInteger()] = it["type"].getValueString();
|
|
}
|
|
return events;
|
|
}
|
|
}
|
|
|
|
/// @test Requests news to the server, validating that the received content
|
|
/// matches with records provisioned (external requirement).
|
|
/// The following URL allows to configure news in UAT:
|
|
/// http://ingame-news-preview-backoffice.ubisoft.org/
|
|
#if (defined(US_TARGET_IOS) && !defined(US_UPLAY_LOGIN_FOR_IOS)) || defined(US_CHINA_SERVICE_UNAVAILABLE) // need the good url with rail id placeholder
|
|
TEST_F(NEWS, DISABLED_US_RequestNews) // News Services does not support Game Center tickets
|
|
#else
|
|
TEST_F(NEWS, US_MINRUN_RequestNews)
|
|
#endif
|
|
{
|
|
#if defined(ENABLING_VERBOSE_LOGGING)
|
|
LoggingHelper::enableVerbose();
|
|
LoggingHelper::enableMultiLines();
|
|
#endif
|
|
|
|
struct Local
|
|
{
|
|
static void validateInstance(const NewsInfo& info, const SpaceId& spaceId, bool checkProfile)
|
|
{
|
|
PRINT_STREAM(info);
|
|
EXPECT_TRUE(info.m_profileId.isValid() || !checkProfile);
|
|
//EXPECT_EQ(ProfileId("4d9061de-7c20-4cc9-9f55-b8d6228da6ae"), info.m_profileId);
|
|
EXPECT_EQ(spaceId, info.m_spaceId);
|
|
|
|
EXPECT_STREQ("Promo", info.m_type.getUtf8());
|
|
EXPECT_STREQ("MainMenu1", info.m_placement.getUtf8());
|
|
EXPECT_EQ(10u, info.m_priority);
|
|
EXPECT_EQ(30u, info.m_displayTime);
|
|
EXPECT_EQ(DateTime(2015, 4, 28, 13, 1, 0), info.m_publicationDate);
|
|
|
|
EXPECT_STREQ("en-US", info.m_locale.getUtf8());
|
|
EXPECT_STREQ("News Title #1", info.m_title.getUtf8());
|
|
EXPECT_STREQ("News Content #1", info.m_body.getUtf8());
|
|
|
|
EXPECT_STREQ("https://ingame-news-preview-backoffice.ubisoft.org/Content/IGN_STG_87x37.png", info.m_mediaUrl.getUtf8());
|
|
EXPECT_STREQ("Image", info.m_mediaType.getUtf8());
|
|
|
|
ASSERT_EQ(2u, info.m_links.size());
|
|
|
|
{
|
|
const NewsLink& link1 = info.m_links.front();
|
|
EXPECT_STREQ("weblink", link1.m_type.getUtf8());
|
|
EXPECT_STREQ("http://www.ubi.com", link1.m_param.getUtf8());
|
|
EXPECT_STREQ("", link1.m_actionName.getUtf8());
|
|
EXPECT_STREQ("", link1.m_actionDescription.getUtf8());
|
|
}
|
|
{
|
|
const NewsLink& link2 = info.m_links.back();
|
|
EXPECT_STREQ("weblink", link2.m_type.getUtf8());
|
|
EXPECT_STREQ("http://www.ubi.com/frca/", link2.m_param.getUtf8());
|
|
EXPECT_STREQ("", link2.m_actionName.getUtf8());
|
|
EXPECT_STREQ("", link2.m_actionDescription.getUtf8());
|
|
}
|
|
EXPECT_STREQ("{\"J\":5,\"0\":\"X\"}", info.m_object.getUtf8());
|
|
|
|
ASSERT_TRUE(info.m_summary.isSpecified());
|
|
EXPECT_STREQ("", info.m_summary.value().getUtf8());
|
|
|
|
EXPECT_EQ(0u, info.m_tags.size());
|
|
}
|
|
|
|
// ::testing::AssertionResult
|
|
// return ::testing::AssertionFailure() << "Request time out after " << NS_COMMON::DEFAULT_WAIT_TIME << " ms";
|
|
// ::testing::AssertionSuccess();
|
|
static ::testing::AssertionResult validateNews(const SpaceId& spaceId, const Vector<NewsInfo>& news, bool checkProfile)
|
|
{
|
|
bool isNewsFound = false;
|
|
for (const auto& it : news)
|
|
{
|
|
if (it.m_id == "ignt.63")
|
|
{
|
|
isNewsFound = true;
|
|
validateInstance(it, spaceId, checkProfile);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return isNewsFound
|
|
? ::testing::AssertionSuccess()
|
|
: ::testing::AssertionFailure() << "News not found among " << news.size() << " news in the list";
|
|
}
|
|
};
|
|
|
|
const SpaceId spaceId(US_TEST_NS::SPACE_ID_US_SDK_PC);
|
|
{
|
|
LocalizationHelper::setLocaleCode("en-US");
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > result = getFacade().getNewsClient().requestProfileNews(spaceId);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
EXPECT_TRUE(Local::validateNews(spaceId, result.getResult(), true));
|
|
}
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > result = getFacade().getNewsClient().requestSpaceNews(spaceId);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
EXPECT_TRUE(Local::validateNews(spaceId, result.getResult(), false)); //profile news points to the space news.
|
|
}
|
|
}
|
|
{
|
|
LocalizationHelper::setLocaleCode("fr-CA");
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > result = getFacade().getNewsClient().requestProfileNews(spaceId);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
EXPECT_FALSE(Local::validateNews(spaceId, result.getResult(), true));
|
|
}
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > result = getFacade().getNewsClient().requestSpaceNews(spaceId);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
EXPECT_FALSE(Local::validateNews(spaceId, result.getResult(), false)); //profile news points to the space news.
|
|
}
|
|
}
|
|
}
|
|
|
|
/// @test Requests news to the server for a space that has no news provisioned.
|
|
#if (defined(US_TARGET_IOS) && !defined(US_UPLAY_LOGIN_FOR_IOS)) || defined(US_CHINA_SERVICE_UNAVAILABLE) // return HTTP_403_FORBIDDEN
|
|
TEST_F(NEWS, DISABLED_US_RequestNewsNoNewsForSpaceId) // News Services does not support Game Center tickets
|
|
#else
|
|
TEST_F(NEWS, US_RequestNewsNoNewsForSpaceId)
|
|
#endif
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Status code: 404", LogLevel::Error, Times(1));
|
|
});
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(getFacade().getNewsClient()
|
|
.requestProfileNews(SpaceId("11111111-2222-3333-4444-555566667777")), Errors::HTTP_404_NOT_FOUND));
|
|
}
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Requests news with a successful response from server and a valid JSON
|
|
TEST_F(NEWS_MOCK, USNOT_RequestNewsProfile)
|
|
{
|
|
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false); // Avoids the request to get the country
|
|
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
|
|
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNews, MockResultHelper::createSuccessResult(TestNews_BF::createMockResult()));
|
|
|
|
const AsyncResult<Vector<NewsInfo> > newsResult = getFacade().getNewsClient().requestProfileNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult));
|
|
|
|
const Vector<NewsInfo>& news0 = newsResult.getResult();
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(news0)) << "News configuration is wrong";
|
|
|
|
{
|
|
const NewsInfo& info = news0.front();
|
|
|
|
EXPECT_TRUE(info.m_profileId.isValid());
|
|
EXPECT_EQ(ProfileId(DUMMY_PROFILE_ID), info.m_profileId);
|
|
EXPECT_EQ(SpaceId("3a441107-673a-40b7-a304-0cd5fcb7ee9b"), info.m_spaceId);
|
|
EXPECT_STREQ("neolane.AC4_DLC_01", info.m_id.getUtf8());
|
|
|
|
EXPECT_STREQ("DLCOffer", info.m_type.getUtf8());
|
|
EXPECT_STREQ("mainMenu1", info.m_placement.getUtf8());
|
|
EXPECT_EQ(1u, info.m_priority);
|
|
EXPECT_EQ(20u, info.m_displayTime);
|
|
EXPECT_EQ(DateTime(2014, 11, 11, 12, 0, 0), info.m_publicationDate);
|
|
|
|
EXPECT_STREQ("en-US", info.m_locale.getUtf8());
|
|
EXPECT_STREQ("New DLC Released", info.m_title.getUtf8());
|
|
EXPECT_STREQ("Get the Season Pass DLC from the Marketplace", info.m_body.getUtf8());
|
|
|
|
EXPECT_STREQ("http://static8.ubisoft.com/234224/asset34.png", info.m_mediaUrl.getUtf8());
|
|
EXPECT_STREQ("image/png", info.m_mediaType.getUtf8());
|
|
|
|
{
|
|
const NewsLink& link1 = info.m_links.front();
|
|
EXPECT_STREQ("pstore", link1.m_type.getUtf8());
|
|
EXPECT_STREQ("0x555308796ea1e800", link1.m_param.getUtf8());
|
|
EXPECT_STREQ("OpenedTheStoreForSeasonPass", link1.m_actionName.getUtf8());
|
|
EXPECT_STREQ("Buy the Season Pass", link1.m_actionDescription.getUtf8());
|
|
}
|
|
{
|
|
const NewsLink& link2 = info.m_links.back();
|
|
EXPECT_STREQ("web", link2.m_type.getUtf8());
|
|
EXPECT_STREQ("http://acu.ubisoft.com/dlc1/description.html", link2.m_param.getUtf8());
|
|
EXPECT_STREQ("MoreInfoOnSeasonPass", link2.m_actionName.getUtf8());
|
|
EXPECT_STREQ("More info...", link2.m_actionDescription.getUtf8());
|
|
}
|
|
|
|
EXPECT_STREQ("{\"assetId\":13}", info.m_object.getUtf8());
|
|
}
|
|
|
|
{
|
|
const NewsInfo& info = news0.back();
|
|
|
|
EXPECT_TRUE(info.m_profileId.isValid());
|
|
EXPECT_EQ(ProfileId(DUMMY_PROFILE_ID), info.m_profileId);
|
|
EXPECT_EQ(SpaceId("3a441107-673a-40b7-a304-0cd5fcb7ee9b"), info.m_spaceId);
|
|
EXPECT_STREQ("neolane2.AC4_DLC_06", info.m_id.getUtf8());
|
|
|
|
EXPECT_STREQ("DLCOffer", info.m_type.getUtf8());
|
|
EXPECT_STREQ("mainMenu3", info.m_placement.getUtf8());
|
|
EXPECT_EQ(2u, info.m_priority);
|
|
EXPECT_EQ(35u, info.m_displayTime);
|
|
EXPECT_EQ(DateTime(2014, 11, 22, 17, 0, 0), info.m_publicationDate);
|
|
|
|
EXPECT_STREQ("en-US", info.m_locale.getUtf8());
|
|
EXPECT_STREQ("New DLC Released", info.m_title.getUtf8());
|
|
EXPECT_STREQ("Get the Season Pass DLC from the Marketplace", info.m_body.getUtf8());
|
|
|
|
EXPECT_STREQ("http://static8.ubisoft.com/234224/asset34.png", info.m_mediaUrl.getUtf8());
|
|
EXPECT_STREQ("image/png", info.m_mediaType.getUtf8());
|
|
|
|
{
|
|
const NewsLink& link1 = info.m_links.front();
|
|
EXPECT_STREQ("pstore", link1.m_type.getUtf8());
|
|
EXPECT_STREQ("0x555308796ea1e800", link1.m_param.getUtf8());
|
|
EXPECT_STREQ("OpenedTheStoreForSeasonPass", link1.m_actionName.getUtf8());
|
|
EXPECT_STREQ("Buy the Season Pass", link1.m_actionDescription.getUtf8());
|
|
}
|
|
{
|
|
const NewsLink& link2 = info.m_links.back();
|
|
EXPECT_STREQ("sstore", link2.m_type.getUtf8());
|
|
EXPECT_STREQ("0x555308796ea1e801", link2.m_param.getUtf8());
|
|
EXPECT_STREQ("MoreInfoOnSeasonPass", link2.m_actionName.getUtf8());
|
|
EXPECT_STREQ("More info...", link2.m_actionDescription.getUtf8());
|
|
}
|
|
|
|
EXPECT_STREQ("{\"assetId\":13}", info.m_object.getUtf8());
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Requests news with a successful response from server and a valid JSON
|
|
TEST_F(NEWS_MOCK, USNOT_RequestNewsProfileCache)
|
|
{
|
|
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false); // Avoids the request to get the country
|
|
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
|
|
|
|
const String jsonBody = TestNews_BF::createMockResult();
|
|
|
|
{
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNews, MockResultHelper::createSuccessResult(jsonBody));
|
|
}
|
|
|
|
NewsClient& client = getFacade().getNewsClient();
|
|
const AsyncResult<Vector<NewsInfo> > newsResult = client.requestProfileNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult));
|
|
|
|
const Vector<NewsInfo>& news0 = newsResult.getResult();
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(news0)) << "News configuration is wrong";
|
|
|
|
// Requesting news a second time. This shall not affect the mock call expectations.
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > newsResult2 = client.requestProfileNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult2));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResult2.getResult()));
|
|
}
|
|
|
|
// Requesting news a third time after requesting to clear the cache.
|
|
// This simulate the behaviour after a call to CacheManager::invalidateCaches()
|
|
// This requires new mock call expectations.
|
|
{
|
|
NewsProxy::invalidateCache(client, CacheUnit::NewsProfile);
|
|
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNews, MockResultHelper::createSuccessResult(jsonBody));
|
|
|
|
const AsyncResult<Vector<NewsInfo> > newsResult3 = client.requestProfileNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult3));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResult3.getResult()));
|
|
}
|
|
|
|
// Requesting news a fourth time. This shall not affect the mock call expectations.
|
|
// The clear cache request only applies once.
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > newsResult4 = client.requestProfileNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult4));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResult4.getResult()));
|
|
}
|
|
|
|
const SpaceId spaceId5("3a441107-673a-40b7-a304-0cd5fcb7FAKE");
|
|
// Requesting news a fifth time on a different space ID.
|
|
// This shall requires a new set of the mock call expectations.
|
|
{
|
|
// Note that the same JSON is sent here for a different Space Id...
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNews, MockResultHelper::createSuccessResult(jsonBody));
|
|
|
|
const AsyncResult<Vector<NewsInfo> > newsResult5 = client.requestProfileNews(spaceId5);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult5));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResult5.getResult()));
|
|
}
|
|
|
|
// Requesting news a sixth time for many space IDs.
|
|
// This shall requires a new set of the mock call expectations.
|
|
{
|
|
// Note that the same JSON is sent here for a different Space Id...
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNews, MockResultHelper::createSuccessResult(jsonBody));
|
|
|
|
const AsyncResult<Vector<NewsInfo> > newsResult6 = client.requestProfileNews(SpaceId("3a441107-673a-40b7-a304-0cd5fcbFAKE1"));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult6));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResult6.getResult()));
|
|
}
|
|
|
|
// Requesting news a seventh time. This shall not affect the mock call expectations.
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > newsResult7 = client.requestProfileNews(spaceId5);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult7));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResult7.getResult()));
|
|
}
|
|
|
|
// Requesting news shall not affect the mock call expectations
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > newsResultTemp = client.requestProfileNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResultTemp));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResultTemp.getResult()));
|
|
}
|
|
|
|
// Sleeping so all entries in cache expires
|
|
// This requires new mock call expectations.
|
|
{
|
|
// A quick check to make sure the mocked TTL is in an acceptable range
|
|
ASSERT_LT(ParametersSpaceMockHelper::s_MOCK_TIME_TO_LIVE_RESOURCE_MSEC, 15000);
|
|
|
|
US_TEST_NS::Helper::sleep(ParametersSpaceMockHelper::s_MOCK_TIME_TO_LIVE_RESOURCE_MSEC * 2);
|
|
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNews, MockResultHelper::createSuccessResult(jsonBody));
|
|
|
|
const AsyncResult<Vector<NewsInfo> > newsResultTemp = client.requestProfileNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResultTemp));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResultTemp.getResult()));
|
|
}
|
|
|
|
// Requesting news shall not affect the mock call expectations
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > newsResultTemp = client.requestProfileNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResultTemp));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResultTemp.getResult()));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Requests news with a successful response from server and a valid JSON
|
|
TEST_F(NEWS_MOCK, USNOT_RequestNewsSpace)
|
|
{
|
|
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false); // Avoids the request to get the country
|
|
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
|
|
|
|
SAVE_ALLOC_COUNT(count);
|
|
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNewsSpace, MockResultHelper::createSuccessResult(TestNews_BF::createMockResult()));
|
|
|
|
EXPECT_ALLOC_COUNT_PC_EQ(28, count);
|
|
const AsyncResult<Vector<NewsInfo> > newsResult = getFacade().getNewsClient().requestSpaceNews();
|
|
EXPECT_ALLOC_COUNT_PC_EQ(31, count);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult));
|
|
|
|
// Check resulting news content
|
|
const Vector<NewsInfo>& news0 = newsResult.getResult();
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(news0));
|
|
|
|
{
|
|
const NewsInfo& info = news0.front();
|
|
|
|
EXPECT_TRUE(info.m_profileId.isValid());
|
|
EXPECT_EQ(ProfileId(DUMMY_PROFILE_ID), info.m_profileId);
|
|
EXPECT_EQ(SpaceId("3a441107-673a-40b7-a304-0cd5fcb7ee9b"), info.m_spaceId);
|
|
EXPECT_STREQ("neolane.AC4_DLC_01", info.m_id.getUtf8());
|
|
|
|
EXPECT_STREQ("DLCOffer", info.m_type.getUtf8());
|
|
EXPECT_STREQ("mainMenu1", info.m_placement.getUtf8());
|
|
EXPECT_EQ(1u, info.m_priority);
|
|
EXPECT_EQ(20u, info.m_displayTime);
|
|
EXPECT_EQ(DateTime(2014, 11, 11, 12, 0, 0), info.m_publicationDate);
|
|
|
|
EXPECT_STREQ("en-US", info.m_locale.getUtf8());
|
|
EXPECT_STREQ("New DLC Released", info.m_title.getUtf8());
|
|
EXPECT_STREQ("Get the Season Pass DLC from the Marketplace", info.m_body.getUtf8());
|
|
|
|
EXPECT_STREQ("http://static8.ubisoft.com/234224/asset34.png", info.m_mediaUrl.getUtf8());
|
|
EXPECT_STREQ("image/png", info.m_mediaType.getUtf8());
|
|
|
|
{
|
|
const NewsLink& link1 = info.m_links.front();
|
|
EXPECT_STREQ("pstore", link1.m_type.getUtf8());
|
|
EXPECT_STREQ("0x555308796ea1e800", link1.m_param.getUtf8());
|
|
EXPECT_STREQ("OpenedTheStoreForSeasonPass", link1.m_actionName.getUtf8());
|
|
EXPECT_STREQ("Buy the Season Pass", link1.m_actionDescription.getUtf8());
|
|
}
|
|
{
|
|
const NewsLink& link2 = info.m_links.back();
|
|
EXPECT_STREQ("web", link2.m_type.getUtf8());
|
|
EXPECT_STREQ("http://acu.ubisoft.com/dlc1/description.html", link2.m_param.getUtf8());
|
|
EXPECT_STREQ("MoreInfoOnSeasonPass", link2.m_actionName.getUtf8());
|
|
EXPECT_STREQ("More info...", link2.m_actionDescription.getUtf8());
|
|
}
|
|
|
|
EXPECT_STREQ("{\"assetId\":13}", info.m_object.getUtf8());
|
|
}
|
|
|
|
{
|
|
const NewsInfo& info = news0.back();
|
|
|
|
EXPECT_TRUE(info.m_profileId.isValid());
|
|
EXPECT_EQ(ProfileId(DUMMY_PROFILE_ID), info.m_profileId);
|
|
EXPECT_EQ(SpaceId("3a441107-673a-40b7-a304-0cd5fcb7ee9b"), info.m_spaceId);
|
|
EXPECT_STREQ("neolane2.AC4_DLC_06", info.m_id.getUtf8());
|
|
|
|
EXPECT_STREQ("DLCOffer", info.m_type.getUtf8());
|
|
EXPECT_STREQ("mainMenu3", info.m_placement.getUtf8());
|
|
EXPECT_EQ(2u, info.m_priority);
|
|
EXPECT_EQ(35u, info.m_displayTime);
|
|
EXPECT_EQ(DateTime(2014, 11, 22, 17, 0, 0), info.m_publicationDate);
|
|
|
|
EXPECT_STREQ("en-US", info.m_locale.getUtf8());
|
|
EXPECT_STREQ("New DLC Released", info.m_title.getUtf8());
|
|
EXPECT_STREQ("Get the Season Pass DLC from the Marketplace", info.m_body.getUtf8());
|
|
|
|
EXPECT_STREQ("http://static8.ubisoft.com/234224/asset34.png", info.m_mediaUrl.getUtf8());
|
|
EXPECT_STREQ("image/png", info.m_mediaType.getUtf8());
|
|
|
|
{
|
|
const NewsLink& link1 = info.m_links.front();
|
|
EXPECT_STREQ("pstore", link1.m_type.getUtf8());
|
|
EXPECT_STREQ("0x555308796ea1e800", link1.m_param.getUtf8());
|
|
EXPECT_STREQ("OpenedTheStoreForSeasonPass", link1.m_actionName.getUtf8());
|
|
EXPECT_STREQ("Buy the Season Pass", link1.m_actionDescription.getUtf8());
|
|
}
|
|
{
|
|
const NewsLink& link2 = info.m_links.back();
|
|
EXPECT_STREQ("sstore", link2.m_type.getUtf8());
|
|
EXPECT_STREQ("0x555308796ea1e801", link2.m_param.getUtf8());
|
|
EXPECT_STREQ("MoreInfoOnSeasonPass", link2.m_actionName.getUtf8());
|
|
EXPECT_STREQ("More info...", link2.m_actionDescription.getUtf8());
|
|
}
|
|
|
|
EXPECT_STREQ("{\"assetId\":13}", info.m_object.getUtf8());
|
|
}
|
|
|
|
EXPECT_ALLOC_COUNT_PC_EQ(4938, count);
|
|
}
|
|
#endif
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Requests news with a successful response from server and a valid JSON
|
|
TEST_F(NEWS_MOCK, USNOT_RequestNewsSpaceCache)
|
|
{
|
|
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false); // Avoids the request to get the country
|
|
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
|
|
|
|
SAVE_ALLOC_COUNT(count);
|
|
|
|
const String jsonBody = TestNews_BF::createMockResult();
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNewsSpace, MockResultHelper::createSuccessResult(jsonBody));
|
|
|
|
NewsClient& client = getFacade().getNewsClient();
|
|
|
|
EXPECT_ALLOC_COUNT_PC_EQ(28, count);
|
|
const AsyncResult<Vector<NewsInfo> > newsResult = client.requestSpaceNews();
|
|
EXPECT_ALLOC_COUNT_PC_EQ(31, count);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult));
|
|
|
|
// Check resulting news content
|
|
const Vector<NewsInfo>& news0 = newsResult.getResult();
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(news0));
|
|
|
|
// Requesting news a second time. This shall not affect the mock call expectations.
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > newsResult2 = client.requestSpaceNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult2));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResult2.getResult()));
|
|
}
|
|
|
|
// Requesting news a third time after requesting to clear the cache.
|
|
// This simulate the behaviour after a call to CacheManager::invalidateCaches()
|
|
// This requires new mock call expectations.
|
|
{
|
|
NewsProxy::invalidateCache(client, CacheUnit::NewsSpace);
|
|
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNewsSpace, MockResultHelper::createSuccessResult(jsonBody));
|
|
|
|
const AsyncResult<Vector<NewsInfo> > newsResult3 = client.requestSpaceNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult3));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResult3.getResult()));
|
|
}
|
|
|
|
// Requesting news a fourth time. This shall not affect the mock call expectations.
|
|
// The clear cache request only applies once.
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > newsResult4 = client.requestSpaceNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult4));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResult4.getResult()));
|
|
}
|
|
|
|
const SpaceId spaceId5("3a441107-673a-40b7-a304-0cd5fcb7FAKE");
|
|
// Requesting news a fifth time on a different space ID.
|
|
// This shall requires a new set of the mock call expectations.
|
|
{
|
|
// Note that the same JSON is sent here for a different Space Id...
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNewsSpace, MockResultHelper::createSuccessResult(jsonBody));
|
|
|
|
const AsyncResult<Vector<NewsInfo> > newsResult5 = client.requestSpaceNews(spaceId5);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult5));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResult5.getResult()));
|
|
}
|
|
|
|
// Requesting news a sixth time for many space IDs.
|
|
// This shall requires a new set of the mock call expectations.
|
|
{
|
|
// Note that the same JSON is sent here for a different Space Id...
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNewsSpace, MockResultHelper::createSuccessResult(jsonBody));
|
|
|
|
const AsyncResult<Vector<NewsInfo> > newsResult6 = client.requestSpaceNews(SpaceId("3a441107-673a-40b7-a304-0cd5fcbFAKE1"));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult6));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResult6.getResult()));
|
|
}
|
|
|
|
// Requesting news a seventh time. This shall not affect the mock call expectations.
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > newsResult7 = client.requestSpaceNews(spaceId5);
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult7));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResult7.getResult()));
|
|
}
|
|
|
|
// Requesting news shall not affect the mock call expectations
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > newsResultTemp = client.requestSpaceNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResultTemp));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResultTemp.getResult()));
|
|
}
|
|
|
|
// Sleeping so all entries in cache expires
|
|
// This requires new mock call expectations.
|
|
{
|
|
US_TEST_NS::Helper::sleep(ParametersSpaceMockHelper::s_MOCK_TIME_TO_LIVE_RESOURCE_MSEC * 2);
|
|
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNewsSpace, MockResultHelper::createSuccessResult(jsonBody));
|
|
|
|
const AsyncResult<Vector<NewsInfo> > newsResultTemp = client.requestSpaceNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResultTemp));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResultTemp.getResult()));
|
|
}
|
|
|
|
// Requesting news shall not affect the mock call expectations
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > newsResultTemp = client.requestSpaceNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResultTemp));
|
|
ASSERT_TRUE(TestNews_BF::checkResultingNews(newsResultTemp.getResult()));
|
|
}
|
|
|
|
EXPECT_ALLOC_COUNT_PC_EQ(4938, count);
|
|
}
|
|
#endif
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Requests news with a successful response from server and an invalid JSON
|
|
TEST_F(NEWS_MOCK, USNOT_RequestNewsErrorJsonSyntax)
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Request news failed. Invalid JSON in response's body", LogLevel::Error, Times(2));
|
|
});
|
|
|
|
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false); // Avoids the request to get the country
|
|
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
|
|
|
|
{
|
|
testing::InSequence s;
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(
|
|
TestNews_BF::createMockResult().replace("{", "")); // Omitting the opening bracket for invalid JSON.
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNews, mockResult);
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNewsSpace, mockResult);
|
|
}
|
|
|
|
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getNewsClient().requestProfileNews(), Errors::CORE_INVALID_JSON_FORMAT));
|
|
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getNewsClient().requestSpaceNews(), Errors::CORE_INVALID_JSON_FORMAT));
|
|
}
|
|
#endif
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Requests news with a successful response from server and a valid JSON (missing fields)
|
|
TEST_F(NEWS_MOCK, USNOT_RequestNewsErrorJsonMissingFields)
|
|
{
|
|
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false); // Avoids the request to get the country
|
|
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
|
|
|
|
{
|
|
testing::InSequence s;
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(
|
|
TestNews_BF::createMockResult().replace("\"newsId\":\"neolane.AC4_DLC_01\",", ""));
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNews, mockResult);
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNewsSpace, mockResult);
|
|
}
|
|
|
|
EXPECT_TRUE(AsyncHelper::waitSuccess(getFacade().getNewsClient().requestProfileNews()));
|
|
EXPECT_TRUE(AsyncHelper::waitSuccess(getFacade().getNewsClient().requestSpaceNews()));
|
|
}
|
|
#endif
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Requests news with a successful response from server and a valid JSON (extra fields)
|
|
TEST_F(NEWS_MOCK, USNOT_RequestNewsJsonExtraFields)
|
|
{
|
|
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false); // Avoids the request to get the country
|
|
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
|
|
|
|
{
|
|
const String jsonBody = TestNews_BF::createMockResult()
|
|
.replace("\"newsId\":\"neolane.AC4_DLC_01\",", "\"newsId\":\"neolane.AC4_DLC_01\",\"priorityExtraField1\": 1,");
|
|
|
|
testing::InSequence s;
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(jsonBody);
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNews, mockResult);
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNewsSpace, mockResult);
|
|
}
|
|
|
|
EXPECT_TRUE(AsyncHelper::waitSuccess(getFacade().getNewsClient().requestProfileNews()));
|
|
EXPECT_TRUE(AsyncHelper::waitSuccess(getFacade().getNewsClient().requestSpaceNews()));
|
|
}
|
|
#endif
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Requests News parsing a JSON structure containing extra Root node.
|
|
TEST_F(NEWS_MOCK, USNOT_RequestNewsWithExtraRootNode)
|
|
{
|
|
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false); // Avoids the request to get the country
|
|
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
|
|
|
|
{
|
|
const String jsonBody = TestNews_BF::createMockResult();
|
|
|
|
// Add extra root node
|
|
// Extra node must be first in json
|
|
String jsonBodyExtraNode = "{\"extraRootNode\":[{\"name\":\"extraItem\",\"quantity\":2}],";
|
|
|
|
// Remove first '{' because its now part of a json array
|
|
jsonBodyExtraNode += jsonBody.substr(jsonBody.findSubstringNoCase("{") + 1, jsonBody.getLength());
|
|
|
|
testing::InSequence s;
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(jsonBodyExtraNode);
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNews, mockResult);
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNewsSpace, mockResult);
|
|
}
|
|
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > newsResult = getFacade().getNewsClient().requestProfileNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult));
|
|
EXPECT_EQ(6, newsResult.getResult().size());
|
|
}
|
|
{
|
|
const AsyncResult<Vector<NewsInfo> > newsResult = getFacade().getNewsClient().requestSpaceNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult));
|
|
EXPECT_EQ(6, newsResult.getResult().size());
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Requests news with an HTTP error from server.
|
|
TEST_F(NEWS_MOCK, USNOT_RequestNewsErrorHttp)
|
|
{
|
|
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false); // Avoids the request to get the country
|
|
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
|
|
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Status code: 400", LogLevel::Error, Times(2));
|
|
});
|
|
|
|
{
|
|
testing::InSequence s;
|
|
const MockAsyncResult mockResult = MockResultHelper::createHttpErrorResult(RestStatusCode::Error400, "{\"error\":\"myerror\"}");
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNews, mockResult);
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNewsSpace, mockResult);
|
|
}
|
|
|
|
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getNewsClient().requestProfileNews(), Errors::NEWS_GENERIC_FAILURE));
|
|
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getNewsClient().requestSpaceNews(), Errors::NEWS_GENERIC_FAILURE));
|
|
}
|
|
#endif
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Check the default spaceId when no spaceId is given
|
|
TEST_F(NEWS_MOCK, USNOT_RequestProfileNewsDefaultParameter)
|
|
{
|
|
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false); // Avoids the request to get the country
|
|
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
|
|
|
|
HttpGet request(StringUrl(""));
|
|
US_EXPECT_CALL(US_TEST_NS::Action::GetNews)
|
|
.WillOnce(testing::DoAll(
|
|
testing::SaveArg<0>(reinterpret_cast<HttpRequest*>(&request)),
|
|
testing::Return(MockResultHelper::createSuccessResult())));
|
|
|
|
EXPECT_TRUE(AsyncHelper::waitSuccess(getFacade().getNewsClient().requestProfileNews()));
|
|
|
|
const String spaceIdQuery = [&]()
|
|
{
|
|
StringStream query;
|
|
query << "spaceId=" << getFacade().getWorkingSpaceId();
|
|
return query.getContent();
|
|
}();
|
|
|
|
EXPECT_NE(String::npos, URLInfo(request.getUrl()).getQuery().findSubstringCase(spaceIdQuery));
|
|
}
|
|
#endif
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Check the default spaceId when no spaceId is given
|
|
TEST_F(NEWS_MOCK, USNOT_RequestSpaceNewsDefaultParameter)
|
|
{
|
|
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false); // Avoids the request to get the country
|
|
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
|
|
|
|
HttpGet request(StringUrl(""));
|
|
US_EXPECT_CALL(US_TEST_NS::Action::GetNewsSpace)
|
|
.WillOnce(testing::DoAll(
|
|
testing::SaveArg<0>(reinterpret_cast<HttpRequest*>(&request)),
|
|
testing::Return(MockResultHelper::createSuccessResult())));
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().getNewsClient().requestSpaceNews()));
|
|
|
|
const String spaceIdQuery = [&]()
|
|
{
|
|
StringStream query;
|
|
query << "spaceId=" << getFacade().getWorkingSpaceId();
|
|
return query.getContent();
|
|
}();
|
|
|
|
EXPECT_TRUE(URLInfo(request.getUrl()).getQuery().findSubstringCase(spaceIdQuery) != String::npos)
|
|
<< "Failed to find the Space id '" << spaceIdQuery.getUtf8() << "' into URL: " << request.getUrl().getUtf8();
|
|
}
|
|
#endif
|
|
|
|
/// @test Check that no request is sent and an error is raised when given spaceId is invalid
|
|
TEST_F(NEWS_MOCK, USNOT_RequestProfileNewsInvalidSpaceId)
|
|
{
|
|
US_EXPECT_CALL(US_TEST_NS::Action::GetNews).Times(0);
|
|
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getNewsClient().requestProfileNews(SpaceId("InvalidSpaceId")), Errors::NEWS_INVALID_PARAM));
|
|
}
|
|
|
|
/// @test Check that no request is sent and an error is raised when given spaceId is invalid
|
|
TEST_F(NEWS_MOCK, USNOT_RequestSpaceNewsInvalidSpaceId)
|
|
{
|
|
US_EXPECT_CALL(US_TEST_NS::Action::GetNewsSpace).Times(0);
|
|
EXPECT_TRUE(AsyncHelper::waitFailure(getFacade().getNewsClient().requestSpaceNews(SpaceId("InvalidSpaceId")), Errors::NEWS_INVALID_PARAM));
|
|
}
|
|
|
|
/// @test Check the default Ubi-Market header when a country code is given
|
|
TEST_F(NEWS_MOCK, USNOT_RequestNewsSpecifiedCountry)
|
|
{
|
|
const SpaceId spaceSdk = SpaceId("3a441107-673a-40b7-a304-0cd5fcb7ee9b");
|
|
HttpGet requestSpace(StringUrl(""));
|
|
US_EXPECT_CALL(US_TEST_NS::Action::GetNewsSpace)
|
|
.WillOnce(testing::DoAll(
|
|
testing::SaveArg<0>(reinterpret_cast<HttpRequest*>(&requestSpace)),
|
|
testing::Return(MockResultHelper::createSuccessResult())));
|
|
|
|
EXPECT_TRUE(AsyncHelper::waitSuccess(getFacade().getNewsClient().requestSpaceNews(spaceSdk, CountryName::UnitedStates)));
|
|
EXPECT_NE(String::npos, requestSpace.getHeader("Ubi-Market").findSubstringCase("US"));
|
|
|
|
HttpGet requestProfile(StringUrl(""));
|
|
US_EXPECT_CALL(US_TEST_NS::Action::GetNews)
|
|
.WillOnce(testing::DoAll(
|
|
testing::SaveArg<0>(reinterpret_cast<HttpRequest*>(&requestProfile)),
|
|
testing::Return(MockResultHelper::createSuccessResult())));
|
|
|
|
EXPECT_TRUE(AsyncHelper::waitSuccess(getFacade().getNewsClient().requestProfileNews(spaceSdk, CountryName::France)));
|
|
EXPECT_NE(String::npos, requestProfile.getHeader("Ubi-Market").findSubstringCase("FR"));
|
|
}
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Validates the push of the player.news.action and player.news.impression.
|
|
TEST_F(NEWS_MOCK, USNOT_NewsActionAndImpression)
|
|
{
|
|
HttpPost httpRequest(StringUrl(""), String());
|
|
{
|
|
US_EXPECT_CALL(US_TEST_NS::Action::DeleteSession)
|
|
.WillOnce(testing::Return(MockResultHelper::createSuccessResult()));
|
|
US_EXPECT_CALL(US_TEST_NS::Action::SendEvents)
|
|
.WillOnce(testing::DoAll(
|
|
testing::SaveArg<0>(static_cast<HttpRequest*>(&httpRequest)),
|
|
testing::Return(MockResultHelper::createSuccessResult())));
|
|
}
|
|
|
|
waitForPostLoginCompletion();
|
|
|
|
const String newsId1("News2");
|
|
const String placement1("Placement1");
|
|
const String action("Action1");
|
|
ASSERT_TRUE(getFacade().getNewsClient().reportNewsAction(newsId1, placement1, action));
|
|
|
|
const String newsId2("News2");
|
|
const String placement2("Placement2");
|
|
const TimeSeconds duration = 10ul;
|
|
ASSERT_TRUE(getFacade().getNewsClient().reportNewsImpression(newsId2, placement2, duration));
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().deleteSession()));
|
|
|
|
{
|
|
Map<int32, String> expectedEvents;
|
|
expectedEvents[0] = "game.start";
|
|
expectedEvents[1] = "player.start";
|
|
expectedEvents[2] = "player.news.action";
|
|
expectedEvents[3] = "player.news.impression";
|
|
ASSERT_THAT(TestNews_BF::extractEventsFromRequest(httpRequest), expectedEvents);
|
|
}
|
|
|
|
const Json requestBodyJson(httpRequest.getBodyAsString());
|
|
for (const auto& it : requestBodyJson["events"].getValueArray())
|
|
{
|
|
if (it["type"].getValueString() == "player.news.action")
|
|
{
|
|
EXPECT_EQ(newsId1, it["typeData"]["newsId"].getValueString());
|
|
EXPECT_EQ(placement1, it["typeData"]["placement"].getValueString());
|
|
EXPECT_EQ(action, it["typeData"]["actionName"].getValueString());
|
|
}
|
|
if (it["type"].getValueString() == "player.news.impression")
|
|
{
|
|
EXPECT_EQ(newsId2, it["typeData"]["newsId"].getValueString());
|
|
EXPECT_EQ(placement2, it["typeData"]["placement"].getValueString());
|
|
EXPECT_EQ(duration, it["typeData"]["duration"].getValueInteger());
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if defined(US_TARGET_PS4) || defined(US_TARGET_XONE) || defined(US_TARGET_KILI)
|
|
/// @test Checks that the country is correctly retrieved. Note : account country for PS4, console country for XBoxOne.
|
|
TEST_F(NEWS_MOCK, LOCAL_DetectMarket)
|
|
{
|
|
HttpGet requestNews(StringUrl(""));
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult();
|
|
US_EXPECT_CALL(US_TEST_NS::Action::GetNewsSpace)
|
|
.WillOnce(testing::DoAll(testing::SaveArg<0>(reinterpret_cast<HttpRequest*>(&requestNews)), testing::Return(mockResult)));
|
|
}
|
|
|
|
EXPECT_TRUE(AsyncHelper::waitSuccess(getFacade().getNewsClient().requestSpaceNews()));
|
|
EXPECT_EQ("US", requestNews.getHeader("Ubi-Market"));
|
|
}
|
|
#endif
|
|
|
|
#if defined(US_SDK_FULL) // Market detection only done in full sdk
|
|
#if !defined(US_TARGET_PS4) && !defined(US_TARGET_XONE) && !defined(US_TARGET_KILI)
|
|
/// @test Checks that the market is correctly detected.
|
|
TEST_F(NEWS_MOCK, LOCAL_DetectMarket)
|
|
{
|
|
// Burundi chosen as value that is probably not a default value anywhere
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetUser, MockResultHelper::createSuccessResult("{\"country\":\"BI\"}"));
|
|
|
|
HttpGet requestNews(StringUrl(""));
|
|
US_EXPECT_CALL(US_TEST_NS::Action::GetNewsSpace)
|
|
.WillOnce(testing::DoAll(
|
|
testing::SaveArg<0>(reinterpret_cast<HttpRequest*>(&requestNews)),
|
|
testing::Return(MockResultHelper::createSuccessResult())));
|
|
|
|
EXPECT_TRUE(AsyncHelper::waitSuccess(getFacade().getNewsClient().requestSpaceNews()));
|
|
EXPECT_EQ("BI", requestNews.getHeader("Ubi-Market"));
|
|
}
|
|
|
|
/// @test Checks that the Ubi-Market is not sent when requesting the user localization returns an error
|
|
TEST_F(NEWS_MOCK, LOCAL_DetectMarketUserLocalizationError)
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Status code: 400", LogLevel::Error, Times(1));
|
|
});
|
|
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetUser, MockResultHelper::createHttpErrorResult(RestStatusCode::Error400, "{\"error\":\"myError\"}"));
|
|
|
|
HttpGet requestNews(StringUrl(""));
|
|
US_EXPECT_CALL(US_TEST_NS::Action::GetNewsSpace)
|
|
.WillOnce(testing::DoAll(
|
|
testing::SaveArg<0>(reinterpret_cast<HttpRequest*>(&requestNews)),
|
|
testing::Return(MockResultHelper::createSuccessResult())));
|
|
|
|
EXPECT_TRUE(AsyncHelper::waitSuccess(getFacade().getNewsClient().requestSpaceNews()));
|
|
EXPECT_EQ(0, requestNews.getHeader("Ubi-Market").getLength());
|
|
}
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test Checks that the Ubi-Market is not sent when the feature switch for user is disabled
|
|
TEST_F(NEWS_MOCK, LOCAL_DetectMarketFeatureSwitchUsersDisabled)
|
|
{
|
|
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false); // Avoids the request to get the country
|
|
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
|
|
|
|
US_EXPECT_CALL(US_TEST_NS::Action::GetUser).Times(0);
|
|
|
|
HttpGet requestNews(StringUrl(""));
|
|
US_EXPECT_CALL(US_TEST_NS::Action::GetNewsSpace)
|
|
.WillOnce(testing::DoAll(
|
|
testing::SaveArg<0>(reinterpret_cast<HttpRequest*>(&requestNews)),
|
|
testing::Return(MockResultHelper::createSuccessResult())));
|
|
|
|
EXPECT_TRUE(AsyncHelper::waitSuccess(getFacade().getNewsClient().requestSpaceNews()));
|
|
EXPECT_EQ(0, requestNews.getHeader("Ubi-Market").getLength());
|
|
}
|
|
#endif
|
|
#endif // defined(US_SDK_FULL)
|
|
|
|
#endif
|
|
|
|
#if !defined(US_DLL)
|
|
/// @test The news service guarantees the order in which the links are returned by their API.
|
|
/// The SDK must return the links and sub-links in the same order.
|
|
TEST_F(NEWS_MOCK, LOCAL_ConfirmNewsLinksOrder)
|
|
{
|
|
ParametersClientProxy::enableSwitch(getFacadeInternal(), FeatureSwitchId::Users, false); // Avoids the request to get the country
|
|
ASSERT_FALSE(getFacade().getParametersClient().isUsFeatureSwitchEnabled(FeatureSwitchId::Users));
|
|
|
|
// Allows to mock a news with various link types and multiple sub-links (2x weblink)
|
|
struct Local
|
|
{
|
|
static Json createMock()
|
|
{
|
|
JsonWriter newsWrapperWriter;
|
|
JsonWriter newsArrayWriter(JsonWriterType::Array);
|
|
JsonWriter writer;
|
|
|
|
writer["profileId"] = "aaaa1111-bbbb-2222-cccc-3333dddd4444"; // <<<<<< missing field
|
|
writer["spaceId"] = "11112222-3333-4444-5555-666677778888";
|
|
writer["newsId"] = "aaaabbbbcccc-dddd-eeee-ffff-123456781234"; // This is not a GUID
|
|
writer["type"] = "myNewsType";
|
|
writer["placement"] = "myNewsPlacement";
|
|
writer["priority"] = 123;
|
|
writer["displayTime"] = 60;
|
|
writer["publicationDate"] = "2014-11-11T12:00:00";
|
|
writer["locale"] = "en-us";
|
|
writer["title"] = "myNewsTitle";
|
|
writer["body"] = "myNewsBody";
|
|
writer["mediaURL"] = "http://myNewsUrl.com";
|
|
writer["mediaType"] = "myNewsMediaType";
|
|
{
|
|
Vector<Json> links;
|
|
links.reserve(4);
|
|
|
|
// Adding a popup type link
|
|
{
|
|
JsonWriter link;
|
|
link["type"] = "popup";
|
|
link["param"] = "myLinkParam0";
|
|
link["actionName"] = "myLinkActionName0";
|
|
link["actionDescription"] = "myLinkActionDesc0";
|
|
links.push_back(link.getJson());
|
|
}
|
|
|
|
// Adding two weblink type
|
|
for (uint32 i = 1; i < 3; ++i)
|
|
{
|
|
JsonWriter link;
|
|
link["type"] = "weblink";
|
|
link["param"] = String::formatText("myLinkParam%d", i);
|
|
link["actionName"] = String::formatText("myLinkActionName%d", i);
|
|
link["actionDescription"] = String::formatText("myLinkActionDesc%d", i);
|
|
links.push_back(link.getJson());
|
|
}
|
|
|
|
// Adding an image type link
|
|
{
|
|
JsonWriter link;
|
|
link["type"] = "image";
|
|
link["param"] = "myLinkParam3";
|
|
link["actionName"] = "myLinkActionName3";
|
|
link["actionDescription"] = "myLinkActionDesc3";
|
|
links.push_back(link.getJson());
|
|
}
|
|
|
|
writer["links"] = links;
|
|
}
|
|
{
|
|
JsonWriter obj;
|
|
obj["field"] = "value";
|
|
writer["obj"] = obj.getJson();
|
|
}
|
|
|
|
newsArrayWriter.addItemToArray(writer.getJson());
|
|
|
|
newsWrapperWriter["news"] = newsArrayWriter.getJson();
|
|
|
|
return newsWrapperWriter.getJson();
|
|
}
|
|
};
|
|
|
|
US_EXPECT_CALL_SIMPLE(US_TEST_NS::Action::GetNews, MockResultHelper::createSuccessResult(Local::createMock().renderContent()));
|
|
|
|
const AsyncResult<Vector<NewsInfo>> newsResult = getFacade().getNewsClient().requestProfileNews();
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(newsResult));
|
|
|
|
const Vector<NewsInfo>& news = newsResult.getResult();
|
|
ASSERT_TRUE(news.size() == 1u);
|
|
|
|
const NewsInfo& info = news[0];
|
|
ASSERT_TRUE(info.m_links.size() == 4u);
|
|
|
|
// Verify the order of the links type is popup->weblink->weblink->image for 4 links provided
|
|
EXPECT_STREQ("popup", info.m_links[0].m_type.getUtf8());
|
|
EXPECT_STREQ("weblink", info.m_links[1].m_type.getUtf8());
|
|
EXPECT_STREQ("weblink", info.m_links[2].m_type.getUtf8());
|
|
EXPECT_STREQ("image", info.m_links[3].m_type.getUtf8());
|
|
|
|
// Verify the order of the sub-links (weblink) is link1->link2
|
|
EXPECT_STREQ("myLinkParam2", info.m_links[2].m_param.getUtf8());
|
|
EXPECT_STREQ("myLinkParam1", info.m_links[1].m_param.getUtf8());
|
|
}
|
|
|
|
#if defined(US_TARGET_WINDOWS) && defined(US_SDK_TEST_CHINA)
|
|
/// @test Checks that the railId and the Tencent session ticket are present in the url of the news request
|
|
TEST_F(NEWS_MOCK_NOINIT, USNOT_LoginCheckChinaNewsUrl)
|
|
{
|
|
const LoginMockNoInitScopedUninit autoUninit(*this);
|
|
{
|
|
US_NS::initializeSdk();
|
|
const ApplicationId chinaPcAppId(US_TEST_NS::SPACE_ID_US_SDK_PC_CHINA_RETAIL);
|
|
const String chinaPcBuildId("CHINA_IS_PROD");
|
|
|
|
US_NS::HttpConfig httpConfig; // Proxy needed for the manual http request to azure
|
|
httpConfig.m_proxy.m_proxyType = HttpProxyConfig::Type::Enabled;
|
|
httpConfig.m_proxy.m_host = "proxy.ubisoft.org";
|
|
httpConfig.m_proxy.m_port = 3128;
|
|
|
|
configureSdk(GameConfig(
|
|
chinaPcAppId,
|
|
chinaPcBuildId,
|
|
OnlineAccessContext::China,
|
|
GameConfigEvent(String(), US_TEST_NS::US_SDK_DUMMY_GAME_SKU, Vector<EventTypeInfo>()),
|
|
GameConfigConsole()),
|
|
SystemConfig(US_NS::ThreadingConfig(), httpConfig));
|
|
|
|
SetUpAfterInit();
|
|
mockFullLogin();
|
|
|
|
{
|
|
const String tencentTicket("DummyTencentSessionTicket");
|
|
// Perform the login
|
|
// Session doesn't have to be valid for our AppId 586cc2e2-29c0-4522-8626-a1159939abe4 (UbiServices SDK PC China RETAIL)
|
|
// A valid session is only possible when using this AppId
|
|
const String sessionRailId(US_TEST_NS::WEGAME_SESSION_ID);
|
|
const US_NS::String playerRailId(US_TEST_NS::WEGAME_PROFILE_RAIL_ID);
|
|
const String gameRailId(US_TEST_NS::WEGAME_GAME_RAIL_ID);
|
|
|
|
const String weGameToken(CredentialsTypeHelper::getWeGameToken(sessionRailId, playerRailId, gameRailId));
|
|
const PlayerCredentials credentials(weGameToken, CredentialsType::WeGame, playerRailId);
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(credentials, {}, {})));
|
|
waitForPostLoginCompletion();
|
|
ASSERT_TRUE(US_TEST_NS::Helper::waitForWebsocketInit(getFacade()));
|
|
|
|
const MockAsyncResult mockResultSuccess = MockResultHelper::createSuccessResult("{}");
|
|
HttpGet requestGetNews((StringUrl()));
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-spaces-news")
|
|
.WillOnce(DoAll(testing::SaveArg<0>(static_cast<HttpRequest*>(&requestGetNews)), testing::Return(mockResultSuccess)));
|
|
|
|
const String currentProfile = getFacade().getAuthenticationClient().getSessionInfo().getProfileId();
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/mock-users/" + currentProfile + "?fields=country,preferredLanguage")
|
|
.Times(testing::AnyNumber());
|
|
|
|
const String currentSpace = getFacade().getWorkingSpaceId();
|
|
|
|
const AsyncResult<Vector<NewsInfo> > result = getFacade().getNewsClient().requestSpaceNewsTencent(tencentTicket, SpaceId(currentSpace));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
// /mock-spaces-news?wegameid=playerRailId&session_ticket=tencentTicket&spaceId=currentSpace
|
|
EXPECT_TRUE(requestGetNews.getUrl().findSubstringCase("wegameid=" + playerRailId)) << "wegameid is not set.";
|
|
EXPECT_TRUE(requestGetNews.getUrl().findSubstringCase("session_ticket=" + tencentTicket)) << "session_ticket is not set.";
|
|
EXPECT_TRUE(requestGetNews.getUrl().findSubstringCase("spaceId=" + currentSpace)) << "spaceId is not set.";
|
|
}
|
|
}
|
|
}
|
|
|
|
/// @test Checks that requesting china news in a Standard online context fails
|
|
TEST_F(NEWS_MOCK_NOINIT, USNOT_RequestChinaNewsInNormalOnlineContext)
|
|
{
|
|
const LoginMockNoInitScopedUninit autoUninit(*this);
|
|
{
|
|
US_NS::initializeSdk();
|
|
const ApplicationId chinaPcAppId(US_TEST_NS::SPACE_ID_US_SDK_PC_CHINA_RETAIL);
|
|
const String chinaPcBuildId("CHINA_IS_PROD");
|
|
|
|
US_NS::HttpConfig httpConfig; // Proxy needed for the manual http request to azure
|
|
httpConfig.m_proxy.m_proxyType = HttpProxyConfig::Type::Enabled;
|
|
httpConfig.m_proxy.m_host = "proxy.ubisoft.org";
|
|
httpConfig.m_proxy.m_port = 3128;
|
|
|
|
configureSdk(GameConfig(
|
|
chinaPcAppId,
|
|
chinaPcBuildId,
|
|
OnlineAccessContext::Standard,
|
|
GameConfigEvent(String(), US_TEST_NS::US_SDK_DUMMY_GAME_SKU, Vector<EventTypeInfo>()),
|
|
GameConfigConsole()),
|
|
SystemConfig(US_NS::ThreadingConfig(), httpConfig));
|
|
|
|
SetUpAfterInit();
|
|
mockFullLogin();
|
|
|
|
{
|
|
const String tencentTicket("DummyTencentSessionTicket");
|
|
// Perform the login
|
|
// Those IDs are from Identity Team
|
|
// Session doesn't have to be valid for our AppId 586cc2e2-29c0-4522-8626-a1159939abe4 (UbiServices SDK PC China RETAIL)
|
|
// A valid session is only possible when using WeGame SDK
|
|
const String sessionRailId(US_TEST_NS::WEGAME_SESSION_ID);
|
|
const US_NS::String playerRailId(US_TEST_NS::WEGAME_PROFILE_RAIL_ID);
|
|
const String gameRailId(US_TEST_NS::WEGAME_GAME_RAIL_ID);
|
|
|
|
const String weGameToken(CredentialsTypeHelper::getWeGameToken(sessionRailId, playerRailId, gameRailId));
|
|
const PlayerCredentials credentials(weGameToken, CredentialsType::WeGame, playerRailId);
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(credentials, {}, {})));
|
|
waitForPostLoginCompletion();
|
|
ASSERT_TRUE(US_TEST_NS::Helper::waitForWebsocketInit(getFacade()));
|
|
|
|
const String currentSpace = getFacade().getWorkingSpaceId();
|
|
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Cannot perform request in an online context different than China", LogLevel::Error, Times(2));
|
|
});
|
|
|
|
const AsyncResult<Vector<NewsInfo> > result = getFacade().getNewsClient().requestSpaceNewsTencent(tencentTicket, SpaceId(currentSpace));
|
|
const AsyncResult<Vector<NewsInfo> > result2 = getFacade().getNewsClient().requestProfileNewsTencent(tencentTicket, SpaceId(currentSpace));
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(result, Errors::NEWS_GENERIC_FAILURE));
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(result2, Errors::NEWS_GENERIC_FAILURE));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// @test Checks that requesting china news without a valid Tencent session ticket fails
|
|
TEST_F(NEWS_MOCK_NOINIT, USNOT_RequestChinaNewsInvalidTencentSessionTicket)
|
|
{
|
|
const LoginMockNoInitScopedUninit autoUninit(*this);
|
|
{
|
|
US_NS::initializeSdk();
|
|
const ApplicationId chinaPcAppId(US_TEST_NS::SPACE_ID_US_SDK_PC_CHINA_RETAIL);
|
|
const String chinaPcBuildId("CHINA_IS_PROD");
|
|
|
|
US_NS::HttpConfig httpConfig; // Proxy needed for the manual http request to azure
|
|
httpConfig.m_proxy.m_proxyType = HttpProxyConfig::Type::Enabled;
|
|
httpConfig.m_proxy.m_host = "proxy.ubisoft.org";
|
|
httpConfig.m_proxy.m_port = 3128;
|
|
|
|
configureSdk(GameConfig(
|
|
chinaPcAppId,
|
|
chinaPcBuildId,
|
|
OnlineAccessContext::China,
|
|
GameConfigEvent(String(), US_TEST_NS::US_SDK_DUMMY_GAME_SKU, Vector<EventTypeInfo>()),
|
|
GameConfigConsole()),
|
|
SystemConfig(US_NS::ThreadingConfig(), httpConfig));
|
|
|
|
SetUpAfterInit();
|
|
mockFullLogin();
|
|
|
|
{
|
|
// Perform the login
|
|
// Those IDs are from Identity Team
|
|
// Session doesn't have to be valid for our AppId 586cc2e2-29c0-4522-8626-a1159939abe4 (UbiServices SDK PC China RETAIL)
|
|
// A valid session is only possible when using WeGame SDK
|
|
const String sessionRailId(US_TEST_NS::WEGAME_SESSION_ID);
|
|
const US_NS::String playerRailId(US_TEST_NS::WEGAME_PROFILE_RAIL_ID);
|
|
const String gameRailId(US_TEST_NS::WEGAME_GAME_RAIL_ID);
|
|
|
|
const String weGameToken(CredentialsTypeHelper::getWeGameToken(sessionRailId, playerRailId, gameRailId));
|
|
const PlayerCredentials credentials(weGameToken, CredentialsType::WeGame, playerRailId);
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(credentials, {}, {})));
|
|
waitForPostLoginCompletion();
|
|
ASSERT_TRUE(US_TEST_NS::Helper::waitForWebsocketInit(getFacade()));
|
|
|
|
const String currentSpace = getFacade().getWorkingSpaceId();
|
|
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Cannot perform request with an empty Tencent session ticket", LogLevel::Error, Times(2));
|
|
});
|
|
|
|
const AsyncResult<Vector<NewsInfo> > result = getFacade().getNewsClient().requestSpaceNewsTencent("", SpaceId(currentSpace));
|
|
const AsyncResult<Vector<NewsInfo> > result2 = getFacade().getNewsClient().requestProfileNewsTencent("", SpaceId(currentSpace));
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(result, Errors::NEWS_INVALID_PARAM));
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(result2, Errors::NEWS_INVALID_PARAM));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// @test Checks that requesting Standard news in a China online context fails
|
|
TEST_F(NEWS_MOCK_NOINIT, USNOT_RequestNewsInChinaOnlineContext)
|
|
{
|
|
const LoginMockNoInitScopedUninit autoUninit(*this);
|
|
{
|
|
US_NS::initializeSdk();
|
|
const ApplicationId chinaPcAppId(US_TEST_NS::SPACE_ID_US_SDK_PC_CHINA_RETAIL);
|
|
const String chinaPcBuildId("CHINA_IS_PROD");
|
|
|
|
US_NS::HttpConfig httpConfig; // Proxy needed for the manual http request to azure
|
|
httpConfig.m_proxy.m_proxyType = HttpProxyConfig::Type::Enabled;
|
|
httpConfig.m_proxy.m_host = "proxy.ubisoft.org";
|
|
httpConfig.m_proxy.m_port = 3128;
|
|
|
|
configureSdk(GameConfig(
|
|
chinaPcAppId,
|
|
chinaPcBuildId,
|
|
OnlineAccessContext::China,
|
|
GameConfigEvent(String(), US_TEST_NS::US_SDK_DUMMY_GAME_SKU, Vector<EventTypeInfo>()),
|
|
GameConfigConsole()),
|
|
SystemConfig(US_NS::ThreadingConfig(), httpConfig));
|
|
|
|
SetUpAfterInit();
|
|
mockFullLogin();
|
|
|
|
{
|
|
// Perform the login
|
|
// Those IDs are from Identity Team
|
|
// Session doesn't have to be valid for our AppId 586cc2e2-29c0-4522-8626-a1159939abe4 (UbiServices SDK PC China RETAIL)
|
|
// A valid session is only possible when using WeGame SDK
|
|
const String sessionRailId(US_TEST_NS::WEGAME_SESSION_ID);
|
|
const US_NS::String playerRailId(US_TEST_NS::WEGAME_PROFILE_RAIL_ID);
|
|
const String gameRailId(US_TEST_NS::WEGAME_GAME_RAIL_ID);
|
|
|
|
const String weGameToken(CredentialsTypeHelper::getWeGameToken(sessionRailId, playerRailId, gameRailId));
|
|
const PlayerCredentials credentials(weGameToken, CredentialsType::WeGame, playerRailId);
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(credentials, {}, {})));
|
|
waitForPostLoginCompletion();
|
|
ASSERT_TRUE(US_TEST_NS::Helper::waitForWebsocketInit(getFacade()));
|
|
|
|
const String currentSpace = getFacade().getWorkingSpaceId();
|
|
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Cannot perform requestNews in a China online context. Use requestNewsTencent instead", LogLevel::Error, Times(2));
|
|
});
|
|
|
|
const AsyncResult<Vector<NewsInfo> > result = getFacade().getNewsClient().requestSpaceNews(SpaceId(currentSpace));
|
|
const AsyncResult<Vector<NewsInfo> > result2 = getFacade().getNewsClient().requestProfileNews(SpaceId(currentSpace));
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(result, Errors::NEWS_GENERIC_FAILURE));
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(result2, Errors::NEWS_GENERIC_FAILURE));
|
|
}
|
|
}
|
|
}
|
|
#endif // defined(US_TARGET_WINDOWS) && defined(US_SDK_TEST_CHINA)
|
|
#endif
|
|
|
|
};
|