smart-tests-cli 2.9.1__tar.gz → 2.11.0__tar.gz

{smart_tests_cli-2.9.1 → smart_tests_cli-2.11.0}/.pre-commit-config.yaml

@@ -26,7 +26,7 @@ repos:
         - tests/*.py
 
   - repo: https://github.com/hhatto/autopep8
-    rev: v2.3.1
+    rev: v2.3.2
     hooks:
     - id: autopep8
       args:

{smart_tests_cli-2.9.1/smart_tests_cli.egg-info → smart_tests_cli-2.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-tests-cli
-Version: 2.9.1
+Version: 2.11.0
 Summary: Smart Tests CLI
 Author-email: CloudBees <support@cloudbees.com>
 License: Apache Software License v2

{smart_tests_cli-2.9.1 → smart_tests_cli-2.11.0}/smart_tests/commands/subset.py

@@ -2,6 +2,7 @@ import glob
 import json
 import os
 import pathlib
+import random
 import re
 import subprocess
 import sys
@@ -44,6 +45,12 @@ class SubsetUseCase(str, Enum):
     RECURRING = "recurring"
 
 
+class FallbackMode(str, Enum):
+    RUN_ALL = "run-all"
+    STOP = "stop"
+    RANDOM_SAMPLE = "random-sample"
+
+
 class SubsetResult:
     def __init__(
             self,
@@ -82,6 +89,14 @@ class SubsetResult:
             is_observation=False
         )
 
+    @classmethod
+    def from_random_sample(cls, test_paths: List[TestPath], target: float) -> 'SubsetResult':
+        count = max(1, round(len(test_paths) * target))
+        sampled = random.sample(test_paths, min(count, len(test_paths)))
+        sampled_set = {id(t): t for t in sampled}
+        rest = [t for t in test_paths if id(t) not in sampled_set]
+        return cls(subset=sampled, rest=rest, subset_id='', summary={}, is_brainless=False, is_observation=False)
+
 
 # Where we take TestPath, we also accept a path name as a string.
 TestPathLike = str | TestPath
@@ -214,6 +229,14 @@ class Subset(TestPathWriter):
                 "--use-case",
                 hidden=True
             )] = None,
+            fallback_mode: Annotated[FallbackMode, typer.Option(
+                "--fallback-mode",
+                hidden=True,
+                help="Behavior when the subset API is unavailable or the model is untrained. "
+                     "'run-all' (default) runs all tests as usual; 'stop' exits with a non-zero status so CI halts; "
+                     "'random-sample' picks a random subset locally based on the count derived from --target "
+                     "(no duration estimates are available in this path).",
+            )] = FallbackMode.RUN_ALL,
             test_runner: Annotated[str | None, typer.Argument()] = None,
     ):
         super().__init__(app)
@@ -295,6 +318,7 @@ class Subset(TestPathWriter):
         self.same_bin_files = list(same_bin_files)
         self.is_get_tests_from_guess = is_get_tests_from_guess
         self.use_case = use_case
+        self.fallback_mode = fallback_mode
 
         self._validate_print_input_snapshot_option()
 
@@ -569,6 +593,22 @@ class Subset(TestPathWriter):
         if not found:
             warn_and_exit_if_fail_fast_mode("Nothing that looks like a test file in the current git repository.")
 
+    def _fallback_result(self) -> SubsetResult:
+        if self.fallback_mode == FallbackMode.STOP:
+            click.echo(
+                "Warning: Smart Tests could not retrieve a subset. Stopping build (--fallback-mode=stop).",
+                err=True,
+            )
+            sys.exit(1)
+        elif self.fallback_mode == FallbackMode.RANDOM_SAMPLE:
+            target_fraction = float(self.target) if self.target is not None else 1.0
+            click.echo(
+                f"Warning: Smart Tests could not retrieve a subset. Falling back to local random sample at {
+                    target_fraction:.0%}.", err=True, )
+            return SubsetResult.from_random_sample(self.test_paths, target_fraction)
+        else:
+            return SubsetResult.from_test_paths(self.test_paths)
+
     def request_subset(self) -> SubsetResult:
         # temporarily extend the timeout because subset API response has become slow
         # TODO: remove this line when API response return response
@@ -604,7 +644,7 @@ class Subset(TestPathWriter):
             )
             self.client.print_exception_and_recover(
                 e, "Warning: the service failed to subset. Falling back to running all tests")
-            return SubsetResult.from_test_paths(self.test_paths)
+            return self._fallback_result()
 
     def _requires_test_input(self) -> bool:
         return (
@@ -699,17 +739,23 @@ class Subset(TestPathWriter):
         if not self.session_id:
             # Session ID in --session is missing. It might be caused by
             # Launchable API errors.
-            subset_result = SubsetResult.from_test_paths(self.test_paths)
+            subset_result = self._fallback_result()
         else:
             subset_result = self.request_subset()
 
         if len(subset_result.subset) == 0:
-            warn_and_exit_if_fail_fast_mode("Error: no tests found matching the path.")
-            if self.print_input_snapshot_id:
-                self._print_input_snapshot_id_value(subset_result)
-            if self.subset_id_file:
-                self._write_subset_id_to_file(subset_result)
-            return
+            if len(subset_result.rest) > 0 and self.client.is_pts_v2_enabled() and self.confidence is not None:
+                # Adaptive Dynamic Subset can return an empty subset when the model
+                # determines no tests in that suite are relevant to the code change.
+                click.echo(click.style("No tests were selected for this code change.", fg="yellow"), err=True)
+            else:
+                warn_and_exit_if_fail_fast_mode("Error: no tests found matching the path.")
+
+                if self.print_input_snapshot_id:
+                    self._print_input_snapshot_id_value(subset_result)
+                if self.subset_id_file:
+                    self._write_subset_id_to_file(subset_result)
+                return
 
         if self.print_input_snapshot_id:
             self._print_input_snapshot_id_value(subset_result)
@@ -721,6 +767,13 @@ class Subset(TestPathWriter):
         # TODO(Konboi): split subset isn't provided for smart-tests initial release
         # if split:
         #   click.echo("subset/{}".format(subset_result.subset_id))
+        if subset_result.is_brainless:
+            click.echo("Your model is currently in training", err=True)
+            # brainless mode split tests on servers. so we don't have to run
+            # client side fallback.
+            if self.fallback_mode != FallbackMode.RANDOM_SAMPLE:
+                subset_result = self._fallback_result()
+
         output_subset, output_rests = subset_result.subset, subset_result.rest
 
         if subset_result.is_observation:
@@ -766,10 +819,6 @@ class Subset(TestPathWriter):
             ],
         ]
 
-        if subset_result.is_brainless:
-            click.echo(
-                "Your model is currently in training", err=True)
-
         click.echo(
             "Smart Tests created subset {} for build {} (test session {}) in workspace {}/{}".format(
                 subset_result.subset_id,

{smart_tests_cli-2.9.1 → smart_tests_cli-2.11.0}/smart_tests/test_runners/maven.py

@@ -1,7 +1,6 @@
 import glob
 import os
 import re
-import xml.etree.ElementTree as ET
 from typing import Annotated, Dict, List
 
 import click
@@ -51,33 +50,6 @@ def is_file(f: str) -> bool:
     return False
 
 
-def parse_surefire_reports() -> List[Dict[str, str]]:
-    """Parse Maven Surefire XML reports from target/surefire-reports/."""
-    test_paths = []
-    report_pattern = '**/target/surefire-reports/TEST-*.xml'
-    report_files = glob.glob(report_pattern, recursive=True)
-
-    if not report_files:
-        return []
-
-    click.echo(f"Found {len(report_files)} surefire report(s)", err=True)
-
-    for report_file in report_files:
-        try:
-            tree = ET.parse(report_file)
-            root = tree.getroot()
-            classname = root.get('name')
-
-            if classname:
-                test_paths.append({"type": "class", "name": classname})
-
-        except ET.ParseError as e:
-            click.secho(f"Warning: Could not parse {report_file}: {e}", fg='yellow', err=True)
-
-    click.echo(f"Total tests discovered: {len(test_paths)}", err=True)
-    return test_paths
-
-
 @smart_tests.subset
 def subset(
     client: Subset,
@@ -101,12 +73,7 @@ def subset(
         multiple=True,
         help="Exclude tests matching the given Python regular expression pattern. Can be specified multiple times."
     )] = [],
