@monoes/monograph 1.5.6 → 1.5.8

package/src/__tests__/graph/regex-search.test.ts

@@ -1,166 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  regexSearchNodes,
-  regexSearchEdges,
-  regexSearchNodesInMemory,
-  regexSearchEdgesInMemory,
-} from '../../graph/regex-search.js';
-import { openDb } from '../../storage/db.js';
-import { join } from 'path';
-import { mkdtempSync } from 'fs';
-import { tmpdir } from 'os';
-import type { MonographNode, MonographEdge } from '../../types.js';
-
-function makeTempDb() {
-  const dir = mkdtempSync(join(tmpdir(), 'monograph-regex-search-test-'));
-  return openDb(join(dir, 'test.db'));
-}
-
-function insertNode(
-  db: ReturnType<typeof openDb>,
-  id: string,
-  name = id,
-  opts: { filePath?: string; language?: string; label?: string } = {},
-) {
-  db.prepare(
-    `INSERT INTO nodes (id, label, name, norm_label, file_path, language, is_exported)
-     VALUES (?, ?, ?, ?, ?, ?, 0)`,
-  ).run(id, opts.label ?? 'Function', name, name.toLowerCase(), opts.filePath ?? null, opts.language ?? null);
-}
-
-function insertEdge(
-  db: ReturnType<typeof openDb>,
-  id: string,
-  src: string,
-  tgt: string,
-  relation = 'CALLS',
-  reason: string | null = null,
-) {
-  db.prepare(
-    `INSERT INTO edges (id, source_id, target_id, relation, confidence, confidence_score, reason)
-     VALUES (?, ?, ?, ?, 'EXTRACTED', 1.0, ?)`,
-  ).run(id, src, tgt, relation, reason);
-}
-
-// ── DB-backed node search ──────────────────────────────────────────────────────
-
-describe('regexSearchNodes (DB)', () => {
-  it('matches nodes by name using regex', () => {
-    const db = makeTempDb();
-    insertNode(db, 'n1', 'authenticateUser');
-    insertNode(db, 'n2', 'validateInput');
-    insertNode(db, 'n3', 'handleRequest');
-    const results = regexSearchNodes(db, /authenticate/i);
-    expect(results).toHaveLength(1);
-    expect(results[0].node.id).toBe('n1');
-    expect(results[0].field).toBe('name');
-    db.close();
-  });
-
-  it('accepts string pattern', () => {
-    const db = makeTempDb();
-    insertNode(db, 'n1', 'UserService');
-    insertNode(db, 'n2', 'OrderService');
-    const results = regexSearchNodes(db, 'User');
-    expect(results).toHaveLength(1);
-    db.close();
-  });
-
-  it('matches by filePath', () => {
-    const db = makeTempDb();
-    insertNode(db, 'n1', 'login', { filePath: '/auth/login.ts' });
-    insertNode(db, 'n2', 'hash', { filePath: '/utils/crypto.ts' });
-    const results = regexSearchNodes(db, /\/auth\//, ['filePath']);
-    expect(results).toHaveLength(1);
-    expect(results[0].field).toBe('filePath');
-    db.close();
-  });
-
-  it('returns empty for no match', () => {
-    const db = makeTempDb();
-    insertNode(db, 'n1', 'fooBar');
-    const results = regexSearchNodes(db, /^zzz/);
-    expect(results).toHaveLength(0);
-    db.close();
-  });
-
-  it('reports each node at most once', () => {
-    const db = makeTempDb();
-    // name and filePath both match but should only appear once
-    insertNode(db, 'n1', 'auth', { filePath: '/auth/index.ts' });
-    const results = regexSearchNodes(db, /auth/, ['name', 'filePath']);
-    expect(results).toHaveLength(1);
-    db.close();
-  });
-});
-
-// ── DB-backed edge search ──────────────────────────────────────────────────────
-
-describe('regexSearchEdges (DB)', () => {
-  it('matches edges by relation', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a'); insertNode(db, 'b'); insertNode(db, 'c');
-    insertEdge(db, 'e1', 'a', 'b', 'CALLS');
-    insertEdge(db, 'e2', 'b', 'c', 'IMPORTS');
-    const results = regexSearchEdges(db, /^CALLS$/);
-    expect(results).toHaveLength(1);
-    expect(results[0].edge.id).toBe('e1');
-    expect(results[0].field).toBe('relation');
-    db.close();
-  });
-
-  it('matches edges by reason', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a'); insertNode(db, 'b');
-    insertEdge(db, 'e1', 'a', 'b', 'CALLS', 'direct function call');
-    insertEdge(db, 'e2', 'a', 'b', 'CALLS', null);
-    const results = regexSearchEdges(db, /direct/, ['reason']);
-    expect(results).toHaveLength(1);
-    expect(results[0].edge.id).toBe('e1');
-    db.close();
-  });
-});
-
-// ── In-memory variants ─────────────────────────────────────────────────────────
-
-describe('regexSearchNodesInMemory', () => {
-  const nodes: MonographNode[] = [
-    { id: 'n1', label: 'Function', name: 'loginUser', normLabel: 'loginuser', filePath: '/auth/login.ts', isExported: true },
-    { id: 'n2', label: 'Class', name: 'UserService', normLabel: 'userservice', filePath: '/services/user.ts', isExported: true },
-    { id: 'n3', label: 'Function', name: 'hash', normLabel: 'hash', isExported: false },
-  ];
-
-  it('matches by name', () => {
-    const results = regexSearchNodesInMemory(nodes, /User/);
-    expect(results.map(r => r.node.id)).toContain('n2');
-    expect(results.map(r => r.node.id)).toContain('n1');
-  });
-
-  it('matches by filePath', () => {
-    const results = regexSearchNodesInMemory(nodes, /\/auth\//, ['filePath']);
-    expect(results).toHaveLength(1);
-  });
-
-  it('returns empty for no match', () => {
-    expect(regexSearchNodesInMemory(nodes, /^zzz/)).toHaveLength(0);
-  });
-});
-
-describe('regexSearchEdgesInMemory', () => {
-  const edges: MonographEdge[] = [
-    { id: 'e1', sourceId: 'a', targetId: 'b', relation: 'CALLS', confidence: 'EXTRACTED', confidenceScore: 1, reason: 'function call' },
-    { id: 'e2', sourceId: 'b', targetId: 'c', relation: 'IMPORTS', confidence: 'INFERRED', confidenceScore: 0.5 },
-  ];
-
-  it('matches by relation', () => {
-    const results = regexSearchEdgesInMemory(edges, /^IMPORTS$/);
-    expect(results).toHaveLength(1);
-    expect(results[0].edge.id).toBe('e2');
-  });
-
-  it('matches by reason', () => {
-    const results = regexSearchEdgesInMemory(edges, /function/, ['reason']);
-    expect(results).toHaveLength(1);
-    expect(results[0].field).toBe('reason');
-  });
-});

package/src/__tests__/graph/ripple-impact.test.ts

@@ -1,73 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { rippleImpact } from '../../graph/ripple-impact.js';
-
-const edges = [
-  { sourceId: 'a', targetId: 'b' },
-  { sourceId: 'b', targetId: 'c' },
-  { sourceId: 'c', targetId: 'd' },
-  { sourceId: 'd', targetId: 'e' },
-];
-
-describe('rippleImpact', () => {
-  it('returns only direct neighbors at depth 1', () => {
-    const result = rippleImpact('a', edges, 1);
-    expect(result.byDepth[1]).toContain('b');
-    expect(result.byDepth[2]).toBeUndefined();
-  });
-
-  it('returns nodes at each depth level', () => {
-    const result = rippleImpact('a', edges, 3);
-    expect(result.byDepth[1]).toContain('b');
-    expect(result.byDepth[2]).toContain('c');
-    expect(result.byDepth[3]).toContain('d');
-  });
-
-  it('does not repeat nodes across depths', () => {
-    const loopyEdges = [
-      { sourceId: 'a', targetId: 'b' },
-      { sourceId: 'b', targetId: 'c' },
-      { sourceId: 'c', targetId: 'a' }, // cycle
-    ];
-    const result = rippleImpact('a', loopyEdges, 5);
-    const allNodes = Object.values(result.byDepth).flat();
-    const unique = new Set(allNodes);
-    expect(unique.size).toBe(allNodes.length);
-  });
-
-  it('totalScore is positive and decreases with depth-only paths', () => {
-    const result = rippleImpact('a', edges, 4);
-    expect(result.totalScore).toBeGreaterThan(0);
-  });
-
-  it('score at depth 2 is less than score at depth 1 (decay)', () => {
-    const result = rippleImpact('a', edges, 2);
-    expect(result.byDepth[1]?.length ?? 0).toBeGreaterThan(0);
-    // total score should reflect decay weighting
-    const result1 = rippleImpact('a', edges, 1);
-    expect(result.totalScore).toBeGreaterThan(result1.totalScore);
-  });
-
-  it('returns empty result for unknown node', () => {
-    const result = rippleImpact('unknown', edges, 3);
-    expect(Object.keys(result.byDepth)).toHaveLength(0);
-    expect(result.totalScore).toBe(0);
-  });
-
-  it('respects maxDepth boundary', () => {
-    const result = rippleImpact('a', edges, 2);
-    expect(result.byDepth[3]).toBeUndefined();
-  });
-
-  it('works on directed edges (not traversing backwards)', () => {
-    // directed: a→b→c only; starting from 'c' should yield nothing
-    const result = rippleImpact('c', edges, 3);
-    // 'd' is downstream of c
-    expect(result.byDepth[1]).toContain('d');
-  });
-
-  it('returns totalScore 0 when node has no outgoing edges', () => {
-    const result = rippleImpact('e', edges, 3);
-    expect(result.totalScore).toBe(0);
-    expect(Object.keys(result.byDepth)).toHaveLength(0);
-  });
-});

package/src/__tests__/graph/scc.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { findStronglyConnectedComponents } from '../../graph/cycles.js';
-import { openDb } from '../../storage/db.js';
-import Database from 'better-sqlite3';
-import { join } from 'path';
-import { mkdtempSync } from 'fs';
-import { tmpdir } from 'os';
-
-function makeTempDb() {
-  const dir = mkdtempSync(join(tmpdir(), 'monograph-scc-test-'));
-  return openDb(join(dir, 'test.db'));
-}
-
-function insertNode(db: Database.Database, id: string) {
-  db.prepare(`INSERT INTO nodes (id, label, name, norm_label, is_exported) VALUES (?, 'Function', ?, ?, 0)`)
-    .run(id, id, id.toLowerCase());
-}
-
-function insertEdge(db: Database.Database, src: string, tgt: string) {
-  db.prepare(`INSERT INTO edges (id, source_id, target_id, relation, confidence, confidence_score) VALUES (?, ?, ?, 'CALLS', 'EXTRACTED', 1.0)`)
-    .run(`${src}_${tgt}`, src, tgt);
-}
-
-describe('findStronglyConnectedComponents', () => {
-  it('returns empty array for empty graph', () => {
-    const db = makeTempDb();
-    expect(findStronglyConnectedComponents(db)).toEqual([]);
-    db.close();
-  });
-
-  it('returns each single node as its own SCC in a DAG', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    const result = findStronglyConnectedComponents(db);
-    // In a DAG, every node is its own SCC
-    expect(result.length).toBe(3);
-    expect(result.every(comp => comp.length === 1)).toBe(true);
-    db.close();
-  });
-
-  it('returns single SCC containing both nodes for a->b->a cycle', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'a');
-    const result = findStronglyConnectedComponents(db);
-    const cycleScc = result.find(comp => comp.length === 2);
-    expect(cycleScc).toBeDefined();
-    expect(cycleScc!.sort()).toEqual(['a', 'b']);
-    db.close();
-  });
-
-  it('covers all nodes across all SCCs', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertNode(db, 'd');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'a'); // cycle: {a, b}
-    insertEdge(db, 'c', 'd'); // DAG tail: {c}, {d}
-    const result = findStronglyConnectedComponents(db);
-    const allNodes = result.flat().sort();
-    expect(allNodes).toEqual(['a', 'b', 'c', 'd'].sort());
-    db.close();
-  });
-
-  it('returns each node in exactly one SCC', () => {
-    const db = makeTempDb();
-    ['a', 'b', 'c'].forEach(n => insertNode(db, n));
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    insertEdge(db, 'c', 'a');
-    const result = findStronglyConnectedComponents(db);
-    const allNodes = result.flat();
-    const unique = new Set(allNodes);
-    expect(unique.size).toBe(allNodes.length); // no duplicates
-    db.close();
-  });
-});

