chatterino2
Code Issues

Refactor tests and benchmarks (#4700)

Browse Source
This commit is contained in:
nerix
2023-06-24 15:03:27 +02:00
committed by GitHub
parent 5d3e5d9312
commit b9934a4532
8 changed files with 109 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/src/NetworkRequest.cpp
+95 -162
View File
@@ -3,17 +3,18 @@
#include "common/NetworkManager.hpp"
#include "common/NetworkResult.hpp"
#include "common/Outcome.hpp"
#include "common/QLogging.hpp"
#include "providers/twitch/api/Helix.hpp"
#include <gtest/gtest.h>
#include <QCoreApplication>
using namespace chatterino;
namespace {
#ifdef CHATTERINO_TEST_USE_PUBLIC_HTTPBIN
const char *const HTTPBIN_BASE_URL = "http://httpbin.org";
// Not using httpbin.org, since it can be really slow and cause timeouts.
// postman-echo has the same API.
const char *const HTTPBIN_BASE_URL = "https://postman-echo.com";
#else
const char *const HTTPBIN_BASE_URL = "http://127.0.0.1:9051";
#endif
@@ -28,6 +29,46 @@ QString getDelayURL(int delay)
return QString("%1/delay/%2").arg(HTTPBIN_BASE_URL).arg(delay);
}
class RequestWaiter
{
public:
void requestDone()
{
{
std::unique_lock lck(this->mutex_);
ASSERT_FALSE(this->requestDone_);
this->requestDone_ = true;
}
this->condition_.notify_one();
}
void waitForRequest()
{
using namespace std::chrono_literals;
while (true)
{
{
std::unique_lock lck(this->mutex_);
bool done = this->condition_.wait_for(lck, 10ms, [this] {
return this->requestDone_;
});
if (done)
{
break;
}
}
QCoreApplication::processEvents(QEventLoop::AllEvents);
QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
}
}
private:
std::mutex mutex_;
std::condition_variable condition_;
bool requestDone_ = false;
};
} // namespace
TEST(NetworkRequest, Success)
@@ -39,39 +80,23 @@ TEST(NetworkRequest, Success)
for (const auto code : codes)
{
auto url = getStatusURL(code);
std::mutex mut;
bool requestDone = false;
std::condition_variable requestDoneCondition;
RequestWaiter waiter;
NetworkRequest(url)
.onSuccess([code, &mut, &requestDone, &requestDoneCondition,
url](NetworkResult result) -> Outcome {
EXPECT_EQ(result.status(), code);
{
std::unique_lock lck(mut);
requestDone = true;
}
requestDoneCondition.notify_one();
return Success;
})
.onError([&](NetworkResult result) {
.onSuccess(
[code, &waiter, url](const NetworkResult &result) -> Outcome {
EXPECT_EQ(result.status(), code);
waiter.requestDone();
return Success;
})
.onError([&](const NetworkResult & /*result*/) {
// The codes should *not* throw an error
EXPECT_TRUE(false);
{
std::unique_lock lck(mut);
requestDone = true;
}
requestDoneCondition.notify_one();
waiter.requestDone();
})
.execute();
// Wait for the request to finish
std::unique_lock lck(mut);
requestDoneCondition.wait(lck, [&requestDone] {
return requestDone;
});
waiter.waitForRequest();
}
EXPECT_TRUE(NetworkManager::workerThread.isRunning());
@@ -86,30 +111,18 @@ TEST(NetworkRequest, FinallyCallbackOnSuccess)
for (const auto code : codes)
{
auto url = getStatusURL(code);
std::mutex mut;
bool requestDone = false;
std::condition_variable requestDoneCondition;
RequestWaiter waiter;
bool finallyCalled = false;
NetworkRequest(url)
.finally(
[&mut, &requestDone, &requestDoneCondition, &finallyCalled] {
finallyCalled = true;
{
std::unique_lock lck(mut);
requestDone = true;
}
requestDoneCondition.notify_one();
})
.finally([&waiter, &finallyCalled] {
finallyCalled = true;
waiter.requestDone();
})
.execute();
// Wait for the request to finish
std::unique_lock lck(mut);
requestDoneCondition.wait(lck, [&requestDone] {
return requestDone;
});
waiter.waitForRequest();
EXPECT_TRUE(finallyCalled);
}
@@ -127,45 +140,24 @@ TEST(NetworkRequest, Error)
for (const auto code : codes)
{
auto url = getStatusURL(code);
std::mutex mut;
bool requestDone = false;
std::condition_variable requestDoneCondition;
RequestWaiter waiter;
NetworkRequest(url)
.onSuccess([code, &mut, &requestDone, &requestDoneCondition,
url](NetworkResult result) -> Outcome {
// The codes should throw an error
EXPECT_TRUE(false);
{
std::unique_lock lck(mut);
requestDone = true;
}
requestDoneCondition.notify_one();
return Success;
})
.onError([code, &mut, &requestDone, &requestDoneCondition,
url](NetworkResult result) {
.onSuccess(
[&waiter, url](const NetworkResult & /*result*/) -> Outcome {
// The codes should throw an error
EXPECT_TRUE(false);
waiter.requestDone();
return Success;
})
.onError([code, &waiter, url](const NetworkResult &result) {
EXPECT_EQ(result.status(), code);
if (code == 402)
{
EXPECT_EQ(result.getData(),
QString("Fuck you, pay me!").toUtf8());
}
{
std::unique_lock lck(mut);
requestDone = true;
}
requestDoneCondition.notify_one();
waiter.requestDone();
})
.execute();
// Wait for the request to finish
std::unique_lock lck(mut);
requestDoneCondition.wait(lck, [&requestDone] {
return requestDone;
});
waiter.waitForRequest();
}
EXPECT_TRUE(NetworkManager::workerThread.isRunning());
@@ -183,30 +175,18 @@ TEST(NetworkRequest, FinallyCallbackOnError)
for (const auto code : codes)
{
auto url = getStatusURL(code);
std::mutex mut;
bool requestDone = false;
std::condition_variable requestDoneCondition;
RequestWaiter waiter;
bool finallyCalled = false;
NetworkRequest(url)
.finally(
[&mut, &requestDone, &requestDoneCondition, &finallyCalled] {
finallyCalled = true;
{
std::unique_lock lck(mut);
requestDone = true;
}
requestDoneCondition.notify_one();
})
.finally([&waiter, &finallyCalled] {
finallyCalled = true;
waiter.requestDone();
})
.execute();
// Wait for the request to finish
std::unique_lock lck(mut);
requestDoneCondition.wait(lck, [&requestDone] {
return requestDone;
});
waiter.waitForRequest();
EXPECT_TRUE(finallyCalled);
}
@@ -217,44 +197,26 @@ TEST(NetworkRequest, TimeoutTimingOut)
EXPECT_TRUE(NetworkManager::workerThread.isRunning());
auto url = getDelayURL(5);
std::mutex mut;
bool requestDone = false;
std::condition_variable requestDoneCondition;
RequestWaiter waiter;
NetworkRequest(url)
.timeout(1000)
.onSuccess([&mut, &requestDone, &requestDoneCondition,
url](NetworkResult result) -> Outcome {
.onSuccess([&waiter](const NetworkResult & /*result*/) -> Outcome {
// The timeout should throw an error
EXPECT_TRUE(false);
{
std::unique_lock lck(mut);
requestDone = true;
}
requestDoneCondition.notify_one();
waiter.requestDone();
return Success;
})
.onError([&mut, &requestDone, &requestDoneCondition,
url](NetworkResult result) {
.onError([&waiter, url](const NetworkResult &result) {
qDebug() << QTime::currentTime().toString()
<< "timeout request finish error";
EXPECT_EQ(result.status(), NetworkResult::timedoutStatus);
{
std::unique_lock lck(mut);
requestDone = true;
}
requestDoneCondition.notify_one();
waiter.requestDone();
})
.execute();
// Wait for the request to finish
std::unique_lock lck(mut);
requestDoneCondition.wait(lck, [&requestDone] {
return requestDone;
});
waiter.waitForRequest();
EXPECT_TRUE(NetworkManager::workerThread.isRunning());
}
@@ -264,42 +226,24 @@ TEST(NetworkRequest, TimeoutNotTimingOut)
EXPECT_TRUE(NetworkManager::workerThread.isRunning());
auto url = getDelayURL(1);
std::mutex mut;
bool requestDone = false;
std::condition_variable requestDoneCondition;
RequestWaiter waiter;
NetworkRequest(url)
.timeout(2000)
.onSuccess([&mut, &requestDone, &requestDoneCondition,
url](NetworkResult result) -> Outcome {
.timeout(3000)
.onSuccess([&waiter, url](const NetworkResult &result) -> Outcome {
EXPECT_EQ(result.status(), 200);
{
std::unique_lock lck(mut);
requestDone = true;
}
requestDoneCondition.notify_one();
waiter.requestDone();
return Success;
})
.onError([&mut, &requestDone, &requestDoneCondition,
url](NetworkResult result) {
.onError([&waiter, url](const NetworkResult & /*result*/) {
// The timeout should *not* throw an error
EXPECT_TRUE(false);
{
std::unique_lock lck(mut);
requestDone = true;
}
requestDoneCondition.notify_one();
waiter.requestDone();
})
.execute();
// Wait for the request to finish
std::unique_lock lck(mut);
requestDoneCondition.wait(lck, [&requestDone] {
return requestDone;
});
waiter.waitForRequest();
EXPECT_TRUE(NetworkManager::workerThread.isRunning());
}
@@ -310,39 +254,28 @@ TEST(NetworkRequest, FinallyCallbackOnTimeout)
auto url = getDelayURL(5);
std::mutex mut;
bool requestDone = false;
std::condition_variable requestDoneCondition;
RequestWaiter waiter;
bool finallyCalled = false;
bool onSuccessCalled = false;
bool onErrorCalled = false;
NetworkRequest(url)
.timeout(1000)
.onSuccess([&](NetworkResult result) -> Outcome {
.onSuccess([&](const NetworkResult & /*result*/) -> Outcome {
onSuccessCalled = true;
return Success;
})
.onError([&](NetworkResult result) {
.onError([&](const NetworkResult &result) {
onErrorCalled = true;
EXPECT_EQ(result.status(), NetworkResult::timedoutStatus);
})
.finally([&] {
finallyCalled = true;
{
std::unique_lock lck(mut);
requestDone = true;
}
requestDoneCondition.notify_one();
waiter.requestDone();
})
.execute();
// Wait for the request to finish
std::unique_lock lck(mut);
requestDoneCondition.wait(lck, [&requestDone] {
return requestDone;
});
waiter.waitForRequest();
EXPECT_TRUE(finallyCalled);
EXPECT_TRUE(onErrorCalled);