← C++

C++ · 24 / 24

Abschlussprojekt: eine geprüfte C++/Qt-Auftragsverwaltung

Du verbindest Oberfläche, Anwendungskern, SQLite und Datei- sowie Netzwerkimport zu einer ausführbaren technischen Arbeitsprobe.

  • Groß
  • Anspruchsvoll
  • 180 min

Voraussetzungen: Reproduzierbare Desktop-Builds und Pakete, Daten mit span, string_view und Ranges auswerten, Versionierte JSON-Dateien sicher migrieren, Qt-Oberflächen mit Aktionen und Signalen testen

In diesem Tutorial
  1. Die Anwendung mit eigener Datenbank starten
  2. Die Abhängigkeiten erklären
  3. Import als überprüfbare Entscheidung darstellen
  4. Netzwerkimport lokal vorführen
  5. Den vollständigen Arbeitsablauf prüfen
  6. Eine komplette Erweiterung liefern
  7. Die Arbeitsprobe nachvollziehbar übergeben
  8. Übung und Lösung
  9. Projektbezug und Quellen

Lernpaket herunterladen

Einrichtung und Prüfstand

GCC mit C++20, CMake ab 3.25, CTest und Python 3. Qt 6.8 mit Core, Widgets und Test. Zusätzlich Qt Network. Zusätzlich Qt SQL mit QSQLITE-Plugin. Setze CMAKE_PREFIX_PATH auf deinen Qt-Installationsordner, falls Qt nicht automatisch gefunden wird. Lokal geprüft mit Qt 6.8.3. Entpacke das ZIP in einen neuen Ordner. python3 run_checks.py prüft Beispiel und Lösung in einer temporären Kopie und erhält deine Dateien. Für einen eigenen Build führe python3 verify.py aus. Danach liegt das Demo unter build/order_lab. Die Qt-Demos verwenden englische Beschriftungen. Automatische Widgettests nutzen standardmäßig offscreen. Starte die sichtbare Demo in einer Desktop-Sitzung ohne QT_QPA_PLATFORM=offscreen. Native Windows-Ausführung ist nicht verifiziert.

Geprüft am 21.10.2026 unter Linux x86_64. Qt-Workflow mit Anlegen, erneuter Datenbanköffnung, Bearbeiten, ungültigem Import, veralteter Vorschau, SQL-Rollback und Datei-Roundtrip. Lokaler HTTP-Import wird über echte Buttons bestätigt. Zusätzlich Modell-, Netzwerk-, Dateitests und persistente Stapelaktionslösung. Linux offscreen, keine native Windows- oder Mehrprozess-Abnahme.

Order Lab mit künstlichen Aufträgen. Tatsächliche Qt-Oberfläche aus einem Linux-offscreen-Lauf. Eigenständiges Lernprojekt, keine Ansicht der FactoryForge-Spielsimulation.
Order Lab mit künstlichen Aufträgen. Tatsächliche Qt-Oberfläche aus einem Linux-offscreen-Lauf. Eigenständiges Lernprojekt, keine Ansicht der FactoryForge-Spielsimulation.

Das Order Lab fasst die neue Reihe zu einer kleinen Desktopanwendung zusammen. Es verwendet das Logistikthema von FactoryForge, ist aber ein eigenständiges Lernprojekt. Die FactoryForge-Spielsimulation wird weder eingebettet noch verändert. Der Schwerpunkt liegt auf überprüfbaren Entscheidungen: dauerhafte Speicherung, Vorschau vor dem Ersetzen, Erhalt des Bestands bei Fehlern und nachvollziehbare Tests.

Paketinhalt und einzelne Dateien

01Die Anwendung mit eigener Datenbank starten

Entpacke das vollständige Paket und starte python3 verify.py. Danach öffnet ./build/order_lab --database orders.sqlite eine eigene SQLite-Datei. Ohne Parameter verwendet die App ihr Qt-Anwendungsdatenverzeichnis. Die englisch beschriftete Oberfläche enthält Auftragstabelle und Bearbeitungsformular. Es werden keine Daten aus einer bestehenden FactoryForge-Installation übernommen.

