test: add missing coverage for Docker parsing, CLI commands, config integration, severity

Added comprehensive tests closing key coverage gaps:

1. Docker _parse_reclaimed_space: GB/MB/KB/B parsing, empty/no-match cases
2. Docker config flags: stopped containers, all flags disabled
3. CLI report command: dry-run with nonexistent config
4. CLI config command: displays 'not found, using defaults'
5. Config integration: verifies config values reach module constructors
6. Severity enum: from_str for all levels, str conversion
7. worst_severity: empty list, single/mixed findings

Coverage increased from 79% to 81% (187 tests passing).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jgamblin

tests/modules/test_docker.py

@@ -80,3 +80,89 @@ def test_audit_returns_empty(docker_module):
     assert isinstance(result, AuditResult)
     assert result.status == "pass"
     assert result.findings == []
+
+
+def test_parse_reclaimed_space_gb():
+    """Test parsing GB from docker prune output."""
+    output = "Total reclaimed space: 1.5GB"
+    result = DockerModule._parse_reclaimed_space(output)
+    assert result == 1610612736  # 1.5 * 1024^3
+
+
+def test_parse_reclaimed_space_mb():
+    """Test parsing MB from docker prune output."""
+    output = "Total reclaimed space: 500MB"
+    result = DockerModule._parse_reclaimed_space(output)
+    assert result == 524288000  # 500 * 1024^2
+
+
+def test_parse_reclaimed_space_kb():
+    """Test parsing KB from docker prune output."""
+    output = "Total reclaimed space: 1024KB"
+    result = DockerModule._parse_reclaimed_space(output)
+    assert result == 1048576  # 1024 * 1024
+
+
+def test_parse_reclaimed_space_bytes():
+    """Test parsing bytes from docker prune output."""
+    output = "Total reclaimed space: 100B"
+    result = DockerModule._parse_reclaimed_space(output)
+    assert result == 100
+
+
+def test_parse_reclaimed_space_empty():
+    """Test parsing empty string returns 0."""
+    result = DockerModule._parse_reclaimed_space("")
+    assert result == 0
+
+
+def test_parse_reclaimed_space_no_match():
+    """Test parsing random text returns 0."""
+    output = "Some random docker output without space info"
+    result = DockerModule._parse_reclaimed_space(output)
+    assert result == 0
+
+
+def test_parse_reclaimed_space_with_surrounding_text():
+    """Test parsing with other text before/after the reclaimed line."""
+    output = """Deleted Images:
+untagged: sha256:abc123
+untagged: sha256:def456
+
+Total reclaimed space: 2.5GB
+
+Some other output here"""
+    result = DockerModule._parse_reclaimed_space(output)
+    assert result == 2684354560  # 2.5 * 1024^3
+
+
+def test_scan_docker_stopped_containers():
+    """Test scan reports stopped containers when enabled."""
+    docker_module = DockerModule(remove_stopped_containers=True)
+    with (
+        patch.object(docker_module, "_is_docker_running", return_value=True),
+        patch.object(docker_module, "_get_dangling_images", return_value=[]),
+        patch.object(docker_module, "_get_unused_volumes", return_value=[]),
+        patch.object(docker_module, "_get_stopped_containers", return_value=["c1", "c2"]),
+    ):
+        result = docker_module.scan()
+
+        assert isinstance(result, ScanResult)
+        assert len(result.items) == 1
+        assert "2 stopped containers" in result.items[0]
+
+
+def test_clean_all_flags_disabled():
+    """Test clean does nothing when all flags are False."""
+    docker_module = DockerModule(
+        remove_dangling_images=False,
+        remove_unused_volumes=False,
+        remove_stopped_containers=False,
+    )
+    with patch.object(docker_module, "_is_docker_running", return_value=True):
+        result = docker_module.clean()
+
+        assert isinstance(result, CleanResult)
+        assert result.items_cleaned == []
+        assert result.bytes_reclaimed == 0
+        assert result.errors == []

tests/test_base.py

@@ -5,6 +5,8 @@
     Finding,
     Module,
     ScanResult,
+    Severity,
+    worst_severity,
 )
 
 
@@ -85,3 +87,68 @@ def test_module_subclass():
     assert mod.category == "dev"
     scan = mod.scan()
     assert len(scan.items) == 1
