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

smart_tests/commands/record/case_event.py

@@ -0,0 +1,190 @@
+import datetime
+import sys
+from typing import Any, Callable, Dict, Generator
+
+import dateutil.parser
+from dateutil.tz import tzlocal
+from junitparser import Error, Failure, IntAttr, Skipped, TestCase, TestSuite
+
+from smart_tests.utils.common_tz import COMMON_TIMEZONES  # type: ignore
+
+from ...testpath import FilePathNormalizer, TestPath
+
+POSSIBLE_RESULTS = (Failure, Error, Skipped)
+
+CaseEventType = Dict[str, str]
+CaseEventGenerator = Generator[CaseEventType, None, None]
+
+# function that computes TestPath from a test case
+# The 3rd argument is the report file path
+TestPathBuilder = Callable[[TestCase, TestSuite, str], TestPath]
+
+DataBuilder = Callable[[TestCase], Dict[str, Any] | None]
+
+
+class CaseEvent:
+    EVENT_TYPE = "case"
+    TEST_SKIPPED = 2
+    TEST_PASSED = 1
+    TEST_FAILED = 0
+
+    STATUS_MAP = {
+        'TEST_SKIPPED': TEST_SKIPPED,
+        'TEST_PASSED': TEST_PASSED,
+        'TEST_FAILED': TEST_FAILED,
+    }
+
+    @staticmethod
+    def default_path_builder(
+            file_path_normalizer: FilePathNormalizer) -> TestPathBuilder:
+        """
+        Obtains a default TestPathBuilder that uses a base directory to relativize the file name
+        """
+
+        def f(case: TestCase, suite: TestSuite, report_file: str) -> TestPath:
+            classname = case._elem.attrib.get("classname") or suite._elem.attrib.get("classname")
+            filepath = case._elem.attrib.get("file") or suite._elem.attrib.get("filepath")
+            if filepath:
+                filepath = file_path_normalizer.relativize(filepath)
+
+            test_path = []
+            if filepath:
+                test_path.append({"type": "file", "name": filepath})
+            if classname:
+                test_path.append({"type": "class", "name": classname})
+            if case.name:
+                test_path.append({"type": "testcase", "name": case._elem.attrib.get("name")})
+            return test_path
+
+        return f
+
+    @staticmethod
+    def default_data_builder() -> DataBuilder:
+        def f(case: TestCase):
+            """
+            case for:
+                <testcase ... file="tests/commands/inspect/test_tests.py" line="133">
+                </testcase>
+            """
+            metadata = MetadataTestCase.fromelem(case)
+            if metadata and metadata.line is not None:
+                return {
+                    "lineNumber": metadata.line
+                }
+            return None
+
+        return f
+
+    @classmethod
+    def from_case_and_suite(
+        cls,
+        path_builder: TestPathBuilder,
+        case: TestCase,
+        suite: TestSuite,
+        report_file: str,
+        data_builder: DataBuilder
+    ) -> Dict:
+        "Builds a JSON representation of CaseEvent from JUnitPaser objects"
+
+        # TODO: reconsider the initial value of the status.
+        status = CaseEvent.TEST_PASSED
+        for r in case.result:
+            if any(isinstance(r, s) for s in (Failure, Error)):
+                status = CaseEvent.TEST_FAILED
+                break
+            elif isinstance(r, Skipped):
+                status = CaseEvent.TEST_SKIPPED
+
+        def path_canonicalizer(test_path: TestPath) -> TestPath:
+            if sys.platform == "win32":
+                for p in test_path:
+                    p['name'] = p['name'].replace("\\", "/")
+
+            return test_path
+
+        def stdout(case: TestCase) -> str:
+            """
+            case for:
+                <testcase>
+                <system-out>...</system-out>
+                </testcase>
+            """
+            if case.system_out is not None:
+                return case.system_out
+
+            return ""
+
+        def stderr(case: TestCase) -> str:
+            """
+            case for:
+                <testcase>
+                <system-err>...</system-err>
+                </testcase>
+            """
+            if case.system_err is not None:
+                return case.system_err
+
+            """
+            case for:
+                <testcase>
+                <failure message="...">...</failure>
+                </testcase>
+            """
+            stderr = ""
+            for result in case.result:
+                if type(result) in POSSIBLE_RESULTS:
+                    # Since the `message` property is a summary of the `text` property,
+                    # we should attempt to retrieve the `text` property first in order to obtain a detailed log.
+                    if result.text:
+                        stderr = stderr + result.text
+                    elif result.message:
+                        stderr = stderr + result.message + "\n"
+
+            return stderr
+
+        return CaseEvent.create(
+            test_path=path_canonicalizer(path_builder(case, suite, report_file)),
+            duration_secs=case.time,
+            status=status,
+            stdout=stdout(case),
+            stderr=stderr(case),
+            timestamp=suite.timestamp,
+            data=data_builder(case),
+        )
+
+    @classmethod
+    def create(cls, test_path: TestPath, duration_secs: float, status,
+               stdout: str | None = None, stderr: str | None = None,
+               timestamp: str | None = None, data: Dict | None = None) -> Dict:
+        def _timestamp(ts: str | None = None):
+            if ts is None:
+                return datetime.datetime.now(datetime.timezone.utc).isoformat()
+            try:
+                date = dateutil.parser.parse(timestr=ts, tzinfos=COMMON_TIMEZONES)
+                if date.tzinfo is None:
+                    return date.replace(tzinfo=tzlocal()).isoformat()
+                return date.isoformat()
+            except Exception:
+                return datetime.datetime.now(datetime.timezone.utc).isoformat()
+
+        """
+        Builds a JSON representation of CaseEvent from arbitrary set of values
+
+        status:    TEST_FAILED or TEST_PASSED
+        timestamp: ISO-8601 formatted date
+        data:      arbitrary data to be submitted to the server. reserved for future enhancement.
+        """
+        return {
+            "type": cls.EVENT_TYPE,
+            "testPath": test_path,
+            "duration": duration_secs if duration_secs and duration_secs >= 0.0 else 0.0,
+            "status": status,
+            "stdout": stdout or "",
+            "stderr": stderr or "",
+            "createdAt": _timestamp(timestamp),
+            "data": data
+        }
+
+
+class MetadataTestCase(TestCase):
+    line = IntAttr()

