@objectstack/core 0.9.1 → 0.9.2

package/dist/enhanced-kernel.test.js

@@ -1,412 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { EnhancedObjectKernel } from './enhanced-kernel';
-import { ServiceLifecycle } from './plugin-loader';
-describe('EnhancedObjectKernel', () => {
-    let kernel;
-    beforeEach(() => {
-        kernel = new EnhancedObjectKernel({
-            logger: { level: 'error' }, // Suppress logs in tests
-            gracefulShutdown: false, // Disable for tests
-        });
-    });
-    describe('Plugin Registration and Loading', () => {
-        it('should register a plugin with version', async () => {
-            const plugin = {
-                name: 'versioned-plugin',
-                version: '1.2.3',
-                init: async () => { },
-            };
-            await kernel.use(plugin);
-            await kernel.bootstrap();
-            expect(kernel.isRunning()).toBe(true);
-            await kernel.shutdown();
-        });
-        it('should validate plugin during registration', async () => {
-            const invalidPlugin = {
-                name: '',
-                init: async () => { },
-            };
-            await expect(async () => {
-                await kernel.use(invalidPlugin);
-            }).rejects.toThrow();
-        });
-        it('should reject plugin registration after bootstrap', async () => {
-            await kernel.bootstrap();
-            const plugin = {
-                name: 'late-plugin',
-                init: async () => { },
-            };
-            await expect(async () => {
-                await kernel.use(plugin);
-            }).rejects.toThrow('Cannot register plugins after bootstrap');
-            await kernel.shutdown();
-        });
-    });
-    describe('Service Factory Registration', () => {
-        it('should register singleton service factory', async () => {
-            let callCount = 0;
-            kernel.registerServiceFactory('counter', () => {
-                callCount++;
-                return { count: callCount };
-            }, ServiceLifecycle.SINGLETON);
-            await kernel.bootstrap();
-            const service1 = await kernel.getServiceAsync('counter');
-            const service2 = await kernel.getServiceAsync('counter');
-            expect(callCount).toBe(1);
-            expect(service1).toBe(service2);
-            await kernel.shutdown();
-        });
-        it('should register transient service factory', async () => {
-            let callCount = 0;
-            kernel.registerServiceFactory('transient', () => {
-                callCount++;
-                return { count: callCount };
-            }, ServiceLifecycle.TRANSIENT);
-            await kernel.bootstrap();
-            const service1 = await kernel.getServiceAsync('transient');
-            const service2 = await kernel.getServiceAsync('transient');
-            expect(callCount).toBe(2);
-            expect(service1).not.toBe(service2);
-            await kernel.shutdown();
-        });
-        it('should register scoped service factory', async () => {
-            let callCount = 0;
-            kernel.registerServiceFactory('scoped', () => {
-                callCount++;
-                return { count: callCount };
-            }, ServiceLifecycle.SCOPED);
-            await kernel.bootstrap();
-            const service1 = await kernel.getServiceAsync('scoped', 'request-1');
-            const service2 = await kernel.getServiceAsync('scoped', 'request-1');
-            const service3 = await kernel.getServiceAsync('scoped', 'request-2');
-            expect(callCount).toBe(2); // Once per scope
-            expect(service1).toBe(service2); // Same within scope
-            expect(service1).not.toBe(service3); // Different across scopes
-            await kernel.shutdown();
-        });
-    });
-    describe('Plugin Lifecycle with Timeout', () => {
-        it('should timeout plugin init if it takes too long', async () => {
-            const plugin = {
-                name: 'slow-init',
-                version: '1.0.0',
-                init: async () => {
-                    await new Promise(resolve => setTimeout(resolve, 5000)); // 5 seconds
-                },
-                startupTimeout: 100, // 100ms timeout
-            };
-            await kernel.use(plugin);
-            await expect(async () => {
-                await kernel.bootstrap();
-            }).rejects.toThrow('timeout');
-        }, 1000); // Test should complete in 1 second
-        it('should timeout plugin start if it takes too long', async () => {
-            const plugin = {
-                name: 'slow-start',
-                version: '1.0.0',
-                init: async () => { },
-                start: async () => {
-                    await new Promise(resolve => setTimeout(resolve, 5000)); // 5 seconds
-                },
-                startupTimeout: 100, // 100ms timeout
-            };
-            await kernel.use(plugin);
-            await expect(async () => {
-                await kernel.bootstrap();
-            }).rejects.toThrow();
-        }, 1000); // Test should complete in 1 second
-        it('should complete plugin startup within timeout', async () => {
-            const plugin = {
-                name: 'fast-plugin',
-                version: '1.0.0',
-                init: async () => {
-                    await new Promise(resolve => setTimeout(resolve, 10));
-                },
-                start: async () => {
-                    await new Promise(resolve => setTimeout(resolve, 10));
-                },
-                startupTimeout: 1000,
-            };
-            await kernel.use(plugin);
-            await kernel.bootstrap();
-            expect(kernel.isRunning()).toBe(true);
-            await kernel.shutdown();
-        });
-    });
-    describe('Startup Failure Rollback', () => {
-        it('should rollback started plugins on failure', async () => {
-            let plugin1Destroyed = false;
-            const plugin1 = {
-                name: 'plugin-1',
-                version: '1.0.0',
-                init: async () => { },
-                start: async () => { },
-                destroy: async () => {
-                    plugin1Destroyed = true;
-                },
-            };
-            const plugin2 = {
-                name: 'plugin-2',
-                version: '1.0.0',
-                init: async () => { },
-                start: async () => {
-                    throw new Error('Startup failed');
-                },
-            };
-            await kernel.use(plugin1);
-            await kernel.use(plugin2);
-            await expect(async () => {
-                await kernel.bootstrap();
-            }).rejects.toThrow('failed to start');
-            // Plugin 1 should be rolled back
-            expect(plugin1Destroyed).toBe(true);
-        });
-        it('should not rollback if disabled', async () => {
-            const noRollbackKernel = new EnhancedObjectKernel({
-                logger: { level: 'error' },
-                rollbackOnFailure: false,
-                gracefulShutdown: false,
-            });
-            let plugin1Destroyed = false;
-            const plugin1 = {
-                name: 'plugin-1',
-                version: '1.0.0',
-                init: async () => { },
-                start: async () => { },
-                destroy: async () => {
-                    plugin1Destroyed = true;
-                },
-            };
-            const plugin2 = {
-                name: 'plugin-2',
-                version: '1.0.0',
-                init: async () => { },
-                start: async () => {
-                    throw new Error('Startup failed');
-                },
-            };
-            await noRollbackKernel.use(plugin1);
-            await noRollbackKernel.use(plugin2);
-            // Should not throw since rollback is disabled
-            await noRollbackKernel.bootstrap();
-            // Plugin 1 should NOT be destroyed
-            expect(plugin1Destroyed).toBe(false);
-        });
-    });
-    describe('Plugin Health Checks', () => {
-        it('should check individual plugin health', async () => {
-            const plugin = {
-                name: 'healthy-plugin',
-                version: '1.0.0',
-                init: async () => { },
-            };
-            await kernel.use(plugin);
-            await kernel.bootstrap();
-            const health = await kernel.checkPluginHealth('healthy-plugin');
-            expect(health.healthy).toBe(true);
-            expect(health.lastCheck).toBeInstanceOf(Date);
-            await kernel.shutdown();
-        });
-        it('should check all plugins health', async () => {
-            const plugin1 = {
-                name: 'plugin-1',
-                version: '1.0.0',
-                init: async () => { },
-            };
-            const plugin2 = {
-                name: 'plugin-2',
-                version: '1.0.0',
-                init: async () => { },
-            };
-            await kernel.use(plugin1);
-            await kernel.use(plugin2);
-            await kernel.bootstrap();
-            const allHealth = await kernel.checkAllPluginsHealth();
-            expect(allHealth.size).toBe(2);
-            expect(allHealth.get('plugin-1').healthy).toBe(true);
-            expect(allHealth.get('plugin-2').healthy).toBe(true);
-            await kernel.shutdown();
-        });
-    });
-    describe('Plugin Metrics', () => {
-        it('should track plugin startup times', async () => {
-            const plugin1 = {
-                name: 'plugin-1',
-                version: '1.0.0',
-                init: async () => { },
-                start: async () => {
-                    await new Promise(resolve => setTimeout(resolve, 50));
-                },
-            };
-            const plugin2 = {
-                name: 'plugin-2',
-                version: '1.0.0',
-                init: async () => { },
-                start: async () => {
-                    await new Promise(resolve => setTimeout(resolve, 30));
-                },
-            };
-            await kernel.use(plugin1);
-            await kernel.use(plugin2);
-            await kernel.bootstrap();
-            const metrics = kernel.getPluginMetrics();
-            expect(metrics.size).toBe(2);
-            expect(metrics.get('plugin-1')).toBeGreaterThan(0);
-            expect(metrics.get('plugin-2')).toBeGreaterThan(0);
-            await kernel.shutdown();
-        });
-        it('should not track metrics for plugins without start', async () => {
-            const plugin = {
-                name: 'no-start',
-                version: '1.0.0',
-                init: async () => { },
-            };
-            await kernel.use(plugin);
-            await kernel.bootstrap();
-            const metrics = kernel.getPluginMetrics();
-            expect(metrics.has('no-start')).toBe(false);
-            await kernel.shutdown();
-        });
-    });
-    describe('Graceful Shutdown', () => {
-        it('should call destroy on all plugins', async () => {
-            let plugin1Destroyed = false;
-            let plugin2Destroyed = false;
-            const plugin1 = {
-                name: 'plugin-1',
-                version: '1.0.0',
-                init: async () => { },
-                destroy: async () => {
-                    plugin1Destroyed = true;
-                },
-            };
-            const plugin2 = {
-                name: 'plugin-2',
-                version: '1.0.0',
-                init: async () => { },
-                destroy: async () => {
-                    plugin2Destroyed = true;
-                },
-            };
-            await kernel.use(plugin1);
-            await kernel.use(plugin2);
-            await kernel.bootstrap();
-            await kernel.shutdown();
-            expect(plugin1Destroyed).toBe(true);
-            expect(plugin2Destroyed).toBe(true);
-        });
-        it('should handle plugin destroy errors gracefully', async () => {
-            const plugin1 = {
-                name: 'error-destroy',
-                version: '1.0.0',
-                init: async () => { },
-                destroy: async () => {
-                    throw new Error('Destroy failed');
-                },
-            };
-            const plugin2 = {
-                name: 'normal-plugin',
-                version: '1.0.0',
-                init: async () => { },
-            };
-            await kernel.use(plugin1);
-            await kernel.use(plugin2);
-            await kernel.bootstrap();
-            // Should not throw even if one plugin fails to destroy
-            await kernel.shutdown();
-            expect(kernel.getState()).toBe('stopped');
-        });
-        it('should trigger shutdown hook', async () => {
-            let hookCalled = false;
-            const plugin = {
-                name: 'hook-plugin',
-                version: '1.0.0',
-                init: async (ctx) => {
-                    ctx.hook('kernel:shutdown', async () => {
-                        hookCalled = true;
-                    });
-                },
-            };
-            await kernel.use(plugin);
-            await kernel.bootstrap();
-            await kernel.shutdown();
-            expect(hookCalled).toBe(true);
-        });
-        it('should execute custom shutdown handlers', async () => {
-            let handlerCalled = false;
-            kernel.onShutdown(async () => {
-                handlerCalled = true;
-            });
-            await kernel.bootstrap();
-            await kernel.shutdown();
-            expect(handlerCalled).toBe(true);
-        });
-    });
-    describe('Dependency Resolution', () => {
-        it('should resolve plugin dependencies in correct order', async () => {
-            const initOrder = [];
-            const pluginA = {
-                name: 'plugin-a',
-                version: '1.0.0',
-                dependencies: ['plugin-b'],
-                init: async () => {
-                    initOrder.push('plugin-a');
-                },
-            };
-            const pluginB = {
-                name: 'plugin-b',
-                version: '1.0.0',
-                init: async () => {
-                    initOrder.push('plugin-b');
-                },
-            };
-            await kernel.use(pluginA);
-            await kernel.use(pluginB);
-            await kernel.bootstrap();
-            expect(initOrder).toEqual(['plugin-b', 'plugin-a']);
-            await kernel.shutdown();
-        });
-        it('should detect circular plugin dependencies', async () => {
-            const pluginA = {
-                name: 'plugin-a',
-                version: '1.0.0',
-                dependencies: ['plugin-b'],
-                init: async () => { },
-            };
-            const pluginB = {
-                name: 'plugin-b',
-                version: '1.0.0',
-                dependencies: ['plugin-a'],
-                init: async () => { },
-            };
-            await kernel.use(pluginA);
-            await kernel.use(pluginB);
-            await expect(async () => {
-                await kernel.bootstrap();
-            }).rejects.toThrow('Circular dependency');
-        });
-    });
-    describe('State Management', () => {
-        it('should track kernel state correctly', async () => {
-            expect(kernel.getState()).toBe('idle');
-            await kernel.bootstrap();
-            expect(kernel.getState()).toBe('running');
-            expect(kernel.isRunning()).toBe(true);
-            await kernel.shutdown();
-            expect(kernel.getState()).toBe('stopped');
-            expect(kernel.isRunning()).toBe(false);
-        });
-        it('should not allow double bootstrap', async () => {
-            await kernel.bootstrap();
-            await expect(async () => {
-                await kernel.bootstrap();
-            }).rejects.toThrow('already bootstrapped');
-            await kernel.shutdown();
-        });
-        it('should not allow shutdown before bootstrap', async () => {
-            await expect(async () => {
-                await kernel.shutdown();
-            }).rejects.toThrow('not running');
-        });
-    });
-});