Add tests.

Author: dnwpark

tests/test_edgeql_delete.py

@@ -665,3 +665,22 @@ async def test_edgeql_delete_where_order_dml(self):
                         (DELETE DeleteTest filter .name = 't1')
                 limit 1
             ''')
+
+    async def test_edgeql_delete_read_only_tx_01(self):
+        con = (
+            edgedb.create_async_client(
+                **self.get_connect_args(database=self.con.dbname)
+            ).with_transaction_options(
+                edgedb.TransactionOptions(readonly=True)
+            )
+        )
+        try:
+            with self.assertRaisesRegex(
+                edgedb.TransactionError,
+                r'Modifications not allowed in a read-only transaction'
+            ):
+                async for tx in con.transaction():
+                    async with tx:
+                        await tx.execute("delete DeleteTest")
+        finally:
+            await con.aclose()

tests/test_edgeql_functions_inline.py

@@ -11576,3 +11576,34 @@ async def reset_data():
             'select Bar.a',
             [3],
         )
+
+
+class TestEdgeQLFunctionsInlineTransaction(tb.QueryTestCase):
+
+    SETUP = [
+        '''
+        create type Bar;
+        create function foo() -> Bar {
+            using ((insert Bar));
+        };
+        '''
+    ]
+
+    async def test_edgeql_functions_inline_transaction_dml_01(self):
+        con = (
+            edgedb.create_async_client(
+                **self.get_connect_args(database=self.con.dbname)
+            ).with_transaction_options(
+                edgedb.TransactionOptions(readonly=True)
+            )
+        )
+        try:
+            with self.assertRaisesRegex(
+                edgedb.TransactionError,
+                r'Modifications not allowed in a read-only transaction'
+            ):
+                async for tx in con.transaction():
+                    async with tx:
+                        await tx.execute("select foo()")
+        finally:
+            await con.aclose()

tests/test_edgeql_insert.py

@@ -7948,6 +7948,48 @@ async def test_edgeql_insert_empty_array_05(self):
             [{'l2': 0, 'subordinates': [{'name': 'hi', '@comment': 'a'}]}],
         )
 
+    async def test_edgeql_insert_read_only_tx_01(self):
+        con = (
+            edgedb.create_async_client(
+                **self.get_connect_args(database=self.con.dbname)
+            ).with_transaction_options(
+                edgedb.TransactionOptions(readonly=True)
+            )
+        )
+        try:
+            with self.assertRaisesRegex(
+                edgedb.TransactionError,
+                r'Modifications not allowed in a read-only transaction'
+            ):
+                async for tx in con.transaction():
+                    async with tx:
+                        await tx.execute("insert Subordinate { name := 'hi' }")
+        finally:
+            await con.aclose()
+
+    async def test_edgeql_insert_read_only_tx_02(self):
+        # Check that the error is raised if the query is cached.
+
+        await self.con.execute("insert Subordinate { name := 'hi' }")
+
+        con = (
+            edgedb.create_async_client(
+                **self.get_connect_args(database=self.con.dbname)
+            ).with_transaction_options(
+                edgedb.TransactionOptions(readonly=True)
+            )
+        )
+        try:
+            with self.assertRaisesRegex(
+                edgedb.TransactionError,
+                r'Modifications not allowed in a read-only transaction'
+            ):
+                async for tx in con.transaction():
+                    async with tx:
+                        await tx.execute("insert Subordinate { name := 'hi' }")
+        finally:
+            await con.aclose()
+
 
 class TestRepeatableReadInsert(tb.QueryTestCase):
     '''The scope of the tests is testing various modes of Object creation.'''

tests/test_edgeql_update.py

@@ -4007,3 +4007,24 @@ async def test_edgeql_update_empty_array_05(self):
                 },
             ],
         )
+
+    async def test_edgeql_update_read_only_tx_01(self):
+        con = (
+            edgedb.create_async_client(
+                **self.get_connect_args(database=self.con.dbname)
+            ).with_transaction_options(
+                edgedb.TransactionOptions(readonly=True)
+            )
+        )
+        try:
+            with self.assertRaisesRegex(
+                edgedb.TransactionError,
+                r'Modifications not allowed in a read-only transaction'
+            ):
+                async for tx in con.transaction():
+                    async with tx:
+                        await tx.execute(
+                            "update UpdateTest set { comment := 'hi' }"
+                        )
+        finally:
+            await con.aclose()

tests/test_server_proto.py

@@ -1568,8 +1568,9 @@ async def test_server_proto_tx_07(self):
             ''')
 
             with self.assertRaisesRegex(
-                    edgedb.TransactionError,
-                    'read-only transaction'):
+                edgedb.TransactionError,
+                'Modifications not allowed in a read-only transaction'
+            ):
 
                 await self.con.query('''
                     INSERT Tmp {
@@ -2344,7 +2345,9 @@ async def test_server_proto_tx_31(self):
             await self.assert_tx_isolation_and_default(
                 'RepeatableRead', default='Serializable'
             )
-            await self.assert_read_only_and_default('read-only transaction')
+            await self.assert_read_only_and_default(
+                'Modifications not allowed in a read-only transaction'
+            )
         finally:
             await self.con.query(f'''
                 ROLLBACK;