0958d8d2cd
- Fixed sync script disconnecting Mongoose (prevents production errors)
- Created text search index (fixes search in rule-manager)
- Enhanced inst_024 with closedown protocol, added inst_061
- Added sync infrastructure: API routes, dashboard widget, auto-sync
- Fixed MemoryProxy tests MongoDB connection
- Created ADR-001 and integration tests
Result: Production stable, 52 rules synced, search working
🤖 Generated with Claude Code
Co-Authored-By: Claude <noreply@anthropic.com>
367 lines
11 KiB
JavaScript
367 lines
11 KiB
JavaScript
/**
|
|
* Unit Tests - MemoryProxy Service
|
|
* Tests memory-backed governance rule persistence and retrieval
|
|
*/
|
|
|
|
const { MemoryProxyService } = require('../../src/services/MemoryProxy.service');
|
|
const mongoose = require('mongoose');
|
|
const fs = require('fs').promises;
|
|
const path = require('path');
|
|
|
|
// Increase timeout for slow filesystem operations
|
|
jest.setTimeout(30000);
|
|
|
|
describe('MemoryProxyService', () => {
|
|
let memoryProxy;
|
|
const testMemoryPath = path.join(__dirname, '../../.memory-test');
|
|
|
|
// Connect to MongoDB before all tests
|
|
beforeAll(async () => {
|
|
const mongoUri = process.env.MONGODB_URI || 'mongodb://localhost:27017/tractatus_test';
|
|
await mongoose.connect(mongoUri);
|
|
});
|
|
|
|
// Disconnect from MongoDB after all tests
|
|
afterAll(async () => {
|
|
await mongoose.disconnect();
|
|
});
|
|
|
|
const testRules = [
|
|
{
|
|
id: 'inst_001',
|
|
text: 'Test rule 1',
|
|
quadrant: 'STRATEGIC',
|
|
persistence: 'HIGH',
|
|
active: true
|
|
},
|
|
{
|
|
id: 'inst_002',
|
|
text: 'Test rule 2',
|
|
quadrant: 'OPERATIONAL',
|
|
persistence: 'HIGH',
|
|
active: true
|
|
},
|
|
{
|
|
id: 'inst_003',
|
|
text: 'Test rule 3',
|
|
quadrant: 'SYSTEM',
|
|
persistence: 'MEDIUM',
|
|
active: true
|
|
}
|
|
];
|
|
|
|
beforeEach(async () => {
|
|
memoryProxy = new MemoryProxyService({
|
|
memoryBasePath: testMemoryPath,
|
|
cacheEnabled: true,
|
|
cacheTTL: 1000 // 1 second for testing
|
|
});
|
|
|
|
await memoryProxy.initialize();
|
|
});
|
|
|
|
afterEach(async () => {
|
|
// Cleanup test directory
|
|
try {
|
|
await fs.rm(testMemoryPath, { recursive: true, force: true });
|
|
} catch (error) {
|
|
// Ignore cleanup errors
|
|
}
|
|
});
|
|
|
|
describe('Initialization', () => {
|
|
test('should create memory directory structure', async () => {
|
|
const governanceDir = path.join(testMemoryPath, 'governance');
|
|
const sessionsDir = path.join(testMemoryPath, 'sessions');
|
|
const auditDir = path.join(testMemoryPath, 'audit');
|
|
|
|
await expect(fs.access(governanceDir)).resolves.toBeUndefined();
|
|
await expect(fs.access(sessionsDir)).resolves.toBeUndefined();
|
|
await expect(fs.access(auditDir)).resolves.toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe('persistGovernanceRules', () => {
|
|
test('should persist rules successfully', async () => {
|
|
const result = await memoryProxy.persistGovernanceRules(testRules);
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.rulesStored).toBe(3);
|
|
expect(result.duration).toBeGreaterThan(0);
|
|
expect(result.stats).toBeDefined();
|
|
expect(result.stats.by_quadrant).toBeDefined();
|
|
expect(result.stats.by_persistence).toBeDefined();
|
|
});
|
|
|
|
test('should create rules file on filesystem', async () => {
|
|
await memoryProxy.persistGovernanceRules(testRules);
|
|
|
|
const filePath = path.join(testMemoryPath, 'governance/tractatus-rules-v1.json');
|
|
const data = await fs.readFile(filePath, 'utf8');
|
|
const parsed = JSON.parse(data);
|
|
|
|
expect(parsed.version).toBe('1.0');
|
|
expect(parsed.total_rules).toBe(3);
|
|
expect(parsed.rules).toHaveLength(3);
|
|
expect(parsed.updated_at).toBeDefined();
|
|
});
|
|
|
|
test('should validate rule format', async () => {
|
|
const invalidRules = [
|
|
{ id: 'test', text: 'missing required fields' }
|
|
];
|
|
|
|
await expect(memoryProxy.persistGovernanceRules(invalidRules))
|
|
.rejects
|
|
.toThrow('Invalid rule format');
|
|
});
|
|
|
|
test('should reject empty rules array', async () => {
|
|
await expect(memoryProxy.persistGovernanceRules([]))
|
|
.rejects
|
|
.toThrow('Cannot persist empty rules array');
|
|
});
|
|
|
|
test('should reject non-array input', async () => {
|
|
await expect(memoryProxy.persistGovernanceRules({ invalid: 'input' }))
|
|
.rejects
|
|
.toThrow('Rules must be an array');
|
|
});
|
|
|
|
test('should update cache after persisting', async () => {
|
|
await memoryProxy.persistGovernanceRules(testRules);
|
|
|
|
const stats = memoryProxy.getCacheStats();
|
|
expect(stats.entries).toBe(1);
|
|
expect(stats.keys).toContain('governance-rules');
|
|
});
|
|
});
|
|
|
|
describe('loadGovernanceRules', () => {
|
|
beforeEach(async () => {
|
|
await memoryProxy.persistGovernanceRules(testRules);
|
|
});
|
|
|
|
test('should load rules successfully', async () => {
|
|
const rules = await memoryProxy.loadGovernanceRules();
|
|
|
|
expect(rules).toHaveLength(3);
|
|
expect(rules[0].id).toBe('inst_001');
|
|
expect(rules[1].id).toBe('inst_002');
|
|
expect(rules[2].id).toBe('inst_003');
|
|
});
|
|
|
|
test('should load from cache on second call', async () => {
|
|
// First call - from filesystem
|
|
await memoryProxy.loadGovernanceRules();
|
|
|
|
// Second call - from cache (much faster)
|
|
const startTime = Date.now();
|
|
const rules = await memoryProxy.loadGovernanceRules();
|
|
const duration = Date.now() - startTime;
|
|
|
|
expect(rules).toHaveLength(3);
|
|
expect(duration).toBeLessThan(5); // Cache should be very fast
|
|
});
|
|
|
|
test('should bypass cache when skipCache option is true', async () => {
|
|
// Load to populate cache
|
|
await memoryProxy.loadGovernanceRules();
|
|
|
|
// Clear cache
|
|
memoryProxy.clearCache();
|
|
|
|
// Load with skipCache should work
|
|
const rules = await memoryProxy.loadGovernanceRules({ skipCache: true });
|
|
expect(rules).toHaveLength(3);
|
|
});
|
|
|
|
test('should return empty array if rules file does not exist', async () => {
|
|
// Create new instance with different path
|
|
const emptyProxy = new MemoryProxyService({
|
|
memoryBasePath: path.join(testMemoryPath, 'empty')
|
|
});
|
|
await emptyProxy.initialize();
|
|
|
|
const rules = await emptyProxy.loadGovernanceRules();
|
|
expect(rules).toEqual([]);
|
|
});
|
|
|
|
test('should maintain data integrity across persist/load cycle', async () => {
|
|
const rules = await memoryProxy.loadGovernanceRules();
|
|
|
|
for (let i = 0; i < testRules.length; i++) {
|
|
expect(rules[i].id).toBe(testRules[i].id);
|
|
expect(rules[i].text).toBe(testRules[i].text);
|
|
expect(rules[i].quadrant).toBe(testRules[i].quadrant);
|
|
expect(rules[i].persistence).toBe(testRules[i].persistence);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('getRule', () => {
|
|
beforeEach(async () => {
|
|
await memoryProxy.persistGovernanceRules(testRules);
|
|
});
|
|
|
|
test('should get specific rule by ID', async () => {
|
|
const rule = await memoryProxy.getRule('inst_002');
|
|
|
|
expect(rule).toBeDefined();
|
|
expect(rule.id).toBe('inst_002');
|
|
expect(rule.text).toBe('Test rule 2');
|
|
expect(rule.quadrant).toBe('OPERATIONAL');
|
|
});
|
|
|
|
test('should return null for non-existent rule', async () => {
|
|
const rule = await memoryProxy.getRule('inst_999');
|
|
expect(rule).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('getRulesByQuadrant', () => {
|
|
beforeEach(async () => {
|
|
await memoryProxy.persistGovernanceRules(testRules);
|
|
});
|
|
|
|
test('should filter rules by quadrant', async () => {
|
|
const strategicRules = await memoryProxy.getRulesByQuadrant('STRATEGIC');
|
|
|
|
expect(strategicRules).toHaveLength(1);
|
|
expect(strategicRules[0].id).toBe('inst_001');
|
|
expect(strategicRules[0].quadrant).toBe('STRATEGIC');
|
|
});
|
|
|
|
test('should return empty array for non-existent quadrant', async () => {
|
|
const rules = await memoryProxy.getRulesByQuadrant('NONEXISTENT');
|
|
expect(rules).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('getRulesByPersistence', () => {
|
|
beforeEach(async () => {
|
|
await memoryProxy.persistGovernanceRules(testRules);
|
|
});
|
|
|
|
test('should filter rules by persistence level', async () => {
|
|
const highRules = await memoryProxy.getRulesByPersistence('HIGH');
|
|
|
|
expect(highRules).toHaveLength(2);
|
|
expect(highRules.every(r => r.persistence === 'HIGH')).toBe(true);
|
|
});
|
|
|
|
test('should return empty array for non-existent persistence level', async () => {
|
|
const rules = await memoryProxy.getRulesByPersistence('LOW');
|
|
expect(rules).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('auditDecision', () => {
|
|
test('should audit decision successfully', async () => {
|
|
const decision = {
|
|
sessionId: 'test-session-001',
|
|
action: 'blog_post_generation',
|
|
rulesChecked: ['inst_016', 'inst_017'],
|
|
violations: [],
|
|
allowed: true,
|
|
metadata: {
|
|
user: 'test-user',
|
|
timestamp: new Date().toISOString()
|
|
}
|
|
};
|
|
|
|
const result = await memoryProxy.auditDecision(decision);
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.audited).toBe(true);
|
|
expect(result.duration).toBeGreaterThanOrEqual(0); // Allow 0ms for very fast operations
|
|
expect(result.path).toContain('audit/decisions-');
|
|
});
|
|
|
|
test('should create audit log file', async () => {
|
|
const decision = {
|
|
sessionId: 'test-session-002',
|
|
action: 'test_action',
|
|
allowed: true
|
|
};
|
|
|
|
await memoryProxy.auditDecision(decision);
|
|
|
|
const today = new Date().toISOString().split('T')[0];
|
|
const auditPath = path.join(testMemoryPath, `audit/decisions-${today}.jsonl`);
|
|
|
|
const data = await fs.readFile(auditPath, 'utf8');
|
|
const lines = data.trim().split('\n');
|
|
const parsed = JSON.parse(lines[0]);
|
|
|
|
expect(parsed.sessionId).toBe('test-session-002');
|
|
expect(parsed.action).toBe('test_action');
|
|
expect(parsed.allowed).toBe(true);
|
|
expect(parsed.timestamp).toBeDefined();
|
|
});
|
|
|
|
test('should append multiple audit entries to same file', async () => {
|
|
const decision1 = { sessionId: 'session-1', action: 'action-1', allowed: true };
|
|
const decision2 = { sessionId: 'session-2', action: 'action-2', allowed: false };
|
|
|
|
await memoryProxy.auditDecision(decision1);
|
|
await memoryProxy.auditDecision(decision2);
|
|
|
|
const today = new Date().toISOString().split('T')[0];
|
|
const auditPath = path.join(testMemoryPath, `audit/decisions-${today}.jsonl`);
|
|
|
|
const data = await fs.readFile(auditPath, 'utf8');
|
|
const lines = data.trim().split('\n');
|
|
|
|
expect(lines).toHaveLength(2);
|
|
});
|
|
|
|
test('should reject decision without required fields', async () => {
|
|
const invalidDecision = { sessionId: 'test', /* missing action */ };
|
|
|
|
await expect(memoryProxy.auditDecision(invalidDecision))
|
|
.rejects
|
|
.toThrow('Decision must include sessionId and action');
|
|
});
|
|
});
|
|
|
|
describe('Cache Management', () => {
|
|
test('should clear cache', async () => {
|
|
await memoryProxy.persistGovernanceRules(testRules);
|
|
|
|
expect(memoryProxy.getCacheStats().entries).toBe(1);
|
|
|
|
memoryProxy.clearCache();
|
|
|
|
expect(memoryProxy.getCacheStats().entries).toBe(0);
|
|
});
|
|
|
|
test('should expire cache after TTL', async () => {
|
|
// Create proxy with 100ms TTL
|
|
const shortTTLProxy = new MemoryProxyService({
|
|
memoryBasePath: testMemoryPath,
|
|
cacheEnabled: true,
|
|
cacheTTL: 100
|
|
});
|
|
await shortTTLProxy.initialize();
|
|
|
|
await shortTTLProxy.persistGovernanceRules(testRules);
|
|
|
|
// Wait for cache to expire
|
|
await new Promise(resolve => setTimeout(resolve, 150));
|
|
|
|
// Should reload from filesystem (cache expired)
|
|
const rules = await shortTTLProxy.loadGovernanceRules();
|
|
expect(rules).toHaveLength(3);
|
|
});
|
|
|
|
test('should get cache statistics', () => {
|
|
const stats = memoryProxy.getCacheStats();
|
|
|
|
expect(stats.enabled).toBe(true);
|
|
expect(stats.ttl).toBe(1000);
|
|
expect(stats.entries).toBeGreaterThanOrEqual(0);
|
|
expect(stats.keys).toBeDefined();
|
|
});
|
|
});
|
|
});
|