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

smart_tests/utils/java.py

@@ -0,0 +1,61 @@
+import os
+import shutil
+import subprocess
+import sys
+from typing import Callable
+
+from junitparser import TestCase, TestSuite
+
+from smart_tests.testpath import TestPath
+
+TestPathBuilder = Callable[[TestCase, TestSuite, str], TestPath]
+
+
+def get_java_command():
+    if shutil.which("java"):
+        return "java"
+
+    if os.access(os.path.expandvars("$JAVA_HOME/bin/java"), os.X_OK):
+        return os.path.expandvars("$JAVA_HOME/bin/java")
+
+    return None
+
+
+def cygpath(p):
+    # When running in Cygwin ported Python (as opposed to Windows native Python), the paths we deal with are in
+    # the cygwin format. But when we invoke Windows native Java (and there's no Cygwin ported Java), those parameters
+    # need to be in the Windows path format.
+    #
+    # In Cygwin aware world, it is always the responsibility of the Cygwin process calling Windows native process to
+    # do this conversion, so here we are.
+    #
+    # Cygwin ported Python is not to be confused with Windows native Python running in Windows with cygwin.
+    # So tests like CYGWIN env var, "uname" are incorrect.
+    if sys.platform == 'cygwin':
+        p = subprocess.check_output(['cygpath', '-w', p]).decode().strip()
+    return p
+
+
+def junit5_nested_class_path_builder(
+        default_path_builder: TestPathBuilder) -> TestPathBuilder:
+    """
+    Creates a path builder function that handles JUnit 5 nested class names.
+
+    With @Nested tests in JUnit 5, test class names have inner class names
+    like com.launchableinc.rocket_car.NestedTest$InnerClass.
+    It causes a problem in subsetting because Smart Tests CLI can't detect inner classes in subsetting.
+    So, we need to ignore the inner class names. The inner class name is separated by $.
+    Note: Launchable allows $ in test paths. But we decided to remove it in this case
+          because $ in the class name is not a common case.
+
+    Args:
+        default_path_builder: The original path builder function to wrap
+
+    Returns:
+        A function that wraps the default path builder and handles nested class names
+    """
+    def path_builder(case: TestCase, suite: TestSuite, report_file: str) -> TestPath:
+        test_path = default_path_builder(case, suite, report_file)
+        return [{**item, "name": item["name"].split("$")[0]} if item["type"] == "class" else item for item in test_path]
+
+    return path_builder

smart_tests/utils/link.py