smart_tests/commands/record/commit.py

@@ -0,0 +1,157 @@
+import os
+import subprocess
+import sys
+from typing import Annotated, List
+from urllib.parse import urlparse
+
+import click
+
+import smart_tests.args4p.typer as typer
+from smart_tests.utils.smart_tests_client import SmartTestsClient
+from smart_tests.utils.tracking import Tracking, TrackingClient
+
+from ... import args4p
+from ...app import Application
+from ...utils.commands import Command
+from ...utils.commit_ingester import upload_commits
+from ...utils.env_keys import COMMIT_TIMEOUT, REPORT_ERROR_KEY
+from ...utils.fail_fast_mode import set_fail_fast_mode, warn_and_exit_if_fail_fast_mode
+from ...utils.git_log_parser import parse_git_log
+from ...utils.http_client import get_base_url
+from ...utils.java import cygpath, get_java_command
+from ...utils.logger import LOG_LEVEL_AUDIT, Logger
+
+jar_file_path = os.path.normpath(os.path.join(os.path.dirname(__file__), "../../jar/exe_deploy.jar"))
+
+
+@args4p.command(help="Record commit information")
+def commit(
+    app: Application,
+    name: Annotated[str | None, typer.Option(
+        help="repository name"
+    )] = None,
+    source: Annotated[str, typer.Option(
+        help="repository path"
+    )] = os.getcwd(),
+    executable: Annotated[str, typer.Option(
+        help="[Obsolete] it was to specify how to perform commit collection but has been removed",
+        hidden=True
+    )] = "jar",
+    max_days: Annotated[int, typer.Option(
+        help="the maximum number of days to collect commits retroactively"
+    )] = 30,
+    import_git_log_output: Annotated[str | None, typer.Option(
+        help="import from the git-log output"
+    )] = None,
+):
+    if executable == 'docker':
+        click.echo("--executable docker is no longer supported", err=True)
+        raise typer.Exit(1)
+
+    tracking_client = TrackingClient(Command.COMMIT, app=app)
+    client = SmartTestsClient(tracking_client=tracking_client, app=app)
+    set_fail_fast_mode(client.is_fail_fast_mode())
+
+    if import_git_log_output:
+        _import_git_log(import_git_log_output, app)
+        return
+
+    # Commit messages are not collected in the default.
+    is_collect_message = False
+    is_collect_files = False
+    try:
+        res = client.request("get", "commits/collect/options")
+        res.raise_for_status()
+        is_collect_message = res.json().get("commitMessage", False)
+        is_collect_files = res.json().get("files", False)
+    except Exception as e:
+        tracking_client.send_error_event(
+            event_name=Tracking.ErrorEvent.INTERNAL_CLI_ERROR,
+            stack_trace=str(e),
+            api="commits/options",
+        )
+        client.print_exception_and_recover(e)
+
+    cwd = os.path.abspath(source)
+    if not name:
+        name = os.path.basename(cwd)
+    try:
+        exec_jar(name, cwd, max_days, app, is_collect_message, is_collect_files)
+    except Exception as e:
+        if os.getenv(REPORT_ERROR_KEY):
+            raise e
+        else:
+            warn_and_exit_if_fail_fast_mode(
+                "Couldn't get commit history from `{}`. Do you run command root of git-controlled directory? "
+                "If not, please set a directory use by --source option.\nerror: {}".format(cwd, e))
+
+
+def exec_jar(name: str, source: str, max_days: int, app: Application, is_collect_message: bool, is_collect_files: bool):
+    java = get_java_command()
+
+    if not java:
+        sys.exit("You need to install Java")
+
+    base_url = get_base_url()
+
+    # using subprocess.check_out with shell=False and a list of command to prevent vulnerability
+    # https://knowledge-base.secureflag.com/vulnerabilities/code_injection/os_command_injection_python.html
+    command = [java]
+    command.extend(_build_proxy_option(os.getenv("HTTPS_PROXY")))
+    command.extend([
+        "-jar",
+        cygpath(jar_file_path),
+        "-endpoint",
+        f"{base_url}/intake/",
+        "-max-days",
+        str(max_days)
+    ])
+
+    if Logger().logger.isEnabledFor(LOG_LEVEL_AUDIT):
+        command.append("-audit")
+    if app.dry_run:
+        command.append("-dry-run")
+    if app.skip_cert_verification:
+        command.append("-skip-cert-verification")
+    if is_collect_message:
+        command.append("-commit-message")
+    if is_collect_files:
+        command.append("-files")
+    if os.getenv(COMMIT_TIMEOUT):
+        command.append("-enable-timeout")
+    command.append(name)
+    command.append(cygpath(source))
+
+    subprocess.run(
+        command,
+        check=True,
+        shell=False,
+    )
+
+
+def _import_git_log(output_file: str, app: Application):
+    try:
+        with open(output_file) as fp:
+            commits = parse_git_log(fp)
+        upload_commits(commits, app)
+    except Exception as e:
+        if os.getenv(REPORT_ERROR_KEY):
+            raise e
+        else:
+            warn_and_exit_if_fail_fast_mode("Failed to import the git-log output\n error: {}".format(e))
+
+
+def _build_proxy_option(https_proxy: str | None) -> List[str]:
+    if not https_proxy:
+        return []
+
+    if not (https_proxy.startswith("https://") or https_proxy.startswith("http://")):
+        https_proxy = "https://" + https_proxy
+    proxy_url = urlparse(https_proxy)
+
+    options = []
+    if proxy_url.hostname:
+        options.append(f"-Dhttps.proxyHost={proxy_url.hostname}")
+    if proxy_url.port:
+        options.append(f"-Dhttps.proxyPort={proxy_url.port}")
+    return options

