feat: sovereign DNS record management (#692)

configs/dns_records.example.yaml

@@ -0,0 +1,13 @@
+# Ansible-style variable file for sovereign DNS sync (#692)
+# Copy to a private path and fill in provider credentials via env vars.
+# Use `auto` to resolve the current VPS public IP at sync time.
+
+dns_provider: cloudflare
+# For Cloudflare: zone_id
+# For Route53: hosted zone ID (also accepted under dns_zone_id)
+dns_zone_id: your-zone-id
+
+domain_ip_map:
+  forge.alexanderwhitestone.com: auto
+  matrix.alexanderwhitestone.com: auto
+  timmy.alexanderwhitestone.com: auto

scripts/codebase_test_generator.py

@@ -1,290 +0,0 @@
-#!/usr/bin/env python3
-"""Codebase Test Generator — Fill Coverage Gaps (#667)."""
-
-import ast
-import os
-import sys
-import argparse
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Dict, List, Optional, Set, Tuple
-
-
-@dataclass
-class FunctionInfo:
-    name: str
-    module_path: str
-    class_name: Optional[str] = None
-    lineno: int = 0
-    args: List[str] = field(default_factory=list)
-    is_async: bool = False
-    is_private: bool = False
-    is_property: bool = False
-    docstring: Optional[str] = None
-    has_return: bool = False
-    raises: List[str] = field(default_factory=list)
-    decorators: List[str] = field(default_factory=list)
-
-    @property
-    def qualified_name(self):
-        if self.class_name:
-            return f"{self.class_name}.{self.name}"
-        return self.name
-
-    @property
-    def test_name(self):
-        safe_mod = self.module_path.replace("/", "_").replace(".py", "").replace("-", "_")
-        safe_cls = self.class_name + "_" if self.class_name else ""
-        return f"test_{safe_mod}_{safe_cls}{self.name}"
-
-
-@dataclass
-class CoverageGap:
-    func: FunctionInfo
-    reason: str
-    test_priority: int
-
-
-class SourceAnalyzer(ast.NodeVisitor):
-    def __init__(self, module_path: str):
-        self.module_path = module_path
-        self.functions: List[FunctionInfo] = []
-        self._class_stack: List[str] = []
-
-    def visit_ClassDef(self, node):
-        self._class_stack.append(node.name)
-        self.generic_visit(node)
-        self._class_stack.pop()
-
-    def visit_FunctionDef(self, node):
-        self._collect(node, False)
-        self.generic_visit(node)
-
-    def visit_AsyncFunctionDef(self, node):
-        self._collect(node, True)
-        self.generic_visit(node)
-
-    def _collect(self, node, is_async):
-        cls = self._class_stack[-1] if self._class_stack else None
-        args = [a.arg for a in node.args.args if a.arg not in ("self", "cls")]
-        has_ret = any(isinstance(c, ast.Return) and c.value for c in ast.walk(node))
-        raises = []
-        for c in ast.walk(node):
-            if isinstance(c, ast.Raise) and c.exc:
-                if isinstance(c.exc, ast.Call) and isinstance(c.exc.func, ast.Name):
-                    raises.append(c.exc.func.id)
-        decos = []
-        for d in node.decorator_list:
-            if isinstance(d, ast.Name): decos.append(d.id)
-            elif isinstance(d, ast.Attribute): decos.append(d.attr)
-        self.functions.append(FunctionInfo(
-            name=node.name, module_path=self.module_path, class_name=cls,
-            lineno=node.lineno, args=args, is_async=is_async,
-            is_private=node.name.startswith("_") and not node.name.startswith("__"),
-            is_property="property" in decos,
-            docstring=ast.get_docstring(node), has_return=has_ret,
-            raises=raises, decorators=decos))
-
-
-def analyze_file(filepath, base_dir):
-    module_path = os.path.relpath(filepath, base_dir)
-    try:
-        with open(filepath, "r", errors="replace") as f:
-            tree = ast.parse(f.read(), filename=filepath)
-    except (SyntaxError, UnicodeDecodeError):
-        return []
-    a = SourceAnalyzer(module_path)
-    a.visit(tree)
-    return a.functions
-
-
-def find_source_files(source_dir):
-    exclude = {"__pycache__", ".git", "venv", ".venv", "node_modules", ".tox", "build", "dist"}
-    files = []
-    for root, dirs, fs in os.walk(source_dir):
-        dirs[:] = [d for d in dirs if d not in exclude and not d.startswith(".")]
-        for f in fs:
-            if f.endswith(".py") and f != "__init__.py" and not f.startswith("test_"):
-                files.append(os.path.join(root, f))
-    return sorted(files)
-
-
-def find_existing_tests(test_dir):
-    existing = set()
-    for root, dirs, fs in os.walk(test_dir):
-        for f in fs:
-            if f.startswith("test_") and f.endswith(".py"):
-                try:
-                    with open(os.path.join(root, f)) as fh:
-                        tree = ast.parse(fh.read())
-                    for node in ast.walk(tree):
-                        if isinstance(node, ast.FunctionDef) and node.name.startswith("test_"):
-                            existing.add(node.name)
-                except (SyntaxError, UnicodeDecodeError):
-                    pass
-    return existing
-
-
-def identify_gaps(functions, existing_tests):
-    gaps = []
-    for func in functions:
-        if func.name.startswith("__") and func.name != "__init__":
-            continue
-        covered = func.name in str(existing_tests)
-        if not covered:
-            pri = 3 if func.is_private else (1 if (func.raises or func.has_return) else 2)
-            gaps.append(CoverageGap(func=func, reason="no test found", test_priority=pri))
-    gaps.sort(key=lambda g: (g.test_priority, g.func.module_path, g.func.name))
-    return gaps
-
-
-def generate_test(gap):
-    func = gap.func
-    lines = []
-    lines.append(f"    # AUTO-GENERATED -- review before merging")
-    lines.append(f"    # Source: {func.module_path}:{func.lineno}")
-    lines.append(f"    # Function: {func.qualified_name}")
-    lines.append("")
-    mod_imp = func.module_path.replace("/", ".").replace("-", "_").replace(".py", "")
-
-    call_args = []
-    for a in func.args:
-        if a in ("self", "cls"): continue
-        if "path" in a or "file" in a or "dir" in a: call_args.append(f"{a}='/tmp/test'")
-        elif "name" in a: call_args.append(f"{a}='test'")
-        elif "id" in a or "key" in a: call_args.append(f"{a}='test_id'")
-        elif "message" in a or "text" in a: call_args.append(f"{a}='test msg'")
-        elif "count" in a or "num" in a or "size" in a: call_args.append(f"{a}=1")
-        elif "flag" in a or "enabled" in a or "verbose" in a: call_args.append(f"{a}=False")
-        else: call_args.append(f"{a}=None")
-    args_str = ", ".join(call_args)
-
-    if func.is_async:
-        lines.append("    @pytest.mark.asyncio")
-    lines.append(f"    def {func.test_name}(self):")
-    lines.append(f'        """Test {func.qualified_name} -- auto-generated."""')
-
-    if func.class_name:
-        lines.append(f"        try:")
-        lines.append(f"            from {mod_imp} import {func.class_name}")
-        if func.is_private:
-            lines.append(f"            pytest.skip('Private method')")
-        elif func.is_property:
-            lines.append(f"            obj = {func.class_name}()")
-            lines.append(f"            _ = obj.{func.name}")
-        else:
-            if func.raises:
-                lines.append(f"            with pytest.raises(({', '.join(func.raises)})):")
-                lines.append(f"                {func.class_name}().{func.name}({args_str})")
-            else:
-                lines.append(f"            obj = {func.class_name}()")
-                lines.append(f"            result = obj.{func.name}({args_str})")
-                if func.has_return:
-                    lines.append(f"            assert result is not None or result is None  # Placeholder")
-        lines.append(f"        except ImportError:")
-        lines.append(f"            pytest.skip('Module not importable')")
-    else:
-        lines.append(f"        try:")
-        lines.append(f"            from {mod_imp} import {func.name}")
-        if func.is_private:
-            lines.append(f"            pytest.skip('Private function')")
-        else:
-            if func.raises:
-                lines.append(f"            with pytest.raises(({', '.join(func.raises)})):")
-                lines.append(f"                {func.name}({args_str})")
-            else:
-                lines.append(f"            result = {func.name}({args_str})")
-                if func.has_return:
-                    lines.append(f"            assert result is not None or result is None  # Placeholder")
-        lines.append(f"        except ImportError:")
-        lines.append(f"            pytest.skip('Module not importable')")
-
-    return chr(10).join(lines)
-
-
-def generate_test_suite(gaps, max_tests=50):
-    by_module = {}
-    for gap in gaps[:max_tests]:
-        by_module.setdefault(gap.func.module_path, []).append(gap)
-
-    lines = []
-    lines.append('"""Auto-generated test suite -- Codebase Genome (#667).')
-    lines.append("")
-    lines.append("Generated by scripts/codebase_test_generator.py")
-    lines.append("Coverage gaps identified from AST analysis.")
-    lines.append("")
-    lines.append("These tests are starting points. Review before merging.")
-    lines.append('"""')
-    lines.append("")
-    lines.append("import pytest")
-    lines.append("from unittest.mock import MagicMock, patch")
-    lines.append("")
-    lines.append("")
-    lines.append("# AUTO-GENERATED -- DO NOT EDIT WITHOUT REVIEW")
-
-    for module, mgaps in sorted(by_module.items()):
-        safe = module.replace("/", "_").replace(".py", "").replace("-", "_")
-        cls_name = "".join(w.title() for w in safe.split("_"))
-        lines.append("")
-        lines.append(f"class Test{cls_name}Generated:")
-        lines.append(f'    """Auto-generated tests for {module}."""')
-        for gap in mgaps:
-            lines.append("")
-            lines.append(generate_test(gap))
-        lines.append("")
-
-    return chr(10).join(lines)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Codebase Test Generator")
-    parser.add_argument("--source", default=".")
-    parser.add_argument("--output", default="tests/test_genome_generated.py")
-    parser.add_argument("--max-tests", type=int, default=50)
-    parser.add_argument("--dry-run", action="store_true")
-    parser.add_argument("--include-private", action="store_true")
-    args = parser.parse_args()
-
-    source_dir = os.path.abspath(args.source)
-    test_dir = os.path.join(source_dir, "tests")
-
-    print(f"Scanning: {source_dir}")
-    source_files = find_source_files(source_dir)
-    print(f"Source files: {len(source_files)}")
-
-    all_funcs = []
-    for f in source_files:
-        all_funcs.extend(analyze_file(f, source_dir))
-    print(f"Functions/methods: {len(all_funcs)}")
-
-    existing = find_existing_tests(test_dir)
-    print(f"Existing tests: {len(existing)}")
-
-    gaps = identify_gaps(all_funcs, existing)
-    if not args.include_private:
-        gaps = [g for g in gaps if not g.func.is_private]
-    print(f"Coverage gaps: {len(gaps)}")
-
-    by_pri = {1: 0, 2: 0, 3: 0}
-    for g in gaps:
-        by_pri[g.test_priority] += 1
-    print(f"  High: {by_pri[1]}, Medium: {by_pri[2]}, Low: {by_pri[3]}")
-
-    if args.dry_run:
-        for g in gaps[:10]:
-            print(f"  {g.func.module_path}:{g.func.lineno} {g.func.qualified_name}")
-        return
-
-    if gaps:
-        content = generate_test_suite(gaps, max_tests=args.max-tests if hasattr(args, 'max-tests') else args.max_tests)
-        out = os.path.join(source_dir, args.output)
-        os.makedirs(os.path.dirname(out), exist_ok=True)
-        with open(out, "w") as f:
-            f.write(content)
-        print(f"Generated {min(len(gaps), args.max_tests)} tests -> {args.output}")
-    else:
-        print("No gaps found!")
-
-
-if __name__ == "__main__":
-    main()

scripts/sovereign_dns.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""Sovereign DNS management for fleet domains.
+
+Supports:
+- Cloudflare via REST API token
+- Route53 via boto3-compatible client (or injected client in tests)
+- add / update / delete A records
+- sync mode using an Ansible-style domain -> IP mapping YAML
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Callable
+
+import yaml
+
+
+DEFAULT_MAPPING_PATH = Path('configs/dns_records.example.yaml')
+
+
+def load_domain_mapping(path: str | Path) -> dict:
+    data = yaml.safe_load(Path(path).read_text()) or {}
+    if not isinstance(data, dict):
+        raise ValueError('mapping file must contain a YAML object')
+    data.setdefault('domain_ip_map', {})
+    if not isinstance(data['domain_ip_map'], dict):
+        raise ValueError('domain_ip_map must be a mapping of domain -> IPv4')
+    return data
+
+
+def detect_public_ip(urlopen_fn=urllib.request.urlopen, service_url: str = 'https://api.ipify.org') -> str:
+    req = urllib.request.Request(service_url, headers={'User-Agent': 'sovereign-dns/1.0'})
+    with urlopen_fn(req, timeout=10) as resp:
+        return resp.read().decode().strip()
+
+
+def resolve_domain_ip_map(domain_ip_map: dict[str, str], current_public_ip: str) -> dict[str, str]:
+    resolved = {}
+    for domain, value in domain_ip_map.items():
+        if isinstance(value, str) and value.strip().lower() in {'auto', '__public_ip__', '$public_ip'}:
+            resolved[domain] = current_public_ip
+        else:
+            resolved[domain] = value
+    return resolved
+
+
+def build_sync_plan(current: dict[str, dict], desired: dict[str, str]) -> dict[str, list[dict]]:
+    create: list[dict] = []
+    update: list[dict] = []
+    delete: list[dict] = []
+
+    for name, ip in desired.items():
+        existing = current.get(name)
+        if existing is None:
+            create.append({'name': name, 'content': ip})
+        elif existing.get('content') != ip:
+            update.append({'name': name, 'id': existing.get('id'), 'content': ip})
+
+    for name, record in current.items():
+        if name not in desired:
+            delete.append({'name': name, 'id': record.get('id')})
+
+    return {'create': create, 'update': update, 'delete': delete}
+
+
+class CloudflareDNSProvider:
+    def __init__(self, api_token: str, zone_id: str, request_fn: Callable | None = None):
+        self.api_token = api_token
+        self.zone_id = zone_id
+        self.request_fn = request_fn or self._request
+
+    def _request(self, method: str, path: str, payload: dict | None = None) -> dict:
+        url = 'https://api.cloudflare.com/client/v4' + path
+        data = None if payload is None else json.dumps(payload).encode()
+        req = urllib.request.Request(
+            url,
+            data=data,
+            method=method,
+            headers={
+                'Authorization': f'Bearer {self.api_token}',
+                'Content-Type': 'application/json',
+            },
+        )
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read().decode())
+
+    def list_a_records(self) -> dict[str, dict]:
+        path = f'/zones/{self.zone_id}/dns_records?type=A&per_page=500'
+        data = self.request_fn('GET', path)
+        return {item['name']: {'id': item['id'], 'content': item['content']} for item in data.get('result', [])}
+
+    def upsert_a_record(self, name: str, content: str) -> dict:
+        lookup_path = f'/zones/{self.zone_id}/dns_records?type=A&name={urllib.parse.quote(name)}'
+        existing = self.request_fn('GET', lookup_path).get('result', [])
+        payload = {'type': 'A', 'name': name, 'content': content, 'ttl': 120, 'proxied': False}
+        if existing:
+            return self.request_fn('PUT', f"/zones/{self.zone_id}/dns_records/{existing[0]['id']}", payload)
+        return self.request_fn('POST', f'/zones/{self.zone_id}/dns_records', payload)
+
+    def delete_record(self, record_id: str) -> dict:
+        return self.request_fn('DELETE', f'/zones/{self.zone_id}/dns_records/{record_id}')
+
+    def apply_plan(self, create: list[dict], update: list[dict], delete: list[dict], current: dict[str, dict] | None = None) -> dict:
+        results = {'created': [], 'updated': [], 'deleted': []}
+        for item in create:
+            self.upsert_a_record(item['name'], item['content'])
+            results['created'].append(item['name'])
+        for item in update:
+            self.upsert_a_record(item['name'], item['content'])
+            results['updated'].append(item['name'])
+        current = current or {}
+        for item in delete:
+            record_id = item.get('id') or current.get(item['name'], {}).get('id')
+            if record_id:
+                self.delete_record(record_id)
+                results['deleted'].append(item['name'])
+        return results
+
+
+class Route53DNSProvider:
+    def __init__(self, hosted_zone_id: str, client=None):
+        self.hosted_zone_id = hosted_zone_id
+        if client is None:
+            import boto3  # optional runtime dependency
+            client = boto3.client('route53')
+        self.client = client
+
+    def list_a_records(self) -> dict[str, dict]:
+        data = self.client.list_resource_record_sets(HostedZoneId=self.hosted_zone_id)
+        result = {}
+        for item in data.get('ResourceRecordSets', []):
+            if item.get('Type') != 'A':
+                continue
+            name = item['Name'].rstrip('.')
+            values = item.get('ResourceRecords', [])
+            if values:
+                result[name] = {'content': values[0]['Value']}
+        return result
+
+    def apply_plan(self, create: list[dict], update: list[dict], delete: list[dict], current: dict[str, dict] | None = None) -> dict:
+        current = current or {}
+        changes = []
+        for item in create:
+            changes.append({
+                'Action': 'CREATE',
+                'ResourceRecordSet': {
+                    'Name': item['name'],
+                    'Type': 'A',
+                    'TTL': 120,
+                    'ResourceRecords': [{'Value': item['content']}],
+                },
+            })
+        for item in update:
+            changes.append({
+                'Action': 'UPSERT',
+                'ResourceRecordSet': {
+                    'Name': item['name'],
+                    'Type': 'A',
+                    'TTL': 120,
+                    'ResourceRecords': [{'Value': item['content']}],
+                },
+            })
+        for item in delete:
+            old = current.get(item['name'], {})
+            if old.get('content'):
+                changes.append({
+                    'Action': 'DELETE',
+                    'ResourceRecordSet': {
+                        'Name': item['name'],
+                        'Type': 'A',
+                        'TTL': 120,
+                        'ResourceRecords': [{'Value': old['content']}],
+                    },
+                })
+        if changes:
+            self.client.change_resource_record_sets(
+                HostedZoneId=self.hosted_zone_id,
+                ChangeBatch={'Changes': changes, 'Comment': 'sovereign_dns sync'},
+            )
+        return {'changes': changes}
+
+
+def build_provider(provider_name: str, zone_id: str, api_token: str | None = None):
+    provider_name = provider_name.lower()
+    if provider_name == 'cloudflare':
+        if not api_token:
+            raise ValueError('Cloudflare requires api_token')
+        return CloudflareDNSProvider(api_token=api_token, zone_id=zone_id)
+    if provider_name == 'route53':
+        return Route53DNSProvider(hosted_zone_id=zone_id)
+    raise ValueError(f'Unsupported provider: {provider_name}')
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description='Manage sovereign DNS A records via provider APIs')
+    sub = parser.add_subparsers(dest='command', required=True)
+
+    sync_p = sub.add_parser('sync', help='Sync desired domain->IP mapping to provider')
+    sync_p.add_argument('--mapping', default=str(DEFAULT_MAPPING_PATH))
+    sync_p.add_argument('--provider')
+    sync_p.add_argument('--zone-id')
+    sync_p.add_argument('--api-token-env', default='CLOUDFLARE_API_TOKEN')
+    sync_p.add_argument('--public-ip-url', default='https://api.ipify.org')
+
+    upsert_p = sub.add_parser('upsert', help='Create or update a single A record')
+    upsert_p.add_argument('--provider', required=True)
+    upsert_p.add_argument('--zone-id', required=True)
+    upsert_p.add_argument('--name', required=True)
+    upsert_p.add_argument('--content', required=True)
+    upsert_p.add_argument('--api-token-env', default='CLOUDFLARE_API_TOKEN')
+
+    delete_p = sub.add_parser('delete', help='Delete a single A record')
+    delete_p.add_argument('--provider', required=True)
+    delete_p.add_argument('--zone-id', required=True)
+    delete_p.add_argument('--name', required=True)
+    delete_p.add_argument('--api-token-env', default='CLOUDFLARE_API_TOKEN')
+
+    args = parser.parse_args()
+
+    if args.command == 'sync':
+        cfg = load_domain_mapping(args.mapping)
+        provider_name = args.provider or cfg.get('dns_provider', 'cloudflare')
+        zone_id = args.zone_id or cfg.get('dns_zone_id') or cfg.get('hosted_zone_id')
+        token = os.environ.get(args.api_token_env, '')
+        provider = build_provider(provider_name, zone_id=zone_id, api_token=token)
+        current = provider.list_a_records()
+        public_ip = detect_public_ip(service_url=args.public_ip_url)
+        desired = resolve_domain_ip_map(cfg['domain_ip_map'], current_public_ip=public_ip)
+        plan = build_sync_plan(current=current, desired=desired)
+        result = provider.apply_plan(**plan, current=current)
+        print(json.dumps({'provider': provider_name, 'zone_id': zone_id, 'public_ip': public_ip, 'plan': plan, 'result': result}, indent=2))
+        return 0
+
+    if args.command == 'upsert':
+        token = os.environ.get(args.api_token_env, '')
+        provider = build_provider(args.provider, zone_id=args.zone_id, api_token=token)
+        result = provider.upsert_a_record(args.name, args.content)
+        print(json.dumps(result, indent=2))
+        return 0
+
+    if args.command == 'delete':
+        token = os.environ.get(args.api_token_env, '')
+        provider = build_provider(args.provider, zone_id=args.zone_id, api_token=token)
+        current = provider.list_a_records()
+        record = current.get(args.name)
+        if not record:
+            raise SystemExit(f'No A record found for {args.name}')
+        if isinstance(provider, CloudflareDNSProvider):
+            result = provider.delete_record(record['id'])
+        else:
+            result = provider.apply_plan(create=[], update=[], delete=[{'name': args.name}], current=current)
+        print(json.dumps(result, indent=2))
+        return 0
+
+    raise SystemExit('Unknown command')
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

