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

smart_tests/utils/authentication.py

@@ -0,0 +1,78 @@
+import os
+from typing import Tuple
+
+import click
+import requests
+
+import smart_tests.args4p.typer as typer
+
+from .env_keys import ORGANIZATION_KEY, WORKSPACE_KEY, get_token
+
+
+def get_org_workspace():
+    token = get_token()
+    if token:
+        try:
+            _, user, _ = token.split(":", 2)
+            org, workspace = user.split("/", 1)
+            return org, workspace
+        except ValueError:
+            return None, None
+
+    return os.getenv(ORGANIZATION_KEY), os.getenv(WORKSPACE_KEY)
+
+
+def ensure_org_workspace() -> Tuple[str, str]:
+    org, workspace = get_org_workspace()
+    if org is None or workspace is None:
+        click.secho(
+            "Could not identify Smart Tests organization/workspace. "
+            "Please confirm if you set SMART_TESTS_TOKEN "
+            "(or LAUNCHABLE_TOKEN for backward compatibility) or SMART_TESTS_ORGANIZATION and "
+            "SMART_TESTS_WORKSPACE environment variables", fg='red', err=True)
+        raise typer.Exit(1)
+    return org, workspace
+
+
+def authentication_headers():
+    token = get_token()
+    if token:
+        return {'Authorization': f'Bearer {token}'}
+
+    if os.getenv('EXPERIMENTAL_GITHUB_OIDC_TOKEN_AUTH'):
+        req_url = os.getenv('ACTIONS_ID_TOKEN_REQUEST_URL')
+        rt_token = os.getenv('ACTIONS_ID_TOKEN_REQUEST_TOKEN')
+        if not req_url or not rt_token:
+            click.secho(
+                "GitHub Actions OIDC tokens cannot be retrieved."
+                "Confirm that you have added necessary permissions following "
+                "https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-cloud-providers#adding-permissions-settings",  # noqa: E501
+                fg='red', err=True)
+            raise typer.Exit(1)
+        r = requests.get(req_url,
+                         headers={
+                             'Authorization': f'Bearer {rt_token}',
+                             'Accept': 'application/json; api-version=2.0',
+                             'Content-Type': 'application/json',
+                         })
+        r.raise_for_status()
+        return {"Authorization": f"Bearer {r.json()['value']}"}
+
+    if os.getenv('GITHUB_ACTIONS'):
+        headers = {
+            'GitHub-Actions': os.environ['GITHUB_ACTIONS'],
+            'GitHub-Run-Id': os.environ['GITHUB_RUN_ID'],
+            'GitHub-Repository': os.environ['GITHUB_REPOSITORY'],
+            'GitHub-Workflow': os.environ['GITHUB_WORKFLOW'],
+            'GitHub-Run-Number': os.environ['GITHUB_RUN_NUMBER'],
+            'GitHub-Event-Name': os.environ['GITHUB_EVENT_NAME'],
+            'GitHub-Sha': os.environ['GITHUB_SHA'],
+        }
+
+        # GITHUB_PR_HEAD_SHA might not exist
+        pr_head_sha = os.getenv('GITHUB_PR_HEAD_SHA')
+        if pr_head_sha:
+            headers['GitHub-Pr-Head-Sha'] = pr_head_sha
+
+        return headers
+    return {}

smart_tests/utils/ci_provider.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class CIProvider(Enum):
+    JENKINS = "jenkins"
+    GITHUB_ACTIONS = "github-actions"
+    CIRCLECI = "circleci"

smart_tests/utils/commands.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class Command(Enum):
+    VERIFY = 'VERIFY'
+    RECORD_TESTS = 'RECORD_TESTS'
+    RECORD_BUILD = 'RECORD_BUILD'
+    RECORD_SESSION = 'RECORD_SESSION'
+    SUBSET = 'SUBSET'
+    COMMIT = 'COMMIT'
+    DETECT_FLAKE = 'DETECT_FLAKE'
+
+    def display_name(self):
+        return self.value.lower().replace('_', ' ')

smart_tests/utils/commit_ingester.py

