Files
dbx/apps/desktop/src/lib/__tests__/tabs/tabPresentation.spec.ts
T

714 lines
31 KiB
TypeScript
Vendored

import { beforeEach, describe, expect, it, vi } from "vitest";
import { createPinia, setActivePinia } from "pinia";
import { useConnectionStore } from "@/stores/connectionStore";
import {
connectionGroupDisplayName,
executionSummaryItems,
middleEllipsis,
queryResultBaseSql,
queryResultExecutionSql,
resultGridCacheKey,
resultGridColumnWidthCacheKey,
resultGridInstanceKey,
resultRunItems,
resultSourceRange,
statementExecutionMarkers,
tabColorStyle,
tabDatabaseIconType,
tabDisplayTitle,
tabDisplayTitles,
syncTabTitleNumbers,
tabIconClass,
tabTooltipLines,
tabularResultItems,
dirtyTabTitleStyle,
} from "@/lib/tabs/tabPresentation";
import { sqlTextFingerprint } from "@/lib/sql/sqlTextFingerprint";
import type { ConnectionConfig, QueryResult, QueryResultRun, QueryTab } from "@/types/database";
const translations: Record<string, string> = {
"tabs.tooltipConnection": "Connection:",
"tabs.tooltipGroup": "Group:",
"tabs.tooltipDatabase": "Database:",
"tabs.tooltipTable": "Table:",
"tabs.tooltipTableComment": "Table Comment:",
"tree.events": "Events",
"connectionGroup.ungroupedLabel": "Ungrouped",
"editor.noDatabase": "No database",
};
const translate = (key: string) => translations[key] ?? key;
beforeEach(() => {
const values = new Map<string, string>();
vi.stubGlobal("localStorage", {
getItem: vi.fn((key: string) => values.get(key) ?? null),
setItem: vi.fn((key: string, value: string) => values.set(key, value)),
removeItem: vi.fn((key: string) => values.delete(key)),
});
setActivePinia(createPinia());
});
function queryTab(overrides: Partial<QueryTab>): QueryTab {
return {
id: "tab-1",
title: "SQL",
connectionId: "conn-1",
database: "db",
sql: "SELECT * FROM dbo.first;\nSELECT * FROM dbo.second;",
originalSql: "",
isExecuting: false,
isCancelling: false,
isExplaining: false,
mode: "query",
...overrides,
} as QueryTab;
}
describe("query result SQL selection", () => {
it("uses the active result source statement for multi-result query actions", () => {
const tab = queryTab({
resultBaseSql: "SELECT * FROM dbo.first;\nSELECT * FROM dbo.second;",
result: {
columns: ["id"],
rows: [[1]],
affected_rows: 0,
execution_time_ms: 1,
sourceStatement: "SELECT * FROM dbo.second",
},
});
expect(queryResultBaseSql(tab)).toBe("SELECT * FROM dbo.second");
expect(queryResultExecutionSql(tab)).toBe("SELECT * FROM dbo.second");
});
it("prefers the sorted SQL when the active result is sorted", () => {
const tab = queryTab({
resultSortedSql: "SELECT * FROM dbo.second ORDER BY id DESC",
result: {
columns: ["id"],
rows: [[2]],
affected_rows: 0,
execution_time_ms: 1,
sourceStatement: "SELECT * FROM dbo.second",
},
});
expect(queryResultBaseSql(tab)).toBe("SELECT * FROM dbo.second");
expect(queryResultExecutionSql(tab)).toBe("SELECT * FROM dbo.second ORDER BY id DESC");
});
it("uses lastExecutedSql when a data tab has no editor SQL", () => {
const tab = queryTab({ mode: "data", sql: "", lastExecutedSql: "SELECT * FROM users", result: { columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 } });
expect(queryResultBaseSql(tab)).toBe("SELECT * FROM users");
expect(queryResultExecutionSql(tab)).toBe("SELECT * FROM users");
});
});
describe("query result labels", () => {
it("excludes tagged server messages without renumbering storage indexes", () => {
const message: QueryResult = { columns: ["Message"], rows: [["notice"]], affected_rows: 0, execution_time_ms: 1, server_message: true };
const data: QueryResult = { columns: ["Message"], rows: [["real data"]], affected_rows: 0, execution_time_ms: 1 };
const empty: QueryResult = { ...data, rows: [] };
const results = [message, data, message, empty, data];
expect(tabularResultItems(results).map(({ index, n }) => ({ index, n }))).toEqual([
{ index: 1, n: 1 },
{ index: 3, n: 2 },
{ index: 4, n: 3 },
]);
expect(tabularResultItems([message])).toEqual([]);
expect(results).toHaveLength(5);
});
it("preserves both ends when shortening long source labels", () => {
expect(middleEllipsis("easy_manager_tool.tool_monitor_data_index_item")).toBe("easy_manage...index_item");
expect(middleEllipsis("aaa.apis")).toBe("aaa.apis");
expect(middleEllipsis("abcdef", 4)).toBe("a...");
});
it("uses the full source label as the result tab tooltip", () => {
const [item] = tabularResultItems([
{
columns: ["id"],
rows: [[1]],
affected_rows: 0,
execution_time_ms: 1,
sourceLabel: "app.users",
sourceStatement: "SELECT * FROM users",
},
]);
expect(item?.label).toBe("app.users");
expect(item?.displayLabel).toBe("app.users");
expect(item?.labelTruncated).toBe(false);
expect(item?.title).toBe("app.users");
});
it("exposes a middle-shortened display label while retaining the full tooltip", () => {
const [item] = tabularResultItems([
{
columns: ["id"],
rows: [[1]],
affected_rows: 0,
execution_time_ms: 1,
sourceLabel: "easy_manager_tool.tool_monitor_data_index_item",
sourceStatement: "SELECT * FROM tool_monitor_data_index_item",
},
]);
expect(item?.displayLabel).toBe("easy_manage...index_item");
expect(item?.labelTruncated).toBe(true);
expect(item?.title).toBe("easy_manager_tool.tool_monitor_data_index_item");
});
it("does not expose SQL text as a visible fallback label", () => {
const [item] = tabularResultItems([
{
columns: ["value"],
rows: [[1]],
affected_rows: 0,
execution_time_ms: 1,
sourceStatement: "SELECT 1",
},
]);
expect(item?.label).toBeUndefined();
expect(item?.title).toBe("SELECT 1");
});
it("shows only the object name when result set names exclude the database", () => {
const results = [
{
columns: ["id"],
rows: [[1]],
affected_rows: 0,
execution_time_ms: 1,
sourceLabel: "cosimulation2.0.data_monitor",
sourceQualifier: "cosimulation2.0",
sourceName: "data_monitor",
sourceStatement: "SELECT * FROM data_monitor",
},
];
const [withDatabase] = tabularResultItems(results);
const [withoutDatabase] = tabularResultItems(results, { includeSourceDatabase: false });
expect(withDatabase?.label).toBe("cosimulation2.0.data_monitor");
expect(withoutDatabase?.label).toBe("data_monitor");
expect(withoutDatabase?.displayLabel).toBe("data_monitor");
// 完整名称(含库名)仍保留在悬浮提示中
expect(withoutDatabase?.title).toBe("cosimulation2.0.data_monitor");
});
it("keeps a custom result name even when the database is hidden", () => {
const [item] = tabularResultItems(
[
{
columns: ["id"],
rows: [[1]],
affected_rows: 0,
execution_time_ms: 1,
sourceLabel: "My weekly report",
sourceQualifier: "app",
sourceName: "users",
sourceStatement: "SELECT * FROM users",
},
],
{ includeSourceDatabase: false },
);
expect(item?.label).toBe("My weekly report");
expect(item?.title).toBe("My weekly report");
});
});
describe("query result grid identity", () => {
it("separates rerun payloads while retaining run and result-set identity", () => {
const first = queryTab({ activeResultRunId: "run-1", activeResultIndex: 2, resultGridRevision: "execution-1" });
const rerun = queryTab({ activeResultRunId: "run-2", activeResultIndex: 2, resultGridRevision: "execution-2" });
expect(resultGridInstanceKey(first)).toBe("tab-1-run-1-2-execution-1");
expect(resultGridInstanceKey(rerun)).not.toBe(resultGridInstanceKey(first));
expect(resultGridInstanceKey({ ...first, activeResultIndex: 1 })).toBe("tab-1-run-1-1-execution-1");
expect(resultGridCacheKey(rerun)).not.toBe(resultGridCacheKey(first));
expect(resultGridColumnWidthCacheKey(rerun)).toBe(resultGridColumnWidthCacheKey(first));
expect(resultGridColumnWidthCacheKey({ ...first, activeResultIndex: 1 })).not.toBe(resultGridColumnWidthCacheKey(first));
});
});
describe("result run labels", () => {
// 与 store 真实创建批次的方式保持一致:默认标题是 `Run N`,只有重命名/多库执行才标记 customTitle
const run = (id: string, sequence: number, result?: QueryResult, overrides: Partial<QueryResultRun> = {}): QueryResultRun => ({ id, title: `Run ${sequence}`, sequence, sql: "SELECT * FROM users", createdAt: sequence, result, ...overrides });
const sourceResult = (label: string, qualifier: string, name: string): QueryResult => ({ columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1, sourceLabel: label, sourceQualifier: qualifier, sourceName: name }) as QueryResult;
it("names result runs after their source table instead of the run ordinal", () => {
const items = resultRunItems(
queryTab({
resultRuns: [run("run-1", 1, sourceResult("app.users", "app", "users")), run("run-2", 2, sourceResult("app.orders", "app", "orders"))],
}) as QueryTab,
);
expect(items.map((item) => item.sourceLabel)).toEqual(["app.users", "app.orders"]);
});
it("suffixes repeated sources and follows the database-name setting", () => {
const tab = queryTab({
resultRuns: [run("run-1", 1, sourceResult("cosimulation2.0.users", "cosimulation2.0", "users")), run("run-2", 2, sourceResult("cosimulation2.0.users", "cosimulation2.0", "users")), run("run-3", 3)],
}) as QueryTab;
expect(resultRunItems(tab).map((item) => item.sourceLabel)).toEqual(["cosimulation2.0.users", "cosimulation2.0.users (2)", undefined]);
expect(resultRunItems(tab, { includeSourceDatabase: false }).map((item) => item.sourceLabel)).toEqual(["users", "users (2)", undefined]);
});
it("keeps a renamed run title ahead of the source label", () => {
const items = resultRunItems(queryTab({ resultRuns: [run("run-1", 1, sourceResult("app.users", "app", "users"), { title: "报表", customTitle: true })] }) as QueryTab);
expect(items[0]?.title).toBe("报表");
expect(items[0]?.sourceLabel).toBe("app.users");
});
it("replaces the default Run N title with the source label", () => {
const items = resultRunItems(queryTab({ resultRuns: [run("run-1", 1, sourceResult("app.users", "app", "users"))] }) as QueryTab);
expect(items[0]?.title).toBe("");
expect(items[0]?.sourceLabel).toBe("app.users");
});
it("falls back to the run SQL for runs created before source labels were stored", () => {
const items = resultRunItems(queryTab({ resultRuns: [run("run-1", 1)] }) as QueryTab, { database: "cosimulation2.0", databaseType: "mysql" });
expect(items[0]?.sourceLabel).toBe("cosimulation2.0.users");
});
});
describe("tab group presentation", () => {
// 编号由 store 在标签列表变化时分配,渲染函数只读结果;这里把两步串起来,
// 与真实调用顺序保持一致(#9938)。
const titlesWithNumbers = (tabs: QueryTab[]) => {
syncTabTitleNumbers(tabs, translate);
return tabDisplayTitles(tabs, translate);
};
it("numbers colliding query tab titles so several tabs stay distinguishable", () => {
const store = useConnectionStore();
store.connections = [{ id: "conn-1", name: "PostgreSQL", db_type: "postgres", driver_profile: "postgres", database: "app" } as ConnectionConfig];
const tabs = [queryTab({ id: "tab-1" }), queryTab({ id: "tab-2" }), queryTab({ id: "tab-3" })];
const titles = titlesWithNumbers(tabs);
expect([...titles.values()]).toEqual(["PostgreSQL@db 1", "PostgreSQL@db 2", "PostgreSQL@db 3"]);
});
it("keeps the remaining numbers when a tab in the middle is closed", () => {
const store = useConnectionStore();
store.connections = [{ id: "conn-1", name: "PostgreSQL", db_type: "postgres", driver_profile: "postgres", database: "app" } as ConnectionConfig];
const tabs = [queryTab({ id: "tab-1" }), queryTab({ id: "tab-2" }), queryTab({ id: "tab-3" })];
titlesWithNumbers(tabs);
const titles = titlesWithNumbers(tabs.filter((tab) => tab.id !== "tab-2"));
expect(titles.get("tab-1")).toBe("PostgreSQL@db 1");
expect(titles.get("tab-3")).toBe("PostgreSQL@db 3");
});
it("keeps the number on the last surviving tab of a closed group", () => {
const store = useConnectionStore();
store.connections = [{ id: "conn-1", name: "PostgreSQL", db_type: "postgres", driver_profile: "postgres", database: "app" } as ConnectionConfig];
const tabs = [queryTab({ id: "tab-1" }), queryTab({ id: "tab-2" })];
titlesWithNumbers(tabs);
expect(titlesWithNumbers([tabs[0]!]).get("tab-1")).toBe("PostgreSQL@db 1");
});
it("continues after the highest number still in use when a new tab opens", () => {
const store = useConnectionStore();
store.connections = [{ id: "conn-1", name: "PostgreSQL", db_type: "postgres", driver_profile: "postgres", database: "app" } as ConnectionConfig];
const tabs = [queryTab({ id: "tab-1" }), queryTab({ id: "tab-2" }), queryTab({ id: "tab-3" })];
titlesWithNumbers(tabs);
const next = [...tabs.filter((tab) => tab.id !== "tab-2"), queryTab({ id: "tab-4" })];
const titles = titlesWithNumbers(next);
expect(titles.get("tab-1")).toBe("PostgreSQL@db 1");
expect(titles.get("tab-3")).toBe("PostgreSQL@db 3");
expect(titles.get("tab-4")).toBe("PostgreSQL@db 4");
});
it("drops the number of a tab whose title stops colliding", () => {
const store = useConnectionStore();
store.connections = [{ id: "conn-1", name: "PostgreSQL", db_type: "postgres", driver_profile: "postgres", database: "app" } as ConnectionConfig];
const tabs = [queryTab({ id: "tab-1" }), queryTab({ id: "tab-2" })];
titlesWithNumbers(tabs);
tabs[1]!.database = "other";
const titles = titlesWithNumbers(tabs);
expect(titles.get("tab-1")).toBe("PostgreSQL@db 1");
expect(titles.get("tab-2")).toBe("PostgreSQL@other");
});
it("leaves tab titles untouched while they are unique", () => {
const store = useConnectionStore();
store.connections = [{ id: "conn-1", name: "PostgreSQL", db_type: "postgres", driver_profile: "postgres", database: "app" } as ConnectionConfig];
const tabs = [queryTab({ id: "tab-1" }), queryTab({ id: "tab-2", database: "other" }), queryTab({ id: "tab-3", customTitle: true, title: "orders.sql", savedSqlId: "sql-1" })];
const titles = titlesWithNumbers(tabs);
expect(titles.get("tab-1")).toBe("PostgreSQL@db");
expect(titles.get("tab-2")).toBe("PostgreSQL@other");
expect(titles.get("tab-3")).toBe("orders.sql");
});
it("numbers duplicate custom titles in strip order and skips preview tabs", () => {
const store = useConnectionStore();
store.connections = [{ id: "conn-1", name: "PostgreSQL", db_type: "postgres", driver_profile: "postgres", database: "app" } as ConnectionConfig, { id: "conn-preview", name: "[Preview] PostgreSQL", db_type: "postgres", driver_profile: "postgres", database: "app" } as ConnectionConfig];
const tabs = [queryTab({ id: "tab-1", customTitle: true, title: "orders.sql", savedSqlId: "sql-1" }), queryTab({ id: "tab-preview", connectionId: "conn-preview" }), queryTab({ id: "tab-2", customTitle: true, title: "orders.sql", savedSqlId: "sql-2" })];
const titles = titlesWithNumbers(tabs);
expect(titles.get("tab-1")).toBe("orders.sql 1");
expect(titles.get("tab-2")).toBe("orders.sql 2");
expect(titles.get("tab-preview")).toBe("SQL");
});
it("does not expose the internal objects mode in object browser tab titles", () => {
const store = useConnectionStore();
store.connections = [{ id: "conn-1", name: "PostgreSQL", db_type: "postgres", driver_profile: "postgres", database: "app" } as ConnectionConfig];
expect(tabDisplayTitle(queryTab({ mode: "objects", title: "app objects" }), translate)).toBe("db");
expect(tabDisplayTitle(queryTab({ mode: "objects", title: "public objects", objectBrowser: { schema: "public" } }), translate)).toBe("public@db");
});
it("uses the selected MySQL event name for event editor tabs", () => {
expect(tabDisplayTitle(queryTab({ mode: "objects", objectBrowser: { objectType: "tables", initialObjectFilter: "events", eventName: "cleanup_sessions" } }), translate)).toBe("cleanup_sessions@db");
expect(tabDisplayTitle(queryTab({ mode: "objects", objectBrowser: { objectType: "tables", initialObjectFilter: "events" } }), translate)).toBe("Events@db");
});
it("uses the live database and branch context for Dolt version control tabs", () => {
const store = useConnectionStore();
store.connections = [{ id: "conn-1", name: "Production Dolt", db_type: "mysql", driver_profile: "dolt", database: "app" } as ConnectionConfig];
expect(tabDisplayTitle(queryTab({ mode: "dolt-version-control", title: "Dolt Version Control", workspaceBranch: "feature/orders" }), translate)).toBe("Production Dolt VCS@db.feature/orders");
expect(tabDisplayTitle(queryTab({ mode: "dolt-version-control", title: "Dolt Version Control" }), translate)).toBe("Production Dolt VCS@db");
});
it("adds the full, live group path to tab tooltips", () => {
const store = useConnectionStore();
store.connections = [{ id: "conn-1", name: "PostgreSQL", db_type: "postgres", database: "app" } as ConnectionConfig];
store.sidebarLayout = {
groups: [
{ id: "project", name: "Project", collapsed: false },
{ id: "staging", name: "Staging", collapsed: false },
],
order: [
{
type: "group",
id: "project",
children: [{ type: "group", id: "staging", children: [{ type: "connection", id: "conn-1" }] }],
},
],
};
expect(connectionGroupDisplayName("conn-1", translate)).toBe("Project / Staging");
expect(tabTooltipLines(queryTab({ database: "app" }), translate)).toEqual([
{ label: "Connection:", value: "PostgreSQL" },
{ label: "Group:", value: "Project / Staging" },
{ label: "Database:", value: "app" },
]);
});
it("omits the database row from tooltips for connections without a database target", () => {
const store = useConnectionStore();
store.sidebarLayout = {
groups: [],
order: [{ type: "connection", id: "conn-1" }],
};
for (const dbType of ["dynamodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "weaviate", "chromadb", "etcd", "zookeeper", "nacos", "consul", "mq", "mqtt", "victoriametrics"] as const) {
store.connections = [{ id: "conn-1", name: "Local", db_type: dbType, database: "default" } as ConnectionConfig];
const lines = tabTooltipLines(queryTab({ database: "default" }), translate);
expect(lines, dbType).toContainEqual({ label: "Connection:", value: "Local" });
expect(lines, dbType).toContainEqual({ label: "Group:", value: "Ungrouped" });
expect(lines, dbType).not.toContainEqual({ label: "Database:", value: "default" });
}
});
it("labels a top-level connection as ungrouped", () => {
const store = useConnectionStore();
store.connections = [{ id: "conn-1", name: "PostgreSQL", db_type: "postgres", database: "app" } as ConnectionConfig];
store.sidebarLayout = {
groups: [],
order: [{ type: "connection", id: "conn-1" }],
};
expect(connectionGroupDisplayName("conn-1", translate)).toBe("Ungrouped");
});
it("shows a bounded table comment only when it is non-empty", () => {
const lines = tabTooltipLines(
queryTab({
mode: "data",
tableComment: ` ${"表".repeat(55)}\narchive `,
tableMeta: { schema: "public", tableName: "users", columns: [], primaryKeys: [] },
}),
translate,
);
const comment = lines.find((line) => line.label === "Table Comment:")?.value;
expect(Array.from(comment || "")).toHaveLength(50);
expect(comment?.endsWith("…")).toBe(true);
expect(tabTooltipLines(queryTab({ mode: "data", tableComment: " ", tableMeta: { schema: "public", tableName: "users", columns: [], primaryKeys: [] } }), translate).some((line) => line.label === "Table Comment:")).toBe(false);
});
});
describe("query result source ranges", () => {
it("prefers the preserved editor range for a selected duplicate statement", () => {
const sql = "SELECT * FROM users;\nSELECT * FROM users;";
const from = sql.lastIndexOf("SELECT");
expect(resultSourceRange(sql, { sourceStatement: "SELECT * FROM users", sourceFrom: from, sourceTo: sql.length - 1 }, 0, "mysql")).toEqual({
from,
to: sql.length - 1,
sql: "SELECT * FROM users",
});
});
it("uses the result index to distinguish repeated statements", () => {
const sql = "SELECT * FROM users;\nSELECT * FROM users;";
const range = resultSourceRange(sql, { sourceStatement: "SELECT * FROM users" }, 1, "mysql");
expect(range).toEqual({
from: sql.lastIndexOf("SELECT"),
to: sql.length - 1,
sql: "SELECT * FROM users",
});
});
it("resolves newline-separated MongoDB commands with the Mongo shell parser", () => {
const sql = "db.model_field_group.find({})\n\ndb.model_info.find({})";
const sourceStatement = "db.model_info.find({})";
const range = resultSourceRange(sql, { sourceStatement }, 1, "mongodb");
expect(range).toEqual({
from: sql.indexOf(sourceStatement),
to: sql.length,
sql: sourceStatement,
});
});
it("resolves newline-separated Redis commands with the Redis parser", () => {
const sql = "GET first\n\nGET second";
const sourceStatement = "GET second";
const range = resultSourceRange(sql, { sourceStatement }, 1, "redis");
expect(range).toEqual({
from: sql.indexOf(sourceStatement),
to: sql.length,
sql: sourceStatement,
});
});
it("does not highlight a stale or ambiguous statement", () => {
expect(resultSourceRange("SELECT * FROM users;", { sourceStatement: "SELECT * FROM orders" }, 0, "mysql")).toBeUndefined();
expect(resultSourceRange("SELECT * FROM users; SELECT * FROM users;", { sourceStatement: "SELECT * FROM users" }, undefined, "mysql")).toBeUndefined();
});
});
describe("execution summary", () => {
it("uses the explicit execution marker instead of the result column name", () => {
const successfulAlias = { columns: ["Error"], rows: [[2]], affected_rows: 0, execution_time_ms: 1 };
const markedFailure = { columns: ["Error"], rows: [["failed"]], affected_rows: 0, execution_time_ms: 1, execution_error: true as const };
expect(executionSummaryItems({ results: [successfulAlias, markedFailure] }).map(({ status, isError }) => ({ status, isError }))).toEqual([
{ status: "success", isError: false },
{ status: "error", isError: true },
]);
});
it("maps out-of-order results to their explicit statement indexes", () => {
const items = executionSummaryItems({
results: [
{ columns: ["value"], rows: [["third"]], affected_rows: 0, execution_time_ms: 3, statement_index: 2 },
{ columns: ["value"], rows: [["first"]], affected_rows: 0, execution_time_ms: 1, statement_index: 0 },
],
batchSqlExecution: {
executionId: "run-out-of-order",
submittedSql: "SELECT 'first'; SELECT 'second'; SELECT 'third'",
editorFingerprint: "fingerprint",
sourceOffset: 0,
completed: 2,
total: 3,
startedAt: 1,
items: [
{ statementIndex: 0, sql: "SELECT 'first'", from: 0, to: 14, status: "success" },
{ statementIndex: 1, sql: "SELECT 'second'", from: 16, to: 31, status: "skipped" },
{ statementIndex: 2, sql: "SELECT 'third'", from: 33, to: 47, status: "success" },
],
},
});
expect(items.map((item) => [item.statementIndex, item.result?.rows[0]?.[0]])).toEqual([
[0, "first"],
[1, undefined],
[2, "third"],
]);
});
});
describe("statement execution markers", () => {
it("renders a live marker for a single statement", () => {
const sql = "SELECT 1";
expect(
statementExecutionMarkers(sql, undefined, "mysql", sql, "", {
executionId: "run-single",
submittedSql: sql,
editorFingerprint: sqlTextFingerprint(sql),
sourceOffset: 0,
completed: 0,
total: 1,
startedAt: 1,
items: [{ statementIndex: 0, sql, from: 0, to: sql.length, status: "running" }],
}),
).toEqual([{ from: 0, status: "running", successCount: 0, errorCount: 0, runningCount: 1 }]);
});
it("renders running and completed markers from live batch state", () => {
const sql = "SELECT 1;\nSELECT 2;\nSELECT 3;";
const secondFrom = sql.indexOf("SELECT 2");
const thirdFrom = sql.indexOf("SELECT 3");
expect(
statementExecutionMarkers(sql, undefined, "sqlite", sql, "", {
executionId: "run-1",
submittedSql: sql,
editorFingerprint: sqlTextFingerprint(sql),
sourceOffset: 0,
completed: 1,
total: 3,
startedAt: 1,
items: [
{ statementIndex: 0, sql: "SELECT 1", from: 0, to: 8, status: "success" },
{ statementIndex: 1, sql: "SELECT 2", from: secondFrom, to: secondFrom + 8, status: "running" },
{ statementIndex: 2, sql: "SELECT 3", from: thirdFrom, to: thirdFrom + 8, status: "pending" },
],
}),
).toEqual([
{ from: 0, status: "success", successCount: 1, errorCount: 0 },
{ from: secondFrom, status: "running", successCount: 0, errorCount: 0, runningCount: 1 },
]);
});
it("projects explicit statement indexes to current editor lines", () => {
const sql = "SELECT 1;\nSELECT * FROM missing;\nSELECT 3;";
const secondFrom = sql.indexOf("SELECT *");
const markers = statementExecutionMarkers(
sql,
[
{ columns: ["value"], rows: [[1]], affected_rows: 0, execution_time_ms: 1, statement_index: 0, sourceStatement: "SELECT 1", sourceFrom: 0, sourceTo: 8 },
{ columns: ["Error"], rows: [["no such table"]], affected_rows: 0, execution_time_ms: 1, execution_error: true, statement_index: 1, sourceStatement: "SELECT * FROM missing", sourceFrom: secondFrom, sourceTo: secondFrom + "SELECT * FROM missing".length },
],
"sqlite",
sql,
);
expect(markers).toEqual([
{ from: 0, status: "success", successCount: 1, errorCount: 0 },
{ from: secondFrom, status: "error", successCount: 0, errorCount: 1 },
]);
});
it("omits unindexed query-level errors and legacy single-statement results without live state", () => {
expect(statementExecutionMarkers("SELECT 1; SELECT 2;", [{ columns: ["Error"], rows: [["pool failed"]], affected_rows: 0, execution_time_ms: 1, execution_error: true }], "mysql", "SELECT 1; SELECT 2;")).toEqual([]);
expect(statementExecutionMarkers("SELECT 1", [{ columns: ["value"], rows: [[1]], affected_rows: 0, execution_time_ms: 1, statement_index: 0, sourceStatement: "SELECT 1", sourceFrom: 0, sourceTo: 8 }], "mysql", "SELECT 1")).toEqual([]);
});
it("keeps duplicate statements scoped by preserved absolute ranges", () => {
const sql = "SELECT * FROM users;\nSELECT * FROM users;";
const from = sql.lastIndexOf("SELECT");
expect(statementExecutionMarkers(sql, [{ columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1, statement_index: 1, sourceStatement: "SELECT * FROM users", sourceFrom: from, sourceTo: sql.length - 1 }], "mysql", sql)).toEqual([
{ from, status: "success", successCount: 1, errorCount: 0 },
]);
});
it("aggregates same-line statements with error precedence", () => {
const sql = "SELECT 1; SELECT bad;";
expect(
statementExecutionMarkers(
sql,
[
{ columns: ["value"], rows: [[1]], affected_rows: 0, execution_time_ms: 1, statement_index: 0, sourceStatement: "SELECT 1", sourceFrom: 0, sourceTo: 8 },
{ columns: ["Error"], rows: [["bad"]], affected_rows: 0, execution_time_ms: 1, execution_error: true, statement_index: 1, sourceStatement: "SELECT bad", sourceFrom: 10, sourceTo: 20 },
],
"mysql",
sql,
),
).toEqual([{ from: 0, status: "error", successCount: 1, errorCount: 1 }]);
});
it("invalidates every marker after the editor document changes", () => {
const executedSql = "SELECT 1;\nSELECT 2;";
expect(statementExecutionMarkers(`-- edited\n${executedSql}`, [{ columns: ["value"], rows: [[1]], affected_rows: 0, execution_time_ms: 1, statement_index: 0, sourceStatement: "SELECT 1" }], "mysql", "stale-editor-fingerprint", executedSql)).toEqual([]);
});
});
describe("shared tab presentation helpers", () => {
it("classifies tab icon colors without MQ special-casing", () => {
expect(tabIconClass(queryTab({ mode: "data" }))).toContain("text-green-500");
const connectionStore = useConnectionStore();
connectionStore.connections = [{ id: "dynamodb-1", name: "DynamoDB", db_type: "dynamodb", driver_profile: "dynamodb", color: "" } as ConnectionConfig];
expect(tabIconClass(queryTab({ connectionId: "dynamodb-1", mode: "data" }))).toContain("text-amber-500");
expect(tabIconClass(queryTab({ mode: "mq" }))).toBe("");
expect(tabIconClass(queryTab({ externalSqlFileMissing: true }))).toContain("text-amber-600");
expect(tabIconClass(queryTab({ mode: "users" }))).toBe("text-primary");
expect(tabIconClass(queryTab({ mode: "objects", objectBrowser: { objectType: "tables", initialObjectFilter: "events", eventName: "cleanup_sessions" } }))).toBe("text-orange-400");
});
it("uses logical Redis database labels instead of the connection title", () => {
const connectionStore = useConnectionStore();
connectionStore.connections = [{ id: "redis-1", name: "Redis", db_type: "redis", driver_profile: "redis", color: "" } as ConnectionConfig];
expect(tabDisplayTitle(queryTab({ connectionId: "redis-1", database: "0", mode: "redis", sql: "" }), translate)).toBe("db0");
expect(tabDisplayTitle(queryTab({ connectionId: "redis-1", database: "1", mode: "redis", sql: "" }), translate)).toBe("db1");
});
it("keeps source tab colors aligned with the sidebar object palette", () => {
const colors = [
["PROCEDURE", "text-blue-500"],
["FUNCTION", "text-amber-500"],
["SEQUENCE", "text-emerald-500"],
["SYNONYM", "text-sky-500"],
["PACKAGE", "text-cyan-500"],
["PACKAGE_BODY", "text-cyan-400"],
["TYPE", "text-violet-500"],
["TYPE_BODY", "text-violet-400"],
] as const;
for (const [objectType, color] of colors) {
expect(tabIconClass(queryTab({ objectSource: { name: "object", objectType } }))).toContain(color);
}
});
it("builds active/inactive color styles for classic and non-classic layouts", () => {
const activeClassic = tabColorStyle(queryTab({}), true, true);
expect(activeClassic?.boxShadow).toContain("var(--foreground)");
const inactiveModern = tabColorStyle(queryTab({}), false, false);
expect(inactiveModern?.borderColor).toBeUndefined();
});
it("resolves MQ driver icons from the connection store", () => {
const connectionStore = useConnectionStore();
connectionStore.connections = [
{
id: "mq-1",
name: "MQ",
db_type: "mq",
driver_profile: "kafka",
color: "",
} as ConnectionConfig,
];
expect(tabDatabaseIconType(queryTab({ connectionId: "mq-1", mode: "mq" }))).toBe("kafka");
});
it("returns a dirty-title style only when the tab is dirty", () => {
expect(dirtyTabTitleStyle(false)).toBeUndefined();
expect(dirtyTabTitleStyle(true)?.fontStyle).toBe("italic");
expect(dirtyTabTitleStyle(true)?.fontWeight).toBe(700);
});
});