Release for v1.111.5

.github/workflows/e2e.yml

@@ -2,7 +2,7 @@ name: e2e
 
 on:
   push:
-    branches: [main]
+    branches: [v1]
   workflow_dispatch:
 
 

.github/workflows/python-package.yml

@@ -6,12 +6,12 @@ name: Python package
 on:
   workflow_dispatch:
   push:
-    branches: [ main ]
+    branches: [ v1 ]
     paths-ignore:
       - 'WORKSPACE'
       - 'src/**'
   pull_request:
-    branches: [ main ]
+    branches: [ v1 ]
     paths-ignore:
       - 'WORKSPACE'
       - 'src/**'

.github/workflows/python-publish.yml

@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
   push:
     branches:
-    - main
+    - v1
 
 env:
   IMAGE_NAME: cloudbees/launchable

.tagpr

@@ -38,6 +38,6 @@
 #
 [tagpr]
 	vPrefix = true
-	releaseBranch = main
+	releaseBranch = v1
 	versionFile = -
 	changelog = false

launchable/__main__.py

@@ -10,6 +10,7 @@
 from launchable.app import Application
 
 from .commands.compare import compare
+from .commands.detect_flakes import detect_flakes
 from .commands.inspect import inspect
 from .commands.record import record
 from .commands.split_subset import split_subset
@@ -91,6 +92,7 @@ def main(ctx, log_level, plugin_dir, dry_run, skip_cert_verification):
 main.add_command(inspect)
 main.add_command(stats)
 main.add_command(compare)
+main.add_command(detect_flakes, "detect-flakes")
 
 if __name__ == '__main__':
     main()

launchable/commands/compare/subsets.py

@@ -47,4 +47,4 @@ def subsets(file_before, file_after):
         (before, after, f"{diff:+}" if isinstance(diff, int) else diff, test)
         for before, after, diff, test in rows
     ]
-    click.echo(tabulate(tabular_data, headers=headers, tablefmt="github"))
+    click.echo_via_pager(tabulate(tabular_data, headers=headers, tablefmt="github"))

launchable/commands/detect_flakes.py

@@ -0,0 +1,92 @@
+import os
+import sys
+
+import click
+
+from launchable.app import Application
+from launchable.commands.helper import find_or_create_session
+from launchable.commands.test_path_writer import TestPathWriter
+from launchable.testpath import unparse_test_path
+from launchable.utils.click import ignorable_error
+from launchable.utils.env_keys import REPORT_ERROR_KEY
+from launchable.utils.launchable_client import LaunchableClient
+from launchable.utils.tracking import Tracking, TrackingClient
+
+from ..utils.commands import Command
+
+
+@click.group(help="Early flake detection")
+@click.option(
+    '--session',
+    'session',
+    help='In the format builds/<build-name>/test_sessions/<test-session-id>',
+    type=str,
+    required=True
+)
+@click.option(
+    '--retry-threshold',
+    'retry_threshold',
+    help='Throughness of how "flake" is detected',
+    type=click.Choice(['low', 'medium', 'high'], case_sensitive=False),
+    default='medium',
+    required=True,
+)
+@click.pass_context
+def detect_flakes(ctx, retry_threshold, session):
+    tracking_client = TrackingClient(Command.DETECT_FLAKE, app=ctx.obj)
+    client = LaunchableClient(app=ctx.obj, tracking_client=tracking_client, test_runner=ctx.invoked_subcommand)
+    session_id = None
+    try:
+        session_id = find_or_create_session(
+            context=ctx,
+            session=session,
+            build_name=None,
+            tracking_client=tracking_client
+        )
+    except click.UsageError as e:
+        click.echo(click.style(str(e), fg="red"), err=True)
+        sys.exit(1)
+    except Exception as e:
+        tracking_client.send_error_event(
+            event_name=Tracking.ErrorEvent.INTERNAL_CLI_ERROR,
+            stack_trace=str(e),
+        )
+        if os.getenv(REPORT_ERROR_KEY):
+            raise e
+        else:
+            click.echo(ignorable_error(e), err=True)
+    if session_id is None:
+        return
+
+    class FlakeDetection(TestPathWriter):
+        def __init__(self, app: Application):
+            super(FlakeDetection, self).__init__(app=app)
+
+        def run(self):
+            test_paths = []
+            try:
+                res = client.request(
+                    "get",
+                    "detect-flake",
+                    params={
+                        "confidence": retry_threshold.upper(),
+                        "session-id": os.path.basename(session_id),
+                        "test-runner": ctx.invoked_subcommand})
+                res.raise_for_status()
+                test_paths = res.json().get("testPaths", [])
+                if test_paths:
+                    self.print(test_paths)
+                    click.echo("Trying to retry the following tests:", err=True)
+                    for detail in res.json().get("testDetails", []):
+                        click.echo(f"{detail.get('reason')}: {unparse_test_path(detail.get('fullTestPath'))}", err=True)
+            except Exception as e:
+                tracking_client.send_error_event(
+                    event_name=Tracking.ErrorEvent.INTERNAL_CLI_ERROR,
+                    stack_trace=str(e),
+                )
+                if os.getenv(REPORT_ERROR_KEY):
+                    raise e
+                else:
+                    click.echo(ignorable_error(e), err=True)
+
+    ctx.obj = FlakeDetection(app=ctx.obj)