main.cpp · cppDatei öffnen
#include "sqlite_repository.hpp"
#include "test_support.hpp"
#include "window.hpp"
#include <QApplication>
#include <QCommandLineParser>
#include <QDir>
#include <QStandardPaths>
#include <iostream>
int main(int argc, char **argv) {
  QApplication app(argc, argv);
  app.setApplicationName("AppFabrikOrderLab");
  app.setStyle("Fusion");
  app.setStyleSheet(
      "QWidget { font-size: 14px; } QPushButton { padding: 7px 12px; } "
      "QLineEdit, QSpinBox { min-height: 28px; } QTableView { gridline-color: "
      "#d8e2ec; alternate-background-color: #f2f6fb; } QHeaderView::section { "
      "padding: 8px; font-weight: bold; }");
  QCommandLineParser parser;
  parser.addHelpOption();
  parser.addOption({"database", "Use this SQLite database", "path"});
  parser.addOption(
      {"screenshot",
       "Render a screenshot and exit. Requires a new explicit database path",
       "path"});
  parser.process(app);
  auto path = parser.value("database");
  if (parser.isSet("screenshot") && (path.isEmpty() || QFile::exists(path))) {
    std::cerr << "Screenshot mode requires a new --database path\n";
    return 1;
  }
  if (path.isEmpty()) {
    const auto directory =
        QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
    if (!QDir().mkpath(directory))
      return 1;
    path = directory + "/orders.sqlite";
  }
  orders::SqliteRepository repository(path);
  orders::OrderService service(repository);
  auto loaded = service.list();
  if (!orders::succeeded(loaded)) {
    std::cerr << std::get<orders::Error>(loaded).message << '\n';
    return 1;
  }
  if (parser.isSet("screenshot") &&
      !orders::succeeded(service.replace(samples())))
    return 1;
  orders::OrderWindow window(service);
  window.show();
  if (parser.isSet("screenshot")) {
    const auto image = parser.value("screenshot");
    QTimer::singleShot(250, &window,
                       [&] { app.exit(window.grab().save(image) ? 0 : 1); });
  }
  return app.exec();
}
Erwartetes Ergebnis

Die Anwendung startet mit einer leeren Tabelle und einer neuen Datenbank.

02Die Abhängigkeiten erklären

Die Oberfläche spricht mit OrderService. Der Dienst kennt die Repository-Schnittstelle und reine C++-Domänentypen. SqliteRepository erfüllt den Speichervertrag. Der Netzwerkloader liefert validierte Dokumente an die Importvorschau. Im Bewerbungsgespräch kannst du an diesem Ablauf erklären, welche Teile ohne Oberfläche und welche mit realer Datenbank geprüft werden.

repository.hpp · cppDatei öffnen
#pragma once
#include "order.hpp"

namespace orders {
class OrderRepository {
public:
  virtual ~OrderRepository() = default;
  virtual Result<std::vector<Order>> list() const = 0;
  // Contract: failure leaves the previously committed batch intact.
  virtual Result<Done> replaceAll(std::span<const Order> batch) = 0;
};
class MemoryRepository final : public OrderRepository {
  std::vector<Order> data_;

public:
  Result<std::vector<Order>> list() const override { return data_; }
  Result<Done> replaceAll(std::span<const Order> batch) override {
    return replaceValidated(data_, batch);
  }
};
class OrderService {
  OrderRepository &repository_;

public:
  explicit OrderService(OrderRepository &repository)
      : repository_(repository) {}
  Result<std::vector<Order>> list() const { return repository_.list(); }
  Result<Done> replace(std::span<const Order> batch) {
    auto result = validateBatch(batch);
    if (!succeeded(result))
      return std::get<Error>(result);
    return repository_.replaceAll(batch);
  }
  Result<Done> save(const Order &order) {
    auto result = repository_.list();
    if (!succeeded(result))
      return std::get<Error>(result);
    auto batch = std::get<std::vector<Order>>(std::move(result));
    auto found = std::ranges::find(batch, order.id, &Order::id);
    if (found == batch.end())
      batch.push_back(order);
    else
      *found = order;
    return replace(batch);
  }
  Result<Done> remove(int id) {
    auto result = repository_.list();
    if (!succeeded(result))
      return std::get<Error>(result);
    auto batch = std::get<std::vector<Order>>(std::move(result));
    std::erase_if(batch, [id](const Order &order) { return order.id == id; });
    return replace(batch);
  }
};
} // namespace orders
Erwartetes Ergebnis

Der Kern benötigt weder QWidget noch SQL-Abfragen.

03Import als überprüfbare Entscheidung darstellen

