test: drop source-text assertion tests and merge locale checks
This commit is contained in:
1 parent
349d77d180
commit
8897e12714
257 files changed
+166
-12815
No files matched your search
-35
@@ -1,35 +0,0 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
const connectionTreeSource = readFileSync(new URL("../ConnectionTree.vue", import.meta.url), "utf8");
|
||||
|
||||
function focusSidebarTreeNodeBody(): string {
|
||||
const match = connectionTreeSource.match(/^async function focusSidebarTreeNode[\s\S]*?^}/m);
|
||||
expect(match).not.toBeNull();
|
||||
return match![0]!;
|
||||
}
|
||||
|
||||
describe("ConnectionTree arrow focus", () => {
|
||||
it("scrolls before querying the row so out-of-window virtual rows materialize first", () => {
|
||||
const body = focusSidebarTreeNodeBody();
|
||||
const scroll = body.indexOf("await scrollToSidebarNode(nodeId);");
|
||||
const renderWait = body.indexOf("await waitForSidebarRenderFrame();");
|
||||
const query = body.indexOf('root.querySelector<HTMLElement>(`[data-node-id="${CSS.escape(nodeId)}"]`)');
|
||||
const missingRowGuard = body.indexOf("if (!row) return;");
|
||||
const focus = body.indexOf("row.focus({ preventScroll: true });");
|
||||
|
||||
// RecycleScroller only keeps the materialized window in the DOM, so the
|
||||
// index-driven scroll must run (no-op when already visible) and one render
|
||||
// frame must pass before the row can be queried and focused.
|
||||
for (const position of [scroll, renderWait, query, missingRowGuard, focus]) expect(position).toBeGreaterThan(-1);
|
||||
expect(scroll).toBeLessThan(renderWait);
|
||||
expect(renderWait).toBeLessThan(query);
|
||||
expect(query).toBeLessThan(missingRowGuard);
|
||||
expect(missingRowGuard).toBeLessThan(focus);
|
||||
});
|
||||
|
||||
it("keeps focus a no-op when the row is still not rendered after the scroll", () => {
|
||||
const body = focusSidebarTreeNodeBody();
|
||||
expect(body).toContain("if (!row) return;");
|
||||
});
|
||||
});
|
||||
-43
@@ -1,50 +1,7 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { runSidebarSearchTasks } from "../sidebarSearchTaskRunner";
|
||||
|
||||
const source = readFileSync(new URL("../ConnectionTree.vue", import.meta.url), "utf8");
|
||||
|
||||
describe("ConnectionTree global search loading", () => {
|
||||
it("discovers collapsed database and schema containers before searching object groups", () => {
|
||||
expect(source).toContain("function isSidebarSearchContainer(node: TreeNode)");
|
||||
// A collapsed database already holds the saved-SQL root, so it has children
|
||||
// even when its object groups were never fetched; the search has to look for
|
||||
// a searchable group instead of an empty child list.
|
||||
expect(source).toMatch(/isSidebarSearchContainer\(node\) && needsSidebarObjectGroupDiscovery\(node, searchableObjectGroupTypes\)/);
|
||||
expect(source).not.toMatch(/isSidebarSearchContainer\(node\) && !node\.children\?\.length/);
|
||||
expect(source).toContain("store.loadTreeNodeChildren(node, { force: true, expectedSidebarSearchQuery: store.sidebarSearchQuery, sidebarSearch: true })");
|
||||
expect(source).toContain("searchExpansionState.markFiltered(node.id, wasCollapsed)");
|
||||
expect(source).toMatch(/if \(refreshedNodeIds && node\.children\) \{[\s\S]*?searchableObjectGroupTypes\.has\(child\.type\)/);
|
||||
});
|
||||
|
||||
it("deduplicates each node within a search round and restores tracked nodes", () => {
|
||||
expect(source).toContain("const scheduledNodeIds = new Set<string>();");
|
||||
expect(source).toContain("while (deferredSearchQuery.value === query && store.sidebarSearchQuery === query)");
|
||||
expect(source).toContain("const restoreTasks = !newQuery && oldQuery ? restoreTrackedSearchTargets() : [];");
|
||||
expect(source).toContain("if (shouldCollapse) node.isExpanded = false;");
|
||||
expect(source).toContain("store.discardFilteredTreeNodeChildren(node.id);");
|
||||
});
|
||||
|
||||
it("restores the pre-search children of an expanded group instead of reloading page one", () => {
|
||||
// Clearing a remote search must put back the pages the user had loaded
|
||||
// through "load more"; only an uncaptured group falls back to a reload.
|
||||
expect(source).toContain("} else if (!store.restoreFilteredObjectGroupChildren(node)) {");
|
||||
expect(source).toMatch(/restoreFilteredObjectGroupChildren\(node\)\) \{[\s\S]*?tasks\.push\(\(\) => store\.loadObjectGroupChildren\(node, \{ force: true, sidebarSearch: true \}\)\);/);
|
||||
});
|
||||
|
||||
it("never lets the global search connect a connection on the user's behalf", () => {
|
||||
// Searching the sidebar is a background projection. Reconnecting here is what
|
||||
// surfaced a raw SQL Server TLS/login error for a connection whose saved
|
||||
// database no longer exists, so only already-connected connections may be
|
||||
// refreshed and every search-driven load is tagged for the store.
|
||||
expect(source).toContain("const connectionIsConnected = store.connectedIds.has(node.connectionId);");
|
||||
expect(source).toMatch(/if \(!connectionIsConnected \|\| node\.connectionId !== store\.activeConnectionId\) return;/);
|
||||
// Search-driven loads are tagged so the store degrades a failed reconnect to a
|
||||
// one-line skip hint instead of the raw driver error (see the store spec).
|
||||
expect(source.match(/sidebarSearch: true/g)?.length ?? 0).toBeGreaterThanOrEqual(7);
|
||||
expect(source).not.toMatch(/tasks\.push\(\(\) => store\.connect\(/);
|
||||
});
|
||||
|
||||
it("limits concurrent metadata loads without dropping a task", async () => {
|
||||
let activeTasks = 0;
|
||||
let maximumActiveTasks = 0;
|
||||
|
||||
-20
@@ -1,20 +0,0 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
const connectionTreeSource = readFileSync(new URL("../ConnectionTree.vue", import.meta.url), "utf8");
|
||||
|
||||
describe("ConnectionTree locate in collapsed groups", () => {
|
||||
it("reopens collapsed connection groups on the node path through the persisted layout op", () => {
|
||||
// Group expansion must flow through store.expandConnectionGroups so
|
||||
// layout.collapsed is flipped and the next layout rebuild keeps the group
|
||||
// open; flipping isExpanded directly would be reverted by that rebuild.
|
||||
expect(connectionTreeSource).toMatch(/const collapsedGroupIds = nodePath\s*\.filter\(\(node\) => node\.type === "connection-group" && !node\.isExpanded\)\s*\.map\(\(node\) => node\.id\);/);
|
||||
// The expansion happens before the flat-tree match that drives selection,
|
||||
// scrolling and flashing, so the reopened groups are visible to it.
|
||||
expect(connectionTreeSource).toMatch(/store\.expandConnectionGroups\(collapsedGroupIds\);\s*\}\s*\n\s*await nextTick\(\);\s*\n\s*const match = target \? findSidebarNodeForTarget\(target, flatNodes\.value\) : null;/);
|
||||
});
|
||||
|
||||
it("still gates generic ancestor expansion on loaded children only (#5850)", () => {
|
||||
expect(connectionTreeSource).toMatch(/if \(!ancestor\.isExpanded && store\.canUseLoadedTreeNodeToggle\(ancestor\)\) \{\s*ancestor\.isExpanded = true;\s*\}/);
|
||||
});
|
||||
});
|
||||
-16
@@ -1,16 +0,0 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
const connectionTreeSource = readFileSync(new URL("../ConnectionTree.vue", import.meta.url), "utf8");
|
||||
|
||||
describe("ConnectionTree selection pruning", () => {
|
||||
it("does not track the visible tree outside multi-selection", () => {
|
||||
expect(connectionTreeSource).toContain("store.connectionMultiSelectActive || store.selectedTreeNodeIds.length > 1");
|
||||
expect(connectionTreeSource).toContain("hasTreeMultiSelection.value ? flatTreeIndex.value.nodeById : null");
|
||||
expect(connectionTreeSource).not.toMatch(/watch\(\s*visibleNodes,/);
|
||||
});
|
||||
|
||||
it("defers selection cleanup until after the tree render", () => {
|
||||
expect(connectionTreeSource).toMatch(/pruneTreeSelectionToVisibleNodeIds[\s\S]*?\{ flush: "post" \}/);
|
||||
});
|
||||
});
|
||||
-11
@@ -1,11 +0,0 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
const source = readFileSync(new URL("../SidebarTreeRuntimeHost.vue", import.meta.url), "utf8");
|
||||
|
||||
describe("SidebarTreeRuntimeHost database backup menu", () => {
|
||||
it("uses the database backup support matrix independently from full-database export", () => {
|
||||
expect(source).toMatch(/const canOpenScheduledBackups = computed\(\(\) => \{[\s\S]*supportsScheduledDatabaseBackup\(rawDatabaseType\(\)\)/);
|
||||
expect(source).toMatch(/if \(canOpenScheduledBackups\.value\) \{[\s\S]*action: openScheduledBackups/);
|
||||
});
|
||||
});
|
||||
Vendored
-28
@@ -1,28 +0,0 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
const source = readFileSync(new URL("../SidebarTreeRuntimeHost.vue", import.meta.url), "utf8");
|
||||
|
||||
function functionSource(name: string, nextName: string) {
|
||||
const start = source.indexOf(`async function ${name}`);
|
||||
const end = source.indexOf(`async function ${nextName}`, start);
|
||||
expect(start).toBeGreaterThanOrEqual(0);
|
||||
expect(end).toBeGreaterThan(start);
|
||||
return source.slice(start, end);
|
||||
}
|
||||
|
||||
describe("SidebarTreeRuntimeHost compile refresh routing", () => {
|
||||
it("refreshes the Dameng schema object list after compiling a view", () => {
|
||||
const compile = functionSource("compileDamengView", "executeXuguSchedulerJobAction");
|
||||
|
||||
expect(compile).toContain("await connectionStore.refreshObjectListTreeNode(node.connectionId, node.database, node.schema);");
|
||||
expect(compile).not.toContain("await connectionStore.refreshTreeNode(node);");
|
||||
});
|
||||
|
||||
it("keeps Xugu compile refresh behavior unchanged", () => {
|
||||
const compile = functionSource("compileXuguObject", "compileDamengView");
|
||||
|
||||
expect(compile).toContain("await connectionStore.refreshTreeNode(node);");
|
||||
expect(compile).not.toContain("await connectionStore.refreshObjectListTreeNode");
|
||||
});
|
||||
});
|
||||
Vendored
-27
@@ -1,27 +0,0 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
const runtimeSource = readFileSync(fileURLToPath(new URL("../SidebarTreeRuntimeHost.vue", import.meta.url)), "utf8");
|
||||
|
||||
function functionSource(name: string): string {
|
||||
const start = runtimeSource.indexOf(`function ${name}(`);
|
||||
expect(start, `${name} not found`).toBeGreaterThan(-1);
|
||||
const next = runtimeSource.indexOf("\nfunction ", start + 1);
|
||||
return runtimeSource.slice(start, next === -1 ? undefined : next);
|
||||
}
|
||||
|
||||
describe("SidebarTreeRuntimeHost createView identifier quoting (#9099)", () => {
|
||||
it("forwards the generate-SQL settings to qualifiedTableName", () => {
|
||||
const createView = functionSource("createView");
|
||||
const callStart = createView.indexOf("qualifiedTableName({");
|
||||
expect(callStart).toBeGreaterThan(-1);
|
||||
const callEnd = createView.indexOf("});", callStart);
|
||||
const call = createView.slice(callStart, callEnd);
|
||||
|
||||
// Turning off the quote toggle must reach qualifiedTableName; otherwise it
|
||||
// unconditionally quotes the schema/view name regardless of the setting.
|
||||
expect(call).toContain("quoteIdentifiers: settingsStore.editorSettings.generateSqlQuoteIdentifiers");
|
||||
expect(call).toContain("includeDatabaseName: settingsStore.editorSettings.generateSqlIncludeDatabaseName");
|
||||
});
|
||||
});
|
||||
Vendored
-22
@@ -1,22 +0,0 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
const runtimeSource = readFileSync(fileURLToPath(new URL("../SidebarTreeRuntimeHost.vue", import.meta.url)), "utf8");
|
||||
|
||||
function asyncFunctionSource(name: string): string {
|
||||
const start = runtimeSource.indexOf(`async function ${name}(`);
|
||||
expect(start, `${name} not found`).toBeGreaterThan(-1);
|
||||
const next = runtimeSource.indexOf("\nasync function ", start + 1);
|
||||
return runtimeSource.slice(start, next === -1 ? undefined : next);
|
||||
}
|
||||
|
||||
describe("SidebarTreeRuntimeHost DDL database qualifier setting (#9421)", () => {
|
||||
it("applies the setting with each target catalog before identifier quote formatting", () => {
|
||||
const openDdl = asyncFunctionSource("openSidebarMultiTableDdlTab");
|
||||
const formatterCall = openDdl.indexOf("formatSidebarDdlTemplateForDisplay(");
|
||||
|
||||
expect(formatterCall).toBeGreaterThan(-1);
|
||||
expect(openDdl.slice(formatterCall, openDdl.indexOf(");", formatterCall))).toContain("target.catalog");
|
||||
});
|
||||
});
|
||||
Vendored
-11
@@ -1,11 +0,0 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
const source = readFileSync(new URL("../SidebarTreeRuntimeHost.vue", import.meta.url), "utf8");
|
||||
|
||||
describe("executeTreeNodeSqlWithProductionGuard executionId", () => {
|
||||
it("only registers a backend execution id for callers that opt in, instead of generating one for every caller", () => {
|
||||
expect(source).toContain("const executionId = options.executionId;");
|
||||
expect(source).not.toMatch(/executionId\s*=\s*options\.executionId\s*\?\?\s*uuid\(\)/);
|
||||
});
|
||||
});
|
||||
Vendored
-31
@@ -1,31 +0,0 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
const source = readFileSync(new URL("../SidebarTreeRuntimeHost.vue", import.meta.url), "utf8");
|
||||
|
||||
/**
|
||||
* Secondary evidence for the connection-node refresh wiring. The primary
|
||||
* behavioral coverage lives in connectionStore.refresh.spec.ts and the
|
||||
* metadata cache specs; this guards the component-side routing and error
|
||||
* classification without mounting the full sidebar tree host.
|
||||
*/
|
||||
describe("SidebarTreeRuntimeHost connection refresh cache invalidation", () => {
|
||||
it("routes connection-node refresh through the awaited strict store method", () => {
|
||||
expect(source).toMatch(/if \(node\.type === "connection" && node\.connectionId\) \{\s*try \{\s*await connectionStore\.refreshConnectionTreeNode\(node\);/);
|
||||
});
|
||||
|
||||
it("reports object cache failures distinctly without opening the driver store", () => {
|
||||
const connectionBranch = source.slice(source.indexOf("await connectionStore.refreshConnectionTreeNode(node);"), source.indexOf("await connectionStore.refreshTreeNode(node);", source.indexOf("await connectionStore.refreshConnectionTreeNode(node);")));
|
||||
const cacheFailureBlock = connectionBranch.match(/if \(isObjectCacheInvalidationError\(e\)\) \{[\s\S]*?\n\s*return;\s*\n/);
|
||||
expect(cacheFailureBlock).not.toBeNull();
|
||||
expect(cacheFailureBlock![0]).toContain('t("connection.objectCacheRefreshFailed"');
|
||||
expect(cacheFailureBlock![0]).not.toContain("openDriverStoreForInstallError");
|
||||
});
|
||||
|
||||
it("keeps the regular refresh path and its connection-error handling for other nodes", () => {
|
||||
const refresh = source.slice(source.indexOf("async function refresh()"), source.indexOf("async function copyName()"));
|
||||
const nonConnection = refresh.slice(refresh.indexOf("await connectionStore.refreshTreeNode(node);"));
|
||||
expect(nonConnection).toMatch(/toast\(t\("connection\.connectFailed"/);
|
||||
expect(nonConnection).toContain("openDriverStoreForInstallError");
|
||||
});
|
||||
});
|
||||
-11
@@ -1,11 +0,0 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
const source = readFileSync(new URL("../VisibleNacosNamespacesDialog.vue", import.meta.url), "utf8");
|
||||
|
||||
describe("VisibleNacosNamespacesDialog", () => {
|
||||
it("offers only namespaces readable by the current Nacos connection", () => {
|
||||
expect(source).toContain("loadReadableNacosNamespaces(props.connectionId, api)");
|
||||
expect(source).toContain("recordPrimaryVisibleObjectNames(props.connectionId, namespaces.value.map(nacosNamespaceValue))");
|
||||
});
|
||||
});
|
||||
-50
@@ -1,50 +0,0 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
const runtimeSource = readFileSync(new URL("../SidebarTreeRuntimeHost.vue", import.meta.url), "utf8");
|
||||
|
||||
describe("cross-database table paste", () => {
|
||||
it("keeps the live node active after async tree loads", () => {
|
||||
expect(runtimeSource).toContain("function emitNodeToggled(node: TreeNode, wasExpanded: boolean, expandedOverride?: boolean)");
|
||||
expect(runtimeSource).toContain("findSidebarActionTarget(connectionStore.treeNodes, createSidebarActionTarget(node)) ?? node");
|
||||
expect(runtimeSource).toContain("activeNode.value = liveNode");
|
||||
expect(runtimeSource).toContain("emitNodeToggled(node, wasExpanded, false)");
|
||||
expect(runtimeSource).toMatch(/await connectionStore\.loadMongoDatabases\(node\.connectionId\);[\s\S]*?emitNodeToggled\(node, wasExpanded\)/);
|
||||
expect(runtimeSource).toContain("connectionStore.cancelTreeNodeLoad(node.id)");
|
||||
});
|
||||
|
||||
it("routes a table clipboard from another context to data transfer", () => {
|
||||
expect(runtimeSource).toContain("function canTransferTreeClipboardToCurrentNode()");
|
||||
expect(runtimeSource).toContain("function openTransferFromTreeClipboard()");
|
||||
expect(runtimeSource).toContain("targetConnectionId: target.connectionId");
|
||||
expect(runtimeSource).toContain("targetDatabase: target.database");
|
||||
expect(runtimeSource).toContain("tables: clipboard.tables.map((entry) => entry.tableName)");
|
||||
expect(runtimeSource).toMatch(/function treeTableClipboardMenuItems[\s\S]*?tableClipboardMenuState\([\s\S]*?canTransferTreeClipboardToCurrentNode\(\),\s*\)/);
|
||||
});
|
||||
|
||||
it("retains the local duplicate-table paste path", () => {
|
||||
expect(runtimeSource).toContain("if (canTransferTreeClipboardToCurrentNode()) return openTransferFromTreeClipboard();");
|
||||
expect(runtimeSource).toContain("pasteTableMode.value = defaultPasteTableMode(currentDatabaseType());");
|
||||
expect(runtimeSource).toContain('normalizeNewTargetName: mode === "structure-and-data"');
|
||||
});
|
||||
|
||||
it("carries table comments through the local sidebar paste path", () => {
|
||||
expect(runtimeSource).toMatch(/tableName: node\.label,\s*tableComment: node\.comment/);
|
||||
expect(runtimeSource).toMatch(/targetName: `\$\{entry\.tableName\}_copy`,[\s\S]*?tableComment: entry\.tableComment/);
|
||||
expect(runtimeSource).toMatch(/targetName,\s*tableComment: entry\.tableComment/);
|
||||
expect(runtimeSource).toContain("executeAsScript: plan.executeAsScript");
|
||||
});
|
||||
|
||||
it("uses the shared metadata-aware structure plan for duplicate and paste", () => {
|
||||
expect(runtimeSource).toContain("buildDuplicateTableStructurePlan");
|
||||
expect(runtimeSource).toMatch(/buildDuplicateTableStructurePlan\(\{[\s\S]*?connectionId: node\.connectionId[\s\S]*?sourceName: node\.label[\s\S]*?tableComment: node\.comment/);
|
||||
expect(runtimeSource).toMatch(/buildDuplicateTableStructurePlan\(\{[\s\S]*?connectionId: entry\.connectionId[\s\S]*?sourceName: entry\.sourceName[\s\S]*?tableComment: entry\.tableComment/);
|
||||
expect(runtimeSource).toContain("sourceColumns = plan.sourceColumns");
|
||||
});
|
||||
|
||||
it("shows the first paste failure reason without concatenating every error", () => {
|
||||
expect(runtimeSource).toMatch(/pasteFailCount\+\+/);
|
||||
expect(runtimeSource).toMatch(/firstPasteError \?\?= e/);
|
||||
expect(runtimeSource).toMatch(/batchPastePartialFail[\s\S]*?tableOperationFailed[\s\S]*?translateBackendError\(t, pasteFeedback\.firstError\)/);
|
||||
});
|
||||
});
|
||||
-39
@@ -1,39 +0,0 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { dirname, resolve } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
const here = dirname(fileURLToPath(import.meta.url));
|
||||
|
||||
function read(relativePath: string) {
|
||||
return readFileSync(resolve(here, relativePath), "utf8");
|
||||
}
|
||||
|
||||
describe("mongo collection import/export UI", () => {
|
||||
it("adds table-style import/export to the original mongo-collection menu", () => {
|
||||
const menu = read("../SidebarTreeRuntimeHost.vue");
|
||||
const start = menu.indexOf('if (node.type === "mongo-collection") {\n items.push({ label: t("contextMenu.copyName")');
|
||||
expect(start).toBeGreaterThan(-1);
|
||||
const end = menu.indexOf("return true;", start);
|
||||
const block = menu.slice(start, end);
|
||||
expect(block).toContain('t("contextMenu.viewData")');
|
||||
expect(block).toContain('t("contextMenu.cloneCollection")');
|
||||
expect(block.indexOf('t("contextMenu.cloneCollection")')).toBeLessThan(block.indexOf('t("contextMenu.importData")'));
|
||||
expect(block).toContain("openMongoImport");
|
||||
expect(block).toContain('t("contextMenu.exportData")');
|
||||
expect(block).toContain('exportMongoCollection("csv")');
|
||||
expect(block).toContain('exportMongoCollection("ndjson")');
|
||||
expect(block).not.toContain("openMongoExport");
|
||||
});
|
||||
|
||||
it("opens import through AppDialogs like table import, without an export setup dialog", () => {
|
||||
const dialogs = read("../../layout/AppDialogs.vue");
|
||||
expect(dialogs).toContain("MongoImportDialog");
|
||||
expect(dialogs).not.toContain("MongoExportDialog");
|
||||
expect(dialogs).toContain("dialogs.showMongoImportDialog.value");
|
||||
|
||||
const sources = read("../../../composables/useDialogSources.ts");
|
||||
expect(sources).toContain("connectionStore.mongoImportSource");
|
||||
expect(sources).not.toContain("connectionStore.mongoExportSource");
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user