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
|
#include "apiUrl.hpp"
#include "hearthstoneApi.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 API Token", "[generateApiToken]") {
const std::string aCredentialsFile{"tests/resources/credentials.json"};
Token aToken(aCredentialsFile);
const std::string aTokenContent{aToken.text()};
const std::string::size_type aTokenSize{aTokenContent.size()};
REQUIRE(aTokenSize >= 30);
REQUIRE(aTokenSize <= 40);
}
TEST_CASE("Retrieve number of cards", "[countCards]") {
const std::string aCredentialsFile{};
const std::string aContentType{"cards"};
const std::string aRegion{"eu"};
ApiUrl aApiUrl(aContentType, aRegion);
aApiUrl.setLocale("fr_FR");
aApiUrl.setGameMode("constructed");
aApiUrl.setPageSize("1");
TokenPool::feedTokenSource("tests/resources/credentials.json");
const json aResponse =
HearthstoneApi::makeApiRequest(aApiUrl, TokenPool::build().value().text());
REQUIRE(aResponse.size() > 0);
REQUIRE(aResponse.contains("pageCount"));
std::uint64_t aNumberOfCards{aResponse["pageCount"]};
std::uint64_t aExpectedNumberOfCards{6178};
REQUIRE(aNumberOfCards == aExpectedNumberOfCards);
}
TEST_CASE("Retrieve page once", "[retrievePageOnce]") {
const std::string aCredentialsFile{"tests/resources/credentials.json"};
Token aToken(kCredentialsFile);
const std::string aContentType{"cards"};
const std::string aRegion{"eu"};
ApiUrl aApiUrl(aContentType, aRegion);
aApiUrl.setLocale("fr_FR");
aApiUrl.setGameMode("constructed");
aApiUrl.setPageSize("16");
TokenPool::feedTokenSource("tests/resources/credentials.json");
const json aApiResponse =
HearthstoneApi::makeApiRequest(aApiUrl, TokenPool::build().value().text());
REQUIRE(aApiResponse["cards"].size() == 16);
}
TEST_CASE("Retrieve pages 10 times without parallelization", "[retrievePagesNoParallel]") {
const std::string aCredentialsFile{"tests/resources/credentials.json"};
Token aToken(aCredentialsFile);
const std::string aContentType{"cards"};
const std::string aRegion{"eu"};
ApiUrl aApiUrl(aContentType, aRegion);
aApiUrl.setLocale("fr_FR");
aApiUrl.setGameMode("constructed");
aApiUrl.setPageSize("16");
aApiUrl.setPage("1");
TokenPool::feedTokenSource("tests/resources/credentials.json");
std::string aTokenText{TokenPool::build().value().text()};
json aApiResponse = 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 = 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 aCredentialsFile{"tests/resources/credentials.json"};
Token aToken(kCredentialsFile);
const std::string aContentType{"cards"};
const std::string aRegion{"eu"};
ApiUrl aApiUrl(aContentType, aRegion);
aApiUrl.setLocale("fr_FR");
aApiUrl.setGameMode("constructed");
aApiUrl.setPageSize("16");
aApiUrl.setPage("1");
std::vector<std::string> aRequests;
TokenPool::feedTokenSource("tests/resources/credentials.json");
std::string aTokenText{TokenPool::build().value().text()};
json aFirstPageJson = HearthstoneApi::makeApiRequest(aApiUrl, aTokenText);
int kNumberOfPages{aFirstPageJson["pageCount"]};
const int aNumberOfRetrievals{10};
REQUIRE(aNumberOfPages >= aNumberOfRetrievals);
for (int i{1}; i < aNumberOfRetrievals; ++i) {
aApiUrl.setPage(std::to_string(i + 1));
aRequests.push_back(aApiUrl.text());
}
std::vector<json> aApiResponses = HearthstoneApi::makeApiRequest(aRequests, aTokenText);
aApiResponses.emplace(aApiResponses.begin(), aFirstPageJson);
REQUIRE(aApiResponses.size() == aNumberOfRetrievals);
for (const json &aApiResponse : aApiResponses) {
REQUIRE(aApiResponse["cards"].size() == 16);
}
}
TEST_CASE("Merge two card lists from two page requests", "[Merge pages]") {
std::ifstream aFirstPageFile{"tests/resources/page_merge_00.json"};
json aFirstPageJson = json::parse(aFirstPageFile);
std::ifstream aSecondPageFile{"tests/resources/page_merge_01.json"};
const json aSecondPageJson = json::parse(aSecondPageFile);
json::reference aMergedCards = aFirstPageJson["cards"];
for (auto &card : aSecondPageJson["cards"]) {
aMergedCards.push_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"};
ApiUrl aApiUrl(aContentType, aRegion);
aApiUrl.setPage(3);
TokenPool::feedTokenSource("tests/resources/credentials.json");
json aApiResponse = HearthstoneApi::makeApiRequest(aApiUrl, TokenPool::build().value().text());
const json::size_type aExpectedNumberOfCards{aApiResponse["cards"].size()};
TokenPool::feedTokenSource("tests/resources/credentials.json");
aApiResponse = HearthstoneApi::downloadCards(aApiUrl, TokenPool::build().value());
const json::size_type aCurrentNumberOfCards{aApiResponse["cards"].size()};
REQUIRE(aCurrentNumberOfCards == aExpectedNumberOfCards);
}
|
