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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import type { SqlFileProgress, TransferProgress, TransferRequest } from "@/lib/backend/api";
import { reactive } from "vue";
import { createOracleRoutineDeployment, disposeOracleRoutineDeployment } from "@/lib/schema/oracleRoutineDeploy";
vi.mock("@/lib/backend/api", () => ({
startTransfer: vi.fn(),
cancelTransfer: vi.fn(),
cancelDatabaseExport: vi.fn(),
cancelSqlFileExecution: vi.fn(),
cancelTableExport: vi.fn(),
updateOracleRoutineOperationReferences: vi.fn().mockResolvedValue(undefined),
}));
const mockAutoRevealExportedPathIfConfigured = vi.fn();
vi.mock("@/lib/export/exportPath", () => ({
autoRevealExportedPathIfConfigured: (...args: unknown[]) => mockAutoRevealExportedPathIfConfigured(...args),
}));
vi.mock("@/lib/metadata/objectDdlCache", () => ({ invalidateObjectDdlCache: vi.fn() }));
vi.mock("@/lib/table/objectBrowserRowsCache", () => ({ invalidateObjectBrowserRowsCache: vi.fn() }));
import * as api from "@/lib/backend/api";
import {
formatDataTransferDuration,
MAX_SQL_FILE_FAILURE_DETAIL_BYTES,
MAX_SQL_FILE_FAILURE_DETAILS,
MAX_SQL_FILE_FAILURE_ERROR_BYTES,
MAX_SQL_FILE_FAILURE_SUMMARY_BYTES,
MAX_TRANSFER_FAILURE_DETAIL_BYTES,
MAX_TRANSFER_FAILURE_DETAILS,
MAX_TRANSFER_FAILURE_ERROR_BYTES,
useExportTracker,
} from "@/composables/useExportTracker";
let now = 0;
function transferRequest(transferId: string, tables = ["users"]): TransferRequest {
return {
transferId,
sourceConnectionId: "source",
sourceDatabase: "source_db",
sourceSchema: "public",
targetConnectionId: "target",
targetDatabase: "target_db",
targetSchema: "public",
tables,
createTable: true,
content: "structureAndData",
objects: [],
mode: "append",
targetTableNameCase: "preserve",
quoteTargetColumnNames: true,
batchSize: 1000,
dropTargetBeforeCreate: false,
dropTargetConfirmed: false,
};
}
function transferProgress(transferId: string, status: TransferProgress["status"], terminal = true): TransferProgress {
return {
transferId,
table: "users",
tableIndex: 1,
totalTables: 1,
rowsTransferred: 10,
totalRows: 10,
status,
error: status === "error" ? "transfer failed" : null,
terminal,
};
}
function sqlFileProgress(executionId: string, statementIndex: number, overrides: Partial<SqlFileProgress> = {}): SqlFileProgress {
return {
executionId,
status: "statementFailed",
statementIndex,
successCount: 0,
failureCount: statementIndex,
affectedRows: 0,
elapsedMs: statementIndex,
statementSummary: `SELECT missing_${statementIndex}`,
error: `failure ${statementIndex}`,
...overrides,
};
}
function resetTracker() {
const tracker = useExportTracker();
for (const task of tracker.tasks.value) tracker.removeTask(task.exportId);
}
beforeEach(() => {
now = 0;
vi.spyOn(Date, "now").mockImplementation(() => now);
vi.clearAllMocks();
resetTracker();
});
afterEach(() => {
resetTracker();
vi.restoreAllMocks();
});
describe("data transfer task duration", () => {
it("ignores a progress packet from another transfer before changing task state", () => {
const tracker = useExportTracker();
const task = tracker.addDataTransferTask("bound-transfer", "users", 1);
tracker.updateDataTransferTask(task.exportId, transferProgress(task.exportId, "running", false));
tracker.updateDataTransferTask(task.exportId, { ...transferProgress("different-transfer", "done"), rowsTransferred: 99 });
expect(task.status).toBe("Running");
expect(task.rowsExported).toBe(10);
expect(task.finishedAt).toBeUndefined();
});
it.each(["oraclePackageApproval", "oraclePackagePreflight"] as const)("keeps completed table rows when receiving %s", (field) => {
const tracker = useExportTracker();
const task = tracker.addDataTransferTask(`rows-${field}`, "users and packages", 1);
tracker.updateDataTransferTask(task.exportId, transferProgress(task.exportId, "tableDone", false));
const endpoint = { connectionId: "target", database: "tenant", schema: "T", databaseType: "oceanbase-oracle" as const, generation: 1 };
const snapshot = { endpoint, state: "complete" as const, enumerationComplete: true, objects: [], issues: [] };
tracker.updateDataTransferTask(task.exportId, {
...transferProgress(task.exportId, field === "oraclePackagePreflight" ? "error" : "running", false),
table: "package objects",
rowsTransferred: 0,
totalRows: null,
[field]: { input: { source: snapshot, target: snapshot, drafts: [] }, skipped: [], plan: { target: endpoint, ready: false, steps: [] } },
});
expect(task.rowsExported).toBe(10);
expect(task.totalRows).toBe(10);
expect(task.finishedAt).toBeUndefined();
tracker.updateDataTransferTask(task.exportId, { ...transferProgress(task.exportId, "error"), table: "" });
expect(task.rowsExported).toBe(10);
expect(task.status).toBe("Error");
});
it("keeps the original package approvals owned by the background task until its result is removed", async () => {
const endpoint = { connectionId: "target", database: "tenant", schema: "T", databaseType: "oceanbase-oracle" as const, generation: 1 };
const snapshot = { endpoint, state: "complete" as const, enumerationComplete: true, objects: [], issues: [] };
const deployment = reactive(createOracleRoutineDeployment(snapshot, snapshot));
deployment.retainedOperationIds = ["original-package-operation"];
const identity = { owner: "T", name: "P", kind: "PACKAGE_BODY" as const };
const prepared = { operationId: "original-package-operation", target: endpoint, identity, lifecycle: "prepared" as const, dispatched: false, acknowledged: false, readback: null, error: null };
deployment.records = [prepared];
deployment.drafts = [{ identity, action: "create", objectId: "body", included: true, operation: prepared }];
let finish!: () => void;
let publish!: (progress: TransferProgress) => void;
vi.mocked(api.startTransfer).mockImplementationOnce(
(request, progress) =>
new Promise<void>((resolve) => {
publish = progress;
finish = () => {
progress(transferProgress(request.transferId, "error"));
resolve();
};
}),
);
const tracker = useExportTracker();
const cleanup = vi.fn(() => {
void disposeOracleRoutineDeployment(deployment);
});
const task = tracker.startDataTransferTask(transferRequest("package-reference-owner", []), "package", { oracleRoutineDeployment: deployment, onRemove: cleanup });
expect(task.oracleRoutineDeployment).toBe(deployment);
expect(deployment.executing).toBe(true);
expect(api.updateOracleRoutineOperationReferences).not.toHaveBeenCalled();
const bodyResult = {
...prepared,
lifecycle: "terminal" as const,
dispatched: true,
acknowledged: true,
readback: { identity, state: "invalid" as const, exists: true, version: null, source: "full original body 中文😀", definitionMatches: true, issues: [], compilerMessages: [{ attribute: "ERROR" as const, line: 2, position: 3, text: "PLS-00323" }] },
};
publish({ ...transferProgress(task.exportId, "error", false), oracleRoutineOperation: bodyResult });
expect(task.status).toBe("Running");
expect(deployment.drafts[0].operation).toEqual(bodyResult);
expect(deployment.records[0].operationId).toBe("original-package-operation");
finish();
await vi.waitFor(() => expect(deployment.executing).toBe(false));
expect(task.status).toBe("Error");
expect(deployment.retainedOperationIds).toEqual(["original-package-operation"]);
expect(cleanup).not.toHaveBeenCalled();
tracker.removeTask(task.exportId);
await vi.waitFor(() => expect(api.updateOracleRoutineOperationReferences).toHaveBeenCalledWith([], ["original-package-operation"]));
expect(cleanup).toHaveBeenCalledOnce();
});
it("freezes the first successful terminal duration", () => {
const tracker = useExportTracker();
now = 1_000;
const task = tracker.addDataTransferTask("success", "users", 1);
now = 4_500;
tracker.updateDataTransferTask(task.exportId, transferProgress(task.exportId, "done"));
now = 9_000;
tracker.updateDataTransferTask(task.exportId, transferProgress(task.exportId, "done"));
expect(task.startedAt).toBe(1_000);
expect(task.finishedAt).toBe(4_500);
expect(task.status).toBe("Done");
});
it.each([
["error", "Error"],
["cancelled", "Cancelled"],
] as const)("freezes %s terminal duration", (status, expectedStatus) => {
const tracker = useExportTracker();
now = 2_000;
const task = tracker.addDataTransferTask(status, "users", 1);
now = 7_250;
tracker.updateDataTransferTask(task.exportId, transferProgress(task.exportId, status));
expect(task.finishedAt! - task.startedAt!).toBe(5_250);
expect(task.status).toBe(expectedStatus);
});
it("tracks concurrent transfer durations independently", () => {
const tracker = useExportTracker();
now = 1_000;
const first = tracker.addDataTransferTask("first", "first", 1);
now = 2_000;
const second = tracker.addDataTransferTask("second", "second", 1);
now = 5_000;
tracker.updateDataTransferTask(first.exportId, transferProgress(first.exportId, "done"));
now = 8_000;
tracker.updateDataTransferTask(second.exportId, transferProgress(second.exportId, "cancelled"));
expect(first.finishedAt! - first.startedAt!).toBe(4_000);
expect(second.finishedAt! - second.startedAt!).toBe(6_000);
});
it("records an immediate start failure as a terminal duration", async () => {
vi.mocked(api.startTransfer).mockRejectedValueOnce(new Error("start failed"));
const tracker = useExportTracker();
const onStarted = vi.fn();
now = 10_000;
const task = tracker.startDataTransferTask(transferRequest("start-failure"), "users", { onStarted });
now = 10_025;
await vi.waitFor(() => expect(task.status).toBe("Error"));
expect(onStarted).not.toHaveBeenCalled();
expect(task.finishedAt! - task.startedAt!).toBe(25);
expect(task.errorMessage).toBe("start failed");
});
it.each([
["append", { content: "structureAndData", mode: "append", createTable: true, dropTargetBeforeCreate: false }],
["rebuild", { content: "structureAndData", mode: "append", createTable: true, dropTargetBeforeCreate: true }],
["data-only", { content: "dataOnly", mode: "append", createTable: false, dropTargetBeforeCreate: false }],
] as const)("launches one %s task and acknowledges its accepted submission once", async (_flow, overrides) => {
let finishTransfer!: () => void;
vi.mocked(api.startTransfer).mockImplementationOnce((_request, _onProgress, onStarted) => {
onStarted?.();
onStarted?.();
return new Promise<void>((resolve) => {
finishTransfer = resolve;
});
});
const tracker = useExportTracker();
const onStarted = vi.fn();
const onOpen = vi.fn();
const request = { ...transferRequest(`start-${_flow}`), ...overrides };
const task = tracker.startDataTransferTask(request, _flow, { onStarted, onOpen });
expect(task.status).toBe("Running");
expect(api.startTransfer).toHaveBeenCalledTimes(1);
expect(vi.mocked(api.startTransfer).mock.calls[0]?.[0]).toMatchObject(overrides);
expect(onStarted).toHaveBeenCalledTimes(1);
task.onOpen?.();
expect(onOpen).toHaveBeenCalledTimes(1);
finishTransfer();
await Promise.resolve();
});
it("freezes an overlapping transfer failure without starting another request", async () => {
let resolveFirst!: () => void;
vi.mocked(api.startTransfer).mockImplementationOnce(() => new Promise<void>((resolve) => (resolveFirst = resolve)));
const tracker = useExportTracker();
now = 100;
tracker.startDataTransferTask(transferRequest("active"), "active");
now = 130;
const onStarted = vi.fn();
const overlapping = tracker.startDataTransferTask(transferRequest("overlap"), "overlap", { onStarted });
expect(overlapping.status).toBe("Error");
expect(overlapping.finishedAt! - overlapping.startedAt!).toBe(0);
expect(api.startTransfer).toHaveBeenCalledTimes(1);
expect(onStarted).not.toHaveBeenCalled();
resolveFirst();
await Promise.resolve();
});
it("allows the same target table in different catalogs", async () => {
const resolvers: Array<() => void> = [];
vi.mocked(api.startTransfer).mockImplementation(
() =>
new Promise<void>((resolve) => {
resolvers.push(resolve);
}),
);
const tracker = useExportTracker();
tracker.startDataTransferTask({ ...transferRequest("hive"), targetCatalog: "hive" }, "hive");
const iceberg = tracker.startDataTransferTask({ ...transferRequest("iceberg"), targetCatalog: "iceberg" }, "iceberg");
expect(iceberg.status).toBe("Running");
expect(api.startTransfer).toHaveBeenCalledTimes(2);
for (const resolve of resolvers) resolve();
await Promise.resolve();
});
it("keeps SQL-file backend elapsed time unchanged", () => {
const tracker = useExportTracker();
const task = tracker.addSqlFileTask("sql", "script.sql", "/tmp/script.sql");
tracker.updateSqlFileTask(task.exportId, {
executionId: task.exportId,
status: "done",
statementIndex: 1,
successCount: 1,
failureCount: 0,
affectedRows: 3,
elapsedMs: 1_234,
statementSummary: "SELECT 1",
error: null,
});
expect(task.elapsedMs).toBe(1_234);
expect(task.startedAt).toBeUndefined();
expect(task.finishedAt).toBeUndefined();
});
});
describe("data transfer failure details", () => {
it("preserves per-table failures after the terminal summary and deduplicates table updates", () => {
const tracker = useExportTracker();
const task = tracker.addDataTransferTask("failure-details", "users and orders", 2);
tracker.updateDataTransferTask(task.exportId, { ...transferProgress(task.exportId, "error", false), table: "users", error: "permission denied" });
tracker.updateDataTransferTask(task.exportId, { ...transferProgress(task.exportId, "error", false), table: "orders", error: "table missing" });
tracker.updateDataTransferTask(task.exportId, { ...transferProgress(task.exportId, "error", false), table: "users", error: "permission denied by policy" });
tracker.updateDataTransferTask(task.exportId, { ...transferProgress(task.exportId, "error"), table: "", error: "2 table(s) failed: users, orders" });
expect(task.errorMessage).toBe("2 table(s) failed: users, orders");
expect(task.transferFailures).toEqual([
{ table: "users", error: "permission denied by policy" },
{ table: "orders", error: "table missing" },
]);
});
it("bounds many distinct failures and deduplicates retained and omitted table updates", () => {
const tracker = useExportTracker();
const task = tracker.addDataTransferTask("many-failures", "many tables", 250);
for (let index = 0; index < 250; index += 1) {
tracker.updateDataTransferTask(task.exportId, {
...transferProgress(task.exportId, "error", false),
table: `table_${index}`,
error: `failure ${index}`,
});
}
expect(task.transferFailures).toHaveLength(MAX_TRANSFER_FAILURE_DETAILS);
expect(task.transferFailuresOmitted).toBe(150);
tracker.updateDataTransferTask(task.exportId, {
...transferProgress(task.exportId, "error", false),
table: "table_150",
error: "updated omitted failure",
});
tracker.updateDataTransferTask(task.exportId, {
...transferProgress(task.exportId, "error", false),
table: "table_0",
error: "updated retained failure",
});
expect(task.transferFailuresOmitted).toBe(150);
expect(task.transferFailures?.[0]).toEqual({ table: "table_0", error: "updated retained failure" });
});
it("counts omitted failures once for an online subscription", () => {
const tracker = useExportTracker();
const task = tracker.addDataTransferTask("online-failures", "many tables", 250);
for (let index = 0; index < 250; index += 1) {
tracker.updateDataTransferTask(task.exportId, {
...transferProgress(task.exportId, "error", false),
table: `table_${index}`,
error: `failure ${index}`,
});
}
tracker.updateDataTransferTask(task.exportId, transferProgress(task.exportId, "done"));
expect(task.transferFailures).toHaveLength(MAX_TRANSFER_FAILURE_DETAILS);
expect(task.transferFailuresOmitted).toBe(150);
});
it("combines pre-subscription and local omissions for a mid-transfer subscription", () => {
const tracker = useExportTracker();
const task = tracker.addDataTransferTask("mid-transfer-failures", "many tables", 250);
for (let index = 12; index < 250; index += 1) {
tracker.updateDataTransferTask(task.exportId, {
...transferProgress(task.exportId, "error", false),
table: `table_${index}`,
error: `failure ${index}`,
...(index === 249 ? { transferFailuresOmitted: 12 } : {}),
});
}
tracker.updateDataTransferTask(task.exportId, transferProgress(task.exportId, "done"));
expect(task.transferFailures).toHaveLength(MAX_TRANSFER_FAILURE_DETAILS);
expect(task.transferFailuresOmitted).toBe(150);
});
it("combines replay and local omissions for a delayed subscription", () => {
const tracker = useExportTracker();
const task = tracker.addDataTransferTask("delayed-failures", "many tables", 250);
for (let index = 12; index < 250; index += 1) {
tracker.updateDataTransferTask(task.exportId, {
...transferProgress(task.exportId, "error", false),
table: `table_${index}`,
error: `failure ${index}`,
});
}
tracker.updateDataTransferTask(task.exportId, { ...transferProgress(task.exportId, "done"), transferFailuresOmitted: 12 });
expect(task.transferFailures).toHaveLength(MAX_TRANSFER_FAILURE_DETAILS);
expect(task.transferFailuresOmitted).toBe(150);
});
it("limits individual and total UTF-8 error detail bytes without splitting characters", () => {
const tracker = useExportTracker();
const task = tracker.addDataTransferTask("long-failures", "long errors", 40);
const longError = "错误🙂".repeat(4_000);
for (let index = 0; index < 40; index += 1) {
tracker.updateDataTransferTask(task.exportId, {
...transferProgress(task.exportId, "error", false),
table: `long_table_${index}`,
error: longError,
});
}
const encoder = new TextEncoder();
const retainedBytes = task.transferFailures!.reduce((total, failure) => {
expect(encoder.encode(failure.error).length).toBeLessThanOrEqual(MAX_TRANSFER_FAILURE_ERROR_BYTES);
expect(failure.error.endsWith("\ud83d")).toBe(false);
expect(failure.truncated).toBe(true);
return total + encoder.encode(failure.table).length + encoder.encode(failure.error).length;
}, 0);
expect(retainedBytes).toBeLessThanOrEqual(MAX_TRANSFER_FAILURE_DETAIL_BYTES);
expect(task.transferFailuresOmitted).toBeGreaterThan(0);
});
it("saturates omitted failure counting after the deduplication cap", () => {
const tracker = useExportTracker();
const task = tracker.addDataTransferTask("omitted-cap", "many tables", 4_197);
for (let index = 0; index < MAX_TRANSFER_FAILURE_DETAILS + 4_097; index += 1) {
tracker.updateDataTransferTask(task.exportId, {
...transferProgress(task.exportId, "error", false),
table: `table_${index}`,
error: `failure ${index}`,
});
}
expect(task.transferFailuresOmitted).toBe(4_096);
tracker.updateDataTransferTask(task.exportId, {
...transferProgress(task.exportId, "error", false),
table: "table_4_196",
error: "repeated omitted failure",
});
expect(task.transferFailuresOmitted).toBe(4_096);
});
});
describe("SQL-file failure details", () => {
it("preserves failures in event order through terminal completion and updates duplicate statements", () => {
const tracker = useExportTracker();
const task = tracker.addSqlFileTask("sql-failures", "migration.sql", "/tmp/migration.sql");
tracker.updateSqlFileTask(task.exportId, sqlFileProgress(task.exportId, 3));
tracker.updateSqlFileTask(task.exportId, sqlFileProgress(task.exportId, 7));
tracker.updateSqlFileTask(task.exportId, sqlFileProgress(task.exportId, 3, { error: "updated failure 3" }));
tracker.updateSqlFileTask(task.exportId, sqlFileProgress(task.exportId, 8, { status: "done", successCount: 5, failureCount: 2, error: null }));
expect(task.status).toBe("Done");
expect(task.sqlFileFailures).toEqual([
{ statementIndex: 3, statementSummary: "SELECT missing_3", error: "updated failure 3" },
{ statementIndex: 7, statementSummary: "SELECT missing_7", error: "failure 7" },
]);
expect(task.failureCount).toBe(2);
});
it("retains reliable multi-file context for equal per-file statement indexes", () => {
const tracker = useExportTracker();
const task = tracker.addSqlFileTask("multi-file-failures", "first.sql (+1)", "/tmp/first.sql; /tmp/second.sql");
tracker.updateSqlFileTask(task.exportId, sqlFileProgress(task.exportId, 1), { fileIndex: 0, fileName: "first.sql" });
tracker.updateSqlFileTask(task.exportId, sqlFileProgress(task.exportId, 1), { fileIndex: 1, fileName: "second.sql" });
expect(task.sqlFileFailures).toEqual([
{ statementIndex: 1, statementSummary: "SELECT missing_1", error: "failure 1", fileIndex: 0, fileName: "first.sql" },
{ statementIndex: 1, statementSummary: "SELECT missing_1", error: "failure 1", fileIndex: 1, fileName: "second.sql" },
]);
});
it("bounds retained count and reports omitted failures without double-counting replays", () => {
const tracker = useExportTracker();
const task = tracker.addSqlFileTask("many-sql-failures", "migration.sql", "/tmp/migration.sql");
for (let index = 1; index <= MAX_SQL_FILE_FAILURE_DETAILS + 2; index += 1) {
tracker.updateSqlFileTask(task.exportId, sqlFileProgress(task.exportId, index));
}
tracker.updateSqlFileTask(task.exportId, sqlFileProgress(task.exportId, MAX_SQL_FILE_FAILURE_DETAILS + 1));
expect(task.sqlFileFailures).toHaveLength(MAX_SQL_FILE_FAILURE_DETAILS);
expect(task.sqlFileFailuresOmitted).toBe(2);
});
it("bounds UTF-8 summaries, errors, and total retained bytes", () => {
const tracker = useExportTracker();
const task = tracker.addSqlFileTask("long-sql-failures", "migration.sql", "/tmp/migration.sql");
const longText = "错误🙂".repeat(4_000);
for (let index = 1; index <= 300; index += 1) {
tracker.updateSqlFileTask(task.exportId, sqlFileProgress(task.exportId, index, { statementSummary: longText, error: longText }));
}
const encoder = new TextEncoder();
const retainedBytes = task.sqlFileFailures!.reduce((total, failure) => {
expect(encoder.encode(failure.statementSummary).length).toBeLessThanOrEqual(MAX_SQL_FILE_FAILURE_SUMMARY_BYTES);
expect(encoder.encode(failure.error).length).toBeLessThanOrEqual(MAX_SQL_FILE_FAILURE_ERROR_BYTES);
expect(failure.statementSummary.endsWith("\ud83d")).toBe(false);
expect(failure.error.endsWith("\ud83d")).toBe(false);
expect(failure.truncated).toBe(true);
return total + encoder.encode(failure.statementSummary).length + encoder.encode(failure.error).length + encoder.encode(failure.fileName ?? "").length;
}, 0);
expect(retainedBytes).toBeLessThanOrEqual(MAX_SQL_FILE_FAILURE_DETAIL_BYTES);
expect(task.sqlFileFailuresOmitted).toBeGreaterThan(0);
});
it("starts a replacement execution with an empty failure list", () => {
const tracker = useExportTracker();
const first = tracker.addSqlFileTask("reused-id", "first.sql", "/tmp/first.sql");
tracker.updateSqlFileTask(first.exportId, sqlFileProgress(first.exportId, 1));
const replacement = tracker.addSqlFileTask("reused-id", "second.sql", "/tmp/second.sql");
expect(replacement.sqlFileFailures).toEqual([]);
expect(replacement.sqlFileFailuresOmitted).toBe(0);
});
});
describe("formatDataTransferDuration", () => {
it("formats millisecond, second, minute, and hour boundaries", () => {
expect(formatDataTransferDuration(Number.NaN)).toBe("0 ms");
expect(formatDataTransferDuration(-1)).toBe("0 ms");
expect(formatDataTransferDuration(999)).toBe("999 ms");
expect(formatDataTransferDuration(1_000)).toBe("1.0 s");
expect(formatDataTransferDuration(59_999)).toBe("59.9 s");
expect(formatDataTransferDuration(60_000)).toBe("1m 0s");
expect(formatDataTransferDuration(60_999)).toBe("1m 0s");
expect(formatDataTransferDuration(3_599_999)).toBe("59m 59s");
expect(formatDataTransferDuration(3_600_000)).toBe("1h 0m 0s");
expect(formatDataTransferDuration(3_661_000)).toBe("1h 1m 1s");
});
});
describe("auto-revealing export directory on completion", () => {
it("triggers auto-reveal when manual export task succeeds with a file path", () => {
const tracker = useExportTracker();
const task = tracker.addDatabaseExportTask("db-export-1", "mydb", "/tmp/backup.sql", "manual");
tracker.updateDatabaseExportTask(task.exportId, {
exportId: task.exportId,
status: "Done",
rowsExported: 100,
totalRows: 100,
} as any);
expect(mockAutoRevealExportedPathIfConfigured).toHaveBeenCalledTimes(1);
expect(mockAutoRevealExportedPathIfConfigured).toHaveBeenCalledWith("/tmp/backup.sql");
});
it("does not trigger auto-reveal for scheduled exports", () => {
const tracker = useExportTracker();
const task = tracker.addDatabaseExportTask("db-export-sched", "mydb", "/tmp/backup.sql", "scheduled");
tracker.updateDatabaseExportTask(task.exportId, {
exportId: task.exportId,
status: "Done",
rowsExported: 100,
totalRows: 100,
} as any);
expect(mockAutoRevealExportedPathIfConfigured).not.toHaveBeenCalled();
});
it("does not trigger auto-reveal when export ends with error or cancellation", () => {
const tracker = useExportTracker();
const task = tracker.addDatabaseExportTask("db-export-err", "mydb", "/tmp/backup.sql", "manual");
tracker.updateDatabaseExportTask(task.exportId, {
exportId: task.exportId,
status: "Error",
errorMessage: "disk full",
} as any);
expect(mockAutoRevealExportedPathIfConfigured).not.toHaveBeenCalled();
});
});