feat(tests): add unit tests for ObjectQL engine and InMemoryDriver, enhance AppPlugin and Runtime tests

Author: hotlong

packages/client/src/client.test.ts

@@ -46,7 +46,7 @@ describe('ObjectStackClient', () => {
         });
 
         const result = await client.meta.getTypes();
-        expect(fetchMock).toHaveBeenCalledWith('http://localhost:3000/api/v1/meta', expect.any(Object));
+        expect(fetchMock).toHaveBeenCalledWith('http://localhost:3000/api/v1/metadata', expect.any(Object));
         expect(result.types).toEqual(['object', 'plugin', 'view']);
     });
 
@@ -65,7 +65,7 @@ describe('ObjectStackClient', () => {
         });
 
         const result = await client.meta.getItems('object');
-        expect(fetchMock).toHaveBeenCalledWith('http://localhost:3000/api/v1/meta/object', expect.any(Object));
+        expect(fetchMock).toHaveBeenCalledWith('http://localhost:3000/api/v1/metadata/object', expect.any(Object));
         expect(result.type).toBe('object');
         expect(result.items).toHaveLength(2);
     });
@@ -85,7 +85,7 @@ describe('ObjectStackClient', () => {
         });
 
         const result = await client.meta.getItem('object', 'customer');
-        expect(fetchMock).toHaveBeenCalledWith('http://localhost:3000/api/v1/meta/object/customer', expect.any(Object));
+        expect(fetchMock).toHaveBeenCalledWith('http://localhost:3000/api/v1/metadata/object/customer', expect.any(Object));
         expect(result.name).toBe('customer');
     });
 });

packages/core/src/api-registry-plugin.test.ts

