117 lines
3.7 KiB
TypeScript
117 lines
3.7 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, it } from 'vitest';
|
|
|
|
import { IdentityDB } from '../src/core/identity-db';
|
|
|
|
async function seedMemoryGraph(db: IdentityDB): Promise<void> {
|
|
await db.addFact({
|
|
statement: 'I have worked with TypeScript since 2025.',
|
|
topics: [
|
|
{ name: 'I', category: 'entity', granularity: 'concrete', role: 'subject' },
|
|
{ name: 'TypeScript', category: 'entity', granularity: 'concrete', role: 'object' },
|
|
{ name: '2025', category: 'temporal', granularity: 'concrete', role: 'time' },
|
|
],
|
|
});
|
|
|
|
await db.addFact({
|
|
statement: 'TypeScript is a programming language.',
|
|
topics: [
|
|
{ name: 'TypeScript', category: 'entity', granularity: 'concrete', role: 'subject' },
|
|
{ name: 'programming language', category: 'concept', granularity: 'abstract', role: 'classification' },
|
|
],
|
|
});
|
|
|
|
await db.linkTopics({
|
|
parentName: 'software technology',
|
|
childName: 'programming language',
|
|
});
|
|
|
|
await db.linkTopics({
|
|
parentName: 'programming language',
|
|
childName: 'TypeScript',
|
|
});
|
|
}
|
|
|
|
describe('IdentityDB queries', () => {
|
|
let db: IdentityDB;
|
|
|
|
beforeEach(async () => {
|
|
db = await IdentityDB.connect({ client: 'sqlite', filename: ':memory:' });
|
|
await db.initialize();
|
|
await seedMemoryGraph(db);
|
|
});
|
|
|
|
afterEach(async () => {
|
|
await db.close();
|
|
});
|
|
|
|
it('gets a topic with its facts', async () => {
|
|
const topic = await db.getTopicByName('TypeScript', { includeFacts: true });
|
|
|
|
expect(topic).not.toBeNull();
|
|
expect(topic?.name).toBe('TypeScript');
|
|
expect(topic?.facts).toHaveLength(2);
|
|
expect(topic?.facts.map((fact) => fact.statement)).toEqual([
|
|
'I have worked with TypeScript since 2025.',
|
|
'TypeScript is a programming language.',
|
|
]);
|
|
});
|
|
|
|
it('gets only the facts linked to another topic', async () => {
|
|
const facts = await db.getTopicFactsLinkedTo('TypeScript', '2025');
|
|
|
|
expect(facts).toHaveLength(1);
|
|
expect(facts[0]?.statement).toBe('I have worked with TypeScript since 2025.');
|
|
});
|
|
|
|
it('lists topics without expanding facts', async () => {
|
|
const topics = await db.listTopics({ includeFacts: false });
|
|
|
|
expect(topics.map((topic) => topic.name)).toEqual([
|
|
'2025',
|
|
'I',
|
|
'programming language',
|
|
'software technology',
|
|
'TypeScript',
|
|
]);
|
|
expect('facts' in topics[0]!).toBe(false);
|
|
});
|
|
|
|
it('finds connected topics with shared fact counts', async () => {
|
|
const connectedTopics = await db.findConnectedTopics('TypeScript');
|
|
|
|
expect(connectedTopics).toEqual([
|
|
expect.objectContaining({ name: '2025', sharedFactCount: 1 }),
|
|
expect.objectContaining({ name: 'I', sharedFactCount: 1 }),
|
|
expect.objectContaining({ name: 'programming language', sharedFactCount: 1 }),
|
|
]);
|
|
});
|
|
|
|
it('finds facts that connect all requested topics', async () => {
|
|
const facts = await db.findFactsConnectingTopics(['I', 'TypeScript', '2025']);
|
|
|
|
expect(facts).toHaveLength(1);
|
|
expect(facts[0]?.statement).toBe('I have worked with TypeScript since 2025.');
|
|
});
|
|
|
|
it('lists direct child topics for a parent topic', async () => {
|
|
const children = await db.getTopicChildren('programming language');
|
|
|
|
expect(children.map((topic) => topic.name)).toEqual(['TypeScript']);
|
|
});
|
|
|
|
it('lists direct parent topics for a child topic', async () => {
|
|
const parents = await db.getTopicParents('TypeScript');
|
|
|
|
expect(parents.map((topic) => topic.name)).toEqual(['programming language']);
|
|
});
|
|
|
|
it('returns lineage from nearest parent outward', async () => {
|
|
const lineage = await db.getTopicLineage('TypeScript');
|
|
|
|
expect(lineage.map((topic) => topic.name)).toEqual([
|
|
'programming language',
|
|
'software technology',
|
|
]);
|
|
});
|
|
});
|