smart-tests-cli 2.0.0__py3-none-any.whl

smart_tests/test_runners/dotnet.py

@@ -0,0 +1,106 @@
+import glob
+import os
+from typing import Annotated, List
+
+import click
+
+import smart_tests.args4p.typer as typer
+from smart_tests.commands.record.tests import RecordTests
+from smart_tests.commands.subset import Subset
+from smart_tests.test_runners import smart_tests
+from smart_tests.test_runners.nunit import nunit_parse_func
+from smart_tests.testpath import TestPath
+
+
+# main subset logic
+def do_subset(client: Subset, bare):
+    if bare:
+        separator = "\n"
+        prefix = ""
+    else:
+        # LEGACY: we recommend the bare mode with native NUnit integration
+        # ref: https://github.com/Microsoft/vstest-docs/blob/main/docs/filter.md
+        separator = "|"
+        prefix = "FullyQualifiedName="
+
+        if client.is_output_exclusion_rules:
+            separator = "&"
+            prefix = "FullyQualifiedName!="
+
+    def formatter(test_path: TestPath):
+        paths = []
+
+        for path in test_path:
+            t = path.get("type", "")
+            if t == 'Assembly':
+                continue
+            if t == 'ParameterizedMethod':
+                # For parameterized test, we get something like
+                # Assembly=calc.dll#TestSuite=SomeNamespace#TestSuite=TestClassName#ParameterizedMethod=DivideTest#TestCase=DivideTest(1,3)
+                # see record_test_result.json as an example.
+                continue
+            paths.append(path.get("name", ""))
+
+        return prefix + ".".join(paths)
+
+    def exclusion_output_handler(subset_tests: List[TestPath], rest_tests: List[TestPath]):
+        if client.rest:
+            with open(client.rest, "w+", encoding="utf-8") as fp:
+                fp.write(client.separator.join(formatter(t) for t in subset_tests))
+
+        click.echo(client.separator.join(formatter(t) for t in rest_tests))
+
+    client.separator = separator
+    client.formatter = formatter
+    client.exclusion_output_handler = exclusion_output_handler
+    client.run()
+
+
+@smart_tests.subset
+def subset(
+    client: Subset,
+    bare: Annotated[bool, typer.Option(
+        "--bare",
+        help="outputs class names alone"
+    )] = False,
+):
+    """
+    Alpha: Supports only Zero Input Subsetting
+    """
+    if not client.is_get_tests_from_previous_sessions:
+        click.secho(
+            "The dotnet profile only supports Zero Input Subsetting.\nMake sure to use "
+            "`--get-tests-from-previous-sessions` option",
+            fg='red',
+            err=True)
+        raise typer.Exit(1)
+
+    do_subset(client, bare)
+
+
+@smart_tests.record.tests
+def record_tests(
+    client: RecordTests,
+    files: Annotated[List[str], typer.Argument(
+        multiple=True,
+        help="Test report files to process"
+    )],
+):
+    """
+    Alpha: Supports only NUnit report formats.
+    """
+    for file in files:
+        match = False
+        for t in glob.iglob(file, recursive=True):
+            match = True
+            if os.path.isdir(t):
+                client.scan(t, "*.xml")
+            else:
+                client.report(t)
+        if not match:
+            click.echo(f"No matches found: {file}", err=True)
+
+    # Note: we support only Nunit test report format now.
+    # If we need to support another format e.g) JUnit, trc, then we'll add a option
+    client.parse_func = nunit_parse_func
+    client.run()

smart_tests/test_runners/file.py

@@ -0,0 +1,20 @@
+#
+# The most bare-bone versions of the test runner support
+#
+
+from ..commands.subset import Subset
+from . import smart_tests
+
+
+@smart_tests.subset
+def subset(client: Subset):
+    # read lines as test file names
+    for t in client.stdin():
+        client.test_path(t.rstrip("\n"))
+
+    client.run()
+
+
+record_tests = smart_tests.CommonRecordTestImpls(__name__).file_profile_report_files()
+smart_tests.CommonDetectFlakesImpls(__name__).detect_flakes()
+# split_subset = launchable.CommonSplitSubsetImpls(__name__).split_subset()

smart_tests/test_runners/flutter.py

