@friggframework/admin-scripts 2.0.0--canary.517.41839c5.0

package/src/application/__tests__/script-factory.test.js

@@ -0,0 +1,381 @@
+const {
+    ScriptFactory,
+    createScriptFactory,
+    getScriptFactory,
+} = require('../script-factory');
+const { AdminScriptBase } = require('../admin-script-base');
+
+describe('ScriptFactory', () => {
+    let factory;
+
+    beforeEach(() => {
+        factory = new ScriptFactory();
+    });
+
+    describe('register()', () => {
+        it('should register a script class', () => {
+            class TestScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'test-script',
+                    version: '1.0.0',
+                    description: 'A test script',
+                };
+            }
+
+            factory.register(TestScript);
+
+            expect(factory.has('test-script')).toBe(true);
+            expect(factory.size).toBe(1);
+        });
+
+        it('should throw error if script class has no Definition', () => {
+            class InvalidScript {}
+
+            expect(() => factory.register(InvalidScript)).toThrow(
+                'Script class must have a static Definition property'
+            );
+        });
+
+        it('should throw error if Definition has no name', () => {
+            class InvalidScript extends AdminScriptBase {
+                static Definition = {
+                    version: '1.0.0',
+                    description: 'No name',
+                };
+            }
+
+            expect(() => factory.register(InvalidScript)).toThrow(
+                'Script Definition must have a name'
+            );
+        });
+
+        it('should throw error if script name is already registered', () => {
+            class Script1 extends AdminScriptBase {
+                static Definition = {
+                    name: 'duplicate',
+                    version: '1.0.0',
+                    description: 'First',
+                };
+            }
+
+            class Script2 extends AdminScriptBase {
+                static Definition = {
+                    name: 'duplicate',
+                    version: '2.0.0',
+                    description: 'Second',
+                };
+            }
+
+            factory.register(Script1);
+
+            expect(() => factory.register(Script2)).toThrow(
+                'Script "duplicate" is already registered'
+            );
+        });
+    });
+
+    describe('registerAll()', () => {
+        it('should register multiple scripts', () => {
+            class Script1 extends AdminScriptBase {
+                static Definition = {
+                    name: 'script-1',
+                    version: '1.0.0',
+                    description: 'First',
+                };
+            }
+
+            class Script2 extends AdminScriptBase {
+                static Definition = {
+                    name: 'script-2',
+                    version: '1.0.0',
+                    description: 'Second',
+                };
+            }
+
+            class Script3 extends AdminScriptBase {
+                static Definition = {
+                    name: 'script-3',
+                    version: '1.0.0',
+                    description: 'Third',
+                };
+            }
+
+            factory.registerAll([Script1, Script2, Script3]);
+
+            expect(factory.size).toBe(3);
+            expect(factory.has('script-1')).toBe(true);
+            expect(factory.has('script-2')).toBe(true);
+            expect(factory.has('script-3')).toBe(true);
+        });
+
+        it('should handle empty array', () => {
+            factory.registerAll([]);
+
+            expect(factory.size).toBe(0);
+        });
+    });
+
+    describe('get()', () => {
+        it('should return registered script class', () => {
+            class TestScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'test',
+                    version: '1.0.0',
+                    description: 'Test',
+                };
+            }
+
+            factory.register(TestScript);
+
+            const retrieved = factory.get('test');
+
+            expect(retrieved).toBe(TestScript);
+        });
+
+        it('should throw error if script not found', () => {
+            expect(() => factory.get('non-existent')).toThrow(
+                'Script "non-existent" not found'
+            );
+        });
+    });
+
+    describe('has()', () => {
+        it('should return true for registered script', () => {
+            class TestScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'test',
+                    version: '1.0.0',
+                    description: 'Test',
+                };
+            }
+
+            factory.register(TestScript);
+
+            expect(factory.has('test')).toBe(true);
+        });
+
+        it('should return false for non-registered script', () => {
+            expect(factory.has('non-existent')).toBe(false);
+        });
+    });
+
+    describe('getNames()', () => {
+        it('should return array of all registered script names', () => {
+            class Script1 extends AdminScriptBase {
+                static Definition = { name: 'script-1', version: '1.0.0', description: 'One' };
+            }
+
+            class Script2 extends AdminScriptBase {
+                static Definition = { name: 'script-2', version: '1.0.0', description: 'Two' };
+            }
+
+            factory.registerAll([Script1, Script2]);
+
+            const names = factory.getNames();
+
+            expect(names).toHaveLength(2);
+            expect(names).toContain('script-1');
+            expect(names).toContain('script-2');
+        });
+
+        it('should return empty array when no scripts registered', () => {
+            const names = factory.getNames();
+
+            expect(names).toEqual([]);
+        });
+    });
+
+    describe('getAll()', () => {
+        it('should return all scripts with their definitions', () => {
+            class Script1 extends AdminScriptBase {
+                static Definition = {
+                    name: 'script-1',
+                    version: '1.0.0',
+                    description: 'First script',
+                };
+            }
+
+            class Script2 extends AdminScriptBase {
+                static Definition = {
+                    name: 'script-2',
+                    version: '2.0.0',
+                    description: 'Second script',
+                };
+            }
+
+            factory.registerAll([Script1, Script2]);
+
+            const all = factory.getAll();
+
+            expect(all).toHaveLength(2);
+
+            const script1Entry = all.find((s) => s.name === 'script-1');
+            const script2Entry = all.find((s) => s.name === 'script-2');
+
+            expect(script1Entry.definition).toEqual(Script1.Definition);
+            expect(script2Entry.definition).toEqual(Script2.Definition);
+        });
+
+        it('should return empty array when no scripts registered', () => {
+            const all = factory.getAll();
+
+            expect(all).toEqual([]);
+        });
+    });
+
+    describe('createInstance()', () => {
+        it('should create an instance of registered script', () => {
+            class TestScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'test',
+                    version: '1.0.0',
+                    description: 'Test',
+                };
+            }
+
+            factory.register(TestScript);
+
+            const instance = factory.createInstance('test');
+
+            expect(instance).toBeInstanceOf(TestScript);
+            expect(instance).toBeInstanceOf(AdminScriptBase);
+        });
+
+        it('should pass params to constructor', () => {
+            class TestScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'test',
+                    version: '1.0.0',
+                    description: 'Test',
+                };
+            }
+
+            factory.register(TestScript);
+
+            const mockFactory = { mock: true };
+            const instance = factory.createInstance('test', {
+                executionId: 'exec_123',
+                integrationFactory: mockFactory,
+            });
+
+            expect(instance.executionId).toBe('exec_123');
+            expect(instance.integrationFactory).toBe(mockFactory);
+        });
+
+        it('should throw error if script not found', () => {
+            expect(() => factory.createInstance('non-existent')).toThrow(
+                'Script "non-existent" not found'
+            );
+        });
+    });
+
+    describe('clear()', () => {
+        it('should remove all registered scripts', () => {
+            class Script1 extends AdminScriptBase {
+                static Definition = { name: 'script-1', version: '1.0.0', description: 'One' };
+            }
+
+            class Script2 extends AdminScriptBase {
+                static Definition = { name: 'script-2', version: '1.0.0', description: 'Two' };
+            }
+
+            factory.registerAll([Script1, Script2]);
+            expect(factory.size).toBe(2);
+
+            factory.clear();
+
+            expect(factory.size).toBe(0);
+            expect(factory.has('script-1')).toBe(false);
+            expect(factory.has('script-2')).toBe(false);
+        });
+    });
+
+    describe('size property', () => {
+        it('should return count of registered scripts', () => {
+            expect(factory.size).toBe(0);
+
+            class Script1 extends AdminScriptBase {
+                static Definition = { name: 'script-1', version: '1.0.0', description: 'One' };
+            }
+
+            factory.register(Script1);
+            expect(factory.size).toBe(1);
+
+            class Script2 extends AdminScriptBase {
+                static Definition = { name: 'script-2', version: '1.0.0', description: 'Two' };
+            }
+
+            factory.register(Script2);
+            expect(factory.size).toBe(2);
+
+            factory.clear();
+            expect(factory.size).toBe(0);
+        });
+    });
+
+    describe('Global factory functions', () => {
+        it('getScriptFactory() should return singleton instance', () => {
+            const factory1 = getScriptFactory();
+            const factory2 = getScriptFactory();
+
+            expect(factory1).toBe(factory2);
+            expect(factory1).toBeInstanceOf(ScriptFactory);
+        });
+
+        it('createScriptFactory() should create new instance', () => {
+            const factory1 = createScriptFactory();
+            const factory2 = createScriptFactory();
+
+            expect(factory1).not.toBe(factory2);
+            expect(factory1).toBeInstanceOf(ScriptFactory);
+            expect(factory2).toBeInstanceOf(ScriptFactory);
+        });
+
+        it('global factory should be independent from created instances', () => {
+            class TestScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'test',
+                    version: '1.0.0',
+                    description: 'Test',
+                };
+            }
+
+            const customFactory = createScriptFactory();
+            customFactory.register(TestScript);
+
+            const globalFactory = getScriptFactory();
+
+            // Custom factory has the script
+            expect(customFactory.has('test')).toBe(true);
+
+            // Global factory doesn't (assuming it's empty or has different scripts)
+            // We can't make assumptions about global factory state in tests
+            // so we just verify they're different instances
+            expect(customFactory).not.toBe(globalFactory);
+        });
+    });
+
+    describe('Exported AdminScriptBase', () => {
+        it('should export AdminScriptBase class', () => {
+            expect(AdminScriptBase).toBeDefined();
+            expect(typeof AdminScriptBase).toBe('function');
+        });
+
+        it('should be usable to create scripts', () => {
+            class MyScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'my-script',
+                    version: '1.0.0',
+                    description: 'My script',
+                };
+
+                async execute(frigg, params) {
+                    return { success: true };
+                }
+            }
+
+            const script = new MyScript();
+            expect(script).toBeInstanceOf(AdminScriptBase);
+        });
+    });
+});

