871 lines
40 KiB
C++
871 lines
40 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/authenticationFixture.h"
|
|
#include "tests/fixture/loginMockFixture.h"
|
|
#include "tests/mock/mockLogDevice.h"
|
|
#include "tests/mock/mockResultHelper.h"
|
|
#include <ubiservices/core/JSON/jsonWriter.h>
|
|
#include <ubiservices/core/types/dateTimeHelper.h>
|
|
#include <ubiservices/services/leaderboard/leaderboardClient.h>
|
|
|
|
namespace US_NS {;
|
|
US_DEFINE_TEST(TestLeadeboardClient);
|
|
|
|
typedef AuthenticationFixture<1> LEADERBOARD;
|
|
typedef AuthenticationFixture<1, false> LEADERBOARD_NOLOGIN;
|
|
typedef LoginMockFixture<true> LEADERBOARD_MOCK;
|
|
|
|
namespace TestLeaderboard_BF
|
|
{
|
|
const uint32 PROFILES_IN_LEADERBOARD = 4;
|
|
|
|
String createMockedLeaderboard()
|
|
{
|
|
struct Local
|
|
{
|
|
static Json createStanding(const char* profile, int32 rank, const char* value, int32 percentile, const DateTime& date)
|
|
{
|
|
JsonWriter standing;
|
|
standing["profileId"] = profile;
|
|
standing["rank"] = rank;
|
|
standing["value"] = value;
|
|
standing["percentile"] = percentile;
|
|
standing["lastModified"] = DateTimeHelper::formatDateISO8601(date);
|
|
return standing.getJson();
|
|
}
|
|
};
|
|
|
|
JsonWriter writer;
|
|
writer["cardinality"] = 1;
|
|
writer["startDate"] = DateTimeHelper::formatDateISO8601(DateTime(2016, 04, 25, 16, 39, 25));
|
|
writer["endDate"] = DateTimeHelper::formatDateISO8601(DateTime(2017, 04, 25, 16, 39, 25));
|
|
writer["lastModified"] = DateTimeHelper::formatDateISO8601(DateTime(2016, 10, 15, 16, 39, 25));
|
|
JsonWriter standingsWriter(JsonWriterType::Array);
|
|
standingsWriter.addItemToArray(Local::createStanding("11111111-2222-3333-4444-555566667777", 1, "dummyValue1", 10, DateTime(2016, 10, 15, 16, 10, 11)));
|
|
standingsWriter.addItemToArray(Local::createStanding("22222222-3333-4444-5555-666677778888", 2, "dummyValue2", 20, DateTime(2016, 10, 15, 16, 20, 21)));
|
|
standingsWriter.addItemToArray(Local::createStanding("33333333-4444-5555-6666-777788889999", 3, "dummyValue3", 30, DateTime(2016, 10, 15, 16, 30, 31)));
|
|
writer["standings"] = standingsWriter.getJson();
|
|
|
|
return writer.renderContent();
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// LeaderboardClient::requestLeaderboardCentered
|
|
|
|
// Enabled only on platforms using ussdk001 to create a session, since other platform's users do not have data in the leaderboard.
|
|
|
|
#if defined(US_ENABLE_UPLAY_LOGIN)
|
|
#if !defined(US_TARGET_IOS) // Except iOS because it uses Game Center ticket instead of a uplay one.
|
|
/// @test Validates that a request for a centered leaderboard retrieves the right values.
|
|
#if defined(US_CHINA_ACCOUNTS_SETUP_NOT_DONE) // Unable to add stats in china for now
|
|
TEST_F(LEADERBOARD, DISABLED_US_RequestLeaderboardCentered)
|
|
#else
|
|
TEST_F(LEADERBOARD_NOLOGIN, US_RequestLeaderboardCentered)
|
|
#endif
|
|
{
|
|
Facade facade;
|
|
const PlayerCredentials credentials("ussdk001@ubisoft.com", "a1234567"); // ussdk001 is used because it's impossible to have a leaderboard where all test accounts appear.
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(facade.createSession(credentials, {}, {})));
|
|
LeaderboardClient& client = facade.getLeaderboardClient();
|
|
const AsyncResult<LeaderboardInfo> result = client.requestLeaderboardCentered("LeaderboardTestKills",
|
|
LeaderboardClient::s_PERIOD_DEFAULT_VALUE, LeaderboardClient::s_RADIUS_DEFAULT_VALUE, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const LeaderboardInfo& leaderboard = result.getResult();
|
|
ASSERT_GT(leaderboard.m_cardinality, 0u);
|
|
ASSERT_GT(leaderboard.m_standings.size(), 0u);
|
|
|
|
for (const auto& it : leaderboard.m_standings)
|
|
{
|
|
EXPECT_GT(it.m_rank, 0u);
|
|
EXPECT_FALSE(it.m_value.isEmpty());
|
|
ASSERT_TRUE(it.m_profileId.isValid());
|
|
}
|
|
}
|
|
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardCenteredWithModifiedResponseForForwardCompatibility)
|
|
{
|
|
const char* const JSON =
|
|
"{"
|
|
" \"before\" : true,"
|
|
" \"cardinality\": 10,"
|
|
" \"standings\": ["
|
|
" {"
|
|
" \"profileId\": \"70321ba2-5c95-40e2-a68b-a20b1cacc57d\","
|
|
" \"rank\" : 2,"
|
|
" \"percentile\" : 90,"
|
|
" \"value\" : \"53\","
|
|
" \"lastModified\" : \"2017-10-04T14:49:56.151Z\""
|
|
" },"
|
|
" {"
|
|
" \"profileId\": \"a701a60d-1fd9-4c4f-98a2-b33fa8beb00f\","
|
|
" \"rank\" : 3,"
|
|
" \"value\" : \"50\","
|
|
" \"percentile\" : 80,"
|
|
" \"lastModified\" : \"2016-06-09T19:04:45.214Z\","
|
|
" \"useless\" : 5"
|
|
" }"
|
|
" ],"
|
|
" \"lastModified\" : \"2016-06-09T19:20:10.672Z\","
|
|
" \"uselessArray\": [ 1, 2, 3, 4, 5 ]"
|
|
"}";
|
|
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(JSON);
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/me/rank/mock-leaderboard", mockResult);
|
|
}
|
|
|
|
const AsyncResult<LeaderboardInfo> result = getFacade().getLeaderboardClient().requestLeaderboardCentered("dummyLeaderboard");
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
EXPECT_EQ(2ull, result.getResult().m_standings.size());
|
|
}
|
|
|
|
/// @test Validates that a request for a global centered leaderboard with filters retrieves the right values.
|
|
#if defined(US_CHINA_ACCOUNTS_SETUP_NOT_DONE) // Unable to add stats in china for now
|
|
TEST_F(LEADERBOARD, DISABLED_US_RequestLeaderboardCenteredWithFilters)
|
|
#else
|
|
TEST_F(LEADERBOARD, US_RequestLeaderboardCenteredWithFilters)
|
|
#endif
|
|
{
|
|
Facade facade;
|
|
const PlayerCredentials credentials("ussdk001@ubisoft.com", "a1234567"); // ussdk001 is used because it's impossible to have a leaderboard where all test accounts appear.
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(facade.createSession(credentials, {}, {})));
|
|
LeaderboardClient& client = facade.getLeaderboardClient();
|
|
|
|
{
|
|
const AsyncResult<LeaderboardInfo> result = client.requestLeaderboardCentered("LeaderboardTestKills",
|
|
LeaderboardClient::s_PERIOD_DEFAULT_VALUE, LeaderboardClient::s_RADIUS_DEFAULT_VALUE, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const LeaderboardInfo& leaderboard = result.getResult();
|
|
ASSERT_GT(leaderboard.m_cardinality, 0u);
|
|
ASSERT_GT(leaderboard.m_standings.size(), 0u);
|
|
}
|
|
|
|
const int32 PERIOD = -10; // The service ignores negative periods for global leader boards
|
|
|
|
// Period filter
|
|
{
|
|
const AsyncResult<LeaderboardInfo> result = client.requestLeaderboardCentered("LeaderboardTestKills", PERIOD,
|
|
LeaderboardClient::s_RADIUS_DEFAULT_VALUE, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const LeaderboardInfo& leaderboard = result.getResult();
|
|
ASSERT_GT(leaderboard.m_cardinality, 0u);
|
|
ASSERT_GT(leaderboard.m_standings.size(), 0u);
|
|
}
|
|
|
|
// Radius filter
|
|
{
|
|
const uint32 RADIUS = 2;
|
|
const AsyncResult<LeaderboardInfo> result = client.requestLeaderboardCentered("LeaderboardTestKills", PERIOD, RADIUS, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const LeaderboardInfo& leaderboard = result.getResult();
|
|
ASSERT_GT(leaderboard.m_cardinality, 0u);
|
|
|
|
// The radius passed as a filter doesn't affect the cardinality of the leaderboard, but it affects the number of standings returned.
|
|
ASSERT_EQ(leaderboard.m_standings.size(), 5u);
|
|
|
|
for (const auto& it : leaderboard.m_standings)
|
|
{
|
|
ASSERT_GT(it.m_rank, 0u);
|
|
EXPECT_FALSE(it.m_value.isEmpty());
|
|
ASSERT_TRUE(it.m_profileId.isValid());
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
// The following tests return an empty leaderboard because the profiles for the players on ps4 and xone are not in the leaderboard.
|
|
// The tests only check that the result of the resource LeaderboardClient::requestLeaderboardCentered is successful.
|
|
#else
|
|
/// @test Validates that a request for a centered leaderboard
|
|
TEST_F(LEADERBOARD, US_RequestLeaderboardCentered)
|
|
{
|
|
LeaderboardClient& client = getFacade().getLeaderboardClient();
|
|
const AsyncResult<LeaderboardInfo> result = client.requestLeaderboardCentered("LeaderboardTestKills",
|
|
LeaderboardClient::s_PERIOD_DEFAULT_VALUE, LeaderboardClient::s_RADIUS_DEFAULT_VALUE, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
ASSERT_GT(result.getResult().m_cardinality, 0u);
|
|
}
|
|
|
|
/// @test Validates that a request for a global centered leaderboard with filters retrieves the right values.
|
|
TEST_F(LEADERBOARD, US_RequestLeaderboardCenteredWithFilters)
|
|
{
|
|
LeaderboardClient& client = getFacade().getLeaderboardClient();
|
|
{
|
|
const AsyncResult<LeaderboardInfo> result = client.requestLeaderboardCentered("LeaderboardTestKills",
|
|
LeaderboardClient::s_PERIOD_DEFAULT_VALUE, LeaderboardClient::s_RADIUS_DEFAULT_VALUE, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
ASSERT_GT(result.getResult().m_cardinality, 0u);
|
|
}
|
|
|
|
const int32 PERIOD = -10; // The service ignores negative periods for global leader boards
|
|
|
|
// Period filter
|
|
{
|
|
|
|
const AsyncResult<LeaderboardInfo> result = client.requestLeaderboardCentered("LeaderboardTestKills", PERIOD,
|
|
LeaderboardClient::s_RADIUS_DEFAULT_VALUE, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
ASSERT_GT(result.getResult().m_cardinality, 0u);
|
|
}
|
|
|
|
// Radius filter
|
|
const uint32 RADIUS = 2;
|
|
{
|
|
const AsyncResult<LeaderboardInfo> result = client.requestLeaderboardCentered("LeaderboardTestKills", PERIOD, RADIUS, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
ASSERT_GT(result.getResult().m_cardinality, 0u);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/// @test Validates that an error is returned when and invalid leaderboard is requested.
|
|
TEST_F(LEADERBOARD, US_RequestLeaderboardCenteredInvalidLeaderboardName)
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Status code: 404", LogLevel::Error, Times(1));
|
|
});
|
|
|
|
LeaderboardClient& client = getFacade().getLeaderboardClient();
|
|
const AsyncResult<LeaderboardInfo> result = client.requestLeaderboardCentered("DummyLeaderboardName",
|
|
LeaderboardClient::s_PERIOD_DEFAULT_VALUE, LeaderboardClient::s_RADIUS_DEFAULT_VALUE, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(result, Errors::SERVICE_INVALID_PARAMETER));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// LeaderboardClient::requestLeaderboardProfiles
|
|
|
|
/// @test Validates that a request for a leaderboard with profiles retrieves the right values.
|
|
#if defined(US_CHINA_ACCOUNTS_SETUP_NOT_DONE) // Unable to add stats in china for now
|
|
TEST_F(LEADERBOARD, DISABLED_US_RequestLeaderboardProfiles)
|
|
#else
|
|
TEST_F(LEADERBOARD, US_RequestLeaderboardProfiles)
|
|
#endif
|
|
{
|
|
struct Local
|
|
{
|
|
static void performRequest(LeaderboardClient& client, const int32 period, LeaderboardInfo& output)
|
|
{
|
|
const Vector<ProfileId> profiles =
|
|
{
|
|
ProfileId("a701a60d-1fd9-4c4f-98a2-b33fa8beb00f"), // ussdk003
|
|
ProfileId("89bca67a-0b27-48f1-9510-b74f205304b9"), // ussdk005
|
|
ProfileId("a03ace35-876a-4fbf-a4ce-9abb8e8f53bb"), // ussdk007
|
|
ProfileId("b3c2d82b-9cfb-4372-a852-c4d030c9a804"), // ussdk009
|
|
ProfileId("223866e1-73a1-4734-87e5-6d1d27be5474"), // ussdk011: This profile is not on the leader board. So the services shouldn't return it.
|
|
};
|
|
auto result = client.requestLeaderboardProfiles("LeaderboardTestKills", profiles, period, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const LeaderboardInfo& leaderboard = result.getResult();
|
|
ASSERT_GT(leaderboard.m_cardinality, 0u);
|
|
ASSERT_EQ(TestLeaderboard_BF::PROFILES_IN_LEADERBOARD, leaderboard.m_standings.size());
|
|
|
|
for (const auto& it : leaderboard.m_standings)
|
|
{
|
|
ASSERT_GT(it.m_rank, 0u);
|
|
EXPECT_FALSE(it.m_value.isEmpty());
|
|
ASSERT_TRUE(it.m_profileId.isValid());
|
|
}
|
|
|
|
output = leaderboard;
|
|
}
|
|
};
|
|
|
|
LeaderboardInfo result1;
|
|
LeaderboardInfo result2;
|
|
Local::performRequest(getFacade().getLeaderboardClient(), LeaderboardClient::s_PERIOD_DEFAULT_VALUE, result1);
|
|
Local::performRequest(getFacade().getLeaderboardClient(), -10, result2); // The service ignores negative periods for global leader boards
|
|
|
|
{ // Compare both results (which should be the same)
|
|
ASSERT_EQ(result1.m_standings.size(), result2.m_standings.size());
|
|
//EXPECT_THAT(result1.getResult().m_standings, ::testing::ContainerEq(result2.getResult().m_standings));
|
|
|
|
auto it2 = result2.m_standings.begin();
|
|
for (const auto& it1 : result1.m_standings)
|
|
{
|
|
EXPECT_EQ(it1.m_rank, it2->m_rank);
|
|
++it2;
|
|
}
|
|
|
|
EXPECT_EQ(result1.m_cardinality, result2.m_cardinality);
|
|
EXPECT_EQ(result1.m_startDate, result2.m_startDate);
|
|
EXPECT_EQ(result1.m_endDate, result2.m_endDate);
|
|
EXPECT_EQ(result1.m_lastModified, result2.m_lastModified);
|
|
}
|
|
}
|
|
|
|
/// @test Validates that an error is returned when and invalid leaderboard is requested.
|
|
TEST_F(LEADERBOARD, US_RequestLeaderboardProfilesInvalidLeaderboardName)
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Status code: 404", LogLevel::Error, Times(1));
|
|
});
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(getFacade().getLeaderboardClient().requestLeaderboardProfiles(
|
|
"DummyLeaderboardName",
|
|
{ ProfileId("a701a60d-1fd9-4c4f-98a2-b33fa8beb00f") }, // ussdk003
|
|
LeaderboardClient::s_PERIOD_DEFAULT_VALUE, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC)),
|
|
Errors::SERVICE_INVALID_PARAMETER));
|
|
}
|
|
|
|
/// @test Validates that passing an invalid GUID for ProdileId returns an error.
|
|
TEST_F(LEADERBOARD, US_RequestLeaderboardProfilesWithInvalidGUID)
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Status code: 400", LogLevel::Error, Times(1));
|
|
});
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(getFacade().getLeaderboardClient().requestLeaderboardProfiles(
|
|
"LeaderboardTestKills",
|
|
{ ProfileId("11111111-2222-3333-4444-555566667777") }),
|
|
Errors::SERVICE_INVALID_PARAMETER));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// LeaderboardClient::requestLeaderboard
|
|
|
|
/// @test Validates that a request for a leaderboard retrieves the right values.
|
|
#if defined(US_CHINA_ACCOUNTS_SETUP_NOT_DONE) // Unable to add stats in china for now
|
|
TEST_F(LEADERBOARD, DISABLED_US_RequestLeaderboard)
|
|
#else
|
|
TEST_F(LEADERBOARD, US_MINRUN_RequestLeaderboard)
|
|
#endif
|
|
{
|
|
const AsyncResult<LeaderboardInfo> result = getFacade().getLeaderboardClient().requestLeaderboard("LeaderboardTestKills",
|
|
LeaderboardClient::s_PERIOD_DEFAULT_VALUE, ResultRange(1, 10), SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const LeaderboardInfo& leaderboard = result.getResult();
|
|
ASSERT_GT(leaderboard.m_cardinality, 0u);
|
|
ASSERT_GT(leaderboard.m_standings.size(), 0u);
|
|
|
|
for (const auto& it : leaderboard.m_standings)
|
|
{
|
|
ASSERT_GT(it.m_rank, 0u);
|
|
EXPECT_FALSE(it.m_value.isEmpty());
|
|
ASSERT_TRUE(it.m_profileId.isValid());
|
|
}
|
|
}
|
|
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardWithModifiedResponseForForwardCompatibility)
|
|
{
|
|
const char* const JSON =
|
|
"{"
|
|
" \"before\" : true,"
|
|
" \"cardinality\": 10,"
|
|
" \"standings\": ["
|
|
" {"
|
|
" \"profileId\": \"327f0a1e-afe3-46b2-a631-c3e3308247cf\","
|
|
" \"rank\" : 1,"
|
|
" \"value\" : \"70\","
|
|
" \"percentile\" : 100,"
|
|
" \"lastModified\" : \"2016-06-09T19:18:00.452Z\""
|
|
" },"
|
|
" {"
|
|
" \"profileId\": \"70321ba2-5c95-40e2-a68b-a20b1cacc57d\","
|
|
" \"rank\" : 2,"
|
|
" \"value\" : \"53\","
|
|
" \"percentile\" : 90,"
|
|
" \"uselessArray\" : [ 1, 2, 3, 4, 5],"
|
|
" \"lastModified\" : \"2017-10-04T14:49:56.151Z\""
|
|
" },"
|
|
" {"
|
|
" \"profileId\": \"a701a60d-1fd9-4c4f-98a2-b33fa8beb00f\","
|
|
" \"value\" : \"50\","
|
|
" \"percentile\" : 80,"
|
|
" \"rank\" : 3,"
|
|
" \"uselessData\" : true,"
|
|
" \"lastModified\" : \"2016-06-09T19:04:45.214Z\""
|
|
" }"
|
|
" ],"
|
|
" \"other\" : {},"
|
|
" \"lastModified\" : \"2016-06-09T19:20:10.672Z\""
|
|
"}";
|
|
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(JSON);
|
|
StringStream url;
|
|
url << "/spaces/" << US_TEST_NS::SPACE_ID_US_SDK_PC << "/leaderboard/mock-leaderboard";
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, url.getContent(), mockResult);
|
|
}
|
|
|
|
ResultRange defaultRange(1, 10);
|
|
const AsyncResult<LeaderboardInfo> result = getFacade().getLeaderboardClient().requestLeaderboard("LeaderboardTestKills",
|
|
LeaderboardClient::s_PERIOD_DEFAULT_VALUE, defaultRange, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const LeaderboardInfo& leaderboard = result.getResult();
|
|
ASSERT_GT(leaderboard.m_cardinality, 0u);
|
|
ASSERT_GT(leaderboard.m_standings.size(), 0u);
|
|
|
|
for (const auto& it : leaderboard.m_standings)
|
|
{
|
|
ASSERT_GT(it.m_rank, 0u);
|
|
EXPECT_FALSE(it.m_value.isEmpty());
|
|
ASSERT_TRUE(it.m_profileId.isValid());
|
|
}
|
|
}
|
|
|
|
/// @test Validates that a request for a leaderboard with all the filters retrieves the right values.
|
|
#if defined(US_CHINA_ACCOUNTS_SETUP_NOT_DONE) // Unable to add stats in china for now
|
|
TEST_F(LEADERBOARD, DISABLED_US_RequestLeaderboardWithFilters)
|
|
#else
|
|
TEST_F(LEADERBOARD, US_RequestLeaderboardWithFilters)
|
|
#endif
|
|
{
|
|
const int32 PERIOD = -10; // The service ignores negative periods for global leader boards
|
|
const AsyncResult<LeaderboardInfo> result = getFacade().getLeaderboardClient().requestLeaderboard("LeaderboardTestKills",
|
|
PERIOD, ResultRange(1, 4), SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const LeaderboardInfo& leaderboard = result.getResult();
|
|
ASSERT_GT(leaderboard.m_cardinality, 0u);
|
|
ASSERT_EQ(4u, leaderboard.m_standings.size());
|
|
|
|
for (const auto& it : leaderboard.m_standings)
|
|
{
|
|
ASSERT_GT(it.m_rank, 0u);
|
|
EXPECT_FALSE(it.m_value.isEmpty());
|
|
ASSERT_TRUE(it.m_profileId.isValid());
|
|
}
|
|
}
|
|
|
|
// {
|
|
// "standings": [
|
|
// { "profileId": "327f0a1e-afe3-46b2-a631-c3e3308247cf", "rank": 1, "value": "70", "percentile": 100, "lastModified": "2016-06-09T19:18:00.452Z" },
|
|
// { "profileId": "70321ba2-5c95-40e2-a68b-a20b1cacc57d", "rank": 2, "value": "53", "percentile": 90, "lastModified": "2016-06-09T19:26:00.374Z" },
|
|
// { "profileId": "a701a60d-1fd9-4c4f-98a2-b33fa8beb00f", "rank": 3, "value": "50", "percentile": 80, "lastModified": "2016-06-09T19:04:45.214Z" },
|
|
// { "profileId": "70e8ed8e-90f0-44cf-b472-c15ac1411b13", "rank": 4, "value": "42", "percentile": 70, "lastModified": "2016-06-09T20:53:50.096Z" },
|
|
// { "profileId": "b3c2d82b-9cfb-4372-a852-c4d030c9a804", "rank": 5, "value": "42", "percentile": 60, "lastModified": "2016-06-09T20:55:34.934Z" },
|
|
// { "profileId": "fa6fd9aa-7726-4e83-a08f-ee61523c6cfa", "rank": 6, "value": "42", "percentile": 50, "lastModified": "2016-06-09T20:57:20.037Z" },
|
|
// { "profileId": "4d9061de-7c20-4cc9-9f55-b8d6228da6ae", "rank": 7, "value": "30", "percentile": 40, "lastModified": "2016-06-08T20:33:09.665Z" },
|
|
// { "profileId": "b2cfc7a1-a08e-4bd8-adf3-73cb1c19faf1", "rank": 8, "value": "25", "percentile": 30, "lastModified": "2016-06-08T21:09:56.608Z" },
|
|
// { "profileId": "a03ace35-876a-4fbf-a4ce-9abb8e8f53bb", "rank": 9, "value": "15", "percentile": 20, "lastModified": "2016-06-09T19:24:10.405Z" },
|
|
// { "profileId": "89bca67a-0b27-48f1-9510-b74f205304b9", "rank": 10, "value": "6", "percentile": 10, "lastModified": "2016-06-09T19:20:10.672Z" }
|
|
// ],
|
|
// "cardinality": 10,
|
|
// "lastModified": "2016-06-09T19:20:10.672Z"
|
|
// }
|
|
|
|
/// @test Validates that a request for a leaderboard with specific percentiles retrieves the right values.
|
|
#if defined(US_CHINA_ACCOUNTS_SETUP_NOT_DONE) // Unable to add stats in china for now
|
|
TEST_F(LEADERBOARD, DISABLED_US_RequestLeaderboardFromPercentiles)
|
|
#else
|
|
TEST_F(LEADERBOARD, US_RequestLeaderboardFromPercentiles)
|
|
#endif
|
|
{
|
|
const int32 PERIOD = 0;
|
|
const String name = "LeaderboardTestKills";
|
|
|
|
LeaderboardClient& client = getFacade().getLeaderboardClient();
|
|
|
|
{ // Top percentiles
|
|
const AsyncResult<LeaderboardInfo> result = client.requestLeaderboard(name, Vector<uint32>({ 100u, 90u }), PERIOD, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const LeaderboardInfo& leaderboard = result.getResult();
|
|
ASSERT_EQ(2u, leaderboard.m_standings.size());
|
|
EXPECT_EQ(ProfileId("b3c2d82b-9cfb-4372-a852-c4d030c9a804"), leaderboard.m_standings[0].m_profileId);
|
|
EXPECT_EQ(ProfileId("327f0a1e-afe3-46b2-a631-c3e3308247cf"), leaderboard.m_standings[1].m_profileId);
|
|
}
|
|
{ // Middle percentile
|
|
const AsyncResult<LeaderboardInfo> result = client.requestLeaderboard(name, Vector<uint32>({ 50u }), PERIOD, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const LeaderboardInfo& leaderboard = result.getResult();
|
|
ASSERT_EQ(1u, leaderboard.m_standings.size());
|
|
EXPECT_EQ(ProfileId("70e8ed8e-90f0-44cf-b472-c15ac1411b13"), leaderboard.m_standings[0].m_profileId);
|
|
}
|
|
{ // Bottom percentiles
|
|
const AsyncResult<LeaderboardInfo> result = client.requestLeaderboard(name, Vector<uint32>({ 10u, 30u }), PERIOD, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const LeaderboardInfo& leaderboard = result.getResult();
|
|
ASSERT_EQ(2u, leaderboard.m_standings.size());
|
|
EXPECT_EQ(ProfileId("89bca67a-0b27-48f1-9510-b74f205304b9"), leaderboard.m_standings[0].m_profileId);
|
|
EXPECT_EQ(ProfileId("b2cfc7a1-a08e-4bd8-adf3-73cb1c19faf1"), leaderboard.m_standings[1].m_profileId);
|
|
}
|
|
}
|
|
|
|
TEST_F(LEADERBOARD, US_RequestLeaderboardFromPercentilesEmptyVector)
|
|
{
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(getFacade().getLeaderboardClient().requestLeaderboard("LeaderboardTestKills", Vector<uint32>()), Errors::LEADERBOARD_INVALID_PARAM));
|
|
}
|
|
|
|
/// @test Validates that an error is returned when and invalid leaderboard is requested.
|
|
TEST_F(LEADERBOARD, US_RequestLeaderboardInvalidLeaderboardName)
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Status code: 404", LogLevel::Error, Times(1));
|
|
});
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(getFacade().getLeaderboardClient().requestLeaderboard(
|
|
"DummyName", LeaderboardClient::s_PERIOD_DEFAULT_VALUE, ResultRange(1, 10), SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC)),
|
|
Errors::SERVICE_INVALID_PARAMETER));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Mocked tests and others
|
|
|
|
/// @test Validates that no error is returned when no profile has data in the leaderboard.
|
|
TEST_F(LEADERBOARD, US_RequestLeaderboardProfilesNoProfilesWithData)
|
|
{
|
|
const Vector<ProfileId> profiles =
|
|
{
|
|
ProfileId("223866e1-73a1-4734-87e5-6d1d27be5474"), // ussdk011
|
|
ProfileId("78137095-22b6-4fe7-a03a-bf36e1e15e11"), // ussdk012
|
|
ProfileId("f0616052-be85-400e-8c3e-48e6c0d9a3f9") // ussdk013
|
|
};
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().getLeaderboardClient().requestLeaderboardProfiles(
|
|
"LeaderboardTestKills", profiles, LeaderboardClient::s_PERIOD_DEFAULT_VALUE, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC))));
|
|
}
|
|
|
|
#if defined(US_ENABLE_UPLAY_LOGIN)
|
|
/// @test Validates that no error is returned when the current profile has no data in the leaderboard.
|
|
TEST_F(LEADERBOARD_NOLOGIN, US_RequestLeaderboardCenteredNoProfilesWithData)
|
|
{
|
|
// For now this test work because we have no stats in China but when this profile will have stats we will need to set up another one and replace this one
|
|
#if defined(US_CHINA_ACCOUNTS_SETUP_NOT_DONE)
|
|
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(PlayerCredentials(credentials), {}, {})));
|
|
#else
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(PlayerCredentials("ussdk011@ubisoft.com", "a1234567"), {}, {})));
|
|
#endif
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().getLeaderboardClient().requestLeaderboardCentered(
|
|
"LeaderboardTestKills", LeaderboardClient::s_PERIOD_DEFAULT_VALUE, LeaderboardClient::s_RADIUS_DEFAULT_VALUE, SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC))));
|
|
}
|
|
#endif
|
|
|
|
/// @test Validates that passing an invalid period returns an error.
|
|
TEST_F(LEADERBOARD_MOCK, LOCAL_RequestLeaderboardWithInvalidPeriod)
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Invalid period: 5, cannot be greater that 0.", LogLevel::Error, Times(1));
|
|
});
|
|
|
|
const int32 INVALID_PERIOD = 5;
|
|
// if the period is greater than 0 the request will not be sent.
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(getFacade().getLeaderboardClient().requestLeaderboardCentered(
|
|
"LeaderboardTestKills", INVALID_PERIOD), Errors::LEADERBOARD_INVALID_PARAM));
|
|
}
|
|
|
|
/// @test Validates that a request for a centered leaderboard retrieves the right values.
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardCenteredNoFilter)
|
|
{
|
|
{
|
|
const String jsonBody = TestLeaderboard_BF::createMockedLeaderboard();
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(jsonBody);
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/me/rank/mock-leaderboard", mockResult);
|
|
}
|
|
|
|
const AsyncResult<LeaderboardInfo> result = getFacade().getLeaderboardClient().requestLeaderboardCentered("dummyLeaderboard");
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
EXPECT_EQ(3ull, result.getResult().m_standings.size());
|
|
}
|
|
|
|
/// @test Validates that a request for a leaderboard with profiles retrieves the right values.
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardProfilesNoFilter)
|
|
{
|
|
{
|
|
const String jsonBody = TestLeaderboard_BF::createMockedLeaderboard();
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(jsonBody);
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/rank/mock-leaderboard", mockResult);
|
|
}
|
|
|
|
const AsyncResult<LeaderboardInfo> result = getFacade().getLeaderboardClient().requestLeaderboardProfiles(
|
|
"dummyLeaderboard", { ProfileId("ae3c2a1e-d29a-4f25-9549-848617ffecda") });
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
EXPECT_EQ(3ull, result.getResult().m_standings.size());
|
|
}
|
|
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardProfilesNoFilterWithModifiedResponseForForwardCompatibility)
|
|
{
|
|
const char* const JSON =
|
|
"{"
|
|
" \"before\" : true,"
|
|
" \"cardinality\": 1,"
|
|
" \"startDate\" : \"2016-04-25T16:39:25\","
|
|
" \"standings\" : ["
|
|
" {"
|
|
" \"profileId\": \"11111111-2222-3333-4444-555566667777\","
|
|
" \"rank\" : 1,"
|
|
" \"value\" : \"dummyValue1\","
|
|
" \"percentile\" : 10,"
|
|
" \"lastModified\" : \"2016-10-15T16:10:11\""
|
|
" },"
|
|
" {"
|
|
" \"profileId\": \"22222222-3333-4444-5555-666677778888\","
|
|
" \"rank\" : 2,"
|
|
" \"value\" : \"dummyValue2\","
|
|
" \"percentile\" : 20,"
|
|
" \"uselessArray\" : [ 1, 2, 3, 4, 5],"
|
|
" \"lastModified\" : \"2016-10-15T16:20:21\""
|
|
" },"
|
|
" {"
|
|
" \"profileId\": \"33333333-4444-5555-6666-777788889999\","
|
|
" \"value\" : \"dummyValue3\","
|
|
" \"percentile\" : 30,"
|
|
" \"rank\" : 3,"
|
|
" \"lastModified\" : \"2016-10-15T16:30:31\""
|
|
" }"
|
|
" ],"
|
|
" \"endDate\" : \"2017-04-25T16:39:25\","
|
|
" \"lastModified\" : \"2016-10-15T16:39:25\","
|
|
" \"other\" : true"
|
|
"}";
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(JSON);
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/rank/mock-leaderboard", mockResult);
|
|
}
|
|
|
|
const AsyncResult<LeaderboardInfo> result = getFacade().getLeaderboardClient().requestLeaderboardProfiles(
|
|
"dummyLeaderboard", { ProfileId("ae3c2a1e-d29a-4f25-9549-848617ffecda") });
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
EXPECT_EQ(3ull, result.getResult().m_standings.size());
|
|
}
|
|
|
|
/// @test Validates that a request for a leaderboard retrieves the right values.
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardNoFilter)
|
|
{
|
|
{
|
|
const String jsonBody = TestLeaderboard_BF::createMockedLeaderboard();
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(jsonBody);
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/leaderboard/mock-leaderboard", mockResult);
|
|
}
|
|
|
|
const AsyncResult<LeaderboardInfo> result = getFacade().getLeaderboardClient().requestLeaderboard("dummyLeaderboard");
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
EXPECT_EQ(3ull, result.getResult().m_standings.size());
|
|
}
|
|
|
|
/// @test Validates that an invalid profileId on requestLeaderboardProfiles returns an error.
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardProfilesWithInvalidProfile)
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Invalid Profile Id removed from the request: dummyProfile", LogLevel::Warning, Times(1));
|
|
US_EXPECT_LOG("No valid ProfileId given. Cannot retrieve leaderboard", LogLevel::Error, Times(1));
|
|
US_EXPECT_LOG("Couldn't build url to retrieve Leaderboards", LogLevel::Error, Times(1));
|
|
});
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(getFacade().getLeaderboardClient().requestLeaderboardProfiles(
|
|
"DummyLeaderboard", { ProfileId("dummyProfile") }), Errors::LEADERBOARD_INVALID_PARAM));
|
|
}
|
|
|
|
/// @test Validates that an invalid spaceId on requestLeaderboard returns an error.
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardWithInvalidSpaceId)
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Cannot perform request with invalid space Id \"DummySpaceId\"", LogLevel::Error, Times(1));
|
|
});
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(getFacade().getLeaderboardClient().requestLeaderboard(
|
|
"DummyLeaderboard", LeaderboardClient::s_PERIOD_DEFAULT_VALUE, ResultRange(1,10), SpaceId("DummySpaceId")),
|
|
Errors::LEADERBOARD_INVALID_PARAM));
|
|
}
|
|
|
|
/// @test Validates that a request for a leaderboard with more profiles than 50 returns an error.
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardWithTooManyProfiles)
|
|
{
|
|
Vector<ProfileId> ids;
|
|
const uint32 TOO_MANY_IDS = 51;
|
|
ids.reserve(TOO_MANY_IDS);
|
|
for (uint32 i = 0; i < TOO_MANY_IDS; i++)
|
|
{
|
|
ids.push_back(ProfileId());
|
|
}
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(getFacade().getLeaderboardClient().requestLeaderboardProfiles(
|
|
"DummyLeaderboard", ids), Errors::LEADERBOARD_TOO_MANY_IDS));
|
|
}
|
|
|
|
/// @test Checks the maximum number of request in parallel is allowed and cannot be exceeded.
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardsInParallel)
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Max capacity: 4", LogLevel::Error, Times(1));
|
|
});
|
|
|
|
const uint32 MAX_LEADERBOARD_CALLS = 4;
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createPendingResult();
|
|
US_EXPECT_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/leaderboard/mock-leaderboard")
|
|
.Times(MAX_LEADERBOARD_CALLS)
|
|
.WillRepeatedly(testing::Return(mockResult));
|
|
}
|
|
|
|
LeaderboardClient& client = getFacade().getLeaderboardClient();
|
|
|
|
{
|
|
// Proceed to max calls (pending to avoid flaky result of the test)
|
|
Vector<AsyncResult<LeaderboardInfo> > results;
|
|
results.reserve(MAX_LEADERBOARD_CALLS);
|
|
for (uint32 i = 0; i < MAX_LEADERBOARD_CALLS; i++)
|
|
{
|
|
results.push_back(client.requestLeaderboard("DummyLeaderboard"));
|
|
}
|
|
|
|
// Checks that a new call returns immediately an error
|
|
const AsyncResult<LeaderboardInfo> result = client.requestLeaderboard("dummyLeaderboard");
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(result, Errors::CORE_TOO_MANY_JOBS_IN_PROGRESS));
|
|
|
|
// Checks that the other calls are still pending (no error returned immediately)
|
|
US_TEST_NS::Helper::sleep(100); // necessary to let the time for the scheduler to reach all HTTP requests
|
|
for (const auto& it : results)
|
|
{
|
|
EXPECT_TRUE(it.isProcessing());
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardPredictionWithModifiedResponseForForwardCompatibility)
|
|
{
|
|
const char* const JSON =
|
|
"{"
|
|
" \"before\" : true,"
|
|
" \"cardinality\": 1,"
|
|
" \"percentile\" : 1,"
|
|
" \"startDate\" : \"2016-04-25T16:39:25\","
|
|
" \"endDate\" : \"2017-04-25T16:39:25\","
|
|
" \"rank\" : 1,"
|
|
" \"value\" : \"100\","
|
|
" \"lastModified\" : \"2016-10-15T16:39:25\","
|
|
" \"uselessArray\" : [ 1, 2, 3, 4, 5 ]"
|
|
"}";
|
|
|
|
{
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(JSON);
|
|
StringStream url;
|
|
url << "/spaces/" << US_TEST_NS::SPACE_ID_US_SDK_PC << "/leaderboard/mock-leaderboard";
|
|
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, url.getContent(), mockResult);
|
|
}
|
|
|
|
const AsyncResult<LeaderboardPrediction> result = getFacade().getLeaderboardClient().requestPrediction("dummyLeaderboard", "dummyStats", SpaceId(US_TEST_NS::SPACE_ID_US_SDK_PC));
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
/*EXPECT_EQ(2ull, result.getResult().m_standings.size());*/
|
|
}
|
|
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardPrediction)
|
|
{
|
|
{
|
|
JsonWriter writer;
|
|
writer["cardinality"] = 1;
|
|
writer["percentile"] = 10;
|
|
writer["rank"] = 2;
|
|
writer["value"] = "1337.5";
|
|
writer["startDate"] = DateTimeHelper::formatDateISO8601(DateTime(2016, 04, 25, 16, 39, 25));
|
|
writer["endDate"] = DateTimeHelper::formatDateISO8601(DateTime(2017, 04, 25, 16, 39, 25));
|
|
|
|
String jsonBody = writer.renderContent();
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(jsonBody);
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/leaderboard/mock-leaderboard/dummyLeaderboard/prediction/1337.5", mockResult);
|
|
}
|
|
|
|
const AsyncResult<LeaderboardPrediction> result = getFacade().getLeaderboardClient().requestPrediction("dummyLeaderboard", "1337.5");
|
|
ASSERT_TRUE(AsyncHelper::waitSuccess(result));
|
|
|
|
const LeaderboardPrediction& prediction = result.getResult();
|
|
|
|
EXPECT_EQ(1ull, prediction.m_cardinality);
|
|
EXPECT_EQ(10ull, prediction.m_percentile);
|
|
EXPECT_EQ(2ull, prediction.m_rank);
|
|
EXPECT_EQ("1337.5", prediction.m_value);
|
|
EXPECT_EQ(DateTime(2016, 04, 25, 16, 39, 25), result.getResult().m_startDate);
|
|
EXPECT_EQ(DateTime(2017, 04, 25, 16, 39, 25), result.getResult().m_endDate);
|
|
}
|
|
|
|
/// @test Validates that requestPrediction with missing fields in response returns an error.
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardPredictionWithMissingFields)
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Request Leaderboard failed. Unexpected JSON in response's body", LogLevel::Error, Times(1));
|
|
US_EXPECT_LOG("Missing mandatory field: percentile", LogLevel::Error, Times(1));
|
|
US_EXPECT_LOG("Missing mandatory field: rank", LogLevel::Error, Times(1));
|
|
});
|
|
|
|
{
|
|
JsonWriter writer;
|
|
writer["cardinality"] = 1;
|
|
writer["value"] = "1337.5";
|
|
writer["startDate"] = DateTimeHelper::formatDateISO8601(DateTime(2016, 04, 25, 16, 39, 25));
|
|
writer["endDate"] = DateTimeHelper::formatDateISO8601(DateTime(2017, 04, 25, 16, 39, 25));
|
|
String jsonBody = writer.renderContent();
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(jsonBody);
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/leaderboard/mock-leaderboard/dummyLeaderboard/prediction/1337.5", mockResult);
|
|
}
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(getFacade().getLeaderboardClient().requestPrediction("dummyLeaderboard", "1337.5"), Errors::CORE_INVALID_JSON_FORMAT));
|
|
}
|
|
|
|
/// @test Validates that requestPrediction with an invalid spaceId returns an error.
|
|
TEST_F(LEADERBOARD_MOCK, USNOT_RequestLeaderboardPredictionWithInvalidSpaceId)
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Cannot perform request with invalid space Id \"DummySpaceId\"", LogLevel::Error, Times(1));
|
|
});
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(getFacade().getLeaderboardClient().requestPrediction("dummyLeaderboard", "1337", SpaceId("DummySpaceId")), Errors::LEADERBOARD_INVALID_PARAM));
|
|
}
|
|
|
|
/// @test Validates that requestPrediction with an invalid leaderboardName returns an error.
|
|
TEST_F(LEADERBOARD, US_RequestLeaderboardPredictionWithInvalidLeaderboardName)
|
|
{
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Status code: 404", LogLevel::Error, Times(1));
|
|
});
|
|
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(getFacade().getLeaderboardClient().requestPrediction("DummyLeaderboardName", "1337"), Errors::SERVICE_INVALID_PARAMETER));
|
|
}
|
|
|
|
TEST_F(LEADERBOARD_MOCK, US_RequestLeaderboardPredictionWithInvalidResponseValue)
|
|
{
|
|
{
|
|
JsonWriter writer;
|
|
writer["cardinality"] = 1;
|
|
writer["percentile"] = 10;
|
|
writer["rank"] = 2;
|
|
writer["value"] = "1337.5";
|
|
writer["startDate"] = "DummyValue";
|
|
writer["endDate"] = DateTimeHelper::formatDateISO8601(DateTime(2017, 04, 25, 16, 39, 25));
|
|
|
|
const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(writer.renderContent());
|
|
US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/leaderboard/mock-leaderboard/dummyLeaderboard/prediction/1337.5", mockResult);
|
|
|
|
PrepareLoggingMock([](US_TEST_NS::MockLogDevice& device)
|
|
{
|
|
US_EXPECT_LOG("Invalid Date (ISO 8601)", LogLevel::Warning, Times(1));
|
|
US_EXPECT_LOG("Request Leaderboard failed. Unexpected JSON in response's body", LogLevel::Error, Times(1));
|
|
});
|
|
}
|
|
|
|
const AsyncResult<LeaderboardPrediction> result = getFacade().getLeaderboardClient().requestPrediction("dummyLeaderboard", "1337.5");
|
|
ASSERT_TRUE(AsyncHelper::waitFailure(result, Errors::CORE_INVALID_JSON_FORMAT));
|
|
}
|
|
|
|
};
|