Add v3 Locations performance test and update script support

- Add TestDojoImporterPerformanceSmallLocations with V3_FEATURE_LOCATIONS
- Update update_performance_test_counts.py to run both v2 and v3 test classes
- Add --no-keepdb and EXTRA_ARGS to run-unittest.sh for test flexibility

Author: valentijnscholten

run-unittest.sh

@@ -1,6 +1,8 @@
 #!/usr/bin/env bash
 unset TEST_CASE
 unset FAIL_FAST
+unset KEEP_DB
+EXTRA_ARGS=()
 
 bash ./docker/docker-compose-check.sh
 if [[ $? -eq 1 ]]; then exit 1; fi
@@ -12,6 +14,7 @@ usage() {
   echo "Options:"
   echo "  --test-case -t {YOUR_FULLY_QUALIFIED_TEST_CASE}"
   echo "  --fail-fast -f - stop on first test failure"
+  echo "  --no-keepdb - recreate the test database (don't reuse existing)"
   echo "  --help -h - prints this dialogue."
   echo
   echo "You must specify a test case (arg)!"
@@ -41,6 +44,10 @@ while [[ $# -gt 0 ]]; do
       FAIL_FAST="--failfast"
       shift # past argument
       ;;
+    --no-keepdb)
+      KEEP_DB=""
+      shift # past argument
+      ;;
     -h|--help)
       usage
       exit 0
@@ -66,4 +73,5 @@ echo "Running docker compose unit tests with test case $TEST_CASE ..."
 # Compose V2 integrates compose functions into the Docker platform, continuing to support
 # most of the  previous docker-compose features and flags. You can run Compose V2 by
 # replacing the hyphen (-) with a space, using docker compose, instead of docker-compose.
-docker compose exec uwsgi bash -c "python manage.py test $TEST_CASE -v2 --keepdb $FAIL_FAST"
+KEEP_DB="${KEEP_DB:---keepdb}"
+docker compose exec uwsgi bash -c "python manage.py test $TEST_CASE -v2 $KEEP_DB $FAIL_FAST ${EXTRA_ARGS[*]}"

scripts/update_performance_test_counts.py

@@ -11,20 +11,18 @@
 
 How to run:
 
-    # Default: Update the test file (uses TestDojoImporterPerformanceSmall by default)
+    # Default: Update both v2 and v3 test classes
     python3 scripts/update_performance_test_counts.py
 
-    # Or specify a different test class:
-    python3 scripts/update_performance_test_counts.py --test-class TestDojoImporterPerformanceSmall
-
     # Step 1: Run tests and generate report only (without updating)
     python3 scripts/update_performance_test_counts.py --report-only
 
     # Step 2: Verify all tests pass
     python3 scripts/update_performance_test_counts.py --verify
 
-The script defaults to TestDojoImporterPerformanceSmall if --test-class is not provided.
-The script defaults to --update behavior if no action flag is provided.
+The script always runs and updates both TestDojoImporterPerformanceSmall (v2) and
+TestDojoImporterPerformanceSmallLocations (v3). The script defaults to --update
+behavior if no action flag is provided.
 """
 
 import argparse
@@ -36,6 +34,12 @@
 # Path to the test file
 TEST_FILE = Path(__file__).parent.parent / "unittests" / "test_importers_performance.py"
 
+# Both v2 and v3 performance test classes - script always updates/verifies both
+TEST_CLASSES = (
+    "TestDojoImporterPerformanceSmall",
+    "TestDojoImporterPerformanceSmallLocations",
+)
+
 
 class TestCount:
 
@@ -64,9 +68,9 @@ def extract_test_methods(test_class: str) -> list[str]:
 
     content = TEST_FILE.read_text()
 
-    # Find the test class definition
+    # Find the test class definition (use (?<!-) to avoid matching "test-class" in docstrings)
     class_pattern = re.compile(
-        rf"class {re.escape(test_class)}.*?(?=class |\Z)",
+        rf"class {re.escape(test_class)}.*?(?=(?<!-)class \w|\Z)",
         re.DOTALL,
     )
     class_match = class_pattern.search(content)
@@ -362,12 +366,17 @@ def generate_report(counts: list[TestCount], expected_counts: dict[str, dict[str
 
     print("=" * 80)
     print("\nTo update the test file, run:")
-    print(f"  python scripts/update_performance_test_counts.py --test-class {test_name.split('_')[0]} --update")
+    print("  python3 scripts/update_performance_test_counts.py")
     print()
 
 
-def update_test_file(counts: list[TestCount]):
-    """Update the test file with new expected counts."""
+def update_test_file(counts: list[TestCount], test_class: str | None = None):
+    """
+    Update the test file with new expected counts.
+
+    When test_class is provided, only update test methods within that class.
+    This is required when multiple classes (e.g. v2 and v3) share the same test method names.
+    """
     if not counts:
         print("No counts to update.")
         return
@@ -419,22 +428,37 @@ def _extract_call_span(method_content: str, call_name: str) -> tuple[int, int] |
         "second_import_async_tasks": "expected_num_async_tasks2",
     }
 
+    # Restrict search to the specified test class if given
+    search_content = content
+    search_offset = 0
+    if test_class:
+        class_pattern = re.compile(
+            rf"class {re.escape(test_class)}.*?(?=(?<!-)class \w|\Z)",
+            re.DOTALL,
+        )
+        class_match = class_pattern.search(content)
+        if not class_match:
+            print(f"⚠️  Warning: Could not find test class {test_class}")
+            return
+        search_content = class_match.group(0)
+        search_offset = class_match.start()
+
     # Update each test method
     for test_name, test_updates in updates.items():
         print(f"  Updating {test_name}...")
-        # Find the test method boundaries
+        # Find the test method boundaries within the search scope
         test_method_pattern = re.compile(
             rf"(def {re.escape(test_name)}\([^)]*\):.*?)(?=def test_|\Z)",
             re.DOTALL,
         )
-        test_match = test_method_pattern.search(content)
+        test_match = test_method_pattern.search(search_content)
         if not test_match:
             print(f"⚠️  Warning: Could not find test method {test_name}")
             continue
 
         test_method_content = test_match.group(1)
-        test_method_start = test_match.start()
-        test_method_end = test_match.end()
+        test_method_start = search_offset + test_match.start()
+        test_method_end = search_offset + test_match.end()
 
         call_span = _extract_call_span(test_method_content, "self._import_reimport_performance")
         param_map = param_map_import_reimport
@@ -543,12 +567,6 @@ def main():
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog=__doc__,
     )
-    parser.add_argument(
-        "--test-class",
-        required=False,
-        default="TestDojoImporterPerformanceSmall",
-        help="Test class name (e.g., TestDojoImporterPerformanceSmall). Defaults to TestDojoImporterPerformanceSmall if not provided.",
-    )
     parser.add_argument(
         "--report-only",
         action="store_true",
@@ -568,96 +586,111 @@ def main():
     args = parser.parse_args()
 
     if args.report_only:
-        # Step 1: Run tests and generate report
-        # Run each test method individually
-        test_methods = extract_test_methods(args.test_class)
-        if not test_methods:
-            print(f"⚠️  No test methods found in {args.test_class}")
-            sys.exit(1)
-
-        print(f"\nFound {len(test_methods)} test method(s) in {args.test_class}")
-        print("=" * 80)
-
+        # Step 1: Run tests and generate report for both test classes
         all_counts = []
-        for test_method in test_methods:
-            print(f"\n{'=' * 80}")
-            output, return_code = run_test_method(args.test_class, test_method)
-            success, error_msg = check_test_execution_success(output, return_code)
-            if not success:
-                print(f"\n⚠️  Test execution failed for {test_method}: {error_msg}")
-                print("Skipping this test method...")
+        for test_class in TEST_CLASSES:
+            test_methods = extract_test_methods(test_class)
+            if not test_methods:
+                print(f"⚠️  No test methods found in {test_class}")
                 continue
 
-            counts = parse_test_output(output)
-            if counts:
-                all_counts.extend(counts)
+            print(f"\n{'=' * 80}")
+            print(f"Test class: {test_class} ({len(test_methods)} methods)")
+            print("=" * 80)
+
+            for test_method in test_methods:
+                print("\n---")
+                output, return_code = run_test_method(test_class, test_method)
+                success, error_msg = check_test_execution_success(output, return_code)
+                if not success:
+                    print(f"\n⚠️  Test execution failed for {test_method}: {error_msg}")
+                    print("Skipping this test method...")
+                    continue
+
+                counts = parse_test_output(output)
+                if counts:
+                    all_counts.extend(counts)
 
-        expected_counts = extract_expected_counts_from_file(args.test_class)
-        generate_report(all_counts, expected_counts)
+        if all_counts:
+            generate_report(all_counts, {})
+        else:
+            print("✅ All tests passed! No count differences found.")
 
     elif args.verify:
-        # Step 3: Verify
-        success = verify_tests(args.test_class)
-        sys.exit(0 if success else 1)
+        # Step 3: Verify both test classes
+        all_pass = True
+        for test_class in TEST_CLASSES:
+            if not verify_tests(test_class):
+                all_pass = False
+        sys.exit(0 if all_pass else 1)
 
     else:
         # Default: Update the file (--update is the default behavior)
-        # Run each test method individually
-        test_methods = extract_test_methods(args.test_class)
-        if not test_methods:
-            print(f"⚠️  No test methods found in {args.test_class}")
-            sys.exit(1)
-
-        print(f"\nFound {len(test_methods)} test method(s) in {args.test_class}")
-        print("=" * 80)
-
+        # Run each test method in both test classes
         all_counts = []
-        for test_method in test_methods:
-            print(f"\n{'=' * 80}")
-            output, return_code = run_test_method(args.test_class, test_method)
-            success, error_msg = check_test_execution_success(output, return_code)
-            if not success:
-                print(f"\n⚠️  Test execution failed for {test_method}: {error_msg}")
-                print("Skipping this test method...")
+        for test_class in TEST_CLASSES:
+            test_methods = extract_test_methods(test_class)
+            if not test_methods:
+                print(f"⚠️  No test methods found in {test_class}")
                 continue
 
-            counts = parse_test_output(output)
-
-            # Check if test actually passed
-            test_passed = "OK" in output or ("Ran" in output and "FAILED" not in output and return_code == 0)
-
-            if counts:
-                all_counts.extend(counts)
-                # Update immediately after each test
-                update_test_file(counts)
-                print(f"⚠️  {test_method}: Found {len(counts)} count mismatch(es) - updated file")
-            elif test_passed:
-                print(f"✅ {test_method}: Test passed, all counts match")
-            elif return_code != 0:
-                # Test might have failed for other reasons
-                print(f"⚠️  {test_method}: Test failed (exit code {return_code}) but no count mismatches parsed")
-                print("   This might indicate a parsing issue or a different type of failure")
-                # Show a snippet of the output to help debug
-                fail_lines = [line for line in output.split("\n") if "FAIL" in line or "Error" in line or "Exception" in line]
-                if fail_lines:
-                    print("   Relevant error lines:")
-                    for line in fail_lines[:5]:
-                        print(f"     {line}")
+            print(f"\n{'=' * 80}")
+            print(f"Test class: {test_class} ({len(test_methods)} methods)")
+            print("=" * 80)
+
+            for test_method in test_methods:
+                print("\n---")
+                output, return_code = run_test_method(test_class, test_method)
+                success, error_msg = check_test_execution_success(output, return_code)
+                if not success:
+                    print(f"\n⚠️  Test execution failed for {test_method}: {error_msg}")
+                    print("Skipping this test method...")
+                    continue
+
+                counts = parse_test_output(output)
+
+                # Check if test actually passed
+                test_passed = "OK" in output or ("Ran" in output and "FAILED" not in output and return_code == 0)
+
+                if counts:
+                    all_counts.extend(counts)
+                    # Update immediately after each test
+                    update_test_file(counts, test_class=test_class)
+                    print(f"⚠️  {test_method}: Found {len(counts)} count mismatch(es) - updated file")
+                elif test_passed:
+                    print(f"✅ {test_method}: Test passed, all counts match")
+                elif return_code != 0:
+                    # Test might have failed for other reasons
+                    print(f"⚠️  {test_method}: Test failed (exit code {return_code}) but no count mismatches parsed")
+                    print("   This might indicate a parsing issue or a different type of failure")
+                    fail_lines = [line for line in output.split("\n") if "FAIL" in line or "Error" in line or "Exception" in line]
+                    if fail_lines:
+                        print("   Relevant error lines:")
+                        for line in fail_lines[:5]:
+                            print(f"     {line}")
 
         if all_counts:
             print(f"\n{'=' * 80}")
             print(f"✅ Updated {len(all_counts)} count(s) across {len({c.test_name for c in all_counts})} test(s)")
             # Some performance counts can vary depending on test ordering / keepdb state.
             # Do a final full-suite pass and apply any remaining mismatches so the suite passes as run in CI.
             print("\nRunning a final verify pass for stability...")
-            success, suite_mismatches = verify_and_get_mismatches(args.test_class)
-            if not success and suite_mismatches:
-                print("\nApplying remaining mismatches from full-suite run...")
-                update_test_file(suite_mismatches)
+            all_pass = True
+            for test_class in TEST_CLASSES:
+                success, suite_mismatches = verify_and_get_mismatches(test_class)
+                if not success and suite_mismatches:
+                    print(f"\nApplying remaining mismatches from {test_class}...")
+                    update_test_file(suite_mismatches, test_class=test_class)
+                    all_pass = False
+            if not all_pass:
                 print("\nRe-running verify...")
-                success, _ = verify_and_get_mismatches(args.test_class)
-                sys.exit(0 if success else 1)
-            sys.exit(0 if success else 1)
+                all_pass = True
+                for test_class in TEST_CLASSES:
+                    success, _ = verify_and_get_mismatches(test_class)
+                    if not success:
+                        all_pass = False
+                sys.exit(0 if all_pass else 1)
+            sys.exit(0 if all_pass else 1)
         else:
             print(f"\n{'=' * 80}")
             print("\n✅ No differences found. All tests are already up to date.")