@useatlas/create 0.0.2 → 0.0.3

package/templates/docker/src/lib/db/__tests__/duckdb.test.ts

@@ -1,141 +0,0 @@
-/**
- * Tests for the DuckDB adapter (duckdb.ts) and DuckDB URL parsing.
- *
- * Uses a real in-memory DuckDB instance (no mocks) to verify end-to-end
- * query execution, column extraction, and close behavior.
- */
-import { describe, it, expect, afterEach } from "bun:test";
-import { parseDuckDBUrl, createDuckDBConnection } from "../duckdb";
-import type { DBConnection } from "../connection";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-
-describe("parseDuckDBUrl", () => {
-  it("parses duckdb://:memory: as in-memory", () => {
-    const config = parseDuckDBUrl("duckdb://:memory:");
-    expect(config.path).toBe(":memory:");
-  });
-
-  it("parses bare duckdb:// as in-memory", () => {
-    const config = parseDuckDBUrl("duckdb://");
-    expect(config.path).toBe(":memory:");
-  });
-
-  it("parses duckdb:///absolute/path.duckdb", () => {
-    const config = parseDuckDBUrl("duckdb:///tmp/test.duckdb");
-    expect(config.path).toBe("/tmp/test.duckdb");
-  });
-
-  it("parses duckdb://relative/path.duckdb", () => {
-    const config = parseDuckDBUrl("duckdb://data/test.duckdb");
-    expect(config.path).toBe("data/test.duckdb");
-  });
-
-  it("throws for non-duckdb:// URL", () => {
-    expect(() => parseDuckDBUrl("postgresql://localhost/db")).toThrow("Invalid DuckDB URL");
-  });
-});
-
-describe("createDuckDBConnection", () => {
-  let conn: DBConnection | null = null;
-
-  afterEach(async () => {
-    if (conn) {
-      await conn.close();
-      conn = null;
-    }
-  });
-
-  it("creates a connection and runs a simple query", async () => {
-    conn = createDuckDBConnection({ path: ":memory:", readOnly: false });
-    const result = await conn.query("SELECT 42 AS answer");
-    expect(result.columns).toEqual(["answer"]);
-    expect(result.rows).toHaveLength(1);
-    expect(result.rows[0].answer).toBe(42);
-  });
-
-  it("returns correct columns and rows for multi-column queries", async () => {
-    conn = createDuckDBConnection({ path: ":memory:", readOnly: false });
-    const result = await conn.query("SELECT 1 AS a, 'hello' AS b, true AS c");
-    expect(result.columns).toEqual(["a", "b", "c"]);
-    expect(result.rows).toHaveLength(1);
-    expect(result.rows[0].a).toBe(1);
-    expect(result.rows[0].b).toBe("hello");
-    expect(result.rows[0].c).toBe(true);
-  });
-
-  it("handles empty result sets", async () => {
-    conn = createDuckDBConnection({ path: ":memory:", readOnly: false });
-    const result = await conn.query("SELECT 1 AS n WHERE false");
-    expect(result.columns).toEqual(["n"]);
-    expect(result.rows).toHaveLength(0);
-  });
-
-  it("supports CREATE TABLE and SELECT in read-write mode", async () => {
-    conn = createDuckDBConnection({ path: ":memory:", readOnly: false });
-    await conn.query("CREATE TABLE test (id INTEGER, name VARCHAR)");
-    await conn.query("INSERT INTO test VALUES (1, 'alice'), (2, 'bob')");
-    const result = await conn.query("SELECT * FROM test ORDER BY id");
-    expect(result.columns).toEqual(["id", "name"]);
-    expect(result.rows).toHaveLength(2);
-    expect(result.rows[0].name).toBe("alice");
-    expect(result.rows[1].name).toBe("bob");
-  });
-
-  it("supports VALUES clause for inline data", async () => {
-    conn = createDuckDBConnection({ path: ":memory:", readOnly: false });
-    const result = await conn.query(
-      "SELECT * FROM (VALUES (1, 'a'), (2, 'b'), (3, 'c')) AS t(id, letter)"
-    );
-    expect(result.rows).toHaveLength(3);
-  });
-
-  it("close is idempotent", async () => {
-    conn = createDuckDBConnection({ path: ":memory:", readOnly: false });
-    await conn.query("SELECT 1");
-    await conn.close();
-    await conn.close(); // Should not throw
-    conn = null; // Prevent afterEach from closing again
-  });
-
-  it("enforces read-only mode for file-based databases", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "atlas-duckdb-ro-"));
-    try {
-      const dbPath = path.join(tmpDir, "test.duckdb");
-
-      // Create and populate the database first (read-write)
-      const rwConn = createDuckDBConnection({ path: dbPath, readOnly: false });
-      await rwConn.query("CREATE TABLE test (id INTEGER)");
-      await rwConn.query("INSERT INTO test VALUES (1)");
-      await rwConn.close();
-
-      // Open in read-only mode (default for file-based)
-      conn = createDuckDBConnection({ path: dbPath });
-      const result = await conn.query("SELECT * FROM test");
-      expect(result.rows).toHaveLength(1);
-
-      // Write operations should fail
-      expect(conn.query("INSERT INTO test VALUES (2)")).rejects.toThrow();
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  it("respects timeoutMs parameter", async () => {
-    conn = createDuckDBConnection({ path: ":memory:", readOnly: false });
-    // A very short timeout on a query that takes some time
-    await expect(
-      conn.query("SELECT COUNT(*) FROM generate_series(1, 100000000)", 1)
-    ).rejects.toThrow("timed out");
-  });
-
-  it("can recover after close by re-initializing", async () => {
-    conn = createDuckDBConnection({ path: ":memory:", readOnly: false });
-    await conn.query("SELECT 1");
-    await conn.close();
-    // After close + retry, lazy init should re-create the connection
-    const result = await conn.query("SELECT 42 AS answer");
-    expect(result.rows[0].answer).toBe(42);
-  });
-});

