sqlspec 0.58.0__tar.gz → 0.58.2__tar.gz

{sqlspec-0.58.0 → sqlspec-0.58.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.58.0
+Version: 0.58.2
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/

{sqlspec-0.58.0 → sqlspec-0.58.2}/pyproject.toml

@@ -24,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.58.0"
+version = "0.58.2"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -331,7 +331,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.58.0"
+current_version = "0.58.2"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.58.0 → sqlspec-0.58.2}/sqlspec/config.py

@@ -48,6 +48,7 @@ if TYPE_CHECKING:
 
 __all__ = (
     "MIGRATION_CONFIG_KEYS",
+    "MIGRATION_TEMPLATES_KEYS",
     "ADKConfig",
     "AsyncConfigT",
     "AsyncDatabaseConfig",
@@ -62,11 +63,14 @@ __all__ = (
     "LifecycleConfig",
     "LitestarConfig",
     "MigrationConfig",
+    "MigrationTemplates",
     "NoPoolAsyncConfig",
     "NoPoolSyncConfig",
     "OpenTelemetryConfig",
     "PoolT",
     "PrometheusConfig",
+    "PythonTemplateOverride",
+    "SQLTemplateOverride",
     "SanicConfig",
     "StarletteConfig",
     "SyncConfigT",
@@ -114,6 +118,55 @@ class LifecycleConfig(TypedDict):
     on_error: NotRequired[list[Callable[[Exception, str, dict[str, Any]], None]]]
 
 
+class SQLTemplateOverride(TypedDict):
+    """Overrides for the SQL migration template."""
+
+    header: NotRequired[str]
+    """First line of the generated file. Supports the migration template placeholders."""
+
+    metadata: NotRequired["list[str]"]
+    """Comment lines rendered beneath the header."""
+
+    body: NotRequired[str]
+    """Migration body containing the up and down named statements."""
+
+    description_key: NotRequired["str | list[str]"]
+    """Metadata label(s) the description is read back from. Defaults to 'Description'."""
+
+
+class PythonTemplateOverride(TypedDict):
+    """Overrides for the Python migration template."""
+
+    docstring: NotRequired[str]
+    """Module docstring contents. Supports the migration template placeholders."""
+
+    body: NotRequired[str]
+    """Module body defining the up and down functions."""
+
+    imports: NotRequired["list[str]"]
+    """Import lines rendered between the docstring and the body."""
+
+    description_key: NotRequired["str | list[str]"]
+    """Docstring label(s) the description is read back from. Defaults to 'Description'."""
+
+
+class MigrationTemplates(TypedDict):
+    """Template overrides applied when generating migration files.
+
+    Placeholders available to every fragment: ``title``, ``version``, ``message``,
+    ``description``, ``created_at``, ``author``, ``adapter``, and ``project_slug``.
+    """
+
+    sql: NotRequired[SQLTemplateOverride]
+    """Overrides for generated ``.sql`` migrations."""
+
+    py: NotRequired[PythonTemplateOverride]
+    """Overrides for generated ``.py`` migrations."""
+
+    title: NotRequired[str]
+    """Title used when ``MigrationConfig.title`` is omitted."""
+
+
 class MigrationConfig(TypedDict):
     """Configuration options for database migrations.
 
@@ -124,7 +177,7 @@ class MigrationConfig(TypedDict):
     """Path to the migrations directory. Accepts string or Path object. Defaults to 'migrations'."""
 
     version_table_name: NotRequired[str]
-    """Name of the table used to track applied migrations. Defaults to 'sqlspec_migrations'."""
+    """Name of the table used to track applied migrations. Defaults to 'ddl_migrations'."""
 
     default_schema: NotRequired[str]
     """Schema applied to migration sessions before user migration SQL runs, when supported by the adapter."""
@@ -198,30 +251,91 @@ class MigrationConfig(TypedDict):
     Defaults to False.
     """
 
+    default_format: NotRequired["Literal['sql', 'py']"]
+    """File format used by ``create-migration`` when none is requested. Defaults to 'sql'."""
+
+    title: NotRequired[str]
+    """Title rendered into generated migration files. Defaults to 'SQLSpec Migration'."""
+
+    templates: NotRequired[MigrationTemplates]
+    """Template fragment overrides applied when generating migration files."""
+
 
 MIGRATION_CONFIG_KEYS: "frozenset[str]" = MigrationConfig.__required_keys__ | MigrationConfig.__optional_keys__
+MIGRATION_TEMPLATES_KEYS: "frozenset[str]" = MigrationTemplates.__required_keys__ | MigrationTemplates.__optional_keys__
+_TEMPLATE_FRAGMENT_KEYS: "dict[str, frozenset[str]]" = {
+    "sql": SQLTemplateOverride.__required_keys__ | SQLTemplateOverride.__optional_keys__,
+    "py": PythonTemplateOverride.__required_keys__ | PythonTemplateOverride.__optional_keys__,
+}
 
 
-def validate_migration_config_keys(migration_config: "Mapping[str, Any]") -> None:
-    """Reject migration configuration keys that SQLSpec does not read.
+def _report_unknown_keys(
+    mapping: "Mapping[str, Any]", valid_keys: "frozenset[str]", prefix: str, scope: str
+) -> "list[str]":
+    """Describe keys a configuration scope does not declare.
 
     Args:
-        migration_config: Migration configuration mapping to check.
+        mapping: Mapping to check.
+        valid_keys: Keys the scope accepts.
+        prefix: Dotted path prepended to each reported key.
+        scope: Scope name used in the valid-key summary, empty for the top level.
 
-    Raises:
-        ImproperConfigurationError: If the mapping contains an unrecognized key.
+    Returns:
+        Report lines, empty when every key is recognized.
     """
-    unknown = sorted(key for key in migration_config if key not in MIGRATION_CONFIG_KEYS)
+    unknown = sorted(key for key in mapping if key not in valid_keys)
     if not unknown:
-        return
+        return []
 
     lines = []
     for key in unknown:
-        suggestions = get_close_matches(key, MIGRATION_CONFIG_KEYS, n=1, cutoff=0.6)
+        suggestions = get_close_matches(key, valid_keys, n=1, cutoff=0.6)
         hint = f" Did you mean {suggestions[0]!r}?" if suggestions else ""
-        lines.append(f"Unknown migration_config key {key!r}.{hint}")
-    lines.append(f"Valid keys: {', '.join(sorted(MIGRATION_CONFIG_KEYS))}.")
-    raise ImproperConfigurationError(" ".join(lines))
+        lines.append(f"Unknown migration_config key {f'{prefix}{key}'!r}.{hint}")
+    lines.append(f"Valid {scope}keys: {', '.join(sorted(valid_keys))}.")
+    return lines
+
+
+def _report_template_keys(templates: Any) -> "list[str]":
+    """Describe unrecognized keys nested under ``templates``.
+
+    Args:
+        templates: Value configured for the ``templates`` key.
+
+    Returns:
+        Report lines, empty when the overrides are recognized.
+    """
+    if not isinstance(templates, Mapping):
+        return [f"migration_config key 'templates' must be a mapping, got {type(templates).__name__}."]
+
+    lines = _report_unknown_keys(templates, MIGRATION_TEMPLATES_KEYS, "templates.", "'templates' ")
+    for section, fragment_keys in _TEMPLATE_FRAGMENT_KEYS.items():
+        overrides = templates.get(section)
+        if overrides is None:
+            continue
+        path = f"templates.{section}"
+        if not isinstance(overrides, Mapping):
+            lines.append(f"migration_config key '{path}' must be a mapping, got {type(overrides).__name__}.")
+            continue
+        lines.extend(_report_unknown_keys(overrides, fragment_keys, f"{path}.", f"'{path}' "))
+    return lines
+
+
+def validate_migration_config_keys(migration_config: "Mapping[str, Any]") -> None:
+    """Reject migration configuration keys that SQLSpec does not read.
+
+    Args:
+        migration_config: Migration configuration mapping to check.
+
+    Raises:
+        ImproperConfigurationError: If the mapping contains an unrecognized key.
+    """
+    lines = _report_unknown_keys(migration_config, MIGRATION_CONFIG_KEYS, "", "")
+    templates = migration_config.get("templates")
+    if templates is not None:
+        lines.extend(_report_template_keys(templates))
+    if lines:
+        raise ImproperConfigurationError(" ".join(lines))
 
 
 class FlaskConfig(TypedDict):

{sqlspec-0.58.0 → sqlspec-0.58.2}/sqlspec/loader.py

@@ -406,15 +406,19 @@ class SQLFileLoader:
                 params.append(_parse_parameter_declaration(param_match))
                 continue
             if PARAM_PREFIX_PATTERN.match(stripped):
+                line_number = base_line + idx + 1
                 if strict:
                     raise SQLFileParseError(
-                        file_path,
-                        file_path,
-                        ValueError(f"Malformed -- param: directive: {stripped}"),
-                        line=base_line + idx + 1,
+                        file_path, file_path, ValueError(f"Malformed -- param: directive: {stripped}"), line=line_number
                     )
                 log_with_context(
-                    logger, logging.WARNING, "sql.parse.param", file_path=file_path, line=stripped, status="malformed"
+                    logger,
+                    logging.WARNING,
+                    f"sql.parse.param: malformed parameter directive in {file_path} at line {line_number}: {stripped}",
+                    file_path=file_path,
+                    line_number=line_number,
+                    directive=stripped,
+                    status="malformed",
                 )
         return dialect, tuple(params), "\n".join(raw_lines[body_start:])
 

sqlspec-0.58.2/tests/unit/config/test_migration_config_key_inventory.py

@@ -0,0 +1,188 @@
+"""Guard test keeping ``MIGRATION_CONFIG_KEYS`` a complete inventory of consumers.
+
+``MIGRATION_CONFIG_KEYS`` is a closed allowlist derived from the ``MigrationConfig``
+``TypedDict``: a key absent from the declaration is rejected at config construction.
+That is only correct while the declaration covers every key SQLSpec reads, and a
+hand-maintained restatement drifts. This module scans the package for reads and
+asserts the allowlist covers them.
+
+The scanner resolves one level of local aliasing because that is what a name-based
+search misses: ``build_template_settings`` rebinds ``config = migration_config or {}``
+before reading, which is how three template keys were consumed without being declared.
+"""
+
+import ast
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import pytest
+
+import sqlspec
+from sqlspec.config import MIGRATION_CONFIG_KEYS
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+CONFIG_NAME = "migration_config"
+PACKAGE_ROOT = Path(sqlspec.__file__).parent
+
+
+def _unwrap(node: ast.expr) -> ast.expr:
+    """Strip ``or`` fallbacks and ``cast()`` wrappers from an expression."""
+    while True:
+        if isinstance(node, ast.BoolOp) and isinstance(node.op, ast.Or) and node.values:
+            node = node.values[0]
+        elif isinstance(node, ast.Call) and _is_cast(node.func) and node.args:
+            node = node.args[-1]
+        else:
+            return node
+
+
+def _is_cast(func: ast.expr) -> bool:
+    """Check whether a call target is ``cast`` or ``typing.cast``."""
+    if isinstance(func, ast.Name):
+        return func.id == "cast"
+    return isinstance(func, ast.Attribute) and func.attr == "cast"
+
+
+def _is_config_expr(node: ast.expr, tracked: "set[str]") -> bool:
+    """Check whether an expression evaluates to a migration configuration mapping."""
+    root = _unwrap(node)
+    if isinstance(root, ast.Name):
+        return root.id in tracked
+    return isinstance(root, ast.Attribute) and root.attr == CONFIG_NAME
+
+
+def _tracked_names(scope: ast.AST) -> "set[str]":
+    """Collect local names bound to a migration configuration within one scope.
+
+    Only direct rebindings are tracked. A name bound to the *result* of a lookup,
+    such as ``templates_config = config.get("templates")``, is deliberately not
+    tracked: its keys belong to a nested scope, not to ``migration_config``.
+    """
+    tracked = {CONFIG_NAME}
+    for _ in range(3):
+        before = len(tracked)
+        for node in ast.walk(scope):
+            targets: list[ast.expr] = []
+            if isinstance(node, ast.Assign):
+                targets = list(node.targets)
+            elif isinstance(node, ast.AnnAssign) and node.value is not None:
+                targets = [node.target]
+            else:
+                continue
+            value = node.value
+            if value is None or not _is_config_expr(value, tracked):
+                continue
+            tracked.update(target.id for target in targets if isinstance(target, ast.Name))
+        if len(tracked) == before:
+            break
+    return tracked
+
+
+def _literal(node: ast.expr) -> "str | None":
+    """Return the value of a string literal node, or None."""
+    return node.value if isinstance(node, ast.Constant) and isinstance(node.value, str) else None
+
+
+def _reads_in_scope(scope: ast.AST, tracked: "set[str]") -> "Iterator[str]":
+    """Yield string-literal keys read from a tracked configuration mapping."""
+    for node in ast.walk(scope):
+        if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and node.args:
+            if node.func.attr in {"get", "pop"} and _is_config_expr(node.func.value, tracked):
+                key = _literal(node.args[0])
+                if key is not None:
+                    yield key
+        elif isinstance(node, ast.Subscript) and _is_config_expr(node.value, tracked):
+            key = _literal(node.slice)
+            if key is not None:
+                yield key
+        elif isinstance(node, ast.Compare) and len(node.ops) == 1 and isinstance(node.ops[0], ast.In):
+            if _is_config_expr(node.comparators[0], tracked):
+                key = _literal(node.left)
+                if key is not None:
+                    yield key
+
+
+def collect_consumed_keys(source: str) -> "set[str]":
+    """Collect every migration_config key a module reads by string literal."""
+    tree = ast.parse(source)
+    scopes: list[ast.AST] = [tree]
+    scopes.extend(
+        node for node in ast.walk(tree) if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda))
+    )
+    consumed: set[str] = set()
+    for scope in scopes:
+        consumed.update(_reads_in_scope(scope, _tracked_names(scope)))
+    return consumed
+
+
+def _package_sources() -> "Iterator[tuple[Path, str]]":
+    """Yield every Python source file shipped in the package."""
+    for path in sorted(PACKAGE_ROOT.rglob("*.py")):
+        yield path, path.read_text(encoding="utf-8")
+
+
+def test_every_consumed_key_is_declared() -> None:
+    """No module may read a migration_config key the allowlist would reject."""
+    undeclared: dict[str, set[str]] = {}
+    for path, source in _package_sources():
+        consumed = collect_consumed_keys(source)
+        missing = consumed - MIGRATION_CONFIG_KEYS
+        if missing:
+            undeclared[str(path.relative_to(PACKAGE_ROOT))] = missing
+
+    assert not undeclared, (
+        f"migration_config keys read but not declared on MigrationConfig: {undeclared}. "
+        "Declare them on the TypedDict; MIGRATION_CONFIG_KEYS rejects everything else at construction."
+    )
+
+
+def test_scanner_finds_keys_read_through_a_local_alias() -> None:
+    """The scanner resolves the rebinding pattern that hid three keys during #670."""
+    source = """
+def build_template_settings(migration_config):
+    config = migration_config or {}
+    return config.get("templates"), config.get("default_format"), config.get("title")
+"""
+
+    assert collect_consumed_keys(source) == {"templates", "default_format", "title"}
+
+
+@pytest.mark.parametrize(
+    "source",
+    [
+        pytest.param('def f(migration_config):\n    return migration_config.get("undeclared")', id="direct-get"),
+        pytest.param('def f(migration_config):\n    return migration_config["undeclared"]', id="subscript"),
+        pytest.param('def f(migration_config):\n    return "undeclared" in migration_config', id="containment"),
+        pytest.param(
+            'def f(config):\n    mc = cast("dict[str, Any]", config.migration_config) or {}\n'
+            '    return mc.get("undeclared")',
+            id="cast-attribute-alias",
+        ),
+    ],
+)
+def test_scanner_detects_an_undeclared_key(source: str) -> None:
+    """A guard that cannot fail is worse than no guard, so prove each read shape is caught."""
+    consumed = collect_consumed_keys(source)
+
+    assert "undeclared" in consumed
+    assert consumed - MIGRATION_CONFIG_KEYS == {"undeclared"}
+
+
+def test_scanner_ignores_keys_of_nested_mappings() -> None:
+    """Keys of a mapping returned by a lookup belong to a nested scope, not the top level."""
+    source = """
+def build_template_settings(migration_config):
+    templates_config = migration_config.get("templates") or {}
+    return templates_config.get("sql")
+"""
+
+    assert collect_consumed_keys(source) == {"templates"}
+
+
+def test_scanner_reads_the_real_template_module() -> None:
+    """The template reader is scanned as a live consumer, not just as a fixture."""
+    source = (PACKAGE_ROOT / "migrations" / "templates.py").read_text(encoding="utf-8")
+
+    assert {"templates", "default_format", "title"} <= collect_consumed_keys(source)

sqlspec-0.58.2/tests/unit/config/test_migration_config_validation.py

@@ -0,0 +1,195 @@
+"""Regression tests for ``migration_config`` key validation.
+
+``migration_config`` is a ``TypedDict``, so a misspelled key was accepted at
+runtime and silently ignored, leaving the corresponding setting at its default.
+These tests pin the validate-and-raise behavior and the suggestion text.
+"""
+
+from typing import TYPE_CHECKING
+
+import pytest
+
+from sqlspec.adapters.sqlite import SqliteConfig
+from sqlspec.config import MIGRATION_CONFIG_KEYS, MigrationConfig, validate_migration_config_keys
+from sqlspec.exceptions import ImproperConfigurationError
+from sqlspec.migrations.utils import create_migration_file
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_known_keys_cover_every_typed_dict_field() -> None:
+    """Every declared MigrationConfig field is accepted by the validator."""
+    assert MIGRATION_CONFIG_KEYS == MigrationConfig.__required_keys__ | MigrationConfig.__optional_keys__
+    validate_migration_config_keys(dict.fromkeys(MIGRATION_CONFIG_KEYS, None))
+
+
+def test_author_key_is_declared() -> None:
+    """The author key is read when generating migrations, so it must be declared."""
+    assert "author" in MIGRATION_CONFIG_KEYS
+
+
+def test_unknown_key_raises_with_suggestion() -> None:
+    """A near-miss key reports the intended field name."""
+    with pytest.raises(ImproperConfigurationError) as exc_info:
+        validate_migration_config_keys({"version_table": "_schema_versions"})
+
+    message = str(exc_info.value)
+    assert "Unknown migration_config key 'version_table'" in message
+    assert "Did you mean 'version_table_name'?" in message
+
+
+def test_unrecognizable_key_lists_valid_keys_without_a_suggestion() -> None:
+    """A key with no close match still reports the accepted set."""
+    with pytest.raises(ImproperConfigurationError) as exc_info:
+        validate_migration_config_keys({"totally_unrelated": 1})
+
+    message = str(exc_info.value)
+    assert "Did you mean" not in message
+    assert "script_location" in message
+
+
+def test_every_unknown_key_is_reported() -> None:
+    """Reporting covers all offending keys, not just the first."""
+    with pytest.raises(ImproperConfigurationError) as exc_info:
+        validate_migration_config_keys({"version_table": "a", "scriptlocation": "b"})
+
+    message = str(exc_info.value)
+    assert "'version_table'" in message
+    assert "'scriptlocation'" in message
+
+
+def test_config_construction_rejects_unknown_key() -> None:
+    """The reporter's original config fails at construction instead of silently ignoring the key."""
+    with pytest.raises(ImproperConfigurationError, match="version_table_name"):
+        SqliteConfig(
+            connection_config={"database": ":memory:"},
+            migration_config={"script_location": "migrations", "version_table": "_schema_versions"},
+        )
+
+
+def test_post_construction_assignment_is_validated() -> None:
+    """Assigning migration_config after construction runs the same check."""
+    config = SqliteConfig(connection_config={"database": ":memory:"})
+
+    with pytest.raises(ImproperConfigurationError, match="version_table_name"):
+        config.set_migration_config({"version_table": "_schema_versions"})
+
+
+def test_valid_config_is_unchanged() -> None:
+    """A correctly spelled configuration is stored as provided."""
+    config = SqliteConfig(
+        connection_config={"database": ":memory:"},
+        migration_config={"script_location": "migrations", "version_table_name": "_schema_versions"},
+    )
+
+    assert config.migration_config["version_table_name"] == "_schema_versions"
+
+
+@pytest.mark.parametrize(
+    ("key", "value"),
+    [("templates", {"sql": {"header": "-- {title} [ACME]"}}), ("title", "Acme Migration"), ("default_format", "py")],
+)
+def test_template_keys_are_accepted(key: str, value: object) -> None:
+    """Keys read by build_template_settings must survive validation."""
+    config = SqliteConfig(connection_config={"database": ":memory:"}, migration_config={key: value})
+
+    assert dict(config.migration_config)[key] == value
+
+
+def test_template_keys_are_declared() -> None:
+    """The template settings reader consumes these keys, so they must be declared."""
+    assert {"templates", "title", "default_format"} <= MIGRATION_CONFIG_KEYS
+
+
+def test_unknown_template_section_key_is_reported() -> None:
+    """A typo directly under templates names the dotted path and the intended key."""
+    with pytest.raises(ImproperConfigurationError) as exc_info:
+        validate_migration_config_keys({"templates": {"sqll": {}}})
+
+    message = str(exc_info.value)
+    assert "Unknown migration_config key 'templates.sqll'" in message
+    assert "Did you mean 'sql'?" in message
+
+
+@pytest.mark.parametrize(
+    ("section", "bad_key", "suggestion"),
+    [("sql", "headers", "header"), ("sql", "bodyy", "body"), ("py", "docstrings", "docstring")],
+)
+def test_unknown_template_fragment_key_is_reported(section: str, bad_key: str, suggestion: str) -> None:
+    """A typo inside a template fragment is caught at construction, not at render time."""
+    with pytest.raises(ImproperConfigurationError) as exc_info:
+        validate_migration_config_keys({"templates": {section: {bad_key: "x"}}})
+
+    message = str(exc_info.value)
+    assert f"Unknown migration_config key 'templates.{section}.{bad_key}'" in message
+    assert f"Did you mean {suggestion!r}?" in message
+
+
+def test_description_key_is_the_accepted_fragment_spelling() -> None:
+    """The singular description_key is declared; the resolved plural form is not a config key."""
+    validate_migration_config_keys({"templates": {"sql": {"description_key": "Summary"}}})
+
+    with pytest.raises(ImproperConfigurationError, match="Did you mean 'description_key'"):
+        validate_migration_config_keys({"templates": {"sql": {"description_keys": "Summary"}}})
+
+
+@pytest.mark.parametrize("path", ["templates", "templates.sql"])
+def test_non_mapping_template_value_reports_the_type(path: str) -> None:
+    """A non-mapping override raises a clear message instead of a TypeError at render time."""
+    payload: dict[str, object] = (
+        {"templates": ["not", "a", "mapping"]} if path == "templates" else {"templates": {"sql": "not a mapping"}}
+    )
+
+    with pytest.raises(ImproperConfigurationError) as exc_info:
+        validate_migration_config_keys(payload)
+
+    assert f"'{path}' must be a mapping" in str(exc_info.value)
+
+
+MISSPELLED_FRAGMENT_KEY = "headerr"  # codespell:ignore headerr
+
+
+def test_nested_typo_fails_at_config_construction() -> None:
+    """Nested validation runs through the real config setter."""
+    with pytest.raises(ImproperConfigurationError, match=rf"templates\.sql\.{MISSPELLED_FRAGMENT_KEY}"):
+        SqliteConfig(
+            connection_config={"database": ":memory:"},
+            migration_config={"templates": {"sql": {MISSPELLED_FRAGMENT_KEY: "-- x"}}},
+        )
+
+
+def test_valid_nested_template_config_is_accepted() -> None:
+    """A fully populated template override passes validation."""
+    validate_migration_config_keys({
+        "title": "Acme",
+        "default_format": "py",
+        "templates": {
+            "title": "Acme Fallback",
+            "sql": {"header": "-- {title}", "metadata": ["-- {author}"], "body": "", "description_key": "Desc"},
+            "py": {"docstring": "{title}", "body": "", "imports": [], "description_key": ["Desc"]},
+        },
+    })
+
+
+def test_template_overrides_reach_the_rendered_migration(tmp_path: "Path") -> None:
+    """A customized template configured on a real config renders through to disk."""
+    migrations_dir = tmp_path / "migrations"
+    migrations_dir.mkdir()
+    config = SqliteConfig(
+        connection_config={"database": ":memory:"},
+        migration_config={
+            "author": "Acme Ops",
+            "title": "Acme Migration",
+            "default_format": "py",
+            "templates": {"sql": {"header": "-- {title} [ACME]", "metadata": ["-- Owner: {author}"]}},
+        },
+    )
+
+    sql_path = create_migration_file(migrations_dir, "0001", "custom", "sql", config=config)
+    default_path = create_migration_file(migrations_dir, "0002", "defaulted", None, config=config)
+
+    content = sql_path.read_text()
+    assert "-- Acme Migration [ACME]" in content
+    assert "-- Owner: Acme Ops" in content
+    assert default_path.suffix == ".py"

{sqlspec-0.58.0 → sqlspec-0.58.2}/tests/unit/loader/test_param_directives.py

@@ -81,7 +81,14 @@ def test_malformed_param_warns_and_skips_by_default(caplog: pytest.LogCaptureFix
         statements = SQLFileLoader._parse_statements(content, "test.sql")
     assert statements["q"].parameters == ()
     assert statements["q"].sql == "select 1"
-    assert any("malformed" in r.message or "param" in r.message.lower() for r in caplog.records)
+    record = caplog.records[-1]
+    assert record.message == "sql.parse.param: malformed parameter directive in test.sql at line 2: -- param: oops"
+    assert record.__dict__["extra_fields"] == {
+        "file_path": "test.sql",
+        "line_number": 2,
+        "directive": "-- param: oops",
+        "status": "malformed",
+    }
 
 
 def test_malformed_param_raises_in_strict_mode() -> None: