dbt-testpilot 0.1.0__py3-none-any.whl

dbt_testpilot/__init__.py

@@ -0,0 +1,3 @@
+"""dbt-testpilot — profile a dbt project's data and (later) propose the tests you're missing."""
+
+__version__ = "0.1.0"

dbt_testpilot/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

dbt_testpilot/apply.py

@@ -0,0 +1,164 @@
+"""Approve/reject flow + write approved tests to schema.yml, then optionally run dbt test.
+
+The reliability ethic: nothing is written without a human OK. Approval is
+interactive by default; `--yes` approves all, and `--dry-run` shows what would
+happen without touching any file.
+
+Custom (non-built-in) tests are skipped by default because dbt has no macro for
+them. With `--include-custom`, we auto-generate vetted macros for supported
+patterns (see macrogen.py) and write those; unsupported ones are still skipped.
+"""
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from .macrogen import classify, generate_macros
+from .yaml_writer import add_tests
+
+_CONF = {"low": 0, "medium": 1, "high": 2}
+
+# dbt's built-in generic tests — always safe to write and run as-is.
+WRITABLE = {"not_null", "unique", "accepted_values", "relationships"}
+
+
+def load_proposals(path: str) -> list[dict]:
+    data = json.loads(Path(path).read_text())
+    out: list[dict] = []
+    for group in data:
+        for p in group.get("proposals", []):
+            p = dict(p)
+            p.setdefault("model", group.get("model"))
+            out.append(p)
+    return out
+
+
+def _fmt(p: dict) -> str:
+    col = p.get("column") or "(model-level)"
+    args = p.get("arguments") or {}
+    extra = ""
+    if p["test"] == "accepted_values" and args.get("values"):
+        extra = f"  values={args['values']}"
+    elif p["test"] == "relationships" and args.get("to"):
+        extra = f"  -> {args['to']}.{args.get('field', '')}"
+    return f"{p['model']}  ::  {col}  ::  {p['test']}{extra}  [{p.get('source','?')[:1]}/{p.get('confidence','')}]"
+
+
+def review(proposals: list[dict], assume_yes: bool, min_conf: str) -> list[dict]:
+    thr = _CONF.get(min_conf, 0)
+    proposals = [p for p in proposals if _CONF.get(p.get("confidence", "medium"), 1) >= thr]
+    if not proposals:
+        return []
+    if assume_yes:
+        return proposals
+    if not sys.stdin.isatty():
+        print("[fail] not attached to a terminal and --yes not set — refusing to auto-approve.")
+        print("       Re-run in a terminal to review interactively, or pass --yes to accept all.")
+        return []
+
+    approved: list[dict] = []
+    take_rest = False
+    for i, p in enumerate(proposals, 1):
+        if take_rest:
+            approved.append(p)
+            continue
+        print(f"\n[{i}/{len(proposals)}] {_fmt(p)}")
+        if p.get("rationale"):
+            print(f"       {p['rationale']}")
+        ans = input("  approve? [y]es / [n]o / [a]ll remaining / [q]uit: ").strip().lower()
+        if ans == "y":
+            approved.append(p)
+        elif ans == "a":
+            take_rest = True
+            approved.append(p)
+        elif ans == "q":
+            break
+        # anything else = skip
+    return approved
+
+
+def _split(approved: list[dict]) -> tuple[list[dict], list[dict]]:
+    builtin = [p for p in approved if p["test"] in WRITABLE]
+    custom = [p for p in approved if p["test"] not in WRITABLE]
+    return builtin, custom
+
+
+def _print_list(header: str, items: list[dict]) -> None:
+    print(header)
+    for p in items:
+        print(f"   - {p['model']} :: {p.get('column') or '(model-level)'} :: {p['test']}")
+
+
+def apply_proposals(project_dir: str, proposals_path: str, assume_yes: bool = False,
+                    min_conf: str = "low", dry_run: bool = False, run: bool = False,
+                    include_custom: bool = False) -> int:
+    project = Path(project_dir).expanduser().resolve()
+    manifest_path = project / "target" / "manifest.json"
+    if not manifest_path.exists():
+        print(f"[fail] {manifest_path} not found — run `dbt build` in the project first.")
+        return 1
+    if not Path(proposals_path).exists():
+        print(f"[fail] {proposals_path} not found — run `propose --out {proposals_path}` first.")
+        return 1
+
+    manifest = json.loads(manifest_path.read_text())
+    proposals = load_proposals(proposals_path)
+    approved = review(proposals, assume_yes=assume_yes, min_conf=min_conf)
+    if not approved:
+        print("\n[ok] nothing approved — no files changed.")
+        return 0
+
+    builtin, custom = _split(approved)
+
+    # --- dry-run: preview only, write nothing (and generate no macros) ---
+    if dry_run:
+        print(f"\n[dry-run] would write {len(builtin)} built-in test(s):")
+        for p in builtin:
+            print("   +", _fmt(p))
+        if custom:
+            print("\n[dry-run] custom tests:")
+            for p in custom:
+                if include_custom:
+                    tag = "generate macro + write" if classify(p["test"]) else "skip (no template)"
+                else:
+                    tag = "skip (needs --include-custom)"
+                print(f"   ~ {_fmt(p)}   [{tag}]")
+        return 0
+
+    # --- resolve custom tests ---
+    to_write = list(builtin)
+    if custom and include_custom:
+        writable_custom, generated, skipped = generate_macros(project, custom)
+        to_write += writable_custom
+        if generated:
+            print(f"\n[ok] generated {len(generated)} test macro(s) under macros/dbt_testpilot/:")
+            for name in generated:
+                print(f"     test_{name}.sql")
+        if skipped:
+            _print_list(f"\n[note] {len(skipped)} custom test(s) have no macro template — left for you to implement:", skipped)
+    elif custom:
+        _print_list(
+            f"\n[note] skipping {len(custom)} custom test(s) that need a dbt macro "
+            f"(use --include-custom to auto-generate supported ones):",
+            custom,
+        )
+
+    if not to_write:
+        print("\n[ok] nothing runnable to write.")
+        return 0
+
+    changed = add_tests(project, manifest, to_write)
+    total = sum(changed.values())
+    print(f"\n[ok] wrote {total} test(s) across {len(changed)} file(s):")
+    for f, n in changed.items():
+        print(f"   {n:>2}  {f}")
+
+    if run:
+        print("\n[info] running `dbt test` ...")
+        proc = subprocess.run(["dbt", "test", "--profiles-dir", str(project)], cwd=str(project))
+        return proc.returncode
+
+    print("\n[next] review the diff, then run:  dbt test   (in the project dir)")
+    return 0

dbt_testpilot/artifacts.py

@@ -0,0 +1,81 @@
+"""Read a dbt project's machine-readable artifacts (manifest.json + catalog.json).
+
+We take the *model list* and *existing tests* from the manifest, and the
+declared column types from the catalog. Actual columns to profile are read
+from the warehouse itself later (see profiler.py) — the artifacts tell us
+which relations are models and what's already tested.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class Model:
+    unique_id: str
+    name: str                              # the built relation name (alias or model name)
+    database: str | None
+    schema: str | None
+    catalog_types: dict[str, str] = field(default_factory=dict)      # column -> type (from catalog)
+    existing_tests: dict[str, list[str]] = field(default_factory=dict)  # column -> [test types]
+
+    @property
+    def identifier(self) -> str:
+        return f"{self.schema}.{self.name}" if self.schema else self.name
+
+
+def _load(path: Path) -> dict:
+    with open(path) as f:
+        return json.load(f)
+
+
+def _test_type(node: dict) -> str:
+    meta = node.get("test_metadata") or {}
+    return meta.get("name") or node.get("name") or "test"
+
+
+def load_models(target_dir: str | Path) -> list[Model]:
+    """Parse target/manifest.json (+ catalog.json if present) into Model objects."""
+    target = Path(target_dir)
+    manifest = _load(target / "manifest.json")
+    catalog_path = target / "catalog.json"
+    catalog = _load(catalog_path) if catalog_path.exists() else {"nodes": {}}
+
+    nodes = manifest.get("nodes", {})
+    cat_nodes = catalog.get("nodes", {})
+
+    # Map existing generic tests: model unique_id -> {column -> [test types]}
+    existing: dict[str, dict[str, list[str]]] = {}
+    for node in nodes.values():
+        if node.get("resource_type") != "test":
+            continue
+        attached = node.get("attached_node")
+        if not attached:
+            deps = (node.get("depends_on") or {}).get("nodes") or []
+            attached = next((d for d in deps if d.startswith("model.")), None)
+        column = node.get("column_name") or "*"  # table-level tests keyed under "*"
+        if attached:
+            existing.setdefault(attached, {}).setdefault(column, []).append(_test_type(node))
+
+    models: list[Model] = []
+    for uid, node in nodes.items():
+        if node.get("resource_type") != "model":
+            continue
+        catalog_types: dict[str, str] = {}
+        cat = cat_nodes.get(uid)
+        if cat:
+            for cname, cinfo in (cat.get("columns") or {}).items():
+                catalog_types[cname] = cinfo.get("type")
+        models.append(
+            Model(
+                unique_id=uid,
+                name=node.get("alias") or node.get("name"),
+                database=node.get("database"),
+                schema=node.get("schema"),
+                catalog_types=catalog_types,
+                existing_tests=existing.get(uid, {}),
+            )
+        )
+    return models

dbt_testpilot/cli.py

@@ -0,0 +1,130 @@
+"""Command-line entry point.
+
+  python -m dbt_testpilot profile  --project-dir <dir> --out profiles.json
+  python -m dbt_testpilot propose  --profiles profiles.json --out proposals.json [--llm]
+  python -m dbt_testpilot apply    --proposals proposals.json --project-dir <dir> [--yes] [--run]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+from .apply import apply_proposals
+from .artifacts import load_models
+from .llm import llm_proposals, load_env
+from .profiler import profile_models
+from .proposals import group_by_model, heuristic_proposals, merge
+from .report import model_to_dict, render_proposals, render_text
+
+
+def _find_duckdb(project_dir: Path) -> Path | None:
+    cands = sorted(project_dir.glob("*.duckdb"))
+    return cands[0] if cands else None
+
+
+def _cmd_profile(args) -> int:
+    project = Path(args.project_dir).expanduser().resolve()
+    target = project / "target"
+    if not (target / "manifest.json").exists():
+        print(f"[fail] no manifest.json under {target} — run `dbt build` / `dbt docs generate` first.")
+        return 1
+    db = Path(args.db).expanduser().resolve() if args.db else _find_duckdb(project)
+    if not db or not db.exists():
+        print(f"[fail] DuckDB file not found (looked in {project}). Pass --db /path/to/file.duckdb.")
+        return 1
+
+    models = load_models(target)
+    profiles = profile_models(str(db), models, max_values=args.max_values)
+    for mp in profiles:
+        print(render_text(mp))
+        print()
+    if args.out:
+        Path(args.out).write_text(json.dumps([model_to_dict(mp) for mp in profiles], indent=2, default=str))
+        print(f"[ok] wrote {len(profiles)} model profiles -> {args.out}")
+    else:
+        print(f"[ok] profiled {len(profiles)} models (pass --out profiles.json to save).")
+    return 0
+
+
+def _cmd_propose(args) -> int:
+    profiles_path = Path(args.profiles).expanduser().resolve()
+    if not profiles_path.exists():
+        print(f"[fail] {profiles_path} not found — run `profile --out {args.profiles}` first.")
+        return 1
+    profiles = json.loads(profiles_path.read_text())
+
+    heur = heuristic_proposals(profiles)
+    llm_list = []
+    if args.llm:
+        env = load_env(args.env)
+        provider = (args.provider or env.get("LLM_PROVIDER") or "gemini").lower()
+        key_name = "GEMINI_API_KEY" if provider == "gemini" else "GROQ_API_KEY"
+        api_key = env.get(key_name) or os.environ.get(key_name, "")
+        if not api_key:
+            print(f"[fail] --llm needs {key_name} in {args.env} (or the environment).")
+            return 1
+        print(f"[info] querying {provider} for proposals ...")
+        llm_list = llm_proposals(profiles, provider, api_key)
+
+    proposals = merge(profiles, heur, llm_list)
+    grouped = group_by_model(proposals)
+    for g in grouped:
+        print(render_proposals(g["model"], g["proposals"]))
+        print()
+
+    n_h = sum(1 for p in proposals if p.source == "heuristic")
+    n_l = sum(1 for p in proposals if p.source == "llm")
+    if args.out:
+        Path(args.out).write_text(json.dumps(grouped, indent=2, default=str))
+        print(f"[ok] wrote {len(proposals)} proposals ({n_h} heuristic, {n_l} llm) -> {args.out}")
+    else:
+        print(f"[ok] {len(proposals)} proposals ({n_h} heuristic, {n_l} llm). Pass --out proposals.json to save.")
+    if not args.llm:
+        print("[hint] add --llm to augment with LLM proposals (needs an API key in .env).")
+    return 0
+
+
+def _cmd_apply(args) -> int:
+    return apply_proposals(
+        args.project_dir, args.proposals,
+        assume_yes=args.yes, min_conf=args.min_confidence,
+        dry_run=args.dry_run, run=args.run, include_custom=args.include_custom,
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="dbt-testpilot",
+        description="Profile a dbt project, propose the tests it's missing, and write the ones you approve.",
+    )
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    pp = sub.add_parser("profile", help="Profile every model in the project.")
+    pp.add_argument("--project-dir", default=".", help="dbt project dir (contains target/ and the .duckdb file).")
+    pp.add_argument("--db", default=None, help="Path to the DuckDB file (auto-detected if omitted).")
+    pp.add_argument("--out", default=None, help="Write per-model profiles as JSON to this path.")
+    pp.add_argument("--max-values", type=int, default=25, help="Max distinct values captured for low-cardinality columns.")
+    pp.set_defaults(func=_cmd_profile)
+
+    pr = sub.add_parser("propose", help="Propose missing tests from a profiles.json.")
+    pr.add_argument("--profiles", default="profiles.json", help="Path to the profiles JSON from `profile`.")
+    pr.add_argument("--out", default=None, help="Write proposals as JSON to this path.")
+    pr.add_argument("--llm", action="store_true", help="Augment heuristics with LLM proposals.")
+    pr.add_argument("--provider", default=None, help="gemini | groq (default: LLM_PROVIDER from .env).")
+    pr.add_argument("--env", default=".env", help="Path to the .env holding API keys.")
+    pr.set_defaults(func=_cmd_propose)
+
+    pa = sub.add_parser("apply", help="Review proposals and write approved tests into schema.yml.")
+    pa.add_argument("--proposals", default="proposals.json", help="Path to the proposals JSON from `propose`.")
+    pa.add_argument("--project-dir", default=".", help="dbt project dir whose schema.yml files get updated.")
+    pa.add_argument("--yes", action="store_true", help="Approve all proposals (non-interactive).")
+    pa.add_argument("--min-confidence", choices=["low", "medium", "high"], default="low", help="Only consider proposals at/above this confidence.")
+    pa.add_argument("--dry-run", action="store_true", help="Show what would be written; change nothing.")
+    pa.add_argument("--include-custom", action="store_true", help="Also handle custom tests: auto-generate vetted macros for supported patterns, then write them.")
+    pa.add_argument("--run", action="store_true", help="Run `dbt test` after writing.")
+    pa.set_defaults(func=_cmd_apply)
+
+    args = parser.parse_args(argv)
+    return args.func(args)

