@unrdf/kgc-runtime 26.4.2

package/test/tool-registry.test.mjs

@@ -0,0 +1,341 @@
+/**
+ * @file Tool Registry Tests
+ * @description Tests for ToolRegistry class functionality
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ToolRegistry, createRegistry } from '../src/tool-registry.mjs';
+import { z } from 'zod';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+describe('ToolRegistry', () => {
+  let registry;
+
+  beforeEach(() => {
+    registry = new ToolRegistry();
+  });
+
+  describe('Tool Registration', () => {
+    it('should register a tool with valid manifest', () => {
+      const manifest = {
+        name: 'TestTool',
+        version: '1.0.0',
+        description: 'Test tool',
+        schema_in: z.object({ input: z.string() }),
+        schema_out: z.object({ output: z.string() }),
+        capabilities: ['test'],
+      };
+
+      registry.registerTool(manifest);
+      const tool = registry.getTool('TestTool');
+
+      expect(tool).toBeDefined();
+      expect(tool.name).toBe('TestTool');
+      expect(tool.version).toBe('1.0.0');
+    });
+
+    it('should reject invalid manifest', () => {
+      const invalidManifest = {
+        name: 'Invalid',
+        // Missing required fields
+      };
+
+      expect(() => registry.registerTool(invalidManifest)).toThrow();
+    });
+
+    it('should store multiple versions of same tool', () => {
+      const v1 = {
+        name: 'Tool',
+        version: '1.0.0',
+        schema_in: z.object({}),
+        schema_out: z.object({}),
+        capabilities: [],
+      };
+
+      const v2 = {
+        name: 'Tool',
+        version: '2.0.0',
+        schema_in: z.object({}),
+        schema_out: z.object({}),
+        capabilities: [],
+      };
+
+      registry.registerTool(v1);
+      registry.registerTool(v2);
+
+      expect(registry.getToolVersion('Tool', '1.0.0')).toBeDefined();
+      expect(registry.getToolVersion('Tool', '2.0.0')).toBeDefined();
+      expect(registry.getTool('Tool').version).toBe('2.0.0'); // Latest
+    });
+  });
+
+  describe('Schema Conversion', () => {
+    it('should convert object schema definition to Zod', () => {
+      const manifest = {
+        name: 'Read',
+        version: '1.0.0',
+        schema_in: {
+          type: 'object',
+          properties: {
+            path: { type: 'string' },
+            encoding: { type: 'string' },
+          },
+          required: ['path'],
+        },
+        schema_out: {
+          type: 'object',
+          properties: {
+            content: { type: 'string' },
+          },
+          required: ['content'],
+        },
+        capabilities: ['file-read'],
+      };
+
+      registry.registerTool(manifest);
+      const tool = registry.getTool('Read');
+
+      // Test that schemas work
+      expect(tool.schema_in.parse({ path: '/test' })).toBeDefined();
+      expect(() => tool.schema_in.parse({})).toThrow(); // Missing required field
+    });
+
+    it('should handle nested object schemas', () => {
+      const manifest = {
+        name: 'Complex',
+        version: '1.0.0',
+        schema_in: {
+          type: 'object',
+          properties: {
+            config: {
+              type: 'object',
+              properties: {
+                timeout: { type: 'number' },
+              },
+              required: ['timeout'],
+            },
+          },
+          required: ['config'],
+        },
+        schema_out: {
+          type: 'object',
+          properties: {
+            result: { type: 'string' },
+          },
+          required: ['result'],
+        },
+        capabilities: [],
+      };
+
+      registry.registerTool(manifest);
+      const tool = registry.getTool('Complex');
+
+      expect(
+        tool.schema_in.parse({ config: { timeout: 5000 } }),
+      ).toBeDefined();
+    });
+
+    it('should handle array schemas', () => {
+      const manifest = {
+        name: 'ArrayTool',
+        version: '1.0.0',
+        schema_in: {
+          type: 'object',
+          properties: {},
+          required: [],
+        },
+        schema_out: {
+          type: 'object',
+          properties: {
+            items: {
+              type: 'array',
+              items: { type: 'string' },
+            },
+          },
+          required: ['items'],
+        },
+        capabilities: [],
+      };
+
+      registry.registerTool(manifest);
+      const tool = registry.getTool('ArrayTool');
+
+      expect(tool.schema_out.parse({ items: ['a', 'b'] })).toBeDefined();
+      expect(() => tool.schema_out.parse({ items: [1, 2] })).toThrow();
+    });
+  });
+
+  describe('Tool Queries', () => {
+    beforeEach(() => {
+      registry.registerTool({
+        name: 'Read',
+        version: '1.0.0',
+        schema_in: z.object({}),
+        schema_out: z.object({}),
+        capabilities: ['file-read', 'filesystem-access'],
+      });
+
+      registry.registerTool({
+        name: 'Write',
+        version: '1.0.0',
+        schema_in: z.object({}),
+        schema_out: z.object({}),
+        capabilities: ['file-write', 'filesystem-access'],
+      });
+
+      registry.registerTool({
+        name: 'Bash',
+        version: '1.0.0',
+        schema_in: z.object({}),
+        schema_out: z.object({}),
+        capabilities: ['command-execution'],
+      });
+    });
+
+    it('should get all tools', () => {
+      const tools = registry.getAllTools();
+      expect(tools).toHaveLength(3);
+      expect(tools.map((t) => t.name).sort()).toEqual([
+        'Bash',
+        'Read',
+        'Write',
+      ]);
+    });
+
+    it('should query tools by capability', () => {
+      const fileTools = registry.getToolsByCapability('filesystem-access');
+      expect(fileTools).toHaveLength(2);
+      expect(fileTools.map((t) => t.name).sort()).toEqual([
+        'Read',
+        'Write',
+      ]);
+    });
+
+    it('should check if tool has capability', () => {
+      expect(registry.hasCapability('Read', 'file-read')).toBe(true);
+      expect(registry.hasCapability('Read', 'file-write')).toBe(false);
+      expect(registry.hasCapability('NonExistent', 'any')).toBe(false);
+    });
+  });
+
+  describe('Output Validation', () => {
+    beforeEach(() => {
+      registry.registerTool({
+        name: 'TestTool',
+        version: '1.0.0',
+        schema_in: z.object({}),
+        schema_out: z.object({
+          result: z.string(),
+          count: z.number(),
+        }),
+        capabilities: [],
+      });
+    });
+
+    it('should validate correct output', () => {
+      const output = { result: 'success', count: 42 };
+      expect(registry.validateOutput('TestTool', output)).toBe(true);
+    });
+
+    it('should reject invalid output', () => {
+      const output = { result: 'success' }; // Missing count
+      expect(registry.validateOutput('TestTool', output)).toBe(false);
+    });
+
+    it('should throw on non-existent tool', () => {
+      expect(() =>
+        registry.validateOutput('NonExistent', {}),
+      ).toThrow();
+    });
+  });
+
+  describe('Registry Statistics', () => {
+    beforeEach(() => {
+      registry.registerTool({
+        name: 'Read',
+        version: '1.0.0',
+        schema_in: z.object({}),
+        schema_out: z.object({}),
+        capabilities: ['file-read', 'filesystem-access'],
+      });
+
+      registry.registerTool({
+        name: 'Write',
+        version: '1.0.0',
+        schema_in: z.object({}),
+        schema_out: z.object({}),
+        capabilities: ['file-write', 'filesystem-access'],
+      });
+    });
+
+    it('should return registry statistics', () => {
+      const stats = registry.getStats();
+
+      expect(stats.total_tools).toBe(2);
+      expect(stats.unique_capabilities).toBe(3);
+      expect(stats.capabilities.sort()).toEqual([
+        'file-read',
+        'file-write',
+        'filesystem-access',
+      ]);
+    });
+  });
+
+  describe('Loading from File', () => {
+    it('should load tools from registry file', () => {
+      const registryPath = join(
+        __dirname,
+        '../../../var/kgc/tool-registry.json',
+      );
+      const fileRegistry = new ToolRegistry({ registryPath });
+
+      const tools = fileRegistry.getAllTools();
+      expect(tools.length).toBeGreaterThan(0);
+
+      // Check built-in tools
+      const bashTool = fileRegistry.getTool('Bash');
+      expect(bashTool).toBeDefined();
+      expect(bashTool.name).toBe('Bash');
+      expect(bashTool.capabilities).toContain('command-execution');
+
+      const readTool = fileRegistry.getTool('Read');
+      expect(readTool).toBeDefined();
+      expect(readTool.capabilities).toContain('file-read');
+    });
+
+    it('should validate loaded schemas work correctly', () => {
+      const registryPath = join(
+        __dirname,
+        '../../../var/kgc/tool-registry.json',
+      );
+      const fileRegistry = new ToolRegistry({ registryPath });
+
+      const readTool = fileRegistry.getTool('Read');
+
+      // Should accept valid input
+      const validInput = readTool.schema_in.parse({ path: '/test.txt' });
+      expect(validInput.path).toBe('/test.txt');
+
+      // Should reject invalid input
+      expect(() => readTool.schema_in.parse({})).toThrow();
+    });
+  });
+
+  describe('Factory Function', () => {
+    it('should create registry with createRegistry', () => {
+      const registryPath = join(
+        __dirname,
+        '../../../var/kgc/tool-registry.json',
+      );
+      const reg = createRegistry(registryPath);
+
+      expect(reg).toBeInstanceOf(ToolRegistry);
+      expect(reg.getAllTools().length).toBeGreaterThan(0);
+    });
+  });
+});

package/test/transaction.test.mjs

@@ -0,0 +1,189 @@
+/**
+ * @fileoverview Tests for Two-Phase Commit Transaction Manager
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TransactionManager } from '../src/transaction.mjs';
+
+describe('TransactionManager', () => {
+  let txManager;
+
+  beforeEach(() => {
+    txManager = new TransactionManager();
+  });
+
+  it('should execute two-phase commit successfully', async () => {
+    // Begin transaction
+    const tx = txManager.begin([
+      {
+        id: 'op1',
+        type: 'add_capsule',
+        data: { id: 'capsule1', content: 'test data' },
+      },
+      {
+        id: 'op2',
+        type: 'add_capsule',
+        data: { id: 'capsule2', content: 'more test data' },
+      },
+    ]);
+
+    expect(tx.status).toBe('pending');
+    expect(tx.operations).toHaveLength(2);
+
+    // Phase 1: Prepare
+    const prepareResult = await txManager.prepare(tx.id);
+
+    expect(prepareResult.success).toBe(true);
+    expect(prepareResult.errors).toHaveLength(0);
+    expect(prepareResult.undoOps).toHaveLength(2);
+
+    const updatedTx = txManager.getTransaction(tx.id);
+    expect(updatedTx.status).toBe('prepared');
+
+    // Phase 2: Commit
+    const commitResult = await txManager.commit(tx.id);
+
+    expect(commitResult.success).toBe(true);
+    expect(commitResult.receipts).toHaveLength(2);
+    expect(commitResult.errors).toHaveLength(0);
+
+    const finalTx = txManager.getTransaction(tx.id);
+    expect(finalTx.status).toBe('committed');
+
+    // Verify state updated
+    const state = txManager.getState();
+    expect(state.capsules).toBeDefined();
+    expect(state.capsules['capsule1']).toBeDefined();
+    expect(state.capsules['capsule2']).toBeDefined();
+  });
+
+  it('should rollback transaction on commit failure', async () => {
+    // Add a capsule first
+    const initialTx = txManager.begin([
+      {
+        id: 'initial',
+        type: 'add_capsule',
+        data: { id: 'existing', content: 'existing data' },
+      },
+    ]);
+
+    await txManager.prepare(initialTx.id);
+    await txManager.commit(initialTx.id);
+
+    // Create transaction that will fail during commit
+    const tx = txManager.begin([
+      {
+        id: 'op1',
+        type: 'add_capsule',
+        data: { id: 'new_capsule', content: 'new data' },
+      },
+      {
+        id: 'op2',
+        type: 'invalid_type', // This will cause failure
+        data: {},
+      },
+    ]);
+
+    const prepareResult = await txManager.prepare(tx.id);
+    expect(prepareResult.success).toBe(false);
+
+    const finalTx = txManager.getTransaction(tx.id);
+    expect(finalTx.status).toBe('aborted');
+
+    // Verify state not changed
+    const state = txManager.getState();
+    expect(state.capsules['new_capsule']).toBeUndefined();
+    expect(state.capsules['existing']).toBeDefined(); // Original still there
+  });
+
+  it('should support cascading transactions with parent hash', async () => {
+    // First transaction
+    const tx1 = txManager.begin([
+      {
+        id: 'op1',
+        type: 'add_capsule',
+        data: { id: 'capsule1', content: 'first' },
+      },
+    ]);
+
+    await txManager.prepare(tx1.id);
+    const commit1 = await txManager.commit(tx1.id);
+
+    expect(commit1.success).toBe(true);
+    expect(commit1.receipts).toHaveLength(1);
+
+    const receipt1 = commit1.receipts[0];
+    const parentHash = receipt1.hash;
+
+    // Second transaction with parent hash
+    const tx2 = txManager.begin(
+      [
+        {
+          id: 'op2',
+          type: 'add_capsule',
+          data: { id: 'capsule2', content: 'second' },
+        },
+      ],
+      parentHash
+    );
+
+    expect(tx2.parentHash).toBe(parentHash);
+
+    await txManager.prepare(tx2.id);
+    await txManager.commit(tx2.id);
+
+    // Verify both transactions committed
+    const finalTx1 = txManager.getTransaction(tx1.id);
+    const finalTx2 = txManager.getTransaction(tx2.id);
+
+    expect(finalTx1.status).toBe('committed');
+    expect(finalTx2.status).toBe('committed');
+    expect(finalTx2.parentHash).toBe(receipt1.hash);
+  });
+
+  it('should handle rollback with undo operations', async () => {
+    // Add initial capsule
+    const tx1 = txManager.begin([
+      {
+        id: 'op1',
+        type: 'add_capsule',
+        data: { id: 'capsule1', content: 'original' },
+      },
+    ]);
+
+    await txManager.prepare(tx1.id);
+    await txManager.commit(tx1.id);
+
+    // Verify capsule added
+    let state = txManager.getState();
+    expect(state.capsules).toBeDefined();
+    expect(state.capsules['capsule1']).toBeDefined();
+
+    // Create transaction to remove it
+    const tx2 = txManager.begin([
+      {
+        id: 'op2',
+        type: 'remove_capsule',
+        data: { capsule_id: 'capsule1' },
+      },
+    ]);
+
+    await txManager.prepare(tx2.id);
+    await txManager.commit(tx2.id);
+
+    // Verify capsule removed
+    state = txManager.getState();
+    expect(state.capsules['capsule1']).toBeUndefined();
+
+    // Rollback the removal
+    const rollbackResult = await txManager.rollback(tx2.id);
+
+    expect(rollbackResult.success).toBe(true);
+    expect(rollbackResult.undone).toBe(1);
+
+    // Verify capsule restored
+    state = txManager.getState();
+    expect(state.capsules['capsule1']).toBeDefined();
+    expect(state.capsules['capsule1'].content).toBe('original');
+  });
+});