rbtr-lang-sql 2026.9.0.dev1__py3-none-any.whl

rbtr_lang_sql/tests/__snapshots__/test_samples/test_sql_dialect_extraction_matches_snapshot[sql_postgres].json

@@ -0,0 +1,116 @@
+[
+  {
+    "blob_sha": "sha1",
+    "file_path": "sql_postgres.sql",
+    "kind": "comment",
+    "name": "",
+    "scope": "",
+    "language": "sql",
+    "file_language": "sql",
+    "content": "-- PostgreSQL dialect sample — SERIAL, JSONB, arrays, ENUM type, plpgsql.",
+    "line_start": 1,
+    "line_end": 1,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "0202263c4558210b"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "sql_postgres.sql",
+    "kind": "variable",
+    "name": "\"uuid-ossp\"",
+    "scope": "",
+    "language": "sql",
+    "file_language": "sql",
+    "content": "CREATE EXTENSION IF NOT EXISTS \"uuid-ossp\"",
+    "line_start": 3,
+    "line_end": 3,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "ea569708fd9107dd"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "sql_postgres.sql",
+    "kind": "class",
+    "name": "mood",
+    "scope": "",
+    "language": "sql",
+    "file_language": "sql",
+    "content": "CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy')",
+    "line_start": 5,
+    "line_end": 5,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "8935d150afcbbe2f"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "sql_postgres.sql",
+    "kind": "class",
+    "name": "users",
+    "scope": "",
+    "language": "sql",
+    "file_language": "sql",
+    "content": "CREATE TABLE users (\n    id SERIAL PRIMARY KEY,\n    email TEXT UNIQUE NOT NULL,\n    profile JSONB DEFAULT '{}'::jsonb,\n    tags TEXT[],\n    created_at TIMESTAMPTZ DEFAULT now()\n)",
+    "line_start": 7,
+    "line_end": 13,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "c959eda6cfcc840d"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "sql_postgres.sql",
+    "kind": "function",
+    "name": "greet",
+    "scope": "",
+    "language": "sql",
+    "file_language": "sql",
+    "content": "CREATE FUNCTION greet(name TEXT) RETURNS TEXT\nLANGUAGE sql AS $$ SELECT 'Hello, ' || name $$",
+    "line_start": 15,
+    "line_end": 16,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "494263cbd1532edd"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "sql_postgres.sql",
+    "kind": "variable",
+    "name": "idx_users_email",
+    "scope": "",
+    "language": "sql",
+    "file_language": "sql",
+    "content": "CREATE INDEX idx_users_email ON users (email)",
+    "line_start": 18,
+    "line_end": 18,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "64c23d29e5209b80"
+  }
+]

rbtr_lang_sql/tests/__snapshots__/test_samples/test_sql_dialect_extraction_matches_snapshot[sql_sqlite].json

@@ -0,0 +1,78 @@
+[
+  {
+    "blob_sha": "sha1",
+    "file_path": "sql_sqlite.sql",
+    "kind": "comment",
+    "name": "",
+    "scope": "",
+    "language": "sql",
+    "file_language": "sql",
+    "content": "-- SQLite dialect sample — AUTOINCREMENT, WITHOUT ROWID, IF NOT EXISTS.",
+    "line_start": 1,
+    "line_end": 1,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "0202263c4558210b"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "sql_sqlite.sql",
+    "kind": "class",
+    "name": "users",
+    "scope": "",
+    "language": "sql",
+    "file_language": "sql",
+    "content": "CREATE TABLE IF NOT EXISTS users (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    email TEXT NOT NULL UNIQUE,\n    created_at TEXT DEFAULT (datetime('now'))\n)",
+    "line_start": 3,
+    "line_end": 7,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "bbc0c1d3c758c83c"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "sql_sqlite.sql",
+    "kind": "variable",
+    "name": "idx_users_email",
+    "scope": "",
+    "language": "sql",
+    "file_language": "sql",
+    "content": "CREATE INDEX idx_users_email ON users (email)",
+    "line_start": 9,
+    "line_end": 9,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "ccab971541354b72"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "sql_sqlite.sql",
+    "kind": "class",
+    "name": "active_users",
+    "scope": "",
+    "language": "sql",
+    "file_language": "sql",
+    "content": "CREATE VIEW active_users AS SELECT id, email FROM users",
+    "line_start": 11,
+    "line_end": 11,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "99cce937484e7657"
+  }
+]