@@ -9,7 +9,9 @@ describe('API Registry Plugin', () => {
   let kernel: ObjectKernel;
 
   beforeEach(() => {
-    kernel = new ObjectKernel();
+    kernel = new ObjectKernel({
+        skipSystemValidation: true
+    });
   });
 
   describe('Plugin Registration', () => {

packages/core/src/kernel.test.ts

@@ -10,6 +10,7 @@ describe('ObjectKernel', () => {
         kernel = new ObjectKernel({
             logger: { level: 'error' }, // Suppress logs in tests
             gracefulShutdown: false, // Disable for tests
+            skipSystemValidation: true,
         });
     });
 
@@ -226,6 +227,7 @@ describe('ObjectKernel', () => {
                 logger: { level: 'error' },
                 rollbackOnFailure: false,
                 gracefulShutdown: false,
+                skipSystemValidation: true,
             });
 
             let plugin1Destroyed = false;

packages/core/src/kernel.ts

@@ -21,6 +21,9 @@ export interface ObjectKernelConfig {
 
     /** Whether to rollback on startup failure */
     rollbackOnFailure?: boolean;
+    
+    /** Whether to skip strict system requirement validation (Critical for testing) */
+    skipSystemValidation?: boolean;
 }
 
 /**
@@ -190,6 +193,11 @@ export class ObjectKernel {
      * Validate Critical System Requirements
      */
     private validateSystemRequirements() {
+        if (this.config.skipSystemValidation) {
+            this.logger.debug('System requirement validation skipped');
+            return;
+        }
+
         this.logger.debug('Validating system service requirements...');
         const missingServices: string[] = [];
         const missingCoreServices: string[] = [];

packages/objectql/src/engine.test.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ObjectQL } from './engine';
+import { SchemaRegistry } from './registry';
+import { DriverInterface } from '@objectstack/spec/data';
+
+// Mock the SchemaRegistry to avoid side effects between tests
+vi.mock('./registry', () => {
+  const mockObjects = new Map();
+  return {
+    SchemaRegistry: {
+      getObject: vi.fn((name) => mockObjects.get(name)),
+      registerObject: vi.fn((obj) => mockObjects.set(obj.name, obj)),
+      registerKind: vi.fn(),
+      metadata: {
+        get: vi.fn(() => mockObjects) // Expose for verification if needed
+      }
+    }
+  };
+});
+
+describe('ObjectQL Engine', () => {
+    let engine: ObjectQL;
+    let mockDriver: DriverInterface;
+    let mockDriver2: DriverInterface;
+
+    beforeEach(() => {
+        // Clear Registry Mocks
+        vi.clearAllMocks();
+        
+        // Setup Drivers
+        mockDriver = {
+            name: 'default-driver',
+            connect: vi.fn().mockResolvedValue(undefined),
+            disconnect: vi.fn().mockResolvedValue(undefined),
+            find: vi.fn().mockResolvedValue([{ id: '1', name: 'Test Record' }]),
+            findOne: vi.fn(),
+            create: vi.fn().mockResolvedValue({ id: '1', success: true }),
+            update: vi.fn(),
+            delete: vi.fn(),
+            count: vi.fn(),
+            capabilities: {} as any // Simplified
+        } as unknown as DriverInterface;
+
+        mockDriver2 = {
+            name: 'mongo',
+            connect: vi.fn().mockResolvedValue(undefined),
+            disconnect: vi.fn().mockResolvedValue(undefined),
+            find: vi.fn().mockResolvedValue([{ id: '2', name: 'Mongo Record' }]),
+            findOne: vi.fn(),
+            create: vi.fn().mockResolvedValue({ id: '2', success: true }),
+            update: vi.fn(),
+            delete: vi.fn(),
+            count: vi.fn(),
+            capabilities: {} as any
+        } as unknown as DriverInterface;
+
+        engine = new ObjectQL();
+    });
+
+    describe('Initialization', () => {
+        it('should initialize with default logger', () => {
+            expect(engine).toBeDefined();
+            expect(engine.getStatus().status).toBe('running');
+        });
+
+        it('should register and connect drivers on init', async () => {
+            engine.registerDriver(mockDriver, true);
+            await engine.init();
+            expect(mockDriver.connect).toHaveBeenCalled();
+        });
+    });
+
+    describe('Metadata Registration', () => {
+        it('should register objects from app manifest', () => {
+            const manifest = {
+                id: 'com.example.app',
+                objects: [
+                    { name: 'task', fields: {} }
+                ]
+            };
+            
+            engine.registerApp(manifest);
+            expect(SchemaRegistry.registerObject).toHaveBeenCalledWith(expect.objectContaining({ name: 'task' }));
+        });
+
+        it('should register kinds from app manifest', () => {
+            const manifest = {
+                id: 'com.example.app',
+                contributes: {
+                    kinds: [{ id: 'test.kind', description: 'Test Kind' }]
+                }
+            };
+            
+            engine.registerApp(manifest);
+            expect(SchemaRegistry.registerKind).toHaveBeenCalledWith(expect.objectContaining({ id: 'test.kind' }));
+        });
+    });
+
+    describe('Driver Routing', () => {
+        beforeEach(async () => {
+            // Setup:
+            // - Default Driver: mockDriver
+            // - Specific Driver: mockDriver2 (named 'mongo')
+            engine.registerDriver(mockDriver, true);
+            engine.registerDriver(mockDriver2);
+            await engine.init();
+        });
+
+        it('should route to default driver when no datasource is specified', async () => {
+            // Mock Schema: Object uses default datasource
+            vi.mocked(SchemaRegistry.getObject).mockReturnValue({ name: 'task', datasource: 'default', fields: {} });
+
+            await engine.find('task', { filters: [] });
+            
+            expect(mockDriver.find).toHaveBeenCalled();
+            expect(mockDriver2.find).not.toHaveBeenCalled();
+        });
+
+        it('should route to specific driver when datasource is specified', async () => {
+            // Mock Schema: Object uses 'mongo' datasource
+            vi.mocked(SchemaRegistry.getObject).mockReturnValue({ name: 'log', datasource: 'mongo', fields: {} });
+
+            await engine.find('log', { filters: [] });
+            
+            expect(mockDriver.find).not.toHaveBeenCalled();
+            expect(mockDriver2.find).toHaveBeenCalled();
+        });
+
+        it('should throw error if datasource is not found', async () => {
+             // Mock Schema: Object uses unknown datasource
+             vi.mocked(SchemaRegistry.getObject).mockReturnValue({ name: 'old_data', datasource: 'legacy_sql', fields: {} });
+
+             await expect(engine.find('old_data', {})).rejects.toThrow("Datasource 'legacy_sql' configured for object 'old_data' is not registered");
+        });
+    });
+
+    describe('CRUD Operations', () => {
+        beforeEach(async () => {
+            engine.registerDriver(mockDriver, true);
+            await engine.init();
+            vi.mocked(SchemaRegistry.getObject).mockReturnValue({ name: 'task', fields: {} });
+        });
+
+        it('should execute insert operation', async () => {
+            const result = await engine.insert('task', { title: 'New Task' });
+            expect(mockDriver.create).toHaveBeenCalledWith('task', { title: 'New Task' }, undefined);
+            expect(result).toEqual({ id: '1', success: true });
+        });
+
+        it('should execute find operation', async () => {
+            const result = await engine.find('task', {});
+            expect(mockDriver.find).toHaveBeenCalled();
+            expect(result).toHaveLength(1);
+        });
+    });
+});

packages/plugins/driver-memory/package.json

@@ -7,13 +7,16 @@
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "dev": "tsc -w"
+    "dev": "tsc -w",
+    "test": "vitest run"
   },
   "dependencies": {
     "@objectstack/core": "workspace:*",
     "@objectstack/spec": "workspace:*"
   },
   "devDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.18",
+    "@types/node": "^25.1.0"
   }
 }

packages/plugins/driver-memory/src/memory-driver.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { InMemoryDriver } from './memory-driver.js';
+
+describe('InMemoryDriver', () => {
+  let driver: InMemoryDriver;
+  const testTable = 'test_table';
+
+  beforeEach(async () => {
+    driver = new InMemoryDriver();
+    await driver.connect();
+    // No explicit clear DB method exposed, but new instance is clean.
+  });
+
+  describe('Lifecycle', () => {
+    it('should connect successfully', async () => {
+      expect(driver.checkHealth()).resolves.toBe(true);
+    });
+
+    it('should clear data on disconnect', async () => {
+      await driver.create(testTable, { id: '1', name: 'test' });
+      await driver.disconnect();
+      const results = await driver.find(testTable, { select: ['id'] });
+      expect(results).toHaveLength(0);
+    });
+  });
+
+  describe('Plugin Installation', () => {
+      it('should register driver with engine', () => {
+          const registerDriverFn = vi.fn();
+          const mockEngine = {
+              ql: {
+                  registerDriver: registerDriverFn
+              }
+          };
+          
+          driver.install({ engine: mockEngine });
+          expect(registerDriverFn).toHaveBeenCalledWith(driver);
+      });
+      
+       it('should handle missing engine gracefully', () => {
+          const mockCtx = {}; // No engine
+          // Should not throw
+          driver.install(mockCtx);
+      });
+  });
+
+  describe('CRUD Operations', () => {
+    it('should create and find records', async () => {
+      const data = { id: '1', name: 'Alice', age: 30 };
+      const created = await driver.create(testTable, data);
+      expect(created.id).toBe('1');
+
+      const results = await driver.find(testTable, { 
+          select: ['id', 'name', 'age'] 
+      });
+      
+      expect(results).toHaveLength(1);
+      expect(results[0].id).toBe('1');
+      expect(results[0].name).toBe('Alice');
+    });
+
+    it('should support updating records by ID', async () => {
+      await driver.create(testTable, { id: '1', name: 'Bob', active: true });
+      
+      const updateResult = await driver.update(
+          testTable, 
+          '1', 
+          { active: false }
+      );
+      
+      expect(updateResult.active).toBe(false);
+      
+      const results = await driver.find(testTable, { select: ['active'] });
+      expect(results[0].active).toBe(false);
+    });
+
+    it('should support deleting records by ID', async () => {
+       await driver.create(testTable, { id: '1', name: 'Charlie' });
+       await driver.create(testTable, { id: '2', name: 'David' });
+       
+       const deleteResult = await driver.delete(testTable, '1');
+       expect(deleteResult).toBe(true);
+       
+       const results = await driver.find(testTable, { select: ['name'] });
+       expect(results).toHaveLength(1);
+       expect(results[0].name).toBe('David');
+    });
+  });
+  
+  describe('Query Capability', () => {
+      it('should filter results', async () => {
+          await driver.create(testTable, { id: '1', role: 'admin' });
+          await driver.create(testTable, { id: '2', role: 'user' });
+          await driver.create(testTable, { id: '3', role: 'user' });
+          
+          const results = await driver.find(testTable, {
+              select: ['id'],
+              where: { role: 'user' }
+          });
+          
+          expect(results).toHaveLength(2);
+      });
+
+      it('should limit results', async () => {
+           await driver.create(testTable, { id: '1' });
+           await driver.create(testTable, { id: '2' });
+           await driver.create(testTable, { id: '3' });
+          
+          const results = await driver.find(testTable, {
+              select: ['id'],
+              limit: 2
+          });
+          
+          expect(results).toHaveLength(2);
+      });
+  });
+});

packages/runtime/package.json

@@ -8,14 +8,16 @@
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "dev": "tsc -w"
+    "dev": "tsc -w",
+    "test": "vitest run"
   },
   "dependencies": {
     "@objectstack/core": "workspace:*",
-    "@objectstack/types": "workspace:*",
-    "@objectstack/spec": "workspace:*"
+    "@objectstack/spec": "workspace:*",
+    "@objectstack/types": "workspace:*"
   },
   "devDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.18"
   }
 }