@@ -0,0 +1,149 @@
+import re
+from enum import Enum
+from typing import Dict, List, Mapping, Sequence
+
+from smart_tests.args4p.exceptions import BadCmdLineException
+from smart_tests.utils.typer_types import KeyValue
+
+JENKINS_URL_KEY = 'JENKINS_URL'
+JENKINS_BUILD_URL_KEY = 'BUILD_URL'
+JENKINS_BUILD_DISPLAY_NAME_KEY = 'BUILD_DISPLAY_NAME'
+JENKINS_JOB_NAME_KEY = 'JOB_NAME'
+GITHUB_ACTIONS_KEY = 'GITHUB_ACTIONS'
+GITHUB_ACTIONS_SERVER_URL_KEY = 'GITHUB_SERVER_URL'
+GITHUB_ACTIONS_REPOSITORY_KEY = 'GITHUB_REPOSITORY'
+GITHUB_ACTIONS_RUN_ID_KEY = 'GITHUB_RUN_ID'
+GITHUB_ACTIONS_RUN_NUMBER_KEY = 'GITHUB_RUN_NUMBER'
+GITHUB_ACTIONS_JOB_KEY = 'GITHUB_JOB'
+GITHUB_ACTIONS_WORKFLOW_KEY = 'GITHUB_WORKFLOW'
+GITHUB_PULL_REQUEST_URL_KEY = 'GITHUB_PULL_REQUEST_URL'
+CIRCLECI_KEY = 'CIRCLECI'
+CIRCLECI_BUILD_URL_KEY = 'CIRCLE_BUILD_URL'
+CIRCLECI_BUILD_NUM_KEY = 'CIRCLE_BUILD_NUM'
+CIRCLECI_JOB_KEY = 'CIRCLE_JOB'
+
+GITHUB_PR_REGEX = re.compile(r"^https://github\.com/[^/]+/[^/]+/pull/\d+$")
+
+
+class LinkKind(Enum):
+
+    LINK_KIND_UNSPECIFIED = 0
+    CUSTOM_LINK = 1
+    JENKINS = 2
+    GITHUB_ACTIONS = 3
+    GITHUB_PULL_REQUEST = 4
+    CIRCLECI = 5
+
+
+def capture_link(env: Mapping[str, str]) -> List[Dict[str, str]]:
+    links = []
+
+    # see https://launchableinc.atlassian.net/wiki/spaces/PRODUCT/pages/612892698/ for the list of
+    # environment variables used by various CI systems
+    if env.get(JENKINS_URL_KEY):
+        links.append({
+            "kind": LinkKind.JENKINS.name, "url": env.get(JENKINS_BUILD_URL_KEY, ""),
+            "title": f"{env.get(JENKINS_JOB_NAME_KEY)} {env.get(JENKINS_BUILD_DISPLAY_NAME_KEY)}"
+        })
+    if env.get(GITHUB_ACTIONS_KEY):
+        links.append({
+            "kind": LinkKind.GITHUB_ACTIONS.name,
+            "url": f"{env.get(GITHUB_ACTIONS_SERVER_URL_KEY)}/{env.get(GITHUB_ACTIONS_REPOSITORY_KEY)}"
+            f"/actions/runs/{env.get(GITHUB_ACTIONS_RUN_ID_KEY)}",
+            # the nomenclature in GitHub PR comment from GHA has the optional additional part "(a,b,c)" that refers
+            # to the matrix, but that doesn't appear to be available as env var. Interestingly, run numbers are not
+            # included. Maybe it was seen as too much details and unnecessary for deciding which link to click?
+            "title": f"{env.get(GITHUB_ACTIONS_WORKFLOW_KEY)} / {env.get(GITHUB_ACTIONS_JOB_KEY)} "
+                     f"#{env.get(GITHUB_ACTIONS_RUN_NUMBER_KEY)}"
+                     })
+    if env.get(GITHUB_PULL_REQUEST_URL_KEY):
+        # TODO: where is this environment variable coming from?
+        links.append({
+            "kind": LinkKind.GITHUB_PULL_REQUEST.name,
+            "url": env.get(GITHUB_PULL_REQUEST_URL_KEY, ""),
+            "title": ""
+        })
+    if env.get(CIRCLECI_KEY):
+        # Their UI is organized as "project > branch > workflow > job (buildNum)" and it's not clear to me
+        # how much of that information should be present in title.
+        links.append({
+            "kind": LinkKind.CIRCLECI.name, "url": env.get(CIRCLECI_BUILD_URL_KEY, ""),
+            "title": f"{env.get(CIRCLECI_JOB_KEY)} ({env.get(CIRCLECI_BUILD_NUM_KEY)})"
+        })
+
+    return links
+
+
+def capture_links_from_options(link_options: Sequence[KeyValue]) -> List[Dict[str, str]]:
+    """
+    Validate user-provided link options, inferring the kind when not explicitly specified.
+
+    Each link option is expected in the format "kind|title=url" or "title=url".
+    If the kind is not provided, it infers the kind based on the URL pattern.
+
+    Returns:
+        A list of dictionaries, where each dictionary contains the validated title, URL, and kind for each link.
+
+    Raises:
+        BadCmdLineException: If an invalid kind is provided or URL doesn't match with the specified kind.
+    """
+    links = []
+    for kv in link_options:
+        k = kv.key
+        url = kv.value.strip()
+
+        # if k,v in format "kind|title=url"
+        if '|' in k:
+            kind, title = (part.strip() for part in k.split('|', 1))
+            if kind not in _valid_kinds():
+                raise BadCmdLineException(
+                    f"Invalid kind '{kind}' passed to --link option.\nSupported kinds are {_valid_kinds()}")
+
+            if not _url_matches_kind(url, kind):
+                raise BadCmdLineException(
+                    f"Invalid url '{url}' passed to --link option.\nURL doesn't match with the specified kind '{kind}'")
+        # if k,v in format "title=url"
+        else:
+            kind = _infer_kinds(url)
+            title = k.strip()
+
+        links.append({
+            "title": title,
+            "url": url,
+            "kind": kind,
+        })
+
+    return links
+
+
+def capture_links(link_options: Sequence[KeyValue], env: Mapping[str, str]) -> List[Dict[str, str]]:
+    links = capture_links_from_options(link_options)
+
+    env_links = capture_link(env)
+    for env_link in env_links:
+        if not _has_kind(links, env_link['kind']):
+            links.append(env_link)
+
+    return links
+
+
+def _infer_kinds(url: str) -> str:
+    if GITHUB_PR_REGEX.match(url):
+        return LinkKind.GITHUB_PULL_REQUEST.name
+
+    return LinkKind.CUSTOM_LINK.name
+
+
+def _has_kind(input_links: List[Dict[str, str]], kind: str) -> bool:
+    return any(link for link in input_links if link['kind'] == kind)
+
+
+def _valid_kinds() -> List[str]:
+    return [kind.name for kind in LinkKind if kind != LinkKind.LINK_KIND_UNSPECIFIED]
+
+
+def _url_matches_kind(url: str, kind: str) -> bool:
+    if kind == LinkKind.GITHUB_PULL_REQUEST.name:
+        return bool(GITHUB_PR_REGEX.match(url))
+
+    return True