Preview JSON file lädt beispielsweise fixtures/orders-v1.json. Die Vorschau zeigt Anzahl, IDs, Titel, Prioritäten und Status. Erst Replace saved orders with preview ersetzt den gespeicherten Bestand. Auch eine leere Liste ist ein vollständiger Ersatz. Werden Aufträge nach Erstellung der Vorschau gespeichert, lehnt die App deren Übernahme ab und verlangt eine neue Vorschau.

window.hpp · cppDatei öffnen
#pragma once
#include "download.hpp"
#include "order_editor.hpp"
#include <QFileDialog>
#include <QPlainTextEdit>
#include <optional>

namespace orders {
class OrderWindow final : public QWidget {
  OrderService &service_;
  OrderDownload download_{this};
  OrderEditor *editor_;
  QPlainTextEdit *preview_;
  QPushButton *apply_;
  QLabel *status_;
  std::optional<std::vector<Order>> pending_;
  std::vector<Order> beforePreview_;
  void clearPreview() {
    pending_.reset();
    preview_->clear();
    apply_->setEnabled(false);
  }
  void showResult(const Result<Done> &result, const QString &success) {
    status_->setText(succeeded(result) ? success
                                       : QString::fromStdString(
                                             std::get<Error>(result).message));
  }

public:
  explicit OrderWindow(OrderService &service) : service_(service) {
    setWindowTitle("FactoryForge context · Order Lab");
    resize(900, 780);
    auto *layout = new QVBoxLayout(this);
    auto *heading =
        new QLabel("Order Lab · independent C++ / Qt learning project", this);
    heading->setStyleSheet("font-size: 20px; font-weight: bold; padding: 8px");
    layout->addWidget(heading);
    editor_ = new OrderEditor(service_, this);
    layout->addWidget(editor_, 1);
    auto *fileButtons = new QHBoxLayout;
    auto *import = new QPushButton("Preview JSON file", this);
    auto *exportFile = new QPushButton("Export saved orders", this);
    fileButtons->addWidget(import);
    fileButtons->addWidget(exportFile);
    layout->addLayout(fileButtons);
    auto *net = new QHBoxLayout;
    auto *url = new QLineEdit("http://127.0.0.1:8765/orders", this);
    url->setAccessibleName("Import URL");
    url->setObjectName("importUrl");
    auto *fetch = new QPushButton("Preview URL", this);
    fetch->setObjectName("fetch");
    auto *cancel = new QPushButton("Cancel request", this);
    cancel->setEnabled(false);
    net->addWidget(url, 1);
    net->addWidget(fetch);
    net->addWidget(cancel);
    layout->addLayout(net);
    preview_ = new QPlainTextEdit(this);
    preview_->setReadOnly(true);
    preview_->setAccessibleName("Import preview");
    preview_->setMaximumHeight(110);
    layout->addWidget(preview_);
    apply_ = new QPushButton("Replace saved orders with preview", this);
    apply_->setObjectName("applyImport");
    apply_->setEnabled(false);
    layout->addWidget(apply_);
    status_ = new QLabel(
        "Import replaces all saved orders after validation and confirmation.",
        this);
    status_->setWordWrap(true);
    status_->setObjectName("importStatus");
    layout->addWidget(status_);
    connect(import, &QPushButton::clicked, this, [this] {
      const auto path = QFileDialog::getOpenFileName(
          this, "Import order-lab JSON", {}, "JSON (*.json)");
      if (!path.isEmpty()) {
        download_.cancel();
        showResult(stageFile(path),
                   "Preview ready. Review before replacing saved orders.");
      }
    });
    connect(exportFile, &QPushButton::clicked, this, [this] {
      const auto path = QFileDialog::getSaveFileName(
          this, "Export order-lab JSON", "orders.json", "JSON (*.json)");
      if (path.isEmpty())
        return;
      auto loaded = service_.list();
      if (!succeeded(loaded)) {
        showResult(std::get<Error>(loaded), {});
        return;
      }
      showResult(saveFile(path, std::get<std::vector<Order>>(loaded)),
                 "Exported");
    });
    connect(fetch, &QPushButton::clicked, this, [this, url] {
      clearPreview();
      status_->setText("Loading preview...");
      download_.load(QUrl(url->text()));
    });
    connect(cancel, &QPushButton::clicked, &download_, &OrderDownload::cancel);
    connect(&download_, &OrderDownload::busyChanged, cancel,
            &QPushButton::setEnabled);
    connect(&download_, &OrderDownload::failed, status_, &QLabel::setText);
    connect(&download_, &OrderDownload::ready, this,
            [this](const QByteArray &bytes) {
              showResult(
                  stage(bytes),
                  "Preview ready. Review before replacing saved orders.");
            });
    connect(apply_, &QPushButton::clicked, this,
            [this] { showResult(applyPreview(), "Import committed"); });
  }
  Result<Done> stage(const QByteArray &bytes) {
    clearPreview();
    auto decoded = decode(bytes);
    if (!succeeded(decoded))
      return std::get<Error>(decoded);
    auto current = service_.list();
    if (!succeeded(current))
      return std::get<Error>(current);
    beforePreview_ = std::get<std::vector<Order>>(std::move(current));
    pending_ = std::get<std::vector<Order>>(std::move(decoded));
    QStringList lines{QString("%1 orders will replace the saved list:")
                          .arg(pending_->size())};
    for (const auto &order : *pending_)
      lines << QString("%1 | %2 | priority %3 | %4")
                   .arg(order.id)
                   .arg(QString::fromStdString(order.title))
                   .arg(order.priority)
                   .arg(order.status == Status::open ? "open" : "done");
    preview_->setPlainText(lines.join('\n'));
    apply_->setEnabled(true);
    return Done{};
  }
  Result<Done> stageFile(const QString &path) {
    clearPreview();
    auto loaded = loadFile(path);
    if (!succeeded(loaded))
      return std::get<Error>(loaded);
    auto encoded = encode(std::get<std::vector<Order>>(loaded));
    if (!succeeded(encoded))
      return std::get<Error>(encoded);
    return stage(std::get<QByteArray>(encoded));
  }
  Result<Done> applyPreview() {
    if (!pending_)
      return Error{ErrorCode::invalid, "No import preview"};
    auto current = service_.list();
    if (!succeeded(current))
      return std::get<Error>(current);
    if (std::get<std::vector<Order>>(current) != beforePreview_) {
      clearPreview();
      return Error{ErrorCode::invalid,
                   "Saved orders changed. Create a new preview."};
    }
    auto saved = service_.replace(*pending_);
    if (!succeeded(saved))
      return std::get<Error>(saved);
    clearPreview();
    editor_->refresh();
    return Done{};
  }
};
} // namespace orders
Erwartetes Ergebnis

