test(vnext): enforce namespace coverage floor

Author: Light2Dark

src/vnext/__tests__/namespace-catalog-boundary.test.ts

@@ -61,6 +61,11 @@ describe("namespace catalog boundary", () => {
     expect(context?.id).toBe("namespaces");
     context?.search(request(), new AbortController().signal);
     expect(receivers).toEqual([undefined]);
+    expect(Reflect.apply(
+      resolveSqlNamespaceCatalogProvider,
+      undefined,
+      [{}],
+    )).toBeNull();
     expect(Object.isFrozen(handle)).toBe(true);
   });
 
@@ -136,6 +141,24 @@ describe("namespace catalog boundary", () => {
     const accessor = { ...valid };
     Object.defineProperty(accessor, "prefix", { get: vi.fn() });
     cases.push(accessor);
+    cases.push({
+      ...valid,
+      qualifier: new Proxy([], {
+        getOwnPropertyDescriptor: (_target, key) => {
+          if (key === "length") throw new Error("length trap");
+          return undefined;
+        },
+      }),
+    });
+    cases.push({
+      ...valid,
+      qualifier: new Proxy([{ quoted: false, value: "x" }], {
+        getOwnPropertyDescriptor: (target, key) => {
+          if (key === "0") throw new Error("element trap");
+          return Reflect.getOwnPropertyDescriptor(target, key);
+        },
+      }),
+    });
     for (const value of cases) {
       expect(createSqlNamespaceCatalogSearchRequest(value).status)
         .toBe("malformed");
@@ -208,6 +231,41 @@ describe("namespace catalog boundary", () => {
     });
   });
 
+  it("orders tied identities and accepts quoted paths without detail", () => {
+    const provider = captured();
+    const base = {
+      canonicalPath: [{
+        quoted: true,
+        role: "schema",
+        value: "Main",
+      }],
+      insertText: "\"Main\"",
+      matchQuality: "exact",
+    };
+    const decoded = decodeSqlNamespaceCatalogSearchResponse(
+      provider,
+      request(),
+      {
+        containers: [
+          { ...base, containerEntityId: "z" },
+          { ...base, containerEntityId: "a" },
+        ],
+        coverage: "complete",
+        epoch,
+        status: "ready",
+      },
+    );
+    expect(decoded).toMatchObject({
+      status: "accepted",
+      value: {
+        containers: [
+          { containerEntityId: "a" },
+          { containerEntityId: "z" },
+        ],
+      },
+    });
+  });
+
   it("rejects malformed, conflicting, stale, and oversized responses", () => {
     const provider = captured();
     const valid = {
@@ -245,6 +303,7 @@ describe("namespace catalog boundary", () => {
         (_, index) => container(String(index), "schema", String(index)),
       ) },
       conflicting,
+      { ...valid, containers: [null] },
       { epoch, extra: true, status: "loading" },
       { code: "bad", epoch, retry: "never", status: "failed" },
       { code: "unknown", epoch, retry: "bad", status: "failed" },
@@ -261,5 +320,10 @@ describe("namespace catalog boundary", () => {
         value,
       ).status).toBe("malformed");
     }
+    expect(Reflect.apply(
+      decodeSqlNamespaceCatalogSearchResponse,
+      undefined,
+      [{}, request(), valid],
+    )).toMatchObject({ status: "malformed" });
   });
 });

src/vnext/__tests__/namespace-catalog-coordinator.test.ts

@@ -8,6 +8,7 @@ import {
   prepareSqlNamespaceCatalogSearch,
 } from "../namespace-completion.js";
 import type {
+  SqlNamespaceCatalogResolvedContainer,
   SqlNamespaceCatalogSearchRequest,
 } from "../namespace-catalog-types.js";
 import type { SqlCatalogEpoch } from "../relation-completion-types.js";
@@ -91,12 +92,15 @@ describe("namespace catalog coordinator", () => {
       searches.push(request);
       return response(request);
     });
-    const outcome = await owner.request(input()).result;
+    const outcome = await owner.request({
+      ...input(),
+      prefix: { quoted: true, value: "ma" },
+    }).result;
     expect(searches).toHaveLength(1);
     expect(searches[0]).toMatchObject({
       dialectId: "duckdb",
       limit: 10,
-      prefix: { value: "ma" },
+      prefix: { quoted: true, value: "ma" },
       qualifier: [{ value: "memory" }],
       scope: "connection",
     });
