Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

37.4 KB
Raw Blame
"""Data (app-to-database) contract extraction tests.

Table-name normalization is tested first and hardest: it is where the false
links would come from (quoting, schema prefixes, case). Then per-dialect
provider/consumer extraction, then the cross-repo end-to-end match.
"""

from __future__ import annotations

from pathlib import Path

from repowise.core.workspace.contracts import normalize_contract_id
from repowise.core.workspace.extractors.data import DataExtractor
from repowise.core.workspace.extractors.data.names import (
    is_system_table,
    normalize_table_name,
    split_qualified,
)
from repowise.core.workspace.matching import match_contracts
from repowise.core.workspace.system_graph import edge_kind_for_contract_type


class TestNormalizeTableName:
    def test_bare_lowercase_passthrough(self) -> None:
        assert normalize_table_name("users") == "users"

    def test_case_folds(self) -> None:
        assert normalize_table_name("Users") == "users"

    def test_double_quotes_stripped(self) -> None:
        assert normalize_table_name('"Users"') == "users"

    def test_backticks_stripped(self) -> None:
        assert normalize_table_name("`users`") == "users"

    def test_brackets_stripped(self) -> None:
        assert normalize_table_name("[Users]") == "users"

    def test_default_schema_dropped(self) -> None:
        assert normalize_table_name("public.users") == "users"
        assert normalize_table_name("dbo.Users") == "users"

    def test_named_schema_kept(self) -> None:
        assert normalize_table_name("analytics.events") == "analytics.events"

    def test_quoted_qualified(self) -> None:
        assert normalize_table_name('"public"."Users"') == "users"
        assert normalize_table_name("[dbo].[Orders]") == "orders"

    def test_three_part_name_keeps_last_two(self) -> None:
        assert normalize_table_name("mydb.analytics.events") == "analytics.events"

    def test_temp_table_rejected(self) -> None:
        assert normalize_table_name("#tmp_orders") is None

    def test_interpolation_rejected(self) -> None:
        assert normalize_table_name("{table}") is None
        assert normalize_table_name("${TABLE}") is None
        assert normalize_table_name("%s") is None

    def test_empty_rejected(self) -> None:
        assert normalize_table_name("") is None

    def test_split_qualified(self) -> None:
        assert split_qualified("a.b") == ("a", "b")
        assert split_qualified("b") == (None, "b")

    def test_is_system_table(self) -> None:
        for sys_tbl in (
            "pg_database",
            "pg_roles",
            "pg_class",
            "pg_catalog.pg_tables",
            "pg_catalog.custom_view",
            "information_schema.tables",
            "information_schema.columns",
            "alembic_version",
            "core.alembic_version",
        ):
            assert is_system_table(sys_tbl), sys_tbl
        for user_tbl in ("users", "page_views", "pgadmin", "analytics.events"):
            assert not is_system_table(user_tbl), user_tbl


def _write(repo: Path, rel: str, content: str) -> None:
    path = repo / rel
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(content, encoding="utf-8")


class TestDdlProviders:
    def test_create_table_and_view(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "schema.sql",
            """
            CREATE TABLE users (id INT PRIMARY KEY, email TEXT);
            CREATE VIEW active_users AS SELECT * FROM users WHERE active;
            CREATE INDEX idx_users_email ON users(email);
            """,
        )
        contracts = DataExtractor().extract(tmp_path, "db")
        providers = {c.contract_id for c in contracts if c.role == "provider"}
        assert "data::users" in providers
        assert "data::active_users" in providers
        # INDEX attaches to a table; it declares none.
        assert not any("idx_users_email" in c for c in providers)

    def test_schema_qualified_and_quoted(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "migrations/001_init.sql",
            'CREATE TABLE "public"."Orders" (id INT);\nCREATE TABLE analytics.events (id INT);\n',
        )
        contracts = DataExtractor().extract(tmp_path, "db")
        ids = {c.contract_id for c in contracts}
        assert "data::orders" in ids
        assert "data::analytics.events" in ids

    def test_alter_table_is_provider(self, tmp_path: Path) -> None:
        _write(tmp_path, "migrations/002_add.sql", "ALTER TABLE users ADD COLUMN age INT;")
        contracts = DataExtractor().extract(tmp_path, "db")
        assert any(c.contract_id == "data::users" and c.role == "provider" for c in contracts)

    def test_malformed_sql_yields_nothing(self, tmp_path: Path) -> None:
        _write(tmp_path, "broken.sql", "CREATE TABLE ((((( ;;; garbage !!")
        contracts = DataExtractor().extract(tmp_path, "db")
        assert contracts == []


