Complete test suite

Not the greatest of tests, but having 49 tests with a total
test coverage of 91% is a good starting point.

Author: dannyadair

tests/examples.yaml

@@ -1,36 +1,101 @@
 """Tests for the PDFBaker class and related functionality."""
 
+import logging
 import shutil
 from pathlib import Path
 
+import pytest
+
 from pdfbaker.baker import PDFBaker, PDFBakerOptions
+from pdfbaker.errors import ConfigurationError
+from pdfbaker.logging import TRACE
+
+
+# PDFBakerOptions tests
+def test_baker_options_defaults() -> None:
+    """Test PDFBakerOptions default values."""
+    options = PDFBakerOptions()
+    assert not options.quiet
+    assert not options.verbose
+    assert not options.trace
+    assert not options.keep_build
+    assert options.default_config_overrides is None
+
+
+def test_baker_options_logging_levels() -> None:
+    """Test different logging level configurations."""
+    test_cases = [
+        (PDFBakerOptions(quiet=True), logging.ERROR),
+        (PDFBakerOptions(verbose=True), logging.DEBUG),
+        (PDFBakerOptions(trace=True), TRACE),
+        (PDFBakerOptions(), logging.INFO),  # default
+    ]
+
+    examples_config = Path(__file__).parent.parent / "examples" / "examples.yaml"
+    for options, expected_level in test_cases:
+        PDFBaker(examples_config, options=options)
+        assert logging.getLogger().level == expected_level
+
 
+def test_baker_options_default_config_overrides(tmp_path: Path) -> None:
+    """Test PDFBakerOptions with default_config_overrides."""
+    # Create a minimal valid config
+    config_file = tmp_path / "test.yaml"
+    config_file.write_text("documents: [test]")
 
-def test_examples() -> None:
-    """Test all examples."""
-    examples_dir = Path(__file__).parent.parent / "examples"
+    custom_dir = tmp_path / "custom"
+    options = PDFBakerOptions(
+        default_config_overrides={
+            "directories": {
+                "documents": str(custom_dir),
+            }
+        }
+    )
+
+    baker = PDFBaker(config_file, options=options)
+    assert str(baker.config["directories"]["documents"]) == str(custom_dir)
+
+
+# PDFBaker initialization tests
+def test_baker_init_invalid_config(tmp_path: Path) -> None:
+    """Test PDFBaker initialization with invalid configuration."""
+    # Create an invalid config file (missing 'documents' key)
+    config_file = tmp_path / "invalid.yaml"
+    config_file.write_text("title: test")
+
+    with pytest.raises(ConfigurationError, match=".*documents.*missing.*"):
+        PDFBaker(config_file)
+
+
+# PDFBaker functionality tests
+def test_baker_examples() -> None:
+    """Test baking all examples."""
     test_dir = Path(__file__).parent
+    examples_config = test_dir.parent / "examples" / "examples.yaml"
 
-    # Create build and dist directories
+    # Create test output directories
     build_dir = test_dir / "build"
     dist_dir = test_dir / "dist"
     build_dir.mkdir(exist_ok=True)
     dist_dir.mkdir(exist_ok=True)
 
-    # Copy and modify examples config
-    config = examples_dir / "examples.yaml"
-    test_config = test_dir / "examples.yaml"
-    shutil.copy(config, test_config)
-
-    # Modify paths in config
-    with open(test_config, encoding="utf-8") as f:
-        content = f.read()
-    content = content.replace("build_dir: build", f"build_dir: {build_dir}")
-    content = content.replace("dist_dir: dist", f"dist_dir: {dist_dir}")
-    with open(test_config, "w", encoding="utf-8") as f:
-        f.write(content)
-
-    # Run baker
-    options = PDFBakerOptions(quiet=True, keep_build=True)
-    baker = PDFBaker(test_config, options=options)
-    baker.bake()
+    options = PDFBakerOptions(
+        quiet=True,
+        keep_build=True,
+        default_config_overrides={
+            "directories": {
+                "build": str(build_dir),
+                "dist": str(dist_dir),
+            }
+        },
+    )
+
+    try:
+        baker = PDFBaker(examples_config, options=options)
+        baker.bake()
+    finally:
+        # Clean up test directories
+        if build_dir.exists():
+            shutil.rmtree(build_dir)
+        if dist_dir.exists():
+            shutil.rmtree(dist_dir)

tests/test_baker.py