@@ -0,0 +1,59 @@
+import hashlib
+from datetime import tzinfo
+from typing import Dict, List
+
+from ..app import Application
+from .git_log_parser import GitCommit
+from .smart_tests_client import SmartTestsClient
+
+
+def _sha256(s: str) -> str:
+    return hashlib.sha256(s.encode('utf8')).hexdigest()
+
+
+def _format_tzinfo(tz: tzinfo | None) -> int:
+    if not tz:
+        return 0
+    delta = tz.utcoffset(None)
+    if not delta:
+        return 0
+    return round(delta.total_seconds() / 60)
+
+
+def _convert_git_commit(commit: GitCommit) -> Dict:
+    changed_files = []
+    for changed_file in commit.changed_files:
+        cf = dict()
+        cf['linesAdded'] = changed_file.added
+        cf['linesDeleted'] = changed_file.deleted
+        cf['status'] = 'MODIFY'
+        cf['path'] = changed_file.path
+        cf['pathTo'] = changed_file.path
+        changed_files.append(cf)
+    parents = dict()
+    if len(commit.parents) > 0:
+        # We don't know which diff is for which parent. Use the first parent.
+        parents[commit.parents[0]] = changed_files
+        for parent in commit.parents[1:len(commit.parents)]:
+            parents[parent] = []
+
+    d = dict()
+    d['commitHash'] = commit.commit_hash
+    d['authorEmailAddress'] = _sha256(commit.author_email)
+    d['authorWhen'] = round(commit.author_time.timestamp() * 1000)
+    d['authorTimezoneOffset'] = _format_tzinfo(commit.author_time.tzinfo)
+    d['committerEmailAddress'] = _sha256(commit.committer_email)
+    d['committerWhen'] = round(commit.committer_time.timestamp() * 1000)
+    d['committerTimezoneOffset'] = _format_tzinfo(commit.committer_time.tzinfo)
+    d['parentHashes'] = parents
+    return d
+
+
+def upload_commits(commits: List[GitCommit], app: Application):
+    payload = {
+        'commits': [_convert_git_commit(commit) for commit in commits]
+    }
+
+    client = SmartTestsClient(app=app)
+    res = client.request("post", "commits/collect", payload=payload)
+    res.raise_for_status()

smart_tests/utils/common_tz.py

@@ -0,0 +1,12 @@
+from dateutil.tz import gettz
+
+# The dateutil library does not recognize timezone abbreviations (like "PDT" or "JST") by default.
+# To handle these, we manually map common abbreviations to their corresponding timezones.
+# See: https://github.com/dateutil/dateutil/issues/932
+COMMON_TIMEZONES = {
+    "UTC": gettz("UTC"),
+    # https://time.now/timezones/pdt/
+    "PDT": gettz("America/Los_Angeles"),
+    # https://time.now/timezones/jst/
+    "JST": gettz("Asia/Tokyo"),
+}

smart_tests/utils/edit_distance.py

@@ -0,0 +1,11 @@
+def edit_distance(s1, s2):
+    distances = range(len(s1) + 1)
+    for i2, c2 in enumerate(s2):
+        distances_ = [i2 + 1]
+        for i1, c1 in enumerate(s1):
+            if c1 == c2:
+                distances_.append(distances[i1])
+            else:
+                distances_.append(1 + min((distances[i1], distances[i1 + 1], distances_[-1])))
+        distances = distances_
+    return distances[-1]

smart_tests/utils/env_keys.py

@@ -0,0 +1,19 @@
+import os
+
+REPORT_ERROR_KEY = "SMART_TESTS_REPORT_ERROR"
+TOKEN_KEY = "SMART_TESTS_TOKEN"
+ORGANIZATION_KEY = "SMART_TESTS_ORGANIZATION"
+WORKSPACE_KEY = "SMART_TESTS_WORKSPACE"
+BASE_URL_KEY = "SMART_TESTS_BASE_URL"
+SKIP_TIMEOUT_RETRY = "SMART_TESTS_SKIP_TIMEOUT_RETRY"
+COMMIT_TIMEOUT = "SMART_TESTS_COMMIT_TIMEOUT"
+SKIP_CERT_VERIFICATION = "SMART_TESTS_SKIP_CERT_VERIFICATION"
+SESSION_DIR_KEY = "SMART_TESTS_SESSION_DIR"
+
+# Legacy token key for backward compatibility
+LEGACY_TOKEN_KEY = "LAUNCHABLE_TOKEN"
+
+
+def get_token():
+    """Get token with backward compatibility for LAUNCHABLE_TOKEN."""
+    return os.getenv(TOKEN_KEY) or os.getenv(LEGACY_TOKEN_KEY)

