Cleanup ADatabase::begin and add tests

Author: dantti

src/adatabase.cpp

@@ -124,7 +124,6 @@ bool ADatabase::isOpen() const
 
 AExpectedResult beginHelper(const std::shared_ptr<ADriver> &d, QObject *receiver)
 {
-    Q_ASSERT(d);
     AExpectedResult coro(receiver);
     d->begin(d, receiver, coro.ref());
     return coro;
@@ -136,11 +135,11 @@ AExpectedTransaction ADatabase::begin(QObject *receiver)
     AExpectedTransaction coro(receiver);
     [](auto chainData, ADatabase db, QObject *receiver) -> ACoroTerminator {
         auto result = co_await beginHelper(db.d, receiver);
-        if (result.has_value()) {
-            chainData->deliverDirect(ATransaction::fromStarted(db));
-        } else {
-            chainData->deliverDirect(std::unexpected(result.error()));
+        if (result) {
+            chainData->deliverDirect(ATransaction(db, true));
+            co_return;
         }
+        chainData->deliverDirect(std::unexpected(result.error()));
     }(coro.m_data, *this, receiver);
     return coro;
 }

src/atransaction.cpp

@@ -46,11 +46,6 @@ ATransaction::ATransaction(const ADatabase &db, bool started)
     d->running = started;
 }
 
-ATransaction ATransaction::fromStarted(const ADatabase &db)
-{
-    return ATransaction(db, true);
-}
-
 ATransaction::ATransaction(const ADatabase &db)
     : d(std::make_shared<ATransactionPrivate>(db))
 {

src/atransaction.h

@@ -37,17 +37,6 @@ class ASQL_EXPORT ATransaction
         return *this;
     }
 
-    /*!
-     * \brief fromStarted creates an ATransaction that is already in a started state.
-     *
-     * This factory is used internally when a BEGIN query has already been sent to the
-     * database (e.g. by ADatabase::beginTransaction or APool::begin) and the transaction
-     * object just needs to track that running state.
-     *
-     * \param db the database connection that issued BEGIN
-     */
-    static ATransaction fromStarted(const ADatabase &db);
-
     /*!
      * \brief commit a transaction only if our usage count equals 1
      *
@@ -77,6 +66,7 @@ class ASQL_EXPORT ATransaction
     [[nodiscard]] bool isActive() const;
 
 private:
+    friend class ADatabase;
     ATransaction(const ADatabase &db, bool started);
     std::shared_ptr<ATransactionPrivate> d;
 };

tests/sqlite_tst.cpp

@@ -27,6 +27,8 @@ private Q_SLOTS:
     void testQueries();
     void testPoolBeginCommit();
     void testPoolBeginRollback();
+    void testDatabaseBeginCommit();
+    void testDatabaseBeginRollback();
 };
 
 void TestSqlite::initTest()
@@ -364,6 +366,93 @@ void TestSqlite::testPoolBeginRollback()
     loop.exec();
 }
 
+void TestSqlite::testDatabaseBeginCommit()
+{
+    QEventLoop loop;
+    {
+        auto finished = std::make_shared<QObject>();
+        connect(finished.get(), &QObject::destroyed, &loop, &QEventLoop::quit);
+
+        auto dbBeginCommit = [finished]() -> ACoroTerminator {
+            auto _ = qScopeGuard(
+                [finished] { qDebug() << "dbBeginCommit exited" << finished.use_count(); });
+
+            auto db = co_await APool::database(nullptr, u"file"_s);
+            AVERIFY(db);
+
+            auto create =
+                co_await db->exec(u"CREATE TABLE IF NOT EXISTS db_commit_test (id INTEGER)"_s);
+            AVERIFY(create);
+
+            auto t = co_await db->begin();
+            AVERIFY(t);
+            AVERIFY(t->isActive());
+
+            auto insert = co_await t->database().exec(u"INSERT INTO db_commit_test VALUES (1)"_s);
+            AVERIFY(insert);
+            ACOMPARE_EQ(insert->numRowsAffected(), qint64(1));
+
+            auto commitResult = co_await t->commit();
+            AVERIFY(commitResult);
+            AVERIFY(!commitResult->hasError());
+
+            auto verifyDb = co_await APool::database(nullptr, u"file"_s);
+            AVERIFY(verifyDb);
+            auto select = co_await verifyDb->exec(u"SELECT COUNT(*) FROM db_commit_test"_s);
+            AVERIFY(select);
+            ACOMPARE_EQ((*select)[0][0].toInt(), 1);
+
+            co_await verifyDb->exec(u"DROP TABLE db_commit_test"_s);
+        };
+        dbBeginCommit();
+    }
+    loop.exec();
+}
+
+void TestSqlite::testDatabaseBeginRollback()
+{
+    QEventLoop loop;
+    {
+        auto finished = std::make_shared<QObject>();
+        connect(finished.get(), &QObject::destroyed, &loop, &QEventLoop::quit);
+
+        auto dbBeginRollback = [finished]() -> ACoroTerminator {
+            auto _ = qScopeGuard(
+                [finished] { qDebug() << "dbBeginRollback exited" << finished.use_count(); });
+
+            auto db = co_await APool::database(nullptr, u"file"_s);
+            AVERIFY(db);
+
+            auto create =
+                co_await db->exec(u"CREATE TABLE IF NOT EXISTS db_rollback_test (id INTEGER)"_s);
+            AVERIFY(create);
+
+            auto t = co_await db->begin();
+            AVERIFY(t);
+            AVERIFY(t->isActive());
+
+            auto insert =
+                co_await t->database().exec(u"INSERT INTO db_rollback_test VALUES (42)"_s);
+            AVERIFY(insert);
+            ACOMPARE_EQ(insert->numRowsAffected(), qint64(1));
+
+            auto rollbackResult = co_await t->rollback();
+            AVERIFY(rollbackResult);
+            AVERIFY(!rollbackResult->hasError());
+
+            auto verifyDb = co_await APool::database(nullptr, u"file"_s);
+            AVERIFY(verifyDb);
+            auto select = co_await verifyDb->exec(u"SELECT COUNT(*) FROM db_rollback_test"_s);
+            AVERIFY(select);
+            ACOMPARE_EQ((*select)[0][0].toInt(), 0);
+
+            co_await verifyDb->exec(u"DROP TABLE db_rollback_test"_s);
+        };
+        dbBeginRollback();
+    }
+    loop.exec();
+}
+
 QTEST_MAIN(TestSqlite)
 #include "sqlite_tst.moc"