@@ -0,0 +1,251 @@
+import json
+import pathlib
+from typing import Annotated, Dict, List
+
+import click
+
+import smart_tests.args4p.typer as typer
+from smart_tests.commands.record.case_event import CaseEvent, CaseEventGenerator
+from smart_tests.testpath import FilePathNormalizer
+
+from ..commands.record.tests import RecordTests
+from . import smart_tests
+
+FLUTTER_FILE_EXT = "_test.dart"
+
+FLUTTER_TEST_RESULT_SUCCESS = "success"
+FLUTTER_TEST_RESULT_FAILURE = "error"
+
+
+class TestCase:
+    def __init__(self, id: int, name: str, is_skipped: bool = False):
+        self._id: int = id
+        self._name: str = name
+        self._is_skipped: bool = is_skipped
+        self._status: str = ""
+        self._stdout: str = ""
+        self._stderr: str = ""
+        self._duration_sec: float = 0
+
+    @property
+    def id(self):
+        return self._id
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def status(self) -> int:  # status code see: case_event.py
+        if self._is_skipped:
+            return CaseEvent.TEST_SKIPPED
+        elif self._status == FLUTTER_TEST_RESULT_SUCCESS:
+            return CaseEvent.TEST_PASSED
+        elif self._status == FLUTTER_TEST_RESULT_FAILURE:
+            return CaseEvent.TEST_FAILED
+
+        # safe fallback
+        return CaseEvent.TEST_PASSED
+
+    @status.setter
+    def status(self, status: str):
+        self._status = status
+
+    @property
+    def duration(self) -> float:
+        return self._duration_sec
+
+    @duration.setter
+    def duration(self, duration_sec: float):
+        self._duration_sec = duration_sec
+
+    @property
+    def stdout(self) -> str:
+        return self._stdout
+
+    @stdout.setter
+    def stdout(self, stdout: str):
+        self._stdout = stdout
+
+    @property
+    def stderr(self) -> str:
+        return self._stderr
+
+    @stderr.setter
+    def stderr(self, stderr: str):
+        self._stderr = stderr
+
+
+class TestSuite:
+    def __init__(self, id: int, platform: str, path: str):
+        self._id = id
+        self._platform = platform
+        self._path = path
+        self._test_cases: Dict[int, TestCase] = {}
+
+    def _get_test_case(self, id: int) -> TestCase | None:
+        return self._test_cases.get(id)
+
+
+class ReportParser:
+    def __init__(self, file_path_normalizer: FilePathNormalizer):
+        self.file_path_normalizer = file_path_normalizer
+        self._suites: Dict[int, TestSuite] = {}
+
+    def _get_suite(self, suite_id: int) -> TestSuite | None:
+        return self._suites.get(suite_id)
+
+    def _get_test(self, test_id: int) -> TestCase | None:
+        if test_id is None:
+            return None
+
+        for s in self._suites.values():
+            c = s._get_test_case(test_id)
+            if c is not None:
+                return c
+
+        return None
+
+    def _events(self) -> List:
+        events = []
+        for s in self._suites.values():
+            for c in s._test_cases.values():
+                events.append(CaseEvent.create(
+                    test_path=[
+                        {"type": "file", "name": pathlib.Path(self.file_path_normalizer.relativize(s._path)).as_posix()},
+                        {"type": "testcase", "name": c.name}],
+                    duration_secs=c.duration,
+                    status=c.status,
+                    stdout=c.stdout,
+                    stderr=c.stderr,
+                ))
+
+        return events
+
+    def parse_func(self, report_file: str) -> CaseEventGenerator:
+        # TODO: Support cases that include information about `flutter pub get`
+        # see detail: https://github.com/launchableinc/examples/actions/runs/11884312142/job/33112309450
+        if not pathlib.Path(report_file).exists():
+            click.secho(f"Error: Report file not found: {report_file}", fg='red', err=True)
+            return
+
+        with open(report_file, "r") as ndjson:
+            try:
+                for j in ndjson:
+                    if not j.strip():
+                        continue
+                    try:
+                        data = json.loads(j)
+                        self._parse_json(data)
+                    except json.JSONDecodeError:
+                        click.secho(
+                            f"Error: Invalid JSON format: {j}. Skip load this line",
+                            fg='yellow',
+                            err=True)
+                        continue
+            except Exception as e:
+                click.secho(
+                    f"Error: Failed to parse the report file: {report_file} : {e}", fg='red', err=True)
+                return
+
+        for event in self._events():
+            yield event
+
+    def _parse_json(self, data: Dict):
+        if not isinstance(data, Dict):
+            # Note: array sometimes comes in but won't use it
+            return
+
+        data_type = data.get("type")
+        if data_type is None:
+            return
+        elif data_type == "suite":
+            suite_data = data.get("suite")
+            if suite_data is None:
+                # it's might be invalid suite data
+                return
+
+            suite_id = suite_data.get("id")
+            if self._get_suite(suite_data.get("id")) is not None:
+                # already recorded
+                return
+
+            self._suites[suite_id] = TestSuite(suite_id, suite_data.get("platform"), suite_data.get("path"))
+        elif data_type == "testStart":
+            test_data = data.get("test")
+
+            if test_data is None:
+                # it's might be invalid test data
+                return
+            if test_data.get("line") is None:
+                # Still set up test case, should skip
+                return
+
+            suite_id = test_data.get("suiteID")
+            suite = self._get_suite(suite_id)
+
+            if suite_id is None or suite is None:
+                click.secho(
+                    f"Warning: Cannot find a parent test suite(id: {suite_id}). So won't send test result of "
+                    f"{test_data.get('name')}", fg='yellow', err=True)
+                return
+
+            test_id = test_data.get("id")
+            test = self._get_test(test_id)
+            if test is not None:
+                # already recorded
+                return
+
+            name = test_data.get("name")
+            metadata = test_data.get("metadata", {})
+            is_skipped = metadata.get("skip", False)
+            suite._test_cases[test_id] = TestCase(test_id, name, is_skipped)
+
+        elif data_type == "testDone":
+            test_id = data.get("testID", 0)
+            test = self._get_test(test_id)
+
+            if test is None:
+                return
+
+            test.status = data.get("result", "success")  # safe fallback
+            duration_msec = data.get("time", 0)
+            test.duration = duration_msec / 1000  # to sec
+
+        elif data_type == "error":
+            test_id = data.get("testID", 0)
+            test = self._get_test(test_id)
+            if test is None:
+                click.secho(
+                    f"Warning: Cannot find a test (id: {test_id}). So we skip update stderr", fg='yellow',
+                    err=True)
+                return
+            test.stderr += ("\n" if test.stderr else "") + data.get("error", "")
+
+        elif data_type == "print":
+            # It's difficult to identify the "Retry" case because Flutter reports it with the same test ID
+            # So we won't handle it at the moment.
+            test_id = data.get("testID", 0)
+            test = self._get_test(test_id)
+            if test is None:
+                click.secho(
+                    f"Warning: Cannot find a test (id: {test_id}). So we skip update stdout", fg='yellow',
+                    err=True)
+                return
+
+            test.stdout += ("\n" if test.stdout else "") + data.get("message", "")
+
+        else:
+            return
+
+
+@smart_tests.record.tests
+def record_tests(client: RecordTests,
+                 reports: Annotated[List[str], typer.Argument(required=True, multiple=True)]):
+    file_path_normalizer = FilePathNormalizer(base_path=client.base_path, no_base_path_inference=client.no_base_path_inference)
+    client.parse_func = ReportParser(file_path_normalizer).parse_func
+
+    smart_tests.CommonRecordTestImpls.load_report_files(client=client, source_roots=reports)
+
+
+subset = smart_tests.CommonSubsetImpls(__name__).scan_files('*.dart')

