323 lines
12 KiB
TypeScript
Vendored
323 lines
12 KiB
TypeScript
Vendored
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import { createPinia, setActivePinia } from "pinia";
|
|
import { shallowRef } from "vue";
|
|
import type { TreeNode } from "@/types/database";
|
|
import { renameMongoCollectionError, renameMongoCollectionLoading, renameMongoCollectionName, showRenameMongoCollectionDialog, sidebarFormTarget } from "@/components/sidebar/sidebarTreeDialogState";
|
|
|
|
const mocks = vi.hoisted(() => ({
|
|
toast: vi.fn(),
|
|
ensureConnected: vi.fn().mockResolvedValue(undefined),
|
|
loadMongoCollections: vi.fn().mockResolvedValue(undefined),
|
|
loadVectorCollections: vi.fn().mockResolvedValue(undefined),
|
|
mongoRenameCollection: vi.fn(),
|
|
vectorRenameCollection: vi.fn(),
|
|
replacePinnedTreeNode: vi.fn(),
|
|
removeTreeNode: vi.fn(),
|
|
getConfig: vi.fn(() => ({
|
|
id: "conn-1",
|
|
name: "Mongo",
|
|
db_type: "mongodb" as const,
|
|
host: "localhost",
|
|
port: 27017,
|
|
username: "op",
|
|
password: "",
|
|
driver_profile: undefined as string | undefined,
|
|
})),
|
|
}));
|
|
|
|
vi.mock("vue-i18n", async (importOriginal) => ({
|
|
...(await importOriginal<typeof import("vue-i18n")>()),
|
|
useI18n: () => ({
|
|
t: (key: string, params?: Record<string, unknown>) => (params ? `${key}:${JSON.stringify(params)}` : key),
|
|
}),
|
|
}));
|
|
|
|
vi.mock("@/composables/useToast", () => ({
|
|
useToast: () => ({ toast: mocks.toast }),
|
|
}));
|
|
|
|
vi.mock("@/stores/connectionStore", () => ({
|
|
useConnectionStore: () => ({
|
|
getConfig: mocks.getConfig,
|
|
ensureConnected: mocks.ensureConnected,
|
|
loadMongoCollections: mocks.loadMongoCollections,
|
|
loadVectorCollections: mocks.loadVectorCollections,
|
|
replacePinnedTreeNode: mocks.replacePinnedTreeNode,
|
|
removeTreeNode: mocks.removeTreeNode,
|
|
treeNodes: [],
|
|
}),
|
|
}));
|
|
|
|
vi.mock("@/lib/backend/api", () => ({
|
|
mongoRenameCollection: (...args: unknown[]) => mocks.mongoRenameCollection(...args),
|
|
vectorRenameCollection: (...args: unknown[]) => mocks.vectorRenameCollection(...args),
|
|
mongoDropCollection: vi.fn(),
|
|
mongoDropDatabase: vi.fn(),
|
|
mongoDropIndexes: vi.fn(),
|
|
nacosCreateNamespace: vi.fn(),
|
|
nacosUpdateNamespace: vi.fn(),
|
|
redisFlushDb: vi.fn(),
|
|
}));
|
|
|
|
vi.mock("@/lib/sidebar/sidebarActionTarget", () => ({
|
|
findSidebarActionTarget: () => null,
|
|
}));
|
|
|
|
import { useSidebarDatabaseSpecificMutationRuntime } from "@/composables/useSidebarDatabaseSpecificMutationRuntime";
|
|
|
|
function collectionNode(overrides: Partial<TreeNode> = {}): TreeNode {
|
|
return {
|
|
id: "conn-1:app:users",
|
|
label: "users",
|
|
type: "mongo-collection",
|
|
connectionId: "conn-1",
|
|
database: "app",
|
|
meta: { collectionKind: "collection" },
|
|
isExpanded: false,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
describe("confirmRenameMongoCollection existing target failure", () => {
|
|
beforeEach(() => {
|
|
setActivePinia(createPinia());
|
|
vi.clearAllMocks();
|
|
mocks.getConfig.mockReturnValue({
|
|
id: "conn-1",
|
|
name: "Mongo",
|
|
db_type: "mongodb",
|
|
host: "localhost",
|
|
port: 27017,
|
|
username: "op",
|
|
password: "",
|
|
driver_profile: undefined,
|
|
});
|
|
mocks.ensureConnected.mockResolvedValue(undefined);
|
|
mocks.loadMongoCollections.mockResolvedValue(undefined);
|
|
mocks.mongoRenameCollection.mockReset();
|
|
|
|
const node = collectionNode();
|
|
sidebarFormTarget.value = node;
|
|
renameMongoCollectionName.value = "accounts";
|
|
renameMongoCollectionError.value = "";
|
|
renameMongoCollectionLoading.value = false;
|
|
showRenameMongoCollectionDialog.value = true;
|
|
});
|
|
|
|
it("surfaces mock API reject for existing target without closing the dialog or toasting success", async () => {
|
|
mocks.mongoRenameCollection.mockRejectedValue(new Error("Namespace app.accounts already exists. target namespace exists"));
|
|
|
|
const activeNode = shallowRef(collectionNode());
|
|
const { confirmRenameMongoCollection } = useSidebarDatabaseSpecificMutationRuntime({
|
|
activeNode,
|
|
connectionStore: {
|
|
getConfig: mocks.getConfig,
|
|
ensureConnected: mocks.ensureConnected,
|
|
loadMongoCollections: mocks.loadMongoCollections,
|
|
treeNodes: [],
|
|
} as any,
|
|
});
|
|
|
|
await confirmRenameMongoCollection();
|
|
|
|
expect(mocks.ensureConnected).toHaveBeenCalledWith("conn-1");
|
|
expect(mocks.mongoRenameCollection).toHaveBeenCalledWith("conn-1", "app", "users", "accounts");
|
|
expect(mocks.loadMongoCollections).not.toHaveBeenCalled();
|
|
expect(mocks.toast).not.toHaveBeenCalled();
|
|
expect(showRenameMongoCollectionDialog.value).toBe(true);
|
|
expect(renameMongoCollectionError.value).toContain("target namespace exists");
|
|
expect(renameMongoCollectionLoading.value).toBe(false);
|
|
});
|
|
|
|
it("does not call rename API when production confirmation is cancelled", async () => {
|
|
mocks.getConfig.mockReturnValue({
|
|
id: "conn-1",
|
|
name: "Mongo Prod",
|
|
db_type: "mongodb",
|
|
host: "localhost",
|
|
port: 27017,
|
|
username: "op",
|
|
password: "",
|
|
is_production: true,
|
|
});
|
|
|
|
const activeNode = shallowRef(collectionNode());
|
|
const { confirmRenameMongoCollection } = useSidebarDatabaseSpecificMutationRuntime({
|
|
activeNode,
|
|
connectionStore: {
|
|
getConfig: mocks.getConfig,
|
|
ensureConnected: mocks.ensureConnected,
|
|
loadMongoCollections: mocks.loadMongoCollections,
|
|
treeNodes: [],
|
|
} as any,
|
|
});
|
|
|
|
const pending = confirmRenameMongoCollection();
|
|
await Promise.resolve();
|
|
|
|
const { useProductionSafetyStore } = await import("@/stores/productionSafetyStore");
|
|
useProductionSafetyStore().cancel();
|
|
await pending;
|
|
|
|
expect(mocks.mongoRenameCollection).not.toHaveBeenCalled();
|
|
expect(showRenameMongoCollectionDialog.value).toBe(true);
|
|
expect(renameMongoCollectionError.value).toBe("");
|
|
expect(mocks.toast).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
function milvusCollectionNode(): TreeNode {
|
|
return {
|
|
id: "milvus-1:__vector_collection:analytics:events",
|
|
label: "events",
|
|
type: "vector-collection",
|
|
connectionId: "milvus-1",
|
|
database: "analytics",
|
|
isExpanded: false,
|
|
};
|
|
}
|
|
|
|
describe("MongoDB collection rename availability", () => {
|
|
beforeEach(() => {
|
|
setActivePinia(createPinia());
|
|
vi.clearAllMocks();
|
|
});
|
|
|
|
it("offers rename on both the native driver and the Legacy Agent", () => {
|
|
// The Agent has renameCollection (capability-gated in the backend), so the menu no longer
|
|
// hides the action on legacy connections; a read-only connection still gets nothing.
|
|
for (const driver_profile of [undefined, "mongodb-native", "mongodb-legacy"]) {
|
|
mocks.getConfig.mockReturnValue({ id: "conn-1", name: "Mongo", db_type: "mongodb", host: "localhost", port: 27017, username: "op", password: "", driver_profile });
|
|
const activeNode = shallowRef(collectionNode());
|
|
const { canRenameMongoCollection } = useSidebarDatabaseSpecificMutationRuntime({
|
|
activeNode,
|
|
connectionStore: { getConfig: mocks.getConfig, ensureConnected: mocks.ensureConnected, loadMongoCollections: mocks.loadMongoCollections, treeNodes: [] } as any,
|
|
});
|
|
expect(canRenameMongoCollection.value, `driver_profile=${driver_profile}`).toBe(true);
|
|
}
|
|
mocks.getConfig.mockReturnValue({ id: "conn-1", name: "Mongo", db_type: "mongodb", host: "localhost", port: 27017, username: "op", password: "", driver_profile: "mongodb-legacy", read_only: true });
|
|
const { canRenameMongoCollection } = useSidebarDatabaseSpecificMutationRuntime({
|
|
activeNode: shallowRef(collectionNode()),
|
|
connectionStore: { getConfig: mocks.getConfig, ensureConnected: mocks.ensureConnected, loadMongoCollections: mocks.loadMongoCollections, treeNodes: [] } as any,
|
|
});
|
|
expect(canRenameMongoCollection.value).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("Milvus collection rename", () => {
|
|
beforeEach(() => {
|
|
setActivePinia(createPinia());
|
|
vi.clearAllMocks();
|
|
mocks.getConfig.mockReturnValue({
|
|
id: "milvus-1",
|
|
name: "Milvus",
|
|
db_type: "milvus",
|
|
host: "localhost",
|
|
port: 19530,
|
|
username: "",
|
|
password: "",
|
|
} as any);
|
|
mocks.ensureConnected.mockResolvedValue(undefined);
|
|
mocks.loadVectorCollections.mockResolvedValue(undefined);
|
|
mocks.vectorRenameCollection.mockResolvedValue(undefined);
|
|
sidebarFormTarget.value = milvusCollectionNode();
|
|
});
|
|
|
|
it("renames a Milvus collection and refreshes its database node", async () => {
|
|
renameMongoCollectionName.value = "events_archive";
|
|
showRenameMongoCollectionDialog.value = true;
|
|
const feature = useSidebarDatabaseSpecificMutationRuntime({
|
|
activeNode: shallowRef(milvusCollectionNode()),
|
|
connectionStore: {
|
|
getConfig: mocks.getConfig,
|
|
ensureConnected: mocks.ensureConnected,
|
|
loadVectorCollections: mocks.loadVectorCollections,
|
|
replacePinnedTreeNode: mocks.replacePinnedTreeNode,
|
|
removeTreeNode: mocks.removeTreeNode,
|
|
treeNodes: [],
|
|
} as any,
|
|
});
|
|
|
|
expect(feature.canRenameMongoCollection.value).toBe(true);
|
|
expect(feature.canCloneMongoCollection.value).toBe(false);
|
|
await feature.confirmRenameMongoCollection();
|
|
|
|
expect(mocks.vectorRenameCollection).toHaveBeenCalledWith("milvus-1", "analytics", "events", "events_archive");
|
|
expect(mocks.loadVectorCollections).toHaveBeenCalledWith("milvus-1", "analytics");
|
|
expect(showRenameMongoCollectionDialog.value).toBe(false);
|
|
});
|
|
|
|
it("preserves a pinned Milvus collection after its rename refresh", async () => {
|
|
const storage = new Map<string, string>();
|
|
vi.stubGlobal("localStorage", {
|
|
getItem: vi.fn((key: string) => storage.get(key) ?? null),
|
|
setItem: vi.fn((key: string, value: string) => storage.set(key, value)),
|
|
removeItem: vi.fn((key: string) => storage.delete(key)),
|
|
});
|
|
vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
|
|
|
|
const { useConnectionStore } = await vi.importActual<typeof import("@/stores/connectionStore")>("@/stores/connectionStore");
|
|
const store = useConnectionStore();
|
|
const originalNode = milvusCollectionNode();
|
|
const renamedNode: TreeNode = {
|
|
...originalNode,
|
|
id: "milvus-1:__vector_collection:analytics:events_archive",
|
|
label: "events_archive",
|
|
};
|
|
const databaseNode: TreeNode = {
|
|
id: "milvus-1:analytics",
|
|
label: "analytics",
|
|
type: "vector-database",
|
|
connectionId: "milvus-1",
|
|
database: "analytics",
|
|
isExpanded: true,
|
|
children: [originalNode],
|
|
};
|
|
store.connections = [mocks.getConfig() as any];
|
|
store.treeNodes = [databaseNode];
|
|
store.toggleTreeNodePin(originalNode);
|
|
vi.spyOn(store, "ensureConnected").mockResolvedValue(undefined);
|
|
vi.spyOn(store, "loadVectorCollections").mockImplementation(async () => {
|
|
databaseNode.children = [renamedNode];
|
|
});
|
|
|
|
sidebarFormTarget.value = originalNode;
|
|
renameMongoCollectionName.value = "events_archive";
|
|
showRenameMongoCollectionDialog.value = true;
|
|
const feature = useSidebarDatabaseSpecificMutationRuntime({
|
|
activeNode: shallowRef(originalNode),
|
|
connectionStore: store,
|
|
});
|
|
|
|
await feature.confirmRenameMongoCollection();
|
|
|
|
expect(store.isTreeNodePinned(renamedNode)).toBe(true);
|
|
expect(store.isTreeNodePinned(originalNode)).toBe(false);
|
|
});
|
|
|
|
it("keeps a successful rename successful when metadata refresh fails", async () => {
|
|
mocks.loadVectorCollections.mockRejectedValueOnce(new Error("metadata timeout"));
|
|
renameMongoCollectionName.value = "events_archive";
|
|
showRenameMongoCollectionDialog.value = true;
|
|
const node = milvusCollectionNode();
|
|
const feature = useSidebarDatabaseSpecificMutationRuntime({
|
|
activeNode: shallowRef(node),
|
|
connectionStore: {
|
|
getConfig: mocks.getConfig,
|
|
ensureConnected: mocks.ensureConnected,
|
|
loadVectorCollections: mocks.loadVectorCollections,
|
|
replacePinnedTreeNode: mocks.replacePinnedTreeNode,
|
|
removeTreeNode: mocks.removeTreeNode,
|
|
treeNodes: [],
|
|
} as any,
|
|
});
|
|
|
|
await feature.confirmRenameMongoCollection();
|
|
|
|
expect(mocks.vectorRenameCollection).toHaveBeenCalledOnce();
|
|
expect(showRenameMongoCollectionDialog.value).toBe(false);
|
|
expect(mocks.removeTreeNode).toHaveBeenCalledWith(node.id);
|
|
expect(renameMongoCollectionError.value).toBe("");
|
|
});
|
|
});
|