Add transaction commands to the testing framework

test/include/test_runner/test_group.h

@@ -10,15 +10,21 @@ struct TestStatement {
     std::string query;
     uint64_t numThreads = 4;
     std::string encodedJoin;
-    uint64_t expectedNumTuples = 0;
     bool expectedError = false;
+    std::string errorMessage;
     bool expectedOk = false;
+    uint64_t expectedNumTuples = 0;
     std::vector<std::string> expectedTuples;
-    std::string errorMessage;
     bool enumerate = false;
     bool checkOutputOrder = false;
-    bool isBeginWriteTransaction = false;
     std::string expectedTuplesCSVFile;
+    enum class TransactionType {
+        NONE,
+        WRITE,
+        READ_ONLY,
+        COMMIT,
+        ROLLBACK
+    } transactionType = TransactionType::NONE;
 };
 
 // Test group is a collection of test cases in a single file.

test/include/test_runner/test_parser.h

@@ -9,15 +9,17 @@ namespace kuzu {
 namespace testing {
 
 enum class TokenType {
-    /* header */
-    BEGIN_WRITE_TRANSACTION,
+    // header
     DATASET,
     GROUP,
     SKIP,
-    /* body */
+    // body
+    BEGIN_READ_ONLY_TRANSACTION,
+    BEGIN_WRITE_TRANSACTION,
     BUFFER_POOL_SIZE,
     CASE,
     CHECK_ORDER,
+    COMMIT,
     DEFINE,
     DEFINE_STATEMENT_BLOCK,
     EMPTY,
@@ -28,22 +30,25 @@ enum class TokenType {
     LOG,
     PARALLELISM,
     RESULT,
+    ROLLBACK,
     SEPARATOR,
     STATEMENT,
     _SKIP_LINE
 };
 
 const std::unordered_map<std::string, TokenType> tokenMap = {{"-GROUP", TokenType::GROUP},
-    {"-DATASET", TokenType::DATASET}, {"-CASE", TokenType::CASE},
+    {"-DATASET", TokenType::DATASET}, {"-CASE", TokenType::CASE}, {"-COMMIT", TokenType::COMMIT},
     {"-CHECK_ORDER", TokenType::CHECK_ORDER}, {"-ENCODED_JOIN", TokenType::ENCODED_JOIN},
     {"-LOG", TokenType::LOG}, {"-DEFINE_STATEMENT_BLOCK", TokenType::DEFINE_STATEMENT_BLOCK},
     {"-ENUMERATE", TokenType::ENUMERATE},
     {"-BEGIN_WRITE_TRANSACTION", TokenType::BEGIN_WRITE_TRANSACTION},
+    {"-BEGIN_READ_ONLY_TRANSACTION", TokenType::BEGIN_READ_ONLY_TRANSACTION},
     {"-PARALLELISM", TokenType::PARALLELISM}, {"-SKIP", TokenType::SKIP},
     {"-DEFINE", TokenType::DEFINE}, {"-STATEMENT", TokenType::STATEMENT},
     {"-INSERT_STATEMENT_BLOCK", TokenType::INSERT_STATEMENT_BLOCK},
-    {"-BUFFER_POOL_SIZE", TokenType::BUFFER_POOL_SIZE}, {"]", TokenType::END_OF_STATEMENT_BLOCK},
-    {"----", TokenType::RESULT}, {"--", TokenType::SEPARATOR}, {"#", TokenType::EMPTY}};
+    {"-ROLLBACK", TokenType::ROLLBACK}, {"-BUFFER_POOL_SIZE", TokenType::BUFFER_POOL_SIZE},
+    {"]", TokenType::END_OF_STATEMENT_BLOCK}, {"----", TokenType::RESULT},
+    {"--", TokenType::SEPARATOR}, {"#", TokenType::EMPTY}};
 
 class LogicToken {
 public:

test/test_runner/test_parser.cpp

@@ -172,7 +172,19 @@ TestStatement* TestParser::extractStatement(TestStatement* statement) {
         break;
     }
     case TokenType::BEGIN_WRITE_TRANSACTION: {
-        statement->isBeginWriteTransaction = true;
+        statement->transactionType = TestStatement::TransactionType::WRITE;
+        return statement;
+    }
+    case TokenType::BEGIN_READ_ONLY_TRANSACTION: {
+        statement->transactionType = TestStatement::TransactionType::READ_ONLY;
+        return statement;
+    }
+    case TokenType::COMMIT: {
+        statement->transactionType = TestStatement::TransactionType::COMMIT;
+        return statement;
+    }
+    case TokenType::ROLLBACK: {
+        statement->transactionType = TestStatement::TransactionType::ROLLBACK;
         return statement;
     }
     case TokenType::EMPTY: {

test/test_runner/test_runner.cpp

@@ -15,11 +15,24 @@ void TestRunner::runTest(const std::vector<std::unique_ptr<TestStatement>>& stat
     Connection& conn, std::string& databasePath) {
     for (auto& statement : statements) {
         initializeConnection(statement.get(), conn);
-        if (statement->isBeginWriteTransaction) {
+        switch (statement->transactionType) {
+        case TestStatement::TransactionType::WRITE:
             conn.beginWriteTransaction();
-            continue;
+            break;
+        case TestStatement::TransactionType::READ_ONLY:
+            conn.beginReadOnlyTransaction();
+            break;
+        case TestStatement::TransactionType::COMMIT:
+            conn.commit();
+            break;
+        case TestStatement::TransactionType::ROLLBACK:
+            conn.rollback();
+            break;
+        case TestStatement::TransactionType::NONE:
+        default:
+            ASSERT_TRUE(testStatement(statement.get(), conn, databasePath));
+            break;
         }
-        ASSERT_TRUE(testStatement(statement.get(), conn, databasePath));
     }
 }