smart_tests/test_runners/go_test.py

@@ -0,0 +1,99 @@
+import glob
+import os
+import re
+from typing import Annotated, Dict, List
+
+import click
+from junitparser import TestCase, TestSuite  # type: ignore
+
+import smart_tests.args4p.typer as typer
+
+from ..commands.record.tests import RecordTests
+from ..commands.subset import Subset
+from ..testpath import TestPath
+from ..utils.logger import Logger
+from . import smart_tests
+
+
+@smart_tests.subset
+def subset(client: Subset):
+    logger = Logger()
+
+    # NOTE: This should be using package name + test function name to specify
+    # which tests to run. However, the initial integration is created so that we
+    # only specify the test function names. This can result in matching some
+    # extra tests in multiple packages. However, in order to keep the initial
+    # way of the integration, we cannot change this. Try to do the best.
+    test_cases = []
+    pattern = re.compile('\\s+')
+    for line in client.stdin():
+        if ' ' not in line:
+            test_cases.append(line.strip('\n'))
+        else:
+            parts = pattern.split(line)
+            if len(parts) >= 2:
+                package = parts[1].split('/')[-1]
+                for test_case in test_cases:
+                    client.test_path([{'type': 'class', 'name': package}, {
+                                     'type': 'testcase', 'name': test_case}])
+            else:
+                logger.warning("Cannot extract the package from the input. This may result in missing some tests.")
+            test_cases = []
+    client.formatter = lambda x: f"^{x[1]['name']}$"
+    client.separator = '|'
+    client.run()
+
+
+@smart_tests.record.tests
+def record_tests(
+    client: RecordTests,
+    source_roots: Annotated[List[str], typer.Argument(
+        multiple=True,
+        help="Source root directories or files to process"
+    )],
+):
+    for root in source_roots:
+        match = False
+        for t in glob.iglob(root, recursive=True):
+            match = True
+            if os.path.isdir(t):
+                client.scan(t, "*.xml")
+            else:
+                client.report(t)
+
+        if not match:
+            click.echo(f"No matches found: {root}", err=True)
+            return
+
+    default_path_builder = client.path_builder
+
+    def path_builder(case: TestCase, suite: TestSuite, report_file: str) -> TestPath:
+        tp = default_path_builder(case, suite, report_file)
+        for tpc in tp:
+            if 'type' in tpc and 'name' in tpc:
+                if tpc['type'] == 'class':
+                    # go-junit-report v2 reports full package name. go-junit-report
+                    # v1 reports only the last component of the package name. In
+                    # order to make this backward compatible, we align this to v1.
+                    tpc['name'] = tpc['name'].split('/')[-1]
+                if tpc['type'] == 'testcase' and '/' in tpc['name']:
+                    # go-junit-report produces test with subtests like `<TEST NAME?/<SUBTEST NAME>`
+                    # But `go test -list` command doesn't include subtest names
+                    # So, we split the name by '/' and save testcase and subtest
+                    names = tpc['name'].split('/')
+                    tpc['name'] = names[0]
+                    tp.append({
+                        'type': 'subtest',
+                        'name': '/'.join(names[1:]) if len(names) > 1 else ''
+                    })
+
+        return tp
+
+    client.path_builder = path_builder
+    client.run()
+
+
+def format_same_bin(s: str) -> List[Dict[str, str]]:
+    t = s.split(".")
+    return [{"type": "class", "name": t[0]},
+            {"type": "testcase", "name": t[1]}]