Das bloße Laden einer Vorschau verändert keine gespeicherten Aufträge.

04Netzwerkimport lokal vorführen

Starte python3 demo_server.py in einem zweiten Terminal und klicke Preview URL. Die Oberfläche bleibt bedienbar und bietet Cancel request. Verwende /error, /invalid und /slow für eine Fehlerdemonstration. Ein erfolgreicher Download erzeugt ebenfalls nur eine Vorschau. Es gibt keine automatische Synchronisation und keinen veröffentlichten Backenddienst.

demo_server.py · pythonDatei öffnen
"""Local synthetic order endpoint. Run with python3 demo_server.py."""

import argparse
import json
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from time import sleep

DOCUMENT = {
    "format": "appfabrik-order-lab",
    "version": 2,
    "orders": [
        {"id": 10, "title": "Deliver motors", "priority": 2, "status": "open"},
        {"id": 20, "title": "Move pallets", "priority": 0, "status": "done"},
    ],
}


class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == "/slow":
            sleep(5)
        status = 500 if self.path == "/error" else 200
        body = (
            b"invalid JSON"
            if self.path == "/invalid"
            else json.dumps(DOCUMENT).encode()
        )
        self.send_response(status)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        try:
            self.wfile.write(body)
        except (BrokenPipeError, ConnectionResetError):
            pass


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--port", type=int, default=8765)
    args = parser.parse_args()
    print(f"Synthetic orders at http://127.0.0.1:{args.port}/orders", flush=True)
    ThreadingHTTPServer(("127.0.0.1", args.port), Handler).serve_forever()
Erwartetes Ergebnis

Die beiden Serveraufträge erscheinen in der Vorschau, bevor sie gespeichert werden.

05Den vollständigen Arbeitsablauf prüfen

Der Integrationstest legt einen Auftrag über den Button an, zerstört Fenster und Repository und öffnet die Datenbank erneut. Er bearbeitet den wieder geladenen Auftrag und prüft ungültigen Import, veraltete Vorschau und einen SQL-Fehler beim zweiten INSERT. Ein weiterer Ablauf verbindet den echten lokalen HTTP-Server mit Vorschau und Übernahme per Button.

