Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

9.8 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { reactive } from "vue";
import type { ObjectBrowserRow } from "@/lib/table/objectBrowserRows";
import { cacheObjectBrowserRows, clearObjectBrowserRowsCache, createObjectBrowserRowsCacheWriteToken, getCachedObjectBrowserRows, getCachedObjectBrowserRowsForScaffold, invalidateObjectBrowserRowsCache } from "@/lib/table/objectBrowserRowsCache";

const row: ObjectBrowserRow = {
  id: "table:users",
  name: "users",
  displayName: "users",
  type: "TABLE",
};

function cacheRows(scope: Parameters<typeof createObjectBrowserRowsCacheWriteToken>[0], rows: readonly ObjectBrowserRow[] = [row]) {
  return cacheObjectBrowserRows(createObjectBrowserRowsCacheWriteToken(scope), rows);
}

function deferred<T>() {
  let resolve!: (value: T) => void;
  const promise = new Promise<T>((resolvePromise) => {
    resolve = resolvePromise;
  });
  return { promise, resolve };
}

describe("objectBrowserRowsCache", () => {
  beforeEach(() => clearObjectBrowserRowsCache());
  afterEach(() => vi.useRealTimers());

  it("restores cached rows only for the same object browser scope", () => {
    const scope = { connectionId: "c1", database: "db", schema: "public" };
    cacheRows(scope);

    expect(getCachedObjectBrowserRows(scope)).toEqual([row]);
    expect(getCachedObjectBrowserRows({ ...scope, schema: "archive" })).toBeUndefined();
    expect(getCachedObjectBrowserRows({ ...scope, connectionId: "c2" })).toBeUndefined();
  });

  it("returns copies so component updates do not mutate the cached rows", () => {
    const scope = { connectionId: "c1", database: "db", schema: "public" };
    cacheRows(scope);

    const cached = getCachedObjectBrowserRows(scope)!;
    cached[0].displayName = "changed";

    expect(getCachedObjectBrowserRows(scope)?.[0].displayName).toBe("users");
  });

  it("separates the trigger exact contract from legacy scaffolds and preserves raw scopes", () => {
    const legacy = { connectionId: "c1", database: "db", schema: " Owner " };
    const exact = { ...legacy, oracleTriggerContract: 1 as const };
    cacheRows(legacy);
    expect(getCachedObjectBrowserRows(exact)).toBeUndefined();
    cacheRows(exact, [{ ...row, name: "Exact" }]);
    expect(getCachedObjectBrowserRows(legacy)?.[0].name).toBe("users");
    expect(getCachedObjectBrowserRows(exact)?.[0].name).toBe("Exact");
    expect(getCachedObjectBrowserRows({ ...exact, schema: "Owner" })).toBeUndefined();
  });

  it("does not share mutable nested trigger snapshots across a cache boundary", () => {
    const scope = { connectionId: "c1", database: "db", schema: " Owner ", oracleTriggerContract: 1 as const };
    const triggerRow: ObjectBrowserRow = {
      ...row,
      type: "TRIGGER",
      trigger: {
        name: " Trigger ",
        event: "INSERT",
        timing: "BEFORE",
        enabled: false,
        oracle_metadata: { contractVersion: 1, identityMode: "exact", owner: " Owner ", name: " Trigger ", engine: "oracle", scope: "VIEW", parent: { owner: "ParentOwner", name: "Parent", objectType: "VIEW" }, reads: { identity: { state: "available" } } },
      },
    };
    cacheRows(scope, [reactive(triggerRow)]);
    triggerRow.trigger!.oracle_metadata!.parent!.name = "changed at producer";
    const cached = getCachedObjectBrowserRows(scope)!;
    expect(cached[0].trigger!.oracle_metadata!.parent!.name).toBe("Parent");
    cached[0].trigger!.oracle_metadata!.reads.identity!.state = "error";
    expect(getCachedObjectBrowserRows(scope)![0].trigger!.oracle_metadata!.reads.identity!.state).toBe("available");
  });

  it("invalidates both trigger contracts only in the affected raw schema and rejects their late writers", () => {
    const exact = { connectionId: "c1", database: "db", schema: " Owner ", oracleTriggerContract: 1 as const };
    const legacy = { connectionId: "c1", database: "db", schema: " Owner " };
    const other = { ...exact, schema: "Owner" };
    const exactToken = createObjectBrowserRowsCacheWriteToken(exact);
    const legacyToken = createObjectBrowserRowsCacheWriteToken(legacy);
    cacheRows(exact);
    cacheRows(legacy);
    cacheRows(other);
    expect(invalidateObjectBrowserRowsCache({ connectionId: "c1", database: "db", schema: " Owner " })).toBe(2);
    expect(cacheObjectBrowserRows(exactToken, [row])).toBeUndefined();
    expect(cacheObjectBrowserRows(legacyToken, [row])).toBeUndefined();
    expect(getCachedObjectBrowserRows(other)).toEqual([row]);
  });

  it("restores fresh rows when a remounted component reads the shared cache", () => {
    vi.useFakeTimers();
    vi.setSystemTime(new Date("2026-07-28T00:00:00Z"));
    const scope = { connectionId: "c1", database: "db", schema: "public" };
    cacheRows(scope);

    expect(getCachedObjectBrowserRows(scope)).toEqual([row]);
  });

  it("rejects cached rows after the TTL", () => {
    vi.useFakeTimers();
    vi.setSystemTime(new Date("2026-07-28T00:00:00Z"));
    const scope = { connectionId: "c1", database: "db", schema: "public" };
    cacheRows(scope);

    vi.advanceTimersByTime(30_001);
    expect(getCachedObjectBrowserRows(scope)).toBeUndefined();
  });

  it("invalidates matching connection and database scopes", () => {
    const first = { connectionId: "c1", database: "db1", schema: "public" };
    const second = { connectionId: "c1", database: "db2", schema: "public" };
    const third = { connectionId: "c2", database: "db1", schema: "public" };
    cacheRows(first);
    cacheRows(second);
    cacheRows(third);

    expect(invalidateObjectBrowserRowsCache({ connectionId: "c1", database: "db1" })).toBe(1);
    expect(getCachedObjectBrowserRows(first)).toBeUndefined();
    expect(getCachedObjectBrowserRows(second)).toEqual([row]);
    expect(getCachedObjectBrowserRows(third)).toEqual([row]);
  });

  it("rejects a late cache write started before matching metadata invalidation", async () => {
    const invalidatedScope = { connectionId: "c1", database: "db1", schema: "public" };
    const isolatedScope = { connectionId: "c1", database: "db2", schema: "public" };
    const invalidatedToken = createObjectBrowserRowsCacheWriteToken(invalidatedScope);
    const isolatedToken = createObjectBrowserRowsCacheWriteToken(isolatedScope);
    const pendingRows = deferred<readonly ObjectBrowserRow[]>();
    const lateWrite = pendingRows.promise.then((rows) => cacheObjectBrowserRows(invalidatedToken, rows));

    invalidateObjectBrowserRowsCache({ connectionId: "c1", database: "db1", schema: "public" });
    pendingRows.resolve([row]);

    expect(await lateWrite).toBeUndefined();
    expect(cacheObjectBrowserRows(isolatedToken, [row])).toEqual(expect.any(Number));
    expect(getCachedObjectBrowserRows(invalidatedScope)).toBeUndefined();
    expect(getCachedObjectBrowserRows(isolatedScope)).toEqual([row]);
  });

  it("rejects old write tokens after their bounded generation state is evicted", () => {
    const staleScope = { connectionId: "stale", database: "db", schema: "public" };
    const staleToken = createObjectBrowserRowsCacheWriteToken(staleScope);
    for (let index = 0; index < 128; index += 1) {
      createObjectBrowserRowsCacheWriteToken({ connectionId: `c${index}`, database: "db", schema: "public" });
    }

    expect(cacheObjectBrowserRows(staleToken, [row])).toBeUndefined();
    expect(getCachedObjectBrowserRows(staleScope)).toBeUndefined();
  });

  it("preserves the original object list freshness when statistics update cached rows", () => {
    vi.useFakeTimers();
    vi.setSystemTime(new Date("2026-07-28T00:00:00Z"));
    const scope = { connectionId: "c1", database: "db", schema: "public" };
    const token = createObjectBrowserRowsCacheWriteToken(scope);
    const fetchedAt = cacheObjectBrowserRows(token, [row]);

    vi.advanceTimersByTime(29_000);
    cacheObjectBrowserRows(token, [{ ...row, estimatedRows: 42 }], { cachedAt: fetchedAt });
    expect(getCachedObjectBrowserRows(scope)?.[0].estimatedRows).toBe(42);

    vi.advanceTimersByTime(1_001);
    expect(getCachedObjectBrowserRows(scope)).toBeUndefined();
  });

  it("projects table invalidation onto the object list cache scope", () => {
    const scope = { connectionId: "c1", database: "db", schema: "public" };
    cacheRows(scope, [{ ...row, estimatedRows: 42 }]);

    expect(invalidateObjectBrowserRowsCache({ ...scope, tableName: "users" })).toBe(1);
    expect(getCachedObjectBrowserRows(scope)).toBeUndefined();
  });

  describe("scaffold reads (allowStale)", () => {
    it("returns a fresh hit marked stale=false before the TTL", () => {
      vi.useFakeTimers();
      vi.setSystemTime(new Date("2026-07-28T00:00:00Z"));
      const scope = { connectionId: "c1", database: "db", schema: "public" };
      cacheRows(scope);

      const hit = getCachedObjectBrowserRowsForScaffold(scope);
      expect(hit).toBeDefined();
      expect(hit!.rows).toEqual([row]);
      expect(hit!.stale).toBe(false);
      expect(hit!.ageMs).toBe(0);
      expect(hit!.cachedAt).toBe(Date.now());
    });

    it("surfaces an expired entry as a stale scaffold instead of refusing it", () => {
      vi.useFakeTimers();
      vi.setSystemTime(new Date("2026-07-28T00:00:00Z"));
      const scope = { connectionId: "c1", database: "db", schema: "public" };
      cacheRows(scope);

      vi.advanceTimersByTime(30_001);
      const hit = getCachedObjectBrowserRowsForScaffold(scope);
      expect(hit).toBeDefined();
      expect(hit!.rows).toEqual([row]);
      expect(hit!.stale).toBe(true);
      expect(hit!.ageMs).toBeGreaterThan(30_000);
    });

    it("returns undefined when no scaffold is available (uncached or invalidated)", () => {
      const scope = { connectionId: "c1", database: "db", schema: "public" };
      expect(getCachedObjectBrowserRowsForScaffold(scope)).toBeUndefined();

      cacheRows(scope);
      invalidateObjectBrowserRowsCache({ connectionId: "c1", database: "db", schema: "public" });
      expect(getCachedObjectBrowserRowsForScaffold(scope)).toBeUndefined();
    });
  });
});