truss 0.11.6rc102__py3-none-any.whl → 0.11.24rc2__py3-none-any.whl

truss/tests/cli/test_cli.py

@@ -1,4 +1,4 @@
-from unittest.mock import Mock, patch
+from unittest.mock import MagicMock, Mock, patch
 
 from click.testing import CliRunner
 
@@ -23,3 +23,136 @@ def test_push_with_grpc_transport_fails_for_development_deployment():
         "Truss with gRPC transport cannot be used as a development deployment"
         in result.output
     )
+
+
+def test_cli_push_passes_deploy_timeout_minutes_to_create_truss_service(
+    custom_model_truss_dir_with_pre_and_post,
+    remote,
+    mock_baseten_requests,
+    mock_upload_truss,
+    mock_create_truss_service,
+):
+    runner = CliRunner()
+    with patch("truss.cli.cli.RemoteFactory.create", return_value=remote):
+        remote.api.get_teams = Mock(return_value={})
+        with patch("truss.cli.cli.resolve_model_team_name", return_value=(None, None)):
+            result = runner.invoke(
+                truss_cli,
+                [
+                    "push",
+                    str(custom_model_truss_dir_with_pre_and_post),
+                    "--remote",
+                    "baseten",
+                    "--model-name",
+                    "model_name",
+                    "--publish",
+                    "--deploy-timeout-minutes",
+                    "450",
+                ],
+            )
+
+    assert result.exit_code == 0
+    mock_create_truss_service.assert_called_once()
+    _, kwargs = mock_create_truss_service.call_args
+    assert kwargs["deploy_timeout_minutes"] == 450
+
+
+def test_cli_push_passes_none_deploy_timeout_minutes_when_not_specified(
+    custom_model_truss_dir_with_pre_and_post,
+    remote,
+    mock_baseten_requests,
+    mock_upload_truss,
+    mock_create_truss_service,
+):
+    runner = CliRunner()
+    with patch("truss.cli.cli.RemoteFactory.create", return_value=remote):
+        remote.api.get_teams = Mock(return_value={})
+        with patch("truss.cli.cli.resolve_model_team_name", return_value=(None, None)):
+            result = runner.invoke(
+                truss_cli,
+                [
+                    "push",
+                    str(custom_model_truss_dir_with_pre_and_post),
+                    "--remote",
+                    "baseten",
+                    "--model-name",
+                    "model_name",
+                    "--publish",
+                ],
+            )
+
+    assert result.exit_code == 0
+    mock_create_truss_service.assert_called_once()
+    _, kwargs = mock_create_truss_service.call_args
+    assert kwargs.get("deploy_timeout_minutes") is None
+
+
+def test_cli_push_integration_deploy_timeout_minutes_propagated(
+    custom_model_truss_dir_with_pre_and_post,
+    remote,
+    mock_baseten_requests,
+    mock_upload_truss,
+    mock_create_truss_service,
+):
+    runner = CliRunner()
+    with patch("truss.cli.cli.RemoteFactory.create", return_value=remote):
+        remote.api.get_teams = Mock(return_value={})
+        with patch("truss.cli.cli.resolve_model_team_name", return_value=(None, None)):
+            result = runner.invoke(
+                truss_cli,
+                [
+                    "push",
+                    str(custom_model_truss_dir_with_pre_and_post),
+                    "--remote",
+                    "baseten",
+                    "--model-name",
+                    "model_name",
+                    "--publish",
+                    "--environment",
+                    "staging",
+                    "--deploy-timeout-minutes",
+                    "750",
+                ],
+            )
+
+    assert result.exit_code == 0
+    mock_create_truss_service.assert_called_once()
+    _, kwargs = mock_create_truss_service.call_args
+    assert kwargs["deploy_timeout_minutes"] == 750
+    assert kwargs["environment"] == "staging"
+
+
+def test_cli_push_api_integration_deploy_timeout_minutes_propagated(
+    custom_model_truss_dir_with_pre_and_post,
+    mock_remote_factory,
+    temp_trussrc_dir,
+    mock_available_config_names,
+):
+    mock_service = MagicMock()
+    mock_service.model_id = "model_id"
+    mock_service.model_version_id = "version_id"
+    mock_remote_factory.push.return_value = mock_service
+
+    runner = CliRunner()
+    with patch(
+        "truss.cli.cli.RemoteFactory.get_available_config_names",
+        return_value=["baseten"],
+    ):
+        result = runner.invoke(
+            truss_cli,
+            [
+                "push",
+                str(custom_model_truss_dir_with_pre_and_post),
+                "--remote",
+                "baseten",
+                "--model-name",
+                "test_model",
+                "--deploy-timeout-minutes",
+                "1200",
+            ],
+        )
+
+    assert result.exit_code == 0
+    mock_remote_factory.push.assert_called_once()
+    _, push_kwargs = mock_remote_factory.push.call_args
+    assert push_kwargs.get("deploy_timeout_minutes") == 1200

truss/tests/cli/test_cli_utils_common.py

@@ -0,0 +1,11 @@
+from truss.cli.utils import common
+
+
+def test_normalize_iso_timestamp_handles_nanoseconds():
+    normalized = common._normalize_iso_timestamp("2025-11-17 05:05:06.000000000 +0000")
+    assert normalized == "2025-11-17 05:05:06.000000+00:00"
+
+
+def test_normalize_iso_timestamp_handles_z_suffix_and_short_fraction():
+    normalized = common._normalize_iso_timestamp("2025-11-17T05:05:06.123456Z")
+    assert normalized == "2025-11-17T05:05:06.123456+00:00"

truss/tests/cli/test_model_team_resolver.py

@@ -0,0 +1,279 @@
+"""Tests for team parameter in model push.
+
+This test suite covers all 8 scenarios for team resolution in truss push:
+1. --team PROVIDED: Valid team name, user has access
+2. --team PROVIDED: Invalid team name (does not exist)
+3. --team NOT PROVIDED: User has multiple teams, no existing model
+4. --team NOT PROVIDED: User has multiple teams, existing model in exactly one team
+5. --team NOT PROVIDED: User has multiple teams, existing model exists in multiple teams
+6. --team NOT PROVIDED: User has exactly one team, no existing model
+7. --team NOT PROVIDED: User has exactly one team, existing model matches the team
+8. --team NOT PROVIDED: User has exactly one team, existing model exists in different team
+"""
+
+from unittest.mock import Mock, patch
+
+import click
+import pytest
+
+from truss.cli.resolvers.model_team_resolver import resolve_model_team_name
+from truss.remote.baseten.remote import BasetenRemote
+
+
+class TestModelTeamResolver:
+    """Test team parameter resolution for model push."""
+
+    @staticmethod
+    def _setup_mock_remote(teams):
+        mock_remote = Mock(spec=BasetenRemote)
+        mock_api = Mock()
+        mock_remote.api = mock_api
+        mock_api.get_teams.return_value = teams
+        return mock_remote
+
+    @pytest.mark.parametrize(
+        "provided_team_name,expected_team_name,expected_team_id,should_raise",
+        [
+            # SCENARIO 1: Valid team name
+            ("Team Alpha", "Team Alpha", "team1", False),
+            # SCENARIO 2: Invalid team name
+            ("NonExistentTeam", None, None, True),
+        ],
+    )
+    def test_team_provided_scenarios(
+        self, provided_team_name, expected_team_name, expected_team_id, should_raise
+    ):
+        """Test scenarios when --team is provided."""
+        teams = {"Team Alpha": {"id": "team1", "name": "Team Alpha"}}
+        mock_remote = self._setup_mock_remote(teams)
+
+        if should_raise:
+            with pytest.raises(click.ClickException) as exc_info:
+                resolve_model_team_name(
+                    remote_provider=mock_remote,
+                    provided_team_name=provided_team_name,
+                    existing_teams=teams,
+                )
+            assert "does not exist" in str(exc_info.value)
+            assert provided_team_name in str(exc_info.value)
+        else:
+            team_name, team_id = resolve_model_team_name(
+                remote_provider=mock_remote,
+                provided_team_name=provided_team_name,
+                existing_teams=teams,
+            )
+            assert team_name == expected_team_name
+            assert team_id == expected_team_id
+            mock_remote.api.get_teams.assert_not_called()
+
+    @pytest.mark.parametrize(
+        "scenario_num,teams,models_response,existing_model_name,inquire_return,expected_team_name,expected_team_id,should_prompt",
+        [
+            # SCENARIO 3: Multiple teams, no existing model
+            (
+                3,
+                {
+                    "Team Alpha": {"id": "team1", "name": "Team Alpha"},
+                    "Team Beta": {"id": "team2", "name": "Team Beta"},
+                    "Team Gamma": {"id": "team3", "name": "Team Gamma"},
+                },
+                {"models": []},  # No models exist
+                "non-existent-model",
+                "Team Beta",
+                "Team Beta",
+                "team2",
+                True,
+            ),
+            # SCENARIO 4: Multiple teams, existing model in exactly one team
+            (
+                4,
+                {
+                    "Team Alpha": {"id": "team1", "name": "Team Alpha"},
+                    "Team Beta": {"id": "team2", "name": "Team Beta"},
+                    "Team Gamma": {"id": "team3", "name": "Team Gamma"},
+                },
+                {
+                    "models": [
+                        {
+                            "id": "model1",
+                            "name": "existing-model",
+                            "team": {"id": "team2", "name": "Team Beta"},
+                        }
+                    ]
+                },
+                "existing-model",
+                None,
+                "Team Beta",
+                "team2",
+                False,
+            ),
+            # SCENARIO 5: Multiple teams, existing model in multiple teams
+            (
+                5,
+                {
+                    "Team Alpha": {"id": "team1", "name": "Team Alpha"},
+                    "Team Beta": {"id": "team2", "name": "Team Beta"},
+                    "Team Gamma": {"id": "team3", "name": "Team Gamma"},
+                },
+                {
+                    "models": [
+                        {
+                            "id": "model1",
+                            "name": "existing-model",
+                            "team": {"id": "team1", "name": "Team Alpha"},
+                        },
+                        {
+                            "id": "model2",
+                            "name": "existing-model",
+                            "team": {"id": "team2", "name": "Team Beta"},
+                        },
+                    ]
+                },
+                "existing-model",
+                "Team Alpha",
+                "Team Alpha",
+                "team1",
+                True,
+            ),
+            # SCENARIO 6: Single team, no existing model
+            (
+                6,
+                {"Team Alpha": {"id": "team1", "name": "Team Alpha"}},
+                {"models": []},  # No models exist
+                "non-existent-model",
+                None,
+                "Team Alpha",
+                "team1",
+                False,
+            ),
+            # SCENARIO 7: Single team, existing model matches the team
+            (
+                7,
+                {"Team Alpha": {"id": "team1", "name": "Team Alpha"}},
+                {
+                    "models": [
+                        {
+                            "id": "model1",
+                            "name": "existing-model",
+                            "team": {"id": "team1", "name": "Team Alpha"},
+                        }
+                    ]
+                },
+                "existing-model",
+                None,
+                "Team Alpha",
+                "team1",
+                False,
+            ),
+            # SCENARIO 8: Single team, existing model in different team
+            (
+                8,
+                {"Team Alpha": {"id": "team1", "name": "Team Alpha"}},
+                {
+                    "models": [
+                        {
+                            "id": "model1",
+                            "name": "existing-model",
+                            "team": {"id": "team2", "name": "Team Other"},
+                        }
+                    ]
+                },
+                "existing-model",
+                None,
+                "Team Alpha",
+                "team1",
+                False,
+            ),
+        ],
+    )
+    @patch("truss.cli.resolvers.model_team_resolver.remote_cli.inquire_team")
+    def test_team_not_provided_scenarios(
+        self,
+        mock_inquire_team,
+        scenario_num,
+        teams,
+        models_response,
+        existing_model_name,
+        inquire_return,
+        expected_team_name,
+        expected_team_id,
+        should_prompt,
+    ):
+        """Test scenarios when --team is NOT provided."""
+        mock_remote = self._setup_mock_remote(teams)
+        if inquire_return:
+            mock_inquire_team.return_value = inquire_return
+
+        mock_remote.api.models.return_value = models_response
+
+        team_name, team_id = resolve_model_team_name(
+            remote_provider=mock_remote,
+            provided_team_name=None,
+            existing_model_name=existing_model_name,
+            existing_teams=teams,
+        )
+
+        assert team_name == expected_team_name
+        assert team_id == expected_team_id
+        if should_prompt:
+            mock_inquire_team.assert_called_once_with(existing_teams=teams)
+        else:
+            mock_inquire_team.assert_not_called()
+        if existing_model_name:
+            mock_remote.api.models.assert_called_once()
+
+    @pytest.mark.parametrize(
+        "existing_teams_param,should_call_get_teams",
+        [(None, True), ({"Team Alpha": {"id": "team1", "name": "Team Alpha"}}, False)],
+    )
+    def test_get_teams_called_when_existing_teams_none(
+        self, existing_teams_param, should_call_get_teams
+    ):
+        """Test that get_teams is called when existing_teams is not provided."""
+        teams = {"Team Alpha": {"id": "team1", "name": "Team Alpha"}}
+        mock_remote = self._setup_mock_remote(teams)
+
+        team_name, team_id = resolve_model_team_name(
+            remote_provider=mock_remote,
+            provided_team_name="Team Alpha",
+            existing_teams=existing_teams_param,
+        )
+
+        assert team_name == "Team Alpha"
+        assert team_id == "team1"
+        if should_call_get_teams:
+            mock_remote.api.get_teams.assert_called_once()
+        else:
+            mock_remote.api.get_teams.assert_not_called()
+
+    @pytest.mark.parametrize(
+        "existing_model_name,should_call_models_api",
+        [(None, False), ("some-model", True)],
+    )
+    @patch("truss.cli.resolvers.model_team_resolver.remote_cli.inquire_team")
+    def test_existing_model_name_scenarios(
+        self, mock_inquire_team, existing_model_name, should_call_models_api
+    ):
+        """Test behavior with different existing_model_name values."""
+        teams = {
+            "Team Alpha": {"id": "team1", "name": "Team Alpha"},
+            "Team Beta": {"id": "team2", "name": "Team Beta"},
+        }
+        mock_remote = self._setup_mock_remote(teams)
+        mock_inquire_team.return_value = "Team Beta"
+        mock_remote.api.models.return_value = {"models": []}
+
+        team_name, team_id = resolve_model_team_name(
+            remote_provider=mock_remote,
+            provided_team_name=None,
+            existing_model_name=existing_model_name,
+            existing_teams=teams,
+        )
+
+        assert team_name == "Team Beta"
+        assert team_id == "team2"
+        mock_inquire_team.assert_called_once_with(existing_teams=teams)
+        if should_call_models_api:
+            mock_remote.api.models.assert_called_once()
+        else:
+            mock_remote.api.models.assert_not_called()

