David Snelling
630661b589
BREAKING API CHANGES IN v5.1.0: 1. VFS now a property (brain.vfs) not method (brain.vfs()) 2. VFS auto-initializes during brain.init() - no separate vfs.init() needed 3. Root directory (/) created automatically during brain.init() 4. Stricter UUID validation (32 hex chars required) 5. VFS readFile() returns Buffer (use .toString() for string) TEST FIXES (106 tests fixed, 86% → 96.7% pass rate): - Fixed brain.vfs() → brain.vfs in 17 test files - Updated VFS initialization tests for auto-init behavior - Fixed type-filtering test to account for VFS root directory - Fixed UUID validation tests to use valid UUID format - Updated VFS readFile expectations (Buffer → string conversion) FILES UPDATED (19 test files): - tests/unit/brainy-core.unit.test.ts (UUID validation) - tests/unit/type-filtering.unit.test.ts (VFS root count) - tests/unit/workshop-vfs-diagnostic.test.ts (VFS API) - tests/vfs/vfs-initialization.unit.test.ts (auto-init behavior) - tests/vfs/vfs.unit.test.ts (VFS API) - tests/vfs/vfs-bug-fixes.unit.test.ts (VFS API) - tests/integration/* (VFS API changes, 7 files) - tests/manual/* (VFS API changes, 5 files) TEST RESULTS: - Before: 906/1051 passing (86%), 120 failures - After: 1016/1051 passing (96.7%), 14 failures - Critical systems: VFS (✓ ALL PASS), COW (✓ ALL PASS), Batch Ops (✓ 25/26) Remaining 14 failures are edge cases (UUID validation) - will fix in patch.
336 lines
9.7 KiB
TypeScript
336 lines
9.7 KiB
TypeScript
/**
|
|
* Entity Confidence & Weight + Result Flattening Tests
|
|
*
|
|
* Tests Phase 2 & 3 of the API Entity Return Audit:
|
|
* - Entity interface exposes confidence and weight
|
|
* - Result interface flattens entity fields for convenience
|
|
* - Backward compatibility preserved
|
|
*/
|
|
|
|
import { describe, it, expect, beforeEach } from 'vitest'
|
|
import { Brainy } from '../../src/brainy.js'
|
|
import { NounType } from '../../src/types/graphTypes.js'
|
|
|
|
describe('Entity Confidence & Weight Exposure', () => {
|
|
let brain: Brainy
|
|
|
|
beforeEach(async () => {
|
|
brain = new Brainy({ storage: { type: 'memory' } })
|
|
await brain.init()
|
|
})
|
|
|
|
describe('Entity interface', () => {
|
|
it('should expose confidence when adding entity with confidence', async () => {
|
|
const id = await brain.add({
|
|
data: 'Machine learning model',
|
|
type: NounType.Concept,
|
|
confidence: 0.92
|
|
})
|
|
|
|
const entity = await brain.get(id)
|
|
expect(entity).toBeTruthy()
|
|
expect(entity!.confidence).toBe(0.92)
|
|
})
|
|
|
|
it('should expose weight when adding entity with weight', async () => {
|
|
const id = await brain.add({
|
|
data: 'Critical system component',
|
|
type: NounType.Thing,
|
|
weight: 0.85
|
|
})
|
|
|
|
const entity = await brain.get(id)
|
|
expect(entity).toBeTruthy()
|
|
expect(entity!.weight).toBe(0.85)
|
|
})
|
|
|
|
it('should expose both confidence and weight together', async () => {
|
|
const id = await brain.add({
|
|
data: 'High-priority AI concept',
|
|
type: NounType.Concept,
|
|
confidence: 0.88,
|
|
weight: 0.95
|
|
})
|
|
|
|
const entity = await brain.get(id)
|
|
expect(entity).toBeTruthy()
|
|
expect(entity!.confidence).toBe(0.88)
|
|
expect(entity!.weight).toBe(0.95)
|
|
})
|
|
|
|
it('should have undefined confidence/weight when not provided', async () => {
|
|
const id = await brain.add({
|
|
data: 'Normal entity',
|
|
type: NounType.Thing
|
|
})
|
|
|
|
const entity = await brain.get(id)
|
|
expect(entity).toBeTruthy()
|
|
expect(entity!.confidence).toBeUndefined()
|
|
expect(entity!.weight).toBeUndefined()
|
|
})
|
|
|
|
it('should preserve confidence/weight after update', async () => {
|
|
const id = await brain.add({
|
|
data: 'Original data',
|
|
type: NounType.Thing,
|
|
confidence: 0.75,
|
|
weight: 0.65
|
|
})
|
|
|
|
await brain.update({
|
|
id,
|
|
data: 'Updated data'
|
|
})
|
|
|
|
const entity = await brain.get(id)
|
|
expect(entity).toBeTruthy()
|
|
expect(entity!.confidence).toBe(0.75)
|
|
expect(entity!.weight).toBe(0.65)
|
|
})
|
|
|
|
it('should allow updating confidence with other fields', async () => {
|
|
const id = await brain.add({
|
|
data: 'Entity with confidence',
|
|
type: NounType.Concept,
|
|
confidence: 0.70,
|
|
metadata: { status: 'draft' }
|
|
})
|
|
|
|
await brain.update({
|
|
id,
|
|
metadata: { status: 'reviewed' },
|
|
confidence: 0.90
|
|
})
|
|
|
|
const entity = await brain.get(id)
|
|
expect(entity).toBeTruthy()
|
|
expect(entity!.confidence).toBe(0.90)
|
|
expect(entity!.metadata).toEqual({ status: 'reviewed' })
|
|
})
|
|
|
|
it('should allow updating weight with other fields', async () => {
|
|
const id = await brain.add({
|
|
data: 'Entity with weight',
|
|
type: NounType.Thing,
|
|
weight: 0.50,
|
|
metadata: { priority: 'low' }
|
|
})
|
|
|
|
await brain.update({
|
|
id,
|
|
metadata: { priority: 'high' },
|
|
weight: 0.80
|
|
})
|
|
|
|
const entity = await brain.get(id)
|
|
expect(entity).toBeTruthy()
|
|
expect(entity!.weight).toBe(0.80)
|
|
expect(entity!.metadata).toEqual({ priority: 'high' })
|
|
})
|
|
})
|
|
|
|
describe('Result interface - Flattened fields', () => {
|
|
it('should flatten entity fields to Result top level', async () => {
|
|
const id = await brain.add({
|
|
data: 'Test entity',
|
|
type: NounType.Concept,
|
|
metadata: { name: 'Test', category: 'Research' },
|
|
confidence: 0.85,
|
|
weight: 0.75
|
|
})
|
|
|
|
const results = await brain.find({ query: 'test' })
|
|
expect(results.length).toBeGreaterThan(0)
|
|
|
|
const result = results[0]
|
|
|
|
// Check flattened fields at top level
|
|
expect(result.type).toBe(NounType.Concept)
|
|
expect(result.metadata).toEqual({ name: 'Test', category: 'Research' })
|
|
expect(result.data).toBe('Test entity')
|
|
expect(result.confidence).toBe(0.85)
|
|
expect(result.weight).toBe(0.75)
|
|
})
|
|
|
|
it('should preserve full entity in Result.entity', async () => {
|
|
const id = await brain.add({
|
|
data: 'Preserved entity',
|
|
type: NounType.Thing,
|
|
metadata: { status: 'active' },
|
|
confidence: 0.92,
|
|
weight: 0.88
|
|
})
|
|
|
|
const results = await brain.find({ query: 'preserved' })
|
|
expect(results.length).toBeGreaterThan(0)
|
|
|
|
const result = results[0]
|
|
|
|
// Check nested entity is preserved
|
|
expect(result.entity).toBeTruthy()
|
|
expect(result.entity.id).toBe(id)
|
|
expect(result.entity.type).toBe(NounType.Thing)
|
|
expect(result.entity.metadata).toEqual({ status: 'active' })
|
|
expect(result.entity.data).toBe('Preserved entity')
|
|
expect(result.entity.confidence).toBe(0.92)
|
|
expect(result.entity.weight).toBe(0.88)
|
|
})
|
|
|
|
it('should match flattened fields with entity fields', async () => {
|
|
await brain.add({
|
|
data: 'Consistency check',
|
|
type: NounType.Person,
|
|
metadata: { role: 'Engineer' },
|
|
confidence: 0.80,
|
|
weight: 0.70
|
|
})
|
|
|
|
const results = await brain.find({ query: 'consistency' })
|
|
expect(results.length).toBeGreaterThan(0)
|
|
|
|
const result = results[0]
|
|
|
|
// Flattened fields should match entity fields
|
|
expect(result.type).toBe(result.entity.type)
|
|
expect(result.metadata).toEqual(result.entity.metadata)
|
|
expect(result.data).toBe(result.entity.data)
|
|
expect(result.confidence).toBe(result.entity.confidence)
|
|
expect(result.weight).toBe(result.entity.weight)
|
|
})
|
|
|
|
it('should have undefined flattened fields when entity fields are undefined', async () => {
|
|
await brain.add({
|
|
data: 'Minimal entity',
|
|
type: NounType.Thing
|
|
})
|
|
|
|
const results = await brain.find({ query: 'minimal' })
|
|
expect(results.length).toBeGreaterThan(0)
|
|
|
|
const result = results[0]
|
|
|
|
expect(result.confidence).toBeUndefined()
|
|
expect(result.weight).toBeUndefined()
|
|
expect(result.entity.confidence).toBeUndefined()
|
|
expect(result.entity.weight).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe('Backward compatibility', () => {
|
|
it('should still work with existing code accessing result.entity.metadata', async () => {
|
|
await brain.add({
|
|
data: 'Backward compat test',
|
|
type: NounType.Concept,
|
|
metadata: { version: '1.0' }
|
|
})
|
|
|
|
const results = await brain.find({ query: 'backward' })
|
|
expect(results.length).toBeGreaterThan(0)
|
|
|
|
// Old code pattern still works
|
|
const oldWay = results[0].entity.metadata
|
|
expect(oldWay).toEqual({ version: '1.0' })
|
|
|
|
// New code pattern also works
|
|
const newWay = results[0].metadata
|
|
expect(newWay).toEqual({ version: '1.0' })
|
|
})
|
|
|
|
it('should work with metadata-only queries', async () => {
|
|
await brain.add({
|
|
data: 'Metadata query test',
|
|
type: NounType.Document,
|
|
metadata: { format: 'PDF', pages: 42 },
|
|
confidence: 0.95
|
|
})
|
|
|
|
const results = await brain.find({
|
|
where: { format: 'PDF' }
|
|
})
|
|
|
|
expect(results.length).toBeGreaterThan(0)
|
|
const result = results[0]
|
|
|
|
expect(result.metadata).toEqual({ format: 'PDF', pages: 42 })
|
|
expect(result.confidence).toBe(0.95)
|
|
})
|
|
|
|
it('should work with empty queries', async () => {
|
|
await brain.add({
|
|
data: 'Empty query test',
|
|
type: NounType.Thing,
|
|
weight: 0.60
|
|
})
|
|
|
|
const results = await brain.find({ limit: 10 })
|
|
|
|
expect(results.length).toBeGreaterThan(0)
|
|
const result = results[0]
|
|
|
|
expect(result.entity).toBeTruthy()
|
|
expect(result.type).toBeDefined()
|
|
})
|
|
})
|
|
|
|
describe('similar() method', () => {
|
|
it('should return flattened results from similar()', async () => {
|
|
const id1 = await brain.add({
|
|
data: 'Neural networks',
|
|
type: NounType.Concept,
|
|
confidence: 0.90,
|
|
weight: 0.85
|
|
})
|
|
|
|
await brain.add({
|
|
data: 'Deep learning',
|
|
type: NounType.Concept,
|
|
confidence: 0.88,
|
|
weight: 0.82
|
|
})
|
|
|
|
const results = await brain.similar({ to: id1, limit: 5 })
|
|
|
|
// similar() delegates to find(), so should have flattened fields
|
|
for (const result of results) {
|
|
expect(result.type).toBeDefined()
|
|
expect(result.entity).toBeTruthy()
|
|
|
|
if (result.confidence !== undefined) {
|
|
expect(result.confidence).toBe(result.entity.confidence)
|
|
}
|
|
if (result.weight !== undefined) {
|
|
expect(result.weight).toBe(result.entity.weight)
|
|
}
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('VFS integration', () => {
|
|
it('should expose confidence/weight for VFS entities', async () => {
|
|
const vfs = brain.vfs
|
|
await vfs.init()
|
|
|
|
await vfs.writeFile('/test.txt', 'VFS test content')
|
|
|
|
// Get VFS entity through find()
|
|
const results = await brain.find({
|
|
where: { vfsType: 'file' }
|
|
})
|
|
|
|
if (results.length > 0) {
|
|
const result = results[0]
|
|
|
|
// VFS entities should have flattened fields
|
|
expect(result.type).toBeDefined()
|
|
expect(result.metadata).toBeDefined()
|
|
expect(result.entity).toBeTruthy()
|
|
|
|
// Confidence/weight may be undefined for VFS entities,
|
|
// but the fields should exist
|
|
expect('confidence' in result).toBe(true)
|
|
expect('weight' in result).toBe(true)
|
|
}
|
|
})
|
|
})
|
|
})
|