smart_tests/utils/exceptions.py

@@ -0,0 +1,34 @@
+# TODO: add cli-specific custom exceptions
+import sys
+
+import click
+
+from smart_tests.utils.tracking import Tracking, TrackingClient
+
+
+class ParseSessionException(Exception):
+    def __init__(
+        self,
+        session: str,
+        message: str = "Wrong session format; session format is like 'builds/<build name>/test_sessions/<test session id>'.",
+    ):
+        self.session = session
+        self.message = f"{message}: {self.session}"
+        super().__init__(self.message)
+
+
+class InvalidJUnitXMLException(Exception):
+    def __init__(
+        self,
+        filename: str,
+        message: str = "Invalid JUnit XML file format",
+    ):
+        self.filename = filename
+        self.message = f"{message}: {filename}"
+        super().__init__(self.message)
+
+
+def print_error_and_die(msg: str, tracking_client: TrackingClient, event: Tracking.ErrorEvent):
+    click.secho(msg, fg='red', err=True)
+    tracking_client.send_error_event(event_name=event, stack_trace=msg)
+    sys.exit(1)

smart_tests/utils/fail_fast_mode.py

@@ -0,0 +1,99 @@
+import sys
+from typing import List, Optional, Sequence, Tuple
+
+import click
+
+from .commands import Command
+
+_fail_fast_mode_cache: Optional[bool] = None
+
+
+def set_fail_fast_mode(enabled: bool):
+    global _fail_fast_mode_cache
+    _fail_fast_mode_cache = enabled
+
+
+def is_fail_fast_mode() -> bool:
+    if _fail_fast_mode_cache:
+        return _fail_fast_mode_cache
+
+    # Default to False if not set
+    return False
+
+
+def warn_and_exit_if_fail_fast_mode(message: str):
+    color = 'red' if is_fail_fast_mode() else 'yellow'
+    click.secho(message, fg=color, err=True)
+    if is_fail_fast_mode():
+        sys.exit(1)
+
+
+class FailFastModeValidateParams:
+    def __init__(self, command: Command, build: Optional[str] = None, is_no_build: bool = False,
+                 test_suite: Optional[str] = None, session: Optional[str] = None,
+                 links: Sequence[Tuple[str, str]] = (), is_observation: bool = False,
+                 flavor: Sequence[Tuple[str, str]] = ()):
+        self.command = command
+        self.build = build
+        self.is_no_build = is_no_build
+        self.test_suite = test_suite
+        self.session = session
+        self.links = links
+        self.is_observation = is_observation
+        self.flavor = flavor
+
+
+def fail_fast_mode_validate(params: FailFastModeValidateParams):
+    if not is_fail_fast_mode():
+        return
+
+    if params.command == Command.RECORD_SESSION:
+        _validate_record_session(params)
+    if params.command == Command.SUBSET:
+        _validate_subset(params)
+    if params.command == Command.RECORD_TESTS:
+        _validate_record_tests(params)
+
+
+def _validate_require_session_option(params: FailFastModeValidateParams) -> List[str]:
+    errors: List[str] = []
+    cmd_name = params.command.display_name()
+    if params.session:
+        if params.test_suite:
+            errors.append("`--test-suite` option was ignored in the {} command. Add `--test-suite` option to the `record session` command instead.".format(cmd_name))  # noqa: E501
+
+        if params.is_observation:
+            errors.append(
+                "`--observation` was ignored in the {} command. Add `--observation` option to the `record session` command instead.".format(cmd_name))  # noqa: E501
+
+        if len(params.flavor) > 0:
+            errors.append(
+                "`--flavor` option was ignored in the {} command. Add `--flavor` option to the `record session` command instead.".format(cmd_name))  # noqa: E501
+
+        if len(params.links) > 0:
+            errors.append(
+                "`--link` option was ignored in the {} command. Add `link` option to the `record session` command instead.".format(cmd_name))  # noqa: E501
+
+    return errors
+
+
+def _validate_record_session(params: FailFastModeValidateParams):
+    # Now, there isn't any validation for the `record session` command in fail-fast mode.
+    return
+
+
+def _validate_subset(params: FailFastModeValidateParams):
+    errors = _validate_require_session_option(params)
+    _exit_if_errors(errors)
+
+
+def _validate_record_tests(params: FailFastModeValidateParams):
+    errors = _validate_require_session_option(params)
+    _exit_if_errors(errors)
+
+
+def _exit_if_errors(errors: List[str]):
+    if errors:
+        msg = "\n".join(map(lambda x: click.style(x, fg='red'), errors))
+        click.echo(msg, err=True)
+        sys.exit(1)