+
+
+def test_severity_from_str_pass():
+    """Test Severity.from_str for pass."""
+    assert Severity.from_str("pass") == Severity.PASS
+
+
+def test_severity_from_str_info():
+    """Test Severity.from_str for info."""
+    assert Severity.from_str("info") == Severity.INFO
+
+
+def test_severity_from_str_warn():
+    """Test Severity.from_str for warn."""
+    assert Severity.from_str("warn") == Severity.WARN
+
+
+def test_severity_from_str_fail():
+    """Test Severity.from_str for fail."""
+    assert Severity.from_str("fail") == Severity.FAIL
+
+
+def test_severity_str_conversion():
+    """Test str(Severity) returns lowercase name."""
+    assert str(Severity.PASS) == "pass"
+    assert str(Severity.INFO) == "info"
+    assert str(Severity.WARN) == "warn"
+    assert str(Severity.FAIL) == "fail"
+
+
+def test_worst_severity_empty_list():
+    """Test worst_severity returns 'pass' for empty list."""
+    result = worst_severity([])
+    assert result == "pass"
+
+
+def test_worst_severity_single_finding():
+    """Test worst_severity with a single finding."""
+    findings = [Finding(severity="warn", title="Test", detail="Detail")]
+    result = worst_severity(findings)
+    assert result == "warn"
+
+
+def test_worst_severity_mixed_findings():
+    """Test worst_severity returns the worst severity from mixed findings."""
+    findings = [
+        Finding(severity="pass", title="Good", detail="All good"),
+        Finding(severity="info", title="Info", detail="FYI"),
+        Finding(severity="warn", title="Warning", detail="Be careful"),
+        Finding(severity="info", title="Info2", detail="Another FYI"),
+    ]
+    result = worst_severity(findings)
+    assert result == "warn"
+
+
+def test_worst_severity_with_fail():
+    """Test worst_severity returns 'fail' when any finding is fail."""
+    findings = [
+        Finding(severity="pass", title="Good", detail="All good"),
+        Finding(severity="warn", title="Warning", detail="Be careful"),
+        Finding(severity="fail", title="Critical", detail="Very bad"),
+        Finding(severity="info", title="Info", detail="FYI"),
+    ]
+    result = worst_severity(findings)
+    assert result == "fail"

tests/test_cli.py

@@ -53,3 +53,21 @@ def test_cli_log_no_previous_run():
     result = runner.invoke(main, ["log", "--log-dir", "/nonexistent"])
     assert result.exit_code == 0
     assert "No previous run" in result.output or "not found" in result.output.lower()
+
+
+def test_cli_report_dry_run_nonexistent_config():
+    """Test report command with dry-run and nonexistent config."""
+    runner = CliRunner()
+    result = runner.invoke(main, ["report", "--dry-run", "--config", "/nonexistent/path.yml"])
+    assert result.exit_code == 0
+    # Should show dry-run preview output
+    output_lower = result.output.lower()
+    assert "dry run" in output_lower or "preview" in output_lower or "no config" in output_lower
+
+
+def test_cli_config_command():
+    """Test config command shows not found message for defaults."""
+    runner = CliRunner()
+    result = runner.invoke(main, ["config"])
+    assert result.exit_code == 0
+    assert "not found, using defaults" in result.output

tests/test_config.py

@@ -78,3 +78,30 @@ def test_generate_default_config():
     assert "categories:" in content
     assert "homebrew:" in content
     assert "wifi:" in content
+
+
+def test_config_integration_pipeline():
+    """Test full pipeline: write config, load it, get modules, verify module config.
+
+    This verifies that config values actually reach module constructors.
+    """
+    from macos_maid.modules import get_all_modules
+    from macos_maid.modules.homebrew import HomebrewModule
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".yml", delete=False) as f:
+        yaml.dump({"homebrew": {"update": True}}, f)
+        f.flush()
+        config = load_config(Path(f.name))
+
+    # Get all modules with this config
+    modules = get_all_modules(config)
+
+    # Find the HomebrewModule instance
+    homebrew_module = None
+    for mod in modules:
+        if isinstance(mod, HomebrewModule):
+            homebrew_module = mod
+            break
+
+    assert homebrew_module is not None
+    assert homebrew_module.update is True