lambder 1.0.147 → 2.0.2

package/tests/hooks.test.ts

@@ -0,0 +1,561 @@
+/**
+ * Hooks System Tests
+ * 
+ * Tests for the hooks system including:
+ * - beforeRender hook execution
+ * - afterRender hook execution
+ * - fallback hook execution
+ * - created hook execution
+ * - Hook priority ordering
+ * - Multiple hooks of same type
+ * - Hook error handling
+ * - Context modification in hooks
+ * - Response modification in hooks
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { z } from 'zod';
+import Lambder from '../src/Lambder.js';
+import type { APIGatewayProxyEvent, Context } from 'aws-lambda';
+
+const createMockEvent = (path: string, method: string = 'GET', apiName?: string, payload?: any): APIGatewayProxyEvent => ({
+    body: apiName ? JSON.stringify({ apiName, payload }) : null,
+    headers: { Host: 'localhost' },
+    multiValueHeaders: {},
+    httpMethod: method,
+    isBase64Encoded: false,
+    path: apiName ? '/api' : path,
+    pathParameters: null,
+    queryStringParameters: null,
+    multiValueQueryStringParameters: null,
+    stageVariables: null,
+    requestContext: {} as any,
+    resource: '',
+});
+
+const createMockContext = (): Context => ({
+    callbackWaitsForEmptyEventLoop: false,
+    functionName: 'test',
+    functionVersion: '1',
+    invokedFunctionArn: 'arn',
+    memoryLimitInMB: '128',
+    awsRequestId: '123',
+    logGroupName: 'group',
+    logStreamName: 'stream',
+    getRemainingTimeInMillis: () => 1000,
+    done: () => {},
+    fail: () => {},
+    succeed: () => {},
+});
+
+describe('Hooks - beforeRender Hook', () => {
+    it('should execute beforeRender hook before route handler', async () => {
+        const executionOrder: string[] = [];
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            executionOrder.push('beforeRender');
+            return ctx;
+        });
+
+        lambder.addRoute('/test', (ctx, res) => {
+            executionOrder.push('routeHandler');
+            return res.html('Test');
+        });
+
+        const handler = lambder.getHandler();
+        await handler(createMockEvent('/test'), createMockContext());
+
+        expect(executionOrder).toEqual(['beforeRender', 'routeHandler']);
+    });
+
+    it('should allow context modification in beforeRender', async () => {
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            // Add custom property to context
+            (ctx as any).customData = 'modified';
+            return ctx;
+        });
+
+        lambder.addRoute('/test', (ctx, res) => {
+            return res.json({ data: (ctx as any).customData });
+        });
+
+        const handler = lambder.getHandler();
+        const result = await handler(createMockEvent('/test'), createMockContext());
+
+        const body = JSON.parse(result.body || '{}');
+        expect(body.data).toBe('modified');
+    });
+
+    it('should execute multiple beforeRender hooks', async () => {
+        const executionOrder: number[] = [];
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            executionOrder.push(1);
+            return ctx;
+        });
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            executionOrder.push(2);
+            return ctx;
+        });
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            executionOrder.push(3);
+            return ctx;
+        });
+
+        lambder.addRoute('/test', (ctx, res) => res.html('Test'));
+
+        const handler = lambder.getHandler();
+        await handler(createMockEvent('/test'), createMockContext());
+
+        expect(executionOrder).toEqual([1, 2, 3]);
+    });
+
+    it('should stop execution if beforeRender returns Error', async () => {
+        let routeHandlerCalled = false;
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        })
+            .setGlobalErrorHandler((err, ctx, res) => {
+                return res.raw({ statusCode: 403, body: err.message });
+            });
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            return new Error('Access Denied');
+        });
+
+        lambder.addRoute('/test', (ctx, res) => {
+            routeHandlerCalled = true;
+            return res.html('Test');
+        });
+
+        const handler = lambder.getHandler();
+        const result = await handler(createMockEvent('/test'), createMockContext());
+
+        expect(result.statusCode).toBe(403);
+        expect(result.body).toBe('Access Denied');
+        expect(routeHandlerCalled).toBe(false);
+    });
+});
+
+describe('Hooks - afterRender Hook', () => {
+    it('should execute afterRender hook after route handler', async () => {
+        const executionOrder: string[] = [];
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        lambder.addRoute('/test', (ctx, res) => {
+            executionOrder.push('routeHandler');
+            return res.html('Test');
+        });
+
+        await lambder.addHook('afterRender', async (ctx, res, response) => {
+            executionOrder.push('afterRender');
+            return response;
+        });
+
+        const handler = lambder.getHandler();
+        await handler(createMockEvent('/test'), createMockContext());
+
+        expect(executionOrder).toEqual(['routeHandler', 'afterRender']);
+    });
+
+    it('should allow response modification in afterRender', async () => {
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        lambder.addRoute('/test', (ctx, res) => {
+            return res.json({ original: true });
+        });
+
+        await lambder.addHook('afterRender', async (ctx, res, response) => {
+            // Modify response body
+            const body = JSON.parse(response.body || '{}');
+            body.modified = true;
+            response.body = JSON.stringify(body);
+            return response;
+        });
+
+        const handler = lambder.getHandler();
+        const result = await handler(createMockEvent('/test'), createMockContext());
+
+        const body = JSON.parse(result.body || '{}');
+        expect(body.original).toBe(true);
+        expect(body.modified).toBe(true);
+    });
+
+    it('should execute multiple afterRender hooks', async () => {
+        const executionOrder: number[] = [];
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        lambder.addRoute('/test', (ctx, res) => res.html('Test'));
+
+        await lambder.addHook('afterRender', async (ctx, res, response) => {
+            executionOrder.push(1);
+            return response;
+        });
+
+        await lambder.addHook('afterRender', async (ctx, res, response) => {
+            executionOrder.push(2);
+            return response;
+        });
+
+        await lambder.addHook('afterRender', async (ctx, res, response) => {
+            executionOrder.push(3);
+            return response;
+        });
+
+        const handler = lambder.getHandler();
+        await handler(createMockEvent('/test'), createMockContext());
+
+        expect(executionOrder).toEqual([1, 2, 3]);
+    });
+
+    it('should add custom headers in afterRender', async () => {
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        lambder.addRoute('/test', (ctx, res) => res.json({ data: 'test' }));
+
+        await lambder.addHook('afterRender', async (ctx, res, response) => {
+            response.multiValueHeaders = response.multiValueHeaders || {};
+            response.multiValueHeaders['X-Custom-Header'] = ['CustomValue'];
+            return response;
+        });
+
+        const handler = lambder.getHandler();
+        const result = await handler(createMockEvent('/test'), createMockContext());
+
+        expect(result.multiValueHeaders?.['X-Custom-Header']).toEqual(['CustomValue']);
+    });
+
+    it('should stop execution if afterRender returns Error', async () => {
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        })
+            .setGlobalErrorHandler((err, ctx, res) => {
+                return res.raw({ statusCode: 500, body: `Error: ${err.message}` });
+            });
+
+        lambder.addRoute('/test', (ctx, res) => res.html('Test'));
+
+        await lambder.addHook('afterRender', async (ctx, res, response) => {
+            return new Error('Post-processing failed');
+        });
+
+        const handler = lambder.getHandler();
+        const result = await handler(createMockEvent('/test'), createMockContext());
+
+        expect(result.statusCode).toBe(500);
+        expect(result.body).toContain('Post-processing failed');
+    });
+});
+
+describe('Hooks - fallback Hook', () => {
+    it('should execute fallback hook when no route matches', async () => {
+        let fallbackCalled = false;
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        lambder.addRoute('/exists', (ctx, res) => res.html('Exists'));
+
+        await lambder.addHook('fallback', async (ctx, res) => {
+            fallbackCalled = true;
+        });
+
+        lambder.setRouteFallbackHandler((ctx, res) => {
+            return res.status404('Not Found');
+        });
+
+        const handler = lambder.getHandler();
+        await handler(createMockEvent('/nonexistent'), createMockContext());
+
+        expect(fallbackCalled).toBe(true);
+    });
+
+    it('should execute multiple fallback hooks', async () => {
+        const executionOrder: number[] = [];
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        await lambder.addHook('fallback', async (ctx, res) => {
+            executionOrder.push(1);
+        });
+
+        await lambder.addHook('fallback', async (ctx, res) => {
+            executionOrder.push(2);
+        });
+
+        lambder.setRouteFallbackHandler((ctx, res) => res.status404('Not Found'));
+
+        const handler = lambder.getHandler();
+        await handler(createMockEvent('/nonexistent'), createMockContext());
+
+        expect(executionOrder).toEqual([1, 2]);
+    });
+
+    it('should not execute fallback hook when route matches', async () => {
+        let fallbackCalled = false;
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        lambder.addRoute('/test', (ctx, res) => res.html('Test'));
+
+        await lambder.addHook('fallback', async (ctx, res) => {
+            fallbackCalled = true;
+        });
+
+        const handler = lambder.getHandler();
+        await handler(createMockEvent('/test'), createMockContext());
+
+        expect(fallbackCalled).toBe(false);
+    });
+});
+
+describe('Hooks - created Hook', () => {
+    it('should execute created hook immediately', async () => {
+        let createdCalled = false;
+        let lambderInstance: Lambder | null = null;
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        await lambder.addHook('created', async (instance) => {
+            createdCalled = true;
+            lambderInstance = instance;
+        });
+
+        expect(createdCalled).toBe(true);
+        expect(lambderInstance).toBe(lambder);
+    });
+
+    it('should allow configuration in created hook', async () => {
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        await lambder.addHook('created', async (instance) => {
+            instance.enableCors(true);
+        });
+
+        expect(lambder.isCorsEnabled).toBe(true);
+    });
+});
+
+describe('Hooks - Priority Ordering', () => {
+    it('should execute beforeRender hooks in priority order', async () => {
+        const executionOrder: number[] = [];
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            executionOrder.push(20);
+            return ctx;
+        }, 20);
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            executionOrder.push(10);
+            return ctx;
+        }, 10);
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            executionOrder.push(30);
+            return ctx;
+        }, 30);
+
+        lambder.addRoute('/test', (ctx, res) => res.html('Test'));
+
+        const handler = lambder.getHandler();
+        await handler(createMockEvent('/test'), createMockContext());
+
+        // Should execute in priority order: 10, 20, 30
+        expect(executionOrder).toEqual([10, 20, 30]);
+    });
+
+    it('should execute afterRender hooks in priority order', async () => {
+        const executionOrder: number[] = [];
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        lambder.addRoute('/test', (ctx, res) => res.html('Test'));
+
+        await lambder.addHook('afterRender', async (ctx, res, response) => {
+            executionOrder.push(50);
+            return response;
+        }, 50);
+
+        await lambder.addHook('afterRender', async (ctx, res, response) => {
+            executionOrder.push(5);
+            return response;
+        }, 5);
+
+        await lambder.addHook('afterRender', async (ctx, res, response) => {
+            executionOrder.push(25);
+            return response;
+        }, 25);
+
+        const handler = lambder.getHandler();
+        await handler(createMockEvent('/test'), createMockContext());
+
+        expect(executionOrder).toEqual([5, 25, 50]);
+    });
+
+    it('should use priority 0 as default', async () => {
+        const executionOrder: string[] = [];
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            executionOrder.push('no-priority');
+            return ctx;
+        }); // No priority specified, defaults to 0
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            executionOrder.push('negative');
+            return ctx;
+        }, -10);
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            executionOrder.push('positive');
+            return ctx;
+        }, 10);
+
+        lambder.addRoute('/test', (ctx, res) => res.html('Test'));
+
+        const handler = lambder.getHandler();
+        await handler(createMockEvent('/test'), createMockContext());
+
+        expect(executionOrder).toEqual(['negative', 'no-priority', 'positive']);
+    });
+});
+
+describe('Hooks - Combined Workflow', () => {
+    it('should execute hooks in correct order: beforeRender -> handler -> afterRender', async () => {
+        const executionOrder: string[] = [];
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            executionOrder.push('before-1');
+            return ctx;
+        });
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            executionOrder.push('before-2');
+            return ctx;
+        });
+
+        lambder.addRoute('/test', (ctx, res) => {
+            executionOrder.push('handler');
+            return res.html('Test');
+        });
+
+        await lambder.addHook('afterRender', async (ctx, res, response) => {
+            executionOrder.push('after-1');
+            return response;
+        });
+
+        await lambder.addHook('afterRender', async (ctx, res, response) => {
+            executionOrder.push('after-2');
+            return response;
+        });
+
+        const handler = lambder.getHandler();
+        await handler(createMockEvent('/test'), createMockContext());
+
+        expect(executionOrder).toEqual([
+            'before-1',
+            'before-2',
+            'handler',
+            'after-1',
+            'after-2'
+        ]);
+    });
+
+    it('should work with API handlers', async () => {
+        const executionOrder: string[] = [];
+
+        const lambder = new Lambder({
+            publicPath: './public',
+            apiPath: '/api'
+        });
+
+        await lambder.addHook('beforeRender', async (ctx, res) => {
+            executionOrder.push('beforeRender');
+            return ctx;
+        });
+
+        lambder.addApi('testApi', {
+            input: z.object({ value: z.string() }),
+            output: z.object({ result: z.string() })
+        }, async (ctx, res) => {
+            executionOrder.push('apiHandler');
+            return res.api({ result: ctx.apiPayload.value });
+        });
+
+        await lambder.addHook('afterRender', async (ctx, res, response) => {
+            executionOrder.push('afterRender');
+            return response;
+        });
+
+        const handler = lambder.getHandler();
+        const event = createMockEvent('/api', 'POST', 'testApi', { value: 'test' });
+        await handler(event, createMockContext());
+
+        expect(executionOrder).toEqual(['beforeRender', 'apiHandler', 'afterRender']);
+    });
+});