package/src/__tests__/graph/statistics.test.ts

@@ -1,219 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { graphDensity, clusteringCoefficient, averagePathLength, graphDiameter } from '../../graph/statistics.js';
-import Database from 'better-sqlite3';
-import { openDb } from '../../storage/db.js';
-import { join } from 'path';
-import { mkdtempSync } from 'fs';
-import { tmpdir } from 'os';
-
-function makeTempDb() {
-  const dir = mkdtempSync(join(tmpdir(), 'monograph-stats-test-'));
-  return openDb(join(dir, 'test.db'));
-}
-
-function insertNode(db: Database.Database, id: string) {
-  db.prepare(`INSERT INTO nodes (id, label, name, norm_label, is_exported) VALUES (?, 'Function', ?, ?, 0)`)
-    .run(id, id, id.toLowerCase());
-}
-
-function insertEdge(db: Database.Database, src: string, tgt: string) {
-  db.prepare(`INSERT INTO edges (id, source_id, target_id, relation, confidence, confidence_score) VALUES (?, ?, ?, 'CALLS', 'EXTRACTED', 1.0)`)
-    .run(`${src}_${tgt}`, src, tgt);
-}
-
-describe('graphDensity', () => {
-  it('returns 0 for empty graph', () => {
-    const db = makeTempDb();
-    expect(graphDensity(db)).toBe(0);
-    db.close();
-  });
-
-  it('returns 0 for graph with only nodes and no edges', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    expect(graphDensity(db)).toBe(0);
-    db.close();
-  });
-
-  it('returns 1 for complete directed graph of 3 nodes (6 edges)', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'a', 'c');
-    insertEdge(db, 'b', 'a');
-    insertEdge(db, 'b', 'c');
-    insertEdge(db, 'c', 'a');
-    insertEdge(db, 'c', 'b');
-    expect(graphDensity(db)).toBeCloseTo(1, 5);
-    db.close();
-  });
-
-  it('returns value between 0 and 1 for partial graph', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    const d = graphDensity(db);
-    expect(d).toBeGreaterThan(0);
-    expect(d).toBeLessThan(1);
-    db.close();
-  });
-
-  it('returns a number', () => {
-    const db = makeTempDb();
-    insertNode(db, 'x');
-    expect(typeof graphDensity(db)).toBe('number');
-    db.close();
-  });
-});
-
-describe('clusteringCoefficient', () => {
-  it('returns 0 for empty graph', () => {
-    const db = makeTempDb();
-    expect(clusteringCoefficient(db)).toBe(0);
-    db.close();
-  });
-
-  it('returns 0 for a chain graph (no triangles)', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    const cc = clusteringCoefficient(db);
-    expect(cc).toBeGreaterThanOrEqual(0);
-    expect(cc).toBeLessThanOrEqual(1);
-    db.close();
-  });
-
-  it('returns 1 for fully connected triangle', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    // bidirectional triangle
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'a');
-    insertEdge(db, 'b', 'c');
-    insertEdge(db, 'c', 'b');
-    insertEdge(db, 'a', 'c');
-    insertEdge(db, 'c', 'a');
-    const cc = clusteringCoefficient(db);
-    expect(cc).toBeGreaterThanOrEqual(0);
-    expect(cc).toBeLessThanOrEqual(1);
-    db.close();
-  });
-
-  it('returns a number between 0 and 1', () => {
-    const db = makeTempDb();
-    insertNode(db, 'x');
-    insertNode(db, 'y');
-    insertEdge(db, 'x', 'y');
-    const cc = clusteringCoefficient(db);
-    expect(typeof cc).toBe('number');
-    expect(cc).toBeGreaterThanOrEqual(0);
-    expect(cc).toBeLessThanOrEqual(1);
-    db.close();
-  });
-});
-
-describe('averagePathLength', () => {
-  it('returns 0 for empty graph', () => {
-    const db = makeTempDb();
-    expect(averagePathLength(db)).toBe(0);
-    db.close();
-  });
-
-  it('returns 0 for single node', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    expect(averagePathLength(db)).toBe(0);
-    db.close();
-  });
-
-  it('returns 1 for two directly connected nodes', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertEdge(db, 'a', 'b');
-    // a->b has path length 1; b->a unreachable
-    expect(averagePathLength(db)).toBeCloseTo(1, 5);
-    db.close();
-  });
-
-  it('returns 4/3 for a->b->c chain (a->b=1, a->c=2, b->c=1)', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    // reachable pairs: (a,b)=1, (a,c)=2, (b,c)=1 => total 4 / 3 pairs
-    const apl = averagePathLength(db);
-    expect(apl).toBeCloseTo(4 / 3, 5);
-    db.close();
-  });
-
-  it('returns a non-negative number', () => {
-    const db = makeTempDb();
-    insertNode(db, 'x');
-    insertNode(db, 'y');
-    insertEdge(db, 'x', 'y');
-    expect(averagePathLength(db)).toBeGreaterThanOrEqual(0);
-    db.close();
-  });
-});
-
-describe('graphDiameter', () => {
-  it('returns 0 for empty graph', () => {
-    const db = makeTempDb();
-    expect(graphDiameter(db)).toBe(0);
-    db.close();
-  });
-
-  it('returns 0 for single node', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    expect(graphDiameter(db)).toBe(0);
-    db.close();
-  });
-
-  it('returns 1 for two directly connected nodes', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertEdge(db, 'a', 'b');
-    expect(graphDiameter(db)).toBe(1);
-    db.close();
-  });
-
-  it('returns 2 for a->b->c chain', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    expect(graphDiameter(db)).toBe(2);
-    db.close();
-  });
-
-  it('returns 3 for a->b->c->d chain', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertNode(db, 'd');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    insertEdge(db, 'c', 'd');
-    expect(graphDiameter(db)).toBe(3);
-    db.close();
-  });
-});

