@friggframework/core 2.0.0--canary.461.61382d8.0 → 2.0.0--canary.461.3d6d8ad.0

package/handlers/routers/health.test.js

@@ -1,210 +0,0 @@
-process.env.HEALTH_API_KEY = 'test-api-key';
-
-jest.mock('../../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-jest.mock('mongoose', () => ({
-    set: jest.fn(),
-    connection: {
-        readyState: 1,
-        db: {
-            admin: () => ({
-                ping: jest.fn().mockResolvedValue(true)
-            })
-        }
-    }
-}));
-
-jest.mock('./../backend-utils', () => ({
-    moduleFactory: {
-        moduleTypes: ['test-module', 'another-module']
-    },
-    integrationFactory: {
-        integrationTypes: ['test-integration', 'another-integration']
-    }
-}));
-
-jest.mock('./../app-handler-helpers', () => ({
-    createAppHandler: jest.fn((name, router) => ({ name, router }))
-}));
-
-const { router } = require('./health');
-const mongoose = require('mongoose');
-
-const mockRequest = (path, headers = {}) => ({
-    path,
-    headers
-});
-
-const mockResponse = () => {
-    const res = {};
-    res.status = jest.fn().mockReturnValue(res);
-    res.json = jest.fn().mockReturnValue(res);
-    return res;
-};
-
-describe('Health Check Endpoints', () => {
-    beforeEach(() => {
-        mongoose.connection.readyState = 1;
-    });
-
-    describe('Middleware - validateApiKey', () => {
-        it('should allow access to /health without authentication', async () => {
-            expect(true).toBe(true);
-        });
-    });
-
-    describe('GET /health', () => {
-        it('should return basic health status', async () => {
-            const req = mockRequest('/health');
-            const res = mockResponse();
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-
-            expect(res.status).toHaveBeenCalledWith(200);
-            expect(res.json).toHaveBeenCalledWith({
-                status: 'ok',
-                timestamp: expect.any(String),
-                service: 'frigg-core-api'
-            });
-        });
-    });
-
-    describe('GET /health/detailed', () => {
-        it('should return detailed health status when healthy', async () => {
-            const req = mockRequest('/health/detailed', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const originalPromiseAll = Promise.all;
-            Promise.all = jest.fn().mockResolvedValue([
-                { name: 'github', status: 'healthy', reachable: true, statusCode: 200, responseTime: 100 },
-                { name: 'npm', status: 'healthy', reachable: true, statusCode: 200, responseTime: 150 }
-            ]);
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/detailed'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-            
-            Promise.all = originalPromiseAll;
-
-            expect(res.status).toHaveBeenCalledWith(200);
-            expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
-                status: 'healthy',
-                service: 'frigg-core-api',
-                timestamp: expect.any(String),
-                checks: expect.objectContaining({
-                    database: expect.objectContaining({
-                        status: 'healthy',
-                        state: 'connected'
-                    }),
-                    integrations: expect.objectContaining({
-                        status: 'healthy'
-                    })
-                }),
-                responseTime: expect.any(Number)
-            }));
-
-            const response = res.json.mock.calls[0][0];
-            expect(response).not.toHaveProperty('version');
-            expect(response).not.toHaveProperty('uptime');
-            expect(response.checks).not.toHaveProperty('memory');
-            expect(response.checks.database).not.toHaveProperty('type');
-        });
-
-        it('should return 503 when database is disconnected', async () => {
-            mongoose.connection.readyState = 0;
-
-            const req = mockRequest('/health/detailed', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const originalPromiseAll = Promise.all;
-            Promise.all = jest.fn().mockResolvedValue([
-                { name: 'github', status: 'healthy', reachable: true, statusCode: 200, responseTime: 100 },
-                { name: 'npm', status: 'healthy', reachable: true, statusCode: 200, responseTime: 150 }
-            ]);
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/detailed'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-            
-            Promise.all = originalPromiseAll;
-
-            expect(res.status).toHaveBeenCalledWith(503);
-            expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
-                status: 'unhealthy'
-            }));
-        });
-    });
-
-    describe('GET /health/live', () => {
-        it('should return alive status', async () => {
-            const req = mockRequest('/health/live', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/live'
-            ).route.stack[0].handle;
-
-            routeHandler(req, res);
-
-            expect(res.status).toHaveBeenCalledWith(200);
-            expect(res.json).toHaveBeenCalledWith({
-                status: 'alive',
-                timestamp: expect.any(String)
-            });
-        });
-    });
-
-    describe('GET /health/ready', () => {
-        it('should return ready when all checks pass', async () => {
-            const req = mockRequest('/health/ready', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/ready'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-
-            expect(res.status).toHaveBeenCalledWith(200);
-            expect(res.json).toHaveBeenCalledWith({
-                ready: true,
-                timestamp: expect.any(String),
-                checks: {
-                    database: true,
-                    modules: true
-                }
-            });
-        });
-
-        it('should return 503 when database is not connected', async () => {
-            mongoose.connection.readyState = 0;
-
-            const req = mockRequest('/health/ready', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/ready'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-
-            expect(res.status).toHaveBeenCalledWith(503);
-            expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
-                ready: false
-            }));
-        });
-    });
-});