package/src/application/__tests__/script-runner.test.js

@@ -0,0 +1,202 @@
+const { ScriptRunner, createScriptRunner } = require('../script-runner');
+const { ScriptFactory } = require('../script-factory');
+const { AdminScriptBase } = require('../admin-script-base');
+
+// Mock dependencies
+jest.mock('../admin-frigg-commands');
+jest.mock('@friggframework/core/application/commands/admin-script-commands');
+
+const { createAdminFriggCommands } = require('../admin-frigg-commands');
+const { createAdminScriptCommands } = require('@friggframework/core/application/commands/admin-script-commands');
+
+describe('ScriptRunner', () => {
+    let scriptFactory;
+    let mockCommands;
+    let mockFrigg;
+    let testScript;
+
+    class TestScript extends AdminScriptBase {
+        static Definition = {
+            name: 'test-script',
+            version: '1.0.0',
+            description: 'Test script',
+            config: {
+                timeout: 300000,
+                maxRetries: 0,
+                requiresIntegrationFactory: false,
+            },
+        };
+
+        async execute(frigg, params) {
+            return { success: true, params };
+        }
+    }
+
+    beforeEach(() => {
+        scriptFactory = new ScriptFactory([TestScript]);
+
+        mockCommands = {
+            createScriptExecution: jest.fn(),
+            updateScriptExecutionStatus: jest.fn(),
+            completeScriptExecution: jest.fn(),
+        };
+
+        mockFrigg = {
+            log: jest.fn(),
+            getExecutionId: jest.fn(),
+        };
+
+        createAdminScriptCommands.mockReturnValue(mockCommands);
+        createAdminFriggCommands.mockReturnValue(mockFrigg);
+
+        mockCommands.createScriptExecution.mockResolvedValue({
+            id: 'exec-123',
+        });
+        mockCommands.updateScriptExecutionStatus.mockResolvedValue({});
+        mockCommands.completeScriptExecution.mockResolvedValue({ success: true });
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('execute()', () => {
+        it('should execute script successfully', async () => {
+            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
+
+            const result = await runner.execute('test-script', { foo: 'bar' }, {
+                trigger: 'MANUAL',
+                mode: 'async',
+                audit: { apiKeyName: 'test-key' },
+            });
+
+            expect(result.status).toBe('COMPLETED');
+            expect(result.scriptName).toBe('test-script');
+            expect(result.output).toEqual({ success: true, params: { foo: 'bar' } });
+            expect(result.executionId).toBe('exec-123');
+            expect(result.metrics.durationMs).toBeGreaterThanOrEqual(0);
+
+            expect(mockCommands.createScriptExecution).toHaveBeenCalledWith({
+                scriptName: 'test-script',
+                scriptVersion: '1.0.0',
+                trigger: 'MANUAL',
+                mode: 'async',
+                input: { foo: 'bar' },
+                audit: { apiKeyName: 'test-key' },
+            });
+
+            expect(mockCommands.updateScriptExecutionStatus).toHaveBeenCalledWith(
+                'exec-123',
+                'RUNNING'
+            );
+
+            expect(mockCommands.completeScriptExecution).toHaveBeenCalledWith(
+                'exec-123',
+                expect.objectContaining({
+                    status: 'COMPLETED',
+                    output: { success: true, params: { foo: 'bar' } },
+                    metrics: expect.objectContaining({
+                        durationMs: expect.any(Number),
+                    }),
+                })
+            );
+        });
+
+        it('should handle script execution failure', async () => {
+            class FailingScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'failing-script',
+                    version: '1.0.0',
+                    description: 'Failing script',
+                    config: { timeout: 300000, maxRetries: 0 },
+                };
+
+                async execute() {
+                    throw new Error('Script failed');
+                }
+            }
+
+            scriptFactory.register(FailingScript);
+            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
+
+            const result = await runner.execute('failing-script', {}, {
+                trigger: 'MANUAL',
+                mode: 'sync',
+            });
+
+            expect(result.status).toBe('FAILED');
+            expect(result.scriptName).toBe('failing-script');
+            expect(result.error.message).toBe('Script failed');
+
+            expect(mockCommands.completeScriptExecution).toHaveBeenCalledWith(
+                'exec-123',
+                expect.objectContaining({
+                    status: 'FAILED',
+                    error: expect.objectContaining({
+                        message: 'Script failed',
+                    }),
+                })
+            );
+        });
+
+        it('should throw error if integrationFactory required but not provided', async () => {
+            class IntegrationScript extends AdminScriptBase {
+                static Definition = {
+                    name: 'integration-script',
+                    version: '1.0.0',
+                    description: 'Integration script',
+                    config: {
+                        requiresIntegrationFactory: true,
+                    },
+                };
+
+                async execute() {
+                    return {};
+                }
+            }
+
+            scriptFactory.register(IntegrationScript);
+            const runner = new ScriptRunner({
+                scriptFactory,
+                commands: mockCommands,
+                integrationFactory: null,
+            });
+
+            await expect(
+                runner.execute('integration-script', {}, { trigger: 'MANUAL' })
+            ).rejects.toThrow(
+                'Script "integration-script" requires integrationFactory but none was provided'
+            );
+        });
+
+        it('should reuse existing execution ID when provided', async () => {
+            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
+
+            const result = await runner.execute('test-script', { foo: 'bar' }, {
+                trigger: 'QUEUE',
+                executionId: 'existing-exec-456',
+            });
+
+            expect(result.executionId).toBe('existing-exec-456');
+            expect(mockCommands.createScriptExecution).not.toHaveBeenCalled();
+            expect(mockCommands.updateScriptExecutionStatus).toHaveBeenCalledWith(
+                'existing-exec-456',
+                'RUNNING'
+            );
+        });
+    });
+
+    describe('createScriptRunner()', () => {
+        it('should create runner with default factory', () => {
+            const runner = createScriptRunner();
+            expect(runner).toBeInstanceOf(ScriptRunner);
+        });
+
+        it('should create runner with custom params', () => {
+            const customFactory = new ScriptFactory();
+            const runner = createScriptRunner({ scriptFactory: customFactory });
+            expect(runner).toBeInstanceOf(ScriptRunner);
+            expect(runner.scriptFactory).toBe(customFactory);
+        });
+    });
+});