truss/tests/cli/train/test_cache_view.py

@@ -3,7 +3,7 @@ from unittest.mock import Mock
 import click
 import pytest
 
-from truss.cli.train.core import (
+from truss.cli.train.cache import (
     SORT_BY_FILEPATH,
     SORT_BY_MODIFIED,
     SORT_BY_PERMISSIONS,
@@ -12,8 +12,8 @@ from truss.cli.train.core import (
     SORT_ORDER_ASC,
     SORT_ORDER_DESC,
     view_cache_summary,
-    view_cache_summary_by_project,
 )
+from truss.cli.train.core import view_cache_summary_by_project
 from truss.remote.baseten.remote import BasetenRemote
 
 
@@ -106,7 +106,9 @@ def test_view_cache_summary_empty_files(capsys):
     mock_api.get_cache_summary.assert_called_once_with("proj123")
 
     captured = capsys.readouterr()
-    assert "No files found in cache." in captured.out
+    # Empty files should still show the table with 0 files
+    assert "Cache summary for project: proj123" in captured.out
+    assert "Total files: 0" in captured.out
 
 
 def test_view_cache_summary_api_error(capsys):
@@ -710,3 +712,238 @@ def test_view_cache_summary_sort_by_permissions_desc(capsys):
 
     assert directory_pos < script_pos
     assert script_pos < config_pos
+
+
+# Tests for individual viewers
+def test_cli_table_viewer_with_data(capsys):
+    """Test CLITableViewer outputs table correctly with data."""
+    from truss.cli.train.cache import CLITableViewer
+    from truss.remote.baseten.custom_types import (
+        FileSummary,
+        FileSummaryWithTotalSize,
+        GetCacheSummaryResponseV1,
+    )
+
+    viewer = CLITableViewer()
+    cache_data = GetCacheSummaryResponseV1(
+        timestamp="2024-01-01T12:00:00Z",
+        project_id="proj123",
+        file_summaries=[
+            FileSummary(
+                path="test/file.txt",
+                size_bytes=1024,
+                modified="2024-01-01T10:00:00Z",
+                file_type="file",
+                permissions="-rw-r--r--",
+            )
+        ],
+    )
+    files_with_total_sizes = [
+        FileSummaryWithTotalSize(
+            file_summary=cache_data.file_summaries[0], total_size=1024
+        )
+    ]
+
+    viewer.output_cache_summary(
+        cache_data, files_with_total_sizes, 1024, "1.02 KB", "proj123"
+    )
+
+    captured = capsys.readouterr()
+    assert "Cache summary for project: proj123" in captured.out
+    assert "test/file.txt" in captured.out
+    assert "1.02 KB" in captured.out
+    assert "Total files: 1" in captured.out
+
+
+def test_cli_table_viewer_empty_files(capsys):
+    """Test CLITableViewer handles empty files correctly."""
+    from truss.cli.train.cache import CLITableViewer
+    from truss.remote.baseten.custom_types import GetCacheSummaryResponseV1
+
+    viewer = CLITableViewer()
+    cache_data = GetCacheSummaryResponseV1(
+        timestamp="2024-01-01T12:00:00Z", project_id="proj123", file_summaries=[]
+    )
+
+    viewer.output_cache_summary(cache_data, [], 0, "0 B", "proj123")
+
+    captured = capsys.readouterr()
+    assert "Cache summary for project: proj123" in captured.out
+    assert "Total files: 0" in captured.out
+    assert "Total size: 0 B" in captured.out
+
+
+def test_cli_table_viewer_no_cache(capsys):
+    """Test CLITableViewer handles no cache message."""
+    from truss.cli.train.cache import CLITableViewer
+
+    viewer = CLITableViewer()
+    viewer.output_no_cache_message("proj123")
+
+    captured = capsys.readouterr()
+    assert "No cache summary found for this project." in captured.out
+
+
+def test_csv_viewer_with_data(capsys):
+    """Test CSVViewer outputs CSV correctly with data."""
+    from truss.cli.train.cache import CSVViewer
+    from truss.remote.baseten.custom_types import (
+        FileSummary,
+        FileSummaryWithTotalSize,
+        GetCacheSummaryResponseV1,
+    )
+
+    viewer = CSVViewer()
+    cache_data = GetCacheSummaryResponseV1(
+        timestamp="2024-01-01T12:00:00Z",
+        project_id="proj123",
+        file_summaries=[
+            FileSummary(
+                path="test/file.txt",
+                size_bytes=2048,
+                modified="2024-01-01T10:00:00Z",
+                file_type="file",
+                permissions="-rw-r--r--",
+            )
+        ],
+    )
+    files_with_total_sizes = [
+        FileSummaryWithTotalSize(
+            file_summary=cache_data.file_summaries[0], total_size=2048
+        )
+    ]
+
+    viewer.output_cache_summary(
+        cache_data, files_with_total_sizes, 2048, "2.05 KB", "proj123"
+    )
+
+    captured = capsys.readouterr()
+    lines = captured.out.strip().split("\n")
+    assert len(lines) == 2  # Header + 1 data row
+    assert "File Path" in lines[0]
+    assert "Size (bytes)" in lines[0]
+    assert "test/file.txt" in lines[1]
+    assert "2048" in lines[1]
+    assert "2.05 KB" in lines[1]
+
+
+def test_csv_viewer_empty_files(capsys):
+    """Test CSVViewer handles empty files correctly (just headers)."""
+    from truss.cli.train.cache import CSVViewer
+    from truss.remote.baseten.custom_types import GetCacheSummaryResponseV1
+
+    viewer = CSVViewer()
+    cache_data = GetCacheSummaryResponseV1(
+        timestamp="2024-01-01T12:00:00Z", project_id="proj123", file_summaries=[]
+    )
+
+    viewer.output_cache_summary(cache_data, [], 0, "0 B", "proj123")
+
+    captured = capsys.readouterr()
+    lines = captured.out.strip().split("\n")
+    assert len(lines) == 1  # Just header row
+    assert "File Path" in lines[0]
+    assert "Size (bytes)" in lines[0]
+
+
+def test_csv_viewer_no_cache(capsys):
+    """Test CSVViewer handles no cache (outputs empty CSV with headers)."""
+    from truss.cli.train.cache import CSVViewer
+
+    viewer = CSVViewer()
+    viewer.output_no_cache_message("proj123")
+
+    captured = capsys.readouterr()
+    lines = captured.out.strip().split("\n")
+    assert len(lines) == 1  # Just header row
+    assert "File Path" in lines[0]
+
+
+def test_json_viewer_with_data(capsys):
+    """Test JSONViewer outputs JSON correctly with data."""
+    import json
+
+    from truss.cli.train.cache import JSONViewer
+    from truss.remote.baseten.custom_types import (
+        FileSummary,
+        FileSummaryWithTotalSize,
+        GetCacheSummaryResponseV1,
+    )
+
+    viewer = JSONViewer()
+    cache_data = GetCacheSummaryResponseV1(
+        timestamp="2024-01-01T12:00:00Z",
+        project_id="proj123",
+        file_summaries=[
+            FileSummary(
+                path="test/file.txt",
+                size_bytes=3072,
+                modified="2024-01-01T10:00:00Z",
+                file_type="file",
+                permissions="-rw-r--r--",
+            )
+        ],
+    )
+    files_with_total_sizes = [
+        FileSummaryWithTotalSize(
+            file_summary=cache_data.file_summaries[0], total_size=3072
+        )
+    ]
+
+    viewer.output_cache_summary(
+        cache_data, files_with_total_sizes, 3072, "3.07 KB", "proj123"
+    )
+
+    captured = capsys.readouterr()
+    output = json.loads(captured.out)
+    assert output["timestamp"] == "2024-01-01T12:00:00Z"
+    assert output["project_id"] == "proj123"
+    assert output["total_files"] == 1
+    assert output["total_size_bytes"] == 3072
+    assert output["total_size_human_readable"] == "3.07 KB"
+    assert len(output["files"]) == 1
+    assert output["files"][0]["path"] == "test/file.txt"
+    assert output["files"][0]["size_bytes"] == 3072
+
+
+def test_json_viewer_empty_files(capsys):
+    """Test JSONViewer handles empty files correctly."""
+    import json
+
+    from truss.cli.train.cache import JSONViewer
+    from truss.remote.baseten.custom_types import GetCacheSummaryResponseV1
+
+    viewer = JSONViewer()
+    cache_data = GetCacheSummaryResponseV1(
+        timestamp="2024-01-01T12:00:00Z", project_id="proj123", file_summaries=[]
+    )
+
+    viewer.output_cache_summary(cache_data, [], 0, "0 B", "proj123")
+
+    captured = capsys.readouterr()
+    output = json.loads(captured.out)
+    assert output["timestamp"] == "2024-01-01T12:00:00Z"
+    assert output["project_id"] == "proj123"
+    assert output["total_files"] == 0
+    assert output["total_size_bytes"] == 0
+    assert output["total_size_human_readable"] == "0 B"
+    assert output["files"] == []
+
+
+def test_json_viewer_no_cache(capsys):
+    """Test JSONViewer handles no cache (outputs empty JSON structure)."""
+    import json
+
+    from truss.cli.train.cache import JSONViewer
+
+    viewer = JSONViewer()
+    viewer.output_no_cache_message("proj123")
+
+    captured = capsys.readouterr()
+    output = json.loads(captured.out)
+    assert output["timestamp"] == ""
+    assert output["project_id"] == "proj123"
+    assert output["total_files"] == 0
+    assert output["total_size_bytes"] == 0
+    assert output["total_size_human_readable"] == "0 B"
+    assert output["files"] == []