Speed up serialize and deserialize, don't load tests on init

pyproject.toml

@@ -5,15 +5,19 @@ include = '''
 (
   ^\/python\/moosecontrol\/.*.py$ |
   ^\/python\/TestHarness\/resultsstore\/.*.py$ |
-  ^\/python\/TestHarness/tests/test_resultsstore.*.py$
+  ^\/python\/TestHarness\/resultssummary\/.*.py$ |
+  ^\/python\/TestHarness/tests/resultsstore\/.*.py$ |
+  ^\/python\/TestHarness/tests/resultssummary\/.*.py$
 )
 '''
 
 [tool.ruff]
 include = [
   "python/moosecontrol/**/*.py",
   "python/TestHarness/resultsstore/**/*.py",
-  "python/TestHarness/tests/test_resultsstore*.py"
+  "python/TestHarness/resultssummary/**/*.py",
+  "python/TestHarness/tests/resultsstore/**/*.py",
+  "python/TestHarness/tests/resultssummary/**/*.py"
 ]
 exclude = ["python/moosecontrol/requests_unixsocket/*.py"]
 

python/TestHarness/.coveragerc

@@ -0,0 +1,13 @@
+[run]
+concurrency = thread
+branch = True
+source =
+    resultsstore/*
+    resultssummary/*
+omit =
+    resultsstore/*/tests
+parallel = False
+
+[report]
+show_missing = True
+fail_under = 100

python/TestHarness/TestHarness.py

@@ -18,7 +18,7 @@
 import argparse
 import typing
 from collections import defaultdict, namedtuple, OrderedDict
-from typing import Any, Tuple
+from typing import Tuple, Optional
 
 from socket import gethostname
 
@@ -224,9 +224,11 @@ class TestHarness:
     # 2 - Added 'abs_zero' key to ValidationNumericData
     VALIDATION_VERSION = 2
 
+    __test__ = False  # prevents pytest collection
+
     @staticmethod
-    def build(argv: list, app_name: str, moose_dir: str, moose_python: str = None,
-              skip_testroot: bool = False) -> None:
+    def build(argv: list, app_name: str, moose_dir: str, moose_python: Optional[str] = None,
+              skip_testroot: bool = False) -> "TestHarness":
         # Cannot skip the testroot if we don't have an application name
         if skip_testroot and not app_name:
             raise ValueError(f'Must provide "app_name" when skip_testroot=True')

python/TestHarness/pytest.ini

@@ -0,0 +1,13 @@
+[pytest]
+addopts =
+    -vvv
+    --cov=TestHarness.resultsstore
+    --cov=TestHarness.resultssummary
+    --cov-config=.coveragerc
+    --durations=20
+testpaths =
+    tests/resultsstore
+    tests/resultssummary
+markers =
+    moose: marks tests as requiring moose (use --no-moose to skip)
+    live_db: marks tests as using a live database (use --no-live-db to skip)

python/TestHarness/resultsstore/auth.py

@@ -65,14 +65,15 @@ def get_var(key: str) -> Optional[str]:
             auth[key] = v
     # Have all three set
     if len(auth) == 3:
-        auth["port"] = get_var("port")
+        port = get_var("port")
+        auth["port"] = int(port) if port is not None else None
         return Authentication(**auth)
     # Have one or two but not all three set
     if len(auth) != 0:
         all_auth_vars = " ".join(map(var_name, all_auth_keys))
         raise ValueError(
             f'All environment variables "{all_auth_vars}"'
-            "must be set for authentication"
+            " must be set for authentication"
         )
 
     # Try to get authentication from file
@@ -85,8 +86,3 @@ def get_var(key: str) -> Optional[str]:
         return Authentication(**values)
     except Exception as e:
         raise Exception(f"Failed to load credentials from '{auth_file}'") from e
-
-
-def has_authentication(var_prefix: str) -> bool:
-    """Check whether or not environment authentication is available."""
-    return load_authentication(var_prefix) is not None

python/TestHarness/resultsstore/civetstore.py

@@ -16,22 +16,18 @@
 import re
 from copy import deepcopy
 from datetime import datetime