tests.cpp · cppDatei öffnen
#include "http_fixture.hpp"
#include "sql_test_helper.hpp"
#include "sqlite_repository.hpp"
#include "test_support.hpp"
#include "window.hpp"
#include <QTemporaryDir>
#include <QtTest>
using namespace orders;
class WorkflowTests : public QObject {
  Q_OBJECT
private slots:
  void networkPreviewAndCommit() {
    MemoryRepository repository;
    OrderService service(repository);
    QVERIFY(succeeded(service.replace(samples())));
    HttpFixture server;
    OrderWindow window(service);
    window.show();
    window.findChild<QLineEdit *>("importUrl")
        ->setText(server.url().toString());
    QTest::mouseClick(window.findChild<QPushButton *>("fetch"), Qt::LeftButton);
    auto *apply = window.findChild<QPushButton *>("applyImport");
    QTRY_VERIFY_WITH_TIMEOUT(apply->isEnabled(), 2000);
    QVERIFY(std::get<std::vector<Order>>(service.list()) == samples());
    QTest::mouseClick(apply, Qt::LeftButton);
    auto saved = std::get<std::vector<Order>>(service.list());
    QCOMPARE(saved.size(), std::size_t{1});
    QCOMPARE(saved[0].id, 7);
    QVERIFY(!apply->isEnabled());
  }
  void persistentWorkflow() {
    QTemporaryDir directory;
    const auto path = directory.filePath("orders.sqlite");
    {
      SqliteRepository repository(path);
      OrderService service(repository);
      OrderWindow window(service);
      window.show();
      window.findChild<QLineEdit *>("title")->setText("Created in UI");
      QTest::mouseClick(window.findChild<QPushButton *>("save"),
                        Qt::LeftButton);
      QCOMPARE(std::get<std::vector<Order>>(service.list()).size(),
               std::size_t{1});
    }
    SqliteRepository repository(path);
    OrderService service(repository);
    OrderWindow window(service);
    window.show();
    QVERIFY(std::get<std::vector<Order>>(service.list())[0].title ==
            "Created in UI");
    auto *table = window.findChild<QTableView *>("orders");
    table->setCurrentIndex(table->model()->index(0, 0));
    window.findChild<QLineEdit *>("title")->setText("Edited after restart");
    QTest::mouseClick(window.findChild<QPushButton *>("save"), Qt::LeftButton);
    const auto before = std::get<std::vector<Order>>(service.list());
    QVERIFY(before[0].title == "Edited after restart");
    QVERIFY(!succeeded(window.stage("broken JSON")));
    QVERIFY(std::get<std::vector<Order>>(service.list()) == before);
    auto import = std::get<QByteArray>(encode(samples()));
    QVERIFY(succeeded(window.stage(import)));
    QVERIFY(std::get<std::vector<Order>>(service.list()) == before);
    QVERIFY(succeeded(service.save({8, "Saved during preview"})));
    QVERIFY(!succeeded(window.applyPreview()));
    QCOMPARE(std::get<std::vector<Order>>(service.list()).size(),
             std::size_t{2});
    const auto latest = std::get<std::vector<Order>>(service.list());
    QVERIFY(succeeded(window.stage(import)));
    QVERIFY(execSql(
        path,
        "CREATE TRIGGER reject_batch BEFORE INSERT ON orders WHEN NEW.id=2 "
        "BEGIN SELECT RAISE(ABORT, 'disk error simulation'); END"));
    QVERIFY(!succeeded(window.applyPreview()));
    QVERIFY(std::get<std::vector<Order>>(service.list()) == latest);
    QVERIFY(execSql(path, "DROP TRIGGER reject_batch"));
    QTest::mouseClick(window.findChild<QPushButton *>("applyImport"),
                      Qt::LeftButton);
    QVERIFY(std::get<std::vector<Order>>(service.list()) == samples());
    const auto file = directory.filePath("export.json");
    QVERIFY(succeeded(saveFile(file, samples())));
    QVERIFY(succeeded(window.stageFile(file)));
    QVERIFY(succeeded(window.applyPreview()));
    SqliteRepository secondReader(path);
    QVERIFY(std::get<std::vector<Order>>(secondReader.list()) == samples());
  }
};
QTEST_MAIN(WorkflowTests)
#include "tests.moc"
Erwartetes Ergebnis