dbt_testpilot/llm.py

@@ -0,0 +1,135 @@
+"""LLM layer: ask a model to propose the *missing* dbt tests as strict JSON.
+
+Runs per model (small prompts, friendly to free-tier token limits). Output is
+parsed and validated against the Proposal schema; anything malformed or
+hallucinated is dropped, so a bad response degrades to "no LLM proposals"
+rather than poisoning the results. The deterministic heuristics still stand on
+their own — this only augments them.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from .proposals import Proposal, validate_llm_proposal
+
+GEMINI_MODEL = "gemini-2.5-flash"
+GROQ_MODEL = "llama-3.1-8b-instant"
+
+_INSTRUCTIONS = """You are a dbt data-quality assistant. Propose the dbt tests this model is MISSING.
+Rules:
+- Only propose tests NOT already listed in each column's existing_tests.
+- Valid generic tests: not_null, unique, accepted_values (arguments.values = [...]),
+  relationships (arguments.to = "ref('model_name')", arguments.field = "column").
+- You may also propose a custom test: use a short snake_case name and explain it in the rationale.
+- Be conservative: only propose accepted_values for stable categorical columns, not for amounts/free text.
+- Every proposal needs a one-line rationale grounded in the profile stats.
+Return ONLY JSON of the form:
+{"proposals":[{"column":"<name or null>","test":"<name>","arguments":{...},"rationale":"...","confidence":"high|medium|low"}]}"""
+
+
+def load_env(path: str = ".env") -> dict[str, str]:
+    env: dict[str, str] = {}
+    p = Path(path)
+    if not p.exists():
+        return env
+    for raw in p.read_text().splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        k, _, v = line.partition("=")
+        env[k.strip()] = v.strip().strip('"').strip("'")
+    return env
+
+
+def _model_prompt(model: dict, unique_index: dict[str, list[str]]) -> str:
+    cols = []
+    for c in model.get("columns", []):
+        cols.append({
+            "name": c["name"],
+            "type": c.get("data_type"),
+            "null_pct": c.get("null_pct"),
+            "distinct": c.get("distinct_count"),
+            "is_unique": c.get("is_unique"),
+            "sample_values": [v for v, _ in (c.get("top_values") or [])][:10],
+            "existing_tests": c.get("existing_tests", []),
+        })
+    fk_targets = {col: models for col, models in unique_index.items()}
+    payload = {
+        "model": model["identifier"],
+        "row_count": model.get("row_count"),
+        "columns": cols,
+        "unique_columns_across_project": fk_targets,  # for relationships
+    }
+    return f"{_INSTRUCTIONS}\n\nPROFILE:\n{json.dumps(payload, default=str)}"
+
+
+def _strip_fences(text: str) -> str:
+    t = text.strip()
+    if t.startswith("```"):
+        t = t.split("\n", 1)[-1]
+        if t.rstrip().endswith("```"):
+            t = t.rstrip()[:-3]
+    return t.strip()
+
+
+def _extract_proposals(text: str) -> list[dict]:
+    data = json.loads(_strip_fences(text))
+    if isinstance(data, dict):
+        data = data.get("proposals", [])
+    return data if isinstance(data, list) else []
+
+
+def _call_gemini(prompt: str, api_key: str) -> str:
+    from google import genai  # pip install google-genai
+
+    client = genai.Client(api_key=api_key)
+    resp = client.models.generate_content(
+        model=GEMINI_MODEL,
+        contents=prompt,
+        config={"response_mime_type": "application/json"},
+    )
+    return resp.text or ""
+
+
+def _call_groq(prompt: str, api_key: str) -> str:
+    from groq import Groq  # pip install groq
+
+    client = Groq(api_key=api_key)
+    resp = client.chat.completions.create(
+        model=GROQ_MODEL,
+        messages=[{"role": "user", "content": prompt}],
+        response_format={"type": "json_object"},
+    )
+    return resp.choices[0].message.content or ""
+
+
+def _unique_index(profiles: list[dict]) -> dict[str, list[str]]:
+    idx: dict[str, list[str]] = {}
+    for m in profiles:
+        mname = m["identifier"].split(".")[-1]
+        for c in m.get("columns", []):
+            if c.get("is_unique"):
+                idx.setdefault(c["name"], []).append(mname)
+    return idx
+
+
+def llm_proposals(profiles: list[dict], provider: str, api_key: str) -> list[Proposal]:
+    """Call the LLM per model and return validated Proposal objects. Never raises."""
+    call = _call_gemini if provider == "gemini" else _call_groq
+    unique_index = _unique_index(profiles)
+    out: list[Proposal] = []
+    for model in profiles:
+        if model.get("note") or not model.get("columns"):
+            continue
+        valid_columns = {c["name"] for c in model["columns"]}
+        try:
+            text = call(_model_prompt(model, unique_index), api_key)
+            for raw in _extract_proposals(text):
+                p = validate_llm_proposal(raw, model["identifier"], valid_columns)
+                if p:
+                    out.append(p)
+        except Exception as e:  # noqa: BLE001 - degrade gracefully per model
+            print(f"[warn] LLM proposal failed for {model['identifier']}: {type(e).__name__}: {e}")
+    return out

dbt_testpilot/macrogen.py

@@ -0,0 +1,106 @@
+"""Generate dbt generic-test macros for approved custom tests.
+
+The LLM proposes semantically useful checks (e.g. `is_not_negative`) by *name*,
+but dbt runs a generic test named `foo` by looking up a macro `test_foo`. Only
+four built-ins ship with dbt, so custom names have no macro and fail to compile.
+
+For a small set of well-understood patterns we emit **vetted, hand-written**
+macros (no guessed SQL) into `macros/dbt_testpilot/`, so the approved tests run.
+Anything we don't recognise is left for the user to implement — we never write a
+macro whose logic we can't guarantee (that would risk false confidence).
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+MACRO_SUBDIR = "dbt_testpilot"  # under <project>/macros/
+
+# value >= 0  (nulls pass, matching dbt's convention of ignoring nulls)
+_NON_NEGATIVE = """{% test __NAME__(model, column_name) %}
+-- generated by dbt-testpilot: fails rows where the value is negative (nulls pass)
+select *
+from {{ model }}
+where {{ column_name }} < 0
+{% endtest %}
+"""
+
+# date/timestamp not in the future
+_NOT_FUTURE = """{% test __NAME__(model, column_name) %}
+-- generated by dbt-testpilot: fails rows where the date is in the future (nulls pass)
+select *
+from {{ model }}
+where {{ column_name }} > current_date
+{% endtest %}
+"""
+
+# (pattern key, name substrings that map to it, template)
+_PATTERNS = [
+    ("non_negative", ("non_negative", "nonnegative", "not_negative", "no_negative",
+                      "positive", "gte_zero", "ge_zero"), _NON_NEGATIVE),
+    ("not_future", ("not_future", "past_or_present", "in_past", "future", "past"), _NOT_FUTURE),
+]
+
+_TEST_DEF_RE = re.compile(r"{%-?\s*test\s+([A-Za-z_]\w*)\s*\(")
+
+
+def classify(test_name: str) -> str | None:
+    """Return the template key a custom test maps to, or None if unsupported."""
+    n = test_name.lower()
+    for key, needles, _ in _PATTERNS:
+        if any(x in n for x in needles):
+            return key
+    return None
+
+
+def _template(key: str) -> str:
+    return next(tmpl for k, _, tmpl in _PATTERNS if k == key)
+
+
+def existing_macro_names(project_dir: Path) -> set[str]:
+    """Names of generic tests already defined in the project's macros/."""
+    names: set[str] = set()
+    macros_dir = Path(project_dir) / "macros"
+    if not macros_dir.exists():
+        return names
+    for sql in macros_dir.rglob("*.sql"):
+        try:
+            names |= set(_TEST_DEF_RE.findall(sql.read_text()))
+        except OSError:
+            pass
+    return names
+
+
+def generate_macros(project_dir, custom: list[dict]):
+    """For each custom proposal: reuse an existing macro, generate one for a known
+    pattern, or skip it.
+
+    Returns (writable, generated, skipped):
+      writable  — proposals that now have a macro (existing or just generated)
+      generated — {test_name: file_path} written this run
+      skipped   — proposals with no template (left for manual implementation)
+    """
+    project_dir = Path(project_dir)
+    existing = existing_macro_names(project_dir)
+    out_dir = project_dir / "macros" / MACRO_SUBDIR
+
+    writable: list[dict] = []
+    generated: dict[str, str] = {}
+    skipped: list[dict] = []
+
+    for p in custom:
+        name = p["test"]
+        if name in existing or name in generated:
+            writable.append(p)  # macro already available
+            continue
+        key = classify(name)
+        if key is None:
+            skipped.append(p)
+            continue
+        out_dir.mkdir(parents=True, exist_ok=True)
+        path = out_dir / f"test_{name}.sql"
+        path.write_text(_template(key).replace("__NAME__", name))
+        generated[name] = str(path)
+        writable.append(p)
+
+    return writable, generated, skipped