Buckets:

download
raw
27 kB
"""Tests for the Tessera CLI."""
import json
import re
from typing import Any
from unittest.mock import MagicMock, patch
import httpx
import pytest
from typer.testing import CliRunner
from tessera.cli import app
runner = CliRunner()
def clean_ansi(text: str) -> str:
"""Strip ANSI color codes from string."""
return re.sub(r"\x1b\[[0-9;]*m", "", text)
class TestVersion:
"""Tests for the version command."""
def test_version_from_package_metadata(self) -> None:
with patch("tessera.cli.importlib.metadata.version", return_value="2.3.1"):
result = runner.invoke(app, ["version"])
assert result.exit_code == 0
assert "tessera 2.3.1" in clean_ansi(result.output)
def test_version_package_not_found(self) -> None:
import importlib.metadata as _meta
with patch(
"tessera.cli.importlib.metadata.version",
side_effect=_meta.PackageNotFoundError,
):
result = runner.invoke(app, ["version"])
assert result.exit_code == 0
assert "tessera dev" in clean_ansi(result.output)
class TestTeamCommands:
"""Tests for team subcommands."""
def test_team_create_success(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 201
mock_response.json.return_value = {
"id": "team-123",
"name": "Data Platform",
"created_at": "2024-01-01T00:00:00Z",
}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["team", "create", "Data Platform"])
assert result.exit_code == 0
assert "Created team:" in result.output
assert "Data Platform" in result.output
def test_team_create_with_metadata(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 201
mock_response.json.return_value = {
"id": "team-123",
"name": "Data Platform",
"metadata": {"slack": "#data-platform"},
"created_at": "2024-01-01T00:00:00Z",
}
with patch("tessera.cli.make_request", return_value=mock_response) as mock_req:
result = runner.invoke(
app, ["team", "create", "Data Platform", "-m", '{"slack": "#data-platform"}']
)
assert result.exit_code == 0
# Verify metadata was passed
call_args = mock_req.call_args
assert call_args[1]["json_data"]["metadata"] == {"slack": "#data-platform"}
def test_team_list_empty(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = []
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["team", "list"])
assert result.exit_code == 0
assert "No teams found" in result.output
def test_team_list_with_teams(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = [
{"id": "team-1", "name": "Team A", "created_at": "2024-01-01T00:00:00Z"},
{"id": "team-2", "name": "Team B", "created_at": "2024-01-02T00:00:00Z"},
]
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["team", "list"])
assert result.exit_code == 0
assert "Team A" in result.output
assert "Team B" in result.output
def test_team_get(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {
"id": "team-123",
"name": "Data Platform",
"created_at": "2024-01-01T00:00:00Z",
}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["team", "get", "team-123"])
assert result.exit_code == 0
assert "team-123" in result.output
class TestAssetCommands:
"""Tests for asset subcommands."""
def test_asset_create_success(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 201
mock_response.json.return_value = {
"id": "asset-123",
"fqn": "warehouse.schema.users",
"owner_team_id": "team-1",
}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(
app, ["asset", "create", "warehouse.schema.users", "--team", "team-1"]
)
assert result.exit_code == 0
assert "Created asset:" in result.output
assert "warehouse.schema.users" in result.output
def test_asset_list_empty(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {"results": []}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["asset", "list"])
assert result.exit_code == 0
assert "No assets found" in result.output
def test_asset_list_with_assets(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {
"results": [
{"id": "a1", "fqn": "db.schema.table1", "owner_team_id": "t1"},
{"id": "a2", "fqn": "db.schema.table2", "owner_team_id": "t2"},
]
}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["asset", "list"])
assert result.exit_code == 0
assert "table1" in result.output
assert "table2" in result.output
def test_asset_search(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {"results": [{"id": "a1", "fqn": "db.schema.users"}]}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["asset", "search", "users"])
assert result.exit_code == 0
assert "users" in result.output
class TestContractCommands:
"""Tests for contract subcommands."""
def test_contract_publish_file_not_found(self, tmp_path: pytest.TempPathFactory) -> None:
result = runner.invoke(
app,
[
"contract",
"publish",
"--asset",
"a1",
"--version",
"1.0.0",
"--schema",
"/nonexistent/schema.json",
"--team",
"t1",
],
)
assert result.exit_code == 1
assert "Schema file not found" in result.output
def test_contract_publish_success(self, tmp_path: pytest.TempPathFactory) -> None:
# Create a temporary schema file
schema_file = tmp_path / "schema.json" # type: ignore[operator]
schema = {"type": "object", "properties": {"id": {"type": "string"}}}
schema_file.write_text(json.dumps(schema))
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 201
mock_response.json.return_value = {
"contract": {"id": "c1", "version": "1.0.0", "status": "active"}
}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(
app,
[
"contract",
"publish",
"--asset",
"a1",
"--version",
"1.0.0",
"--schema",
str(schema_file),
"--team",
"t1",
],
)
assert result.exit_code == 0
assert "Published contract:" in result.output
assert "v1.0.0" in clean_ansi(result.output)
def test_contract_publish_breaking_change(self, tmp_path: pytest.TempPathFactory) -> None:
schema_file = tmp_path / "schema.json" # type: ignore[operator]
schema = {"type": "object", "properties": {"id": {"type": "string"}}}
schema_file.write_text(json.dumps(schema))
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {
"proposal": {"id": "p1", "status": "pending"},
"breaking_changes": [
{"change_type": "field_removed", "message": "Field 'name' removed"}
],
}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(
app,
[
"contract",
"publish",
"--asset",
"a1",
"--version",
"2.0.0",
"--schema",
str(schema_file),
"--team",
"t1",
],
)
assert result.exit_code == 0
assert "Breaking change detected" in result.output
assert "field_removed" in result.output
def test_contract_list_empty(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {"results": [], "total": 0, "limit": 50, "offset": 0}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["contract", "list", "asset-123"])
assert result.exit_code == 0
assert "No contracts found" in result.output
def test_contract_list_with_contracts(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {
"results": [
{
"id": "c1",
"version": "1.0.0",
"status": "deprecated",
"published_at": "2024-01-01T00:00:00Z",
},
{
"id": "c2",
"version": "2.0.0",
"status": "active",
"published_at": "2024-01-02T00:00:00Z",
},
],
"total": 2,
"limit": 50,
"offset": 0,
}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["contract", "list", "asset-123"])
assert result.exit_code == 0
assert "1.0.0" in result.output
assert "2.0.0" in result.output
def test_contract_diff(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {
"from_version": "1.0.0",
"to_version": "2.0.0",
"change_type": "minor",
"is_breaking": False,
"changes": [
{"change_type": "field_added", "message": "Added field 'email'", "breaking": False}
],
}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["contract", "diff", "asset-123"])
assert result.exit_code == 0
output = clean_ansi(result.output)
assert "1.0.0" in output
assert "2.0.0" in output
assert "field_added" in output
class TestProposalCommands:
"""Tests for proposal subcommands."""
def test_proposal_list_empty(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {"results": []}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["proposal", "list"])
assert result.exit_code == 0
assert "No proposals found" in result.output
def test_proposal_status(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {
"proposal_id": "p1",
"status": "pending",
"pending_count": 2,
"acknowledged_count": 1,
"can_publish": False,
"acknowledgments": [
{"consumer_team_name": "Team A", "response": "approved"},
],
}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["proposal", "status", "p1"])
assert result.exit_code == 0
assert "pending" in result.output
assert "Team A" in result.output
def test_proposal_acknowledge(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {"id": "ack-1", "response": "approved"}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(
app, ["proposal", "acknowledge", "p1", "--team", "t1", "--response", "approved"]
)
assert result.exit_code == 0
assert "Acknowledged:" in result.output
def test_proposal_force_with_yes(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {"id": "p1", "status": "force_approved"}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["proposal", "force", "p1", "--team", "t1", "--yes"])
assert result.exit_code == 0
assert "Force approved:" in result.output
class TestRegisterCommand:
"""Tests for the register command."""
def test_register_success(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 201
mock_response.json.return_value = {
"id": "reg-1",
"asset_id": "a1",
"consumer_team_id": "t1",
}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["register", "--asset", "a1", "--team", "t1"])
assert result.exit_code == 0
assert "Registered:" in result.output
def test_register_with_pin(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 201
mock_response.json.return_value = {
"id": "reg-1",
"asset_id": "a1",
"consumer_team_id": "t1",
"pinned_version": "1.0.0",
}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(
app, ["register", "--asset", "a1", "--team", "t1", "--pin", "1.0.0"]
)
assert result.exit_code == 0
assert "Pinned to:" in result.output
assert "v1.0.0" in clean_ansi(result.output)
class TestErrorHandling:
"""Tests for error handling."""
def test_api_error_response(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 404
mock_response.text = "Not found"
mock_response.json.return_value = {"detail": "Team not found"}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["team", "get", "nonexistent"])
assert result.exit_code == 1
output = clean_ansi(result.output)
assert "Error (404)" in output
assert "Team not found" in output
def test_api_error_no_json(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 500
mock_response.text = "Internal Server Error"
mock_response.json.side_effect = Exception("Invalid JSON")
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["team", "get", "team-1"])
assert result.exit_code == 1
assert "Error (500)" in clean_ansi(result.output)
class TestHelpOutput:
"""Tests for help output."""
def test_main_help(self) -> None:
result = runner.invoke(app, ["--help"])
assert result.exit_code == 0
assert "Service contract coordination" in result.output
assert "team" in result.output
assert "asset" in result.output
assert "contract" in result.output
assert "proposal" in result.output
def test_team_help(self) -> None:
result = runner.invoke(app, ["team", "--help"])
assert result.exit_code == 0
assert "create" in result.output
assert "list" in result.output
assert "get" in result.output
def test_contract_help(self) -> None:
result = runner.invoke(app, ["contract", "--help"])
assert result.exit_code == 0
assert "publish" in result.output
assert "list" in result.output
assert "diff" in result.output
assert "impact" in result.output
class TestConfirmationPrompts:
"""Tests for destructive operation confirmation prompts."""
def test_proposal_withdraw_prompts_and_aborts(self) -> None:
result = runner.invoke(app, ["proposal", "withdraw", "p1", "--team", "t1"], input="n\n")
assert result.exit_code != 0
assert "Are you sure" in result.output
def test_proposal_withdraw_prompts_and_confirms(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {"id": "p1", "status": "withdrawn"}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["proposal", "withdraw", "p1", "--team", "t1"], input="y\n")
assert result.exit_code == 0
assert "Withdrawn:" in result.output
def test_proposal_withdraw_yes_skips_prompt(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {"id": "p1", "status": "withdrawn"}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["proposal", "withdraw", "p1", "--team", "t1", "--yes"])
assert result.exit_code == 0
assert "Are you sure" not in result.output
assert "Withdrawn:" in result.output
def test_proposal_force_prompts_with_warning(self) -> None:
result = runner.invoke(app, ["proposal", "force", "p1", "--team", "t1"], input="n\n")
assert result.exit_code != 0
output = clean_ansi(result.output)
assert "bypasses consumer" in output
def test_proposal_force_prompts_and_confirms(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {"id": "p1", "status": "force_approved"}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["proposal", "force", "p1", "--team", "t1"], input="y\n")
assert result.exit_code == 0
assert "Force approved:" in result.output
def test_proposal_force_yes_skips_prompt(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 200
mock_response.json.return_value = {"id": "p1", "status": "force_approved"}
with patch("tessera.cli.make_request", return_value=mock_response):
result = runner.invoke(app, ["proposal", "force", "p1", "--team", "t1", "--yes"])
assert result.exit_code == 0
assert "bypasses consumer" not in clean_ansi(result.output)
assert "Force approved:" in result.output
class TestDbtSyncConfirmationPrompts:
"""Tests for dbt sync --create-assets confirmation prompt."""
_MODELS = [
{
"fqn": "db.public.orders",
"schema": {"type": "object", "properties": {"id": {"type": "string"}}},
"description": "Orders table",
"tags": [],
"node_id": "model.project.orders",
},
]
def _mock_search_not_found(self) -> MagicMock:
"""Return a mock 200 response with no search results (new model)."""
resp = MagicMock(spec=httpx.Response)
resp.status_code = 200
resp.json.return_value = {"results": []}
return resp
def _mock_asset_created(self) -> MagicMock:
"""Return a mock 201 response for asset creation."""
resp = MagicMock(spec=httpx.Response)
resp.status_code = 201
resp.json.return_value = {"id": "asset-new", "fqn": "db.public.orders"}
return resp
def _mock_publish_ok(self) -> MagicMock:
"""Return a mock 201 response for contract publish."""
resp = MagicMock(spec=httpx.Response)
resp.status_code = 201
resp.json.return_value = {"contract": {"id": "c1", "version": "1.0.0"}}
return resp
def test_dbt_sync_create_assets_prompts_and_aborts(
self, tmp_path: pytest.TempPathFactory
) -> None:
manifest = tmp_path / "manifest.json" # type: ignore[operator]
manifest.write_text("{}")
with (
patch("tessera.cli.dbt.load_manifest", return_value={}),
patch("tessera.cli.dbt.get_models_from_manifest", return_value=self._MODELS),
patch("tessera.cli.dbt.make_request", return_value=self._mock_search_not_found()),
):
result = runner.invoke(
app,
["dbt", "sync", "--manifest", str(manifest), "--team", "t1", "--create-assets"],
input="n\n",
)
assert result.exit_code != 0
output = clean_ansi(result.output)
assert "1 new asset(s) will be created" in output
assert "db.public.orders" in output
def test_dbt_sync_create_assets_prompts_and_confirms(
self, tmp_path: pytest.TempPathFactory
) -> None:
manifest = tmp_path / "manifest.json" # type: ignore[operator]
manifest.write_text("{}")
search_resp = self._mock_search_not_found()
create_resp = self._mock_asset_created()
publish_resp = self._mock_publish_ok()
def route_request(method: str, path: str, **kwargs: Any) -> MagicMock:
if method == "GET" and "/assets/search" in path:
return search_resp
if method == "POST" and path == "/assets":
return create_resp
return publish_resp
with (
patch("tessera.cli.dbt.load_manifest", return_value={}),
patch("tessera.cli.dbt.get_models_from_manifest", return_value=self._MODELS),
patch("tessera.cli.dbt.make_request", side_effect=route_request),
):
result = runner.invoke(
app,
["dbt", "sync", "--manifest", str(manifest), "--team", "t1", "--create-assets"],
input="y\n",
)
assert result.exit_code == 0
output = clean_ansi(result.output)
assert "Created:" in output
def test_dbt_sync_create_assets_yes_skips_prompt(
self, tmp_path: pytest.TempPathFactory
) -> None:
manifest = tmp_path / "manifest.json" # type: ignore[operator]
manifest.write_text("{}")
search_resp = self._mock_search_not_found()
create_resp = self._mock_asset_created()
publish_resp = self._mock_publish_ok()
def route_request(method: str, path: str, **kwargs: Any) -> MagicMock:
if method == "GET" and "/assets/search" in path:
return search_resp
if method == "POST" and path == "/assets":
return create_resp
return publish_resp
with (
patch("tessera.cli.dbt.load_manifest", return_value={}),
patch("tessera.cli.dbt.get_models_from_manifest", return_value=self._MODELS),
patch("tessera.cli.dbt.make_request", side_effect=route_request),
):
result = runner.invoke(
app,
[
"dbt",
"sync",
"--manifest",
str(manifest),
"--team",
"t1",
"--create-assets",
"--yes",
],
)
assert result.exit_code == 0
output = clean_ansi(result.output)
assert "new asset(s) will be created" not in output
assert "Created:" in output
class TestMetadataValidation:
"""Tests for --metadata JSON validation."""
def test_invalid_json_metadata_team_create(self) -> None:
result = runner.invoke(app, ["team", "create", "MyTeam", "-m", "{bad json}"])
assert result.exit_code == 1
output = clean_ansi(result.output)
assert "Invalid JSON in --metadata" in output
def test_invalid_json_metadata_asset_create(self) -> None:
result = runner.invoke(
app, ["asset", "create", "db.schema.t", "--team", "t1", "-m", "not-json"]
)
assert result.exit_code == 1
output = clean_ansi(result.output)
assert "Invalid JSON in --metadata" in output
def test_non_object_json_metadata(self) -> None:
result = runner.invoke(app, ["team", "create", "MyTeam", "-m", "[1,2,3]"])
assert result.exit_code == 1
output = clean_ansi(result.output)
assert "expected a JSON object" in output
def test_valid_json_metadata_passes(self) -> None:
mock_response = MagicMock(spec=httpx.Response)
mock_response.status_code = 201
mock_response.json.return_value = {
"id": "t1",
"name": "MyTeam",
"created_at": "2024-01-01T00:00:00Z",
}
with patch("tessera.cli.make_request", return_value=mock_response) as mock_req:
result = runner.invoke(app, ["team", "create", "MyTeam", "-m", '{"env": "prod"}'])
assert result.exit_code == 0
call_args = mock_req.call_args
assert call_args[1]["json_data"]["metadata"] == {"env": "prod"}

Xet Storage Details

Size:
27 kB
·
Xet hash:
1fce02cb6744940033c9a0cbe88103fd92282d359f46619e9afe64b1db2d0fe1

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.