@@ -169,7 +173,7 @@ describe("namespace catalog coordinator", () => {
     });
     expect(signals[1]?.aborted).toBe(true);
     pending[0]?.resolve({});
-    pending[1]?.resolve({});
+    pending[1]?.reject(new Error("late"));
     await Promise.resolve();
   });
 
@@ -188,6 +192,7 @@ describe("namespace catalog coordinator", () => {
     const first = owner.request(input("first"));
     const second = other.owner.request(input("second"));
     owner.dispose();
+    owner.dispose();
     await expect(first.result).resolves.toEqual({
       reason: "disposed",
       status: "unavailable",
@@ -199,6 +204,7 @@ describe("namespace catalog coordinator", () => {
     await Promise.resolve();
     expect(secondSettled).toBe(false);
     coordinator.dispose();
+    coordinator.dispose();
     await expect(second.result).resolves.toEqual({
       reason: "disposed",
       status: "unavailable",
@@ -276,10 +282,12 @@ describe("namespace catalog coordinator", () => {
       scope: "scope",
     });
     if (prepared.status !== "prepared") throw new Error("prepared");
-    expect(await prepared.owner.request({
+    const invalidTicket = prepared.owner.request({
       ...input(),
       limit: 0,
-    }).result).toMatchObject({
+    });
+    invalidTicket.cancel();
+    expect(await invalidTicket.result).toMatchObject({
       reason: "invalid-request",
       status: "unavailable",
     });
@@ -372,21 +380,38 @@ describe("namespace completion composer", () => {
     const catalog = catalogResponse();
     const main = catalog.containers[0];
     if (!main) throw new Error("main");
+    const parent = main.canonicalPath[0];
+    const child = main.canonicalPath[1];
+    if (!child) throw new Error("child");
+    const copied: SqlNamespaceCatalogResolvedContainer = {
+      ...main,
+      canonicalPath: [
+        parent,
+        { ...child, quoted: true },
+      ],
+      containerEntityId: "main-copy",
+      provenance: {
+        ...main.provenance,
+        containerEntityId: "main-copy",
+      },
+    };
+    const tied: SqlNamespaceCatalogResolvedContainer = {
+      ...main,
+      containerEntityId: "aaa",
+      provenance: {
+        ...main.provenance,
+        containerEntityId: "aaa",
+      },
+    };
     const duplicated = {
       ...readyOutcome,
       response: {
         ...catalog,
         containers: [
           ...catalog.containers,
           main,
-          {
-            ...main,
-            containerEntityId: "main-copy",
-            provenance: {
-              ...main.provenance,
-              containerEntityId: "main-copy",
-            },
-          },
+          copied,
+          tied,
         ],
       },
     };
@@ -398,7 +423,7 @@ describe("namespace completion composer", () => {
       replacementRange: { from: 10, to: 12 },
     });
     expect(all?.value.items.map((value) => value.label))
-      .toEqual(["main", "main", "metrics"]);
+      .toEqual(["main", "main", "main", "metrics"]);
     const composition = composeSqlNamespaceCompletion({
       matchPrefix: (candidate, prefix) =>
         candidate.value.startsWith(prefix.value)
@@ -421,6 +446,10 @@ describe("namespace completion composer", () => {
           edit: { from: 10, insert: "main", to: 12 },
           label: "main",
           role: "schema",
+        }, {
+          edit: { from: 10, insert: "main", to: 12 },
+          label: "main",
+          role: "schema",
         }],
       },
     });

src/vnext/namespace-catalog-coordinator.ts

@@ -356,18 +356,20 @@ function request(
       status: "usable",
     }));
   }
-  let resolveResult:
-    (value: SqlNamespaceCatalogSearchOutcome) => void =
-      (): void => {};
+  const resolver: {
+    value:
+      | ((value: SqlNamespaceCatalogSearchOutcome) => void)
+      | null;
+  } = { value: null };
   const result = new Promise<SqlNamespaceCatalogSearchOutcome>(
     (resolve) => {
-      resolveResult = resolve;
+      resolver.value = resolve;
     },
   );
   const consumer: ConsumerState = {
     controller: new AbortController(),
     owner,
-    resolve: resolveResult,
+    resolve: resolver.value,
     settled: false,
   };
   owner.active = consumer;