launchable/commands/helper.py

@@ -124,6 +124,8 @@ def find_or_create_session(
     session_id = read_session(saved_build_name)
     if session_id:
         _check_observation_mode_status(session_id, is_observation, tracking_client=tracking_client, app=context.obj)
+        if links:
+            click.echo(click.style("WARNING: --link option is ignored since session already exists."), err=True)
         return session_id
 
     context.invoke(

launchable/commands/inspect/subset.py

@@ -65,7 +65,7 @@ def display(self):
                     result._estimated_duration_sec,
                 ]
             )
-        click.echo(tabulate(rows, header, tablefmt="github", floatfmt=".2f"))
+        click.echo_via_pager(tabulate(rows, header, tablefmt="github", floatfmt=".2f"))
 
 
 class SubsetResultJSONDisplay(SubsetResultAbstractDisplay):

launchable/commands/record/build.py

@@ -7,7 +7,7 @@
 import click
 from tabulate import tabulate
 
-from launchable.utils.link import CIRCLECI_KEY, GITHUB_ACTIONS_KEY, JENKINS_URL_KEY, LinkKind, capture_link
+from launchable.utils.link import CIRCLECI_KEY, GITHUB_ACTIONS_KEY, JENKINS_URL_KEY, capture_links
 from launchable.utils.tracking import Tracking, TrackingClient
 
 from ...utils import subprocess
@@ -316,14 +316,7 @@ def synthesize_workspaces() -> List[Workspace]:
     def send(ws: List[Workspace]) -> Optional[str]:
         # figure out all the CI links to capture
         def compute_links():
