1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
#include "apiUrl.hpp"
#include "hearthstoneApi.hpp"
#include "hearthstoneTokenBuilder.hpp"
#include <catch2/benchmark/catch_benchmark.hpp>
#include <catch2/benchmark/catch_chronometer.hpp>
#include <catch2/benchmark/detail/catch_analyse.hpp>
#include <catch2/benchmark/detail/catch_benchmark_function.hpp>
#include <catch2/benchmark/detail/catch_estimate_clock.hpp>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_config.hpp>
#include <catch2/catch_test_macros.hpp>
#include <cstdint>
#include <fstream>
#include <nlohmann/json.hpp>
#include <string>
#include <tokenBuilder.hpp>
TEST_CASE("Retrieve number of cards", "[countCards]") {
const std::string aContentType{"cards"};
const std::string aRegion{"eu"};
bnet::ApiUrl aApiUrl(aContentType, aRegion);
aApiUrl.setLocale("fr_FR");
aApiUrl.setGameMode("constructed");
aApiUrl.setPageSize(1);
bnet::HearthstoneTokenBuilder aHearthstoneTokenBuilder("resources/credentials.json");
const nlohmann::json aResponse = bnet::HearthstoneApi::makeApiRequest(
aApiUrl, aHearthstoneTokenBuilder.allowBattleNetApiCall()
.allowUpdateSourceFile()
.buildToken()
.getToken()
->text()
.value());
REQUIRE(aResponse.size() > 0);
REQUIRE(aResponse.contains("pageCount"));
std::uint64_t aNumberOfCards{aResponse["pageCount"]};
std::uint64_t aExpectedNumberOfCards{6000};
REQUIRE(aNumberOfCards >= aExpectedNumberOfCards);
}
TEST_CASE("Retrieve page once", "[retrievePageOnce]") {
const std::string aContentType{"cards"};
const std::string aRegion{"eu"};
bnet::ApiUrl aApiUrl(aContentType, aRegion);
aApiUrl.setLocale("fr_FR");
aApiUrl.setGameMode("constructed");
aApiUrl.setPageSize(16);
bnet::HearthstoneTokenBuilder aHearthstoneTokenBuilder("resources/credentials.json");
const std::string aTokenText{aHearthstoneTokenBuilder.allowBattleNetApiCall()
.allowUpdateSourceFile()
.buildToken()
.getToken()
->text()
.value()};
const nlohmann::json aApiResponse = bnet::HearthstoneApi::makeApiRequest(aApiUrl, aTokenText);
REQUIRE(aApiResponse["cards"].size() == 16);
}
TEST_CASE("Retrieve pages 10 times without parallelization", "[retrievePagesNoParallel]") {
const std::string aContentType{"cards"};
const std::string aRegion{"eu"};
bnet::ApiUrl aApiUrl(aContentType, aRegion);
aApiUrl.setLocale("fr_FR");
aApiUrl.setGameMode("constructed");
aApiUrl.setPageSize(16);
aApiUrl.setPage("1");
bnet::HearthstoneTokenBuilder aHearthstoneTokenBuilder("resources/credentials.json");
const std::string aTokenText{aHearthstoneTokenBuilder.allowBattleNetApiCall()
.allowUpdateSourceFile()
.buildToken()
.getToken()
->text()
.value()};
bnet::json aApiResponse = bnet::HearthstoneApi::makeApiRequest(aApiUrl, aTokenText);
// Retrieve number of pages
const int aNumberOfRetrievals{10};
const int aNumberOfPages{aApiResponse["pageCount"]};
REQUIRE(aNumberOfPages >= aNumberOfRetrievals);
for (int i{1}; i < aNumberOfRetrievals; ++i) {
REQUIRE(aApiResponse["cards"].size() == 16);
aApiUrl.setPage(std::to_string(i + 1));
aApiResponse = bnet::HearthstoneApi::makeApiRequest(aApiUrl, aTokenText);
}
REQUIRE(aApiResponse["cards"].size() >= 1);
REQUIRE(aApiResponse["cards"].size() <= 16);
}
TEST_CASE("Retrieve pages 10 times with parallelization", "[retrievePagesParallel]") {
const std::string aContentType{"cards"};
const std::string aRegion{"eu"};
bnet::ApiUrl aApiUrl(aContentType, aRegion);
aApiUrl.setLocale("fr_FR");
aApiUrl.setGameMode("constructed");
aApiUrl.setPageSize(16);
aApiUrl.setPage("1");
std::vector<std::string> aRequests;
bnet::HearthstoneTokenBuilder aHearthstoneTokenBuilder("resources/credentials.json");
const std::string aTokenText{aHearthstoneTokenBuilder.allowBattleNetApiCall()
.allowUpdateSourceFile()
.buildToken()
.getToken()
->text()
.value()};
bnet::json aFirstPageJson = bnet::HearthstoneApi::makeApiRequest(aApiUrl, aTokenText);
const int aNumberOfPages{aFirstPageJson["pageCount"]};
const int aNumberOfRetrievals{10};
REQUIRE(aNumberOfPages >= aNumberOfRetrievals);
for (int i{1}; i < aNumberOfRetrievals; ++i) {
aApiUrl.setPage(std::to_string(i + 1));
aRequests.emplace_back(aApiUrl.text());
}
std::vector<nlohmann::json> aApiResponses =
bnet::HearthstoneApi::makeApiRequest(aRequests, aTokenText);
aApiResponses.emplace(aApiResponses.begin(), aFirstPageJson);
REQUIRE(aApiResponses.size() == aNumberOfRetrievals);
for (const nlohmann::json &aApiResponse : aApiResponses) {
REQUIRE(aApiResponse["cards"].size() == 16);
}
}
TEST_CASE("Merge two card lists from two page requests", "[Merge pages]") {
std::ifstream aFirstPageFile{"resources/page_merge_00.json"};
nlohmann::json aFirstPageJson = nlohmann::json::parse(aFirstPageFile);
std::ifstream aSecondPageFile{"resources/page_merge_01.json"};
const nlohmann::json aSecondPageJson = nlohmann::json::parse(aSecondPageFile);
nlohmann::json::reference aMergedCards = aFirstPageJson["cards"];
for (auto &card : aSecondPageJson["cards"]) {
aMergedCards.emplace_back(std::move(card));
}
REQUIRE(aMergedCards.size() == 32);
std::ofstream aOutputJson("build/output_pages_merge.json");
aOutputJson << aMergedCards.dump(4);
}
TEST_CASE("Retrieve a single page with HearthstoneApi::downloadCards",
"[retrievePageOnceHearthstoneApi]") {
const std::string aContentType{"cards"};
const std::string aRegion{"eu"};
bnet::ApiUrl aApiUrl(aContentType, aRegion);
aApiUrl.setPage(3);
bnet::HearthstoneTokenBuilder aHearthstoneTokenBuilder("resources/credentials.json");
const std::string aTokenText{aHearthstoneTokenBuilder.allowBattleNetApiCall()
.allowUpdateSourceFile()
.buildToken()
.getToken()
->text()
.value()};
nlohmann::json aApiResponse = bnet::HearthstoneApi::makeApiRequest(aApiUrl, aTokenText);
const nlohmann::json::size_type aExpectedNumberOfCards{aApiResponse["cards"].size()};
aApiResponse =
bnet::HearthstoneApi::downloadCards(aApiUrl, *aHearthstoneTokenBuilder.getToken());
const nlohmann::json::size_type aCurrentNumberOfCards{aApiResponse["cards"].size()};
REQUIRE(aCurrentNumberOfCards == aExpectedNumberOfCards);
}
|