rbtr_lang_sql/tests/cases_extraction.py

@@ -0,0 +1,265 @@
+"""SQL extraction test cases.
+
+Each `@case` returns test data consumed by `test_extraction.py` via
+`pytest-cases`. The cases are the spec of the SQL constructs the plugin
+captures — one chunk per top-level statement (plus one per CTE), named
+by its object/table (SQL has no nesting, so scope is always ""). See the
+plugin docstring for the full source→chunk mapping.
+"""
+
+from __future__ import annotations
+
+from pytest_cases import case
+
+type SymbolCase = tuple[str, str, list[tuple[str, str, str]]]
+type MixedCase = tuple[str, str, set[str], list[tuple[str, str]]]
+
+
+# ── DDL definitions: class ───────────────────────────────────────────
+
+
+@case(tags=["symbol"])
+def case_sql_table() -> SymbolCase:
+    """CREATE TABLE — structural definition → class."""
+    return "sql", "CREATE TABLE users (id INT, name TEXT);\n", [("class", "users", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_view() -> SymbolCase:
+    """CREATE VIEW → class."""
+    return "sql", "CREATE VIEW active AS SELECT * FROM users;\n", [("class", "active", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_materialized_view() -> SymbolCase:
+    """CREATE MATERIALIZED VIEW → class."""
+    src = "CREATE MATERIALIZED VIEW recent AS SELECT * FROM users;\n"
+    return "sql", src, [("class", "recent", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_type_enum() -> SymbolCase:
+    """CREATE TYPE ... AS ENUM — SQL's enum → class."""
+    return "sql", "CREATE TYPE mood AS ENUM ('sad', 'happy');\n", [("class", "mood", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_type_composite() -> SymbolCase:
+    """CREATE TYPE ... AS (...) — composite type → class."""
+    src = "CREATE TYPE point AS (x DOUBLE PRECISION, y DOUBLE PRECISION);\n"
+    return "sql", src, [("class", "point", "")]
+
+
+# ── DDL definitions: variable (standalone named objects) ─────────────
+
+
+@case(tags=["symbol"])
+def case_sql_index() -> SymbolCase:
+    """CREATE INDEX → variable, named by the index (not the ON table)."""
+    return "sql", "CREATE INDEX idx_name ON users (name);\n", [("variable", "idx_name", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_sequence() -> SymbolCase:
+    """CREATE SEQUENCE → variable."""
+    return "sql", "CREATE SEQUENCE order_id START 1;\n", [("variable", "order_id", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_schema() -> SymbolCase:
+    """CREATE SCHEMA → variable."""
+    return "sql", "CREATE SCHEMA app;\n", [("variable", "app", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_extension() -> SymbolCase:
+    """CREATE EXTENSION → variable (common in migrations)."""
+    return "sql", "CREATE EXTENSION postgis;\n", [("variable", "postgis", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_trigger() -> SymbolCase:
+    """CREATE TRIGGER → variable, named by the trigger (not its table/function)."""
+    src = """\
+CREATE TRIGGER audit BEFORE UPDATE ON users
+FOR EACH ROW EXECUTE FUNCTION log_change();
+"""
+    return "sql", src, [("variable", "audit", "")]
+
+
+# ── Routines and statements: function ────────────────────────────────
+
+
+@case(tags=["symbol"])
+def case_sql_function() -> SymbolCase:
+    """CREATE FUNCTION — routine → function."""
+    src = """\
+CREATE FUNCTION add(a INT, b INT) RETURNS INT
+LANGUAGE SQL
+AS $$ SELECT a + b; $$;
+"""
+    return "sql", src, [("function", "add", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_select() -> SymbolCase:
+    """SELECT → function, named by its primary FROM table."""
+    return "sql", "SELECT id, name FROM users;\n", [("function", "users", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_insert() -> SymbolCase:
+    """INSERT → function, named by its target table."""
+    return "sql", "INSERT INTO logs (msg) VALUES ('hi');\n", [("function", "logs", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_update() -> SymbolCase:
+    """UPDATE → function, named by its target table."""
+    return "sql", "UPDATE users SET name = 'x' WHERE id = 1;\n", [("function", "users", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_delete() -> SymbolCase:
+    """DELETE → function, named by its target table."""
+    return "sql", "DELETE FROM sessions WHERE id = 1;\n", [("function", "sessions", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_cte() -> SymbolCase:
+    """Each CTE → a function named by its identifier."""
+    src = """\
+WITH ranked AS (
+    SELECT id FROM events
+),
+recent AS (
+    SELECT id FROM ranked
+)
+SELECT id FROM recent;
+"""
+    return "sql", src, [("function", "ranked", ""), ("function", "recent", "")]
+
+
+# ── DDL operations: function (alter/drop) ────────────────────────────
+
+
+@case(tags=["symbol"])
+def case_sql_alter_table() -> SymbolCase:
+    """ALTER TABLE → function, named by the table."""
+    return "sql", "ALTER TABLE users ADD COLUMN age INT;\n", [("function", "users", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_drop_table() -> SymbolCase:
+    """DROP TABLE → function, named by the table."""
+    return "sql", "DROP TABLE legacy;\n", [("function", "legacy", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_drop_index() -> SymbolCase:
+    """DROP INDEX → function, named by the index."""
+    return "sql", "DROP INDEX idx_old;\n", [("function", "idx_old", "")]
+
+
+# ── Naming invariances (optional clauses must not change the name) ───
+
+
+@case(tags=["symbol"])
+def case_sql_table_if_not_exists() -> SymbolCase:
+    """IF NOT EXISTS does not change the table name."""
+    return "sql", "CREATE TABLE IF NOT EXISTS users (id INT);\n", [("class", "users", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_view_or_replace() -> SymbolCase:
+    """CREATE OR REPLACE does not change the view name."""
+    return "sql", "CREATE OR REPLACE VIEW v AS SELECT 1;\n", [("class", "v", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_schema_qualified_table() -> SymbolCase:
+    """A schema-qualified table is named by the table, not the schema."""
+    return "sql", "CREATE TABLE app.users (id INT);\n", [("class", "users", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_select_aliased_table() -> SymbolCase:
+    """An aliased FROM is named by the table, not the alias."""
+    src = "SELECT c.id FROM chunks AS c JOIN files f ON f.id = c.id;\n"
+    return "sql", src, [("function", "chunks", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_create_table_as_select() -> SymbolCase:
+    """CREATE TABLE AS SELECT yields only the table, not the nested select."""
+    return "sql", "CREATE TABLE snap AS SELECT * FROM users;\n", [("class", "snap", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_insert_select() -> SymbolCase:
+    """INSERT ... SELECT is named by the insert target."""
+    src = "INSERT INTO archive SELECT * FROM events;\n"
+    return "sql", src, [("function", "archive", "")]
+
+
+# ── Unnamed statements (no nameable target) ──────────────────────────
+
+
+@case(tags=["symbol"])
+def case_sql_select_no_table() -> SymbolCase:
+    """A SELECT with no table has no name."""
+    return "sql", "SELECT 1;\n", [("function", "", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_union() -> SymbolCase:
+    """A top-level UNION (set_operation) is one unnamed function chunk."""
+    src = "SELECT id FROM a UNION SELECT id FROM b;\n"
+    return "sql", src, [("function", "", "")]
+
+
+@case(tags=["symbol"])
+def case_sql_param_error_recovery() -> SymbolCase:
+    """A DuckDB $param errors internally but the statement still extracts.
+
+    The `$id` placeholder is unknown to the grammar (an ERROR node),
+    but error recovery keeps the enclosing statement, so the chunk is
+    still produced and named by its table.
+    """
+    return "sql", "SELECT * FROM users WHERE id = $id;\n", [("function", "users", "")]
+
+
+# ── Mixed ────────────────────────────────────────────────────────────
+
+
+@case(tags=["mixed"])
+def case_sql_migration() -> MixedCase:
+    """Realistic migration script producing every SQL chunk kind.
+
+    SQL has no method scoping, so the expected-methods list is
+    empty — definitions are all top-level.
+    """
+    src = """\
+CREATE SCHEMA shop;
+
+CREATE TABLE shop.products (
+    id INT PRIMARY KEY,
+    name TEXT NOT NULL,
+    price NUMERIC
+);
+
+CREATE VIEW in_stock AS
+SELECT * FROM shop.products WHERE price > 0;
+
+CREATE FUNCTION price_with_tax(p NUMERIC) RETURNS NUMERIC
+LANGUAGE SQL
+AS $$ SELECT p * 1.2; $$;
+
+CREATE INDEX idx_products_name ON shop.products (name);
+"""
+    return (
+        "sql",
+        src,
+        {"class", "function", "variable"},
+        [],
+    )

rbtr_lang_sql/tests/samples/sql/sql.sql

@@ -0,0 +1,38 @@
+-- Greeter schema — tables, views, and statements for greetings.
+--
+-- The SQL plugin extracts one chunk per top-level statement: CREATE
+-- TABLE/VIEW (as classes), CREATE FUNCTION and DML/CTEs (as functions),
+-- and CREATE SCHEMA/INDEX/SEQUENCE (as variables). There is no import
+-- concept. CREATE PROCEDURE and PRAGMA do not parse and live in the
+-- xfail registry instead.
+
+CREATE SCHEMA greet; -- trailing comment: its own chunk
+
+-- Standalone note, separated by blank lines from any statement.
+-- Second line of the same block.
+
+CREATE TABLE greeters (
+    id INTEGER PRIMARY KEY,
+    prefix TEXT NOT NULL
+);
+
+CREATE INDEX idx_greeters_prefix ON greeters (prefix);
+
+CREATE SEQUENCE greeting_id_seq;
+
+CREATE VIEW active_greeters AS
+SELECT id, prefix FROM greeters WHERE prefix IS NOT NULL;
+
+CREATE FUNCTION shout(message TEXT) RETURNS TEXT AS 'SELECT upper(message)';
+
+WITH recent AS (
+    SELECT id FROM greeters
+)
+
+SELECT id FROM recent;
+
+INSERT INTO greeters (id, prefix) VALUES (1, 'Hello');
+
+UPDATE greeters SET prefix = 'Hi' WHERE id = 1;
+
+DELETE FROM greeters WHERE id = 1;

rbtr_lang_sql/tests/samples/sql_clickhouse.sql

@@ -0,0 +1,17 @@
+-- ClickHouse dialect sample — MergeTree engine, ORDER BY, special types.
+
+CREATE TABLE events (
+    event_date Date,
+    user_id UInt64,
+    name LowCardinality(String),
+    props Array(String),
+    value Nullable(Float64)
+)
+ENGINE = MergeTree
+PARTITION BY toYYYYMM(event_date)
+ORDER BY (user_id, event_date);
+
+CREATE MATERIALIZED VIEW events_mv
+ENGINE = SummingMergeTree
+ORDER BY user_id
+AS SELECT user_id, count() AS c FROM events GROUP BY user_id;

rbtr_lang_sql/tests/samples/sql_duckdb.sql

@@ -0,0 +1,14 @@
+-- DuckDB dialect sample — LIST/STRUCT types, CTAS, CREATE MACRO.
+
+CREATE TABLE users (
+    id BIGINT PRIMARY KEY,
+    email VARCHAR NOT NULL,
+    tags VARCHAR[],
+    profile STRUCT(name VARCHAR, age INTEGER)
+);
+
+CREATE TABLE recent AS SELECT * FROM users LIMIT 10;
+
+CREATE MACRO add_one(x) AS x + 1;
+
+CREATE VIEW emails AS SELECT email FROM users;

rbtr_lang_sql/tests/samples/sql_mysql.sql

@@ -0,0 +1,11 @@
+-- MySQL dialect sample — backtick identifiers, UNSIGNED AUTO_INCREMENT, ENGINE.
+
+CREATE TABLE `users` (
+    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    `email` VARCHAR(255) NOT NULL,
+    `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    PRIMARY KEY (`id`),
+    UNIQUE KEY `uq_email` (`email`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+CREATE INDEX `idx_email` ON `users` (`email`);

rbtr_lang_sql/tests/samples/sql_postgres.sql

@@ -0,0 +1,18 @@
+-- PostgreSQL dialect sample — SERIAL, JSONB, arrays, ENUM type, plpgsql.
+
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');
+
+CREATE TABLE users (
+    id SERIAL PRIMARY KEY,
+    email TEXT UNIQUE NOT NULL,
+    profile JSONB DEFAULT '{}'::jsonb,
+    tags TEXT[],
+    created_at TIMESTAMPTZ DEFAULT now()
+);
+
+CREATE FUNCTION greet(name TEXT) RETURNS TEXT
+LANGUAGE sql AS $$ SELECT 'Hello, ' || name $$;
+
+CREATE INDEX idx_users_email ON users (email);

rbtr_lang_sql/tests/samples/sql_sqlite.sql

@@ -0,0 +1,11 @@
+-- SQLite dialect sample — AUTOINCREMENT, WITHOUT ROWID, IF NOT EXISTS.
+
+CREATE TABLE IF NOT EXISTS users (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    email TEXT NOT NULL UNIQUE,
+    created_at TEXT DEFAULT (datetime('now'))
+) WITHOUT ROWID;
+
+CREATE INDEX idx_users_email ON users (email);
+
+CREATE VIEW active_users AS SELECT id, email FROM users;

rbtr_lang_sql/tests/test_extraction.py

@@ -0,0 +1,85 @@
+"""SQL extraction tests.
+
+Construct/mixed cases (`cases_extraction.py`) drive the shared checks;
+the two functions at the end pin SQL-specific edge behaviour.
+"""
+
+from __future__ import annotations
+
+import pytest
+from pytest_cases import parametrize_with_cases
+
+from rbtr.domain.models import ChunkKind
+from rbtr.git import FileEntry
+from rbtr.languages.extract import extract_file
+
+
+@parametrize_with_cases("lang, source, expected", cases=".cases_extraction", has_tag="symbol")
+def test_extracts_expected_symbols(lang: str, source: str, expected: list) -> None:
+    """Each expected (kind, name, scope) tuple appears in the output."""
+    chunks = extract_file(FileEntry("input", "sha1", source.encode()), lang)
+    symbols = [(c.kind, c.name, c.scope) for c in chunks]
+    for exp in expected:
+        assert exp in symbols, f"expected {exp} not found in {symbols}"
+
+
+@parametrize_with_cases(
+    "lang, source, expected_kinds, expected_methods", cases=".cases_extraction", has_tag="mixed"
+)
+def test_extracts_all_expected_kinds(
+    lang: str,
+    source: str,
+    expected_kinds: set[str],
+    expected_methods: list[tuple[str, str]],
+) -> None:
+    """Realistic source produces all expected chunk kinds and method scoping."""
+    chunks = extract_file(FileEntry("input", "sha1", source.encode()), lang)
+    kinds = {c.kind for c in chunks}
+    for kind in expected_kinds:
+        assert kind in kinds, f"expected kind {kind!r} not in {kinds}"
+    methods = [(c.name, c.scope) for c in chunks if c.kind == ChunkKind.METHOD]
+    for name, scope in expected_methods:
+        assert (name, scope) in methods, f"expected method ({name}, {scope}) not in {methods}"
+
+
+def test_sql_pragma_not_extracted() -> None:
+    """A DuckDB PRAGMA yields no definition chunk.
+
+    The grammar has no PRAGMA statement node, so it parses to a top-level
+    ERROR with no enclosing `statement` to capture. This is a known
+    limitation guard; it flags the day the grammar gains PRAGMA support.
+    Only the content-less host-presence chunk (for blob dedup) remains.
+    """
+    src = "PRAGMA create_fts_index('chunks', 'id', 'body');\n"
+    chunks = extract_file(FileEntry("input", "sha1", src.encode()), "sql")
+    assert [c for c in chunks if c.content] == []
+
+
+@pytest.mark.xfail(
+    strict=True,
+    reason="tree-sitter-sql has no create_procedure node — parses to ERROR",
+)
+def test_stored_procedure_unsupported() -> None:
+    """A SQL stored procedure should ideally extract as a function (grammar gap).
+
+    Strict xfail: when the grammar gains `create_procedure` this fails, prompting
+    removal of the xfail and a sample update.
+    """
+    src = "CREATE PROCEDURE refresh()\nLANGUAGE SQL\nAS $$ DELETE FROM cache; $$;\n"
+    chunks = extract_file(FileEntry("input", "sha1", src.encode()), "sql")
+    assert (ChunkKind.FUNCTION, "refresh", "") in [(c.kind, c.name, c.scope) for c in chunks]
+
+
+def test_sql_multi_statement_one_chunk_each() -> None:
+    """Each top-level statement in a file becomes its own chunk."""
+    src = """\
+CREATE TABLE a (id INT);
+SELECT * FROM a;
+DROP TABLE a;
+"""
+    chunks = extract_file(FileEntry("input", "sha1", src.encode()), "sql")
+    assert [(c.kind, c.name) for c in chunks] == [
+        (ChunkKind.CLASS, "a"),
+        (ChunkKind.FUNCTION, "a"),
+        (ChunkKind.FUNCTION, "a"),
+    ]