smart-tests-cli 2.4.2__tar.gz → 2.5.1__tar.gz

{smart_tests_cli-2.4.2 → smart_tests_cli-2.5.1}/.tagpr

@@ -41,3 +41,4 @@
 	releaseBranch = main
 	versionFile = -
 	changelog = false
+	fixedMajorVersion = v2

{smart_tests_cli-2.4.2 → smart_tests_cli-2.5.1}/Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.13-slim
+FROM python:3.13-slim AS builder
 
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \
@@ -13,15 +13,21 @@ COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv
 WORKDIR /src
 COPY . .
 
-# Install dependencies and build the package using uv
-# This works with normal Git repositories (non-worktree)
-RUN uv sync --frozen --no-dev
+# Build wheel for distribution (standard Python package)
+RUN uv build --wheel --out-dir /wheels
+
+FROM python:3.13-slim
 
+# Install runtime dependencies
 RUN apt-get update && \
     apt-get install -y --no-install-recommends openjdk-21-jre-headless git && \
     rm -rf /var/lib/apt/lists/*
 
-RUN useradd -m smart-tests && chown -R smart-tests:smart-tests /src
+# Install wheel system-wide to /usr/local/bin
+RUN --mount=type=bind,from=builder,source=/wheels,target=/wheels \
+    pip install --no-cache-dir /wheels/*.whl
+
+RUN useradd --system --no-create-home smart-tests
 USER smart-tests
 
 ENTRYPOINT ["smart-tests"]

{smart_tests_cli-2.4.2 → smart_tests_cli-2.5.1}/PKG-INFO

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

{smart_tests_cli-2.4.2 → smart_tests_cli-2.5.1}/smart_tests/commands/compare/subsets.py

@@ -1,3 +1,6 @@
+import re
+import shutil
+import textwrap
 from dataclasses import dataclass
 from http import HTTPStatus
 from pathlib import Path
@@ -192,13 +195,54 @@ def _from_subset_ids(client: SmartTestsClient, subset_id_before: int, subset_id_
 
     # Display results in a tabular format
     headers = ["Δ Rank", "Subset Rank", "Test Name", "Reason", "Density"]
+    column_width = get_column_width()
     tabular_data = [
-        (rank, after, test_name, reason, density)
+        (rank, after, wrap_data(test_name, width=column_width), wrap_data(reason, width=column_width), density)
         for rank, after, test_name, reason, density in rows
     ]
     click.echo_via_pager(summary + "\n" + tabulate(tabular_data, headers=headers, tablefmt="simple"))
 
 
+def wrap_data(data: str, width: int = 30) -> str:
+
+    if not data:
+        return data
+
+    # Add space after / and \ to allow wrapping at these points
+    formatted_data = re.sub(r'([/\\])', r'\1 ', data)
+    wrapped = textwrap.fill(formatted_data, width=width)
+    # Remove the added spaces
+    wrapped = wrapped.replace("/ ", "/").replace("\\ ", "\\")
+    return wrapped
+
+
+def get_column_width() -> int:
+
+    try:
+        # Get terminal size, fallback to 80x24 if not detectable
+        terminal_size = shutil.get_terminal_size(fallback=(80, 24))
+        terminal_width = terminal_size.columns
+
+        # Estimate space needed for fixed columns and table formatting:
+        # - "Δ Rank" column: ~10 chars
+        # - "Subset Rank" column: ~12 chars
+        # - "Density" column: ~8 chars
+        # - Table separators and padding: ~6 chars
+        fixed_width = 36
+
+        # Calculate available width for the two wrappable columns
+        available_width = terminal_width - fixed_width
+
+        # Split equally between Test Name and Reason columns
+        column_width = available_width // 2
+
+        # Ensure minimum width of 30 characters
+        return max(30, column_width)
+    except Exception:
+        # If anything goes wrong, fall back to default
+        return 30
+
+
 def _from_files(file_before: Path, file_after: Path):
     before_subset = SubsetResultBases.from_file(file_before)
     after_subset = SubsetResultBases.from_file(file_after)

{smart_tests_cli-2.4.2 → smart_tests_cli-2.5.1}/smart_tests/commands/record/attachment.py

@@ -1,25 +1,26 @@
 import fnmatch
+import os
 import tarfile
 import zipfile
 from io import BytesIO
-from typing import Annotated, List, Tuple
+from typing import Annotated, List, Optional, Set, 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.fail_fast_mode import warn_and_exit_if_fail_fast_mode
 from ...utils.smart_tests_client import SmartTestsClient
-from tabulate import tabulate
 
 
 class AttachmentStatus:
     SUCCESS = "✓ Recorded successfully"
     FAILED = "⚠ Failed to record"
     SKIPPED_NON_TEXT = "⚠ Skipped: not a valid text file"
+    SKIPPED_DUPLICATE = "⚠ Skipped: duplicate"
 
 
 @args4p.command(help="Record attachment information")
@@ -39,6 +40,8 @@ def attachment(
 ):
     client = SmartTestsClient(app=app)
     summary_rows = []
+    used_filenames: Set[str] = set()
+
     try:
         # Note: Call get_session method to check test session exists
         _ = get_session(session, client)
@@ -50,7 +53,7 @@ def attachment(
                         if zip_info.is_dir():
                             continue
 
-                        if not matches_include_patterns(zip_info.filename, include_patterns):
+                        if not matches_include_patterns(zip_info.filename, tuple(include_patterns)):
                             continue
 
                         file_content = zip_file.read(zip_info.filename)
@@ -60,9 +63,15 @@ def attachment(
                                 [zip_info.filename, AttachmentStatus.SKIPPED_NON_TEXT])
                             continue
 
+                        file_name = get_unique_filename(zip_info.filename, used_filenames)
+                        if not file_name:
+                            summary_rows.append(
+                                [zip_info.filename, AttachmentStatus.SKIPPED_DUPLICATE])
+                            continue
+
                         status = post_attachment(
-                            client, session, file_content, zip_info.filename)
-                        summary_rows.append([zip_info.filename, status])
+                            client, session, file_content, file_name)
+                        summary_rows.append([file_name, status])
 
             # If tar file (tar, tar.gz, tar.bz2, tgz, etc.)
             elif tarfile.is_tarfile(a):
@@ -71,7 +80,7 @@ def attachment(
                         if tar_info.isdir():
                             continue
 
-                        if not matches_include_patterns(tar_info.name, include_patterns):
+                        if not matches_include_patterns(tar_info.name, tuple(include_patterns)):
                             continue
 
                         file_obj = tar_file.extractfile(tar_info)
@@ -85,9 +94,15 @@ def attachment(
                                 [tar_info.name, AttachmentStatus.SKIPPED_NON_TEXT])
                             continue
 
+                        file_name = get_unique_filename(tar_info.name, used_filenames)
+                        if not file_name:
+                            summary_rows.append(
+                                [tar_info.name, AttachmentStatus.SKIPPED_DUPLICATE])
+                            continue
+
                         status = post_attachment(
-                            client, session, file_content, tar_info.name)
-                        summary_rows.append([tar_info.name, status])
+                            client, session, file_content, file_name)
+                        summary_rows.append([file_name, status])
 
             else:
                 with open(a, mode='rb') as f:
@@ -98,15 +113,55 @@ def attachment(
                             [a, AttachmentStatus.SKIPPED_NON_TEXT])
                         continue
 
-                    status = post_attachment(client, session, file_content, a)
-                    summary_rows.append([a, status])
+                    file_name = get_unique_filename(a, used_filenames)
+                    if not file_name:
+                        summary_rows.append(
+                            [a, AttachmentStatus.SKIPPED_DUPLICATE])
+                        continue
+
+                    status = post_attachment(client, session, file_content, file_name)
+                    summary_rows.append([file_name, status])
+
     except Exception as e:
         client.print_exception_and_recover(e)
 
     display_summary_as_table(summary_rows)
 
 
-def matches_include_patterns(filename: str, include_patterns: List[str]) -> bool:
+def get_unique_filename(filepath: str, used_filenames: Set[str]) -> Optional[str]:
+    """
+    Get a unique filename by extracting the basename and prepending parent folders if needed.
+    Strategy:
+    1. First occurrence: use basename (e.g., app.log)
+    2. Duplicate: prepend parent directories until unique
+    """
+    # Normalize path separators to forward slash (archives always use forward slash in both linux, and windows)
+    normalized_path = filepath.replace(os.sep, '/')
+    normalized_path = normalize_filename(normalized_path)
+
+    basename = normalized_path.split('/')[-1]
+
+    # If basename is not used, return it
+    if basename not in used_filenames:
+        used_filenames.add(basename)
+        return basename
+
+    # Try prepending parents from nearest to farthest
+    path_parts = normalized_path.split('/')
+    parent_parts = [p for p in path_parts[:-1] if p]
+
+    prefixed_name = basename
+    for parent in reversed(parent_parts):
+        prefixed_name = f"{parent}/{prefixed_name}"
+
+        if prefixed_name not in used_filenames:
+            used_filenames.add(prefixed_name)
+            return prefixed_name
+
+    return None
+
+
+def matches_include_patterns(filename: str, include_patterns: Tuple[str, ...]) -> bool:
     """
     Check if a file should be included based on the include patterns.
     If no patterns are specified, all files are included.
@@ -121,6 +176,13 @@ def matches_include_patterns(filename: str, include_patterns: List[str]) -> bool
     return False
 
 
+def normalize_filename(filename: str) -> str:
+    """
+    Normalize filename by replacing whitespace with dashes.
+    """
+    return filename.replace(' ', '-')
+
+
 def valid_utf8_file(file_content: bytes) -> bool:
     # Check for null bytes (binary files)
     if b'\x00' in file_content:

{smart_tests_cli-2.4.2 → smart_tests_cli-2.5.1}/smart_tests/commands/subset.py

@@ -537,7 +537,7 @@ class Subset(TestPathWriter):
 
     def _collect_potential_test_files(self):
         LOOSE_TEST_FILE_PATTERN = r'(\.(test|spec)\.|_test\.|Test\.|Spec\.|test/|tests/|__tests__/|src/test/)'
-        EXCLUDE_PATTERN = r'(BUILD|Makefile|Dockerfile|LICENSE|.gitignore|.gitkeep|.keep|id_rsa|rsa|blank|taglib)|\.(xml|json|jsonl|txt|yml|yaml|toml|md|png|jpg|jpeg|gif|svg|sql|html|css|graphql|proto|gz|zip|rz|bzl|conf|config|snap|pem|crt|key|lock|jpi|hpi|jelly|properties|jar|ini|mod|sum|bmp|env|envrc|sh)$'  # noqa E501
+        EXCLUDE_PATTERN = r'(BUILD|Makefile|Dockerfile|LICENSE|.gitignore|.gitkeep|.keep|id_rsa|rsa|blank|taglib)|\.(xml|json|jsonl|txt|yml|yaml|toml|md|png|jpg|jpeg|gif|svg|sql|html|css|graphql|proto|gz|zip|rz|bzl|conf|config|snap|pem|crt|key|lock|jpi|hpi|jelly|properties|jar|ini|mod|sum|bmp|env|envrc|sh|csv|list)$'  # noqa E501
 
         try:
             git_managed_files = subprocess.run(['git', 'ls-files'], stdout=subprocess.PIPE,

{smart_tests_cli-2.4.2 → smart_tests_cli-2.5.1}/smart_tests/test_runners/maven.py

@@ -1,18 +1,18 @@
 import glob
 import os
 import re
-from typing import Annotated
-from typing import Dict, List, Tuple
+from typing import Annotated, Dict, List
 
 import click
 
 import smart_tests.args4p.typer as typer
 from smart_tests.utils import glob as uglob
 from smart_tests.utils.java import junit5_nested_class_path_builder
-from . import smart_tests
+
 from ..args4p.exceptions import BadCmdLineException
 from ..commands.record.tests import RecordTests
 from ..commands.subset import Subset
+from . import smart_tests
 
 # Surefire has the default inclusion pattern
 # https://maven.apache.org/surefire/maven-surefire-plugin/test-mojo.html#includes
@@ -169,4 +169,15 @@ def record_tests(
     )],
 ):
     client.path_builder = junit5_nested_class_path_builder(client.path_builder)
+
+    # Override report method to filter out non-JUnit report files
+    original_report = client.report
+
+    IGNORED_FILES = {'failsafe-summary.xml', 'testng-results.xml'}
+
+    def report_with_filter(junit_report_file: str):
+        if not any(junit_report_file.endswith(f) for f in IGNORED_FILES):
+            original_report(junit_report_file)
+
+    client.report = report_with_filter  # type: ignore[method-assign]
     smart_tests.CommonRecordTestImpls.load_report_files(client=client, source_roots=reports)

{smart_tests_cli-2.4.2 → smart_tests_cli-2.5.1}/smart_tests/test_runners/pytest.py

@@ -3,7 +3,8 @@ import json
 import os
 import pathlib
 import subprocess
-from typing import Annotated, Generator, Iterable, List
+from datetime import datetime, timezone
+from typing import Annotated, Generator, Iterable, List, Optional
 
 import click
 from junitparser import Properties, TestCase  # type: ignore
@@ -17,7 +18,6 @@ from ..commands.record.tests import RecordTests
 from ..commands.subset import Subset
 from . import smart_tests
 
-
 # Please specify junit_family=legacy for pytest report format. if using pytest version 6 or higher.
 # - pytest has changed its default test report format from xunit1 to xunit2 since version 6.
 #     - https://docs.pytest.org/en/latest/deprecations.html#junit-family-default-value-change-to-xunit2
@@ -40,6 +40,15 @@ from . import smart_tests
 # <testcase classname="tests.test_mod.TestClass" name="test__can_print_aaa" file="tests/test_mod.py"
 # line="3" time="0.001" />
 #
+
+
+def _timestamp_to_iso(ts: Optional[float]) -> Optional[str]:
+    # convert to ISO-8601 formatted date
+    if ts is None:
+        return None
+    return datetime.fromtimestamp(ts, tz=timezone.utc).isoformat()
+
+
 @smart_tests.subset
 def subset(
     client: Subset,
@@ -344,15 +353,39 @@ class PytestJSONReportParser:
                     else:
                         props = None
 
+                # extract raw timestamps
+                start_timestamp = data.get("start")
+                stop_timestamp = data.get("stop")
+
+                # convert to ISO-8601
+                start_timestamp_iso_format = _timestamp_to_iso(start_timestamp)
+                end_timestamp_iso_format = _timestamp_to_iso(stop_timestamp)
+
+                print(
+                    f"DEBUG pytest timing start={start_timestamp_iso_format}, stop={end_timestamp_iso_format}"
+                )
+
+                event_data = {}
+                if start_timestamp_iso_format:
+                    event_data["start_timestamp"] = start_timestamp_iso_format
+                if end_timestamp_iso_format:
+                    event_data["stop_timestamp"] = end_timestamp_iso_format
+
                 test_path = _parse_pytest_nodeid(nodeid)
                 for path in test_path:
                     if path.get("type") == "file":
                         path["name"] = pathlib.Path(path["name"]).as_posix()
 
+                data_payload = event_data if event_data else None
+
+                # end_timestamp_iso_format is being passed as timestamp as it reflects event finalization
+                # start + duration = stop
+                # sending both start and stop time in the event data field
                 yield CaseEvent.create(
                     test_path=test_path,
                     duration_secs=data.get("duration", 0),
                     status=status,
                     stdout=stdout,
                     stderr=stderr,
-                    data=props)
+                    timestamp=end_timestamp_iso_format,
+                    data=data_payload)

{smart_tests_cli-2.4.2 → smart_tests_cli-2.5.1}/smart_tests_cli.egg-info/PKG-INFO

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

{smart_tests_cli-2.4.2 → smart_tests_cli-2.5.1}/tests/commands/compare/test_subsets.py

@@ -201,17 +201,149 @@ class SubsetsTest(CliTestCase):
                           mix_stderr=False)
 
         self.assert_success(result)
-        expect = """PTS subset change summary:
-────────────────────────────────
--> 3 tests analyzed | 1 ↑ promoted | 1 ↓ demoted
--> Code files affected: bbb.py, ccc.py, ddd.py
-────────────────────────────────
-
-Δ Rank    Subset Rank    Test Name    Reason                Density
---------  -------------  -----------  --------------------  ---------
-NEW       1              file=ddd.py  Changed file: ddd.py  0.9
-↑1        2              file=ccc.py  Changed file: ccc.py  0.7
-↓1        3              file=bbb.py  Changed file: bbb.py  0.5
-DELETED   -              file=aaa.py
-"""
-        self.assertEqual(result.stdout, expect)
+        output = result.stdout
+        self.assertIn("3 tests analyzed | 1 ↑ promoted | 1 ↓ demoted", output)
+        self.assertIn("Code files affected: bbb.py, ccc.py, ddd.py", output)
+        self.assertIn("Δ Rank", output)
+        self.assertIn("Density", output)
+        for expected_row in [
+            ("NEW", "1", "file=ddd.py", "Changed file: ddd.py", "0.9"),
+            ("↑1", "2", "file=ccc.py", "Changed file: ccc.py", "0.7"),
+            ("↓1", "3", "file=bbb.py", "Changed file: bbb.py", "0.5"),
+            ("DELETED", "-", "file=aaa.py"),
+        ]:
+            for cell in expected_row:
+                self.assertIn(cell, output)
+
+    def test_wrap_data(self):
+        """Test that wrap_data breaks paths at separators."""
+        from smart_tests.commands.compare.subsets import wrap_data
+
+        # Short path - no wrapping needed
+        short = "Changed file: aaa.py"
+        self.assertEqual(wrap_data(short, width=30), short)
+
+        # Empty string
+        self.assertEqual(wrap_data("", width=30), "")
+
+        # Long path - should wrap at /
+        long_path = "Changed file: src/mongo/db/telemetry/telemetry_thread_base.cpp"
+        wrapped = wrap_data(long_path, width=30)
+
+        # Verify it contains newlines
+        self.assertIn("\n", wrapped)
+
+        # Verify no unwanted spaces around path separators
+        self.assertNotIn(" /", wrapped)
+
+        # Verify content is preserved (just reformatted)
+        unwrapped = wrapped.replace("\n", "")
+        self.assertEqual(unwrapped, long_path)
+
+        # Windows path test
+        windows_path = "Changed file: C:\\Users\\test\\very\\long\\windows\\path\\file.cpp"
+        wrapped_win = wrap_data(windows_path, width=30)
+        self.assertIn("\n", wrapped_win)
+        self.assertNotIn(" \\", wrapped_win)
+
+        # Verify content preservation
+        self.assertEqual(wrapped_win.replace("\n", ""), windows_path)
+
+    def test_get_column_width(self):
+        """Test that get_column_width() calculates widths based on terminal size."""
+        from smart_tests.commands.compare.subsets import get_column_width
+
+        # Test with a wide terminal (e.g., 160 columns)
+        # Available width = 160 - 36 (fixed columns) = 124
+        # Per column = 124 / 2 = 62
+        with mock.patch("shutil.get_terminal_size") as mock_terminal:
+            mock_terminal.return_value = os.terminal_size((160, 24))
+            width = get_column_width()
+            self.assertEqual(width, 62)
+
+        # Test with standard terminal (80 columns)
+        # Available width = 80 - 36 = 44
+        # Per column = 44 / 2 = 22, but minimum is 30
+        with mock.patch("shutil.get_terminal_size") as mock_terminal:
+            mock_terminal.return_value = os.terminal_size((80, 24))
+            width = get_column_width()
+            self.assertEqual(width, 30)  # Should hit minimum
+
+        # Test with narrow terminal (60 columns)
+        # Should still return minimum of 30
+        with mock.patch("shutil.get_terminal_size") as mock_terminal:
+            mock_terminal.return_value = os.terminal_size((60, 24))
+            width = get_column_width()
+            self.assertEqual(width, 30)  # Should hit minimum
+
+        # Test with very wide terminal (200 columns)
+        # Available width = 200 - 36 = 164
+        # Per column = 164 / 2 = 82
+        with mock.patch("shutil.get_terminal_size") as mock_terminal:
+            mock_terminal.return_value = os.terminal_size((200, 24))
+            width = get_column_width()
+            self.assertEqual(width, 82)
+
+        # Test fallback when get_terminal_size raises exception
+        with mock.patch("shutil.get_terminal_size") as mock_terminal:
+            mock_terminal.side_effect = Exception("Terminal size unavailable")
+            width = get_column_width()
+            self.assertEqual(width, 30)  # Should fall back to default
+
+    @mock.patch.dict(os.environ, {"SMART_TESTS_TOKEN": CliTestCase.smart_tests_token})
+    @responses.activate
+    def test_subsets_with_long_paths_wrapped(self):
+        """Test that long file paths in Reason column are wrapped properly."""
+        long_path1 = "src/mongo/db/telemetry/telemetry_thread_base.cpp"
+        long_path2 = "jstests/concurrency/fsm_workloads/timeseries/timeseries_raw_data_operations.js"
+
+        responses.add(
+            responses.GET,
+            f"{get_base_url()}/intake/organizations/{self.organization}/workspaces/{self.workspace}/subset/200",
+            json={
+                "subsetting": {"id": 200},
+                "testPaths": [
+                    {"testPath": [{"type": "file", "name": long_path1}],
+                     "duration": 10, "density": 0.9,
+                     "reason": f"Changed file: {long_path1}"}
+                ],
+                "rest": []
+            },
+            status=200
+        )
+
+        responses.add(
+            responses.GET,
+            f"{get_base_url()}/intake/organizations/{self.organization}/workspaces/{self.workspace}/subset/201",
+            json={
+                "subsetting": {"id": 201},
+                "testPaths": [
+                    {"testPath": [{"type": "file", "name": long_path2}],
+                     "duration": 10, "density": 0.85,
+                     "reason": f"Changed file: {long_path2}"}
+                ],
+                "rest": []
+            },
+            status=200
+        )
+
+        result = self.cli('compare', 'subsets',
+                          '--subset-id-before', '200',
+                          '--subset-id-after', '201',
+                          mix_stderr=False)
+
+        self.assert_success(result)
+
+        # Verify output contains the summary
+        self.assertIn("PTS subset change summary:", result.stdout)
+        self.assertIn("Changed file:", result.stdout)
+
+        # Verify the long paths are present (even if wrapped)
+        self.assertIn("telemetry_thread_base.cpp", result.stdout)
+        self.assertIn("timeseries_raw_data_operations.js", result.stdout)
+
+        # Verify no line has excessive length (wrapped properly)
+        for line in result.stdout.split('\n'):
+            # Allow some buffer for separator lines
+            if line.strip() and not line.startswith('─'):
+                self.assertLessEqual(len(line), 150)