mirror of
https://github.com/Kaelio/ktx.git
synced 2026-06-28 08:49:38 +02:00
test: split cli tests from source tree (#216)
* feat(cli): define full warehouse dialect contract
* test(cli): keep dialect edge tests focused
* fix(cli): stabilize dialect contract foundation
* refactor(connectors): own read-only query preparation
* refactor(connectors): resolve dialects through registry
* refactor(connectors): keep concrete dialect classes internal
* chore(workspace): enforce dialect import boundary
* refactor(cli): resolve relationship dialect at scan boundary
* refactor(cli): use dialect display parsing for entity details
* refactor(cli): use dialect display parsing for warehouse catalog
* refactor(cli): use dialect SQL in relationship workflows
* test(cli): verify solid dialect scan workflow closure
* test: split cli tests from source tree
* refactor(cli): standardize BigQuery scope listing
* feat(sqlite): implement connector scope listing
* test(connectors): cover required table listing
* feat(cli): add warehouse driver registry
* refactor(setup): route scope discovery through driver registry
* refactor(cli): route local query execution through driver registry
* refactor(historic-sql): route dialect support through driver registry
* refactor(cli): test warehouse connections through driver registry
* fix(cli): close driver registry type export gaps
* Improve setup daemon diagnostics
* refactor(setup): centralize rail-prefixed diagnostics + query-history fallback
Extract errorMessage, writePrefixedLines, and flushPrefixedBufferedCommandOutput
into clack.ts so the setup wizard, managed daemons, and embedding/agent steps
share one rail-formatted writer. setup-databases.ts also adds a
"disable query history and retry" option when the schema-context build fails
and query history is the likely culprit, surfaced via a new
failed-query-history-unavailable status.
* fix(cli): carry catalog through the picker so BigQuery/Snowflake/SQL Server scope filters match
The setup picker's KtxTableListEntry was a 2-level { schema, name }, so
qualifiedTableId always wrote db.name into enabled_tables. When BigQuery,
Snowflake, or SQL Server later ran fast ingest, their introspect step filtered
the scope set with scopedTableNames(scope, { catalog: projectId|database, db })
— catalog was non-null on the introspect side but null in the scope refs, so
every entry was rejected, the live-database adapter staged zero table files,
and detect() failed with 'Adapter "live-database" did not recognize fetched
source output'.
Align the picker boundary with the canonical 3-level KtxTableRef:
- Add catalog: string | null to KtxTableListEntry.
- BigQuery/Snowflake/SQL Server listTables populate catalog from the
resolved projectId / database; Postgres/MySQL/ClickHouse/SQLite set null.
- qualifiedTableId emits catalog.schema.name when catalog is non-null
(resolveEnabledTables already accepts the 3-part shape) and
schemasFromEnabledTables now goes through parseDottedTableEntry so it
recovers the schema correctly from both 2-part and 3-part entries.
- Export parseDottedTableEntry from enabled-tables.ts (@internal) for picker
reuse.
Update listTables expectations in all seven connector tests and the setup /
picker test fixtures. Add a picker regression test that covers the
catalog-bearing round-trip (save + refine).
* fix(cli): allow debug telemetry under opt-out env
This commit is contained in:
Andrey Avtomonov
GitHub
parent
924868841d
commit
56985b7e09
548 changed files with 5048 additions and 2228 deletions
|
|
@ -1,18 +0,0 @@
|
|||
import { describe, expect, it } from 'vitest';
|
||||
import { slToolConnectionIdSchema } from './connection-id-schema.js';
|
||||
|
||||
describe('slToolConnectionIdSchema', () => {
|
||||
it('accepts app UUIDs and local project connection ids', () => {
|
||||
expect(slToolConnectionIdSchema.parse('00000000-0000-4000-8000-000000000001')).toBe(
|
||||
'00000000-0000-4000-8000-000000000001',
|
||||
);
|
||||
expect(slToolConnectionIdSchema.parse('warehouse')).toBe('warehouse');
|
||||
expect(slToolConnectionIdSchema.parse('warehouse_prod-1')).toBe('warehouse_prod-1');
|
||||
});
|
||||
|
||||
it('rejects empty, path-like, and hidden connection ids', () => {
|
||||
for (const value of ['', '../warehouse', 'warehouse/prod', '.warehouse', 'warehouse prod']) {
|
||||
expect(() => slToolConnectionIdSchema.parse(value)).toThrow();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
|
@ -1,84 +0,0 @@
|
|||
import { describe, expect, it, vi } from 'vitest';
|
||||
import type { ToolContext } from '../../../context/tools/base-tool.js';
|
||||
import type { ToolSession } from '../../../context/tools/tool-session.js';
|
||||
import { createTouchedSlSources } from '../../../context/tools/touched-sl-sources.js';
|
||||
import type { SemanticLayerSource } from '../types.js';
|
||||
import { SlDiscoverTool } from './sl-discover.tool.js';
|
||||
|
||||
function makeTool() {
|
||||
const semanticLayerService = {
|
||||
listConnectionIdsWithNames: vi.fn(async () => [] as Array<{ id: string; name: string; connectionType: string }>),
|
||||
loadAllSources: vi.fn(async () => ({ sources: [] as SemanticLayerSource[], loadErrors: [] })),
|
||||
};
|
||||
const slSearchService = {
|
||||
search: vi.fn(async () => []),
|
||||
};
|
||||
const tool = new SlDiscoverTool(
|
||||
{
|
||||
semanticLayerService: semanticLayerService as never,
|
||||
slSearchService: slSearchService as never,
|
||||
authorResolver: { resolve: vi.fn() },
|
||||
},
|
||||
{ maxSources: 25, minRrfScore: 0, maxDetailedSources: 5 },
|
||||
);
|
||||
return { tool, semanticLayerService, slSearchService };
|
||||
}
|
||||
|
||||
function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
|
||||
return {
|
||||
sourceId: 'src',
|
||||
messageId: 'msg',
|
||||
userId: 'user',
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function makeSession(semanticLayerService: Record<string, unknown>): ToolSession {
|
||||
return {
|
||||
connectionId: 'dbt-main',
|
||||
isWorktreeScoped: true,
|
||||
preHead: 'base',
|
||||
touchedSlSources: createTouchedSlSources(),
|
||||
actions: [],
|
||||
semanticLayerService: semanticLayerService as never,
|
||||
wikiService: {} as never,
|
||||
configService: {} as never,
|
||||
gitService: {} as never,
|
||||
};
|
||||
}
|
||||
|
||||
describe('SlDiscoverTool - session-scoped reads', () => {
|
||||
it('discovers sources through context.session.semanticLayerService when a session is present', async () => {
|
||||
const { tool, semanticLayerService } = makeTool();
|
||||
const sessionSemanticLayerService = {
|
||||
listConnectionIdsWithNames: vi.fn().mockResolvedValue([
|
||||
{ id: 'warehouse', name: 'warehouse', connectionType: 'postgres' },
|
||||
]),
|
||||
loadAllSources: vi.fn().mockResolvedValue({
|
||||
sources: [
|
||||
{
|
||||
name: 'orders',
|
||||
table: 'public.orders',
|
||||
grain: ['order_id'],
|
||||
columns: [{ name: 'order_id', type: 'string' }],
|
||||
measures: [],
|
||||
joins: [],
|
||||
},
|
||||
],
|
||||
loadErrors: [],
|
||||
}),
|
||||
};
|
||||
|
||||
const result = await tool.call({}, makeContext({ session: makeSession(sessionSemanticLayerService) }));
|
||||
|
||||
expect(result.structured.totalSources).toBe(1);
|
||||
expect(result.structured.sources[0]).toMatchObject({
|
||||
connectionId: 'warehouse',
|
||||
name: 'orders',
|
||||
columnCount: 1,
|
||||
});
|
||||
expect(sessionSemanticLayerService.listConnectionIdsWithNames).toHaveBeenCalled();
|
||||
expect(sessionSemanticLayerService.loadAllSources).toHaveBeenCalledWith('warehouse');
|
||||
expect(semanticLayerService.listConnectionIdsWithNames).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
|
@ -1,243 +0,0 @@
|
|||
import { describe, expect, it, vi } from 'vitest';
|
||||
import type { ToolSession } from '../../../context/tools/tool-session.js';
|
||||
import { createTouchedSlSources, hasTouchedSlSource } from '../../../context/tools/touched-sl-sources.js';
|
||||
import type { ToolContext } from '../../../context/tools/base-tool.js';
|
||||
import { SlEditSourceTool } from './sl-edit-source.tool.js';
|
||||
|
||||
function makeTool(overrides: any = {}) {
|
||||
const semanticLayerService = {
|
||||
readSourceFile: vi.fn().mockResolvedValue({
|
||||
content:
|
||||
'name: orders\ntable: public.orders\ngrain: [id]\ncolumns:\n - name: id\n type: string\nmeasures: []\njoins: []\n',
|
||||
}),
|
||||
validateWithProposedSource: vi.fn().mockResolvedValue({ errors: [], warnings: [] }),
|
||||
writeSource: vi.fn().mockResolvedValue({ commitHash: 'c1' }),
|
||||
loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
|
||||
deleteSource: vi.fn().mockResolvedValue(undefined),
|
||||
isManifestBacked: vi.fn().mockResolvedValue(false),
|
||||
...overrides.semanticLayerService,
|
||||
};
|
||||
const slSearchService = {
|
||||
indexSources: vi.fn().mockResolvedValue(undefined),
|
||||
...overrides.slSearchService,
|
||||
};
|
||||
const tool = new SlEditSourceTool({
|
||||
semanticLayerService: semanticLayerService as never,
|
||||
slSearchService: slSearchService as never,
|
||||
authorResolver: { resolve: vi.fn().mockResolvedValue({ name: 'T U', email: 't@u.com' }) },
|
||||
});
|
||||
return { tool, semanticLayerService, slSearchService };
|
||||
}
|
||||
|
||||
const baseContext: ToolContext = { sourceId: 's', messageId: 'm', userId: 'u' };
|
||||
|
||||
function makeSession(overrides: Partial<ToolSession> = {}): ToolSession {
|
||||
return {
|
||||
connectionId: '11111111-1111-1111-1111-111111111111',
|
||||
isWorktreeScoped: true,
|
||||
preHead: 'base',
|
||||
touchedSlSources: createTouchedSlSources(),
|
||||
actions: [],
|
||||
semanticLayerService: {
|
||||
readSourceFile: vi.fn().mockResolvedValue({
|
||||
content:
|
||||
'name: orders\ntable: public.orders\ngrain: [id]\ncolumns:\n - name: id\n type: string\nmeasures: []\njoins: []\n',
|
||||
}),
|
||||
validateWithProposedSource: vi.fn().mockResolvedValue({ errors: [], warnings: [] }),
|
||||
writeSource: vi.fn().mockResolvedValue({ commitHash: 'c1' }),
|
||||
loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
|
||||
} as any,
|
||||
wikiService: {} as any,
|
||||
configService: {} as any,
|
||||
gitService: {} as any,
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
describe('SlEditSourceTool — session gating', () => {
|
||||
it('skips slSearchService.indexSources when session is worktree-scoped', async () => {
|
||||
const { tool, slSearchService } = makeTool();
|
||||
const session = makeSession();
|
||||
const context: ToolContext = { ...baseContext, session };
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: session.connectionId,
|
||||
sourceName: 'orders',
|
||||
yaml_edits: [{ oldText: 'measures: []', newText: 'measures: []' }],
|
||||
} as any,
|
||||
context,
|
||||
);
|
||||
expect(result.structured.success).toBe(true);
|
||||
expect(slSearchService.indexSources).not.toHaveBeenCalled();
|
||||
expect(hasTouchedSlSource(session.touchedSlSources, session.connectionId!, 'orders')).toBe(true);
|
||||
expect(session.actions).toContainEqual(expect.objectContaining({ target: 'sl', key: 'orders' }));
|
||||
});
|
||||
|
||||
it('records cross-connection SL edits with targetConnectionId', async () => {
|
||||
const { tool } = makeTool();
|
||||
const session = makeSession({ connectionId: '11111111-1111-4111-8111-111111111111' });
|
||||
const warehouseConnectionId = '22222222-2222-4222-8222-222222222222';
|
||||
const context: ToolContext = { ...baseContext, session };
|
||||
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: warehouseConnectionId,
|
||||
sourceName: 'orders',
|
||||
yaml_edits: [{ oldText: 'measures: []', newText: 'measures: []' }],
|
||||
} as any,
|
||||
context,
|
||||
);
|
||||
|
||||
expect(result.structured.success).toBe(true);
|
||||
expect(hasTouchedSlSource(session.touchedSlSources, warehouseConnectionId, 'orders')).toBe(true);
|
||||
expect(session.actions).toContainEqual(
|
||||
expect.objectContaining({
|
||||
target: 'sl',
|
||||
type: 'updated',
|
||||
key: 'orders',
|
||||
targetConnectionId: warehouseConnectionId,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('rejects session-scoped edits outside allowed target connections', async () => {
|
||||
const { tool } = makeTool();
|
||||
const session = makeSession({
|
||||
allowedConnectionNames: new Set(['warehouse']),
|
||||
});
|
||||
const context: ToolContext = { ...baseContext, session };
|
||||
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: 'finance',
|
||||
sourceName: 'orders',
|
||||
yaml_edits: [{ oldText: 'measures: []', newText: 'measures: []' }],
|
||||
} as any,
|
||||
context,
|
||||
);
|
||||
|
||||
expect(result.structured.success).toBe(false);
|
||||
expect(result.markdown).toContain('connectionId "finance" is outside this ingest session');
|
||||
expect(session.actions).toEqual([]);
|
||||
});
|
||||
|
||||
it('indexes normally when no session is present', async () => {
|
||||
const { tool, slSearchService } = makeTool();
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: '11111111-1111-1111-1111-111111111111',
|
||||
sourceName: 'orders',
|
||||
yaml_edits: [{ oldText: 'measures: []', newText: 'measures: []' }],
|
||||
} as any,
|
||||
baseContext,
|
||||
);
|
||||
expect(result.structured.success).toBe(true);
|
||||
expect(slSearchService.indexSources).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('uses session.semanticLayerService when session is present', async () => {
|
||||
const { tool } = makeTool();
|
||||
const session = makeSession();
|
||||
const context: ToolContext = { ...baseContext, session };
|
||||
await tool.call(
|
||||
{
|
||||
connectionId: session.connectionId,
|
||||
sourceName: 'orders',
|
||||
yaml_edits: [{ oldText: 'measures: []', newText: 'measures: []' }],
|
||||
} as any,
|
||||
context,
|
||||
);
|
||||
expect((session.semanticLayerService as any).writeSource).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('fills missing descriptions when an ingest session edits a source', async () => {
|
||||
const { tool } = makeTool();
|
||||
const session = makeSession({
|
||||
ingest: { runId: 'run-1', jobId: 'job-1', syncId: 'sync-1', sourceKey: 'dbt' },
|
||||
});
|
||||
const context: ToolContext = { ...baseContext, session };
|
||||
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: session.connectionId,
|
||||
sourceName: 'orders',
|
||||
yaml_edits: [{ oldText: 'measures: []', newText: 'measures: []' }],
|
||||
} as any,
|
||||
context,
|
||||
);
|
||||
|
||||
expect(result.structured.success).toBe(true);
|
||||
expect((session.semanticLayerService as any).writeSource).toHaveBeenCalledWith(
|
||||
expect.any(String),
|
||||
expect.objectContaining({
|
||||
descriptions: { ktx: expect.stringContaining('orders') },
|
||||
columns: [
|
||||
expect.objectContaining({
|
||||
descriptions: { ktx: expect.stringContaining('Identifier') },
|
||||
}),
|
||||
],
|
||||
}),
|
||||
expect.any(String),
|
||||
expect.any(String),
|
||||
expect.any(String),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('SlEditSourceTool — manifest-backed source without overlay', () => {
|
||||
it('returns a directed hint pointing at sl_write_source + overlay shape', async () => {
|
||||
const { tool, semanticLayerService } = makeTool({
|
||||
semanticLayerService: {
|
||||
readSourceFile: vi.fn().mockRejectedValue(new Error('ENOENT')),
|
||||
isManifestBacked: vi.fn().mockResolvedValue(true),
|
||||
},
|
||||
});
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: '11111111-1111-1111-1111-111111111111',
|
||||
sourceName: 'CONSIGNMENTS',
|
||||
yaml_edits: [{ oldText: 'measures: []', newText: 'measures:\n - name: aav_count\n expr: count(*)' }],
|
||||
} as any,
|
||||
baseContext,
|
||||
);
|
||||
|
||||
expect(result.structured.success).toBe(false);
|
||||
expect(semanticLayerService.isManifestBacked).toHaveBeenCalledWith(
|
||||
'11111111-1111-1111-1111-111111111111',
|
||||
'CONSIGNMENTS',
|
||||
);
|
||||
expect(semanticLayerService.writeSource).not.toHaveBeenCalled();
|
||||
|
||||
const joinedErrors = (result.structured.errors ?? []).join('\n');
|
||||
expect(joinedErrors).toContain('CONSIGNMENTS');
|
||||
expect(joinedErrors).toContain('manifest');
|
||||
expect(joinedErrors).toContain('sl_write_source');
|
||||
expect(joinedErrors).toContain('overlay');
|
||||
// Overlay shape: name plus overlay-only fields.
|
||||
expect(joinedErrors).toContain('measures');
|
||||
expect(joinedErrors).toContain('segments');
|
||||
expect(joinedErrors).toContain('column_overrides');
|
||||
});
|
||||
|
||||
it('still returns the plain "Source not found" error for truly-missing names', async () => {
|
||||
const { tool, semanticLayerService } = makeTool({
|
||||
semanticLayerService: {
|
||||
readSourceFile: vi.fn().mockRejectedValue(new Error('ENOENT')),
|
||||
isManifestBacked: vi.fn().mockResolvedValue(false),
|
||||
},
|
||||
});
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: '11111111-1111-1111-1111-111111111111',
|
||||
sourceName: 'does_not_exist',
|
||||
yaml_edits: [{ oldText: 'x', newText: 'y' }],
|
||||
} as any,
|
||||
baseContext,
|
||||
);
|
||||
|
||||
expect(result.structured.success).toBe(false);
|
||||
expect(result.structured.errors).toEqual(['Source not found. Use sl_write_source to create it.']);
|
||||
expect(semanticLayerService.isManifestBacked).toHaveBeenCalledTimes(1);
|
||||
expect(semanticLayerService.writeSource).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
|
@ -1,76 +0,0 @@
|
|||
import { describe, expect, it, vi } from 'vitest';
|
||||
import type { ToolSession } from '../../../context/tools/tool-session.js';
|
||||
import { createTouchedSlSources } from '../../../context/tools/touched-sl-sources.js';
|
||||
import type { ToolContext } from '../../../context/tools/base-tool.js';
|
||||
import { SlReadSourceTool } from './sl-read-source.tool.js';
|
||||
|
||||
function makeTool(overrides: Partial<Record<string, any>> = {}) {
|
||||
const semanticLayerService = {
|
||||
readSourceFile: vi.fn().mockResolvedValue({ content: 'name: foo_default\n', path: 'default' }),
|
||||
...overrides.semanticLayerService,
|
||||
};
|
||||
|
||||
const tool = new SlReadSourceTool({
|
||||
semanticLayerService: semanticLayerService as never,
|
||||
slSearchService: {} as never,
|
||||
authorResolver: { resolve: vi.fn() },
|
||||
});
|
||||
return { tool, semanticLayerService };
|
||||
}
|
||||
|
||||
function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
|
||||
return {
|
||||
sourceId: 'src',
|
||||
messageId: 'msg',
|
||||
userId: 'user',
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function makeSession(overrides: Partial<ToolSession> = {}): ToolSession {
|
||||
return {
|
||||
connectionId: '11111111-1111-1111-1111-111111111111',
|
||||
isWorktreeScoped: true,
|
||||
preHead: 'base',
|
||||
touchedSlSources: createTouchedSlSources(),
|
||||
actions: [],
|
||||
semanticLayerService: {
|
||||
readSourceFile: vi.fn().mockResolvedValue({ content: 'name: foo_session\n', path: 'session' }),
|
||||
} as any,
|
||||
wikiService: {} as any,
|
||||
configService: {} as any,
|
||||
gitService: {} as any,
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
describe('SlReadSourceTool - session-scoped reads', () => {
|
||||
it('reads through context.session.semanticLayerService when a session is present', async () => {
|
||||
const { tool, semanticLayerService } = makeTool();
|
||||
const session = makeSession();
|
||||
|
||||
const result = await tool.call(
|
||||
{ connectionId: '11111111-1111-1111-1111-111111111111', sourceName: 'foo' },
|
||||
makeContext({ session }),
|
||||
);
|
||||
|
||||
expect((session.semanticLayerService as any).readSourceFile).toHaveBeenCalledWith(
|
||||
'11111111-1111-1111-1111-111111111111',
|
||||
'foo',
|
||||
);
|
||||
expect(semanticLayerService.readSourceFile).not.toHaveBeenCalled();
|
||||
expect(result.structured.yaml).toContain('foo_session');
|
||||
});
|
||||
|
||||
it('reads through the default service when no session is present', async () => {
|
||||
const { tool, semanticLayerService } = makeTool();
|
||||
|
||||
const result = await tool.call(
|
||||
{ connectionId: '11111111-1111-1111-1111-111111111111', sourceName: 'foo' },
|
||||
makeContext(),
|
||||
);
|
||||
|
||||
expect(semanticLayerService.readSourceFile).toHaveBeenCalledWith('11111111-1111-1111-1111-111111111111', 'foo');
|
||||
expect(result.structured.yaml).toContain('foo_default');
|
||||
});
|
||||
});
|
||||
|
|
@ -1,68 +0,0 @@
|
|||
import { describe, expect, it, vi } from 'vitest';
|
||||
import type { ToolSession } from '../../../context/tools/tool-session.js';
|
||||
import { createTouchedSlSources, hasTouchedSlSource } from '../../../context/tools/touched-sl-sources.js';
|
||||
import type { ToolContext } from '../../../context/tools/base-tool.js';
|
||||
import { SlRollbackTool } from './sl-rollback.tool.js';
|
||||
|
||||
function makeSession(overrides: Partial<ToolSession> = {}): ToolSession {
|
||||
return {
|
||||
connectionId: 'conn-1',
|
||||
isWorktreeScoped: true,
|
||||
preHead: 'base',
|
||||
touchedSlSources: createTouchedSlSources([{ connectionId: 'conn-1', sourceName: 'orders' }]),
|
||||
actions: [{ target: 'sl', type: 'updated', key: 'orders', detail: 'x' }],
|
||||
semanticLayerService: {} as any,
|
||||
wikiService: {} as any,
|
||||
configService: {
|
||||
writeFile: vi.fn().mockResolvedValue(undefined),
|
||||
deleteFile: vi.fn().mockResolvedValue(undefined),
|
||||
} as any,
|
||||
gitService: { getFileAtCommit: vi.fn().mockResolvedValue('pre: content') } as any,
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
describe('SlRollbackTool', () => {
|
||||
const connections = {
|
||||
getConnectionById: vi.fn(),
|
||||
listEnabledConnections: vi.fn(),
|
||||
executeQuery: vi.fn(),
|
||||
};
|
||||
|
||||
it('errors when context.session is absent', async () => {
|
||||
const tool = new SlRollbackTool({} as never, connections as never, 1);
|
||||
const context: ToolContext = { sourceId: 's', messageId: 'm', userId: 'u' };
|
||||
const result = await tool.call({ sourceName: 'orders' } as any, context);
|
||||
expect(result.structured.success).toBe(false);
|
||||
expect(result.markdown).toMatch(/session/i);
|
||||
});
|
||||
|
||||
it('errors when session has no connectionId (wiki-only turn)', async () => {
|
||||
const tool = new SlRollbackTool({} as never, connections as never, 1);
|
||||
const session = makeSession({ connectionId: null });
|
||||
const context: ToolContext = { sourceId: 's', messageId: 'm', userId: 'u', session };
|
||||
const result = await tool.call({ sourceName: 'orders' } as any, context);
|
||||
expect(result.structured.success).toBe(false);
|
||||
expect(result.markdown).toMatch(/connection-scoped session/i);
|
||||
// Session state untouched
|
||||
expect(hasTouchedSlSource(session.touchedSlSources, 'conn-1', 'orders')).toBe(true);
|
||||
expect((session.gitService as any).getFileAtCommit).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('restores the source content from preHead, clears touched set, prunes actions', async () => {
|
||||
const slSourcesRepository = { deleteByConnectionAndName: vi.fn().mockResolvedValue(undefined) };
|
||||
const tool = new SlRollbackTool(slSourcesRepository as never, connections as never, 1);
|
||||
const session = makeSession();
|
||||
const context: ToolContext = { sourceId: 's', messageId: 'm', userId: 'u', session };
|
||||
const result = await tool.call({ sourceName: 'orders' } as any, context);
|
||||
|
||||
expect(result.structured.success).toBe(true);
|
||||
expect((session.gitService as any).getFileAtCommit).toHaveBeenCalledWith(
|
||||
expect.stringContaining('orders.yaml'),
|
||||
'base',
|
||||
);
|
||||
expect((session.configService as any).writeFile).toHaveBeenCalled();
|
||||
expect(hasTouchedSlSource(session.touchedSlSources, 'conn-1', 'orders')).toBe(false);
|
||||
expect(session.actions).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
|
@ -1,67 +0,0 @@
|
|||
import { describe, expect, it, vi } from 'vitest';
|
||||
import type { ToolSession } from '../../../context/tools/tool-session.js';
|
||||
import { createTouchedSlSources } from '../../../context/tools/touched-sl-sources.js';
|
||||
import type { ToolContext } from '../../../context/tools/base-tool.js';
|
||||
import type { SemanticLayerService } from '../semantic-layer.service.js';
|
||||
import type { SemanticLayerSource } from '../types.js';
|
||||
import { SlValidateTool, validateSemanticLayerEndpoint } from './sl-validate.tool.js';
|
||||
|
||||
describe('validateSemanticLayerEndpoint', () => {
|
||||
it('uses the connection warehouse dialect, not hardcoded postgres', async () => {
|
||||
const serviceMock = {
|
||||
validateSourcesForConnection: vi.fn().mockResolvedValue({ errors: [], warnings: [] }),
|
||||
};
|
||||
|
||||
await validateSemanticLayerEndpoint('conn-1', serviceMock as unknown as SemanticLayerService);
|
||||
|
||||
expect(serviceMock.validateSourcesForConnection).toHaveBeenCalledWith('conn-1');
|
||||
});
|
||||
|
||||
it('short-circuits when there are no validatable sources', async () => {
|
||||
const serviceMock = {
|
||||
validateSourcesForConnection: vi.fn().mockResolvedValue({ errors: [], warnings: [] }),
|
||||
};
|
||||
|
||||
const result = await validateSemanticLayerEndpoint('conn-1', serviceMock as unknown as SemanticLayerService);
|
||||
|
||||
expect(result).toEqual({ errors: [], warnings: [] });
|
||||
});
|
||||
});
|
||||
|
||||
describe('SlValidateTool — session-aware touched-set filtering', () => {
|
||||
it('when session present, only returns errors/warnings that mention touched sources', async () => {
|
||||
const sources: SemanticLayerSource[] = [
|
||||
{ name: 'orders', table: 'x.orders', grain: ['id'], columns: [], joins: [], measures: [] },
|
||||
{ name: 'customers', table: 'x.customers', grain: ['id'], columns: [], joins: [], measures: [] },
|
||||
];
|
||||
const serviceMock = {
|
||||
loadAllSources: vi.fn().mockResolvedValue({ sources, loadErrors: [] }),
|
||||
validateSourcesForConnection: vi.fn().mockResolvedValue({
|
||||
errors: ['orders: missing join target', 'customers: invalid grain'],
|
||||
warnings: ['orders: disconnected-components warning'],
|
||||
}),
|
||||
};
|
||||
|
||||
const tool = new SlValidateTool({
|
||||
semanticLayerService: serviceMock as never,
|
||||
slSearchService: {} as never,
|
||||
authorResolver: { resolve: vi.fn() },
|
||||
});
|
||||
|
||||
const session: ToolSession = {
|
||||
connectionId: 'conn-1',
|
||||
isWorktreeScoped: true,
|
||||
preHead: null,
|
||||
touchedSlSources: createTouchedSlSources([{ connectionId: 'conn-1', sourceName: 'orders' }]),
|
||||
actions: [],
|
||||
semanticLayerService: serviceMock as any,
|
||||
wikiService: {} as any,
|
||||
configService: {} as any,
|
||||
gitService: {} as any,
|
||||
};
|
||||
const context: ToolContext = { sourceId: 's', messageId: 'm', userId: 'u', session };
|
||||
const result = await tool.call({ connectionId: 'conn-1' } as any, context);
|
||||
expect(result.structured.validationErrors).toEqual(['orders: missing join target']);
|
||||
expect(result.structured.validationWarnings).toEqual(['orders: disconnected-components warning']);
|
||||
});
|
||||
});
|
||||
|
|
@ -1,146 +0,0 @@
|
|||
import { describe, expect, it, vi } from 'vitest';
|
||||
import { validateSingleSource } from './sl-warehouse-validation.js';
|
||||
|
||||
function makeDeps(opts: { sourceYaml: string; executeQuery: ReturnType<typeof vi.fn> }) {
|
||||
return {
|
||||
semanticLayerService: {
|
||||
readSourceFile: vi.fn().mockResolvedValue({ content: opts.sourceYaml, path: 'x' }),
|
||||
isManifestBacked: vi.fn().mockResolvedValue(false),
|
||||
listManifestSourceNames: vi.fn().mockResolvedValue([]),
|
||||
loadSource: vi.fn().mockResolvedValue(null),
|
||||
loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
|
||||
validatePhysicalTableReferences: vi.fn().mockResolvedValue([]),
|
||||
} as never,
|
||||
connections: {
|
||||
executeQuery: opts.executeQuery,
|
||||
getConnectionById: vi.fn().mockResolvedValue({ id: 'conn-1', name: 'conn-1', connectionType: 'bigquery' }),
|
||||
listEnabledConnections: vi.fn().mockResolvedValue([]),
|
||||
} as never,
|
||||
configService: {} as never,
|
||||
gitService: {} as never,
|
||||
slSourcesRepository: { deleteByConnectionAndName: vi.fn().mockResolvedValue(undefined) } as never,
|
||||
probeRowCount: 1,
|
||||
};
|
||||
}
|
||||
|
||||
describe('validateSingleSource warehouse dry-run', () => {
|
||||
it('surfaces warehouse error when dry-run fails on unknown column', async () => {
|
||||
const yaml = `name: fct_arr_delta
|
||||
source_type: sql
|
||||
sql: |
|
||||
SELECT * FROM analytics.fct_arr_delta WHERE date_date < CURRENT_DATE()
|
||||
grain: [date_date]
|
||||
columns:
|
||||
- name: date_date
|
||||
type: time
|
||||
measures:
|
||||
- name: count_delta_events
|
||||
expr: count(*)
|
||||
joins: []
|
||||
`;
|
||||
const executeQuery = vi.fn().mockRejectedValue(new Error('Unrecognized name: date_date at [1:42]'));
|
||||
const deps = makeDeps({ sourceYaml: yaml, executeQuery });
|
||||
const result = await validateSingleSource(deps, 'conn-1', 'fct_arr_delta');
|
||||
expect(result.errors.join('\n')).toMatch(/Unrecognized name: date_date/);
|
||||
expect(result.errors.join('\n')).toMatch(/embedded sql dry-run failed/);
|
||||
});
|
||||
|
||||
it('flags declared columns missing from the dry-run result', async () => {
|
||||
const yaml = `name: fct_arr_delta
|
||||
source_type: sql
|
||||
sql: |
|
||||
SELECT date, customer_id FROM analytics.fct_arr_delta
|
||||
columns:
|
||||
- name: date_date
|
||||
type: time
|
||||
- name: customer_id
|
||||
type: string
|
||||
measures:
|
||||
- name: count_delta
|
||||
expr: count(*)
|
||||
joins: []
|
||||
grain: [customer_id]
|
||||
`;
|
||||
const executeQuery = vi.fn().mockResolvedValue({
|
||||
headers: ['date', 'customer_id'],
|
||||
rows: [],
|
||||
totalRows: 0,
|
||||
error: null,
|
||||
});
|
||||
const deps = makeDeps({ sourceYaml: yaml, executeQuery });
|
||||
const result = await validateSingleSource(deps, 'conn-1', 'fct_arr_delta');
|
||||
expect(result.errors.join('\n')).toMatch(/declared columns absent from sql result — date_date/);
|
||||
expect(result.errors.join('\n')).toMatch(/warehouse returned:/);
|
||||
});
|
||||
|
||||
it('passes cleanly when dry-run succeeds and declared columns match', async () => {
|
||||
const yaml = `name: lab_results
|
||||
source_type: sql
|
||||
sql: |
|
||||
SELECT lab_order_id, admin_user_id FROM analytics.raw_lab_results
|
||||
grain: [lab_order_id]
|
||||
columns:
|
||||
- name: lab_order_id
|
||||
type: string
|
||||
- name: admin_user_id
|
||||
type: string
|
||||
measures:
|
||||
- name: count_lab_results
|
||||
expr: count(lab_order_id)
|
||||
joins: []
|
||||
`;
|
||||
const executeQuery = vi.fn().mockResolvedValue({
|
||||
headers: ['lab_order_id', 'admin_user_id'],
|
||||
rows: [],
|
||||
totalRows: 0,
|
||||
error: null,
|
||||
});
|
||||
const deps = makeDeps({ sourceYaml: yaml, executeQuery });
|
||||
const result = await validateSingleSource(deps, 'conn-1', 'lab_results');
|
||||
expect(result.errors).toEqual([]);
|
||||
});
|
||||
|
||||
it('uses LIMIT 1 (not LIMIT 0) so runtime policies fire', async () => {
|
||||
const yaml = `name: foo
|
||||
source_type: sql
|
||||
sql: |
|
||||
SELECT a FROM analytics.bar
|
||||
grain: [a]
|
||||
columns:
|
||||
- {name: a, type: string}
|
||||
measures: []
|
||||
joins: []
|
||||
`;
|
||||
const executeQuery = vi.fn().mockResolvedValue({ headers: ['a'], rows: [], totalRows: 0, error: null });
|
||||
const deps = makeDeps({ sourceYaml: yaml, executeQuery });
|
||||
await validateSingleSource(deps, 'conn-1', 'foo');
|
||||
const probeSql = executeQuery.mock.calls[0][1] as string;
|
||||
expect(probeSql).toMatch(/LIMIT 1\b/);
|
||||
expect(probeSql).not.toMatch(/LIMIT 0\b/);
|
||||
});
|
||||
|
||||
it('adds physical manifest errors for table-backed sources', async () => {
|
||||
const yaml = `name: int_active_contract_arr
|
||||
table: orbit_analytics.int_active_contract_arr
|
||||
grain: [contract_id]
|
||||
columns:
|
||||
- {name: contract_id, type: string}
|
||||
- {name: arr_cents, type: number}
|
||||
measures:
|
||||
- {name: arr, expr: sum(arr_cents)}
|
||||
joins: []
|
||||
`;
|
||||
const executeQuery = vi.fn();
|
||||
const deps = makeDeps({ sourceYaml: yaml, executeQuery }) as any;
|
||||
deps.semanticLayerService.validatePhysicalTableReferences.mockResolvedValue([
|
||||
'int_active_contract_arr.yaml: declared column(s) absent from physical table: arr_cents',
|
||||
]);
|
||||
|
||||
const result = await validateSingleSource(deps, 'conn-1', 'int_active_contract_arr');
|
||||
|
||||
expect(result.errors).toContain(
|
||||
'int_active_contract_arr.yaml: declared column(s) absent from physical table: arr_cents',
|
||||
);
|
||||
expect(executeQuery).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
|
@ -1,379 +0,0 @@
|
|||
import { describe, expect, it, vi } from 'vitest';
|
||||
import type { ToolSession } from '../../../context/tools/tool-session.js';
|
||||
import { createTouchedSlSources, hasTouchedSlSource } from '../../../context/tools/touched-sl-sources.js';
|
||||
import type { ToolContext } from '../../../context/tools/base-tool.js';
|
||||
import { SlWriteSourceTool } from './sl-write-source.tool.js';
|
||||
|
||||
function makeTool(overrides: Partial<Record<string, any>> = {}) {
|
||||
const semanticLayerService = {
|
||||
listManifestSourceNames: vi.fn().mockResolvedValue(['ACCOUNTS', 'ORDERS']),
|
||||
isManifestBacked: vi.fn().mockResolvedValue(false),
|
||||
loadSource: vi.fn().mockResolvedValue(null),
|
||||
loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
|
||||
validateWithProposedSource: vi.fn().mockResolvedValue({ errors: [], warnings: [] }),
|
||||
writeSource: vi.fn().mockResolvedValue({ commitHash: 'c1' }),
|
||||
deleteSource: vi.fn().mockResolvedValue(undefined),
|
||||
readSourceFile: vi.fn().mockRejectedValue(new Error('not found')),
|
||||
...overrides.semanticLayerService,
|
||||
};
|
||||
const slSearchService = {
|
||||
indexSources: vi.fn().mockResolvedValue(undefined),
|
||||
...overrides.slSearchService,
|
||||
};
|
||||
const tool = new SlWriteSourceTool({
|
||||
semanticLayerService: semanticLayerService as never,
|
||||
slSearchService: slSearchService as never,
|
||||
authorResolver: { resolve: vi.fn().mockResolvedValue({ name: 'T U', email: 't@u.com' }) },
|
||||
});
|
||||
return { tool, semanticLayerService, slSearchService };
|
||||
}
|
||||
|
||||
const baseContext: ToolContext = { sourceId: 's', messageId: 'm', userId: 'u' };
|
||||
|
||||
describe('SlWriteSourceTool — orphan overlay guard', () => {
|
||||
it('rejects overlay YAMLs targeting a name absent from the manifest', async () => {
|
||||
const { tool } = makeTool();
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: '11111111-1111-1111-1111-111111111111',
|
||||
sourceName: 'does_not_exist',
|
||||
source: {
|
||||
name: 'does_not_exist',
|
||||
measures: [{ name: 'count_rows', expr: 'count(*)' }],
|
||||
} as any,
|
||||
} as any,
|
||||
baseContext,
|
||||
);
|
||||
expect(result.structured.success).toBe(false);
|
||||
expect(result.markdown).toMatch(/no manifest entry with that name exists/i);
|
||||
expect(result.markdown).toMatch(/ACCOUNTS|ORDERS/);
|
||||
});
|
||||
});
|
||||
|
||||
describe('SlWriteSourceTool — session gating', () => {
|
||||
function makeSession(overrides: Partial<ToolSession> = {}): ToolSession {
|
||||
return {
|
||||
connectionId: '11111111-1111-1111-1111-111111111111',
|
||||
isWorktreeScoped: true,
|
||||
preHead: 'base',
|
||||
touchedSlSources: createTouchedSlSources(),
|
||||
actions: [],
|
||||
semanticLayerService: {
|
||||
loadSource: vi.fn().mockResolvedValue(null),
|
||||
loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
|
||||
validateWithProposedSource: vi.fn().mockResolvedValue({ errors: [], warnings: [] }),
|
||||
writeSource: vi.fn().mockResolvedValue({ commitHash: 'c1' }),
|
||||
deleteSource: vi.fn().mockResolvedValue(undefined),
|
||||
listManifestSourceNames: vi.fn().mockResolvedValue([]),
|
||||
isManifestBacked: vi.fn().mockResolvedValue(false),
|
||||
readSourceFile: vi.fn().mockRejectedValue(new Error('not found')),
|
||||
findManifestEntryByTableRef: vi.fn().mockResolvedValue(null),
|
||||
} as any,
|
||||
wikiService: {} as any,
|
||||
configService: {} as any,
|
||||
gitService: {} as any,
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
it('skips slSearchService.indexSources when session is worktree-scoped', async () => {
|
||||
const { tool, slSearchService } = makeTool();
|
||||
const session = makeSession();
|
||||
const context: ToolContext = { ...baseContext, session };
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: session.connectionId,
|
||||
sourceName: 'my_source',
|
||||
source: {
|
||||
name: 'my_source',
|
||||
sql: 'select 1 as id',
|
||||
grain: ['id'],
|
||||
columns: [{ name: 'id', type: 'string' }],
|
||||
measures: [],
|
||||
joins: [],
|
||||
} as any,
|
||||
} as any,
|
||||
context,
|
||||
);
|
||||
expect(result.structured.success).toBe(true);
|
||||
expect(slSearchService.indexSources).not.toHaveBeenCalled();
|
||||
expect(hasTouchedSlSource(session.touchedSlSources, session.connectionId!, 'my_source')).toBe(true);
|
||||
expect(session.actions).toContainEqual(expect.objectContaining({ target: 'sl', key: 'my_source' }));
|
||||
});
|
||||
|
||||
it('records cross-connection SL writes with targetConnectionId', async () => {
|
||||
const { tool } = makeTool();
|
||||
const session = makeSession({ connectionId: '11111111-1111-4111-8111-111111111111' });
|
||||
const warehouseConnectionId = '22222222-2222-4222-8222-222222222222';
|
||||
const context: ToolContext = { ...baseContext, session };
|
||||
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: warehouseConnectionId,
|
||||
sourceName: 'mapped_orders',
|
||||
source: {
|
||||
name: 'mapped_orders',
|
||||
table: 'public.orders',
|
||||
grain: ['id'],
|
||||
columns: [{ name: 'id', type: 'string' }],
|
||||
measures: [],
|
||||
joins: [],
|
||||
} as any,
|
||||
} as any,
|
||||
context,
|
||||
);
|
||||
|
||||
expect(result.structured.success).toBe(true);
|
||||
expect(hasTouchedSlSource(session.touchedSlSources, warehouseConnectionId, 'mapped_orders')).toBe(true);
|
||||
expect(session.actions).toContainEqual(
|
||||
expect.objectContaining({
|
||||
target: 'sl',
|
||||
key: 'mapped_orders',
|
||||
targetConnectionId: warehouseConnectionId,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('rejects session-scoped writes outside allowed target connections', async () => {
|
||||
const { tool } = makeTool();
|
||||
const session = makeSession({
|
||||
allowedConnectionNames: new Set(['warehouse']),
|
||||
});
|
||||
const context: ToolContext = { ...baseContext, session };
|
||||
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: 'finance',
|
||||
sourceName: 'finance_orders',
|
||||
source: {
|
||||
name: 'finance_orders',
|
||||
table: 'public.orders',
|
||||
grain: ['id'],
|
||||
columns: [{ name: 'id', type: 'string' }],
|
||||
measures: [],
|
||||
joins: [],
|
||||
} as any,
|
||||
} as any,
|
||||
context,
|
||||
);
|
||||
|
||||
expect(result.structured.success).toBe(false);
|
||||
expect(result.markdown).toContain('connectionId "finance" is outside this ingest session');
|
||||
expect(session.actions).toEqual([]);
|
||||
});
|
||||
|
||||
it('indexes normally when no session is present', async () => {
|
||||
const { tool, slSearchService } = makeTool();
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: '11111111-1111-1111-1111-111111111111',
|
||||
sourceName: 'my_source',
|
||||
source: {
|
||||
name: 'my_source',
|
||||
sql: 'select 1 as id',
|
||||
grain: ['id'],
|
||||
columns: [{ name: 'id', type: 'string' }],
|
||||
measures: [],
|
||||
joins: [],
|
||||
} as any,
|
||||
} as any,
|
||||
baseContext,
|
||||
);
|
||||
expect(result.structured.success).toBe(true);
|
||||
expect(slSearchService.indexSources).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('uses session.semanticLayerService when session is present', async () => {
|
||||
const { tool } = makeTool();
|
||||
const session = makeSession();
|
||||
const context: ToolContext = { ...baseContext, session };
|
||||
await tool.call(
|
||||
{
|
||||
connectionId: session.connectionId,
|
||||
sourceName: 'my_source',
|
||||
source: {
|
||||
name: 'my_source',
|
||||
sql: 'select 1 as id',
|
||||
grain: ['id'],
|
||||
columns: [{ name: 'id', type: 'string' }],
|
||||
measures: [],
|
||||
joins: [],
|
||||
} as any,
|
||||
} as any,
|
||||
context,
|
||||
);
|
||||
expect((session.semanticLayerService as any).writeSource).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('writes source and column description maps', async () => {
|
||||
const { tool, semanticLayerService } = makeTool();
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: '11111111-1111-1111-1111-111111111111',
|
||||
sourceName: 'orders',
|
||||
source: {
|
||||
name: 'orders',
|
||||
descriptions: { user: 'Finance orders used for invoice reconciliation.' },
|
||||
table: 'public.orders',
|
||||
grain: ['id'],
|
||||
columns: [{ name: 'id', type: 'string', descriptions: { user: 'Stable order identifier.' } }],
|
||||
measures: [],
|
||||
joins: [],
|
||||
} as any,
|
||||
} as any,
|
||||
baseContext,
|
||||
);
|
||||
|
||||
expect(result.structured.success).toBe(true);
|
||||
expect(semanticLayerService.writeSource).toHaveBeenCalledWith(
|
||||
expect.any(String),
|
||||
expect.objectContaining({
|
||||
descriptions: { user: 'Finance orders used for invoice reconciliation.' },
|
||||
columns: [expect.objectContaining({ descriptions: { user: 'Stable order identifier.' } })],
|
||||
}),
|
||||
expect.any(String),
|
||||
expect.any(String),
|
||||
expect.any(String),
|
||||
);
|
||||
});
|
||||
|
||||
it('fills missing descriptions for ingest-written overlays and columns', async () => {
|
||||
const session = makeSession({
|
||||
ingest: { runId: 'run-1', jobId: 'job-1', syncId: 'sync-1', sourceKey: 'metabase' },
|
||||
semanticLayerService: {
|
||||
loadSource: vi.fn().mockResolvedValue(null),
|
||||
loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
|
||||
validateWithProposedSource: vi.fn().mockResolvedValue({ errors: [], warnings: [] }),
|
||||
writeSource: vi.fn().mockResolvedValue({ commitHash: 'c1' }),
|
||||
deleteSource: vi.fn().mockResolvedValue(undefined),
|
||||
listManifestSourceNames: vi.fn().mockResolvedValue(['mart_account_segments']),
|
||||
isManifestBacked: vi.fn().mockResolvedValue(false),
|
||||
readSourceFile: vi.fn().mockRejectedValue(new Error('not found')),
|
||||
findManifestEntryByTableRef: vi.fn().mockResolvedValue(null),
|
||||
} as any,
|
||||
});
|
||||
const { tool } = makeTool();
|
||||
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: session.connectionId,
|
||||
sourceName: 'mart_account_segments',
|
||||
source: {
|
||||
name: 'mart_account_segments',
|
||||
columns: [{ name: 'is_large_contract', type: 'boolean', expr: 'contract_arr_cents >= 20000000' }],
|
||||
measures: [{ name: 'account_count', expr: 'count(account_id)' }],
|
||||
} as any,
|
||||
} as any,
|
||||
{ ...baseContext, session },
|
||||
);
|
||||
|
||||
expect(result.structured.success).toBe(true);
|
||||
expect((session.semanticLayerService as any).writeSource).toHaveBeenCalledWith(
|
||||
expect.any(String),
|
||||
expect.objectContaining({
|
||||
descriptions: {
|
||||
ktx: expect.stringContaining('mart_account_segments'),
|
||||
},
|
||||
columns: [
|
||||
expect.objectContaining({
|
||||
descriptions: {
|
||||
ktx: expect.stringContaining('is large contract'),
|
||||
},
|
||||
}),
|
||||
],
|
||||
}),
|
||||
expect.any(String),
|
||||
expect.any(String),
|
||||
expect.any(String),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('SlWriteSourceTool — disconnected-components warning in markdown', () => {
|
||||
it('surfaces validation warnings (including disconnected-components) in the markdown body', async () => {
|
||||
const { tool } = makeTool({
|
||||
semanticLayerService: {
|
||||
validateWithProposedSource: vi.fn().mockResolvedValue({
|
||||
errors: [],
|
||||
warnings: ['orders: disconnected-components — no join path to ACCOUNTS'],
|
||||
}),
|
||||
},
|
||||
});
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: '11111111-1111-1111-1111-111111111111',
|
||||
sourceName: 'orders',
|
||||
source: {
|
||||
name: 'orders',
|
||||
sql: 'select 1 as id',
|
||||
grain: ['id'],
|
||||
columns: [{ name: 'id', type: 'string' }],
|
||||
measures: [],
|
||||
joins: [],
|
||||
} as any,
|
||||
} as any,
|
||||
baseContext,
|
||||
);
|
||||
expect(result.markdown).toMatch(/disconnected-components/i);
|
||||
});
|
||||
|
||||
it('renders per-source warnings prominently when the just-written source becomes a singleton component', async () => {
|
||||
const { tool } = makeTool({
|
||||
semanticLayerService: {
|
||||
validateWithProposedSource: vi.fn().mockResolvedValue({
|
||||
errors: [],
|
||||
warnings: ['Model has 2 disconnected components.'],
|
||||
perSourceWarnings: {
|
||||
foo: ["Source 'foo' is now a singleton component (no joins to any other source)."],
|
||||
},
|
||||
}),
|
||||
},
|
||||
});
|
||||
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: '11111111-1111-1111-1111-111111111111',
|
||||
sourceName: 'foo',
|
||||
source: {
|
||||
name: 'foo',
|
||||
sql: 'select 1 as id',
|
||||
grain: ['id'],
|
||||
columns: [{ name: 'id', type: 'string' }],
|
||||
measures: [],
|
||||
joins: [],
|
||||
} as any,
|
||||
} as any,
|
||||
baseContext,
|
||||
);
|
||||
|
||||
expect(result.markdown).toMatch(/Action required/i);
|
||||
expect(result.markdown).toContain("Source 'foo' is now a singleton component");
|
||||
});
|
||||
});
|
||||
|
||||
describe('SlWriteSourceTool — standalone shadow guard', () => {
|
||||
it('rejects standalone YAMLs that shadow a manifest entry', async () => {
|
||||
const { tool } = makeTool({
|
||||
semanticLayerService: {
|
||||
isManifestBacked: vi.fn().mockResolvedValue(true),
|
||||
},
|
||||
});
|
||||
const result = await tool.call(
|
||||
{
|
||||
connectionId: '11111111-1111-1111-1111-111111111111',
|
||||
sourceName: 'ACCOUNTS',
|
||||
source: {
|
||||
name: 'ACCOUNTS',
|
||||
table: 'raw.accounts',
|
||||
grain: ['id'],
|
||||
columns: [{ name: 'id', type: 'string' }],
|
||||
measures: [],
|
||||
joins: [],
|
||||
} as any,
|
||||
} as any,
|
||||
baseContext,
|
||||
);
|
||||
expect(result.structured.success).toBe(false);
|
||||
expect(result.markdown).toMatch(/shadows an existing manifest entry|already exists/i);
|
||||
});
|
||||
});
|
||||
Loading…
Add table
Add a link
Reference in a new issue