smart_tests/utils/file_name_pattern.py

@@ -0,0 +1,4 @@
+import re
+
+# find *Test, *Tests, *TestCase, *Spec + .java, .scala, .kt, .groovy
+jvm_test_pattern = re.compile(r'^.*(?:Test(?:Case|s)?|Spec)\.(?:java|scala|kt|groovy)$')

smart_tests/utils/git_log_parser.py

@@ -0,0 +1,53 @@
+import json
+from collections import namedtuple
+from typing import Any, Dict, List, TextIO
+
+import dateutil.parser
+
+ChangedFile = namedtuple('ChangedFile', ['path', 'added', 'deleted'])
+
+GitCommit = namedtuple('GitCommit', [
+    'commit_hash', 'parents', 'author_email', 'author_time', 'committer_email',
+    'committer_time', 'changed_files'
+])
+
+
+def parse_git_log(fp: TextIO) -> List[GitCommit]:
+    """Parses the output of a git log command.
+
+    This parses the output of `git log --pretty='format:{"commit": "%H",
+    "parents": "%P", "authorEmail": "%ae", "authorTime": "%aI",
+    "committerEmail": "%ce", "committerTime": "%cI"}' --numstat`
+    """
+    ret = []
+    meta: Dict[str, Any] = {}
+    files: List[ChangedFile] = []
+    for idx, line in enumerate(fp):
+        line = line.strip()
+        if line == '':
+            continue
+        try:
+            if line.startswith('{'):
+                if len(meta) != 0:
+                    ret.append(GitCommit(changed_files=files, **meta))
+                    meta = {}
+                    files = []
+                d = json.loads(line)
+                meta['commit_hash'] = d['commit']
+                meta['parents'] = d['parents'].split(' ')
+                meta['author_email'] = d['authorEmail']
+                meta['author_time'] = dateutil.parser.parse(d['authorTime'])
+                meta['committer_email'] = d['committerEmail']
+                meta['committer_time'] = dateutil.parser.parse(
+                    d['committerTime'])
+            elif line.startswith('-'):
+                # Ignore binary file changes
+                pass
+            else:
+                added, deleted, path = line.split('\t', 3)
+                files.append(ChangedFile(path=path, added=int(added), deleted=int(deleted)))
+        except Exception as e:
+            raise ValueError(f"Failed to parse the file at line {idx + 1}: {e}")
+    if len(meta) != 0:
+        ret.append(GitCommit(changed_files=files, **meta))
+    return ret

smart_tests/utils/glob.py