tests/test_genome_generated.py

@@ -1,737 +0,0 @@
-"""Auto-generated test suite -- Codebase Genome (#667).
-
-Generated by scripts/codebase_test_generator.py
-Coverage gaps identified from AST analysis.
-
-These tests are starting points. Review before merging.
-"""
-
-import pytest
-from unittest.mock import MagicMock, patch
-
-
-# AUTO-GENERATED -- DO NOT EDIT WITHOUT REVIEW
-
-class TestAngbandMcpServerGenerated:
-    """Auto-generated tests for angband/mcp_server.py."""
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:319
-    # Function: call_tool
-
-    @pytest.mark.asyncio
-    def test_angband_mcp_server_call_tool(self):
-        """Test call_tool -- auto-generated."""
-        try:
-            from angband.mcp_server import call_tool
-            result = call_tool(name='test', arguments=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:64
-    # Function: capture_screen
-
-    def test_angband_mcp_server_capture_screen(self):
-        """Test capture_screen -- auto-generated."""
-        try:
-            from angband.mcp_server import capture_screen
-            result = capture_screen(lines=None, session_name='test')
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:74
-    # Function: has_save
-
-    def test_angband_mcp_server_has_save(self):
-        """Test has_save -- auto-generated."""
-        try:
-            from angband.mcp_server import has_save
-            result = has_save(user=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:234
-    # Function: keypress
-
-    def test_angband_mcp_server_keypress(self):
-        """Test keypress -- auto-generated."""
-        try:
-            from angband.mcp_server import keypress
-            result = keypress(key='test_id', wait_ms=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:141
-    # Function: launch_game
-
-    def test_angband_mcp_server_launch_game(self):
-        """Test launch_game -- auto-generated."""
-        try:
-            from angband.mcp_server import launch_game
-            result = launch_game(user=None, new_game=None, continue_splash=None, width='test_id', height=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:253
-    # Function: list_tools
-
-    @pytest.mark.asyncio
-    def test_angband_mcp_server_list_tools(self):
-        """Test list_tools -- auto-generated."""
-        try:
-            from angband.mcp_server import list_tools
-            result = list_tools()
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:130
-    # Function: maybe_continue_splash
-
-    def test_angband_mcp_server_maybe_continue_splash(self):
-        """Test maybe_continue_splash -- auto-generated."""
-        try:
-            from angband.mcp_server import maybe_continue_splash
-            result = maybe_continue_splash(session_name='test')
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:226
-    # Function: observe
-
-    def test_angband_mcp_server_observe(self):
-        """Test observe -- auto-generated."""
-        try:
-            from angband.mcp_server import observe
-            result = observe(lines=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:57
-    # Function: pane_id
-
-    def test_angband_mcp_server_pane_id(self):
-        """Test pane_id -- auto-generated."""
-        try:
-            from angband.mcp_server import pane_id
-            result = pane_id(session_name='test')
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:108
-    # Function: send_key
-
-    def test_angband_mcp_server_send_key(self):
-        """Test send_key -- auto-generated."""
-        try:
-            from angband.mcp_server import send_key
-            with pytest.raises((RuntimeError)):
-                send_key(key='test_id', session_name='test')
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:123
-    # Function: send_text
-
-    def test_angband_mcp_server_send_text(self):
-        """Test send_text -- auto-generated."""
-        try:
-            from angband.mcp_server import send_text
-            with pytest.raises((RuntimeError)):
-                send_text(text='test msg', session_name='test')
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:53
-    # Function: session_exists
-
-    def test_angband_mcp_server_session_exists(self):
-        """Test session_exists -- auto-generated."""
-        try:
-            from angband.mcp_server import session_exists
-            result = session_exists(session_name='test')
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:203
-    # Function: stop_game
-
-    def test_angband_mcp_server_stop_game(self):
-        """Test stop_game -- auto-generated."""
-        try:
-            from angband.mcp_server import stop_game
-            result = stop_game()
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:46
-    # Function: tmux
-
-    def test_angband_mcp_server_tmux(self):
-        """Test tmux -- auto-generated."""
-        try:
-            from angband.mcp_server import tmux
-            with pytest.raises((RuntimeError)):
-                tmux(args=None, check=None)
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: angband/mcp_server.py:243
-    # Function: type_and_observe
-
-    def test_angband_mcp_server_type_and_observe(self):
-        """Test type_and_observe -- auto-generated."""
-        try:
-            from angband.mcp_server import type_and_observe
-            result = type_and_observe(text='test msg', wait_ms=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-
-class TestEvenniaTimmyWorldGameGenerated:
-    """Auto-generated tests for evennia/timmy_world/game.py."""
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/game.py:495
-    # Function: ActionSystem.get_available_actions
-
-    def test_evennia_timmy_world_game_ActionSystem_get_available_actions(self):
-        """Test ActionSystem.get_available_actions -- auto-generated."""
-        try:
-            from evennia.timmy_world.game import ActionSystem
-            obj = ActionSystem()
-            result = obj.get_available_actions(char_name='test', world=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/game.py:1485
-    # Function: PlayerInterface.get_available_actions
-
-    def test_evennia_timmy_world_game_PlayerInterface_get_available_actions(self):
-        """Test PlayerInterface.get_available_actions -- auto-generated."""
-        try:
-            from evennia.timmy_world.game import PlayerInterface
-            obj = PlayerInterface()
-            result = obj.get_available_actions()
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/game.py:55
-    # Function: get_narrative_phase
-
-    def test_evennia_timmy_world_game_get_narrative_phase(self):
-        """Test get_narrative_phase -- auto-generated."""
-        try:
-            from evennia.timmy_world.game import get_narrative_phase
-            result = get_narrative_phase(tick=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/game.py:65
-    # Function: get_phase_transition_event
-
-    def test_evennia_timmy_world_game_get_phase_transition_event(self):
-        """Test get_phase_transition_event -- auto-generated."""
-        try:
-            from evennia.timmy_world.game import get_phase_transition_event
-            result = get_phase_transition_event(old_phase=None, new_phase=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/game.py:347
-    # Function: World.get_room_desc
-
-    def test_evennia_timmy_world_game_World_get_room_desc(self):
-        """Test World.get_room_desc -- auto-generated."""
-        try:
-            from evennia.timmy_world.game import World
-            obj = World()
-            result = obj.get_room_desc(room_name='test', char_name='test')
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/game.py:1045
-    # Function: GameEngine.load_game
-
-    def test_evennia_timmy_world_game_GameEngine_load_game(self):
-        """Test GameEngine.load_game -- auto-generated."""
-        try:
-            from evennia.timmy_world.game import GameEngine
-            obj = GameEngine()
-            result = obj.load_game()
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/game.py:556
-    # Function: NPCAI.make_choice
-
-    def test_evennia_timmy_world_game_NPCAI_make_choice(self):
-        """Test NPCAI.make_choice -- auto-generated."""
-        try:
-            from evennia.timmy_world.game import NPCAI
-            obj = NPCAI()
-            result = obj.make_choice(char_name='test')
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/game.py:1454
-    # Function: GameEngine.play_turn
-
-    def test_evennia_timmy_world_game_GameEngine_play_turn(self):
-        """Test GameEngine.play_turn -- auto-generated."""
-        try:
-            from evennia.timmy_world.game import GameEngine
-            obj = GameEngine()
-            result = obj.play_turn(action=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/game.py:1076
-    # Function: GameEngine.run_tick
-
-    def test_evennia_timmy_world_game_GameEngine_run_tick(self):
-        """Test GameEngine.run_tick -- auto-generated."""
-        try:
-            from evennia.timmy_world.game import GameEngine
-            obj = GameEngine()
-            result = obj.run_tick(timmy_action=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-
-class TestEvenniaTimmyWorldServerConfWebPluginsGenerated:
-    """Auto-generated tests for evennia/timmy_world/server/conf/web_plugins.py."""
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/server/conf/web_plugins.py:31
-    # Function: at_webproxy_root_creation
-
-    def test_evennia_timmy_world_server_conf_web_plugins_at_webproxy_root_creation(self):
-        """Test at_webproxy_root_creation -- auto-generated."""
-        try:
-            from evennia.timmy_world.server.conf.web_plugins import at_webproxy_root_creation
-            result = at_webproxy_root_creation(web_root=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/server/conf/web_plugins.py:6
-    # Function: at_webserver_root_creation
-
-    def test_evennia_timmy_world_server_conf_web_plugins_at_webserver_root_creation(self):
-        """Test at_webserver_root_creation -- auto-generated."""
-        try:
-            from evennia.timmy_world.server.conf.web_plugins import at_webserver_root_creation
-            result = at_webserver_root_creation(web_root=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-
-class TestEvenniaTimmyWorldWorldGameGenerated:
-    """Auto-generated tests for evennia/timmy_world/world/game.py."""
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/world/game.py:400
-    # Function: ActionSystem.get_available_actions
-
-    def test_evennia_timmy_world_world_game_ActionSystem_get_available_actions(self):
-        """Test ActionSystem.get_available_actions -- auto-generated."""
-        try:
-            from evennia.timmy_world.world.game import ActionSystem
-            obj = ActionSystem()
-            result = obj.get_available_actions(char_name='test', world=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/world/game.py:1289
-    # Function: PlayerInterface.get_available_actions
-
-    def test_evennia_timmy_world_world_game_PlayerInterface_get_available_actions(self):
-        """Test PlayerInterface.get_available_actions -- auto-generated."""
-        try:
-            from evennia.timmy_world.world.game import PlayerInterface
-            obj = PlayerInterface()
-            result = obj.get_available_actions()
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/world/game.py:254
-    # Function: World.get_room_desc
-
-    def test_evennia_timmy_world_world_game_World_get_room_desc(self):
-        """Test World.get_room_desc -- auto-generated."""
-        try:
-            from evennia.timmy_world.world.game import World
-            obj = World()
-            result = obj.get_room_desc(room_name='test', char_name='test')
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/world/game.py:880
-    # Function: GameEngine.load_game
-
-    def test_evennia_timmy_world_world_game_GameEngine_load_game(self):
-        """Test GameEngine.load_game -- auto-generated."""
-        try:
-            from evennia.timmy_world.world.game import GameEngine
-            obj = GameEngine()
-            result = obj.load_game()
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/world/game.py:461
-    # Function: NPCAI.make_choice
-
-    def test_evennia_timmy_world_world_game_NPCAI_make_choice(self):
-        """Test NPCAI.make_choice -- auto-generated."""
-        try:
-            from evennia.timmy_world.world.game import NPCAI
-            obj = NPCAI()
-            result = obj.make_choice(char_name='test')
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/world/game.py:1258
-    # Function: GameEngine.play_turn
-
-    def test_evennia_timmy_world_world_game_GameEngine_play_turn(self):
-        """Test GameEngine.play_turn -- auto-generated."""
-        try:
-            from evennia.timmy_world.world.game import GameEngine
-            obj = GameEngine()
-            result = obj.play_turn(action=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/world/game.py:911
-    # Function: GameEngine.run_tick
-
-    def test_evennia_timmy_world_world_game_GameEngine_run_tick(self):
-        """Test GameEngine.run_tick -- auto-generated."""
-        try:
-            from evennia.timmy_world.world.game import GameEngine
-            obj = GameEngine()
-            result = obj.run_tick(timmy_action=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia/timmy_world/world/game.py:749
-    # Function: DialogueSystem.select
-
-    def test_evennia_timmy_world_world_game_DialogueSystem_select(self):
-        """Test DialogueSystem.select -- auto-generated."""
-        try:
-            from evennia.timmy_world.world.game import DialogueSystem
-            obj = DialogueSystem()
-            result = obj.select(char_name='test', listener=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-
-class TestEvenniaToolsLayoutGenerated:
-    """Auto-generated tests for evennia_tools/layout.py."""
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia_tools/layout.py:58
-    # Function: grouped_exits
-
-    def test_evennia_tools_layout_grouped_exits(self):
-        """Test grouped_exits -- auto-generated."""
-        try:
-            from evennia_tools.layout import grouped_exits
-            result = grouped_exits()
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia_tools/layout.py:54
-    # Function: room_keys
-
-    def test_evennia_tools_layout_room_keys(self):
-        """Test room_keys -- auto-generated."""
-        try:
-            from evennia_tools.layout import room_keys
-            result = room_keys()
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-
-class TestEvenniaToolsTelemetryGenerated:
-    """Auto-generated tests for evennia_tools/telemetry.py."""
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia_tools/telemetry.py:8
-    # Function: telemetry_dir
-
-    def test_evennia_tools_telemetry_telemetry_dir(self):
-        """Test telemetry_dir -- auto-generated."""
-        try:
-            from evennia_tools.telemetry import telemetry_dir
-            result = telemetry_dir(base_dir='/tmp/test')
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-
-class TestEvenniaToolsTrainingGenerated:
-    """Auto-generated tests for evennia_tools/training.py."""
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia_tools/training.py:18
-    # Function: example_eval_path
-
-    def test_evennia_tools_training_example_eval_path(self):
-        """Test example_eval_path -- auto-generated."""
-        try:
-            from evennia_tools.training import example_eval_path
-            result = example_eval_path(repo_root=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evennia_tools/training.py:14
-    # Function: example_trace_path
-
-    def test_evennia_tools_training_example_trace_path(self):
-        """Test example_trace_path -- auto-generated."""
-        try:
-            from evennia_tools.training import example_trace_path
-            result = example_trace_path(repo_root=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-
-class TestEvolutionBitcoinScripterGenerated:
-    """Auto-generated tests for evolution/bitcoin_scripter.py."""
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evolution/bitcoin_scripter.py:18
-    # Function: BitcoinScripter.generate_script
-
-    def test_evolution_bitcoin_scripter_BitcoinScripter_generate_script(self):
-        """Test BitcoinScripter.generate_script -- auto-generated."""
-        try:
-            from evolution.bitcoin_scripter import BitcoinScripter
-            obj = BitcoinScripter()
-            result = obj.generate_script(requirements=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-
-class TestEvolutionLightningClientGenerated:
-    """Auto-generated tests for evolution/lightning_client.py."""
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evolution/lightning_client.py:18
-    # Function: LightningClient.plan_payment_route
-
-    def test_evolution_lightning_client_LightningClient_plan_payment_route(self):
-        """Test LightningClient.plan_payment_route -- auto-generated."""
-        try:
-            from evolution.lightning_client import LightningClient
-            obj = LightningClient()
-            result = obj.plan_payment_route(destination=None, amount_sats=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-
-class TestEvolutionSovereignAccountantGenerated:
-    """Auto-generated tests for evolution/sovereign_accountant.py."""
-
-    # AUTO-GENERATED -- review before merging
-    # Source: evolution/sovereign_accountant.py:17
-    # Function: SovereignAccountant.generate_financial_report
-
-    def test_evolution_sovereign_accountant_SovereignAccountant_generate_financial_report(self):
-        """Test SovereignAccountant.generate_financial_report -- auto-generated."""
-        try:
-            from evolution.sovereign_accountant import SovereignAccountant
-            obj = SovereignAccountant()
-            result = obj.generate_financial_report(transaction_history=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-
-class TestInfrastructureTimmyBridgeClientTimmyClientGenerated:
-    """Auto-generated tests for infrastructure/timmy-bridge/client/timmy_client.py."""
-
-    # AUTO-GENERATED -- review before merging
-    # Source: infrastructure/timmy-bridge/client/timmy_client.py:108
-    # Function: TimmyClient.create_artifact
-
-    def test_infrastructure_timmy_bridge_client_timmy_client_TimmyClient_create_artifact(self):
-        """Test TimmyClient.create_artifact -- auto-generated."""
-        try:
-            from infrastructure.timmy_bridge.client.timmy_client import TimmyClient
-            obj = TimmyClient()
-            result = obj.create_artifact()
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: infrastructure/timmy-bridge/client/timmy_client.py:167
-    # Function: TimmyClient.create_event
-
-    def test_infrastructure_timmy_bridge_client_timmy_client_TimmyClient_create_event(self):
-        """Test TimmyClient.create_event -- auto-generated."""
-        try:
-            from infrastructure.timmy_bridge.client.timmy_client import TimmyClient
-            obj = TimmyClient()
-            result = obj.create_event(kind=None, content=None, tags=None)
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: infrastructure/timmy-bridge/client/timmy_client.py:74
-    # Function: TimmyClient.generate_observation
-
-    def test_infrastructure_timmy_bridge_client_timmy_client_TimmyClient_generate_observation(self):
-        """Test TimmyClient.generate_observation -- auto-generated."""
-        try:
-            from infrastructure.timmy_bridge.client.timmy_client import TimmyClient
-            obj = TimmyClient()
-            result = obj.generate_observation()
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-
-class TestInfrastructureTimmyBridgeMlxMlxIntegrationGenerated:
-    """Auto-generated tests for infrastructure/timmy-bridge/mlx/mlx_integration.py."""
-
-    # AUTO-GENERATED -- review before merging
-    # Source: infrastructure/timmy-bridge/mlx/mlx_integration.py:122
-    # Function: MLXInference.available
-
-    def test_infrastructure_timmy_bridge_mlx_mlx_integration_MLXInference_available(self):
-        """Test MLXInference.available -- auto-generated."""
-        try:
-            from infrastructure.timmy_bridge.mlx.mlx_integration import MLXInference
-            obj = MLXInference()
-            _ = obj.available
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: infrastructure/timmy-bridge/mlx/mlx_integration.py:125
-    # Function: MLXInference.get_stats
-
-    def test_infrastructure_timmy_bridge_mlx_mlx_integration_MLXInference_get_stats(self):
-        """Test MLXInference.get_stats -- auto-generated."""
-        try:
-            from infrastructure.timmy_bridge.mlx.mlx_integration import MLXInference
-            obj = MLXInference()
-            result = obj.get_stats()
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: infrastructure/timmy-bridge/mlx/mlx_integration.py:30
-    # Function: MLXInference.load_model
-
-    def test_infrastructure_timmy_bridge_mlx_mlx_integration_MLXInference_load_model(self):
-        """Test MLXInference.load_model -- auto-generated."""
-        try:
-            from infrastructure.timmy_bridge.mlx.mlx_integration import MLXInference
-            obj = MLXInference()
-            result = obj.load_model(model_path='/tmp/test')
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: infrastructure/timmy-bridge/mlx/mlx_integration.py:93
-    # Function: MLXInference.reflect
-
-    def test_infrastructure_timmy_bridge_mlx_mlx_integration_MLXInference_reflect(self):
-        """Test MLXInference.reflect -- auto-generated."""
-        try:
-            from infrastructure.timmy_bridge.mlx.mlx_integration import MLXInference
-            obj = MLXInference()
-            result = obj.reflect()
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')
-
-    # AUTO-GENERATED -- review before merging
-    # Source: infrastructure/timmy-bridge/mlx/mlx_integration.py:108
-    # Function: MLXInference.respond_to
-
-    def test_infrastructure_timmy_bridge_mlx_mlx_integration_MLXInference_respond_to(self):
-        """Test MLXInference.respond_to -- auto-generated."""
-        try:
-            from infrastructure.timmy_bridge.mlx.mlx_integration import MLXInference
-            obj = MLXInference()
-            result = obj.respond_to(message='test msg', context='test msg')
-            assert result is not None or result is None  # Placeholder
-        except ImportError:
-            pytest.skip('Module not importable')

tests/test_sovereign_dns.py

@@ -0,0 +1,163 @@
+import json
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / 'scripts'))
+
+from sovereign_dns import (
+    CloudflareDNSProvider,
+    Route53DNSProvider,
+    build_sync_plan,
+    detect_public_ip,
+    load_domain_mapping,
+    resolve_domain_ip_map,
+)
+
+
+def test_load_domain_mapping_reads_ansible_style_domain_to_ip_map(tmp_path):
+    cfg = tmp_path / 'dns_records.yaml'
+    cfg.write_text(
+        """
+        dns_provider: cloudflare
+        dns_zone_id: zone-123
+        domain_ip_map:
+          forge.example.com: 1.2.3.4
+          matrix.example.com: 5.6.7.8
+        """
+    )
+
+    loaded = load_domain_mapping(cfg)
+
+    assert loaded['dns_provider'] == 'cloudflare'
+    assert loaded['dns_zone_id'] == 'zone-123'
+    assert loaded['domain_ip_map'] == {
+        'forge.example.com': '1.2.3.4',
+        'matrix.example.com': '5.6.7.8',
+    }
+
+
+def test_build_sync_plan_updates_changed_ip_and_creates_missing_records():
+    current = {
+        'forge.example.com': {'id': 'rec-1', 'content': '1.1.1.1'},
+        'old.example.com': {'id': 'rec-2', 'content': '9.9.9.9'},
+    }
+    desired = {
+        'forge.example.com': '2.2.2.2',
+        'new.example.com': '3.3.3.3',
+    }
+
+    plan = build_sync_plan(current=current, desired=desired)
+
+    assert plan['update'] == [
+        {'name': 'forge.example.com', 'id': 'rec-1', 'content': '2.2.2.2'}
+    ]
+    assert plan['create'] == [
+        {'name': 'new.example.com', 'content': '3.3.3.3'}
+    ]
+    assert plan['delete'] == [
+        {'name': 'old.example.com', 'id': 'rec-2'}
+    ]
+
+
+def test_resolve_domain_ip_map_replaces_auto_values_with_detected_public_ip():
+    resolved = resolve_domain_ip_map(
+        {
+            'forge.example.com': 'auto',
+            'matrix.example.com': '5.6.7.8',
+        },
+        current_public_ip='8.8.4.4',
+    )
+
+    assert resolved == {
+        'forge.example.com': '8.8.4.4',
+        'matrix.example.com': '5.6.7.8',
+    }
+
+
+def test_detect_public_ip_reads_provider_response():
+    class FakeResponse:
+        def __enter__(self):
+            return self
+        def __exit__(self, exc_type, exc, tb):
+            return False
+        def read(self):
+            return b'4.3.2.1\n'
+
+    ip = detect_public_ip(lambda req, timeout=10: FakeResponse())
+    assert ip == '4.3.2.1'
+
+
+def test_cloudflare_upsert_calls_expected_http_methods():
+    calls = []
+
+    def fake_request(method, path, payload=None):
+        calls.append({'method': method, 'path': path, 'payload': payload})
+        if method == 'GET':
+            return {'success': True, 'result': []}
+        return {'success': True, 'result': {'id': 'created-id'}}
+
+    provider = CloudflareDNSProvider(
+        api_token='tok',
+        zone_id='zone-1',
+        request_fn=fake_request,
+    )
+
+    provider.upsert_a_record('forge.example.com', '1.2.3.4')
+
+    assert calls[0]['method'] == 'GET'
+    assert calls[0]['path'] == '/zones/zone-1/dns_records?type=A&name=forge.example.com'
+    assert calls[1]['method'] == 'POST'
+    assert calls[1]['path'] == '/zones/zone-1/dns_records'
+    assert calls[1]['payload']['name'] == 'forge.example.com'
+    assert calls[1]['payload']['content'] == '1.2.3.4'
+    assert calls[1]['payload']['type'] == 'A'
+
+
+def test_cloudflare_upsert_updates_when_record_exists():
+    calls = []
+
+    def fake_request(method, path, payload=None):
+        calls.append({'method': method, 'path': path, 'payload': payload})
+        if method == 'GET':
+            return {'success': True, 'result': [{'id': 'rec-123', 'content': '1.1.1.1'}]}
+        return {'success': True, 'result': {'id': 'rec-123'}}
+
+    provider = CloudflareDNSProvider(
+        api_token='tok',
+        zone_id='zone-1',
+        request_fn=fake_request,
+    )
+
+    provider.upsert_a_record('forge.example.com', '2.2.2.2')
+
+    assert calls[1]['method'] == 'PUT'
+    assert calls[1]['path'] == '/zones/zone-1/dns_records/rec-123'
+    assert calls[1]['payload']['content'] == '2.2.2.2'
+
+
+def test_route53_sync_uses_change_batches():
+    batches = []
+
+    class FakeClient:
+        def change_resource_record_sets(self, HostedZoneId, ChangeBatch):
+            batches.append({'HostedZoneId': HostedZoneId, 'ChangeBatch': ChangeBatch})
+            return {'ChangeInfo': {'Status': 'PENDING'}}
+
+    provider = Route53DNSProvider(hosted_zone_id='ZONE123', client=FakeClient())
+    provider.apply_plan(
+        create=[{'name': 'new.example.com', 'content': '3.3.3.3'}],
+        update=[{'name': 'forge.example.com', 'id': 'ignored', 'content': '2.2.2.2'}],
+        delete=[{'name': 'old.example.com', 'id': 'ignored'}],
+        current={'old.example.com': {'content': '9.9.9.9'}},
+    )
+
+    batch = batches[0]
+    assert batch['HostedZoneId'] == 'ZONE123'
+    changes = batch['ChangeBatch']['Changes']
+    assert changes[0]['Action'] == 'CREATE'
+    assert changes[0]['ResourceRecordSet']['Name'] == 'new.example.com'
+    assert changes[1]['Action'] == 'UPSERT'
+    assert changes[1]['ResourceRecordSet']['Name'] == 'forge.example.com'
+    assert changes[2]['Action'] == 'DELETE'
+    assert changes[2]['ResourceRecordSet']['Name'] == 'old.example.com'