-            _links = capture_link(os.environ)
-            for k, v in links:
-                _links.append({
-                    "title": k,
-                    "url": v,
-                    "kind": LinkKind.CUSTOM_LINK.name,
-                })
-            return _links
+            return capture_links(links, os.environ)
 
         try:
             payload = {

launchable/commands/record/session.py

@@ -8,7 +8,7 @@
 import click
 
 from launchable.utils.click import DATETIME_WITH_TZ, validate_past_datetime
-from launchable.utils.link import LinkKind, capture_link
+from launchable.utils.link import capture_links
 from launchable.utils.tracking import Tracking, TrackingClient
 
 from ...utils.click import KEY_VALUE
@@ -181,25 +181,17 @@ def session(
 
     flavor_dict = dict(flavor)
 
-    payload = {
-        "flavors": flavor_dict,
-        "isObservation": is_observation,
-        "noBuild": is_no_build,
-        "lineage": lineage,
-        "testSuite": test_suite,
-        "timestamp": timestamp.isoformat() if timestamp else None,
-    }
-
-    _links = capture_link(os.environ)
-    for link in links:
-        _links.append({
-            "title": link[0],
-            "url": link[1],
-            "kind": LinkKind.CUSTOM_LINK.name,
-        })
-    payload["links"] = _links
-
     try:
+        payload = {
+            "flavors": flavor_dict,
+            "isObservation": is_observation,
+            "noBuild": is_no_build,
+            "lineage": lineage,
+            "testSuite": test_suite,
+            "timestamp": timestamp.isoformat() if timestamp else None,
+            "links": capture_links(links, os.environ),
+        }
+
         sub_path = "builds/{}/test_sessions".format(build_name)
         res = client.request("post", sub_path, payload=payload)
 

launchable/commands/record/tests.py

@@ -229,6 +229,11 @@ def tests(
 
         is_no_build = False
 
+    if session and links:
+        warn_and_exit_if_fail_fast_mode(
+            "WARNING: `--link` and `--session` are set together.\n--link option can't be used with existing sessions."
+        )
+
     try:
         if is_no_build:
             session_id = "builds/{}/test_sessions/{}".format(NO_BUILD_BUILD_NAME, NO_BUILD_TEST_SESSION_ID)

launchable/commands/subset.py

@@ -207,6 +207,12 @@
     help="get subset list from git managed files",
     is_flag=True,
 )
+@click.option(
+    "--use-case",
+    "use_case",
+    type=click.Choice(["one-commit", "feature-branch", "recurring"]),
+    hidden=True,  # control PTS v2 test selection behavior. Non-committed, so hidden for now.
+)
 @click.pass_context
 def subset(
     context: click.core.Context,
@@ -235,6 +241,7 @@ def subset(
     prioritized_tests_mapping_file: Optional[TextIO] = None,
     test_suite: Optional[str] = None,
     is_get_tests_from_guess: bool = False,
+    use_case: Optional[str] = None,
 ):
     app = context.obj
     tracking_client = TrackingClient(Command.SUBSET, app=app)
@@ -484,17 +491,17 @@ def get_payload(
             if target is not None:
                 payload["goal"] = {
                     "type": "subset-by-percentage",
-                    "percentage": target,
+                    "percentage": float(target),
                 }
             elif duration is not None:
                 payload["goal"] = {
                     "type": "subset-by-absolute-time",
-                    "duration": duration,
+                    "duration": float(duration),
                 }
             elif confidence is not None:
                 payload["goal"] = {
                     "type": "subset-by-confidence",
-                    "percentage": confidence
+                    "percentage": float(confidence)
                 }
             elif goal_spec is not None:
                 payload["goal"] = {
@@ -513,6 +520,9 @@ def get_payload(
             if prioritized_tests_mapping_file:
                 payload['prioritizedTestsMapping'] = json.load(prioritized_tests_mapping_file)
 
+            if use_case:
+                payload["changesUnderTest"] = use_case
+
             return payload
 
         def _collect_potential_test_files(self):
@@ -560,6 +570,7 @@ def request_subset(self) -> SubsetResult:
                 # The status code 422 is returned when validation error of the test mapping file occurs.
                 if res.status_code == 422:
                     print_error_and_die("Error: {}".format(res.reason), Tracking.ErrorEvent.USER_ERROR)
+                res.raise_for_status()
 
                 return SubsetResult.from_response(res.json())
             except Exception as e:

launchable/test_runners/bazel.py

@@ -33,6 +33,8 @@ def subset(client):
 split_subset = launchable.CommonSplitSubsetImpls(__name__,
                                                  formatter=lambda x: x[0]['name'] + ":" + x[1]['name']).split_subset()
 
+launchable.CommonFlakeDetectionImpls(__name__, formatter=lambda x: x[0]['name'] + ":" + x[1]['name']).detect_flakes()
+
 
 @click.argument('workspace', required=True)
 @click.option('--build-event-json', 'build_event_json_files', help="set file path generated by --build_event_json_file",

launchable/test_runners/file.py

@@ -52,3 +52,5 @@ def find_filename():
 
 
 split_subset = launchable.CommonSplitSubsetImpls(__name__).split_subset()
+
+launchable.CommonFlakeDetectionImpls(__name__).detect_flakes()

launchable/test_runners/launchable.py

@@ -5,6 +5,7 @@
 
 import click
 
+from launchable.commands.detect_flakes import detect_flakes as detect_flakes_cmd
 from launchable.commands.record.tests import tests as record_tests_cmd
 from launchable.commands.split_subset import split_subset as split_subset_cmd
 from launchable.commands.subset import subset as subset_cmd
@@ -43,6 +44,10 @@ def subset(f):
 record.tests = lambda f: wrap(f, record_tests_cmd)
 
 
+def flake_detection(f):
+    return wrap(f, detect_flakes_cmd)
+
+
 def split_subset(f):
     return wrap(f, split_subset_cmd)
 
@@ -165,3 +170,27 @@ def split_subset(client):
             client.run()
 
         return wrap(split_subset, split_subset_cmd, self.cmdname)
+
+
+class CommonFlakeDetectionImpls:
+    def __init__(
+            self,
+            module_name,
+            formatter=None,
+            seperator="\n",
+    ):
+        self.cmdname = cmdname(module_name)
+        self._formatter = formatter
+        self._separator = seperator
+
+    def detect_flakes(self):
+        def detect_flakes(client):
+            if self._formatter:
+                client.formatter = self._formatter
+
+            if self._separator:
+                client.separator = self._separator
+
+            client.run()
+
+        return wrap(detect_flakes, detect_flakes_cmd, self.cmdname)

launchable/test_runners/raw.py

@@ -47,6 +47,8 @@ def subset(client, test_path_file):
 
 split_subset = launchable.CommonSplitSubsetImpls(__name__, formatter=unparse_test_path, seperator='\n').split_subset()
 
+launchable.CommonFlakeDetectionImpls(__name__).detect_flakes()
+
 
 @click.argument('test_result_files', required=True, type=click.Path(exists=True), nargs=-1)
 @launchable.record.tests

launchable/test_runners/rspec.py

@@ -3,3 +3,4 @@
 subset = launchable.CommonSubsetImpls(__name__).scan_files('*_spec.rb')
 split_subset = launchable.CommonSplitSubsetImpls(__name__).split_subset()
 record_tests = launchable.CommonRecordTestImpls(__name__).report_files()
+launchable.CommonFlakeDetectionImpls(__name__).detect_flakes()

launchable/utils/commands.py

@@ -8,6 +8,7 @@ class Command(Enum):
     RECORD_SESSION = 'RECORD_SESSION'
     SUBSET = 'SUBSET'
     COMMIT = 'COMMIT'
+    DETECT_FLAKE = 'DETECT_FLAKE'
 
     def display_name(self):
         return self.value.lower().replace('_', ' ')