smart_tests/utils/logger.py

@@ -0,0 +1,53 @@
+import logging
+
+LOG_LEVEL_DEFAULT = logging.WARNING
+LOG_LEVEL_DEFAULT_STR = "DEFAULT"
+LOG_LEVEL_AUDIT = 25
+LOG_LEVEL_AUDIT_STR = "AUDIT"
+
+AUDIT_LOG_FORMAT = "{0}send request method:{1} path:{2} headers:{3} args:{4}"
+
+logging.addLevelName(LOG_LEVEL_AUDIT, "AUDIT")
+
+
+def get_log_level(level=str) -> int:
+    level = level.lower()
+
+    if level == "critical":
+        return logging.CRITICAL
+    elif level == "error":
+        return logging.ERROR
+    elif level == "warn" or level == "warning":
+        return logging.WARNING
+    elif level == "audit":
+        return LOG_LEVEL_AUDIT
+    elif level == "info":
+        return logging.INFO
+    elif level == "debug":
+        return logging.DEBUG
+    else:
+        return LOG_LEVEL_DEFAULT
+
+
+class Logger(object):
+    def __init__(self, name: str = "smart-tests"):
+        logger = logging.getLogger(name)
+        self.logger = logger
+
+    def audit(self, msg, *args, **kargs):
+        self.logger.log(LOG_LEVEL_AUDIT, msg, *args, **kargs)
+
+    def debug(self, msg, *args, **kargs):
+        self.logger.debug(msg, *args, **kargs)
+
+    def info(self, msg, *args, **kargs):
+        self.logger.info(msg, *args, **kargs)
+
+    def warning(self, msg, *args, **kargs):
+        self.logger.warning(msg, *args, **kargs)
+
+    def error(self, msg, *args, **kargs):
+        self.logger.error(msg, *args, **kargs)
+
+    def critical(self, msg, *args, **kargs):
+        self.logger.critical(msg, *args, **kargs)

smart_tests/utils/no_build.py

@@ -0,0 +1,2 @@
+NO_BUILD_BUILD_NAME = "nameless"
+NO_BUILD_TEST_SESSION_ID = 0

smart_tests/utils/sax.py

@@ -0,0 +1,119 @@
+import re
+import sys
+from typing import Callable, Dict, List
+from xml.sax import make_parser
+from xml.sax.handler import ContentHandler
+from xml.sax.xmlreader import AttributesImpl
+
+from smart_tests.args4p.exceptions import BadCmdLineException
+
+
+class Element:
+    """Just like DOM element except it only knows about ancestors"""
+
+    # XML tag name
+    # name: str
+
+    # parent element
+    # parent: Element
+
+    # attributes. 'Attributes' class doesn't seem to exist
+    # attrs: object
+
+    # tags captured at this context
+    # tags: Dict[str,object]
+
+    def __init__(self, parent: 'Element', name: str, attrs: AttributesImpl):
+        self.name = name
+        self.attrs = attrs
+        self.parent = parent
+        # start with a copy of parents, and we modify it with ours
+        self.tags: Dict[str, object] = dict()
+        self.tags = parent.tags.copy() if parent else dict()
+
+    def __str__(self):
+        return "%s %s" % (self.name, self.tags)
+
+
+class TagMatcher:
+    """Matches to an attribute of an XML element and captures its value as a 'tag' """
+
+    # XML tag name to match
+    # element: str
+    # XML attribute name to match
+    # attr: str
+
+    # Name of the variable to capture
+    # var: str
+
+    pattern = re.compile(r"(\w+|\*)/@([a-zA-Z_\-]+)={(\w+)}")
+
+    def __init__(self, element: str, attr: str, var: str):
+        self.element = element
+        self.attr = attr
+        self.var = var
+
+    def matches(self, e: Element) -> str | None:
+        return e.attrs.get(
+            self.attr) if self.element == e.name or self.element == "*" else None
+
+    @staticmethod
+    def parse(spec: str) -> 'TagMatcher':
+        """Parse a string like foo/@bar={zot}"""
+        m = TagMatcher.pattern.match(spec)
+        if m:
+            return TagMatcher(m.group(1), m.group(2), m.group(3))
+        else:
+            raise BadCmdLineException("Invalid tag spec: %s" % spec)
+
+
+class SaxParser(ContentHandler):
+    """
+    Parse XML in a streaming manner, capturing attribute values as specified by TagMatchers
+    """
+
+    # represents the current element
+    context: Element | None = None
+
+    # matchers: List[TagMatcher]
+
+    # receiver: Callable[[Element],None]
+
+    def __init__(self, matchers: List[TagMatcher], receiver: Callable[[Element], None]):
+        super().__init__()
+        self.matchers = matchers
+        self.receiver = receiver
+
+    def startElement(self, tag, attrs):
+        self.context = Element(self.context, tag, attrs)
+
+        # match tags at this element
+        for m in self.matchers:
+            v = m.matches(self.context)
+            if v is not None:
+                self.context.tags[m.var] = v
+
+        # yield is more Pythonesque but because this is called from SAX parser
+        # I'm assuming that won't work
+        self.receiver(self.context)
+
+    def endElement(self, tag):
+        self.context = self.context.parent
+
+    def parse(self, body):
+        p = make_parser()
+        p.setContentHandler(self)
+        p.parse(body)
+
+
+# Scaffold JUnit parser
+# python -m launchable.utils.sax < result.xml
+if __name__ == "__main__":
+    def print_test_case(e: Element):
+        if e.name == "testcase":
+            print(e)
+
+    SaxParser([
+        TagMatcher.parse("testcase/@name={testcaseName}"),
+        TagMatcher.parse("testsuite/@timestamp={timestamp}")
+    ], print_test_case).parse(sys.stdin)