package/handlers/routers/integration-webhook-routers.test.js

@@ -1,126 +0,0 @@
-jest.mock('../../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-jest.mock('../app-definition-loader', () => {
-    const { IntegrationBase } = require('../../integrations/integration-base');
-
-    class WebhookEnabledIntegration extends IntegrationBase {
-        static Definition = {
-            name: 'webhook-enabled',
-            version: '1.0.0',
-            modules: {},
-            webhooks: true,
-        };
-
-        constructor(params) {
-            super(params);
-            this.queueWebhook = jest.fn().mockResolvedValue('message-id');
-        }
-    }
-
-    class AdvancedWebhookIntegration extends IntegrationBase {
-        static Definition = {
-            name: 'advanced-webhook',
-            version: '1.0.0',
-            modules: {},
-            webhooks: {
-                enabled: true,
-            },
-        };
-
-        constructor(params) {
-            super(params);
-            this.events = {
-                WEBHOOK_RECEIVED: {
-                    handler: async ({ req, res }) => {
-                        // Custom signature verification
-                        const signature = req.headers['x-webhook-signature'];
-                        if (signature !== 'valid-signature') {
-                            return res.status(401).json({ error: 'Invalid signature' });
-                        }
-                        await this.queueWebhook({ body: req.body });
-                        res.status(200).json({ verified: true });
-                    },
-                },
-            };
-            this.queueWebhook = jest.fn().mockResolvedValue('message-id');
-        }
-    }
-
-    class NoWebhookIntegration extends IntegrationBase {
-        static Definition = {
-            name: 'no-webhook',
-            version: '1.0.0',
-            modules: {},
-        };
-    }
-
-    return {
-        loadAppDefinition: () => ({
-            integrations: [
-                WebhookEnabledIntegration,
-                AdvancedWebhookIntegration,
-                NoWebhookIntegration,
-            ],
-        }),
-    };
-});
-
-describe('Integration Webhook Routers', () => {
-    let handlers;
-
-    beforeEach(() => {
-        // Clear module cache to get fresh handlers
-        jest.resetModules();
-        jest.clearAllMocks();
-
-        // Re-require after mocking
-        handlers = require('./integration-webhook-routers').handlers;
-    });
-
-    describe('Handler Creation', () => {
-        it('should create webhook handlers for integrations with webhooks: true', () => {
-            expect(handlers['webhook-enabledWebhook']).toBeDefined();
-            expect(handlers['webhook-enabledWebhook'].handler).toBeDefined();
-        });
-
-        it('should create webhook handlers for integrations with webhooks.enabled: true', () => {
-            expect(handlers['advanced-webhookWebhook']).toBeDefined();
-            expect(handlers['advanced-webhookWebhook'].handler).toBeDefined();
-        });
-
-        it('should not create webhook handlers for integrations without webhooks', () => {
-            expect(handlers['no-webhookWebhook']).toBeUndefined();
-        });
-
-        it('should configure handlers to not use database connection', () => {
-            // Handlers are created with createAppHandler(..., false)
-            // This means shouldUseDatabase = false
-            // Actual behavior is tested in integration tests
-            expect(handlers['webhook-enabledWebhook']).toBeDefined();
-            expect(handlers['advanced-webhookWebhook']).toBeDefined();
-        });
-    });
-
-    describe('Webhook Configuration', () => {
-        it('should support boolean webhook configuration', () => {
-            // webhooks: true should enable webhook handling
-            expect(handlers['webhook-enabledWebhook']).toBeDefined();
-        });
-
-        it('should support object webhook configuration', () => {
-            // webhooks: { enabled: true } should enable webhook handling
-            expect(handlers['advanced-webhookWebhook']).toBeDefined();
-        });
-
-        it('should skip integrations with webhooks disabled', () => {
-            // webhooks: false or missing should not create handlers
-            expect(handlers['no-webhookWebhook']).toBeUndefined();
-        });
-    });
-});
-

