@friggframework/admin-scripts 2.0.0--canary.545.b4ca16d.0 → 2.0.0--canary.517.ff03f2c.0

package/src/builtins/__tests__/integration-health-check.test.js

@@ -1,607 +0,0 @@
-const { IntegrationHealthCheckScript } = require('../integration-health-check');
-
-describe('IntegrationHealthCheckScript', () => {
-    describe('Definition', () => {
-        it('should have correct name and metadata', () => {
-            expect(IntegrationHealthCheckScript.Definition.name).toBe('integration-health-check');
-            expect(IntegrationHealthCheckScript.Definition.version).toBe('1.0.0');
-            expect(IntegrationHealthCheckScript.Definition.source).toBe('BUILTIN');
-            expect(IntegrationHealthCheckScript.Definition.config.requireIntegrationInstance).toBe(true);
-        });
-
-        it('should have valid input schema', () => {
-            const schema = IntegrationHealthCheckScript.Definition.inputSchema;
-            expect(schema.type).toBe('object');
-            expect(schema.properties.integrationIds).toBeDefined();
-            expect(schema.properties.checkCredentials).toBeDefined();
-            expect(schema.properties.checkConnectivity).toBeDefined();
-            expect(schema.properties.updateStatus).toBeDefined();
-        });
-
-        it('should have valid output schema', () => {
-            const schema = IntegrationHealthCheckScript.Definition.outputSchema;
-            expect(schema.type).toBe('object');
-            expect(schema.properties.healthy).toBeDefined();
-            expect(schema.properties.unhealthy).toBeDefined();
-            expect(schema.properties.unknown).toBeDefined();
-            expect(schema.properties.results).toBeDefined();
-        });
-
-        it('should have schedule configuration', () => {
-            const schedule = IntegrationHealthCheckScript.Definition.schedule;
-            expect(schedule).toBeDefined();
-            expect(schedule.enabled).toBe(false);
-            expect(schedule.cronExpression).toBe('cron(0 6 * * ? *)');
-        });
-
-        it('should have appropriate timeout configuration', () => {
-            expect(IntegrationHealthCheckScript.Definition.config.timeout).toBe(900000); // 15 minutes
-        });
-
-        it('should have clean display object', () => {
-            // Display should only have UI-specific fields
-            expect(IntegrationHealthCheckScript.Definition.display.category).toBe('maintenance');
-            // Should NOT have redundant label/description - they're derived from top-level
-        });
-    });
-
-    describe('execute()', () => {
-        let script;
-        let mockContext;
-
-        beforeEach(() => {
-            mockContext = {
-                log: jest.fn(),
-                integrationRepository: {
-                    findIntegrations: jest.fn(),
-                    findIntegrationById: jest.fn(),
-                    updateIntegrationStatus: jest.fn(),
-                },
-                instantiate: jest.fn(),
-            };
-            script = new IntegrationHealthCheckScript({ context: mockContext });
-        });
-
-        it('should return empty results when no integrations found', async () => {
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([]);
-
-            const result = await script.execute({});
-
-            expect(result.healthy).toBe(0);
-            expect(result.unhealthy).toBe(0);
-            expect(result.unknown).toBe(0);
-            expect(result.results).toEqual([]);
-        });
-
-        it('should return healthy for valid integrations', async () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    type: 'hubspot',
-                    credentials: {
-                        access_token: 'token123',
-                        expires_at: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString()
-                    }
-                }
-            };
-
-            const mockInstance = {
-                primary: {
-                    api: {
-                        getAuthenticationInfo: jest.fn().mockResolvedValue({ user: 'test' })
-                    }
-                }
-            };
-
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
-            mockContext.instantiate.mockResolvedValue(mockInstance);
-
-            const result = await script.execute({
-                checkCredentials: true,
-                checkConnectivity: true
-            });
-
-            expect(result.healthy).toBe(1);
-            expect(result.unhealthy).toBe(0);
-            expect(result.results[0]).toMatchObject({
-                integrationId: 'int-1',
-                status: 'healthy',
-                issues: []
-            });
-            expect(mockInstance.primary.api.getAuthenticationInfo).toHaveBeenCalled();
-        });
-
-        it('should return unhealthy for missing access token', async () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    type: 'hubspot',
-                    credentials: {} // No access_token
-                }
-            };
-
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
-
-            const result = await script.execute({
-                checkCredentials: true,
-                checkConnectivity: false
-            });
-
-            expect(result.healthy).toBe(0);
-            expect(result.unhealthy).toBe(1);
-            expect(result.results[0]).toMatchObject({
-                integrationId: 'int-1',
-                status: 'unhealthy',
-                issues: ['Missing access token']
-            });
-        });
-
-        it('should return unhealthy for expired credentials', async () => {
-            const pastDate = new Date(Date.now() - 24 * 60 * 60 * 1000); // 24 hours ago
-            const integration = {
-                id: 'int-1',
-                config: {
-                    type: 'hubspot',
-                    credentials: {
-                        access_token: 'token123',
-                        expires_at: pastDate.toISOString()
-                    }
-                }
-            };
-
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
-
-            const result = await script.execute({
-                checkCredentials: true,
-                checkConnectivity: false
-            });
-
-            expect(result.unhealthy).toBe(1);
-            expect(result.results[0]).toMatchObject({
-                integrationId: 'int-1',
-                status: 'unhealthy',
-                issues: ['Access token expired']
-            });
-        });
-
-        it('should return unhealthy for connectivity failures', async () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    type: 'hubspot',
-                    credentials: {
-                        access_token: 'token123',
-                        expires_at: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString()
-                    }
-                }
-            };
-
-            const mockInstance = {
-                primary: {
-                    api: {
-                        getAuthenticationInfo: jest.fn().mockRejectedValue(new Error('Network error'))
-                    }
-                }
-            };
-
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
-            mockContext.instantiate.mockResolvedValue(mockInstance);
-
-            const result = await script.execute({
-                checkCredentials: true,
-                checkConnectivity: true
-            });
-
-            expect(result.unhealthy).toBe(1);
-            expect(result.results[0].status).toBe('unhealthy');
-            expect(result.results[0].issues).toContainEqual(expect.stringContaining('API connectivity failed'));
-        });
-
-        it('should update integration status when updateStatus is true', async () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    type: 'hubspot',
-                    credentials: {
-                        access_token: 'token123',
-                        expires_at: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString()
-                    }
-                }
-            };
-
-            const mockInstance = {
-                primary: {
-                    api: {
-                        getAuthenticationInfo: jest.fn().mockResolvedValue({ user: 'test' })
-                    }
-                }
-            };
-
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
-            mockContext.instantiate.mockResolvedValue(mockInstance);
-            mockContext.integrationRepository.updateIntegrationStatus.mockResolvedValue(undefined);
-
-            const result = await script.execute({
-                checkCredentials: true,
-                checkConnectivity: true,
-                updateStatus: true
-            });
-
-            expect(result.healthy).toBe(1);
-            expect(mockContext.integrationRepository.updateIntegrationStatus).toHaveBeenCalledWith('int-1', 'ACTIVE');
-        });
-
-        it('should update integration status to ERROR for unhealthy integrations', async () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    type: 'hubspot',
-                    credentials: {} // Missing credentials
-                }
-            };
-
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
-            mockContext.integrationRepository.updateIntegrationStatus.mockResolvedValue(undefined);
-
-            const result = await script.execute({
-                checkCredentials: true,
-                checkConnectivity: false,
-                updateStatus: true
-            });
-
-            expect(result.unhealthy).toBe(1);
-            expect(mockContext.integrationRepository.updateIntegrationStatus).toHaveBeenCalledWith('int-1', 'ERROR');
-        });
-
-        it('should not update status when updateStatus is false', async () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    type: 'hubspot',
-                    credentials: {
-                        access_token: 'token123',
-                        expires_at: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString()
-                    }
-                }
-            };
-
-            const mockInstance = {
-                primary: {
-                    api: {
-                        getAuthenticationInfo: jest.fn().mockResolvedValue({ user: 'test' })
-                    }
-                }
-            };
-
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
-            mockContext.instantiate.mockResolvedValue(mockInstance);
-
-            await script.execute({
-                checkCredentials: true,
-                checkConnectivity: true,
-                updateStatus: false
-            });
-
-            expect(mockContext.integrationRepository.updateIntegrationStatus).not.toHaveBeenCalled();
-        });
-
-        it('should handle status update failures gracefully', async () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    type: 'hubspot',
-                    credentials: {
-                        access_token: 'token123',
-                        expires_at: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString()
-                    }
-                }
-            };
-
-            const mockInstance = {
-                primary: {
-                    api: {
-                        getAuthenticationInfo: jest.fn().mockResolvedValue({ user: 'test' })
-                    }
-                }
-            };
-
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
-            mockContext.instantiate.mockResolvedValue(mockInstance);
-            mockContext.integrationRepository.updateIntegrationStatus.mockRejectedValue(new Error('Update failed'));
-
-            const result = await script.execute({
-                checkCredentials: true,
-                checkConnectivity: true,
-                updateStatus: true
-            });
-
-            expect(result.healthy).toBe(1); // Should still report healthy
-            expect(mockContext.log).toHaveBeenCalledWith(
-                'warn',
-                expect.stringContaining('Failed to update status'),
-                expect.any(Object)
-            );
-        });
-
-        it('should filter by specific integration IDs', async () => {
-            const integration1 = {
-                id: 'int-1',
-                config: { type: 'hubspot', credentials: { access_token: 'token1' } }
-            };
-            const integration2 = {
-                id: 'int-2',
-                config: { type: 'salesforce', credentials: { access_token: 'token2' } }
-            };
-
-            mockContext.integrationRepository.findIntegrationById.mockImplementation((id) => {
-                if (id === 'int-1') return Promise.resolve(integration1);
-                if (id === 'int-2') return Promise.resolve(integration2);
-                return Promise.reject(new Error('Not found'));
-            });
-
-            const result = await script.execute({
-                integrationIds: ['int-1', 'int-2'],
-                checkCredentials: true,
-                checkConnectivity: false
-            });
-
-            expect(mockContext.integrationRepository.findIntegrationById).toHaveBeenCalledWith('int-1');
-            expect(mockContext.integrationRepository.findIntegrationById).toHaveBeenCalledWith('int-2');
-            expect(mockContext.integrationRepository.findIntegrations).not.toHaveBeenCalled();
-            expect(result.results).toHaveLength(2);
-        });
-
-        it('should handle errors when checking integrations', async () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    type: 'hubspot',
-                    credentials: {
-                        access_token: 'token123',
-                        expires_at: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString()
-                    }
-                }
-            };
-
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
-            mockContext.instantiate.mockRejectedValue(new Error('Instantiation failed'));
-
-            const result = await script.execute({
-                checkCredentials: true,
-                checkConnectivity: true
-            });
-
-            // Should still complete but mark as unknown or unhealthy
-            expect(result.results).toHaveLength(1);
-            expect(result.results[0].integrationId).toBe('int-1');
-        });
-
-        it('should skip credential check when checkCredentials is false', async () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    type: 'hubspot',
-                    credentials: {} // Missing credentials, but check is disabled
-                }
-            };
-
-            const mockInstance = {
-                primary: {
-                    api: {
-                        getAuthenticationInfo: jest.fn().mockResolvedValue({ user: 'test' })
-                    }
-                }
-            };
-
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
-            mockContext.instantiate.mockResolvedValue(mockInstance);
-
-            const result = await script.execute({
-                checkCredentials: false,
-                checkConnectivity: true
-            });
-
-            expect(result.results[0].checks.credentials).toBeUndefined();
-            expect(result.results[0].checks.connectivity).toBeDefined();
-        });
-
-        it('should skip connectivity check when checkConnectivity is false', async () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    type: 'hubspot',
-                    credentials: {
-                        access_token: 'token123',
-                        expires_at: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString()
-                    }
-                }
-            };
-
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
-
-            const result = await script.execute({
-                checkCredentials: true,
-                checkConnectivity: false
-            });
-
-            expect(result.results[0].checks.credentials).toBeDefined();
-            expect(result.results[0].checks.connectivity).toBeUndefined();
-            expect(mockContext.instantiate).not.toHaveBeenCalled();
-        });
-    });
-
-    describe('checkCredentialValidity()', () => {
-        let script;
-
-        beforeEach(() => {
-            script = new IntegrationHealthCheckScript({ context: { log: jest.fn() } });
-        });
-
-        it('should return valid for integrations with valid credentials', () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    credentials: {
-                        access_token: 'token123',
-                        expires_at: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString()
-                    }
-                }
-            };
-
-            const result = script.checkCredentialValidity(integration);
-
-            expect(result.valid).toBe(true);
-            expect(result.issue).toBeNull();
-        });
-
-        it('should return invalid for missing access token', () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    credentials: {}
-                }
-            };
-
-            const result = script.checkCredentialValidity(integration);
-
-            expect(result.valid).toBe(false);
-            expect(result.issue).toBe('Missing access token');
-        });
-
-        it('should return invalid for expired tokens', () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    credentials: {
-                        access_token: 'token123',
-                        expires_at: new Date(Date.now() - 1000).toISOString() // Expired
-                    }
-                }
-            };
-
-            const result = script.checkCredentialValidity(integration);
-
-            expect(result.valid).toBe(false);
-            expect(result.issue).toBe('Access token expired');
-        });
-
-        it('should return valid for credentials without expiry', () => {
-            const integration = {
-                id: 'int-1',
-                config: {
-                    credentials: {
-                        access_token: 'token123'
-                        // No expires_at
-                    }
-                }
-            };
-
-            const result = script.checkCredentialValidity(integration);
-
-            expect(result.valid).toBe(true);
-            expect(result.issue).toBeNull();
-        });
-    });
-
-    describe('checkApiConnectivity()', () => {
-        let script;
-        let mockContext;
-
-        beforeEach(() => {
-            mockContext = {
-                log: jest.fn(),
-                instantiate: jest.fn(),
-            };
-            script = new IntegrationHealthCheckScript({ context: mockContext });
-        });
-
-        it('should return valid for successful API calls', async () => {
-            const integration = {
-                id: 'int-1',
-                config: { type: 'hubspot' }
-            };
-
-            const mockInstance = {
-                primary: {
-                    api: {
-                        getAuthenticationInfo: jest.fn().mockResolvedValue({ user: 'test' })
-                    }
-                }
-            };
-
-            mockContext.instantiate.mockResolvedValue(mockInstance);
-
-            const result = await script.checkApiConnectivity(integration);
-
-            expect(result.valid).toBe(true);
-            expect(result.issue).toBeNull();
-            expect(result.responseTime).toBeGreaterThanOrEqual(0);
-        });
-
-        it('should try getCurrentUser if getAuthenticationInfo is not available', async () => {
-            const integration = {
-                id: 'int-1',
-                config: { type: 'hubspot' }
-            };
-
-            const mockInstance = {
-                primary: {
-                    api: {
-                        getCurrentUser: jest.fn().mockResolvedValue({ user: 'test' })
-                    }
-                }
-            };
-
-            mockContext.instantiate.mockResolvedValue(mockInstance);
-
-            const result = await script.checkApiConnectivity(integration);
-
-            expect(result.valid).toBe(true);
-            expect(mockInstance.primary.api.getCurrentUser).toHaveBeenCalled();
-        });
-
-        it('should return note when no health check endpoint is available', async () => {
-            const integration = {
-                id: 'int-1',
-                config: { type: 'hubspot' }
-            };
-
-            const mockInstance = {
-                primary: {
-                    api: {} // No health check methods
-                }
-            };
-
-            mockContext.instantiate.mockResolvedValue(mockInstance);
-
-            const result = await script.checkApiConnectivity(integration);
-
-            expect(result.valid).toBe(true);
-            expect(result.issue).toBeNull();
-            expect(result.note).toBe('No health check endpoint available');
-        });
-
-        it('should return invalid for API failures', async () => {
-            const integration = {
-                id: 'int-1',
-                config: { type: 'hubspot' }
-            };
-
-            const mockInstance = {
-                primary: {
-                    api: {
-                        getAuthenticationInfo: jest.fn().mockRejectedValue(new Error('Network error'))
-                    }
-                }
-            };
-
-            mockContext.instantiate.mockResolvedValue(mockInstance);
-
-            const result = await script.checkApiConnectivity(integration);
-
-            expect(result.valid).toBe(false);
-            expect(result.issue).toContain('API connectivity failed');
-            expect(result.issue).toContain('Network error');
-        });
-    });
-});