Comments

synapse/storage/engines/sqlite.py

@@ -34,6 +34,9 @@ def __init__(self, database_config: Mapping[str, Any]):
             ":memory:",
         )
 
+        # A connection to a database that has already been prepared, to use as a
+        # base for an in-memory connection. This is used during unit tests to
+        # speed up setting up the DB.
         self._prepped_conn: Optional[sqlite3.Connection] = database_config.get(
             "_TEST_PREPPED_CONN"
         )
@@ -86,6 +89,7 @@ def on_new_connection(self, db_conn: "LoggingDatabaseConnection") -> None:
 
         if self._is_in_memory:
             if self._prepped_conn is not None:
+                # Initialise the new DB from the pre-prepared DB.
                 assert isinstance(db_conn.conn, sqlite3.Connection)
                 self._prepped_conn.backup(db_conn.conn)
             else:

tests/server.py

@@ -107,7 +107,9 @@
 # the type of thing that can be passed into `make_request` in the headers list
 CustomHeaderType = Tuple[Union[str, bytes], Union[str, bytes]]
 
-PREPPED_DB_CONN: Optional[LoggingDatabaseConnection] = None
+# A pre-prepared SQLite DB that is used as a template when creating new SQLite
+# DB each test run. This dramatically speeds up test set up when using SQLite.
+PREPPED_SQlITE_DB_CONN: Optional[LoggingDatabaseConnection] = None
 
 
 class TimedOutException(Exception):
@@ -904,18 +906,21 @@ def setup_test_homeserver(
             "args": {"database": test_db_location, "cp_min": 1, "cp_max": 1},
         }
 
-        global PREPPED_DB_CONN
-        if PREPPED_DB_CONN is None:
+        # Check if we have set up a DB that we can use as a template.
+        global PREPPED_SQlITE_DB_CONN
+        if PREPPED_SQlITE_DB_CONN is None:
             temp_engine = create_engine(database_config)
-            PREPPED_DB_CONN = LoggingDatabaseConnection(
+            PREPPED_SQlITE_DB_CONN = LoggingDatabaseConnection(
                 sqlite3.connect(":memory:"), temp_engine, "PREPPED_CONN"
             )
 
             database = DatabaseConnectionConfig("master", database_config)
             config.database.databases = [database]
-            prepare_database(PREPPED_DB_CONN, create_engine(database_config), config)
+            prepare_database(
+                PREPPED_SQlITE_DB_CONN, create_engine(database_config), config
+            )
 
-        database_config["_TEST_PREPPED_CONN"] = PREPPED_DB_CONN
+        database_config["_TEST_PREPPED_CONN"] = PREPPED_SQlITE_DB_CONN
 
     if "db_txn_limit" in kwargs:
         database_config["txn_limit"] = kwargs["db_txn_limit"]

tests/unittest.py

@@ -163,11 +163,22 @@ def tearDown(orig: Callable[[], R]) -> R:
 
             return orig()
 
+        # We want to force a GC to workaround problems with deferreds leaking
+        # logcontexts when they are GCed (see the logcontext docs).
+        #
+        # The easiest way to do this would be to do a full GC after each test
+        # run, but that is very expensive. Instead, we disable GC for the
+        # duration of the test so that we only need to run a gen-0 GC, which is
+        # a lot quicker.
+
+        @around(self)
+        def setUp(orig: Callable[[], R]) -> R:
+            gc.disable()
+            return orig()
+
         @around(self)
         def tearDown(orig: Callable[[], R]) -> R:
             ret = orig()
-            # force a GC to workaround problems with deferreds leaking logcontexts when
-            # they are GCed (see the logcontext docs)
             gc.collect(0)
             set_current_context(SENTINEL_CONTEXT)