package/templates/docker/src/lib/db/__tests__/salesforce.test.ts

@@ -1,339 +0,0 @@
-/**
- * Tests for the Salesforce DataSource adapter and registry.
- */
-import { describe, it, expect, beforeEach, mock } from "bun:test";
-
-// Mock jsforce before importing the module under test
-const mockLogin = mock(() => Promise.resolve());
-const mockLogout = mock(() => Promise.resolve());
-const mockQuery = mock(() =>
-  Promise.resolve({
-    records: [
-      { attributes: { type: "Account" }, Id: "001", Name: "Acme" },
-      { attributes: { type: "Account" }, Id: "002", Name: "Widget Co" },
-    ],
-  }),
-);
-const mockDescribe = mock(() =>
-  Promise.resolve({
-    name: "Account",
-    label: "Account",
-    fields: [
-      {
-        name: "Id",
-        type: "id",
-        label: "Account ID",
-        picklistValues: [],
-        referenceTo: [],
-        nillable: false,
-        length: 18,
-      },
-      {
-        name: "Name",
-        type: "string",
-        label: "Account Name",
-        picklistValues: [],
-        referenceTo: [],
-        nillable: false,
-        length: 255,
-      },
-      {
-        name: "Industry",
-        type: "picklist",
-        label: "Industry",
-        picklistValues: [
-          { value: "Technology", label: "Technology", active: true },
-          { value: "Finance", label: "Finance", active: true },
-        ],
-        referenceTo: [],
-        nillable: true,
-        length: 255,
-      },
-    ],
-  }),
-);
-const mockDescribeGlobal = mock(() =>
-  Promise.resolve({
-    sobjects: [
-      { name: "Account", label: "Account", queryable: true },
-      { name: "Contact", label: "Contact", queryable: true },
-      { name: "ApexLog", label: "Apex Log", queryable: false },
-    ],
-  }),
-);
-
-mock.module("jsforce", () => ({
-  Connection: class MockConnection {
-    login = mockLogin;
-    logout = mockLogout;
-    query = mockQuery;
-    describe = mockDescribe;
-    describeGlobal = mockDescribeGlobal;
-  },
-}));
-
-const {
-  parseSalesforceURL,
-  createSalesforceDataSource,
-  registerSalesforceSource,
-  getSalesforceSource,
-  listSalesforceSources,
-  describeSalesforceSources,
-  _resetSalesforceSources,
-} = await import("@atlas/api/lib/db/salesforce");
-
-describe("parseSalesforceURL", () => {
-  it("parses a full URL", () => {
-    const config = parseSalesforceURL(
-      "salesforce://user%40example.com:pass123@login.salesforce.com?token=SECTOKEN",
-    );
-    expect(config.loginUrl).toBe("https://login.salesforce.com");
-    expect(config.username).toBe("user@example.com");
-    expect(config.password).toBe("pass123");
-    expect(config.securityToken).toBe("SECTOKEN");
-  });
-
-  it("parses minimal URL with defaults", () => {
-    const config = parseSalesforceURL("salesforce://admin:secret@localhost");
-    expect(config.loginUrl).toBe("https://localhost");
-    expect(config.username).toBe("admin");
-    expect(config.password).toBe("secret");
-    expect(config.securityToken).toBeUndefined();
-  });
-
-  it("parses sandbox URL (test.salesforce.com)", () => {
-    const config = parseSalesforceURL(
-      "salesforce://user:pass@test.salesforce.com",
-    );
-    expect(config.loginUrl).toBe("https://test.salesforce.com");
-  });
-
-  it("parses OAuth params", () => {
-    const config = parseSalesforceURL(
-      "salesforce://user:pass@login.salesforce.com?clientId=CID&clientSecret=CSEC",
-    );
-    expect(config.clientId).toBe("CID");
-    expect(config.clientSecret).toBe("CSEC");
-  });
-
-  it("throws for non-salesforce scheme", () => {
-    expect(() => parseSalesforceURL("postgresql://user:pass@localhost")).toThrow(
-      "expected salesforce://",
-    );
-  });
-
-  it("throws for missing username", () => {
-    expect(() =>
-      parseSalesforceURL("salesforce://:pass@login.salesforce.com"),
-    ).toThrow("missing username");
-  });
-
-  it("throws for missing password", () => {
-    expect(() =>
-      parseSalesforceURL("salesforce://user@login.salesforce.com"),
-    ).toThrow("missing password");
-  });
-});
-
-describe("createSalesforceDataSource", () => {
-  beforeEach(() => {
-    mockLogin.mockClear();
-    mockLogout.mockClear();
-    mockQuery.mockClear();
-    mockDescribe.mockClear();
-    mockDescribeGlobal.mockClear();
-  });
-
-  it("query returns columns and rows without attributes key", async () => {
-    const source = createSalesforceDataSource({
-      loginUrl: "https://login.salesforce.com",
-      username: "user",
-      password: "pass",
-    });
-
-    const result = await source.query("SELECT Id, Name FROM Account");
-    expect(result.columns).toEqual(["Id", "Name"]);
-    expect(result.rows).toEqual([
-      { Id: "001", Name: "Acme" },
-      { Id: "002", Name: "Widget Co" },
-    ]);
-    expect(mockLogin).toHaveBeenCalledTimes(1);
-  });
-
-  it("query returns empty result for no records", async () => {
-    mockQuery.mockImplementationOnce(() =>
-      Promise.resolve({ records: [] }),
-    );
-    const source = createSalesforceDataSource({
-      loginUrl: "https://login.salesforce.com",
-      username: "user",
-      password: "pass",
-    });
-
-    const result = await source.query("SELECT Id FROM Account WHERE Id = 'none'");
-    expect(result.columns).toEqual([]);
-    expect(result.rows).toEqual([]);
-  });
-
-  it("describe returns mapped fields", async () => {
-    const source = createSalesforceDataSource({
-      loginUrl: "https://login.salesforce.com",
-      username: "user",
-      password: "pass",
-    });
-
-    const desc = await source.describe("Account");
-    expect(desc.name).toBe("Account");
-    expect(desc.fields).toHaveLength(3);
-    expect(desc.fields[0].name).toBe("Id");
-    expect(desc.fields[2].picklistValues).toHaveLength(2);
-  });
-
-  it("listObjects filters to queryable only", async () => {
-    const source = createSalesforceDataSource({
-      loginUrl: "https://login.salesforce.com",
-      username: "user",
-      password: "pass",
-    });
-
-    const objects = await source.listObjects();
-    expect(objects).toHaveLength(2);
-    expect(objects.map((o) => o.name)).toEqual(["Account", "Contact"]);
-  });
-
-  it("close calls logout", async () => {
-    const source = createSalesforceDataSource({
-      loginUrl: "https://login.salesforce.com",
-      username: "user",
-      password: "pass",
-    });
-
-    // Force login first
-    await source.listObjects();
-    await source.close();
-    expect(mockLogout).toHaveBeenCalledTimes(1);
-  });
-
-  it("appends security token to password on login", async () => {
-    const source = createSalesforceDataSource({
-      loginUrl: "https://login.salesforce.com",
-      username: "user",
-      password: "pass",
-      securityToken: "TOKEN123",
-    });
-
-    await source.listObjects();
-    expect(mockLogin).toHaveBeenCalledWith("user", "passTOKEN123");
-  });
-
-  it("serializes concurrent login attempts (no duplicate logins)", async () => {
-    // Make login take some time so concurrent calls overlap
-    mockLogin.mockImplementation(
-      () => new Promise((resolve) => setTimeout(resolve, 50)),
-    );
-
-    const source = createSalesforceDataSource({
-      loginUrl: "https://login.salesforce.com",
-      username: "user",
-      password: "pass",
-    });
-
-    // Fire three concurrent queries — all need login
-    await Promise.all([
-      source.query("SELECT Id FROM Account"),
-      source.listObjects(),
-      source.describe("Account"),
-    ]);
-
-    // Login should have been called exactly once despite three concurrent callers
-    expect(mockLogin).toHaveBeenCalledTimes(1);
-  });
-
-  it("close without prior login is a no-op", async () => {
-    const source = createSalesforceDataSource({
-      loginUrl: "https://login.salesforce.com",
-      username: "user",
-      password: "pass",
-    });
-
-    // Close without ever calling login — should not throw or call logout
-    await source.close();
-    expect(mockLogout).not.toHaveBeenCalled();
-    expect(mockLogin).not.toHaveBeenCalled();
-  });
-});
-
-describe("Salesforce source registry", () => {
-  beforeEach(() => {
-    _resetSalesforceSources();
-    mockLogin.mockClear();
-    mockLogout.mockClear();
-  });
-
-  it("register and get a source", () => {
-    registerSalesforceSource("sf1", {
-      loginUrl: "https://login.salesforce.com",
-      username: "user",
-      password: "pass",
-    });
-
-    const source = getSalesforceSource("sf1");
-    expect(source).toBeDefined();
-    expect(source.query).toBeDefined();
-  });
-
-  it("throws for unregistered source", () => {
-    expect(() => getSalesforceSource("nonexistent")).toThrow(
-      'not registered',
-    );
-  });
-
-  it("lists registered sources", () => {
-    registerSalesforceSource("sf1", {
-      loginUrl: "https://login.salesforce.com",
-      username: "user",
-      password: "pass",
-    });
-    registerSalesforceSource("sf2", {
-      loginUrl: "https://test.salesforce.com",
-      username: "admin",
-      password: "secret",
-    });
-
-    expect(listSalesforceSources()).toEqual(["sf1", "sf2"]);
-  });
-
-  it("reset clears all sources", () => {
-    registerSalesforceSource("sf1", {
-      loginUrl: "https://login.salesforce.com",
-      username: "user",
-      password: "pass",
-    });
-
-    _resetSalesforceSources();
-    expect(listSalesforceSources()).toEqual([]);
-  });
-
-  it("describeSalesforceSources returns metadata for registered sources", () => {
-    registerSalesforceSource("sf1", {
-      loginUrl: "https://login.salesforce.com",
-      username: "user",
-      password: "pass",
-    });
-    registerSalesforceSource("sf2", {
-      loginUrl: "https://test.salesforce.com",
-      username: "admin",
-      password: "secret",
-    });
-
-    const meta = describeSalesforceSources();
-    expect(meta).toEqual([
-      { id: "sf1", dbType: "salesforce" },
-      { id: "sf2", dbType: "salesforce" },
-    ]);
-  });
-
-  it("describeSalesforceSources returns empty array when no sources registered", () => {
-    expect(describeSalesforceSources()).toEqual([]);
-  });
-});