smart_tests/utils/session.py

@@ -0,0 +1,73 @@
+# Utilities for TestSession.
+# Named `session.py` to avoid confusion with test files.
+
+import re
+import sys
+from dataclasses import dataclass
+from typing import Tuple
+
+import click
+from requests import HTTPError
+
+from smart_tests.args4p.exceptions import BadCmdLineException
+from smart_tests.utils.smart_tests_client import SmartTestsClient
+from smart_tests.utils.tracking import Tracking
+
+
+@dataclass
+class TestSession:
+    id: int
+    build_id: int
+    build_name: str
+    observation_mode: bool
+    name: str | None = None
+
+
+def get_session(session: str, client: SmartTestsClient) -> TestSession:
+    build_name, test_session_id = parse_session(session)
+
+    subpath = f"builds/{build_name}/test_sessions/{test_session_id}"
+    res = client.request("get", subpath)
+
+    try:
+        res.raise_for_status()
+    except HTTPError as e:
+        if e.response.status_code == 404:
+            # TODO(Konboi): move subset.print_error_and_die to util and use it
+            msg = f"Session {session} was not found. Make sure to run `smart-tests record session --build {build_name}` before you run this command"  # noqa E501
+            click.secho(msg, fg='red', err=True)
+            if client.tracking_client:
+                client.tracking_client.send_error_event(event_name=Tracking.ErrorEvent.USER_ERROR, stack_trace=msg)
+            sys.exit(1)
+        raise
+
+    test_session = res.json()
+
+    return TestSession(
+        id=test_session.get("id"),
+        build_id=test_session.get("buildId"),
+        build_name=test_session.get("buildNumber"),
+        observation_mode=test_session.get("isObservation"),
+        name=test_session.get("name"),
+    )
+
+
+def parse_session(session: str) -> Tuple[str, int]:
+    """Parse session to extract build name and test session id.
+
+    Args:
+        session: Session in format "builds/{build_name}/test_sessions/{test_session_id}"
+
+    Returns:
+        Tuple of (build_name, test_session_id)
+
+    Raises:
+        ValueError: If session_id format is invalid
+    """
+    match = re.match(r"builds/([^/]+)/test_sessions/(.+)", session)
+
+    if match:
+        return match.group(1), int(match.group(2))
+    else:
+        raise BadCmdLineException(
+            f"Invalid session ID format: {session}. Expected format: builds/{{build_name}}/test_sessions/{{test_session_id}}")

smart_tests/utils/smart_tests_client.py

