test: expand edge-case coverage and DRY up test helpers (#168)

## Summary
Broadens unit-test coverage and reduces test boilerplate.

Unit suite (excludes browser-covered `navigation-extension`):

| Metric | Before | After |
|---|---|---|
| Statements | 89.1% | **91.6%** |
| Branches | 81.2% | **85.9%** |
| Lines | 89.0% | **91.5%** |
| Tests | 471 | **587** (+116) |

## DRY
- New `__tests__/test-utils.ts`: shared fixtures +
`createCompletionContext`/`labels`/`completeWith` runner.
- `column-` and `alias-completion-source` suites refactored onto it (~90
lines of duplicated setup removed).
- Scoped vitest's `__tests__` glob to `*.test.ts` and excluded
`__tests__/**` from the `tsc` build so the helper file isn't run as a
test or shipped in `dist`.

## New edge cases
- New `completion-utils` suite (previously untested).
- Added cases to `parser` (64→71% branch), `namespace-utils` (78→86%),
`query-context`, `references` (79→86%), `semantic-diagnostics` (82→86%),
`hover` (86→98%, lines→100%), `diagnostics` (→100%).

## Test plan
- `pnpm test` (jsdom): 587 passed, 1 pre-existing `it.fails`.
- `pnpm run typecheck` and `pnpm exec oxlint`: clean.

<!-- This is an auto-generated description by cubic. -->
---
## Summary by cubic
Expands unit-test edge-case coverage and consolidates shared test
helpers to cut boilerplate. Coverage up: statements 89.1%→91.6%,
branches 81.2%→85.9%, lines 89.0%→91.5%; +116 tests.

- **Refactors**
- Added `src/sql/__tests__/test-utils.ts` with shared fixtures and
`createCompletionContext`/`completeWith`/`labels`; introduced
`completion-utils` tests.
- Refactored `column-` and `alias-completion-source` tests to use the
helpers (~90 lines of duplicate setup removed).
- Scoped `vite` test include to `src/**/__tests__/**/*.test.ts` and
excluded `__tests__/**` from `tsc` so helpers aren’t executed or
published.

<sup>Written for commit 6d51e0e.
Summary will update on new commits.</sup>

<a
href="https://cubic.dev/pr/marimo-team/codemirror-sql/pull/168?utm_source=github"
target="_blank" rel="noopener noreferrer"
data-no-image-dialog="true"><picture><source
media="(prefers-color-scheme: dark)"
srcset="https://www.cubic.dev/buttons/review-in-cubic-dark.svg"><source
media="(prefers-color-scheme: light)"
srcset="https://www.cubic.dev/buttons/review-in-cubic-light.svg"><img
alt="Review in cubic"
src="https://www.cubic.dev/buttons/review-in-cubic-dark.svg"></picture></a>

<!-- End of auto-generated description by cubic. -->

Author: mscolnick

src/sql/__tests__/alias-completion-source.test.ts

@@ -1,48 +1,12 @@
-import { CompletionContext, type CompletionResult } from "@codemirror/autocomplete";
 import type { SQLNamespace } from "@codemirror/lang-sql";
-import { EditorState } from "@codemirror/state";
 import { describe, expect, it } from "vitest";
 import { aliasColumnCompletionSource } from "../alias-completion-source.js";
-import { sqlSchemaFacet } from "../schema-facet.js";
-
-const schema: SQLNamespace = {
-  users: ["id", "username", "email"],
-  orders: [
-    { label: "order_id", detail: "Order ID", type: "property" },
-    "total",
-  ],
-};
-
-const nestedSchema: SQLNamespace = {
-  mydb: {
-    users: ["id", "username"],
-  },
-};
-
-async function complete(
-  doc: string,
-  opts: {
-    schema?: SQLNamespace;
-    pos?: number;
-    explicit?: boolean;
-    facetSchema?: SQLNamespace;
-  } = {},
-): Promise<CompletionResult | null> {
-  const source = aliasColumnCompletionSource(
-    opts.schema === undefined && opts.facetSchema !== undefined ? {} : { schema: opts.schema },
-  );
-  const state = EditorState.create({
-    doc,
-    extensions: opts.facetSchema !== undefined ? [sqlSchemaFacet.of(opts.facetSchema)] : [],
-  });
-  const pos = opts.pos ?? doc.length;
-  const context = new CompletionContext(state, pos, opts.explicit ?? false);
-  return (await source(context)) as CompletionResult | null;
-}
-
-function labels(result: CompletionResult | null): string[] {
-  return (result?.options ?? []).map((option) => option.label);
-}
+import { completeWith, labels, NESTED_SCHEMA, TEST_SCHEMA } from "./test-utils.js";
+
+const schema = TEST_SCHEMA;
+const nestedSchema = NESTED_SCHEMA;
+
+const complete = completeWith(aliasColumnCompletionSource);
 
 describe("aliasColumnCompletionSource", () => {
   it("offers the aliased table's columns after `alias.`", async () => {

src/sql/__tests__/column-completion-source.test.ts

@@ -1,48 +1,12 @@
-import { CompletionContext, type CompletionResult } from "@codemirror/autocomplete";
 import type { SQLNamespace } from "@codemirror/lang-sql";
-import { EditorState } from "@codemirror/state";
 import { describe, expect, it } from "vitest";
 import { unqualifiedColumnCompletionSource } from "../column-completion-source.js";
-import { sqlSchemaFacet } from "../schema-facet.js";
+import { completeWith, labels, NESTED_SCHEMA, TEST_SCHEMA } from "./test-utils.js";
 
-const schema: SQLNamespace = {
-  users: ["id", "username", "email"],
-  orders: [
-    { label: "order_id", detail: "Order ID", type: "property" },
-    "total",
-  ],
-};
+const schema = TEST_SCHEMA;
+const nestedSchema = NESTED_SCHEMA;
 
-const nestedSchema: SQLNamespace = {
-  mydb: {
-    users: ["id", "username"],
-  },
-};
-
-async function complete(
-  doc: string,
-  opts: {
-    schema?: SQLNamespace;
-    pos?: number;
-    explicit?: boolean;
-    facetSchema?: SQLNamespace;
-  } = {},
-): Promise<CompletionResult | null> {
-  const source = unqualifiedColumnCompletionSource(
-    opts.schema === undefined && opts.facetSchema !== undefined ? {} : { schema: opts.schema },
-  );
-  const state = EditorState.create({
-    doc,
-    extensions: opts.facetSchema !== undefined ? [sqlSchemaFacet.of(opts.facetSchema)] : [],
-  });
-  const pos = opts.pos ?? doc.length;
-  const context = new CompletionContext(state, pos, opts.explicit ?? false);
-  return (await source(context)) as CompletionResult | null;
-}
-
-function labels(result: CompletionResult | null): string[] {
-  return (result?.options ?? []).map((option) => option.label);
-}
+const complete = completeWith(unqualifiedColumnCompletionSource);
 
 describe("unqualifiedColumnCompletionSource", () => {
   it("offers the FROM table's columns for a bare prefix", async () => {

src/sql/__tests__/completion-utils.test.ts

@@ -0,0 +1,170 @@
+import type { Completion, CompletionContext } from "@codemirror/autocomplete";
+import type { SQLNamespace } from "@codemirror/lang-sql";
+import type { EditorView } from "@codemirror/view";
+import { describe, expect, it, vi } from "vitest";
+import { columnsOf, findTableColumns, resolveSchema, toCompletion } from "../completion-utils.js";
+import { sqlSchemaFacet } from "../schema-facet.js";
+import { createCompletionContext, createState } from "./test-utils.js";
+
+describe("resolveSchema", () => {
+  it("returns an explicitly provided namespace as-is", () => {
+    const schema: SQLNamespace = { users: ["id"] };
+    const context = createCompletionContext("SELECT ");
+    expect(resolveSchema(schema, context)).toBe(schema);
+  });
+
+  it("falls back to the schema facet when no explicit source is given", () => {
+    const schema: SQLNamespace = { users: ["id"] };
+    const context = createCompletionContext("SELECT ", {
+      extensions: [sqlSchemaFacet.of(schema)],
+    });
+    expect(resolveSchema(undefined, context)).toBe(schema);
+  });
+
+  it("returns null when neither an explicit source nor a facet is present", () => {
+    const context = createCompletionContext("SELECT ");
+    expect(resolveSchema(undefined, context)).toBeNull();
+  });
+
+  it("returns null for a function source when the context has no view", () => {
+    // Contexts created without an editor (as in unit tests) get no schema
+    const source = vi.fn(() => ({ users: ["id"] }) as SQLNamespace);
+    const context = createCompletionContext("SELECT ");
+    expect(resolveSchema(source, context)).toBeNull();
+    expect(source).not.toHaveBeenCalled();
+  });
+
+  it("invokes a function source with the view when one is present", () => {
+    const schema: SQLNamespace = { users: ["id"] };
+    const view = {} as EditorView;
+    const source = vi.fn(() => schema);
+    // Minimal context carrying a view — resolveSchema only reads `state`/`view`
+    const context = { state: createState("SELECT "), view } as unknown as CompletionContext;
+
+    expect(resolveSchema(source, context)).toBe(schema);
+    expect(source).toHaveBeenCalledWith(view);
+  });
+});
+
+describe("columnsOf", () => {
+  it("returns null for a nullish namespace", () => {
+    expect(columnsOf(undefined)).toBeNull();
+  });
+
+  it("returns the array itself for an array namespace", () => {
+    const columns = ["id", "name"];
+    expect(columnsOf(columns)).toBe(columns);
+  });
+
+  it("unwraps the children of a self/children namespace", () => {
+    const children = ["id", "name"];
+    const namespace = { self: { label: "users" }, children } as unknown as SQLNamespace;
+    expect(columnsOf(namespace)).toBe(children);
+  });
+
+  it("returns null for an object (non-column) namespace", () => {
+    expect(columnsOf({ users: ["id"] } as SQLNamespace)).toBeNull();
+  });
+
+  it("returns null when a self/children node wraps a non-array child", () => {
+    const namespace = {
+      self: { label: "db" },
+      children: { users: ["id"] },
+    } as unknown as SQLNamespace;
+    expect(columnsOf(namespace)).toBeNull();
+  });
+});
+
+describe("findTableColumns", () => {
+  const schema: SQLNamespace = {
+    users: ["id", "username", "email"],
+    orders: ["order_id", "total"],
+  };
+
+  it("resolves a simple table name (case-insensitively)", () => {
+    expect(findTableColumns(schema, "users")).toEqual(["id", "username", "email"]);
+    expect(findTableColumns(schema, "USERS")).toEqual(["id", "username", "email"]);
+  });
+
+  it("resolves a fully-qualified path", () => {
+    const nested: SQLNamespace = { mydb: { users: ["id", "name"] } };
+    expect(findTableColumns(nested, "mydb.users")).toEqual(["id", "name"]);
+  });
+
+  it("resolves an under-qualified name to a table nested deeper", () => {
+    const nested: SQLNamespace = { mydb: { users: ["id", "name"] } };
+    expect(findTableColumns(nested, "users")).toEqual(["id", "name"]);
+  });
+
+  it("resolves via pre-split segments (preserving dotted identifiers)", () => {
+    const nested: SQLNamespace = { "my.db": { users: ["id"] } };
+    expect(findTableColumns(nested, ["my.db", "users"])).toEqual(["id"]);
+  });
+
+  it("returns null for an unknown table", () => {
+    expect(findTableColumns(schema, "missing")).toBeNull();
+  });
+
+  it("returns null when the last segment is empty", () => {
+    // A path that reduces to no final segment cannot resolve
+    expect(findTableColumns(schema, [])).toBeNull();
+    expect(findTableColumns(schema, "")).toBeNull();
+  });
+
+  it("returns null when an under-qualified name is ambiguous", () => {
+    const ambiguous: SQLNamespace = {
+      db1: { users: ["id", "a"] },
+      db2: { users: ["id", "b"] },
+    };
+    // `users` exists under two catalogs — refuse to guess
+    expect(findTableColumns(ambiguous, "users")).toBeNull();
+  });
+
+  it("returns null when the qualified path is longer than any match", () => {
+    const nested: SQLNamespace = { mydb: { users: ["id"] } };
+    // `other.users` — the suffix does not match the `mydb.users` path
+    expect(findTableColumns(nested, "other.users")).toBeNull();
+  });
+});
+
+describe("toCompletion", () => {
+  it("wraps a string column with the property type and detail", () => {
+    expect(toCompletion("id", "column")).toEqual({
+      label: "id",
+      type: "property",
+      detail: "column",
+    });
+  });
+
+  it("adds a boost to a string column when provided", () => {
+    expect(toCompletion("id", "column", 5)).toEqual({
+      label: "id",
+      type: "property",
+      detail: "column",
+      boost: 5,
+    });
+  });
+
+  it("preserves an existing Completion detail and forces the property type", () => {
+    const column: Completion = { label: "id", type: "keyword", detail: "Primary key" };
+    expect(toCompletion(column, "fallback")).toEqual({
+      label: "id",
+      type: "property",
+      detail: "Primary key",
+    });
+  });
+
+  it("uses the fallback detail when the Completion has none", () => {
+    const column: Completion = { label: "id" };
+    expect(toCompletion(column, "fallback")).toMatchObject({
+      label: "id",
+      type: "property",
+      detail: "fallback",
+    });
+  });
+
+  it("applies a boost to a Completion only when it has none of its own", () => {
+    expect(toCompletion({ label: "id" }, "d", 3).boost).toBe(3);
+    expect(toCompletion({ label: "id", boost: 9 }, "d", 3).boost).toBe(9);
+  });
+});

src/sql/__tests__/diagnostics.test.ts

@@ -232,4 +232,84 @@ describe("lint source", () => {
     expect(diagnostics).toHaveLength(2);
     expect(validateSpy).not.toHaveBeenCalled();
   });
+
+  it("should clamp the diagnostic span to the document end when the error column runs past it", async () => {
+    // A parser whose reported column points beyond the end of the document
+    // exercises the `from >= doc.length` branch in tokenEndAt, which clamps
+    // the span end to `doc.length`.
+    const doc = "SELECT 1";
+    const parser = {
+      validateSql: vi.fn(async () => [
+        { message: "unexpected end of input", line: 1, column: 999, severity: "error" as const },
+      ]),
+      parse: vi.fn(async () => ({ success: false, errors: [] })),
+      extractTableReferences: vi.fn(async () => []),
+      extractColumnReferences: vi.fn(async () => []),
+    } as unknown as SqlParser;
+
+    const diagnostics = await lint(doc, { parser, perStatement: false });
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0].from).toBe(doc.length);
+    expect(diagnostics[0].to).toBe(doc.length);
+  });
+
+  it("should preserve warning severity from the parser", async () => {
+    const parser = {
+      validateSql: vi.fn(async () => [
+        { message: "deprecated syntax", line: 1, column: 1, severity: "warning" as const },
+      ]),
+      parse: vi.fn(async () => ({ success: false, errors: [] })),
+      extractTableReferences: vi.fn(async () => []),
+      extractColumnReferences: vi.fn(async () => []),
+    } as unknown as SqlParser;
+
+    const diagnostics = await lint("SELECT 1", { parser, perStatement: false });
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0].severity).toBe("warning");
+    expect(diagnostics[0].message).toBe("deprecated syntax");
+  });
+
+  it("should emit multiple diagnostics from a single statement when the parser returns several", async () => {
+    const parser = {
+      validateSql: vi.fn(async () => [
+        { message: "first", line: 1, column: 1, severity: "error" as const },
+        { message: "second", line: 1, column: 8, severity: "error" as const },
+      ]),
+      parse: vi.fn(async () => ({ success: false, errors: [] })),
+      extractTableReferences: vi.fn(async () => []),
+      extractColumnReferences: vi.fn(async () => []),
+    } as unknown as SqlParser;
+
+    const diagnostics = await lint("SELECT badcol", { parser, perStatement: false });
+
+    expect(diagnostics).toHaveLength(2);
+    expect(diagnostics.map((d) => d.message)).toEqual(["first", "second"]);
+  });
+
+  it("clamps a statement-relative error column that overshoots to the statement end", async () => {
+    // perStatement path: an error with a large column is clamped within the
+    // statement bounds by convertStatementErrorToDiagnostic.
+    const doc = "SELECT 1;";
+    const parser = {
+      validateSql: vi.fn(async () => []),
+      // The structure analyzer derives per-statement errors from parse().
+      parse: vi.fn(async () => ({
+        success: false,
+        errors: [{ message: "boom", line: 1, column: 999, severity: "error" as const }],
+      })),
+      extractTableReferences: vi.fn(async () => []),
+      extractColumnReferences: vi.fn(async () => []),
+    } as unknown as SqlParser;
+
+    const diagnostics = await lint(doc, { parser });
+
+    expect(diagnostics.length).toBeGreaterThanOrEqual(1);
+    for (const d of diagnostics) {
+      expect(d.from).toBeLessThanOrEqual(doc.length);
+      expect(d.to).toBeLessThanOrEqual(doc.length);
+      expect(d.to).toBeGreaterThanOrEqual(d.from);
+    }
+  });
 });