@@ -0,0 +1,77 @@
+"""Tests for CLI functionality."""
+
+from pathlib import Path
+
+from click.testing import CliRunner
+
+from pdfbaker.__main__ import cli
+
+
+def test_cli_version() -> None:
+    """Test CLI version command."""
+    runner = CliRunner()
+    result = runner.invoke(cli, ["--version"])
+    assert result.exit_code == 0
+    assert "version" in result.output.lower()
+
+
+def test_cli_help() -> None:
+    """Test CLI help command."""
+    runner = CliRunner()
+    result = runner.invoke(cli, ["--help"])
+    assert result.exit_code == 0
+    assert "Usage:" in result.output
+
+
+def test_cli_bake_help() -> None:
+    """Test CLI bake help command."""
+    runner = CliRunner()
+    result = runner.invoke(cli, ["bake", "--help"])
+    assert result.exit_code == 0
+    assert "Usage:" in result.output
+
+
+def test_cli_bake_missing_config(tmp_path: Path) -> None:
+    """Test CLI bake command with missing config file."""
+    runner = CliRunner()
+    result = runner.invoke(cli, ["bake", str(tmp_path / "missing.yaml")])
+    assert result.exit_code == 2
+    assert "does not exist" in result.output
+
+
+def test_cli_bake_invalid_config(tmp_path: Path) -> None:
+    """Test CLI bake command with invalid config file."""
+    config_file = tmp_path / "invalid.yaml"
+    config_file.write_text("invalid: yaml: content")
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["bake", str(config_file)])
+    assert result.exit_code == 1
+    assert "Invalid YAML" in result.output
+
+
+def test_cli_bake_quiet_mode(tmp_path: Path) -> None:
+    """Test CLI bake command in quiet mode."""
+    # Test case 1: Failure - should show errors
+    failing_config = tmp_path / "failing.yaml"
+    failing_config.write_text("""
+pages: [page1.yaml]
+directories:
+  build: build
+""")
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["bake", "--quiet", str(failing_config)])
+    assert result.exit_code == 1  # Will fail because page1.yaml doesn't exist
+    assert "error" in result.output.lower()  # Should show error message
+    assert "info" not in result.output.lower()  # Should not show info messages
+
+    # Test case 2: Success - should be completely quiet
+    success_config = tmp_path / "success.yaml"
+    success_config.write_text("""
+documents: []  # Empty list of documents is valid
+""")
+
+    result = runner.invoke(cli, ["bake", "--quiet", str(success_config)])
+    assert result.exit_code == 0
+    assert not result.output  # Should be completely quiet on success

tests/test_cli.py

@@ -1,13 +1,16 @@
-"""Tests for common functionality."""
+"""Tests for configuration functionality."""
 
 from pathlib import Path
 
 import pytest
+import yaml
 