package/templates/docker/src/lib/db/__tests__/snowflake.test.ts

@@ -1,217 +0,0 @@
-/**
- * Tests for Snowflake URL parsing, detectDBType integration, and connection behavior.
- */
-import { describe, it, expect, mock, beforeEach } from "bun:test";
-import { resolve } from "path";
-
-// Track all SQL statements executed via the mock connection.
-// Reset in each describe block's beforeEach to prevent cross-test pollution.
-let executedStatements: string[] = [];
-
-// Flag to make the QUERY_TAG ALTER SESSION fail in specific tests
-let queryTagShouldFail = false;
-
-// Mock logger to capture structured log output
-const mockWarn = mock(() => {});
-mock.module("@atlas/api/lib/logger", () => ({
-  createLogger: () => ({
-    info: mock(() => {}),
-    warn: mockWarn,
-    error: mock(() => {}),
-    debug: mock(() => {}),
-    child: () => ({ info: mock(() => {}), warn: mockWarn, error: mock(() => {}), debug: mock(() => {}) }),
-  }),
-}));
-
-// Mock database drivers before importing connection module
-mock.module("pg", () => ({
-  Pool: class MockPool {
-    async query() { return { rows: [], fields: [] }; }
-    async connect() { return { async query() { return { rows: [], fields: [] }; }, release() {} }; }
-    async end() {}
-  },
-}));
-
-mock.module("mysql2/promise", () => ({
-  createPool: () => ({
-    async getConnection() { return { async execute() { return [[], []]; }, release() {} }; },
-    async end() {},
-  }),
-}));
-
-mock.module("snowflake-sdk", () => ({
-  configure: () => {},
-  createPool: () => ({
-    use: async (fn: (conn: unknown) => Promise<unknown>) => {
-      const mockConn = {
-        execute: (opts: { sqlText: string; complete: (err: Error | null, stmt: unknown, rows: unknown[]) => void }) => {
-          executedStatements.push(opts.sqlText);
-          if (queryTagShouldFail && opts.sqlText.includes("QUERY_TAG")) {
-            opts.complete(new Error("Insufficient privileges to set QUERY_TAG"), null, []);
-            return;
-          }
-          opts.complete(null, { getColumns: () => [] }, []);
-        },
-      };
-      return fn(mockConn);
-    },
-    drain: async () => {},
-    clear: async () => {},
-  }),
-}));
-
-// Cache-busting import to get a fresh module instance, avoiding interference
-// from global mock.module("@atlas/api/lib/db/connection") in other test files
-// (e.g. sql.test.ts) that don't export parseSnowflakeURL.
-const connModPath = resolve(__dirname, "../connection.ts");
-const connMod = await import(`${connModPath}?t=${Date.now()}`);
-const parseSnowflakeURL = connMod.parseSnowflakeURL as typeof import("../connection").parseSnowflakeURL;
-const detectDBType = connMod.detectDBType as typeof import("../connection").detectDBType;
-
-describe("parseSnowflakeURL", () => {
-  it("parses full Snowflake URL with all components", () => {
-    const opts = parseSnowflakeURL(
-      "snowflake://myuser:mypass@xy12345.us-east-1/mydb/myschema?warehouse=COMPUTE_WH&role=ANALYST"
-    );
-    expect(opts.account).toBe("xy12345.us-east-1");
-    expect(opts.username).toBe("myuser");
-    expect(opts.password).toBe("mypass");
-    expect(opts.database).toBe("mydb");
-    expect(opts.schema).toBe("myschema");
-    expect(opts.warehouse).toBe("COMPUTE_WH");
-    expect(opts.role).toBe("ANALYST");
-  });
-
-  it("parses URL with database only (no schema)", () => {
-    const opts = parseSnowflakeURL("snowflake://user:pass@account123/mydb");
-    expect(opts.account).toBe("account123");
-    expect(opts.username).toBe("user");
-    expect(opts.password).toBe("pass");
-    expect(opts.database).toBe("mydb");
-    expect(opts.schema).toBeUndefined();
-    expect(opts.warehouse).toBeUndefined();
-    expect(opts.role).toBeUndefined();
-  });
-
-  it("parses minimal URL (account only)", () => {
-    const opts = parseSnowflakeURL("snowflake://user:pass@account123");
-    expect(opts.account).toBe("account123");
-    expect(opts.username).toBe("user");
-    expect(opts.password).toBe("pass");
-    expect(opts.database).toBeUndefined();
-    expect(opts.schema).toBeUndefined();
-  });
-
-  it("decodes URL-encoded credentials", () => {
-    const opts = parseSnowflakeURL("snowflake://my%40user:p%40ss%23word@account123/db");
-    expect(opts.username).toBe("my@user");
-    expect(opts.password).toBe("p@ss#word");
-  });
-
-  it("handles warehouse query parameter only", () => {
-    const opts = parseSnowflakeURL("snowflake://user:pass@account123/db/schema?warehouse=WH");
-    expect(opts.warehouse).toBe("WH");
-    expect(opts.role).toBeUndefined();
-  });
-
-  it("throws for non-snowflake protocol", () => {
-    expect(() => parseSnowflakeURL("postgresql://user:pass@localhost:5432/db")).toThrow(
-      "Invalid Snowflake URL"
-    );
-  });
-
-  it("accepts empty password (key-pair auth scenario)", () => {
-    const opts = parseSnowflakeURL("snowflake://user:@account123/db");
-    expect(opts.username).toBe("user");
-    expect(opts.password).toBe("");
-    expect(opts.database).toBe("db");
-  });
-
-  it("throws for missing username", () => {
-    expect(() => parseSnowflakeURL("snowflake://:pass@account123/db")).toThrow(
-      "missing username"
-    );
-  });
-
-  it("throws for missing account (unparseable URL)", () => {
-    // snowflake://user:pass@/db is not a valid URL — the URL constructor throws
-    expect(() => parseSnowflakeURL("snowflake://user:pass@/db")).toThrow();
-  });
-});
-
-describe("detectDBType — Snowflake", () => {
-  it("returns 'snowflake' for snowflake:// URLs", () => {
-    expect(detectDBType("snowflake://user:pass@account123/db")).toBe("snowflake");
-  });
-
-  it("still returns 'postgres' for postgresql:// URLs", () => {
-    expect(detectDBType("postgresql://user:pass@localhost:5432/db")).toBe("postgres");
-  });
-
-  it("still returns 'mysql' for mysql:// URLs", () => {
-    expect(detectDBType("mysql://user:pass@localhost:3306/db")).toBe("mysql");
-  });
-
-  it("throws for unsupported URL schemes", () => {
-    expect(() => detectDBType("sqlite:///test.db")).toThrow("Unsupported database URL");
-  });
-});
-
-describe("createSnowflakeDB — defense-in-depth", () => {
-  const ConnectionRegistry = connMod.ConnectionRegistry as typeof import("../connection").ConnectionRegistry;
-
-  beforeEach(() => {
-    executedStatements = [];
-    queryTagShouldFail = false;
-    mockWarn.mockClear();
-  });
-
-  it("logs a startup warning recommending a SELECT-only role", () => {
-    const registry = new ConnectionRegistry();
-    registry.register("sf-test", { url: "snowflake://user:pass@account123/db" });
-    expect(mockWarn).toHaveBeenCalledWith(
-      expect.stringContaining("no session-level read-only mode"),
-    );
-  });
-
-  it("sets QUERY_TAG before each query", async () => {
-    const registry = new ConnectionRegistry();
-    registry.register("sf-tag", { url: "snowflake://user:pass@account123/db" });
-    const db = registry.get("sf-tag");
-    await db.query("SELECT 1");
-
-    expect(executedStatements).toContain("ALTER SESSION SET QUERY_TAG = 'atlas:readonly'");
-    // QUERY_TAG should come after timeout and before the actual query
-    const tagIdx = executedStatements.indexOf("ALTER SESSION SET QUERY_TAG = 'atlas:readonly'");
-    const queryIdx = executedStatements.indexOf("SELECT 1");
-    expect(tagIdx).toBeLessThan(queryIdx);
-  });
-
-  it("sets statement timeout before QUERY_TAG", async () => {
-    const registry = new ConnectionRegistry();
-    registry.register("sf-order", { url: "snowflake://user:pass@account123/db" });
-    const db = registry.get("sf-order");
-    await db.query("SELECT 1", 15000);
-
-    const timeoutIdx = executedStatements.findIndex((s) => s.includes("STATEMENT_TIMEOUT_IN_SECONDS"));
-    const tagIdx = executedStatements.indexOf("ALTER SESSION SET QUERY_TAG = 'atlas:readonly'");
-    expect(timeoutIdx).toBeLessThan(tagIdx);
-  });
-
-  it("proceeds with the query when QUERY_TAG fails (best-effort)", async () => {
-    queryTagShouldFail = true;
-    const registry = new ConnectionRegistry();
-    registry.register("sf-tag-fail", { url: "snowflake://user:pass@account123/db" });
-    const db = registry.get("sf-tag-fail");
-    const result = await db.query("SELECT 42");
-
-    // The actual query should still execute despite QUERY_TAG failure
-    expect(executedStatements).toContain("SELECT 42");
-    expect(result).toEqual({ columns: [], rows: [] });
-
-    // A warning should be logged
-    expect(mockWarn).toHaveBeenCalledWith(
-      expect.stringContaining("Failed to set QUERY_TAG"),
-    );
-  });
-});