Fehler erhalten den letzten gespeicherten Bestand. Ein erfolgreicher Import ist erneut aus SQLite lesbar.

06Eine komplette Erweiterung liefern

Die Übung ergänzt einen Button, der alle gespeicherten Aufträge gemeinsam abschließt. Die Lösung lädt den Bestand, erzeugt einen Kandidaten und speichert ihn atomar. Erst danach wird die Tabelle aktualisiert. Der Test klickt den Button, öffnet die Datenbank erneut und prüft, dass der Offen-Filter anschließend keine Zeile mehr zeigt.

solution.cpp · cppDatei öffnen
#include "order_editor.hpp"
#include "sqlite_repository.hpp"
#include "test_support.hpp"
#include <QTemporaryDir>
#include <QtTest>
QPushButton *addCompleteButton(orders::OrderEditor &editor,
                               orders::OrderService &service) {
  auto *button = new QPushButton("Complete all saved orders", &editor);
  editor.layout()->addWidget(button);
  QObject::connect(button, &QPushButton::clicked, &editor, [&editor, &service] {
    auto loaded = service.list();
    if (!orders::succeeded(loaded)) {
      editor.report(std::get<orders::Error>(loaded), {});
      return;
    }
    auto batch = std::get<std::vector<orders::Order>>(loaded);
    for (auto &order : batch)
      order.status = orders::Status::done;
    if (editor.report(service.replace(batch), "All saved orders completed"))
      editor.refresh();
  });
  return button;
}
class CompleteTest : public QObject {
  Q_OBJECT
private slots:
  void buttonPersistsBatch() {
    QTemporaryDir directory;
    auto path = directory.filePath("orders.sqlite");
    orders::SqliteRepository repository(path);
    orders::OrderService service(repository);
    QVERIFY(orders::succeeded(service.replace(samples())));
    orders::OrderEditor editor(service);
    auto *button = addCompleteButton(editor, service);
    editor.show();
    QTest::mouseClick(button, Qt::LeftButton);
    orders::SqliteRepository reopened(path);
    const auto persisted = reopened.list();
    QVERIFY(orders::succeeded(persisted));
    for (const auto &order : std::get<std::vector<orders::Order>>(persisted))
      QCOMPARE(order.status, orders::Status::done);
    auto *checkbox = editor.findChild<QCheckBox *>("onlyOpen");
    QTest::mouseClick(checkbox, Qt::LeftButton, {},
                      QPoint(8, checkbox->height() / 2));
    QCOMPARE(editor.findChild<QTableView *>("orders")->model()->rowCount(), 0);
  }
};
QTEST_MAIN(CompleteTest)
#include "solution.moc"
Erwartetes Ergebnis

Alle gespeicherten Aufträge erhalten dauerhaft den Status done.

07Die Arbeitsprobe nachvollziehbar übergeben

Das ZIP enthält Quellcode, beide Anleitungen, Testfixture und Lösung. CTest führt fünf Prüfprogramme aus: Gesamtworkflow, Übung, Netzwerk, Modell und Dateien. Für eine kurze Vorführung: Auftrag anlegen, App neu öffnen, Titel ändern, fehlerhaften Import zeigen und einen gültigen Import bewusst übernehmen. Erkläre anschließend den Einprozess-Vertrag und die noch fehlende native Windows-Abnahme.