-    is_scan_dryrun_results: Annotated[bool, typer.Option(
-        "--scan-dryrun-results",
-        help="Scan surefire reports generated by mvn test -DdryRun=true"
-    )] = False,
 ):
-
     # Compile exclude rules
     compiled_exclude_rules = []
     for rule in exclude_rules:
@@ -141,45 +108,22 @@ def subset(
     if source_roots is None:
         source_roots = []
 
-    if is_scan_dryrun_results:
-        click.echo("Scanning Maven dry-run results...", err=True)
-        tests = parse_surefire_reports()
-
-        if not tests:
-            click.secho(
-                "Warning: No surefire reports found. Did you run 'mvn test -DdryRun=true'?",
-                fg='yellow',
-                err=True
-            )
-            click.secho(
-                "Please run: mvn test -DdryRun=true",
-                fg='cyan',
-                err=True
-            )
+    files_to_read = list(test_compile_created_file)
+    if is_scan_test_compile_lst:
+        if len(test_compile_created_file) > 0:
+            click.echo(click.style(
+                "Warning: --test-compile-created-file is overridden by --scan-test-compile-lst", fg="yellow"),
+                err=True)
+        pattern = os.path.join('**', 'createdFiles.lst')
+        files_to_read = glob.glob(pattern, recursive=True)
+
+        if not files_to_read:
+            click.echo(click.style(
+                "Warning: No .lst files. Please run after executing `mvn test-compile`", fg="yellow"),
+                err=True)
             return
 
-        # Add tests to client (each test path must be a list)
-        for test in tests:
-            client.test_paths.append([test])
-
-    elif is_scan_test_compile_lst or test_compile_created_file:
-        if is_scan_test_compile_lst:
-            if len(test_compile_created_file) > 0:
-                click.echo(click.style(
-                    "Warning: --test-compile-created-file is overridden by --scan-test-compile-lst", fg="yellow"),
-                    err=True)
-
-            pattern = os.path.join('**', 'createdFiles.lst')
-            files_to_read = glob.glob(pattern, recursive=True)
-
-            if not files_to_read:
-                click.echo(click.style(
-                    "Warning: No .lst files. Please run after executing `mvn test-compile`", fg="yellow"),
-                    err=True)
-                return
-        elif test_compile_created_file:
-            files_to_read = list(test_compile_created_file)
-
+    if files_to_read:
         for file in files_to_read:
             with open(file, 'r') as f:
                 lines = f.readlines()
@@ -196,7 +140,6 @@ def subset(
                     path = file2test(line)
                     if path:
                         client.test_paths.append(path)
-
     else:
         for root in source_roots:
             client.scan(root, '**/*', file2test)

{smart_tests_cli-2.9.1 → smart_tests_cli-2.11.0/smart_tests_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-tests-cli
-Version: 2.9.1
+Version: 2.11.0
 Summary: Smart Tests CLI
 Author-email: CloudBees <support@cloudbees.com>
 License: Apache Software License v2

{smart_tests_cli-2.9.1 → smart_tests_cli-2.11.0}/smart_tests_cli.egg-info/SOURCES.txt

@@ -521,7 +521,6 @@ tests/data/karma/record_test_result.json
 tests/data/karma/sample-report.json
 tests/data/karma/subset_payload.json
 tests/data/karma/subset_result.json
-tests/data/maven/README.md
 tests/data/maven/createdFile_1.lst
 tests/data/maven/createdFile_2.lst
 tests/data/maven/list.lst
@@ -532,12 +531,6 @@ tests/data/maven/subset_from_file_result.json
 tests/data/maven/subset_result.json
 tests/data/maven/subset_scan_test_compile_lst_result.json
 tests/data/maven/subset_with_exclude_rules_result.json
-tests/data/maven/dryrun-test/target/surefire-reports/TEST-com.example.excludetestapplication.ExcludeTestApplicationTests.xml
-tests/data/maven/dryrun-test/target/surefire-reports/TEST-com.launchable.demo.CalculatorTest.xml
-tests/data/maven/dryrun-test/target/surefire-reports/TEST-com.launchable.demo.MixedTagsTest.xml
-tests/data/maven/dryrun-test/target/surefire-reports/com.example.excludetestapplication.ExcludeTestApplicationTests.txt
-tests/data/maven/dryrun-test/target/surefire-reports/com.launchable.demo.CalculatorTest.txt
-tests/data/maven/dryrun-test/target/surefire-reports/com.launchable.demo.MixedTagsTest.txt
 tests/data/maven/java/test/src/java/com/example/sample_app_maven/App2Test.java
 tests/data/maven/java/test/src/java/com/example/sample_app_maven/AppTest.java
 tests/data/maven/java/test/src/java/com/launchableinc/rocket_car_maven/e2e/E2ETest.java

{smart_tests_cli-2.9.1 → smart_tests_cli-2.11.0}/tests/commands/test_api_error.py

@@ -420,3 +420,103 @@ class APIErrorTest(CliTestCase):
                 if attempt > 10:
                     break
             self.assertEqual(tracking.call_count, count)
+
+
+class FallbackModeTest(CliTestCase):
+    test_files_dir = Path(__file__).parent.joinpath('../data/minitest/').resolve()
+
+    def _subset_args(self, rest_file_name, extra_args=()):
+        return (
+            "subset", "minitest",
+            "--target", "50%",
+            "--session", self.session,
+            "--rest", rest_file_name,
+            str(self.test_files_dir) + "/test/**/*.rb",
+        ) + tuple(extra_args)
+
+    # --- API error cases ---
+
+    @responses.activate
+    @mock.patch.dict(os.environ, {"SMART_TESTS_TOKEN": CliTestCase.smart_tests_token})
+    def test_api_error_fallback_stop(self):
+        responses.replace(
+            responses.POST,
+            f"{get_base_url()}/intake/organizations/{self.organization}/workspaces/{self.workspace}/subset",
+            status=500)
+
+        with tempfile.NamedTemporaryFile(delete=False) as rest_file:
+            result = self.cli(*self._subset_args(rest_file.name, ("--fallback-mode", "stop")), mix_stderr=False)
+            self.assertEqual(result.exit_code, 1)
+
+    @responses.activate
+    @mock.patch.dict(os.environ, {"SMART_TESTS_TOKEN": CliTestCase.smart_tests_token})
+    def test_api_error_fallback_random_sample(self):
+        responses.replace(
+            responses.POST,
+            f"{get_base_url()}/intake/organizations/{self.organization}/workspaces/{self.workspace}/subset",
+            status=500)
+
+        with tempfile.NamedTemporaryFile(delete=False) as rest_file:
+            result = self.cli(*self._subset_args(rest_file.name, ("--fallback-mode", "random-sample")), mix_stderr=False)
+            self.assert_success(result)
+            self.assertIn("example_test.rb", result.stdout)
+
+    @responses.activate
+    @mock.patch.dict(os.environ, {"SMART_TESTS_TOKEN": CliTestCase.smart_tests_token})
+    def test_api_error_fallback_run_all_default(self):
+        responses.replace(
+            responses.POST,
+            f"{get_base_url()}/intake/organizations/{self.organization}/workspaces/{self.workspace}/subset",
+            status=500)
+
+        with tempfile.NamedTemporaryFile(delete=False) as rest_file:
+            result = self.cli(*self._subset_args(rest_file.name), mix_stderr=False)
+            self.assert_success(result)
+            self.assertIn("example_test.rb", result.stdout)
+
+    # --- Brainless mode cases ---
+
+    @responses.activate
+    @mock.patch.dict(os.environ, {"SMART_TESTS_TOKEN": CliTestCase.smart_tests_token})
+    def test_brainless_fallback_stop(self):
+        responses.replace(
+            responses.POST,
+            f"{get_base_url()}/intake/organizations/{self.organization}/workspaces/{self.workspace}/subset",
+            json={"testPaths": [[{"type": "file", "name": "example_test.rb"}]],
+                  "rest": [], "subsettingId": 1, "isBrainless": True, "summary": {}},
+            status=200)
+
+        with tempfile.NamedTemporaryFile(delete=False) as rest_file:
+            result = self.cli(*self._subset_args(rest_file.name, ("--fallback-mode", "stop")), mix_stderr=False)
+            self.assertEqual(result.exit_code, 1)
+
+    @responses.activate
+    @mock.patch.dict(os.environ, {"SMART_TESTS_TOKEN": CliTestCase.smart_tests_token})
+    def test_brainless_fallback_random_sample(self):
+        # In brainless mode the server already split the tests, so random-sample keeps the server's result as-is.
+        responses.replace(
+            responses.POST,
+            f"{get_base_url()}/intake/organizations/{self.organization}/workspaces/{self.workspace}/subset",
+            json={"testPaths": [[{"type": "file", "name": "example_test.rb"}]],
+                  "rest": [], "subsettingId": 1, "isBrainless": True, "summary": {}},
+            status=200)
+
+        with tempfile.NamedTemporaryFile(delete=False) as rest_file:
+            result = self.cli(*self._subset_args(rest_file.name, ("--fallback-mode", "random-sample")), mix_stderr=False)
+            self.assert_success(result)
+            self.assertIn("example_test.rb", result.stdout)
+
+    @responses.activate
+    @mock.patch.dict(os.environ, {"SMART_TESTS_TOKEN": CliTestCase.smart_tests_token})
+    def test_brainless_fallback_run_all_default(self):
+        responses.replace(
+            responses.POST,
+            f"{get_base_url()}/intake/organizations/{self.organization}/workspaces/{self.workspace}/subset",
+            json={"testPaths": [[{"type": "file", "name": "example_test.rb"}]],
+                  "rest": [], "subsettingId": 1, "isBrainless": True, "summary": {}},
+            status=200)
+
+        with tempfile.NamedTemporaryFile(delete=False) as rest_file:
+            result = self.cli(*self._subset_args(rest_file.name), mix_stderr=False)
+            self.assert_success(result)
+            self.assertIn("example_test.rb", result.stdout)

{smart_tests_cli-2.9.1 → smart_tests_cli-2.11.0}/tests/commands/test_subset.py

@@ -279,6 +279,101 @@ class SubsetTest(CliTestCase):
         payload = self.decode_request_body(self.find_request('/subset').request.body)
         self.assertTrue(payload.get('useServerSideOptimizationTarget'))
 
+    @responses.activate
+    @mock.patch.dict(os.environ, {"SMART_TESTS_TOKEN": CliTestCase.smart_tests_token})
+    def test_confidence_subset_with_empty_valid_subset_when_pts_v2_enabled(self):
+        pipe = "test_aaa.py\ntest_bbb.py\ntest_ccc.py"
+        responses.replace(
+            responses.GET,
+            "{}/intake/organizations/{}/workspaces/{}/state".format(
+                get_base_url(),
+                self.organization,
+                self.workspace),
+            json={"isFailFastMode": False, "isPtsV2Enabled": True},
+            status=200)
+        responses.replace(
+            responses.POST,
+            "{}/intake/organizations/{}/workspaces/{}/subset".format(
+                get_base_url(),
+                self.organization,
+                self.workspace),
+            json={
+                "testPaths": [],
+                "testRunner": "file",
+                "rest": [
+                    [{"type": "file", "name": "test_aaa.py"}],
+                    [{"type": "file", "name": "test_bbb.py"}],
+                    [{"type": "file", "name": "test_ccc.py"}],
+                ],
+                "subsettingId": 123,
+                "summary": {
+                    "subset": {"duration": 0, "candidates": 99, "rate": 0},
+                    "rest": {"duration": 30, "candidates": 0, "rate": 100}
+                },
+                "isObservation": False,
+            },
+            status=200)
+
+        result = self.cli(
+            "subset",
+            "--confidence",
+            "90%",
+            "--session",
+            self.session,
+            "file",
+            input=pipe,
+            mix_stderr=False)
+        self.assert_success(result)
+        self.assertEqual(result.stdout, "")
+        self.assertIn("No tests were selected for this code change.", result.stderr)
+        self.assertIn("Smart Tests created subset 123", result.stderr)
+        self.assertNotIn("Error: no tests found matching the path.", result.stderr)
+
+    @responses.activate
+    @mock.patch.dict(os.environ, {"SMART_TESTS_TOKEN": CliTestCase.smart_tests_token})
+    def test_confidence_subset_with_empty_subset_and_rest_is_error_even_if_summary_has_candidates(self):
+        pipe = "test_aaa.py\ntest_bbb.py\ntest_ccc.py"
+        responses.replace(
+            responses.GET,
+            "{}/intake/organizations/{}/workspaces/{}/state".format(
+                get_base_url(),
+                self.organization,
+                self.workspace),
+            json={"isFailFastMode": False, "isPtsV2Enabled": True},
+            status=200)
+        responses.replace(
+            responses.POST,
+            "{}/intake/organizations/{}/workspaces/{}/subset".format(
+                get_base_url(),
+                self.organization,
+                self.workspace),
+            json={
+                "testPaths": [],
+                "testRunner": "file",
+                "rest": [],
+                "subsettingId": 123,
+                "summary": {
+                    "subset": {"duration": 0, "candidates": 99, "rate": 0},
+                    "rest": {"duration": 30, "candidates": 99, "rate": 100}
+                },
+                "isObservation": False,
+            },
+            status=200)
+
+        result = self.cli(
+            "subset",
+            "--confidence",
+            "90%",
+            "--session",
+            self.session,
+            "file",
+            input=pipe,
+            mix_stderr=False)
+        self.assert_success(result)
+        self.assertEqual(result.stdout, "")
+        self.assertIn("Error: no tests found matching the path.", result.stderr)
+        self.assertNotIn("No tests were selected for this code change.", result.stderr)
+
     @responses.activate
     @mock.patch.dict(os.environ, {"SMART_TESTS_TOKEN": CliTestCase.smart_tests_token})
     def test_subset_goalspec(self):

{smart_tests_cli-2.9.1 → smart_tests_cli-2.11.0}/tests/test_runners/test_maven.py

@@ -182,109 +182,3 @@ class MavenTest(CliTestCase):
             'foo/Util.class',
         ]:
             self.assertFalse(maven.is_file(x))
-
-    def test_parse_surefire_reports_valid(self):
-        """Test parsing valid surefire reports from test data directory"""
-        # Change to test data directory with surefire reports
-        original_dir = os.getcwd()
-        test_data_dir = str(self.test_files_dir.joinpath('dryrun-test').resolve())
-
-        try:
-            os.chdir(test_data_dir)
-            tests = maven.parse_surefire_reports()
-
-            # Should find test reports (at least 2)
-            self.assertGreaterEqual(len(tests), 2)
-
-            # Verify test class names
-            test_names = {test['name'] for test in tests}
-            self.assertIn('com.launchable.demo.CalculatorTest', test_names)
-            self.assertIn('com.launchable.demo.MixedTagsTest', test_names)
-
-            # Verify format
-            for test in tests:
-                self.assertEqual(test['type'], 'class')
-                self.assertIsInstance(test['name'], str)
-        finally:
-            os.chdir(original_dir)
-
-    def test_parse_surefire_reports_no_files(self):
-        """Test parsing when no surefire reports exist"""
-        # Create empty temp directory
-        with tempfile.TemporaryDirectory() as temp_dir:
-            original_dir = os.getcwd()
-            try:
-                os.chdir(temp_dir)
-                tests = maven.parse_surefire_reports()
-
-                # Should return empty list when no reports found
-                self.assertEqual(tests, [])
-            finally:
-                os.chdir(original_dir)
-
-    def test_parse_surefire_reports_invalid_xml(self):
-        """Test parsing handles invalid XML gracefully"""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            original_dir = os.getcwd()
-            try:
-                os.chdir(temp_dir)
-
-                # Create target/surefire-reports directory
-                os.makedirs('target/surefire-reports', exist_ok=True)
-
-                # Create invalid XML file
-                invalid_xml_path = os.path.join('target/surefire-reports', 'TEST-Invalid.xml')
-                with open(invalid_xml_path, 'w') as f:
-                    f.write('<invalid><unclosed>')
-
-                # Should handle parse error gracefully
-                tests = maven.parse_surefire_reports()
-
-                # Should return empty list (invalid file skipped)
-                self.assertEqual(tests, [])
-            finally:
-                os.chdir(original_dir)
-
-    @responses.activate
-    @mock.patch.dict(os.environ, {"SMART_TESTS_TOKEN": CliTestCase.smart_tests_token})
-    def test_subset_with_scan_dryrun_results(self):
-        """Test subset command with --scan-dryrun-results flag"""
-        # Change to test data directory with surefire reports
-        original_dir = os.getcwd()
-        test_data_dir = str(self.test_files_dir.joinpath('dryrun-test').resolve())
-
-        try:
-            os.chdir(test_data_dir)
-
-            result = self.cli('subset', '--target', '10%', '--session',
-                              self.session, 'maven', '--scan-dryrun-results')
-
-            self.assert_success(result)
-
-            # Verify output mentions scanning dry-run results
-            self.assertIn('Scanning Maven dry-run results', result.output)
-            self.assertIn('Found', result.output)
-            self.assertIn('surefire report', result.output)
-        finally:
-            os.chdir(original_dir)
-
-    @responses.activate
-    @mock.patch.dict(os.environ, {"SMART_TESTS_TOKEN": CliTestCase.smart_tests_token})
-    def test_subset_with_scan_dryrun_results_no_reports(self):
-        """Test subset command with --scan-dryrun-results when no reports exist"""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            original_dir = os.getcwd()
-            try:
-                os.chdir(temp_dir)
-
-                result = self.cli('subset', '--target', '10%', '--session',
-                                  self.session, 'maven', '--scan-dryrun-results')
-
-                # Should still succeed but show warning
-                self.assert_success(result)
-
-                # Verify warning message displayed
-                self.assertIn('Warning: No surefire reports found', result.output)
-                self.assertIn('mvn test -DdryRun=true', result.output)
-            finally:
-                os.chdir(original_dir)