-from pdfbaker.config import PDFBakerConfiguration, deep_merge
+from pdfbaker.config import PDFBakerConfiguration, deep_merge, render_config
+from pdfbaker.errors import ConfigurationError
 
 
-def test_deep_merge_basic():
+# Dictionary merging tests
+def test_deep_merge_basic() -> None:
     """Test basic dictionary merging."""
     base = {
         "title": "Document",
@@ -34,8 +37,8 @@ def test_deep_merge_basic():
     assert deep_merge(base, update) == expected
 
 
-def test_deep_merge_nested():
-    """Test merging of nested dictionaries."""
+def test_deep_merge_nested() -> None:
+    """Test nested dictionary merging."""
     base = {
         "document": {
             "title": "Main Document",
@@ -85,7 +88,7 @@ def test_deep_merge_nested():
     assert deep_merge(base, update) == expected
 
 
-def test_deep_merge_empty():
+def test_deep_merge_empty() -> None:
     """Test merging with empty dictionaries."""
     base = {
         "title": "Document",
@@ -101,44 +104,116 @@ def test_deep_merge_empty():
     assert deep_merge(update, base) == base
 
 
-def test_configuration_init_with_dict():
+# Configuration initialization tests
+def test_configuration_init_with_dict(tmp_path: Path) -> None:
     """Test initializing Configuration with a dictionary."""
-    config = PDFBakerConfiguration({}, {"title": "Document"})
+    config_file = tmp_path / "test.yaml"
+    config_file.write_text(yaml.dump({"title": "Document"}))
+
+    config = PDFBakerConfiguration({}, config_file)
     assert config["title"] == "Document"
 
 
-def test_configuration_init_with_path(tmp_path):
+def test_configuration_init_with_path(tmp_path: Path) -> None:
     """Test initializing Configuration with a file path."""
     config_file = tmp_path / "test.yaml"
-    config_file.write_text("title: Document")
+    config_file.write_text(yaml.dump({"title": "Document"}))
 
     config = PDFBakerConfiguration({}, config_file)
     assert config["title"] == "Document"
-    assert config.directory == tmp_path
+    assert config["directories"]["config"] == tmp_path
 
 
-def test_configuration_init_with_directory(tmp_path):
+def test_configuration_init_with_directory(tmp_path: Path) -> None:
     """Test initializing Configuration with custom directory."""
     config_file = tmp_path / "test.yaml"
-    config_file.write_text('{"title": "Document"}')
+    config_file.write_text(yaml.dump({"title": "Document"}))
+
     config = PDFBakerConfiguration({}, config_file)
     assert config["title"] == "Document"
-    assert config.directory == tmp_path
+    assert config["directories"]["config"] == tmp_path
 
 
-def test_configuration_resolve_path():
+def test_configuration_init_invalid_yaml(tmp_path: Path) -> None:
+    """Test configuration with invalid YAML."""
+    config_file = tmp_path / "invalid.yaml"
+    config_file.write_text("invalid: [yaml: content")
+
+    with pytest.raises(ConfigurationError, match="Failed to load config file"):
+        PDFBakerConfiguration({}, config_file)
+
+
+# Path resolution tests
+def test_configuration_resolve_path(tmp_path: Path) -> None:
     """Test path resolution."""
-    config = PDFBakerConfiguration({}, {"template": "test.yaml"})
-    config.directory = Path("/base")  # Set directory explicitly for testing
-    assert config.resolve_path("test.yaml") == Path("/base/test.yaml")
+    config_file = tmp_path / "test.yaml"
+    config_file.write_text(yaml.dump({"template": "test.yaml"}))
+
+    config = PDFBakerConfiguration({}, config_file)
+
+    # Test relative path
+    assert config.resolve_path("test.yaml") == tmp_path / "test.yaml"
+
+    # Test absolute path
     assert config.resolve_path({"path": "/absolute/path.yaml"}) == Path(
         "/absolute/path.yaml"
     )
-    assert config.resolve_path({"name": "test.yaml"}) == Path("/base/test.yaml")
 
+    # Test named path
+    assert config.resolve_path({"name": "test.yaml"}) == tmp_path / "test.yaml"
 
-def test_configuration_resolve_path_invalid():
+
+def test_configuration_resolve_path_invalid(tmp_path: Path) -> None:
     """Test invalid path specification."""
-    config = PDFBakerConfiguration({}, {})
-    with pytest.raises(ValueError, match="Invalid path specification"):
+    config_file = tmp_path / "test.yaml"
+    config_file.write_text(yaml.dump({}))
+
+    config = PDFBakerConfiguration({}, config_file)
+    with pytest.raises(ConfigurationError, match="Invalid path specification"):
         config.resolve_path({})
+
+
+# Configuration rendering tests
+def test_render_config_basic() -> None:
+    """Test basic template rendering in configuration."""
+    config = {
+        "name": "test",
+        "title": "{{ name }} document",
+        "nested": {
+            "value": "{{ title }}",
+        },
+    }
+
+    rendered = render_config(config)
+    assert rendered["title"] == "test document"
+    assert rendered["nested"]["value"] == "test document"
+
+
+def test_render_config_circular() -> None:
+    """Test detection of circular references in config rendering."""
+    config = {
+        "a": "{{ b }}",
+        "b": "{{ a }}",
+    }
+
+    with pytest.raises(ConfigurationError, match="(?i).*circular.*"):
+        render_config(config)
+
+
+# Utility method tests
+def test_configuration_pretty(tmp_path: Path) -> None:
+    """Test configuration pretty printing."""
+    config_file = tmp_path / "test.yaml"
+    config_file.write_text(
+        yaml.dump(
+            {
+                "title": "Test",
+                "content": "A" * 100,  # Long string that should be truncated
+            }
+        )
+    )
+
+    config = PDFBakerConfiguration({}, config_file)
+    pretty = config.pretty(max_chars=20)
+    assert "…" in pretty  # Should show truncation
+    assert "Test" in pretty