class TestOrmProviders:
    def test_sqlalchemy_tablename(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/models.py",
            'class User(Base):\n    __tablename__ = "users"\n',
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        assert any(c.contract_id == "data::users" and c.role == "provider" for c in contracts)

    def test_alembic_create_table(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "alembic/versions/abc_init.py",
            'def upgrade():\n    op.create_table("orders", sa.Column("id", sa.Integer))\n',
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        (orders,) = [c for c in contracts if c.contract_id == "data::orders"]
        # A migration defines the schema, which marks the owning repo.
        assert orders.meta["schema"] == "create"

    def test_alembic_create_table_records_the_schema_keyword(self, tmp_path: Path) -> None:
        # `schema=` trails the column list, so the name has to come off the
        # call's argument list rather than the string right after the paren.
        _write(
            tmp_path,
            "alembic/versions/abc_init.py",
            "def upgrade():\n"
            "    op.create_table(\n"
            '        "owners",\n'
            '        sa.Column("id", sa.Integer, primary_key=True),\n'
            '        schema="core",\n'
            "    )\n",
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        ids = {c.contract_id for c in contracts}
        assert "data::core.owners" in ids
        # The bare key must go: it is what let the two sides drift apart.
        assert "data::owners" not in ids

    def test_alembic_schema_keyword_matches_the_qualified_sql_consumer(
        self, tmp_path: Path
    ) -> None:
        # The end-to-end shape from the issue: a schema-qualified migration and
        # a schema-qualified consumer previously never met (2 of 48 consumers).
        backend = tmp_path / "backend"
        worker = tmp_path / "worker"
        _write(
            backend,
            "alembic/versions/abc_init.py",
            'def upgrade():\n    op.create_table("owners", sa.Column("id"), schema="core")\n',
        )
        _write(worker, "jobs/process.py", 'q = "SELECT id FROM core.owners WHERE done = 0"\n')

        contracts = DataExtractor().extract(backend, "backend")
        contracts += DataExtractor().extract(worker, "worker")
        links = match_contracts(contracts)

        assert len(links) == 1
        assert links[0].provider_repo == "backend"
        assert links[0].consumer_repo == "worker"

    def test_alembic_default_schema_keyword_still_normalizes_away(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "alembic/versions/abc_init.py",
            'op.create_table("owners", sa.Column("id"), schema="public")\n',
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        assert "data::owners" in {c.contract_id for c in contracts}

    def test_alembic_schema_keyword_does_not_leak_to_the_next_call(
        self, tmp_path: Path
    ) -> None:
        _write(
            tmp_path,
            "alembic/versions/abc_init.py",
            "def upgrade():\n"
            '    op.create_table("owners", sa.Column("id"), schema="core")\n'
            '    op.create_table("visits", sa.Column("id"))\n',
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        ids = {c.contract_id for c in contracts}
        assert {"data::core.owners", "data::visits"} <= ids

    def test_alembic_schema_in_another_statement_does_not_leak(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "alembic/versions/abc_init.py",
            'op.create_table("owners", sa.Column("id"))\n'
            'op.execute(sa.text(\'ALTER TABLE x SET SCHEMA "core"\'))\n',
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        assert "data::owners" in {c.contract_id for c in contracts}

    def test_sqlmodel_table_true(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/models.py",
            "class HeroTeam(SQLModel, table=True):\n    id: int\n",
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        # SQLModel default table name is the class name lower-cased.
        assert any(c.contract_id == "data::heroteam" for c in contracts)

    def test_django_db_table(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/models.py",
            "class Order(models.Model):\n    class Meta:\n        db_table = 'shop_orders'\n",
        )
        contracts = DataExtractor().extract(tmp_path, "shop")
        assert any(c.contract_id == "data::shop_orders" for c in contracts)

    def test_jpa_table_annotation(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "src/main/java/User.java",
            '@Entity\n@Table(name = "app_users")\npublic class User {}\n',
        )
        contracts = DataExtractor().extract(tmp_path, "svc")
        assert any(c.contract_id == "data::app_users" for c in contracts)

    def test_jpa_entity_class_convention(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "src/main/java/OrderItem.java",
            "@Entity\npublic class OrderItem {}\n",
        )
        contracts = DataExtractor().extract(tmp_path, "svc")
        match = [c for c in contracts if c.contract_id == "data::order_item"]
        assert match and match[0].confidence < 0.85

    def test_efcore_dbset_and_table_attr(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "Data/AppDbContext.cs",
            "public class AppDbContext : DbContext {\n"
            "    public DbSet<User> Users { get; set; }\n"
            "}\n",
        )
        _write(tmp_path, "Models/Legacy.cs", '[Table("legacy_orders")]\npublic class Legacy {}\n')
        contracts = DataExtractor().extract(tmp_path, "svc")
        ids = {c.contract_id for c in contracts}
        assert "data::users" in ids
        assert "data::legacy_orders" in ids

    def test_activerecord_convention_and_override(self, tmp_path: Path) -> None:
        _write(tmp_path, "app/models/blog_post.rb", "class BlogPost < ApplicationRecord\nend\n")
        _write(
            tmp_path,
            "app/models/legacy.rb",
            "class Legacy < ApplicationRecord\n  self.table_name = 'old_stuff'\nend\n",
        )
        contracts = DataExtractor().extract(tmp_path, "rails")
        ids = {c.contract_id for c in contracts}
        assert "data::blog_posts" in ids
        assert "data::old_stuff" in ids

    def test_eloquent_table_property(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/Models/Order.php",
            "<?php\nclass Order extends Model {\n    protected $table = 'orders';\n}\n",
        )
        contracts = DataExtractor().extract(tmp_path, "shop")
        assert any(c.contract_id == "data::orders" for c in contracts)


class TestSqlStringConsumers:
    def test_parseable_select(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/queries.py",
            'q = "SELECT id, email FROM users WHERE active = 1"\n',
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        consumers = [c for c in contracts if c.role == "consumer"]
        assert [c.contract_id for c in consumers] == ["data::users"]
        assert consumers[0].meta["verb"] == "select"

    def test_quoted_table_inside_single_quoted_literal(self, tmp_path: Path) -> None:
        # The inner double quotes must stay part of the single-quoted literal;
        # lexing them as their own string turns the alias into a phantom
        # table (found live: data::u from JOIN "user" u).
        _write(
            tmp_path,
            "app/report.py",
            "q = 'SELECT i.id FROM item i JOIN \"user\" u ON i.owner_id = u.id'\n",
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        ids = {c.contract_id for c in contracts if c.role == "consumer"}
        assert ids == {"data::item", "data::user"}

    def test_join_tables_all_captured(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/queries.go",
            'var q = "SELECT o.id FROM orders o JOIN customers c ON o.cid = c.id"\n',
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        ids = {c.contract_id for c in contracts if c.role == "consumer"}
        assert ids == {"data::orders", "data::customers"}

    def test_interpolated_query_falls_back_to_regex(self, tmp_path: Path) -> None:
        # %s placeholder breaks the sqlglot parse; the verb-anchored regex
        # still recovers the literal table token.
        _write(
            tmp_path,
            "app/db.py",
            'q = "UPDATE orders SET state = %s WHERE id = %s"\n',
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        consumers = [c for c in contracts if c.role == "consumer"]
        assert [c.contract_id for c in consumers] == ["data::orders"]

    def test_interpolated_table_name_skipped(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/db.py",
            'q = f"SELECT * FROM {table} WHERE id = 1"\n',
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        assert [c for c in contracts if c.role == "consumer"] == []

    def test_prose_comment_not_matched(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/notes.py",
            '"""Select the widest rows from users and update the cache."""\n'
            "# fetch data from the users service\n",
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        assert contracts == []

    def test_insert_and_delete_verbs(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/db.ts",
            "const a = `INSERT INTO audit_log (id) VALUES (1)`;\n"
            "const b = `DELETE FROM sessions WHERE expired = true`;\n",
        )
        contracts = DataExtractor().extract(tmp_path, "web")
        by_id = {c.contract_id: c for c in contracts if c.role == "consumer"}
        assert set(by_id) == {"data::audit_log", "data::sessions"}
        assert by_id["data::audit_log"].meta["verb"] == "insert"
        assert by_id["data::sessions"].meta["verb"] == "delete"

    def test_test_files_excluded_by_default(self, tmp_path: Path) -> None:
        from repowise.core.workspace.extractors.base import make_exclude_predicate

        _write(tmp_path, "tests/test_db.py", 'q = "SELECT id FROM users WHERE x = 1"\n')
        contracts = DataExtractor().extract(tmp_path, "api", make_exclude_predicate())
        assert contracts == []

    def test_jpql_skipped_in_java_and_kotlin(self, tmp_path: Path) -> None:
        # JPQL queries (@Query without nativeQuery = true, @NamedQuery, and
        # createQuery) target entity classes rather than database tables. They
        # must emit no consumers, while native queries (@Query with
        # nativeQuery = true, and createNativeQuery) still emit table targets.
        _write(
            tmp_path,
            "shipping/CityRepository.java",
            '@Query("select c from City c where c.active = true")\n'
            "List<City> findActive();\n"
            '@NamedQuery(name = "findAll", query = "SELECT c FROM City c")\n'
            "class CityRepo {\n"
            "    void find(EntityManager em) {\n"
            '        em.createQuery("SELECT c FROM City c", City.class);\n'
            "    }\n"
            "}\n",
        )
        _write(
            tmp_path,
            "catalog/ProductRepository.java",
            '@Query(value = "SELECT * FROM products WHERE sku = ?1", nativeQuery = true)\n'
            "Product findBySku(String sku);\n"
            "class ProductRepo {\n"
            "    void find(EntityManager em) {\n"
            '        em.createNativeQuery("SELECT * FROM products", Product.class);\n'
            "    }\n"
            "}\n",
        )
        _write(
            tmp_path,
            "shipping/CityRepository.kt",
            '@Query("SELECT c FROM City c")\nfun findCities(): List<City>\n',
        )
        contracts = DataExtractor().extract(tmp_path, "service")
        consumers = [c for c in contracts if c.role == "consumer"]
        assert {c.contract_id for c in consumers} == {"data::products"}

    def test_native_query_variations_and_jdbc_preserved(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/NativeRepo.java",
            '@Query(nativeQuery = true, value = "SELECT id FROM orders WHERE active = true")\n'
            "List<Order> findActive();\n"
            '@Query("SELECT * FROM customers WHERE id = ?1", nativeQuery = true)\n'
            "Customer findCust(Long id);\n"
            "class JdbcWork {\n"
            "    void run(JdbcTemplate jdbc) {\n"
            '        jdbc.query("SELECT * FROM audit_log", mapper);\n'
            "    }\n"
            "}\n",
        )
        contracts = DataExtractor().extract(tmp_path, "app")
        consumers = [c for c in contracts if c.role == "consumer"]
        assert {c.contract_id for c in consumers} == {
            "data::orders",
            "data::customers",
            "data::audit_log",
        }

    def test_system_catalogs_and_alembic_version_skipped(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "scripts/promote.py",
            'q1 = "SELECT datname FROM pg_database WHERE datistemplate = false"\n'
            'q2 = "SELECT rolname FROM pg_roles WHERE rolcanlogin = true"\n'
            'q3 = "SELECT relname FROM pg_class WHERE relkind = \'r\'"\n'
            'q4 = "SELECT table_name FROM information_schema.tables WHERE table_schema = \'public\'"\n'
            'q5 = "SELECT version_num FROM alembic_version"\n'
            'q6 = "SELECT nspname FROM pg_catalog.pg_namespace"\n'
            'q7 = "SELECT id FROM orders WHERE promoted = true"\n',
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        consumers = [c for c in contracts if c.role == "consumer"]
        assert [c.contract_id for c in consumers] == ["data::orders"]

    def test_csharp_verbatim_sql(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "src/Verbatim.cs",
            'const string sql = @"\n'
            "    SELECT *\n"
            "    FROM Orders o\n"
            "    JOIN Customers c ON o.CustomerId = c.Id\n"
            '";\n',
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        ids = {c.contract_id for c in contracts if c.role == "consumer"}
        assert ids == {"data::orders", "data::customers"}


class TestMyBatisConsumers:
    def test_mybatis_mapper_xml(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "src/main/resources/OrderMapper.xml",
            """<?xml version="1.0" encoding="UTF-8" ?>
            <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
            <mapper namespace="com.shop.mapper.OrderMapper">
                <select id="findOrders">
                    SELECT * FROM orders WHERE id = #{id}
                </select>
                <select id="findLines">
                    SELECT * FROM order_lines WHERE order_id = #{orderId}
                </select>
                <!--
                <select id="deletedOrders">
                    SELECT * FROM archived_orders
                </select>
                -->
            </mapper>
            """,
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        ids = {c.contract_id for c in contracts if c.role == "consumer"}
        assert ids == {"data::orders", "data::order_lines"}

    def test_mybatis_array_annotation(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "src/main/java/com/shop/mapper/CustomerMapper.java",
            """package com.shop.mapper;
            public interface CustomerMapper {
                @Update({
                    "UPDATE customers",
                    "SET name = #{name}",
                    "WHERE id = #{id}"
                })
                int update(Customer c);
            }
            """,
        )
        contracts = DataExtractor().extract(tmp_path, "api")
        ids = {c.contract_id for c in contracts if c.role == "consumer"}
        assert ids == {"data::customers"}


class TestDataMatching:
    def test_normalize_contract_id_lowercases(self) -> None:
        assert normalize_contract_id("data::Users") == "data::users"

    def test_edge_kind_is_db(self) -> None:
        assert edge_kind_for_contract_type("data") == "db"

    def test_cross_repo_link(self, tmp_path: Path) -> None:
        backend = tmp_path / "backend"
        worker = tmp_path / "worker"
        _write(backend, "migrations/001.sql", "CREATE TABLE orders (id INT);")
        _write(worker, "jobs/process.py", 'q = "SELECT id FROM orders WHERE done = 0"\n')

        contracts = DataExtractor().extract(backend, "backend")
        contracts += DataExtractor().extract(worker, "worker")
        links = match_contracts(contracts)

        assert len(links) == 1
        link = links[0]
        assert link.contract_type == "data"
        assert link.provider_repo == "backend"
        assert link.consumer_repo == "worker"
        assert link.match_type == "exact"

    def test_same_repo_not_linked(self, tmp_path: Path) -> None:
        repo = tmp_path / "app"
        _write(repo, "schema.sql", "CREATE TABLE orders (id INT);")
        _write(repo, "db.py", 'q = "SELECT id FROM orders WHERE done = 0"\n')
        contracts = DataExtractor().extract(repo, "app")
        assert match_contracts(contracts) == []

    def test_quoting_and_schema_survive_matching(self, tmp_path: Path) -> None:
        backend = tmp_path / "backend"
        worker = tmp_path / "worker"
        _write(backend, "schema.sql", 'CREATE TABLE "public"."Orders" (id INT);')
        _write(worker, "job.py", 'q = "SELECT id FROM orders WHERE x = 1"\n')
        contracts = DataExtractor().extract(backend, "backend")
        contracts += DataExtractor().extract(worker, "worker")
        assert len(match_contracts(contracts)) == 1

    def test_embedded_database_reader_not_linked_across_repos(self, tmp_path: Path) -> None:
        # A table name shared with another repo's server schema is a second
        # database when the reader opens a SQLite file of its own.
        backend = tmp_path / "backend"
        tool = tmp_path / "tool"
        _write(backend, "migrations/001.sql", "CREATE TABLE repos (id INT);")
        _write(
            tool,
            "store.py",
            'import sqlite3\nq = "SELECT id FROM repos WHERE x = 1"\n',
        )
        _write(
            tool,
            "web/db.ts",
            "import Database from 'better-sqlite3';\n"
            "const q = 'SELECT id FROM repos WHERE x = 1';\n",
        )
        consumers = DataExtractor().extract(tool, "tool")
        assert [c.meta.get("embedded") for c in consumers] == ["sqlite", "sqlite"]
        contracts = DataExtractor().extract(backend, "backend") + consumers
        assert match_contracts(contracts) == []

    def test_embedded_database_reader_linked_within_its_repo(self, tmp_path: Path) -> None:
        from repowise.core.workspace.matching.data import accepts

        repo = tmp_path / "app"
        _write(repo, "schema.sql", "CREATE TABLE repos (id INT);")
        _write(repo, "store.py", 'import sqlite3\nq = "SELECT id FROM repos WHERE x = 1"\n')
        contracts = DataExtractor().extract(repo, "app")
        (consumer,) = [c for c in contracts if c.role == "consumer"]
        (provider,) = [c for c in contracts if c.role == "provider"]
        assert consumer.meta.get("embedded") == "sqlite"
        assert accepts(provider, consumer)

    def test_server_database_reader_still_linked_across_repos(self, tmp_path: Path) -> None:
        backend = tmp_path / "backend"
        worker = tmp_path / "worker"
        _write(backend, "migrations/001.sql", "CREATE TABLE repos (id INT);")
        _write(
            worker,
            "job.py",
            "import psycopg\n"
            'URL = "postgresql://db/app"\n'
            'q = "SELECT id FROM repos WHERE x = 1"\n',
        )
        contracts = DataExtractor().extract(backend, "backend")
        contracts += DataExtractor().extract(worker, "worker")
        assert len(match_contracts(contracts)) == 1

    def test_repo_that_opens_sqlite_in_one_module_keeps_its_tables(self, tmp_path: Path) -> None:
        # The Flask tutorial shape: db.py opens SQLite, auth.py queries it,
        # schema.sql declares it. No other repo reads or owns those tables.
        app = tmp_path / "app"
        server = tmp_path / "server"
        _write(app, "app/db.py", "import sqlite3\n")
        _write(app, "app/auth.py", 'q = "SELECT id FROM user WHERE x = 1"\n')
        _write(app, "app/schema.sql", "CREATE TABLE post (id INT);")
        _write(server, "db/database.sql", "CREATE TABLE user (id INT);")
        _write(server, "db/db.go", 'import _ "github.com/lib/pq"\n')
        _write(server, "models/post.go", 'const q = "SELECT id FROM post WHERE x = 1"\n')
        app_contracts = DataExtractor().extract(app, "app")
        assert {c.meta.get("embedded") for c in app_contracts} == {"sqlite"}
        server_contracts = DataExtractor().extract(server, "server")
        assert len(server_contracts) == 2
        assert all("embedded" not in c.meta for c in server_contracts)
        assert match_contracts(app_contracts + server_contracts) == []

    def test_repo_naming_a_server_database_keeps_the_file_tag(self, tmp_path: Path) -> None:
        # SQLite only as a fallback to DATABASE_URL: the app may run on a shared server.
        app = tmp_path / "app"
        backend = tmp_path / "backend"
        _write(
            app,
            "config.py",
            "URI = os.environ.get('DATABASE_URL', '').replace('postgres://', 'postgresql://')"
            " or 'sqlite:///app.db'\n",
        )
        _write(app, "routes.py", 'q = "SELECT id FROM repos WHERE x = 1"\n')
        _write(backend, "migrations/001.sql", "CREATE TABLE repos (id INT);")
        contracts = DataExtractor().extract(app, "app") + DataExtractor().extract(backend, "backend")
        assert len(match_contracts(contracts)) == 1

    def test_repo_engine_reads_server_tokens_in_any_case(self) -> None:
        from repowise.core.workspace.extractors.data.dialect import repo_embedded_engine

        db = "import sqlite3\n"
        assert repo_embedded_engine([db, "x = 1\n"]) == "sqlite"
        assert repo_embedded_engine([db, "'driver' => 'pgsql',\n"]) is None
        assert repo_embedded_engine([db, "const { Pool } = require('pg');\n"]) is None
        assert repo_embedded_engine([db, "# Works with MariaDB too\n"]) is None
        assert repo_embedded_engine(["x = 1\n"]) is None

    def test_embedded_model_not_shared_with_another_repos_schema(self, tmp_path: Path) -> None:
        _write(tmp_path / "api", "db/schema.sql", "CREATE TABLE refunds (id INT);")
        _write(tmp_path / "admin", "config.php", "<?php\n$db = new PDO('sqlite:app.db');\n")
        _write(tmp_path / "admin", "app/Models/Refund.php", _ELOQUENT_HEAD + "class Refund extends Model {}\n")
        contracts = DataExtractor().extract(tmp_path / "api", "api")
        contracts += DataExtractor().extract(tmp_path / "admin", "admin")
        assert match_contracts(contracts) == []


_ELOQUENT_HEAD = "<?php\nnamespace App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\n"


def _data(repo: Path, alias: str = "app") -> dict[tuple[str, str], dict]:
    """``(contract_id, framework or client) -> meta`` for *repo*'s data contracts."""
    return {
        (c.contract_id, c.meta.get("framework") or c.meta["client"]): c.meta
        for c in DataExtractor().extract(repo, alias)
    }


class TestLaravelData:
    def test_model_table_follows_the_naming_convention(self, tmp_path: Path) -> None:
        _write(tmp_path, "app/Models/GuestlistEntry.php", _ELOQUENT_HEAD + "class GuestlistEntry extends Model {}\n")
        _write(
            tmp_path,
            "app/Models/User.php",
            "<?php\nuse Illuminate\\Foundation\\Auth\\User as Authenticatable;\n"
            "class User extends Authenticatable {}\n",
        )
        assert set(_data(tmp_path)) == {
            ("data::guestlist_entries", "eloquent"),
            ("data::users", "eloquent"),
        }

    def test_an_explicit_table_wins_over_the_convention(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/Models/Table.php",
            _ELOQUENT_HEAD + "class Table extends Model {\n    protected $table = 'venue_tables';\n}\n",
        )
        assert set(_data(tmp_path)) == {("data::venue_tables", "eloquent")}

    def test_the_convention_needs_eloquent_and_a_concrete_class(self, tmp_path: Path) -> None:
        # Another library's `Model`, and an abstract base, name no table.
        _write(tmp_path, "src/Widget.php", "<?php\nuse Acme\\Model;\nclass Widget extends Model {}\n")
        _write(tmp_path, "app/Models/Base.php", _ELOQUENT_HEAD + "abstract class Base extends Model {}\n")
        assert _data(tmp_path) == {}

    def test_migrations_create_and_alter_with_schema_meta(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "database/migrations/2024_01_01_000000_create_orders_table.php",
            "<?php\nreturn new class extends Migration {\n"
            "    public function up(): void {\n"
            "        Schema::create('orders', function (Blueprint $t) { $t->id(); });\n"
            "        Schema::connection('audit')->table('order_log', function (Blueprint $t) {});\n"
            "    }\n"
            "    public function down(): void { Schema::dropIfExists('orders'); }\n"
            "};\n",
        )
        found = _data(tmp_path)
        assert found[("data::orders", "laravel-migration")]["schema"] == "create"
        assert found[("data::order_log", "laravel-migration")]["schema"] == "alter"
        assert len(found) == 2

    def test_query_builder_reads_and_writes(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/Services/Stats.php",
            "<?php\nclass Stats {\n    public function run() {\n"
            "        DB::table('tickets')->where('event_id', 1)->count();\n"
            "        DB::table('event_scan_stats')->updateOrInsert(['id' => 1], ['n' => 2]);\n"
            "        DB::table('audit as a')->insert(['x' => 1]);\n"
            "        DB::table('sessions')->where('old', true)->delete();\n"
            "        DB::table('counters')->increment('hits');\n"
            "    }\n}\n",
        )
        verbs = {cid: meta["verb"] for (cid, _), meta in _data(tmp_path).items()}
        assert verbs == {
            "data::tickets": "select",
            "data::event_scan_stats": "update",
            "data::audit": "insert",
            "data::sessions": "delete",
            "data::counters": "update",
        }

    def test_less_common_spellings(self, tmp_path: Path) -> None:
        _write(tmp_path, "app/Models/Seat.php", _ELOQUENT_HEAD + "final class Seat extends Model {}\n")
        _write(
            tmp_path,
            "app/Jobs/Sync.php",
            "<?php\nclass Sync { public function run() {\n"
            "    DB::connection('reporting')->table('rollups')->upsert([], ['id']);\n"
            "    DB::table('scratch')->truncate();\n"
            "    Schema::connection('audit')->create('audit_log', function ($t) {});\n"
            "} }\n",
        )
        found = _data(tmp_path)
        assert ("data::seats", "eloquent") in found
        assert found[("data::rollups", "laravel-db")]["verb"] == "insert"
        assert found[("data::scratch", "laravel-db")]["verb"] == "delete"
        assert found[("data::audit_log", "laravel-migration")]["schema"] == "create"

    def test_a_semicolon_in_a_string_does_not_end_the_statement(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/Jobs/Purge.php",
            "<?php\nDB::table('tokens')->where('note', 'a;b')->delete();\n",
        )
        assert _data(tmp_path)[("data::tokens", "laravel-db")]["verb"] == "delete"

    def test_a_write_inside_a_callback_is_not_the_outer_statement(self, tmp_path: Path) -> None:
        _write(
            tmp_path,
            "app/Jobs/Backfill.php",
            "<?php\nDB::table('orders')->orderBy('id')->each(function ($o) {\n"
            "    DB::table('ledger')->insert(['order' => $o->id]);\n});\n",
        )
        verbs = {cid: meta["verb"] for (cid, _), meta in _data(tmp_path).items()}
        assert verbs == {"data::orders": "select", "data::ledger": "insert"}

    def test_an_aliased_eloquent_base_is_missed_not_guessed(self, tmp_path: Path) -> None:
        # Deliberate ceiling: only the framework's own base-class names count.
        _write(
            tmp_path,
            "app/Models/Seat.php",
            "<?php\nuse Illuminate\\Database\\Eloquent\\Model as Eloquent;\nclass Seat extends Eloquent {}\n",
        )
        assert _data(tmp_path) == {}

    def test_a_ddl_create_carries_schema_meta(self, tmp_path: Path) -> None:
        _write(tmp_path, "schema.sql", "CREATE TABLE a (id INT);\nALTER TABLE b ADD COLUMN x INT;")
        found = _data(tmp_path)
        assert found[("data::a", "sql-ddl")]["schema"] == "create"
        assert found[("data::b", "sql-ddl")]["schema"] == "alter"


class TestSharedTables:
    def _extract(self, root: Path, *aliases: str) -> list:
        return [c for a in aliases for c in DataExtractor().extract(root / a, a)]

    def test_a_model_is_linked_to_the_service_owning_the_migration(self, tmp_path: Path) -> None:
        _write(
            tmp_path / "api",
            "database/migrations/2024_create_events.php",
            "<?php\nSchema::create('events', function ($t) {});\n",
        )
        _write(tmp_path / "api", "app/Models/Event.php", _ELOQUENT_HEAD + "class Event extends Model {}\n")
        _write(tmp_path / "admin", "app/Models/Event.php", _ELOQUENT_HEAD + "class Event extends Model {}\n")
        links = match_contracts(self._extract(tmp_path, "admin", "api"))
        assert [(k.consumer_repo, k.consumer_file, k.provider_repo, k.provider_file) for k in links] == [
            ("admin", "app/Models/Event.php", "api", "database/migrations/2024_create_events.php")
        ]
        assert links[0].contract_type == "data"

    def test_models_alone_say_nothing(self, tmp_path: Path) -> None:
        # Nobody defines the schema, so nothing says whose table it is.
        for alias in ("a", "b"):
            _write(tmp_path / alias, "app/Models/Venue.php", _ELOQUENT_HEAD + "class Venue extends Model {}\n")
        assert match_contracts(self._extract(tmp_path, "a", "b")) == []

    def test_two_apps_migrating_one_table_name_are_not_linked(self, tmp_path: Path) -> None:
        # Every stock Laravel app creates `users`; two of them are two databases.
        for alias in ("shop", "blog"):
            _write(
                tmp_path / alias,
                "database/migrations/0001_create_users_table.php",
                "<?php\nSchema::create('users', function ($t) {});\n",
            )
            _write(tmp_path / alias, "app/Models/User.php", _ELOQUENT_HEAD + "class User extends Model {}\n")
        assert match_contracts(self._extract(tmp_path, "shop", "blog")) == []

    def test_an_alter_only_owner_still_owns(self, tmp_path: Path) -> None:
        _write(tmp_path / "api", "db/002.sql", "ALTER TABLE seats ADD COLUMN row INT;")
        _write(tmp_path / "admin", "app/Models/Seat.php", _ELOQUENT_HEAD + "class Seat extends Model {}\n")
        links = match_contracts(self._extract(tmp_path, "admin", "api"))
        assert [(k.consumer_repo, k.provider_repo) for k in links] == [("admin", "api")]

    def test_one_service_declaring_twice_shares_nothing(self, tmp_path: Path) -> None:
        _write(tmp_path / "api", "db/schema.sql", "CREATE TABLE zones (id INT);")
        _write(tmp_path / "api", "app/Models/Zone.php", _ELOQUENT_HEAD + "class Zone extends Model {}\n")
        assert match_contracts(self._extract(tmp_path, "api")) == []

    def test_readers_and_models_both_link(self, tmp_path: Path) -> None:
        # The shared-table pass adds to the exact pass; it does not replace it.
        _write(tmp_path / "api", "db/schema.sql", "CREATE TABLE refunds (id INT);")
        _write(tmp_path / "admin", "app/Models/Refund.php", _ELOQUENT_HEAD + "class Refund extends Model {}\n")
        _write(tmp_path / "worker", "job.py", 'q = "SELECT id FROM refunds WHERE x = 1"\n')
        links = match_contracts(self._extract(tmp_path, "api", "admin", "worker"))
        assert sorted((k.consumer_repo, k.provider_repo) for k in links) == [
            ("admin", "api"),
            ("worker", "admin"),
            ("worker", "api"),
        ]