@@ -0,0 +1,44 @@
+"""Path name matching with extended GLOBs.
+
+Primarily developed to interface with Maven, which supports "**", "*", and "?" as the special characters
+"""
+import re
+from typing import Pattern
+
+
+def is_path_separator(c: str):
+    return c == '/' or c == '\\'
+
+
+def compile(glob: str) -> Pattern:
+    """Compiles a glob pattern like foo/**/*.txt into a """
+    # fnmatch.fnmatch is close but it doesn't deal with paths well, including
+    # '**'
+
+    p = ""
+    i = 0
+    n = len(glob)
+    while i < n:
+        c = glob[i]
+        i += 1
+
+        if c == '*':
+            if i < n and glob[i] == '*':
+                i += 1
+                if i < n and is_path_separator(glob[i]):
+                    # '**/' matches any sub-directories or none
+                    i += 1
+                    p += "(.+[\\/])?"
+                else:
+                    # '**' used like **Test.java. Is this even legal?
+                    p += ".*"
+            else:
+                p += "[^\\/]*"
+        elif c == '?':
+            p += "[^\\/]"
+        elif is_path_separator(c):
+            p += "[\\/]"
+        else:
+            p += re.escape(c)
+
+    return re.compile(p)

smart_tests/utils/gzipgen.py

@@ -0,0 +1,46 @@
+# MIT License, from https://github.com/leetreveil/gengzip
+import struct
+import time
+import zlib
+from builtins import int
+
+
+def write32u(value):
+    return struct.pack('<L', value)
+
+
+def write_gzip_header():
+    header = b''
+    header += b'\037\213'  # magic header (0x1f, 0x8b)
+    header += b'\010'  # compression method (deflate)
+    header += b'\000'  # flags (not set)
+    header += write32u(int(time.time()))  # file modification time
+    header += b'\002'  # extra flags (maximum compression)
+    header += b'\377'  # os type (unknown)
+    return header
+
+
+def write_gzip_footer(crc, size):
+    footer = b''
+    footer += write32u(crc)
+    footer += write32u(size & 0xffffffff)
+    return footer
+
+
+def compress(d, compresslevel=6):
+    """
+    Takes a generator 'd' that provides streaem of data, then returns a wrapper generator
+    that yields compressed gzip data stream
+    """
+    crc = zlib.crc32(b'') & 0xffffffff
+    size = 0
+    yield write_gzip_header()
+    compress = zlib.compressobj(
+        compresslevel, zlib.DEFLATED, -zlib.MAX_WBITS, zlib.DEF_MEM_LEVEL, 0)
+    for data in d:
+        crc = zlib.crc32(data, crc) & 0xffffffff
+        size += len(data)
+        compressed = compress.compress(data)
+        if len(compressed) > 0:
+            yield compressed
+    yield compress.flush() + write_gzip_footer(crc, size)

smart_tests/utils/http_client.py