smart_tests/test_runners/googletest.py

@@ -0,0 +1,34 @@
+import re
+
+from ..commands.subset import Subset
+from ..testpath import TestPath
+from . import smart_tests
+
+
+def make_test_path(cls, case) -> TestPath:
+    return [{'type': 'class', 'name': cls}, {'type': 'testcase', 'name': case}]
+
+
+@smart_tests.subset
+def subset(client: Subset):
+    cls = ''
+    class_pattern = re.compile(r'^([^\.]+)\.')
+    case_pattern = re.compile(r'^  ([^ ]+)')
+    for label in map(str.rstrip, client.stdin()):
+        # handle Google Test's --gtest_list_tests output
+        # FooTest.
+        #  Bar
+        #  Baz
+        gtest_class = class_pattern.match(label)
+        if gtest_class:
+            cls = gtest_class.group(1)
+        gtest_case = case_pattern.match(label)
+        if gtest_case and cls:
+            case = gtest_case.group(1)
+            client.test_path(make_test_path(cls, case))
+
+    client.formatter = lambda x: x[0]['name'] + "." + x[1]['name']
+    client.run()
+
+
+record_tests = smart_tests.CommonRecordTestImpls(__name__).report_files()

smart_tests/test_runners/gradle.py

@@ -0,0 +1,96 @@
+import os
+from typing import Annotated, List
+
+import click
+
+import smart_tests.args4p.typer as typer
+from smart_tests.utils.java import junit5_nested_class_path_builder
+
+from ..args4p.exceptions import BadCmdLineException
+from ..commands.record.tests import RecordTests
+from ..commands.subset import Subset
+from ..utils.file_name_pattern import jvm_test_pattern
+from . import smart_tests
+
+
+@smart_tests.subset
+def subset(
+    client: Subset,
+    source_roots: Annotated[List[str] | None, typer.Argument(
+        multiple=True,
+        required=False,
+        help="Source root directories to scan for tests"
+    )] = None,
+    bare: Annotated[bool, typer.Option(
+        "--bare",
+        help="outputs class names alone"
+    )] = False,
+):
+    def file2test(f: str):
+        if jvm_test_pattern.match(f):
+            f = f[:f.rindex('.')]   # remove extension
+            # directory -> package name conversion
+            cls_name = f.replace(os.path.sep, '.')
+            return [{"type": "class", "name": cls_name}]
+        else:
+            return None
+
+    # Handle None source_roots - convert to empty list
+    if source_roots is None:
+        source_roots = []
+
+    if client.is_get_tests_from_previous_sessions:
+        if len(source_roots) != 0:
+            click.secho(
+                "Warning: SOURCE_ROOTS are ignored when --get-tests-from-previous-sessions is used",
+                fg='yellow', err=True)
+        # Always set to empty list when getting tests from previous sessions
+        source_roots = []
+    else:
+        if len(source_roots) == 0:
+            raise BadCmdLineException("Error: Missing argument 'SOURCE_ROOTS...'")
+
+    # Only scan if we have source roots
+    for root in source_roots:
+        client.scan(root, '**/*', file2test)
+
+    def exclusion_output_handler(subset_tests, rest_tests):
+        if client.rest:
+            with open(client.rest, "w+", encoding="utf-8") as fp:
+                if not bare and len(rest_tests) == 0:
+                    # This prevents the CLI output to be evaled as an empty
+                    # string argument.
+                    fp.write('-PdummyPlaceHolder')
+                else:
+                    fp.write(client.separator.join(client.formatter(t) for t in rest_tests))
+
+        classes = [to_class_file(tp[0]['name']) for tp in rest_tests]
+        if bare:
+            click.echo(','.join(classes))
+        else:
+            click.echo('-PexcludeTests=' + (','.join(classes)))
+    client.exclusion_output_handler = exclusion_output_handler
+
+    if bare:
+        client.formatter = lambda x: x[0]['name']
+    else:
+        client.formatter = lambda x: f"--tests {x[0]['name']}"
+        client.separator = ' '
+
+    client.run()
+
+
+def to_class_file(class_name: str):
+    return class_name.replace('.', '/') + '.class'
+
+
+@smart_tests.record.tests
+def record_tests(
+    client: RecordTests,
+    reports: Annotated[List[str], typer.Argument(
+        multiple=True,
+        help="Test report files to process"
+    )],
+):
+    client.path_builder = junit5_nested_class_path_builder(client.path_builder)
+    smart_tests.CommonRecordTestImpls.load_report_files(client=client, source_roots=reports)