package/handlers/use-cases/check-integrations-health-use-case.test.js

@@ -1,125 +0,0 @@
-/**
- * Tests for CheckIntegrationsHealthUseCase
- * 
- * Tests integration and module factory health checking
- */
-
-const { CheckIntegrationsHealthUseCase } = require('./check-integrations-health-use-case');
-
-describe('CheckIntegrationsHealthUseCase', () => {
-    describe('execute()', () => {
-        it('should return healthy status with module and integration counts', () => {
-            const mockModuleFactory = {
-                moduleDefinitions: [
-                    { moduleName: 'HubSpot' },
-                    { moduleName: 'Salesforce' },
-                    { moduleName: 'Slack' },
-                ],
-            };
-
-            const mockIntegrationClasses = [
-                { Definition: { name: 'HubSpot-to-Salesforce' } },
-                { Definition: { name: 'Slack-Notifications' } },
-            ];
-
-            const useCase = new CheckIntegrationsHealthUseCase({
-                moduleFactory: mockModuleFactory,
-                integrationClasses: mockIntegrationClasses,
-            });
-
-            const result = useCase.execute();
-
-            expect(result.status).toBe('healthy');
-            expect(result.modules.count).toBe(3);
-            expect(result.modules.available).toEqual(['HubSpot', 'Salesforce', 'Slack']);
-            expect(result.integrations.count).toBe(2);
-            expect(result.integrations.available).toEqual(['HubSpot-to-Salesforce', 'Slack-Notifications']);
-        });
-
-        it('should handle undefined moduleFactory gracefully', () => {
-            const mockIntegrationClasses = [
-                { Definition: { name: 'Integration1' } },
-            ];
-
-            const useCase = new CheckIntegrationsHealthUseCase({
-                moduleFactory: undefined,
-                integrationClasses: mockIntegrationClasses,
-            });
-
-            const result = useCase.execute();
-
-            expect(result.status).toBe('healthy');
-            expect(result.modules.count).toBe(0);
-            expect(result.modules.available).toEqual([]);
-            expect(result.integrations.count).toBe(1);
-        });
-
-        it('should handle undefined integrationClasses gracefully', () => {
-            const mockModuleFactory = {
-                moduleDefinitions: [{ moduleName: 'Module1' }],
-            };
-
-            const useCase = new CheckIntegrationsHealthUseCase({
-                moduleFactory: mockModuleFactory,
-                integrationClasses: undefined,
-            });
-
-            const result = useCase.execute();
-
-            expect(result.status).toBe('healthy');
-            expect(result.modules.count).toBe(1);
-            expect(result.integrations.count).toBe(0);
-            expect(result.integrations.available).toEqual([]);
-        });
-
-        it('should handle both moduleFactory and integrationClasses being undefined', () => {
-            const useCase = new CheckIntegrationsHealthUseCase({
-                moduleFactory: undefined,
-                integrationClasses: undefined,
-            });
-
-            const result = useCase.execute();
-
-            expect(result.status).toBe('healthy');
-            expect(result.modules.count).toBe(0);
-            expect(result.modules.available).toEqual([]);
-            expect(result.integrations.count).toBe(0);
-            expect(result.integrations.available).toEqual([]);
-        });
-
-        it('should handle non-array moduleDefinitions', () => {
-            const mockModuleFactory = {
-                moduleDefinitions: 'not-an-array',
-            };
-
-            const useCase = new CheckIntegrationsHealthUseCase({
-                moduleFactory: mockModuleFactory,
-                integrationClasses: [],
-            });
-
-            const result = useCase.execute();
-
-            expect(result.status).toBe('healthy');
-            expect(result.modules.count).toBe(0);
-            expect(result.modules.available).toEqual([]);
-        });
-
-        it('should handle moduleFactory with missing moduleDefinitions property', () => {
-            const mockModuleFactory = {}; // No moduleDefinitions property
-
-            const useCase = new CheckIntegrationsHealthUseCase({
-                moduleFactory: mockModuleFactory,
-                integrationClasses: [],
-            });
-
-            const result = useCase.execute();
-
-            expect(result.status).toBe('healthy');
-            expect(result.modules.count).toBe(0);
-            expect(result.modules.available).toEqual([]);
-            expect(result.integrations.count).toBe(0);
-            expect(result.integrations.available).toEqual([]);
-        });
-    });
-});
-