CMakeLists.txt · cmakeDatei öffnen
cmake_minimum_required(VERSION 3.25)
project(cpp_24 LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
enable_testing()
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
  add_compile_options(-Wall -Wextra -Wpedantic -Werror)
endif()
find_package(Qt6 6.8 REQUIRED COMPONENTS Core Test Widgets Network Sql)
set(CMAKE_AUTOMOC ON)
add_executable(order_lab main.cpp download.hpp)
target_link_libraries(order_lab PRIVATE Qt6::Core Qt6::Test Qt6::Widgets Qt6::Network Qt6::Sql)
add_executable(lesson_tests tests.cpp download.hpp)
target_link_libraries(lesson_tests PRIVATE Qt6::Core Qt6::Test Qt6::Widgets Qt6::Network Qt6::Sql)
add_test(NAME lesson_tests COMMAND lesson_tests)
set_tests_properties(lesson_tests PROPERTIES TIMEOUT 30)
add_executable(exercise_solution solution.cpp download.hpp)
target_link_libraries(exercise_solution PRIVATE Qt6::Core Qt6::Test Qt6::Widgets Qt6::Network Qt6::Sql)
add_test(NAME exercise_solution COMMAND exercise_solution)
set_tests_properties(exercise_solution PROPERTIES TIMEOUT 30)
add_executable(network_tests network_tests.cpp download.hpp)
target_link_libraries(network_tests PRIVATE Qt6::Core Qt6::Test Qt6::Widgets Qt6::Network Qt6::Sql)
add_test(NAME network_tests COMMAND network_tests)
set_tests_properties(network_tests PROPERTIES TIMEOUT 30)
add_executable(model_tests model_tests.cpp download.hpp)
target_link_libraries(model_tests PRIVATE Qt6::Core Qt6::Test Qt6::Widgets Qt6::Network Qt6::Sql)
add_test(NAME model_tests COMMAND model_tests)
set_tests_properties(model_tests PROPERTIES TIMEOUT 30)
add_executable(files_tests files_tests.cpp download.hpp)
target_link_libraries(files_tests PRIVATE Qt6::Core Qt6::Test Qt6::Widgets Qt6::Network Qt6::Sql)
add_test(NAME files_tests COMMAND files_tests)
set_tests_properties(files_tests PROPERTIES TIMEOUT 30)
Erwartetes Ergebnis

Alle fünf Prüfprogramme bestehen. Die Demo kann ohne Konto gestartet werden.

Deine Übung

Ergänze Complete all saved orders. Verwende den Anwendungsdienst, zeige Fehler in der Oberfläche und aktualisiere die Tabelle nur nach erfolgreichem Speichern. Prüfe den Button sowie die erneut geöffnete Datenbank.

Lösung mit Erklärung anzeigen

addCompleteButton verbindet den Klick mit einem atomaren Stapelupdate und verwendet die vorhandene Fehleranzeige. Der Widgettest prüft den gespeicherten Status über ein zweites Repository und schaltet anschließend den Offen-Filter ein.

solution.cpp · cppDatei öffnen
#include "order_editor.hpp"
#include "sqlite_repository.hpp"
#include "test_support.hpp"
#include <QTemporaryDir>
#include <QtTest>
QPushButton *addCompleteButton(orders::OrderEditor &editor,
                               orders::OrderService &service) {
  auto *button = new QPushButton("Complete all saved orders", &editor);
  editor.layout()->addWidget(button);
  QObject::connect(button, &QPushButton::clicked, &editor, [&editor, &service] {
    auto loaded = service.list();
    if (!orders::succeeded(loaded)) {
      editor.report(std::get<orders::Error>(loaded), {});
      return;
    }
    auto batch = std::get<std::vector<orders::Order>>(loaded);
    for (auto &order : batch)
      order.status = orders::Status::done;
    if (editor.report(service.replace(batch), "All saved orders completed"))
      editor.refresh();
  });
  return button;
}
class CompleteTest : public QObject {
  Q_OBJECT
private slots:
  void buttonPersistsBatch() {
    QTemporaryDir directory;
    auto path = directory.filePath("orders.sqlite");
    orders::SqliteRepository repository(path);
    orders::OrderService service(repository);
    QVERIFY(orders::succeeded(service.replace(samples())));
    orders::OrderEditor editor(service);
    auto *button = addCompleteButton(editor, service);
    editor.show();
    QTest::mouseClick(button, Qt::LeftButton);
    orders::SqliteRepository reopened(path);
    const auto persisted = reopened.list();
    QVERIFY(orders::succeeded(persisted));
    for (const auto &order : std::get<std::vector<orders::Order>>(persisted))
      QCOMPARE(order.status, orders::Status::done);
    auto *checkbox = editor.findChild<QCheckBox *>("onlyOpen");
    QTest::mouseClick(checkbox, Qt::LeftButton, {},
                      QPoint(8, checkbox->height() / 2));
    QCOMPARE(editor.findChild<QTableView *>("orders")->model()->rowCount(), 0);
  }
};
QTEST_MAIN(CompleteTest)
#include "solution.moc"

Projektbezug und Quellen

Eigenständiges Lernprojekt im Logistikthema von FactoryForge. Der bestehende FactoryForge-Quellstand dient als Architekturkontext. Die hier eingeführten SQLite-, Netzwerk- und Importfunktionen sind Funktionen des Lernprojekts. Das Order-Lab-JSON ist ein eigenes Format.