aws-bootstrap-g4dn 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

aws_bootstrap/tests/test_cli.py

@@ -1,11 +1,13 @@
 """Tests for CLI entry point and help output."""
 
 from __future__ import annotations
+import json
 from datetime import UTC, datetime
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
 import botocore.exceptions
+import yaml
 from click.testing import CliRunner
 
 from aws_bootstrap.cli import main
@@ -1254,3 +1256,378 @@ def test_cleanup_with_yes(mock_find, mock_session, mock_stale, mock_cleanup):
     assert "Removed aws-gpu1" in result.output
     assert "Cleaned up 1" in result.output
     mock_cleanup.assert_called_once()
+
+
+# ---------------------------------------------------------------------------
+# cleanup --include-ebs
+# ---------------------------------------------------------------------------
+
+
+@patch("aws_bootstrap.cli.find_orphan_ebs_volumes", return_value=[])
+@patch("aws_bootstrap.cli.find_stale_ssh_hosts", return_value=[])
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances", return_value=[])
+def test_cleanup_include_ebs_no_orphans(mock_find, mock_session, mock_stale, mock_orphan):
+    runner = CliRunner()
+    result = runner.invoke(main, ["cleanup", "--include-ebs"])
+    assert result.exit_code == 0
+    assert "No stale SSH config entries or orphan EBS volumes found." in result.output
+    mock_orphan.assert_called_once()
+
+
+@patch("aws_bootstrap.cli.find_orphan_ebs_volumes")
+@patch("aws_bootstrap.cli.find_stale_ssh_hosts", return_value=[])
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances", return_value=[])
+def test_cleanup_include_ebs_dry_run(mock_find, mock_session, mock_stale, mock_orphan):
+    mock_orphan.return_value = [
+        {"VolumeId": "vol-orphan1", "Size": 50, "State": "available", "InstanceId": "i-dead1234"},
+    ]
+    runner = CliRunner()
+    result = runner.invoke(main, ["cleanup", "--include-ebs", "--dry-run"])
+    assert result.exit_code == 0
+    assert "Would delete vol-orphan1" in result.output
+    assert "50 GB" in result.output
+
+
+@patch("aws_bootstrap.cli.delete_ebs_volume")
+@patch("aws_bootstrap.cli.find_orphan_ebs_volumes")
+@patch("aws_bootstrap.cli.find_stale_ssh_hosts", return_value=[])
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances", return_value=[])
+def test_cleanup_include_ebs_delete_with_yes(mock_find, mock_session, mock_stale, mock_orphan, mock_delete):
+    mock_orphan.return_value = [
+        {"VolumeId": "vol-orphan1", "Size": 50, "State": "available", "InstanceId": "i-dead1234"},
+    ]
+    runner = CliRunner()
+    result = runner.invoke(main, ["cleanup", "--include-ebs", "--yes"])
+    assert result.exit_code == 0
+    assert "Deleted vol-orphan1" in result.output
+    mock_delete.assert_called_once_with(mock_session.return_value.client.return_value, "vol-orphan1")
+
+
+@patch("aws_bootstrap.cli.delete_ebs_volume")
+@patch("aws_bootstrap.cli.find_orphan_ebs_volumes")
+@patch("aws_bootstrap.cli.find_stale_ssh_hosts", return_value=[])
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances", return_value=[])
+def test_cleanup_include_ebs_json(mock_find, mock_session, mock_stale, mock_orphan, mock_delete):
+    mock_orphan.return_value = [
+        {"VolumeId": "vol-orphan1", "Size": 50, "State": "available", "InstanceId": "i-dead1234"},
+    ]
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "cleanup", "--include-ebs", "--yes"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "deleted_volumes" in data
+    assert len(data["deleted_volumes"]) == 1
+    assert data["deleted_volumes"][0]["volume_id"] == "vol-orphan1"
+    assert data["deleted_volumes"][0]["deleted"] is True
+
+
+@patch("aws_bootstrap.cli.find_orphan_ebs_volumes")
+@patch("aws_bootstrap.cli.find_stale_ssh_hosts", return_value=[])
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances", return_value=[])
+def test_cleanup_include_ebs_dry_run_json(mock_find, mock_session, mock_stale, mock_orphan):
+    mock_orphan.return_value = [
+        {"VolumeId": "vol-orphan1", "Size": 50, "State": "available", "InstanceId": "i-dead1234"},
+    ]
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "cleanup", "--include-ebs", "--dry-run"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["dry_run"] is True
+    assert "orphan_volumes" in data
+    assert data["orphan_volumes"][0]["volume_id"] == "vol-orphan1"
+    assert data["orphan_volumes"][0]["size_gb"] == 50
+
+
+@patch("aws_bootstrap.cli.find_orphan_ebs_volumes", return_value=[])
+@patch("aws_bootstrap.cli.find_stale_ssh_hosts", return_value=[])
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances", return_value=[])
+def test_cleanup_without_include_ebs_skips_volume_check(mock_find, mock_session, mock_stale, mock_orphan):
+    """Without --include-ebs, orphan volume discovery should not be called."""
+    runner = CliRunner()
+    result = runner.invoke(main, ["cleanup"])
+    assert result.exit_code == 0
+    mock_orphan.assert_not_called()
+
+
+# ---------------------------------------------------------------------------
+# --output structured format tests
+# ---------------------------------------------------------------------------
+
+
+def test_help_shows_output_option():
+    runner = CliRunner()
+    result = runner.invoke(main, ["--help"])
+    assert result.exit_code == 0
+    assert "--output" in result.output
+    assert "-o" in result.output
+
+
+@patch("aws_bootstrap.cli.find_ebs_volumes_for_instance", return_value=[])
+@patch("aws_bootstrap.cli.get_ssh_host_details", return_value=None)
+@patch("aws_bootstrap.cli.list_ssh_hosts", return_value={})
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_spot_price")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_status_output_json(mock_find, mock_spot_price, mock_session, mock_ssh_hosts, mock_details, mock_ebs):
+    mock_find.return_value = [
+        {
+            "InstanceId": "i-abc123",
+            "Name": "aws-bootstrap-g4dn.xlarge",
+            "State": "running",
+            "InstanceType": "g4dn.xlarge",
+            "PublicIp": "1.2.3.4",
+            "LaunchTime": datetime(2025, 1, 1, tzinfo=UTC),
+            "Lifecycle": "spot",
+            "AvailabilityZone": "us-west-2a",
+        }
+    ]
+    mock_spot_price.return_value = 0.1578
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "status"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "instances" in data
+    assert len(data["instances"]) == 1
+    inst = data["instances"][0]
+    assert inst["instance_id"] == "i-abc123"
+    assert inst["state"] == "running"
+    assert inst["instance_type"] == "g4dn.xlarge"
+    assert inst["public_ip"] == "1.2.3.4"
+    assert inst["lifecycle"] == "spot"
+    assert inst["spot_price_per_hour"] == 0.1578
+    assert "uptime_seconds" in inst
+    assert "estimated_cost" in inst
+    # No ANSI or progress text in structured output
+    assert "\x1b[" not in result.output
+    assert "Found" not in result.output
+
+
+@patch("aws_bootstrap.cli.find_ebs_volumes_for_instance", return_value=[])
+@patch("aws_bootstrap.cli.get_ssh_host_details", return_value=None)
+@patch("aws_bootstrap.cli.list_ssh_hosts", return_value={})
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_spot_price")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_status_output_yaml(mock_find, mock_spot_price, mock_session, mock_ssh_hosts, mock_details, mock_ebs):
+    mock_find.return_value = [
+        {
+            "InstanceId": "i-abc123",
+            "Name": "aws-bootstrap-g4dn.xlarge",
+            "State": "running",
+            "InstanceType": "g4dn.xlarge",
+            "PublicIp": "1.2.3.4",
+            "LaunchTime": datetime(2025, 1, 1, tzinfo=UTC),
+            "Lifecycle": "spot",
+            "AvailabilityZone": "us-west-2a",
+        }
+    ]
+    mock_spot_price.return_value = 0.15
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "yaml", "status"])
+    assert result.exit_code == 0
+    data = yaml.safe_load(result.output)
+    assert "instances" in data
+    assert data["instances"][0]["instance_id"] == "i-abc123"
+
+
+@patch("aws_bootstrap.cli.find_ebs_volumes_for_instance", return_value=[])
+@patch("aws_bootstrap.cli.get_ssh_host_details", return_value=None)
+@patch("aws_bootstrap.cli.list_ssh_hosts", return_value={})
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_spot_price")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_status_output_table(mock_find, mock_spot_price, mock_session, mock_ssh_hosts, mock_details, mock_ebs):
+    mock_find.return_value = [
+        {
+            "InstanceId": "i-abc123",
+            "Name": "aws-bootstrap-g4dn.xlarge",
+            "State": "running",
+            "InstanceType": "g4dn.xlarge",
+            "PublicIp": "1.2.3.4",
+            "LaunchTime": datetime(2025, 1, 1, tzinfo=UTC),
+            "Lifecycle": "spot",
+            "AvailabilityZone": "us-west-2a",
+        }
+    ]
+    mock_spot_price.return_value = 0.15
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "table", "status"])
+    assert result.exit_code == 0
+    assert "Instance ID" in result.output
+    assert "i-abc123" in result.output
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_status_no_instances_json(mock_find, mock_session):
+    mock_find.return_value = []
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "status"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data == {"instances": []}
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_latest_ami")
+@patch("aws_bootstrap.cli.import_key_pair", return_value="aws-bootstrap-key")
+@patch("aws_bootstrap.cli.ensure_security_group", return_value="sg-123")
+def test_launch_output_json_dry_run(mock_sg, mock_import, mock_ami, mock_session, tmp_path):
+    mock_ami.return_value = {"ImageId": "ami-123", "Name": "TestAMI"}
+
+    key_path = tmp_path / "id_ed25519.pub"
+    key_path.write_text("ssh-ed25519 AAAA test@host")
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "launch", "--key-path", str(key_path), "--dry-run"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["dry_run"] is True
+    assert data["instance_type"] == "g4dn.xlarge"
+    assert data["ami_id"] == "ami-123"
+    assert data["pricing"] == "spot"
+    assert data["region"] == "us-west-2"
+
+
+@patch("aws_bootstrap.cli.remove_ssh_host", return_value="aws-gpu1")
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+@patch("aws_bootstrap.cli.terminate_tagged_instances")
+def test_terminate_output_json(mock_terminate, mock_find, mock_session, mock_remove_ssh):
+    mock_find.return_value = [
+        {
+            "InstanceId": "i-abc123",
+            "Name": "test",
+            "State": "running",
+            "InstanceType": "g4dn.xlarge",
+            "PublicIp": "1.2.3.4",
+            "LaunchTime": datetime(2025, 1, 1, tzinfo=UTC),
+        }
+    ]
+    mock_terminate.return_value = [
+        {
+            "InstanceId": "i-abc123",
+            "PreviousState": {"Name": "running"},
+            "CurrentState": {"Name": "shutting-down"},
+        }
+    ]
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "terminate", "--yes"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "terminated" in data
+    assert len(data["terminated"]) == 1
+    assert data["terminated"][0]["instance_id"] == "i-abc123"
+    assert data["terminated"][0]["previous_state"] == "running"
+    assert data["terminated"][0]["current_state"] == "shutting-down"
+    assert data["terminated"][0]["ssh_alias_removed"] == "aws-gpu1"
+
+
+@patch("aws_bootstrap.cli.cleanup_stale_ssh_hosts")
+@patch("aws_bootstrap.cli.find_stale_ssh_hosts", return_value=[("i-dead1234", "aws-gpu1")])
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances", return_value=[])
+def test_cleanup_output_json(mock_find, mock_session, mock_stale, mock_cleanup):
+    mock_cleanup.return_value = [CleanupResult(instance_id="i-dead1234", alias="aws-gpu1", removed=True)]
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "cleanup", "--yes"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "cleaned" in data
+    assert len(data["cleaned"]) == 1
+    assert data["cleaned"][0]["instance_id"] == "i-dead1234"
+    assert data["cleaned"][0]["alias"] == "aws-gpu1"
+    assert data["cleaned"][0]["removed"] is True
+
+
+@patch("aws_bootstrap.cli.find_stale_ssh_hosts", return_value=[("i-dead1234", "aws-gpu1")])
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances", return_value=[])
+def test_cleanup_dry_run_json(mock_find, mock_session, mock_stale):
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "cleanup", "--dry-run"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["dry_run"] is True
+    assert "stale" in data
+    assert data["stale"][0]["alias"] == "aws-gpu1"
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.list_instance_types")
+def test_list_instance_types_json(mock_list, mock_session):
+    mock_list.return_value = [
+        {
+            "InstanceType": "g4dn.xlarge",
+            "VCpuCount": 4,
+            "MemoryMiB": 16384,
+            "GpuSummary": "1x T4 (16384 MiB)",
+        },
+    ]
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "list", "instance-types"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert isinstance(data, list)
+    assert data[0]["instance_type"] == "g4dn.xlarge"
+    assert data[0]["vcpus"] == 4
+    assert data[0]["memory_mib"] == 16384
+    assert data[0]["gpu"] == "1x T4 (16384 MiB)"
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.list_amis")
+def test_list_amis_json(mock_list, mock_session):
+    mock_list.return_value = [
+        {
+            "ImageId": "ami-abc123",
+            "Name": "Deep Learning AMI v42",
+            "CreationDate": "2025-06-01T00:00:00Z",
+            "Architecture": "x86_64",
+        },
+    ]
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "list", "amis"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert isinstance(data, list)
+    assert data[0]["image_id"] == "ami-abc123"
+    assert data[0]["name"] == "Deep Learning AMI v42"
+    assert data[0]["creation_date"] == "2025-06-01"
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_terminate_json_requires_yes(mock_find, mock_session):
+    """Structured output without --yes should error."""
+    mock_find.return_value = [
+        {
+            "InstanceId": "i-abc123",
+            "Name": "test",
+            "State": "running",
+            "InstanceType": "g4dn.xlarge",
+            "PublicIp": "1.2.3.4",
+            "LaunchTime": datetime(2025, 1, 1, tzinfo=UTC),
+        }
+    ]
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "terminate"])
+    assert result.exit_code != 0
+    assert "--yes is required" in result.output
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_terminate_no_instances_json(mock_find, mock_session):
+    mock_find.return_value = []
+    runner = CliRunner()
+    result = runner.invoke(main, ["-o", "json", "terminate", "--yes"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data == {"terminated": []}

aws_bootstrap/tests/test_ebs.py

@@ -14,6 +14,7 @@ from aws_bootstrap.ec2 import (
     delete_ebs_volume,
     detach_ebs_volume,
     find_ebs_volumes_for_instance,
+    find_orphan_ebs_volumes,
     validate_ebs_volume,
 )
 
@@ -243,3 +244,92 @@ def test_find_ebs_volumes_client_error_returns_empty():
     )
     volumes = find_ebs_volumes_for_instance(ec2, "i-test", "aws-bootstrap-g4dn")
     assert volumes == []
+
+
+# ---------------------------------------------------------------------------
+# find_orphan_ebs_volumes
+# ---------------------------------------------------------------------------
+
+
+def test_find_orphan_ebs_volumes_returns_orphans():
+    """Volumes whose linked instance is not live should be returned."""
+    ec2 = MagicMock()
+    ec2.describe_volumes.return_value = {
+        "Volumes": [
+            {
+                "VolumeId": "vol-orphan1",
+                "Size": 50,
+                "State": "available",
+                "Tags": [
+                    {"Key": "created-by", "Value": "aws-bootstrap-g4dn"},
+                    {"Key": "aws-bootstrap-instance", "Value": "i-dead1234"},
+                ],
+            }
+        ]
+    }
+    orphans = find_orphan_ebs_volumes(ec2, "aws-bootstrap-g4dn", live_instance_ids=set())
+    assert len(orphans) == 1
+    assert orphans[0]["VolumeId"] == "vol-orphan1"
+    assert orphans[0]["InstanceId"] == "i-dead1234"
+    assert orphans[0]["Size"] == 50
+
+    # Verify the API was called with status=available filter
+    filters = ec2.describe_volumes.call_args[1]["Filters"]
+    filter_names = {f["Name"] for f in filters}
+    assert "status" in filter_names
+
+
+def test_find_orphan_ebs_volumes_excludes_live_instances():
+    """Volumes linked to a live instance should NOT be returned."""
+    ec2 = MagicMock()
+    ec2.describe_volumes.return_value = {
+        "Volumes": [
+            {
+                "VolumeId": "vol-attached",
+                "Size": 96,
+                "State": "available",
+                "Tags": [
+                    {"Key": "created-by", "Value": "aws-bootstrap-g4dn"},
+                    {"Key": "aws-bootstrap-instance", "Value": "i-live123"},
+                ],
+            }
+        ]
+    }
+    orphans = find_orphan_ebs_volumes(ec2, "aws-bootstrap-g4dn", live_instance_ids={"i-live123"})
+    assert orphans == []
+
+
+def test_find_orphan_ebs_volumes_empty():
+    """No volumes at all should return empty list."""
+    ec2 = MagicMock()
+    ec2.describe_volumes.return_value = {"Volumes": []}
+    orphans = find_orphan_ebs_volumes(ec2, "aws-bootstrap-g4dn", live_instance_ids=set())
+    assert orphans == []
+
+
+def test_find_orphan_ebs_volumes_skips_no_instance_tag():
+    """Volumes without aws-bootstrap-instance tag should be skipped."""
+    ec2 = MagicMock()
+    ec2.describe_volumes.return_value = {
+        "Volumes": [
+            {
+                "VolumeId": "vol-notag",
+                "Size": 10,
+                "State": "available",
+                "Tags": [{"Key": "created-by", "Value": "aws-bootstrap-g4dn"}],
+            }
+        ]
+    }
+    orphans = find_orphan_ebs_volumes(ec2, "aws-bootstrap-g4dn", live_instance_ids=set())
+    assert orphans == []
+
+
+def test_find_orphan_ebs_volumes_client_error():
+    """ClientError should return empty list."""
+    ec2 = MagicMock()
+    ec2.describe_volumes.side_effect = botocore.exceptions.ClientError(
+        {"Error": {"Code": "UnauthorizedOperation", "Message": "no access"}},
+        "DescribeVolumes",
+    )
+    orphans = find_orphan_ebs_volumes(ec2, "aws-bootstrap-g4dn", live_instance_ids=set())
+    assert orphans == []

aws_bootstrap/tests/test_output.py

@@ -0,0 +1,192 @@
+"""Tests for the output formatting module."""
+
+from __future__ import annotations
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+
+import click
+import yaml
+from click.testing import CliRunner
+
+from aws_bootstrap.output import OutputFormat, echo, emit, is_text
+
+
+def test_output_format_enum_values():
+    assert OutputFormat.TEXT.value == "text"
+    assert OutputFormat.JSON.value == "json"
+    assert OutputFormat.YAML.value == "yaml"
+    assert OutputFormat.TABLE.value == "table"
+
+
+def test_serialize_datetime():
+    """datetime objects should serialize to ISO format strings."""
+    dt = datetime(2025, 6, 15, 12, 30, 0, tzinfo=UTC)
+
+    @click.command()
+    @click.pass_context
+    def cli(ctx):
+        ctx.ensure_object(dict)
+        ctx.obj["output_format"] = OutputFormat.JSON
+        emit({"timestamp": dt}, ctx=ctx)
+
+    runner = CliRunner()
+    result = runner.invoke(cli, [])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["timestamp"] == "2025-06-15T12:30:00+00:00"
+
+
+def test_serialize_path():
+    """Path objects should serialize to strings."""
+    p = Path("/home/user/.ssh/id_ed25519")
+
+    @click.command()
+    @click.pass_context
+    def cli(ctx):
+        ctx.ensure_object(dict)
+        ctx.obj["output_format"] = OutputFormat.JSON
+        emit({"path": p}, ctx=ctx)
+
+    runner = CliRunner()
+    result = runner.invoke(cli, [])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["path"] == "/home/user/.ssh/id_ed25519"
+
+
+def test_emit_json():
+    """emit() should produce valid JSON in JSON mode."""
+
+    @click.command()
+    @click.pass_context
+    def cli(ctx):
+        ctx.ensure_object(dict)
+        ctx.obj["output_format"] = OutputFormat.JSON
+        emit({"key": "value", "count": 42}, ctx=ctx)
+
+    runner = CliRunner()
+    result = runner.invoke(cli, [])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data == {"key": "value", "count": 42}
+
+
+def test_emit_yaml():
+    """emit() should produce valid YAML in YAML mode."""
+
+    @click.command()
+    @click.pass_context
+    def cli(ctx):
+        ctx.ensure_object(dict)
+        ctx.obj["output_format"] = OutputFormat.YAML
+        emit({"key": "value", "count": 42}, ctx=ctx)
+
+    runner = CliRunner()
+    result = runner.invoke(cli, [])
+    assert result.exit_code == 0
+    data = yaml.safe_load(result.output)
+    assert data == {"key": "value", "count": 42}
+
+
+def test_emit_table_list():
+    """emit() should render a list of dicts as a table with headers."""
+
+    @click.command()
+    @click.pass_context
+    def cli(ctx):
+        ctx.ensure_object(dict)
+        ctx.obj["output_format"] = OutputFormat.TABLE
+        emit(
+            [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}],
+            headers={"name": "Name", "age": "Age"},
+            ctx=ctx,
+        )
+
+    runner = CliRunner()
+    result = runner.invoke(cli, [])
+    assert result.exit_code == 0
+    assert "Name" in result.output
+    assert "Age" in result.output
+    assert "Alice" in result.output
+    assert "Bob" in result.output
+
+
+def test_emit_table_dict():
+    """emit() should render a single dict as key-value pairs."""
+
+    @click.command()
+    @click.pass_context
+    def cli(ctx):
+        ctx.ensure_object(dict)
+        ctx.obj["output_format"] = OutputFormat.TABLE
+        emit({"instance_id": "i-abc123", "state": "running"}, ctx=ctx)
+
+    runner = CliRunner()
+    result = runner.invoke(cli, [])
+    assert result.exit_code == 0
+    assert "instance_id" in result.output
+    assert "i-abc123" in result.output
+    assert "running" in result.output
+
+
+def test_echo_suppressed_in_json_mode():
+    """echo() should produce no output when format is JSON."""
+
+    @click.command()
+    @click.pass_context
+    def cli(ctx):
+        ctx.ensure_object(dict)
+        ctx.obj["output_format"] = OutputFormat.JSON
+        echo("This should not appear")
+
+    runner = CliRunner()
+    result = runner.invoke(cli, [])
+    assert result.exit_code == 0
+    assert result.output == ""
+
+
+def test_echo_emits_in_text_mode():
+    """echo() should work normally in text mode."""
+
+    @click.command()
+    @click.pass_context
+    def cli(ctx):
+        ctx.ensure_object(dict)
+        ctx.obj["output_format"] = OutputFormat.TEXT
+        echo("Hello world")
+
+    runner = CliRunner()
+    result = runner.invoke(cli, [])
+    assert result.exit_code == 0
+    assert "Hello world" in result.output
+
+
+def test_is_text_default():
+    """is_text() should return True when no context is set (default behavior)."""
+
+    @click.command()
+    @click.pass_context
+    def cli(ctx):
+        ctx.ensure_object(dict)
+        ctx.obj["output_format"] = OutputFormat.TEXT
+        assert is_text(ctx) is True
+
+    runner = CliRunner()
+    result = runner.invoke(cli, [])
+    assert result.exit_code == 0
+
+
+def test_is_text_false_for_json():
+    """is_text() should return False when format is JSON."""
+
+    @click.command()
+    @click.pass_context
+    def cli(ctx):
+        ctx.ensure_object(dict)
+        ctx.obj["output_format"] = OutputFormat.JSON
+        assert is_text(ctx) is False
+
+    runner = CliRunner()
+    result = runner.invoke(cli, [])
+    assert result.exit_code == 0