smart_tests/test_runners/jest.py

@@ -0,0 +1,52 @@
+from typing import Annotated, List
+
+from junitparser import TestCase, TestSuite  # type: ignore
+
+import smart_tests.args4p.typer as typer
+from smart_tests.testpath import TestPath
+
+from ..args4p.exceptions import BadCmdLineException
+from ..commands.record.tests import RecordTests
+from ..commands.subset import Subset
+from . import smart_tests
+
+
+def path_builder(case: TestCase, suite: TestSuite, report_file: str) -> TestPath:
+    test_path = []
+    if suite.name:
+        test_path.append({"type": "file", "name": suite.name})
+
+    if case.classname:
+        test_path.append({"type": "class", "name": case.classname})
+
+    if case.name:
+        test_path.append({"type": "testcase", "name": case.name})
+
+    return test_path
+
+
+@smart_tests.record.tests
+def record_tests(
+    client: RecordTests,
+    reports: Annotated[List[str], typer.Argument(
+        multiple=True,
+        help="Test report files to process"
+    )],
+):
+    for r in reports:
+        client.report(r)
+
+    client.path_builder = path_builder
+    client.run()
+
+
+@smart_tests.subset
+def subset(client: Subset):
+    if client.base_path is None:
+        raise BadCmdLineException("Please specify base path")
+
+    for line in client.stdin():
+        if len(line.strip()) and not line.startswith(">"):
+            client.test_path(line.rstrip("\n"))
+
+    client.run()