Merge pull request #966 from flowln/refactor_tasks

Reduce code duplication in tasks, fix some bugs and add some tests
This commit is contained in:
flow 2022-09-07 08:26:28 -03:00 committed by GitHub
commit 8e3f5c3305
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 250 additions and 394 deletions

View File

@ -54,6 +54,8 @@ class NetAction : public Task {
QUrl url() { return m_url; } QUrl url() { return m_url; }
auto index() -> int { return m_index_within_job; } auto index() -> int { return m_index_within_job; }
void setNetwork(shared_qobject_ptr<QNetworkAccessManager> network) { m_network = network; }
protected slots: protected slots:
virtual void downloadProgress(qint64 bytesReceived, qint64 bytesTotal) = 0; virtual void downloadProgress(qint64 bytesReceived, qint64 bytesTotal) = 0;
virtual void downloadError(QNetworkReply::NetworkError error) = 0; virtual void downloadError(QNetworkReply::NetworkError error) = 0;

View File

@ -35,204 +35,90 @@
*/ */
#include "NetJob.h" #include "NetJob.h"
#include "Download.h"
auto NetJob::addNetAction(NetAction::Ptr action) -> bool auto NetJob::addNetAction(NetAction::Ptr action) -> bool
{ {
action->m_index_within_job = m_downloads.size(); action->m_index_within_job = m_queue.size();
m_downloads.append(action); m_queue.append(action);
part_info pi;
m_parts_progress.append(pi);
partProgress(m_parts_progress.count() - 1, action->getProgress(), action->getTotalProgress()); action->setNetwork(m_network);
if (action->isRunning()) {
connect(action.get(), &NetAction::succeeded, [this, action]{ partSucceeded(action->index()); });
connect(action.get(), &NetAction::failed, [this, action](QString){ partFailed(action->index()); });
connect(action.get(), &NetAction::aborted, [this, action](){ partAborted(action->index()); });
connect(action.get(), &NetAction::progress, [this, action](qint64 done, qint64 total) { partProgress(action->index(), done, total); });
connect(action.get(), &NetAction::status, this, &NetJob::status);
} else {
m_todo.append(m_parts_progress.size() - 1);
}
return true; return true;
} }
void NetJob::startNext()
{
if (m_queue.isEmpty() && m_doing.isEmpty()) {
// We're finished, check for failures and retry if we can (up to 3 times)
if (!m_failed.isEmpty() && m_try < 3) {
m_try += 1;
while (!m_failed.isEmpty())
m_queue.enqueue(m_failed.take(*m_failed.keyBegin()));
}
}
ConcurrentTask::startNext();
}
auto NetJob::size() const -> int
{
return m_queue.size() + m_doing.size() + m_done.size();
}
auto NetJob::canAbort() const -> bool auto NetJob::canAbort() const -> bool
{ {
bool canFullyAbort = true; bool canFullyAbort = true;
// can abort the downloads on the queue? // can abort the downloads on the queue?
for (auto index : m_todo) { for (auto part : m_queue)
auto part = m_downloads[index];
canFullyAbort &= part->canAbort(); canFullyAbort &= part->canAbort();
}
// can abort the active downloads? // can abort the active downloads?
for (auto index : m_doing) { for (auto part : m_doing)
auto part = m_downloads[index];
canFullyAbort &= part->canAbort(); canFullyAbort &= part->canAbort();
}
return canFullyAbort; return canFullyAbort;
} }
void NetJob::executeTask()
{
// hack that delays early failures so they can be caught easier
QMetaObject::invokeMethod(this, "startMoreParts", Qt::QueuedConnection);
}
auto NetJob::getFailedFiles() -> QStringList
{
QStringList failed;
for (auto index : m_failed) {
failed.push_back(m_downloads[index]->url().toString());
}
failed.sort();
return failed;
}
auto NetJob::abort() -> bool auto NetJob::abort() -> bool
{ {
bool fullyAborted = true; bool fullyAborted = true;
// fail all downloads on the queue // fail all downloads on the queue
#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0) for (auto task : m_queue)
QSet<int> todoSet(m_todo.begin(), m_todo.end()); m_failed.insert(task.get(), task);
m_failed.unite(todoSet); m_queue.clear();
#else
m_failed.unite(m_todo.toSet());
#endif
m_todo.clear();
// abort active downloads // abort active downloads
auto toKill = m_doing.values(); auto toKill = m_doing.values();
for (auto index : toKill) { for (auto part : toKill) {
auto part = m_downloads[index];
fullyAborted &= part->abort(); fullyAborted &= part->abort();
} }
return fullyAborted; return fullyAborted;
} }
void NetJob::partSucceeded(int index) auto NetJob::getFailedActions() -> QList<NetAction*>
{ {
// do progress. all slots are 1 in size at least QList<NetAction*> failed;
auto& slot = m_parts_progress[index]; for (auto index : m_failed) {
partProgress(index, slot.total_progress, slot.total_progress); failed.push_back(dynamic_cast<NetAction*>(index.get()));
}
m_doing.remove(index); return failed;
m_done.insert(index);
m_downloads[index].get()->disconnect(this);
startMoreParts();
} }
void NetJob::partFailed(int index) auto NetJob::getFailedFiles() -> QList<QString>
{ {
m_doing.remove(index); QList<QString> failed;
for (auto index : m_failed) {
auto& slot = m_parts_progress[index]; failed.append(static_cast<NetAction*>(index.get())->url().toString());
// Can try 3 times before failing by definitive }
if (slot.failures == 3) { return failed;
m_failed.insert(index);
} else {
slot.failures++;
m_todo.enqueue(index);
} }
m_downloads[index].get()->disconnect(this); void NetJob::updateState()
startMoreParts();
}
void NetJob::partAborted(int index)
{ {
m_aborted = true; emit progress(m_done.count(), m_total_size);
setStatus(tr("Executing %1 task(s) (%2 out of %3 are done)")
m_doing.remove(index); .arg(QString::number(m_doing.count()), QString::number(m_done.count()), QString::number(m_total_size)));
m_failed.insert(index);
m_downloads[index].get()->disconnect(this);
startMoreParts();
}
void NetJob::partProgress(int index, qint64 bytesReceived, qint64 bytesTotal)
{
auto& slot = m_parts_progress[index];
slot.current_progress = bytesReceived;
slot.total_progress = bytesTotal;
int done = m_done.size();
int doing = m_doing.size();
int all = m_parts_progress.size();
qint64 bytesAll = 0;
qint64 bytesTotalAll = 0;
for (auto& partIdx : m_doing) {
auto part = m_parts_progress[partIdx];
// do not count parts with unknown/nonsensical total size
if (part.total_progress <= 0) {
continue;
}
bytesAll += part.current_progress;
bytesTotalAll += part.total_progress;
}
qint64 inprogress = (bytesTotalAll == 0) ? 0 : (bytesAll * 1000) / bytesTotalAll;
auto current = done * 1000 + doing * inprogress;
auto current_total = all * 1000;
// HACK: make sure it never jumps backwards.
// FAIL: This breaks if the size is not known (or is it something else?) and jumps to 1000, so if it is 1000 reset it to inprogress
if (m_current_progress == 1000) {
m_current_progress = inprogress;
}
if (m_current_progress > current) {
current = m_current_progress;
}
m_current_progress = current;
setProgress(current, current_total);
}
void NetJob::startMoreParts()
{
if (!isRunning()) {
// this actually makes sense. You can put running m_downloads into a NetJob and then not start it until much later.
return;
}
// OK. We are actively processing tasks, proceed.
// Check for final conditions if there's nothing in the queue.
if (!m_todo.size()) {
if (!m_doing.size()) {
if (!m_failed.size()) {
emitSucceeded();
} else if (m_aborted) {
emitAborted();
} else {
emitFailed(tr("Job '%1' failed to process:\n%2").arg(objectName()).arg(getFailedFiles().join("\n")));
}
}
return;
}
// There's work to do, try to start more parts, to a maximum of 6 concurrent ones.
while (m_doing.size() < 6) {
if (m_todo.size() == 0)
return;
int doThis = m_todo.dequeue();
m_doing.insert(doThis);
auto part = m_downloads[doThis];
// connect signals :D
connect(part.get(), &NetAction::succeeded, this, [this, part]{ partSucceeded(part->index()); });
connect(part.get(), &NetAction::failed, this, [this, part](QString){ partFailed(part->index()); });
connect(part.get(), &NetAction::aborted, this, [this, part]{ partAborted(part->index()); });
connect(part.get(), &NetAction::progress, this, [this, part](qint64 done, qint64 total) { partProgress(part->index(), done, total); });
connect(part.get(), &NetAction::status, this, &NetJob::status);
part->startAction(m_network);
}
} }

View File

@ -39,64 +39,40 @@
#include <QObject> #include <QObject>
#include "NetAction.h" #include "NetAction.h"
#include "tasks/Task.h" #include "tasks/ConcurrentTask.h"
// Those are included so that they are also included by anyone using NetJob // Those are included so that they are also included by anyone using NetJob
#include "net/Download.h" #include "net/Download.h"
#include "net/HttpMetaCache.h" #include "net/HttpMetaCache.h"
class NetJob : public Task { class NetJob : public ConcurrentTask {
Q_OBJECT Q_OBJECT
public: public:
using Ptr = shared_qobject_ptr<NetJob>; using Ptr = shared_qobject_ptr<NetJob>;
explicit NetJob(QString job_name, shared_qobject_ptr<QNetworkAccessManager> network) : Task(), m_network(network) explicit NetJob(QString job_name, shared_qobject_ptr<QNetworkAccessManager> network) : ConcurrentTask(nullptr, job_name), m_network(network) {}
{ ~NetJob() override = default;
setObjectName(job_name);
}
virtual ~NetJob() = default;
void executeTask() override; void startNext() override;
auto size() const -> int;
auto canAbort() const -> bool override; auto canAbort() const -> bool override;
auto addNetAction(NetAction::Ptr action) -> bool; auto addNetAction(NetAction::Ptr action) -> bool;
auto operator[](int index) -> NetAction::Ptr { return m_downloads[index]; } auto getFailedActions() -> QList<NetAction*>;
auto at(int index) -> const NetAction::Ptr { return m_downloads.at(index); } auto getFailedFiles() -> QList<QString>;
auto size() const -> int { return m_downloads.size(); }
auto first() -> NetAction::Ptr { return m_downloads.size() != 0 ? m_downloads[0] : NetAction::Ptr{}; }
auto getFailedFiles() -> QStringList;
public slots: public slots:
// Qt can't handle auto at the start for some reason? // Qt can't handle auto at the start for some reason?
bool abort() override; bool abort() override;
private slots: protected:
void startMoreParts(); void updateState() override;
void partProgress(int index, qint64 bytesReceived, qint64 bytesTotal);
void partSucceeded(int index);
void partFailed(int index);
void partAborted(int index);
private: private:
shared_qobject_ptr<QNetworkAccessManager> m_network; shared_qobject_ptr<QNetworkAccessManager> m_network;
struct part_info { int m_try = 1;
qint64 current_progress = 0;
qint64 total_progress = 1;
int failures = 0;
};
QList<NetAction::Ptr> m_downloads;
QList<part_info> m_parts_progress;
QQueue<int> m_todo;
QSet<int> m_doing;
QSet<int> m_done;
QSet<int> m_failed;
qint64 m_current_progress = 0;
bool m_aborted = false;
}; };

View File

@ -37,32 +37,39 @@ void ConcurrentTask::executeTask()
{ {
m_total_size = m_queue.size(); m_total_size = m_queue.size();
for (int i = 0; i < m_total_max_size; i++) { int num_starts = std::min(m_total_max_size, m_total_size);
for (int i = 0; i < num_starts; i++) {
QMetaObject::invokeMethod(this, &ConcurrentTask::startNext, Qt::QueuedConnection); QMetaObject::invokeMethod(this, &ConcurrentTask::startNext, Qt::QueuedConnection);
} }
} }
bool ConcurrentTask::abort() bool ConcurrentTask::abort()
{ {
m_queue.clear();
m_aborted = true;
if (m_doing.isEmpty()) { if (m_doing.isEmpty()) {
// Don't call emitAborted() here, we want to bypass the 'is the task running' check // Don't call emitAborted() here, we want to bypass the 'is the task running' check
emit aborted(); emit aborted();
emit finished(); emit finished();
m_aborted = true;
return true; return true;
} }
m_queue.clear(); bool suceedeed = true;
m_aborted = true; QMutableHashIterator<Task*, Task::Ptr> doing_iter(m_doing);
for (auto task : m_doing) while (doing_iter.hasNext()) {
m_aborted &= task->abort(); auto task = doing_iter.next();
suceedeed &= (task.value())->abort();
}
if (m_aborted) if (suceedeed)
emitAborted(); emitAborted();
else
emitFailed(tr("Failed to abort all running tasks."));
return m_aborted; return suceedeed;
} }
void ConcurrentTask::startNext() void ConcurrentTask::startNext()
@ -70,7 +77,7 @@ void ConcurrentTask::startNext()
if (m_aborted || m_doing.count() > m_total_max_size) if (m_aborted || m_doing.count() > m_total_max_size)
return; return;
if (m_queue.isEmpty() && m_doing.isEmpty()) { if (m_queue.isEmpty() && m_doing.isEmpty() && !wasSuccessful()) {
emitSucceeded(); emitSucceeded();
return; return;
} }
@ -131,11 +138,6 @@ void ConcurrentTask::subTaskStatus(const QString& msg)
void ConcurrentTask::subTaskProgress(qint64 current, qint64 total) void ConcurrentTask::subTaskProgress(qint64 current, qint64 total)
{ {
if (total == 0) {
setProgress(0, 100);
return;
}
m_stepProgress = current; m_stepProgress = current;
m_stepTotalProgress = total; m_stepTotalProgress = total;
} }

View File

@ -9,7 +9,9 @@ class ConcurrentTask : public Task {
Q_OBJECT Q_OBJECT
public: public:
explicit ConcurrentTask(QObject* parent = nullptr, QString task_name = "", int max_concurrent = 6); explicit ConcurrentTask(QObject* parent = nullptr, QString task_name = "", int max_concurrent = 6);
virtual ~ConcurrentTask(); ~ConcurrentTask() override;
bool canAbort() const override { return true; }
inline auto isMultiStep() const -> bool override { return m_queue.size() > 1; }; inline auto isMultiStep() const -> bool override { return m_queue.size() > 1; };
auto getStepProgress() const -> qint64 override; auto getStepProgress() const -> qint64 override;

View File

@ -6,43 +6,22 @@ MultipleOptionsTask::MultipleOptionsTask(QObject* parent, const QString& task_na
void MultipleOptionsTask::startNext() void MultipleOptionsTask::startNext()
{ {
Task* previous = nullptr; if (m_done.size() != m_failed.size()) {
if (m_currentIndex != -1) {
previous = m_queue[m_currentIndex].get();
disconnect(previous, 0, this, 0);
}
m_currentIndex++;
if ((previous && previous->wasSuccessful())) {
emitSucceeded(); emitSucceeded();
return; return;
} }
Task::Ptr next = m_queue[m_currentIndex]; if (m_queue.isEmpty()) {
emitFailed(tr("All attempts have failed!"));
connect(next.get(), &Task::failed, this, &MultipleOptionsTask::subTaskFailed); qWarning() << "All attempts have failed!";
connect(next.get(), &Task::succeeded, this, &MultipleOptionsTask::startNext);
connect(next.get(), &Task::status, this, &MultipleOptionsTask::subTaskStatus);
connect(next.get(), &Task::stepStatus, this, &MultipleOptionsTask::subTaskStatus);
connect(next.get(), &Task::progress, this, &MultipleOptionsTask::subTaskProgress);
qDebug() << QString("Making attemp %1 out of %2").arg(m_currentIndex + 1).arg(m_queue.size());
setStatus(tr("Making attempt #%1 out of %2").arg(m_currentIndex + 1).arg(m_queue.size()));
setStepStatus(next->isMultiStep() ? next->getStepStatus() : next->getStatus());
next->start();
}
void MultipleOptionsTask::subTaskFailed(QString const& reason)
{
qDebug() << QString("Failed attempt #%1 of %2. Reason: %3").arg(m_currentIndex + 1).arg(m_queue.size()).arg(reason);
if(m_currentIndex < m_queue.size() - 1) {
startNext();
return; return;
} }
qWarning() << QString("All attempts have failed!"); ConcurrentTask::startNext();
emitFailed(); }
void MultipleOptionsTask::updateState()
{
setProgress(m_done.count(), m_total_size);
setStatus(tr("Attempting task %1 out of %2").arg(QString::number(m_doing.count() + m_done.count()), QString::number(m_total_size)));
} }

View File

@ -5,15 +5,13 @@
/* This task type will attempt to do run each of it's subtasks in sequence, /* This task type will attempt to do run each of it's subtasks in sequence,
* until one of them succeeds. When that happens, the remaining tasks will not run. * until one of them succeeds. When that happens, the remaining tasks will not run.
* */ * */
class MultipleOptionsTask : public SequentialTask class MultipleOptionsTask : public SequentialTask {
{
Q_OBJECT Q_OBJECT
public: public:
explicit MultipleOptionsTask(QObject* parent = nullptr, const QString& task_name = ""); explicit MultipleOptionsTask(QObject* parent = nullptr, const QString& task_name = "");
virtual ~MultipleOptionsTask() = default; ~MultipleOptionsTask() override = default;
private private slots:
slots:
void startNext() override; void startNext() override;
void subTaskFailed(const QString &msg) override; void updateState() override;
}; };

View File

@ -2,107 +2,21 @@
#include <QDebug> #include <QDebug>
SequentialTask::SequentialTask(QObject* parent, const QString& task_name) : Task(parent), m_name(task_name), m_currentIndex(-1) {} SequentialTask::SequentialTask(QObject* parent, QString task_name) : ConcurrentTask(parent, task_name, 1) {}
SequentialTask::~SequentialTask()
{
for(auto task : m_queue){
if(task)
task->deleteLater();
}
}
auto SequentialTask::getStepProgress() const -> qint64
{
return m_stepProgress;
}
auto SequentialTask::getStepTotalProgress() const -> qint64
{
return m_stepTotalProgress;
}
void SequentialTask::addTask(Task::Ptr task)
{
m_queue.append(task);
}
void SequentialTask::executeTask()
{
m_currentIndex = -1;
startNext();
}
bool SequentialTask::abort()
{
if(m_currentIndex == -1 || m_currentIndex >= m_queue.size()) {
if(m_currentIndex == -1) {
// Don't call emitAborted() here, we want to bypass the 'is the task running' check
emit aborted();
emit finished();
}
m_aborted = true;
return true;
}
bool succeeded = m_queue[m_currentIndex]->abort();
m_aborted = succeeded;
if (succeeded)
emitAborted();
return succeeded;
}
void SequentialTask::startNext() void SequentialTask::startNext()
{ {
if (m_aborted) if (m_failed.size() > 0) {
return; emitFailed(tr("One of the tasks failed!"));
qWarning() << m_failed.constBegin()->get()->failReason();
if (m_currentIndex != -1 && m_currentIndex < m_queue.size()) {
Task::Ptr previous = m_queue.at(m_currentIndex);
disconnect(previous.get(), 0, this, 0);
}
m_currentIndex++;
if (m_queue.isEmpty() || m_currentIndex >= m_queue.size()) {
emitSucceeded();
return;
}
Task::Ptr next = m_queue[m_currentIndex];
connect(next.get(), SIGNAL(failed(QString)), this, SLOT(subTaskFailed(QString)));
connect(next.get(), SIGNAL(succeeded()), this, SLOT(startNext()));
connect(next.get(), SIGNAL(status(QString)), this, SLOT(subTaskStatus(QString)));
connect(next.get(), SIGNAL(stepStatus(QString)), this, SLOT(subTaskStatus(QString)));
connect(next.get(), SIGNAL(progress(qint64, qint64)), this, SLOT(subTaskProgress(qint64, qint64)));
setStatus(tr("Executing task %1 out of %2").arg(m_currentIndex + 1).arg(m_queue.size()));
setStepStatus(next->isMultiStep() ? next->getStepStatus() : next->getStatus());
setProgress(m_currentIndex + 1, m_queue.count());
next->start();
}
void SequentialTask::subTaskFailed(const QString& msg)
{
emitFailed(msg);
}
void SequentialTask::subTaskStatus(const QString& msg)
{
setStepStatus(msg);
}
void SequentialTask::subTaskProgress(qint64 current, qint64 total)
{
if (total == 0) {
setProgress(0, 100);
return; return;
} }
m_stepProgress = current; ConcurrentTask::startNext();
m_stepTotalProgress = total; }
void SequentialTask::updateState()
{
setProgress(m_done.count(), m_total_size);
setStatus(tr("Executing task %1 out of %2").arg(QString::number(m_doing.count() + m_done.count()), QString::number(m_total_size)));
} }

View File

@ -1,49 +1,21 @@
#pragma once #pragma once
#include "Task.h" #include "ConcurrentTask.h"
#include "QObjectPtr.h"
#include <QQueue> /** A concurrent task that only allows one concurrent task :)
*
class SequentialTask : public Task * This should be used when there's a need to maintain a strict ordering of task executions, and
{ * the starting of a task is contingent on the success of the previous one.
*
* See MultipleOptionsTask if that's not the case.
*/
class SequentialTask : public ConcurrentTask {
Q_OBJECT Q_OBJECT
public: public:
explicit SequentialTask(QObject *parent = nullptr, const QString& task_name = ""); explicit SequentialTask(QObject* parent = nullptr, QString task_name = "");
virtual ~SequentialTask(); ~SequentialTask() override = default;
inline auto isMultiStep() const -> bool override { return m_queue.size() > 1; };
auto getStepProgress() const -> qint64 override;
auto getStepTotalProgress() const -> qint64 override;
inline auto getStepStatus() const -> QString override { return m_step_status; }
void addTask(Task::Ptr task);
public slots:
bool abort() override;
protected
slots:
void executeTask() override;
virtual void startNext();
virtual void subTaskFailed(const QString &msg);
virtual void subTaskStatus(const QString &msg);
virtual void subTaskProgress(qint64 current, qint64 total);
protected: protected:
void setStepStatus(QString status) { m_step_status = status; emit stepStatus(status); }; void startNext() override;
void updateState() override;
protected:
QString m_name;
QString m_step_status;
QQueue<Task::Ptr > m_queue;
int m_currentIndex;
qint64 m_stepProgress = 0;
qint64 m_stepTotalProgress = 100;
bool m_aborted = false;
}; };

View File

@ -1,5 +1,8 @@
#include <QTest> #include <QTest>
#include "ConcurrentTask.h"
#include "MultipleOptionsTask.h"
#include "SequentialTask.h"
#include "Task.h" #include "Task.h"
/* Does nothing. Only used for testing. */ /* Does nothing. Only used for testing. */
@ -9,7 +12,10 @@ class BasicTask : public Task {
friend class TaskTest; friend class TaskTest;
private: private:
void executeTask() override {}; void executeTask() override
{
emitSucceeded();
};
}; };
/* Does nothing. Only used for testing. */ /* Does nothing. Only used for testing. */
@ -60,6 +66,123 @@ class TaskTest : public QObject {
QCOMPARE(t.getProgress(), current); QCOMPARE(t.getProgress(), current);
QCOMPARE(t.getTotalProgress(), total); QCOMPARE(t.getTotalProgress(), total);
} }
void test_basicRun(){
BasicTask t;
QObject::connect(&t, &Task::finished, [&]{ QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been."); });
t.start();
QVERIFY2(QTest::qWaitFor([&]() {
return t.isFinished();
}, 1000), "Task didn't finish as it should.");
}
void test_basicConcurrentRun(){
BasicTask t1;
BasicTask t2;
BasicTask t3;
ConcurrentTask t;
t.addTask(&t1);
t.addTask(&t2);
t.addTask(&t3);
QObject::connect(&t, &Task::finished, [&]{
QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been.");
QVERIFY(t1.wasSuccessful());
QVERIFY(t2.wasSuccessful());
QVERIFY(t3.wasSuccessful());
});
t.start();
QVERIFY2(QTest::qWaitFor([&]() {
return t.isFinished();
}, 1000), "Task didn't finish as it should.");
}
// Tests if starting new tasks after the 6 initial ones is working
void test_moreConcurrentRun(){
BasicTask t1, t2, t3, t4, t5, t6, t7, t8, t9;
ConcurrentTask t;
t.addTask(&t1);
t.addTask(&t2);
t.addTask(&t3);
t.addTask(&t4);
t.addTask(&t5);
t.addTask(&t6);
t.addTask(&t7);
t.addTask(&t8);
t.addTask(&t9);
QObject::connect(&t, &Task::finished, [&]{
QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been.");
QVERIFY(t1.wasSuccessful());
QVERIFY(t2.wasSuccessful());
QVERIFY(t3.wasSuccessful());
QVERIFY(t4.wasSuccessful());
QVERIFY(t5.wasSuccessful());
QVERIFY(t6.wasSuccessful());
QVERIFY(t7.wasSuccessful());
QVERIFY(t8.wasSuccessful());
QVERIFY(t9.wasSuccessful());
});
t.start();
QVERIFY2(QTest::qWaitFor([&]() {
return t.isFinished();
}, 1000), "Task didn't finish as it should.");
}
void test_basicSequentialRun(){
BasicTask t1;
BasicTask t2;
BasicTask t3;
SequentialTask t;
t.addTask(&t1);
t.addTask(&t2);
t.addTask(&t3);
QObject::connect(&t, &Task::finished, [&]{
QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been.");
QVERIFY(t1.wasSuccessful());
QVERIFY(t2.wasSuccessful());
QVERIFY(t3.wasSuccessful());
});
t.start();
QVERIFY2(QTest::qWaitFor([&]() {
return t.isFinished();
}, 1000), "Task didn't finish as it should.");
}
void test_basicMultipleOptionsRun(){
BasicTask t1;
BasicTask t2;
BasicTask t3;
MultipleOptionsTask t;
t.addTask(&t1);
t.addTask(&t2);
t.addTask(&t3);
QObject::connect(&t, &Task::finished, [&]{
QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been.");
QVERIFY(t1.wasSuccessful());
QVERIFY(!t2.wasSuccessful());
QVERIFY(!t3.wasSuccessful());
});
t.start();
QVERIFY2(QTest::qWaitFor([&]() {
return t.isFinished();
}, 1000), "Task didn't finish as it should.");
}
}; };
QTEST_GUILESS_MAIN(TaskTest) QTEST_GUILESS_MAIN(TaskTest)

View File

@ -230,10 +230,11 @@ void ListModel::searchRequestFinished(QJsonDocument& doc)
void ListModel::searchRequestFailed(QString reason) void ListModel::searchRequestFailed(QString reason)
{ {
if (!jobPtr->first()->m_reply) { auto failed_action = jobPtr->getFailedActions().at(0);
if (!failed_action->m_reply) {
// Network error // Network error
QMessageBox::critical(nullptr, tr("Error"), tr("A network error occurred. Could not load mods.")); QMessageBox::critical(nullptr, tr("Error"), tr("A network error occurred. Could not load mods."));
} else if (jobPtr->first()->m_reply && jobPtr->first()->m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 409) { } else if (failed_action->m_reply && failed_action->m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 409) {
// 409 Gone, notify user to update // 409 Gone, notify user to update
QMessageBox::critical(nullptr, tr("Error"), QMessageBox::critical(nullptr, tr("Error"),
//: %1 refers to the launcher itself //: %1 refers to the launcher itself

View File

@ -301,10 +301,11 @@ void ModpackListModel::searchRequestFinished(QJsonDocument& doc_all)
void ModpackListModel::searchRequestFailed(QString reason) void ModpackListModel::searchRequestFailed(QString reason)
{ {
if (!jobPtr->first()->m_reply) { auto failed_action = jobPtr->getFailedActions().at(0);
if (!failed_action->m_reply) {
// Network error // Network error
QMessageBox::critical(nullptr, tr("Error"), tr("A network error occurred. Could not load modpacks.")); QMessageBox::critical(nullptr, tr("Error"), tr("A network error occurred. Could not load modpacks."));
} else if (jobPtr->first()->m_reply && jobPtr->first()->m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 409) { } else if (failed_action->m_reply && failed_action->m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 409) {
// 409 Gone, notify user to update // 409 Gone, notify user to update
QMessageBox::critical(nullptr, tr("Error"), QMessageBox::critical(nullptr, tr("Error"),
//: %1 refers to the launcher itself //: %1 refers to the launcher itself