@@ -0,0 +1,134 @@
+import os
+from typing import BinaryIO, Dict
+
+import click
+import requests
+from requests import HTTPError, Session, Timeout
+
+from smart_tests.utils.http_client import _HttpClient, _join_paths
+from smart_tests.utils.tracking import Tracking, TrackingClient  # type: ignore
+
+from ..app import Application
+from ..args4p.exceptions import BadCmdLineException
+from .authentication import get_org_workspace
+from .env_keys import REPORT_ERROR_KEY
+
+
+class SmartTestsClient:
+    def __init__(self, tracking_client: TrackingClient | None = None, base_url: str = "", session: Session | None = None,
+                 app: Application | None = None):
+        self.http_client = _HttpClient(
+            base_url=base_url,
+            session=session,
+            app=app
+        )
+        self.tracking_client = tracking_client
+        self.organization, self.workspace = get_org_workspace()
+        if self.organization is None or self.workspace is None:
+            raise BadCmdLineException(
+                "Could not identify a Smart Tests organization/workspace. "
+                "Confirm that you set SMART_TESTS_TOKEN "
+                "(or SMART_TESTS_ORGANIZATION and SMART_TESTS_WORKSPACE) environment variable(s)\n"
+                "See https://help.launchableinc.com/sending-data-to-launchable/using-the-launchable-cli/getting-started/")
+        self._workspace_state_cache: Dict[str, str | bool] | None = None
+
+    def request(
+        self,
+        method: str,
+        sub_path: str,
+        payload: dict | BinaryIO | None = None,
+        params: dict | None = None,
+        timeout: tuple[int, int] = (5, 60),
+        compress: bool = False,
+        additional_headers: dict | None = None,
+    ) -> requests.Response:
+        path = _join_paths(
+            f"/intake/organizations/{self.organization}/workspaces/{self.workspace}",
+            sub_path
+        )
+
+        # report an error and bail out
+        def track(event_name: Tracking.ErrorEvent, e: Exception):
+            if self.tracking_client:
+                self.tracking_client.send_error_event(
+                    event_name=event_name,
+                    stack_trace=str(e),
+                    api=sub_path,
+                )
+            raise e
+
+        try:
+            response = self.http_client.request(
+                method=method,
+                path=path,
+                payload=payload,
+                params=params,
+                timeout=timeout,
+                compress=compress,
+                additional_headers=additional_headers
+            )
+            return response
+        except ConnectionError as e:
+            track(Tracking.ErrorEvent.NETWORK_ERROR, e)
+        except Timeout as e:
+            track(Tracking.ErrorEvent.TIMEOUT_ERROR, e)
+        except HTTPError as e:
+            track(Tracking.ErrorEvent.UNEXPECTED_HTTP_STATUS_ERROR, e)
+        except Exception as e:
+            track(Tracking.ErrorEvent.INTERNAL_SERVER_ERROR, e)
+
+        # should never come here, but needed to make type checker happy
+        assert False
+
+    def print_exception_and_recover(self, e: Exception, warning: str | None = None, warning_color='yellow'):
+        """
+        Print the exception raised from the request method, then recover from it
+
+        :param warning: optional warning message to contextualize the HTTP error
+        """
+
+        # a diagnostics flag to abort and report the details
+        if os.getenv(REPORT_ERROR_KEY):
+            raise e
+
+        click.echo(e, err=True)
+        if isinstance(e, HTTPError):
+            # if the payload is present, report that as well to assist troubleshooting
+            res = e.response
+            if res and res.text:
+                click.echo(res.text, err=True)
+
+        if warning:
+            click.secho(warning, fg=warning_color, err=True)
+
+    def base_url(self) -> str:
+        return self.http_client.base_url
+
+    def is_fail_fast_mode(self) -> bool:
+        state = self._get_workspace_state()
+        return state.get('fail_fast_mode', False)
+
+    def is_pts_v2_enabled(self) -> bool:
+        state = self._get_workspace_state()
+        return state.get('pts_v2', False)
+
+    def _get_workspace_state(self) -> dict:
+        """
+        Get the current state of the workspace.
+        """
+        if self._workspace_state_cache is not None:
+            return self._workspace_state_cache
+        try:
+            res = self.request("get", "state")
+            res.raise_for_status()
+
+            state = res.json()
+            self._workspace_state_cache = {
+                'fail_fast_mode': state.get('isFailFastMode', False),
+                'pts_v2': state.get('isPtsV2Enabled', False),
+            }
+            return self._workspace_state_cache
+        except Exception as e:
+            self.print_exception_and_recover(e, "Failed to get workspace state")
+
+        return {}

smart_tests/utils/subprocess.py

@@ -0,0 +1,12 @@
+import subprocess
+
+
+def check_output(*args, **kwargs):
+    """A wrapper for subprocess.check_output
+
+    In Windows, subprocess.check_output is used internally in one of those
+    dependencies. If we mock out subprocess.check_output, it also traps those
+    internall calls, making tests fail. This wrapper is a point to mock only
+    Smart Tests CLI initiated calls.
+    """
+    return subprocess.check_output(*args, **kwargs)