package/src/__tests__/graph/subgraph.test.ts

@@ -1,127 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractInducedSubgraph } from '../../graph/subgraph.js';
-import { openDb } from '../../storage/db.js';
-import Database from 'better-sqlite3';
-import { join } from 'path';
-import { mkdtempSync } from 'fs';
-import { tmpdir } from 'os';
-
-function makeTempDb() {
-  const dir = mkdtempSync(join(tmpdir(), 'monograph-subgraph-test-'));
-  return openDb(join(dir, 'test.db'));
-}
-
-function insertNode(db: Database.Database, id: string, name = id) {
-  db.prepare(`INSERT INTO nodes (id, label, name, norm_label, is_exported) VALUES (?, 'Function', ?, ?, 0)`)
-    .run(id, name, name.toLowerCase());
-}
-
-function insertEdge(db: Database.Database, src: string, tgt: string, relation = 'CALLS') {
-  db.prepare(`INSERT INTO edges (id, source_id, target_id, relation, confidence, confidence_score) VALUES (?, ?, ?, ?, 'EXTRACTED', 1.0)`)
-    .run(`${src}_${tgt}`, src, tgt, relation);
-}
-
-describe('extractInducedSubgraph', () => {
-  it('returns empty nodes and edges for empty node set', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertEdge(db, 'a', 'b');
-    const result = extractInducedSubgraph(db, []);
-    expect(result.nodes).toHaveLength(0);
-    expect(result.edges).toHaveLength(0);
-    db.close();
-  });
-
-  it('returns only specified nodes', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    const result = extractInducedSubgraph(db, ['a', 'b']);
-    expect(result.nodes).toHaveLength(2);
-    expect(result.nodes.map(n => n.id).sort()).toEqual(['a', 'b']);
-    db.close();
-  });
-
-  it('returns only edges where both source and target are in the node set', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'b', 'c');
-    const result = extractInducedSubgraph(db, ['a', 'b']);
-    // a->b is in subgraph; b->c is NOT (c excluded)
-    expect(result.edges).toHaveLength(1);
-    expect(result.edges[0].sourceId).toBe('a');
-    expect(result.edges[0].targetId).toBe('b');
-    db.close();
-  });
-
-  it('excludes edges crossing the subgraph boundary', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertNode(db, 'c');
-    insertEdge(db, 'a', 'b');
-    insertEdge(db, 'a', 'c');
-    const result = extractInducedSubgraph(db, ['a', 'b']);
-    expect(result.edges).toHaveLength(1);
-    db.close();
-  });
-
-  it('handles a single node with no edges', () => {
-    const db = makeTempDb();
-    insertNode(db, 'solo');
-    const result = extractInducedSubgraph(db, ['solo']);
-    expect(result.nodes).toHaveLength(1);
-    expect(result.edges).toHaveLength(0);
-    db.close();
-  });
-
-  it('ignores node ids not in the database', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    const result = extractInducedSubgraph(db, ['a', 'ghost']);
-    expect(result.nodes).toHaveLength(1);
-    expect(result.nodes[0].id).toBe('a');
-    db.close();
-  });
-
-  it('returns all edges within the full node set', () => {
-    const db = makeTempDb();
-    insertNode(db, 'x');
-    insertNode(db, 'y');
-    insertNode(db, 'z');
-    insertEdge(db, 'x', 'y');
-    insertEdge(db, 'y', 'z');
-    insertEdge(db, 'x', 'z');
-    const result = extractInducedSubgraph(db, ['x', 'y', 'z']);
-    expect(result.nodes).toHaveLength(3);
-    expect(result.edges).toHaveLength(3);
-    db.close();
-  });
-
-  it('returns MonographNode and MonographEdge shaped objects', () => {
-    const db = makeTempDb();
-    insertNode(db, 'a');
-    insertNode(db, 'b');
-    insertEdge(db, 'a', 'b', 'IMPORTS');
-    const result = extractInducedSubgraph(db, ['a', 'b']);
-    const node = result.nodes[0];
-    expect(node).toHaveProperty('id');
-    expect(node).toHaveProperty('label');
-    expect(node).toHaveProperty('name');
-    expect(node).toHaveProperty('isExported');
-    const edge = result.edges[0];
-    expect(edge).toHaveProperty('id');
-    expect(edge).toHaveProperty('sourceId');
-    expect(edge).toHaveProperty('targetId');
-    expect(edge).toHaveProperty('relation');
-    expect(edge.relation).toBe('IMPORTS');
-    db.close();
-  });
-});