smart_tests/commands/record/session.py

@@ -0,0 +1,120 @@
+import os
+import re
+import sys
+from http import HTTPStatus
+from typing import Annotated, List
+
+import click
+
+import smart_tests.args4p.typer as typer
+from smart_tests import args4p
+from smart_tests.app import Application
+from smart_tests.utils.commands import Command
+from smart_tests.utils.exceptions import print_error_and_die
+from smart_tests.utils.fail_fast_mode import set_fail_fast_mode
+from smart_tests.utils.link import capture_links
+from smart_tests.utils.no_build import NO_BUILD_BUILD_NAME
+from smart_tests.utils.smart_tests_client import SmartTestsClient
+from smart_tests.utils.tracking import Tracking, TrackingClient
+from smart_tests.utils.typer_types import KeyValue, parse_key_value, validate_datetime_with_tz
+
+TEST_SESSION_NAME_RULE = re.compile("^[a-zA-Z0-9][a-zA-Z0-9_.-]*$")
+
+
+@args4p.command(help="Record session information")
+def session(
+    app: Application,
+    build_name: Annotated[str, typer.Option(
+        "--build",
+        help="build name",
+        required=True
+    )],
+    test_suite: Annotated[str, typer.Option(
+        "--test-suite",
+        help="Set test suite name. A test suite is a collection of test sessions. Setting a test suite allows you to "
+             "manage data over test sessions and lineages.",
+        required=True
+    )],
+    flavors: Annotated[List[KeyValue], typer.Option(
+        "--flavor",
+        help="flavors",
+        multiple=True,
+        metavar="KEY=VALUE",
+        type=parse_key_value
+    )] = [],
+    is_observation: Annotated[bool, typer.Option(
+        "--observation",
+        help="enable observation mode"
+    )] = False,
+    links: Annotated[List[KeyValue], typer.Option(
+        "--link",
+        help="Set external link of a title and url",
+        multiple=True,
+        type=parse_key_value,
+    )] = [],
+    is_no_build: Annotated[bool, typer.Option(
+        "--no-build",
+        help="If you want to only send test reports, please use this option"
+    )] = False,
+    timestamp: Annotated[str | None, typer.Option(
+        help="Used to overwrite the session time when importing historical data. Note: Format must be "
+             "`YYYY-MM-DDThh:mm:ssTZD` or `YYYY-MM-DDThh:mm:ss` (local timezone applied)"
+    )] = None,
+):
+
+    # Validate and convert timestamp if provided
+    parsed_timestamp = None
+    if timestamp:
+        parsed_timestamp = validate_datetime_with_tz(timestamp)
+
+    tracking_client = TrackingClient(Command.RECORD_SESSION, app=app)
+    client = SmartTestsClient(app=app, tracking_client=tracking_client)
+    set_fail_fast_mode(client.is_fail_fast_mode())
+
+    if not is_no_build and not build_name:
+        print_error_and_die("Missing option '--build'", tracking_client, Tracking.ErrorEvent.USER_ERROR)
+
+    if is_no_build and build_name:
+        print_error_and_die("Cannot use --build option with --no-build option", tracking_client, Tracking.ErrorEvent.USER_ERROR)
+
+    if is_no_build:
+        build_name = NO_BUILD_BUILD_NAME
+
+    try:
+        payload = {
+            "flavors": dict([(f.key, f.value) for f in flavors]),
+            "isObservation": is_observation,
+            "noBuild": is_no_build,
+            "testSuite": test_suite,
+            "timestamp": parsed_timestamp.isoformat() if parsed_timestamp else None,
+            "links": capture_links(link_options=links, env=os.environ)
+        }
+
+        sub_path = f"builds/{build_name}/test_sessions"
+        res = client.request("post", sub_path, payload=payload)
+
+        if res.status_code == HTTPStatus.NOT_FOUND:
+            msg = f"Build {build_name} was not found." \
+                f"Make sure to run `launchable record build --build {build_name}` before you run this command."
+            tracking_client.send_error_event(
+                event_name=Tracking.ErrorEvent.INTERNAL_CLI_ERROR,
+                stack_trace=msg,
+            )
+            click.secho(msg, fg='yellow', err=True)
+            sys.exit(1)
+
+        res.raise_for_status()
+
+        session_id = res.json().get('id', None)
+        if is_no_build:
+            build_name = res.json().get("buildNumber", "")
+            assert build_name is not None
+
+        click.echo(f"{sub_path}/{session_id}", nl=False)
+
+    except Exception as e:
+        tracking_client.send_error_event(
+            event_name=Tracking.ErrorEvent.INTERNAL_CLI_ERROR,
+            stack_trace=str(e),
+        )
+        client.print_exception_and_recover(e)