smart-tests-cli 2.16.3__tar.gz → 2.16.5__tar.gz

{smart_tests_cli-2.16.3 → smart_tests_cli-2.16.5}/.github/workflows/test.yml

@@ -65,6 +65,16 @@ jobs:
 
       - name: Lint with flake8
         run: uv run poe lint
+
+      - name: Check CLI reference docs are up to date
+        run: |
+          uv run tools/generate_reference.py smart_tests/docs/modules/references/pages/cli-reference.adoc
+          git diff --exit-code smart_tests/docs/modules/references/pages/cli-reference.adoc || {
+            echo "::error::cli-reference.adoc is stale. Run 'tools/generate_reference.py smart_tests/docs/modules/references/pages/cli-reference.adoc' and commit the updated doc."
+            exit 1
+          }
+        shell: bash
+
       - name: Pull request validation
         run: |
           # Install Smart Tests CLI from this repo's code as a global tool

{smart_tests_cli-2.16.3 → smart_tests_cli-2.16.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-tests-cli
-Version: 2.16.3
+Version: 2.16.5
 Summary: Smart Tests CLI
 Author-email: CloudBees <support@cloudbees.com>
 License: Apache Software License v2

{smart_tests_cli-2.16.3 → smart_tests_cli-2.16.5}/scripts/update_docs.sh

@@ -13,3 +13,7 @@ git clone --depth=1 "$REPO" "$tmpdir"
 rm -rf "$DOCS_DST"
 cp -r "$tmpdir/docs" "$DOCS_DST"
 echo "Docs updated at $DOCS_DST"
+
+CLI_REFERENCE="$DOCS_DST/modules/references/pages/cli-reference.adoc"
+"$(dirname "$0")/../tools/generate_reference.py" "$CLI_REFERENCE"
+echo "Regenerated CLI reference tables in $CLI_REFERENCE"

{smart_tests_cli-2.16.3 → smart_tests_cli-2.16.5}/smart_tests/commands/record/__init__.py

@@ -3,6 +3,7 @@ from ...app import Application
 from .attachment import attachment
 from .build import build
 from .commit import commit
+from .coverage import coverage
 from .deployment import deployment
 from .session import session
 from .tests import tests
@@ -18,4 +19,5 @@ record.add_command(commit)
 record.add_command(tests)
 record.add_command(session)
 record.add_command(attachment)
+record.add_command(coverage)
 record.add_command(deployment)

smart_tests_cli-2.16.5/smart_tests/commands/record/case_event.py

@@ -0,0 +1,249 @@
+import sys
+import uuid
+from typing import Any, Callable, Dict, Generator, List, Optional, Tuple
+
+from junitparser import Error, Failure, IntAttr, Skipped, TestCase, TestSuite
+
+from ...testpath import FilePathNormalizer, TestPath
+
+POSSIBLE_RESULTS = (Failure, Error, Skipped)
+
+# Surefire's rerun/flaky extension tags. junitparser's TestCase.ITER_TYPES (and thus
+# case.result/case.system_out/case.system_err) doesn't know about these, so they're
+# read directly off the raw element.
+RERUN_TAGS = ("rerunFailure", "rerunError")
+FLAKY_TAGS = ("flakyFailure", "flakyError")
+
+# Internal-only key tagging which original <testcase> an event came from (see
+# from_case_and_suite). Used by summarize_case_events to group retry/flaky attempts of the
+# SAME testcase without relying on testPath (which can be lossy, e.g. Maven's nested-class
+# $-stripping, or missing/extra attributes from the raw runner's free-form TestPathComponent).
+# Must be stripped before a payload is uploaded (see tests.py's payload()).
+BATCH_ID_KEY = "testcaseBatchId"
+
+CaseEventType = Dict[str, Any]
+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
+    ) -> List[Dict]:
+        """
+        Builds JSON representations of CaseEvent(s) from JUnitParser objects.
+
+        Normally a <testcase> maps to a single event. But Surefire's rerun/flaky
+        reports pack multiple attempts into one <testcase> (see RERUN_TAGS/FLAKY_TAGS);
+        each attempt is expanded into its own FAILED event here, in addition to the
+        testcase's own final PASSED/FAILED/SKIPPED result.
+        """
+
+        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 ""
+
+        # TODO(Improvement): when <system-err> is present, it currently replaces the failure's own
+        # text/message below instead of being appended to it. A test can both fail AND
+        # print to stderr (e.g. a logged warning before the assertion), so this can hide
+        # the actual failure detail behind unrelated captured output. Consider
+        # concatenating (failure text/message first, then system-err) instead of
+        # returning early here.
+        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
+
+        def final_result() -> Tuple[int, str, str, float]:
+            """
+            The testcase's own final result: unchanged from before this method supported reruns.
+            <testcase time> is defined by Surefire as the duration of THIS run (the first failing
+            run, or the last successful run), so this is the one attempt that keeps it.
+            """
+            # 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
+            return status, stdout(case), stderr(case), case.time
+
+        def attempt_result(elem) -> Tuple[int, str, str, float]:
+            """
+            One <flakyFailure>/<flakyError>/<rerunFailure>/<rerunError> attempt: always FAILED.
+            Surefire doesn't record a separate duration for these, so duration is 0 (avoids
+            double-counting the testcase's total time against final_result()'s duration).
+            """
+            def child_text(tag: str) -> Optional[str]:
+                child = elem.find(tag)
+                return child.text if child is not None and child.text else None
+
+            attempt_stdout = child_text("system-out") or ""
+            attempt_stderr = child_text("system-err") or child_text("stackTrace") or elem.attrib.get("message") or ""
+            return CaseEvent.TEST_FAILED, attempt_stdout, attempt_stderr, 0.0
+
+        rerun_elems = [c for c in case._elem if c.tag in RERUN_TAGS]
+        flaky_elems = [c for c in case._elem if c.tag in FLAKY_TAGS]
+
+        if rerun_elems:
+            # failed on the first attempt and on every rerun
+            attempts = [final_result()] + [attempt_result(e) for e in rerun_elems]
+        elif flaky_elems:
+            # failed on earlier attempts, passed on the last one
+            attempts = [attempt_result(e) for e in flaky_elems] + [final_result()]
+        else:
+            # no reruns: unchanged, single-event behavior
+            attempts = [final_result()]
+
+        test_path = path_canonicalizer(path_builder(case, suite, report_file))
+        data = data_builder(case)
+        # One id per original <testcase>, shared by every attempt derived from it here, so
+        # summarize_case_events can group retries correctly without relying on test_path.
+        batch_id = uuid.uuid4()
+
+        return [
+            {
+                **CaseEvent.create(
+                    test_path=test_path,
+                    duration_secs=attempt_duration,
+                    status=attempt_status,
+                    stdout=attempt_stdout,
+                    stderr=attempt_stderr,
+                    timestamp=suite.timestamp,
+                    data=data,
+                ),
+                BATCH_ID_KEY: batch_id,
+            }
+            for attempt_status, attempt_stdout, attempt_stderr, attempt_duration in attempts
+        ]
+
+    @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:
+        """
+        Builds a JSON representation of CaseEvent from arbitrary set of values
+
+        status:    TEST_FAILED or TEST_PASSED
+        timestamp: the raw <testsuite timestamp> string, sent unresolved. The server owns timezone
+                   resolution (see mothership TestTimestampResolver); the CLI holds no framework-TZ
+                   knowledge. None when the runner emits no suite timestamp.
+        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 "",
+            "junitSuiteTimestamp": timestamp,
+            "data": data
+        }
+
+
+class MetadataTestCase(TestCase):
+    line = IntAttr()

smart_tests_cli-2.16.5/smart_tests/commands/record/coverage.py

@@ -0,0 +1,135 @@
+import glob
+import os
+from io import BytesIO
+from pathlib import Path
+from typing import Annotated, List, Optional, Tuple
+
+import click
+from tabulate import tabulate
+
+import smart_tests.args4p.typer as typer
+from smart_tests.utils.session import SessionId, get_session
+
+from ... import args4p
+from ...app import Application
+from ...utils.smart_tests_client import SmartTestsClient
+
+
+class CoverageStatus:
+    SUCCESS = "✓ Recorded successfully"
+    FAILED = "⚠ Failed to record"
+
+
+@args4p.command(help="Record coverage data (LCOV format) related to a test session. "
+                "Passing COVERAGE_FILES is optional for bazel; "
+                "files are auto discovered when the command is run inside project root. "
+                "Other test runners must pass their coverage report file(s) directly.")
+def coverage(
+    app: Application,
+    session: Annotated[SessionId, SessionId.as_option()],
+    coverage_files: Annotated[List[str], typer.Argument(
+        multiple=True,
+        required=False,
+        help="Coverage report files to upload (LCOV format)"
+    )] = [],
+):
+    client = SmartTestsClient(app=app)
+    sources: List[str] = []
+
+    try:
+        # Assert test session exists
+        get_session(session, client)
+
+        if coverage_files:
+            sources = list(coverage_files)
+            blocks = [_read(f) for f in sources]
+        else:
+            # No files given: auto-discover from the current directory
+            # Auto discovery is Bazel only for now.
+            sources, blocks = discover_bazel_coverage(Path("."))
+
+        # LCOV tracefiles are just a sequence of SF:...end_of_record blocks, so concatenating
+        # multiple files is itself a valid tracefile. Send them as one upload rather than one
+        # request per file. The server already unions repeated SF: blocks for the same file within
+        # one upload, so this is correct even when the inputs cover overlapping files (e.g. one
+        # report from a unit-test run, another from an integration-test run touching the same
+        # source file)
+        content = b"\n".join(blocks)
+        status, files_recorded, is_reupload = post_coverage(client, session, content)
+    except Exception as e:
+        client.print_exception_and_recover(e)
+        status, files_recorded, is_reupload = CoverageStatus.FAILED, None, False
+
+    display_summary(sources, status, files_recorded, is_reupload)
+
+
+def discover_bazel_coverage(workspace: "str | Path") -> Tuple[List[str], List[bytes]]:
+    """
+    Finds every per-target coverage.dat under <workspace>/bazel-testlogs
+
+    Bazel's own coverage.dat carries no target identity on its own, though TN (Test Name) is a standard LCOV field.
+    So we derive TN by file path (same approach used by `record tests bazel`
+    (bazel-testlogs/<pkg>/<target>/coverage.dat -> TN://<pkg>:<target>).
+    """
+    base = Path(workspace).joinpath('bazel-testlogs')
+    if not base.exists():
+        raise click.UsageError(
+            "No such directory: %s. "
+            "Pass coverage report file(s) directly as arguments instead." % str(base))
+
+    sources: List[str] = []
+    blocks: List[bytes] = []
+    for report_file in sorted(glob.iglob(os.path.join(str(base), '**', 'coverage.dat'), recursive=True)):
+        pkg_and_target = report_file[len(str(base)) + 1:-len("/coverage.dat")]
+        package, target = os.path.dirname(pkg_and_target), os.path.basename(pkg_and_target)
+        label = "//{}:{}".format(package.replace(os.sep, '/'), target)
+        sources.append(report_file)
+        blocks.append(_tag_with_test_name(_read(report_file), label))
+
+    if not blocks:
+        raise click.UsageError("No coverage.dat files found under %s" % str(base))
+
+    return sources, blocks
+
+
+def _tag_with_test_name(content: bytes, label: str) -> bytes:
+    tn_line = "TN:{}\n".format(label).encode('utf-8')
+    tagged = []
+    for line in content.splitlines(keepends=True):
+        if line.startswith(b"SF:"):
+            tagged.append(tn_line)
+        tagged.append(line)
+    return b"".join(tagged)
+
+
+def _read(path: str) -> bytes:
+    with open(path, mode='rb') as f:
+        return f.read()
+
+
+def post_coverage(client: SmartTestsClient, session: SessionId, content: bytes) -> Tuple[str, Optional[int], bool]:
+    try:
+        res = client.request(
+            "post", session.subpath("coverage"), compress=True, payload=BytesIO(content),
+            additional_headers={"Content-Type": "text/plain"})
+        res.raise_for_status()
+        summary = res.json()
+        return CoverageStatus.SUCCESS, summary.get("sourceFilesRecorded"), summary.get("isReupload", False)
+    except Exception as e:
+        click.echo("Failed to upload coverage report: {}".format(str(e)), err=True)
+        return CoverageStatus.FAILED, None, False
+
+
+def display_summary(sources: List[str], status: str, source_files: Optional[int], is_reupload: bool = False):
+    if sources:
+        click.echo(tabulate([[f] for f in sources], ["Coverage files found"], tablefmt="github"))
+        click.echo()
+    rows = [[len(sources), source_files if source_files is not None else "-", status]]
+    click.echo(tabulate(rows, ["Coverage Files", "Source Files", "Status"], tablefmt="github"))
+    if is_reupload:
+        click.echo(
+            click.style(
+                "⚠ This session already had coverage recorded. The previous upload was overwritten. "
+                "Refer to --help if you intended to record multiple files",
+                fg="yellow"),
+            err=True)

{smart_tests_cli-2.16.3 → smart_tests_cli-2.16.5}/smart_tests/commands/record/tests.py

@@ -6,7 +6,7 @@ import xml.etree.ElementTree as ET
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from time import time_ns
-from typing import Annotated, Callable, Dict, Generator, List, Tuple, Union
+from typing import Annotated, Any, Callable, Dict, Generator, Iterable, List, Tuple, Union
 
 import click
 from dateutil.parser import ParserError, parse
@@ -32,7 +32,7 @@ from ...utils.fail_fast_mode import (FailFastModeValidateParams, fail_fast_mode_
                                      set_fail_fast_mode, warn_and_exit_if_fail_fast_mode)
 from ...utils.logger import Logger
 from ...utils.smart_tests_client import SmartTestsClient
-from .case_event import CaseEvent, CaseEventGenerator, CaseEventType, DataBuilder, TestPathBuilder
+from .case_event import BATCH_ID_KEY, CaseEvent, CaseEventGenerator, CaseEventType, DataBuilder, TestPathBuilder
 
 # Together with the workers sending events, this stays within urllib3's default pool size (10 connections per host)
 MAX_RAW_FILE_UPLOAD_WORKERS = 5
@@ -45,6 +45,18 @@ GROUP_NAME_RULE = re.compile("^[a-zA-Z0-9][a-zA-Z0-9_-]*$")
 RESERVED_GROUP_NAMES = ["group", "groups", "nogroup", "nogroups"]
 
 
+def _agent_utc_offset() -> str:
+    """The recording agent's current UTC offset as an ISO string (e.g. '+09:00', '+00:00').
+
+    Sent once per 'record tests' request so the server can resolve naive suite timestamps. Parseable
+    by the server's ZoneOffset.of(...).
+    """
+    offset = datetime.datetime.now().astimezone().strftime("%z")  # e.g. '+0900', '-0700', '+0000'
+    if not offset:
+        return "+00:00"
+    return offset[:3] + ":" + offset[3:5]
+
+
 def _validate_group(value):
     if value is None:
         return ""
@@ -118,7 +130,8 @@ class RecordTests:
             try:
                 for suite in testsuites:
                     for case in suite:
-                        yield CaseEvent.from_case_and_suite(self.path_builder, case, suite, report, self.metadata_builder)
+                        yield from CaseEvent.from_case_and_suite(
+                            self.path_builder, case, suite, report, self.metadata_builder)
             except Exception as e:
                 warn_and_exit_if_fail_fast_mode(
                     "Warning: error parsing JUnitXml file {filename}: {error}".format(
@@ -351,7 +364,7 @@ class RecordTests:
 
         # generator that creates the payload incrementally
         def payload(
-                cases: Generator[TestCase, None, None],
+                cases: Generator[CaseEventType, None, None],
                 test_runner, group: str,
                 test_suite_name: str,
                 flavors: Dict[str, str]) -> Tuple[Dict[str, Union[str, List, dict, bool]], List[Exception]]:
@@ -361,11 +374,15 @@ class RecordTests:
 
             while True:
                 try:
-                    cs.append(next(cases))
+                    tc = next(cases)
                 except StopIteration:
                     break
                 except Exception as ex:
                     exs.append(ex)
+                    continue
+                # internal-only; never leaves the process
+                tc.pop(BATCH_ID_KEY, None)
+                cs.append(tc)
 
             count += len(cs)
             return {
@@ -378,6 +395,9 @@ class RecordTests:
                 # testSuite and flavors are applied only when the no-build option is enabled
                 "testSuite": test_suite_name,
                 "flavors": flavors,
+                # The recording agent's UTC offset, sent once per request. Only the client knows it;
+                # the server needs it to resolve naive (offset-less) suite timestamps.
+                "agentUtcOffset": _agent_utc_offset(),
             }, exs
 
         def send(payload: Dict[str, Union[str, List]]) -> None:
@@ -388,23 +408,6 @@ class RecordTests:
             nonlocal is_observation
             is_observation = res.json().get("testSession", {}).get("isObservation", False)
 
-        def recorded_result() -> Tuple[int, int, int, float]:
-            test_count = 0
-            success_count = 0
-            fail_count = 0
-            duration = float(0)
-
-            for tc in testcases(self.reports):
-                test_count += 1
-                status = tc.get("status")
-                if status == 0:
-                    fail_count += 1
-                elif status == 1:
-                    success_count += 1
-                duration += float(tc.get("duration") or 0)  # sec
-
-            return test_count, success_count, fail_count, duration / 60   # sec to min
-
         try:
             start = time_ns()
             tc = testcases(self.reports)
@@ -478,7 +481,7 @@ class RecordTests:
                 return
 
         file_count = len(self.reports)
-        test_count, success_count, fail_count, duration = recorded_result()
+        test_count, success_count, fail_count, duration = summarize_case_events(testcases(self.reports))
 
         click.echo(
             f"Smart Tests recorded tests for build "
@@ -516,6 +519,47 @@ class RecordTests:
 tests = Group(name="tests", callback=RecordTests, help="Record test results")
 
 
+def summarize_case_events(events: Iterable[CaseEventType]) -> Tuple[int, int, int, float]:
+    """
+    Summarizes a stream of case events into (test_count, success_count, fail_count, duration_minutes),
+    for the "Tests found / Tests passed / Tests failed" table printed after `record tests` runs.
+
+    Grouped by which original testcase an event came from, not counted per event: a flaky/rerun
+    testcase produces multiple events (see CaseEvent.from_case_and_suite), but it's still a
+    single test. A test that ever passed counts as passed (even if it also failed on earlier
+    attempts); a test that only ever failed counts as failed.
+
+    JUnit-based events carry BATCH_ID_KEY (one id per original <testcase>, see
+    from_case_and_suite), which is used as the grouping key directly. Other runners (e.g. raw)
+    build events without going through from_case_and_suite, so they never have that key; for
+    those, fall back to grouping by testPath's complete attribute set. This fallback never
+    assumes a component has "type"/"name" specifically -- TestPathComponent is an arbitrary
+    bag of string attributes (see raw's free-form testPath/testPathComponents) -- and keeps
+    every attribute, not just type/name, so two components differing only in some other
+    attribute are never treated as the same path.
+    """
+    tests: Dict[Any, Dict[str, bool]] = {}
+    duration = float(0)
+
+    for tc in events:
+        key = tc.get(BATCH_ID_KEY)
+        if key is None:
+            key = tuple(tuple(sorted(p.items())) for p in tc.get("testPath", []))
+        entry = tests.setdefault(key, {"passed": False, "failed": False})
+        status = tc.get("status")
+        if status == 1:
+            entry["passed"] = True
+        elif status == 0:
+            entry["failed"] = True
+        duration += float(tc.get("duration") or 0)  # sec
+
+    test_count = len(tests)
+    success_count = sum(1 for e in tests.values() if e["passed"])
+    fail_count = sum(1 for e in tests.values() if e["failed"] and not e["passed"])
+
+    return test_count, success_count, fail_count, duration / 60   # sec to min
+
+
 # if we fail to determine the timestamp of the build, we err on the side of collecting more test reports
 # than no test reports, so we use the 'epoch' timestamp
 INVALID_TIMESTAMP = datetime.datetime.fromtimestamp(0)

{smart_tests_cli-2.16.3 → smart_tests_cli-2.16.5}/smart_tests/docs/modules/ROOT/nav.adoc

@@ -3,7 +3,10 @@ include::ROOT:partial$abbr.adoc[]
 * xref:ROOT:index.adoc[Overview]
 * xref:send-data-to-smart-tests:send-data-to-smart-tests.adoc[Send data to {PRODUCT}]
 ** xref:send-data-to-smart-tests:set-up-smart-tests/getting-started.adoc[Set up smart tests]
-*** xref:send-data-to-smart-tests:set-up-smart-tests/migration-to-github-oidc-auth.adoc[Update tokenless authentication to use GitHub OIDC]
+*** xref:send-data-to-smart-tests:set-up-smart-tests/migration-from-cli-v1-to-v2.adoc[Migrate from CLI v1 to v2]
+*** xref:send-data-to-smart-tests:set-up-smart-tests/oidc-authentication.adoc[Authenticate without an API key (OIDC)]
+*** xref:send-data-to-smart-tests:set-up-smart-tests/oidc-pipeline-authentication.adoc[Authenticate a pipeline with OIDC]
+*** xref:send-data-to-smart-tests:set-up-smart-tests/migration-to-github-oidc-auth.adoc[Migrate from the legacy GitHub Actions OIDC flow]
 *** xref:send-data-to-smart-tests:set-up-smart-tests/use-the-cli-with-docker-image.adoc[Use the CLI with Docker image]
 ** xref:send-data-to-smart-tests:record-builds/record-builds.adoc[Record builds]
 *** xref:send-data-to-smart-tests:record-builds/choose-a-value-for-build-name.adoc[Choose a value for build name]
@@ -67,7 +70,6 @@ include::ROOT:partial$abbr.adoc[]
 ** xref:references:integrations/raw.adoc['raw' profile for custom test runners]
 
 * xref:references:supported-languages.adoc[Supported languages]
-* xref:references:supported-test-frameworks.adoc[Supported test frameworks]
 * xref:references:faq.adoc[FAQ]
 
 .Administration