This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
gitgram-ai/aitimemachine/gitnexus-web/test/unit/server-connection.test.ts
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00

576 lines
19 KiB
TypeScript

import { afterEach, describe, expect, it, vi } from 'vitest';
import {
connectToServer,
fetchGraph,
getBackendUrl,
GraphTooLargeError,
normalizeServerUrl,
setBackendUrl,
validateBackendUrl,
} from '../../src/services/backend-client';
// ── NDJSON stream helpers for the U3 circuit-breaker tests ──
const ndjsonStream = (lines: string[]): ReadableStream<Uint8Array> => {
const encoder = new TextEncoder();
return new ReadableStream<Uint8Array>({
start(controller) {
for (const l of lines) controller.enqueue(encoder.encode(l));
controller.close();
},
});
};
const ndjsonResponse = (lines: string[]): Response =>
new Response(ndjsonStream(lines), {
status: 200,
headers: { 'Content-Type': 'application/x-ndjson' },
});
const nodeLine = (i: number): string =>
`{"type":"node","data":{"id":"n${i}","label":"Function","properties":{"name":"f${i}"}}}\n`;
const relLine = (i: number): string =>
`{"type":"relationship","data":{"id":"r${i}","type":"CALLS","sourceId":"n0","targetId":"n${i}"}}\n`;
describe('normalizeServerUrl', () => {
it('adds http:// to localhost', () => {
expect(normalizeServerUrl('localhost:4747')).toBe('http://localhost:4747');
});
it('adds http:// to 127.0.0.1', () => {
expect(normalizeServerUrl('127.0.0.1:4747')).toBe('http://127.0.0.1:4747');
});
it('adds https:// to non-local hosts', () => {
expect(normalizeServerUrl('example.com')).toBe('https://example.com');
});
it('strips trailing slashes', () => {
expect(normalizeServerUrl('http://localhost:4747/')).toBe('http://localhost:4747');
expect(normalizeServerUrl('http://localhost:4747///')).toBe('http://localhost:4747');
});
it('strips /api suffix (base URL only)', () => {
expect(normalizeServerUrl('http://localhost:4747/api')).toBe('http://localhost:4747');
});
it('trims whitespace', () => {
expect(normalizeServerUrl(' localhost:4747 ')).toBe('http://localhost:4747');
});
it('preserves existing https://', () => {
expect(normalizeServerUrl('https://gitnexus.example.com')).toBe('https://gitnexus.example.com');
});
});
afterEach(() => {
vi.restoreAllMocks();
});
describe('fetchGraph', () => {
it('requests streamed graph responses from the backend', async () => {
setBackendUrl('http://localhost:4747');
const fetchMock = vi.fn().mockResolvedValue(
new Response('{"nodes":[],"relationships":[]}', {
status: 200,
headers: {
'Content-Type': 'application/json',
},
}),
);
vi.stubGlobal('fetch', fetchMock);
await fetchGraph('big-repo');
expect(fetchMock).toHaveBeenCalledWith(
expect.stringContaining('/api/graph?repo=big-repo&stream=true'),
expect.any(Object),
);
});
it('parses NDJSON graph streams incrementally', async () => {
setBackendUrl('http://localhost:4747');
const encoder = new TextEncoder();
const stream = new ReadableStream<Uint8Array>({
start(controller) {
controller.enqueue(
encoder.encode(
[
'{"type":"node","data":{"id":"File:src/app.ts","label":"File","properties":{"name":"app.ts","filePath":"src/app.ts"}}}\n',
'{"type":"relationship","data":{"id":"File:src/app.ts_CONTAINS_Function:src/app.ts:main","type":"CONTAINS","sourceId":"File:src/app.ts","targetId":"Function:src/app.ts:main"}}\n',
].join(''),
),
);
controller.close();
},
});
vi.stubGlobal(
'fetch',
vi.fn().mockResolvedValue(
new Response(stream, {
status: 200,
headers: {
'Content-Type': 'application/x-ndjson',
},
}),
),
);
const progress = vi.fn();
const result = await fetchGraph('big-repo', { onProgress: progress });
expect(result.nodes).toHaveLength(1);
expect(result.relationships).toHaveLength(1);
expect(result.nodes[0].id).toBe('File:src/app.ts');
expect(result.relationships[0].type).toBe('CONTAINS');
expect(progress).toHaveBeenCalled();
});
it('parses NDJSON graph lines split across chunks', async () => {
setBackendUrl('http://localhost:4747');
const encoder = new TextEncoder();
const stream = new ReadableStream<Uint8Array>({
start(controller) {
controller.enqueue(
encoder.encode(
'{"type":"node","data":{"id":"File:src/app.ts","label":"File","properties":{"name":"app.ts"',
),
);
controller.enqueue(
encoder.encode(
',"filePath":"src/app.ts"}}}\n{"type":"relationship","data":{"id":"File:src/app.ts_CONTAINS_Function:src/app.ts:main","type":"CONTAINS","sourceId":"File:src/app.ts","targetId":"Function:src/app.ts:main"}}\n',
),
);
controller.close();
},
});
vi.stubGlobal(
'fetch',
vi.fn().mockResolvedValue(
new Response(stream, {
status: 200,
headers: {
'Content-Type': 'application/x-ndjson',
},
}),
),
);
const result = await fetchGraph('big-repo');
expect(result.nodes).toHaveLength(1);
expect(result.relationships).toHaveLength(1);
expect(result.nodes[0].properties.filePath).toBe('src/app.ts');
});
it('throws backend errors emitted in the NDJSON stream', async () => {
setBackendUrl('http://localhost:4747');
const encoder = new TextEncoder();
const stream = new ReadableStream<Uint8Array>({
start(controller) {
controller.enqueue(encoder.encode('{"type":"error","error":"stream failed"}\n'));
controller.close();
},
});
vi.stubGlobal(
'fetch',
vi.fn().mockResolvedValue(
new Response(stream, {
status: 200,
headers: {
'Content-Type': 'application/x-ndjson',
},
}),
),
);
await expect(fetchGraph('big-repo')).rejects.toMatchObject({
message: 'stream failed',
});
});
});
describe('connectToServer skipGraph (chat-only mode)', () => {
const repoInfo = (nodes: number | undefined) => ({
name: 'big-repo',
path: '/repos/big-repo',
repoPath: '/repos/big-repo',
indexedAt: '2026-06-13T00:00:00Z',
...(nodes !== undefined ? { stats: { nodes, edges: nodes * 2 } } : {}),
});
// Routes /api/repo to the repo info and /api/graph to the supplied handler;
// any other path returns an empty 200 so the breaker stays closed.
const makeFetchMock = (nodes: number | undefined) => {
const graphHandler = vi.fn(
() =>
new Response('{"nodes":[],"relationships":[]}', {
status: 200,
headers: { 'Content-Type': 'application/json' },
}),
);
const fetchMock = vi.fn((url: string) => {
if (url.includes('/api/repo')) {
return Promise.resolve(
new Response(JSON.stringify(repoInfo(nodes)), {
status: 200,
headers: { 'Content-Type': 'application/json' },
}),
);
}
if (url.includes('/api/graph')) {
return Promise.resolve(graphHandler());
}
return Promise.resolve(
new Response('{}', { status: 200, headers: { 'Content-Type': 'application/json' } }),
);
});
return { fetchMock, graphHandler };
};
const graphRequests = (fetchMock: ReturnType<typeof vi.fn>) =>
fetchMock.mock.calls.filter(([u]: unknown[]) => String(u).includes('/api/graph'));
it('skips the graph download when skipGraph is true (even for a tiny repo)', async () => {
const { fetchMock } = makeFetchMock(5);
vi.stubGlobal('fetch', fetchMock);
const result = await connectToServer(
'http://localhost:4747',
undefined,
undefined,
'big-repo',
{
skipGraph: true,
},
);
expect(result.graphSkipped).toBe(true);
expect(result.nodes).toEqual([]);
expect(result.relationships).toEqual([]);
expect(result.repoInfo.name).toBe('big-repo');
expect(graphRequests(fetchMock)).toHaveLength(0);
});
it('downloads the graph when skipGraph is false (even for a huge repo)', async () => {
const { fetchMock } = makeFetchMock(300_000);
vi.stubGlobal('fetch', fetchMock);
const result = await connectToServer(
'http://localhost:4747',
undefined,
undefined,
'big-repo',
{
skipGraph: false,
},
);
expect(result.graphSkipped).toBe(false);
expect(graphRequests(fetchMock).length).toBeGreaterThan(0);
});
it('auto-detects a large project and skips the graph (no explicit flag)', async () => {
const { fetchMock } = makeFetchMock(300_000);
vi.stubGlobal('fetch', fetchMock);
const result = await connectToServer('http://localhost:4747', undefined, undefined, 'big-repo');
expect(result.graphSkipped).toBe(true);
expect(graphRequests(fetchMock)).toHaveLength(0);
});
it('downloads the graph for a small project (no explicit flag)', async () => {
const { fetchMock } = makeFetchMock(500);
vi.stubGlobal('fetch', fetchMock);
const result = await connectToServer('http://localhost:4747', undefined, undefined, 'big-repo');
expect(result.graphSkipped).toBe(false);
expect(graphRequests(fetchMock).length).toBeGreaterThan(0);
});
it('fails open to a full download when node stats are missing', async () => {
const { fetchMock } = makeFetchMock(undefined);
vi.stubGlobal('fetch', fetchMock);
const result = await connectToServer('http://localhost:4747', undefined, undefined, 'big-repo');
expect(result.graphSkipped).toBe(false);
expect(graphRequests(fetchMock).length).toBeGreaterThan(0);
});
it('auto-detects an edge-heavy repo (nodes under, edges over the threshold)', async () => {
// 10K nodes (< 25K node threshold) but 80K edges (> 50K edge threshold).
const fetchMock = vi.fn((url: string) => {
if (url.includes('/api/repo')) {
return Promise.resolve(
new Response(
JSON.stringify({
name: 'edgy-repo',
path: '/repos/edgy-repo',
repoPath: '/repos/edgy-repo',
indexedAt: '2026-06-13T00:00:00Z',
stats: { nodes: 10_000, edges: 80_000 },
}),
{ status: 200, headers: { 'Content-Type': 'application/json' } },
),
);
}
return Promise.resolve(
new Response('{}', { status: 200, headers: { 'Content-Type': 'application/json' } }),
);
});
vi.stubGlobal('fetch', fetchMock);
const result = await connectToServer(
'http://localhost:4747',
undefined,
undefined,
'edgy-repo',
);
expect(result.graphSkipped).toBe(true);
expect(fetchMock.mock.calls.filter(([u]) => String(u).includes('/api/graph'))).toHaveLength(0);
});
});
describe('DEFAULT_BACKEND_URL resolution', () => {
afterEach(() => {
delete window.__GITNEXUS_CONFIG__;
vi.resetModules();
});
it('falls back to localhost:4747 when no config is injected', async () => {
delete window.__GITNEXUS_CONFIG__;
const { DEFAULT_BACKEND_URL } = await import('../../src/config/ui-constants');
expect(DEFAULT_BACKEND_URL).toBe('http://localhost:4747');
});
it('uses window.__GITNEXUS_CONFIG__.backendUrl when set', async () => {
window.__GITNEXUS_CONFIG__ = { backendUrl: 'http://10.0.0.1:4747' };
const { DEFAULT_BACKEND_URL } = await import('../../src/config/ui-constants');
expect(DEFAULT_BACKEND_URL).toBe('http://10.0.0.1:4747');
});
it('falls back to localhost:4747 when config object has no backendUrl', async () => {
window.__GITNEXUS_CONFIG__ = {};
const { DEFAULT_BACKEND_URL } = await import('../../src/config/ui-constants');
expect(DEFAULT_BACKEND_URL).toBe('http://localhost:4747');
});
it('falls back to localhost:4747 when backendUrl is an empty string', async () => {
window.__GITNEXUS_CONFIG__ = { backendUrl: '' };
const { DEFAULT_BACKEND_URL } = await import('../../src/config/ui-constants');
expect(DEFAULT_BACKEND_URL).toBe('http://localhost:4747');
});
});
describe('LARGE_GRAPH_NODE_THRESHOLD resolution', () => {
afterEach(() => {
delete window.__GITNEXUS_CONFIG__;
vi.resetModules();
});
it('defaults to 25000 when no config is injected', async () => {
delete window.__GITNEXUS_CONFIG__;
const { LARGE_GRAPH_NODE_THRESHOLD } = await import('../../src/config/ui-constants');
expect(LARGE_GRAPH_NODE_THRESHOLD).toBe(25_000);
});
it('uses a valid positive override', async () => {
window.__GITNEXUS_CONFIG__ = { largeGraphNodeThreshold: 100_000 };
const { LARGE_GRAPH_NODE_THRESHOLD } = await import('../../src/config/ui-constants');
expect(LARGE_GRAPH_NODE_THRESHOLD).toBe(100_000);
});
it('ignores NaN, zero, and negative overrides (falls back to default)', async () => {
for (const bad of [NaN, 0, -10]) {
window.__GITNEXUS_CONFIG__ = { largeGraphNodeThreshold: bad };
vi.resetModules();
const { LARGE_GRAPH_NODE_THRESHOLD } = await import('../../src/config/ui-constants');
expect(LARGE_GRAPH_NODE_THRESHOLD, `override=${bad}`).toBe(25_000);
}
});
});
describe('validateBackendUrl', () => {
it('allows http:// URLs', () => {
expect(() => validateBackendUrl('http://localhost:4747')).not.toThrow();
expect(() => validateBackendUrl('http://127.0.0.1:4747')).not.toThrow();
});
it('allows https:// URLs', () => {
expect(() => validateBackendUrl('https://gitnexus.example.com')).not.toThrow();
expect(() => validateBackendUrl('https://my-server.internal:4747')).not.toThrow();
});
it('rejects non-http schemes', () => {
expect(() => validateBackendUrl('javascript:alert(1)')).toThrow('must use http:// or https://');
expect(() => validateBackendUrl('file:///etc/passwd')).toThrow('must use http:// or https://');
expect(() => validateBackendUrl('data:text/plain,evil')).toThrow(
'must use http:// or https://',
);
});
it('rejects malformed URLs', () => {
expect(() => validateBackendUrl('not-a-url')).toThrow('Invalid backend URL');
});
it('does not include the raw URL in error messages (credential hygiene)', () => {
const urlWithCreds = 'javascript:alert("sk-secret")';
let msg = '';
try {
validateBackendUrl(urlWithCreds);
} catch (e) {
msg = (e as Error).message;
}
expect(msg).not.toContain('sk-secret');
expect(msg).not.toContain(urlWithCreds);
});
});
describe('setBackendUrl', () => {
it('accepts valid http URLs', () => {
expect(() => setBackendUrl('http://localhost:4747')).not.toThrow();
});
it('accepts valid https URLs', () => {
expect(() => setBackendUrl('https://my-server.example.com')).not.toThrow();
});
it('rejects non-http/https schemes', () => {
expect(() => setBackendUrl('javascript:alert(1)')).toThrow('must use http:// or https://');
expect(() => setBackendUrl('file:///etc/passwd')).toThrow('must use http:// or https://');
});
it('does not mutate _backendUrl when validation fails', () => {
setBackendUrl('http://localhost:4747');
expect(() => setBackendUrl('javascript:alert(1)')).toThrow();
expect(getBackendUrl()).toBe('http://localhost:4747');
});
});
describe('fetchGraph streaming size breaker (#2178)', () => {
it('throws GraphTooLargeError when node count exceeds maxNodes', async () => {
setBackendUrl('http://localhost:4747');
vi.stubGlobal(
'fetch',
vi.fn().mockResolvedValue(ndjsonResponse([nodeLine(0), nodeLine(1), nodeLine(2)])),
);
await expect(fetchGraph('repo', { maxNodes: 2 })).rejects.toBeInstanceOf(GraphTooLargeError);
});
it('completes when node count is at or below maxNodes (== not >)', async () => {
setBackendUrl('http://localhost:4747');
vi.stubGlobal('fetch', vi.fn().mockResolvedValue(ndjsonResponse([nodeLine(0), nodeLine(1)])));
const result = await fetchGraph('repo', { maxNodes: 2 });
expect(result.nodes).toHaveLength(2);
});
it('trips on the edge counter for a node-light stream', async () => {
setBackendUrl('http://localhost:4747');
vi.stubGlobal(
'fetch',
vi.fn().mockResolvedValue(ndjsonResponse([nodeLine(0), relLine(1), relLine(2), relLine(3)])),
);
await expect(fetchGraph('repo', { maxNodes: 1000, maxEdges: 2 })).rejects.toBeInstanceOf(
GraphTooLargeError,
);
});
it('never trips when no limits are passed (default behavior unchanged)', async () => {
setBackendUrl('http://localhost:4747');
vi.stubGlobal(
'fetch',
vi
.fn()
.mockResolvedValue(ndjsonResponse([nodeLine(0), nodeLine(1), nodeLine(2), relLine(3)])),
);
const result = await fetchGraph('repo');
expect(result.nodes).toHaveLength(3);
expect(result.relationships).toHaveLength(1);
});
it('breaker wins over a later error record in the same stream', async () => {
setBackendUrl('http://localhost:4747');
vi.stubGlobal(
'fetch',
vi
.fn()
.mockResolvedValue(
ndjsonResponse([
nodeLine(0),
nodeLine(1),
nodeLine(2),
'{"type":"error","error":"late boom"}\n',
]),
),
);
await expect(fetchGraph('repo', { maxNodes: 2 })).rejects.toBeInstanceOf(GraphTooLargeError);
});
});
describe('connectToServer streaming breaker (no-stats fail-open backstop, #2178)', () => {
afterEach(() => {
delete window.__GITNEXUS_CONFIG__;
vi.resetModules();
});
// Re-import with a tiny threshold so a 3-record stream exercises the breaker.
const setupTinyThreshold = async () => {
window.__GITNEXUS_CONFIG__ = { largeGraphNodeThreshold: 2, largeGraphEdgeThreshold: 2 };
vi.resetModules();
const mod = await import('../../src/services/backend-client');
mod.setBackendUrl('http://localhost:4747');
return mod;
};
const repoNoStats = () =>
new Response(
JSON.stringify({ name: 'r', path: '/r', repoPath: '/r', indexedAt: '2026-06-13T00:00:00Z' }),
{ status: 200, headers: { 'Content-Type': 'application/json' } },
);
it('falls into chat-only when an auto-detect stream exceeds the threshold (absent stats)', async () => {
const { connectToServer: connect } = await setupTinyThreshold();
const fetchMock = vi.fn((url: string) => {
if (url.includes('/api/repo')) return Promise.resolve(repoNoStats());
if (url.includes('/api/graph'))
return Promise.resolve(ndjsonResponse([nodeLine(0), nodeLine(1), nodeLine(2)]));
return Promise.resolve(
new Response('{}', { status: 200, headers: { 'Content-Type': 'application/json' } }),
);
});
vi.stubGlobal('fetch', fetchMock);
const result = await connect('http://localhost:4747', undefined, undefined, 'r');
expect(result.graphSkipped).toBe(true);
expect(result.nodes).toEqual([]);
expect(result.relationships).toEqual([]);
});
it('does NOT enforce the breaker for an explicit load-anyway (skipGraph:false)', async () => {
const { connectToServer: connect } = await setupTinyThreshold();
const fetchMock = vi.fn((url: string) => {
if (url.includes('/api/repo')) return Promise.resolve(repoNoStats());
if (url.includes('/api/graph'))
return Promise.resolve(ndjsonResponse([nodeLine(0), nodeLine(1), nodeLine(2)]));
return Promise.resolve(
new Response('{}', { status: 200, headers: { 'Content-Type': 'application/json' } }),
);
});
vi.stubGlobal('fetch', fetchMock);
const result = await connect('http://localhost:4747', undefined, undefined, 'r', {
skipGraph: false,
});
expect(result.graphSkipped).toBe(false);
expect(result.nodes).toHaveLength(3);
});
});