@@ -0,0 +1,169 @@
+import gzip
+import json
+import os
+import platform
+from typing import IO, BinaryIO, Dict, Tuple, Union
+
+from requests import Session
+from requests.adapters import HTTPAdapter
+from requests.packages.urllib3.util.retry import Retry  # type: ignore
+
+from smart_tests.version import __version__
+
+from ..app import Application
+from .authentication import authentication_headers
+from .env_keys import BASE_URL_KEY, SKIP_TIMEOUT_RETRY
+from .gzipgen import compress as gzipgen_compress
+from .logger import Logger
+
+DEFAULT_BASE_URL = "https://api.mercury.launchableinc.com"
+
+# (connect timeout, read timeout)
+DEFAULT_TIMEOUT: Tuple[int, int] = (5, 60)
+DEFAULT_GET_TIMEOUT: Tuple[int, int] = (5, 15)
+
+MAX_RETRIES = 3
+
+
+def get_base_url():
+    return os.getenv(BASE_URL_KEY) or DEFAULT_BASE_URL
+
+
+class DryRunResponse:
+    def __init__(self, status_code, payload):
+        self.status_code = status_code
+        self.payload = payload
+
+    def raise_for_status(self):
+        return
+
+    def json(self):
+        return self.payload
+
+
+class _HttpClient:
+    def __init__(self, base_url: str = "", session: Session | None = None, app: Application | None = None):
+        self.base_url = base_url or get_base_url()
+        self.dry_run = bool(app and app.dry_run)
+        self.skip_cert_verification = bool(app and app.skip_cert_verification)
+
+        if session is None:
+            read = MAX_RETRIES
+            if os.getenv(SKIP_TIMEOUT_RETRY):
+                read = 0
+            strategy = Retry(
+                total=MAX_RETRIES,
+                read=read,
+                allowed_methods=["GET", "PUT", "PATCH", "DELETE"],
+                status_forcelist=[429, 500, 502, 503, 504],
+                backoff_factor=2
+            )
+
+            adapter = HTTPAdapter(max_retries=strategy)
+            s = Session()
+            s.mount("http://", adapter)
+            s.mount("https://", adapter)
+            self.session = s
+        else:
+            self.session = session
+
+        self.test_runner = app.test_runner if app else None
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        payload: Union[Dict, BinaryIO] | None = None,
+        params: Dict | None = None,
+        timeout: Tuple[int, int] = DEFAULT_TIMEOUT,
+        compress: bool = False,
+        additional_headers: Dict | None = None,
+    ):
+        url = _join_paths(self.base_url, path)
+
+        if (timeout == DEFAULT_TIMEOUT and method.upper() == "GET"):
+            timeout = DEFAULT_GET_TIMEOUT
+
+        headers = self._headers(compress)
+        if additional_headers:
+            headers = {**headers, **additional_headers}
+
+        dry_run_prefix = "(DRY RUN) " if self.dry_run else ""
+        Logger().audit(f"{dry_run_prefix}send request method:{method} path:{url} headers:{headers} args:{payload}")
+
+        if self.dry_run and method.upper() not in ["HEAD", "GET"]:
+            return DryRunResponse(status_code=200, payload={
+                "id": "dry-run-session",  # `record session` use this
+                "testPaths": [],  # `split_subset` use this
+                "rest": [],  # `split_subset` use this
+            })
+
+        data = _build_data(payload, compress)
+
+        # the 'data' argument accepts generator. whenever we can potentially send a large amount of data,
+        # we want to use generator to stream data
+        response = self.session.request(method, url, headers=headers, timeout=timeout, data=data,
+                                        params=params, verify=(not self.skip_cert_verification))
+        Logger().debug(
+            f"received response status:{response.status_code} message:{response.reason} headers:{response.headers}"
+        )
+
+        # because (I believe, though I could be wrong) HTTP/2 got rid of status message, our server side HTTP stack
+        # doesn't let us forward the status message (=response.reason), which would have been otherwise a very handy
+        # mechanism to reliably forward error messages. So instead, we forward JSON error response of the form
+        # {"reason": ...}. Backfill response.reason with this JSON error message if it exists, so that the exceptions
+        # thrown from response.raise_for_status() will have a meaningful message.
+        if response.status_code >= 400 and response.headers.get("Content-Type", "").startswith("application/json"):
+            try:
+                response.reason = response.json().get("reason", response.reason)
+            except json.JSONDecodeError:
+                pass
+
+        return response
+
+    def _headers(self, compress):
+        h = {
+            "User-Agent": f"Launchable/{__version__} (Python {platform.python_version()}, {platform.platform()})",
+            "Content-Type": "application/json"
+        }
+
+        if compress:
+            h["Content-Encoding"] = "gzip"
+
+        if self.test_runner:
+            h["User-Agent"] = h["User-Agent"] + f" TestRunner/{self.test_runner}"
+
+        return {**h, **authentication_headers()}
+
+
+def _file_to_generator(f: IO, chunk_size=4096):
+    """
+    Returns a generator that reads from a given file-like object
+    """
+    while True:
+        data = f.read(chunk_size)
+        if not data:
+            break
+        yield data
+
+
+def _build_data(payload: Union[BinaryIO, Dict] | None, compress: bool):
+    if payload is None:
+        return None
+    if isinstance(payload, dict):
+        encoded = json.dumps(payload).encode()
+        if compress:
+            return gzip.compress(encoded)
+        else:
+            return encoded
+    else:
+        # payload is BinaryIO
+        if compress:
+            # this produces a generator
+            return gzipgen_compress(_file_to_generator(payload))
+        else:
+            return payload
+
+
+def _join_paths(*components):
+    return '/'.join([c.strip('/') for c in components])