-from typing import Optional, Tuple
+from typing import Optional, Sequence, Tuple
 
 from bson import encode
 from bson.objectid import ObjectId
 from pymongo import MongoClient
 
-from TestHarness.resultsstore.auth import (
-    Authentication,
-    has_authentication,
-    load_authentication,
-)
+from TestHarness.resultsstore import auth
 from TestHarness.resultsstore.utils import (
     TestName,
     compress_dict,
-    results_folder_iterator,
-    results_test_iterator,
+    mutable_results_folder_iterator,
+    mutable_results_test_iterator,
 )
 
 NoneType = type(None)
@@ -93,7 +89,7 @@ class CIVETStore:
     CIVET_VERSION = 6
 
     @staticmethod
-    def parse_args() -> argparse.Namespace:
+    def parse_args(args: Sequence[str]) -> argparse.Namespace:
         """Parse command-line arguments."""
         parser = argparse.ArgumentParser(
             description="Converts test results from a CIVET run for "
@@ -125,10 +121,10 @@ def parse_args() -> argparse.Namespace:
             default=MAX_RESULT_SIZE,
             help="Max size of a result for tests to be stored within it",
         )
-        return parser.parse_args()
+        return parser.parse_args(args)
 
     @staticmethod
-    def load_authentication() -> Optional[Authentication]:
+    def load_authentication() -> Optional[auth.Authentication]:
         """
         Load mongo authentication, if available.
 
@@ -138,12 +134,7 @@ def load_authentication() -> Optional[Authentication]:
         environment from the file set by env var
         CIVET_STORE_AUTH_FILE if it is available.
         """
-        return load_authentication("CIVET_STORE")
-
-    @staticmethod
-    def has_authentication() -> bool:
-        """Check whether or not authentication is available."""
-        return has_authentication("CIVET_STORE")
+        return auth.load_authentication("CIVET_STORE")
 
     @staticmethod
     def get_document_size(doc: dict) -> float:
@@ -388,7 +379,7 @@ def build(
         # Remove skipped tests if requested
         num_skipped_tests = 0
         if kwargs.get("ignore_skipped"):
-            for folder in results_folder_iterator(results):
+            for folder in mutable_results_folder_iterator(results):
                 for test in folder.test_iterator():
                     if test.value["status"]["status"] == "SKIP":
                         num_skipped_tests += 1
@@ -397,14 +388,13 @@ def build(
 
         # Cleanup each test as needed
         num_tests = 0
-        for test in results_test_iterator(results):
+        for test in mutable_results_test_iterator(results):
             test_values = test.value
             num_tests += 1
 
             # Remove all output from results
             for key in ["output", "output_files"]:
-                if key in test_values:
-                    del test_values[key]
+                del test_values[key]
 
             # Remove keys if requested
             for entry in ["status", "timing", "tester"]:
@@ -439,7 +429,7 @@ def build(
             tests = {}
             tests_size = 0
             oversized_tests = []
-            for test in results_test_iterator(results):
+            for test in mutable_results_test_iterator(results):
                 # Test data in the result entry, separated
                 test_data = deepcopy(test.value)
                 # Store and check test size
@@ -486,39 +476,23 @@ def setup_client() -> MongoClient:
             auth.host, auth.port, username=auth.username, password=auth.password
         )
 
-    def store(
-        self, database: str, results: dict, base_sha: str, **kwargs
-    ) -> Tuple[ObjectId, Optional[list[ObjectId]]]:
+    @staticmethod
+    def _build_database(
+        result: dict, tests: Optional[dict[TestName, dict]]
+    ) -> Tuple[dict, list[dict]]:
         """
-        Store the data in the database from a test harness result.
+        Build entries for the database from the return of build().
 
         Parameters
         ----------
-        database : str
-            The name of the mongo database to store into
-        results : dict
-            The results that come from TestHarness JSON result output
-        base_sha : str
-            The base commit SHA for the CIVET event
-
-        Optional Parameters
-        -------------------
-        **kwargs :
-            See build().
-
-        Returns
-        -------
-        ObjectID:
-            The mongo ObjectID of the inserted results document
-        list[ObjectId] or None:
-            The mongo ObjectIDs of the inserted test documents, if any;
-            this will be None if tests are small enough to be stored
-            within the results document (determined by build())
+        result : dict
+            The top level result entry.
+        tests : Optional[dict[TestName, dict]]
+            The separate test entires, if any.
 
         """
-        assert isinstance(database, str)
-
-        result, tests = self.build(results, base_sha, **kwargs)
+        # Don't modify the input
+        result = deepcopy(result)
 
         # Assign an ID for the result
         result_id = ObjectId()
@@ -528,8 +502,9 @@ def store(
         insert_tests = []
         test_ids = None
         if tests:
+            tests = deepcopy(tests)
             test_ids = []
-            for result_test in results_test_iterator(result):
+            for result_test in mutable_results_test_iterator(result):
                 # Get the separate test data
                 test_data = tests[result_test.name]
 
@@ -547,23 +522,85 @@ def store(
                 assert result_test.value is None
                 result_test.set_value(test_id)
 
-        # Do the insertion
+        return result, insert_tests
+
+    def _insert_database(self, database: str, result: dict, tests: list[dict]) -> None:
+        """
+        Insert a result and optionally separate tests into the database.
+
+        Used in store(), but kept separate for unit testing.
+
+        Parameters
+        ----------
+        database : str
+            The name of the mongo database to store into.
+        result : dict
+            The results to store.
+        tests : list[dict]
+            The separate tests to store.
+
+        """
+        assert isinstance(database, str)
+        assert isinstance(result, dict)
+        assert isinstance(tests, list)
+        result_id = result["_id"]
+        assert isinstance(result_id, ObjectId)
+
         with self.setup_client() as client:
             db = client[database]
 
             inserted_result = db.results.insert_one(result)
             assert inserted_result.acknowledged
-            assert result_id == inserted_result.inserted_id
-            print(f"Inserted result {result_id} into {database}")
+            assert inserted_result.inserted_id == result_id
+            print(f"Inserted result {inserted_result.inserted_id} into {database}")
 
-            if insert_tests:
-                inserted_tests = db.tests.insert_many(insert_tests)
+            if tests:
+                inserted_tests = db.tests.insert_many(tests)
                 assert inserted_tests.acknowledged
-                assert isinstance(test_ids, list)
-                assert set(test_ids) == set(inserted_tests.inserted_ids)
-                print(f"Inserted {len(test_ids)} tests into {database}")
+                print(f"Inserted {len(tests)} tests into {database}")
+
+    def store(
+        self, database: str, results: dict, base_sha: str, **kwargs
+    ) -> Tuple[ObjectId, Optional[list[ObjectId]]]:
+        """
+        Store the data in the database from a test harness result.
+
+        Parameters
+        ----------
+        database : str
+            The name of the mongo database to store into
+        results : dict
+            The results that come from TestHarness JSON result output
+        base_sha : str
+            The base commit SHA for the CIVET event
+
+        Optional Parameters
+        -------------------
+        **kwargs :
+            See build().
+
+        Returns
+        -------
+        ObjectID:
+            The mongo ObjectID of the inserted results document
+        list[ObjectId] or None:
+            The mongo ObjectIDs of the inserted test documents, if any;
+            this will be None if tests are small enough to be stored
+            within the results document (determined by build())
+
+        """
+        # Get the data
+        result, tests = self.build(results, base_sha, **kwargs)
 
-        return result_id, test_ids
+        # Build for storage in the database
+        insert_result, insert_tests = self._build_database(result, tests)
+
+        # Do the insertion
+        self._insert_database(database, insert_result, insert_tests)
+
+        return insert_result["_id"], (
+            [v["_id"] for v in insert_tests] if insert_tests else None
+        )
 
     def main(
         self, result_path: str, database: str, base_sha: str, **kwargs
@@ -610,6 +647,8 @@ def main(
         return self.store(database, results, base_sha, **kwargs)
 
 
-if __name__ == "__main__":
-    args = CIVETStore.parse_args()
+if __name__ == "__main__":  # pragma: no cover
+    from sys import argv
+
+    args = CIVETStore.parse_args(argv[1:])
     CIVETStore().main(**vars(args))