bxo 0.0.5-dev.50 → 0.0.5-dev.52

package/tests/unit/context-factory.test.ts

@@ -0,0 +1,386 @@
+import { describe, it, expect, beforeEach } from 'bun:test';
+import { createContext, createOptionsContext, getInternalCookies } from '../../src/utils/context-factory';
+import { z } from 'zod';
+
+describe('Context Factory', () => {
+  let mockRequest: Request;
+  let mockRouteConfig: any;
+
+  beforeEach(() => {
+    mockRequest = new Request('http://localhost:3000/test');
+    mockRouteConfig = {
+      params: z.object({ id: z.string() }),
+      query: z.object({ page: z.string().optional() }),
+      body: z.object({ name: z.string() }),
+      headers: z.object({ 'user-agent': z.string() }),
+      cookies: z.object({ session: z.string() })
+    };
+  });
+
+  describe('createContext', () => {
+    it('should create context with validation enabled', () => {
+      const params = { id: '123' };
+      const query = { page: '1' };
+      const body = { name: 'John' };
+      const headers = { 'user-agent': 'Mozilla/5.0' };
+      const cookies = { session: 'abc123' };
+      const pathname = '/users/123';
+
+      const ctx = createContext(
+        params,
+        query,
+        body,
+        headers,
+        cookies,
+        pathname,
+        mockRequest,
+        mockRouteConfig,
+        true
+      );
+
+      expect(ctx.params).toEqual(params);
+      expect(ctx.query).toEqual(query);
+      expect(ctx.body).toEqual(body);
+      expect(ctx.headers).toEqual(headers);
+      expect(ctx.cookies).toEqual(cookies);
+      expect(ctx.path).toBe(pathname);
+      expect(ctx.request).toBe(mockRequest);
+      expect(ctx.set.status).toBe(200);
+      expect(ctx.set.headers).toEqual({});
+    });
+
+    it('should create context without validation when disabled', () => {
+      const params = { id: '123' };
+      const query = { page: '1' };
+      const body = { name: 'John' };
+      const headers = { 'user-agent': 'Mozilla/5.0' };
+      const cookies = { session: 'abc123' };
+      const pathname = '/users/123';
+
+      const ctx = createContext(
+        params,
+        query,
+        body,
+        headers,
+        cookies,
+        pathname,
+        mockRequest,
+        mockRouteConfig,
+        false
+      );
+
+      expect(ctx.params).toEqual(params);
+      expect(ctx.query).toEqual(query);
+      expect(ctx.body).toEqual(body);
+      expect(ctx.headers).toEqual(headers);
+      expect(ctx.cookies).toEqual(cookies);
+    });
+
+    it('should create context without route config', () => {
+      const params = { id: '123' };
+      const query = { page: '1' };
+      const body = { name: 'John' };
+      const headers = { 'user-agent': 'Mozilla/5.0' };
+      const cookies = { session: 'abc123' };
+      const pathname = '/users/123';
+
+      const ctx = createContext(
+        params,
+        query,
+        body,
+        headers,
+        cookies,
+        pathname,
+        mockRequest,
+        undefined,
+        true
+      );
+
+      expect(ctx.params).toEqual(params);
+      expect(ctx.query).toEqual(query);
+      expect(ctx.body).toEqual(body);
+      expect(ctx.headers).toEqual(headers);
+      expect(ctx.cookies).toEqual(cookies);
+    });
+
+    it('should handle cookie setting', () => {
+      const ctx = createContext(
+        {},
+        {},
+        {},
+        {},
+        {},
+        '/',
+        mockRequest,
+        undefined,
+        true
+      );
+
+      ctx.set.cookies('session', 'abc123', {
+        domain: 'example.com',
+        path: '/',
+        secure: true,
+        httpOnly: true
+      });
+
+      const internalCookies = getInternalCookies(ctx);
+      expect(internalCookies).toHaveLength(1);
+      expect(internalCookies[0]).toEqual({
+        name: 'session',
+        value: 'abc123',
+        domain: 'example.com',
+        path: '/',
+        secure: true,
+        httpOnly: true
+      });
+    });
+
+    it('should handle status setting', () => {
+      const ctx = createContext(
+        {},
+        {},
+        {},
+        {},
+        {},
+        '/',
+        mockRequest,
+        undefined,
+        true
+      );
+
+      ctx.status(404, 'Not Found');
+      expect(ctx.set.status).toBe(404);
+    });
+
+    it('should handle redirect', () => {
+      const ctx = createContext(
+        {},
+        {},
+        {},
+        {},
+        {},
+        '/',
+        mockRequest,
+        undefined,
+        true
+      );
+
+      const response = ctx.redirect('/new-location', 301);
+      
+      expect(response.status).toBe(301);
+      expect(response.headers.get('location')).toBe('/new-location');
+      expect(ctx.set.redirect).toEqual({
+        location: '/new-location',
+        status: 301
+      });
+    });
+
+    it('should handle redirect with cookies', () => {
+      const ctx = createContext(
+        {},
+        {},
+        {},
+        {},
+        {},
+        '/',
+        mockRequest,
+        undefined,
+        true
+      );
+
+      ctx.set.cookies('session', 'abc123');
+      const response = ctx.redirect('/new-location');
+
+      expect(response.status).toBe(302);
+      expect(response.headers.get('location')).toBe('/new-location');
+      expect(response.headers.get('set-cookie')).toBe('session=abc123');
+    });
+
+    it('should handle clearRedirect', () => {
+      const ctx = createContext(
+        {},
+        {},
+        {},
+        {},
+        {},
+        '/',
+        mockRequest,
+        undefined,
+        true
+      );
+
+      ctx.redirect('/new-location');
+      expect(ctx.set.redirect).toBeDefined();
+
+      ctx.clearRedirect();
+      expect(ctx.set.redirect).toBeUndefined();
+    });
+  });
+
+  describe('createOptionsContext', () => {
+    it('should create minimal context for OPTIONS requests', () => {
+      const headers = { 'origin': 'http://localhost:3000' };
+      const pathname = '/api/users';
+
+      const ctx = createOptionsContext(pathname, mockRequest, headers);
+
+      expect(ctx.params).toEqual({});
+      expect(ctx.query).toEqual({});
+      expect(ctx.body).toEqual({});
+      expect(ctx.headers).toEqual(headers);
+      expect(ctx.cookies).toEqual({});
+      expect(ctx.path).toBe(pathname);
+      expect(ctx.request).toBe(mockRequest);
+    });
+
+    it('should handle redirect in options context', () => {
+      const headers = { 'origin': 'http://localhost:3000' };
+      const pathname = '/api/users';
+
+      const ctx = createOptionsContext(pathname, mockRequest, headers);
+      const response = ctx.redirect('/new-location', 301);
+
+      expect(response.status).toBe(301);
+      expect(response.headers.get('location')).toBe('/new-location');
+    });
+  });
+
+  describe('getInternalCookies', () => {
+    it('should return internal cookies from context', () => {
+      const ctx = createContext(
+        {},
+        {},
+        {},
+        {},
+        {},
+        '/',
+        mockRequest,
+        undefined,
+        true
+      );
+
+      ctx.set.cookies('session', 'abc123');
+      ctx.set.cookies('theme', 'dark');
+
+      const internalCookies = getInternalCookies(ctx);
+      expect(internalCookies).toHaveLength(2);
+      expect(internalCookies[0].name).toBe('session');
+      expect(internalCookies[1].name).toBe('theme');
+    });
+
+    it('should return empty array when no cookies set', () => {
+      const ctx = createContext(
+        {},
+        {},
+        {},
+        {},
+        {},
+        '/',
+        mockRequest,
+        undefined,
+        true
+      );
+
+      const internalCookies = getInternalCookies(ctx);
+      expect(internalCookies).toEqual([]);
+    });
+
+    it('should handle context without internal cookies', () => {
+      const ctx = {
+        params: {},
+        query: {},
+        body: {},
+        headers: {},
+        cookies: {},
+        path: '/',
+        request: mockRequest,
+        set: { status: 200, headers: {} }
+      } as any;
+
+      const internalCookies = getInternalCookies(ctx);
+      expect(internalCookies).toEqual([]);
+    });
+  });
+
+  describe('Validation Integration', () => {
+    it('should validate params with schema', () => {
+      const config = {
+        params: z.object({ id: z.string().min(1) })
+      };
+
+      const ctx = createContext(
+        { id: '123' },
+        {},
+        {},
+        {},
+        {},
+        '/users/123',
+        mockRequest,
+        config,
+        true
+      );
+
+      expect(ctx.params.id).toBe('123');
+    });
+
+    it('should throw error for invalid params', () => {
+      const config = {
+        params: z.object({ id: z.string().min(1) })
+      };
+
+      expect(() => {
+        createContext(
+          { id: '' },
+          {},
+          {},
+          {},
+          {},
+          '/users/',
+          mockRequest,
+          config,
+          true
+        );
+      }).toThrow();
+    });
+
+    it('should validate body with schema', () => {
+      const config = {
+        body: z.object({ name: z.string().min(1) })
+      };
+
+      const ctx = createContext(
+        {},
+        {},
+        { name: 'John' },
+        {},
+        {},
+        '/users',
+        mockRequest,
+        config,
+        true
+      );
+
+      expect(ctx.body.name).toBe('John');
+    });
+
+    it('should throw error for invalid body', () => {
+      const config = {
+        body: z.object({ name: z.string().min(1) })
+      };
+
+      expect(() => {
+        createContext(
+          {},
+          {},
+          { name: '' },
+          {},
+          {},
+          '/users',
+          mockRequest,
+          config,
+          true
+        );
+      }).toThrow();
+    });
+  });
+});

package/tests/unit/helpers.test.ts

@@ -0,0 +1,253 @@
+import { describe, it, expect } from 'bun:test';
+import { error, file, redirect, createCookieOptions } from '../../src/utils/helpers';
+
+describe('Helper Functions', () => {
+  describe('error', () => {
+    it('should create error response with Error object', () => {
+      const errorObj = new Error('Something went wrong');
+      const response = error(errorObj, 500);
+
+      expect(response.status).toBe(500);
+      expect(response.headers.get('content-type')).toBe('application/json');
+    });
+
+    it('should create error response with string', () => {
+      const response = error('Custom error message', 400);
+
+      expect(response.status).toBe(400);
+      expect(response.headers.get('content-type')).toBe('application/json');
+    });
+
+    it('should use default status when not provided', () => {
+      const response = error('Error message');
+
+      expect(response.status).toBe(500);
+    });
+
+    it('should serialize error message correctly', async () => {
+      const errorObj = new Error('Test error');
+      const response = error(errorObj, 422);
+
+      const body = await response.json();
+      expect(body.error).toBe('Test error');
+    });
+
+    it('should serialize string message correctly', async () => {
+      const response = error('String error', 400);
+
+      const body = await response.json();
+      expect(body.error).toBe('String error');
+    });
+  });
+
+  describe('file', () => {
+    it('should create file response with default options', () => {
+      const result = file('./test.txt');
+
+      expect(result).toBeDefined();
+      expect(result.size).toBeDefined();
+      expect(result.type).toBeDefined();
+    });
+
+    it('should override MIME type when provided', () => {
+      const result = file('./test.txt', { type: 'text/plain' });
+
+      expect(result.type).toBe('text/plain');
+    });
+
+    it('should include custom headers when provided', () => {
+      const customHeaders = {
+        'x-custom': 'value',
+        'authorization': 'Bearer token'
+      };
+
+      const result = file('./test.txt', { headers: customHeaders });
+
+      expect(result.headers).toEqual(customHeaders);
+    });
+
+    it('should handle both type and headers', () => {
+      const result = file('./test.txt', {
+        type: 'application/json',
+        headers: { 'x-format': 'json' }
+      });
+
+      expect(result.type).toBe('application/json');
+      expect(result.headers).toEqual({ 'x-format': 'json' });
+    });
+
+    it('should preserve original file properties', () => {
+      const result = file('./test.txt');
+
+      // These properties should still exist from the original Bun.file
+      expect(result.stream).toBeDefined();
+      expect(result.size).toBeDefined();
+    });
+  });
+
+  describe('redirect', () => {
+    it('should create redirect response with default status', () => {
+      const response = redirect('/new-location');
+
+      expect(response.status).toBe(302);
+      expect(response.headers.get('location')).toBe('/new-location');
+    });
+
+    it('should create redirect response with custom status', () => {
+      const response = redirect('/new-location', 301);
+
+      expect(response.status).toBe(301);
+      expect(response.headers.get('location')).toBe('/new-location');
+    });
+
+    it('should create redirect response with 307 status', () => {
+      const response = redirect('/new-location', 307);
+
+      expect(response.status).toBe(307);
+      expect(response.headers.get('location')).toBe('/new-location');
+    });
+
+    it('should handle relative URLs', () => {
+      const response = redirect('../parent');
+
+      expect(response.status).toBe(302);
+      expect(response.headers.get('location')).toBe('../parent');
+    });
+
+    it('should handle absolute URLs', () => {
+      const response = redirect('https://example.com');
+
+      expect(response.status).toBe(302);
+      expect(response.headers.get('location')).toBe('https://example.com');
+    });
+
+    it('should handle root path', () => {
+      const response = redirect('/');
+
+      expect(response.status).toBe(302);
+      expect(response.headers.get('location')).toBe('/');
+    });
+
+    it('should handle empty path', () => {
+      const response = redirect('', 301);
+
+      expect(response.status).toBe(301);
+      expect(response.headers.get('location')).toBe('');
+    });
+  });
+
+  describe('createCookieOptions', () => {
+    it('should create cookie options with default values', () => {
+      const options = createCookieOptions();
+
+      expect(options).toEqual({});
+    });
+
+    it('should preserve provided cookie options', () => {
+      const providedOptions = {
+        domain: 'example.com',
+        path: '/',
+        secure: true,
+        httpOnly: true,
+        sameSite: 'Strict' as const
+      };
+
+      const options = createCookieOptions(providedOptions);
+
+      expect(options).toEqual(providedOptions);
+    });
+
+    it('should handle partial cookie options', () => {
+      const providedOptions = {
+        secure: true,
+        httpOnly: true
+      };
+
+      const options = createCookieOptions(providedOptions);
+
+      expect(options).toEqual(providedOptions);
+      expect(options.domain).toBeUndefined();
+      expect(options.path).toBeUndefined();
+    });
+
+    it('should handle cookie options with dates', () => {
+      const expires = new Date('2024-12-31');
+      const providedOptions = {
+        expires,
+        maxAge: 3600
+      };
+
+      const options = createCookieOptions(providedOptions);
+
+      expect(options.expires).toBe(expires);
+      expect(options.maxAge).toBe(3600);
+    });
+
+    it('should handle cookie options with boolean values', () => {
+      const providedOptions = {
+        secure: true,
+        httpOnly: false
+      };
+
+      const options = createCookieOptions(providedOptions);
+
+      expect(options.secure).toBe(true);
+      expect(options.httpOnly).toBe(false);
+    });
+
+    it('should handle sameSite values', () => {
+      const strictOptions = createCookieOptions({ sameSite: 'Strict' });
+      const laxOptions = createCookieOptions({ sameSite: 'Lax' });
+      const noneOptions = createCookieOptions({ sameSite: 'None' });
+
+      expect(strictOptions.sameSite).toBe('Strict');
+      expect(laxOptions.sameSite).toBe('Lax');
+      expect(noneOptions.sameSite).toBe('None');
+    });
+  });
+
+  describe('Integration', () => {
+    it('should work together in typical scenarios', () => {
+      // Simulate a typical error handling scenario
+      const errorResponse = error('User not found', 404);
+      expect(errorResponse.status).toBe(404);
+
+      // Simulate a typical redirect scenario
+      const redirectResponse = redirect('/login', 302);
+      expect(redirectResponse.status).toBe(302);
+
+      // Simulate a typical file serving scenario
+      const fileResponse = file('./public/avatar.jpg', { type: 'image/jpeg' });
+      expect(fileResponse.type).toBe('image/jpeg');
+
+      // Simulate a typical cookie scenario
+      const cookieOptions = createCookieOptions({
+        secure: true,
+        httpOnly: true,
+        sameSite: 'Strict'
+      });
+      expect(cookieOptions.secure).toBe(true);
+    });
+
+    it('should handle edge cases gracefully', () => {
+      // Error with empty string
+      const emptyError = error('', 400);
+      expect(emptyError.status).toBe(400);
+
+      // Redirect with special characters
+      const specialRedirect = redirect('/path/with%20spaces', 301);
+      expect(specialRedirect.headers.get('location')).toBe('/path/with%20spaces');
+
+      // File with empty path
+      const emptyFile = file('');
+      expect(emptyFile).toBeDefined();
+
+      // Cookie options with undefined values
+      const undefinedOptions = createCookieOptions({
+        domain: undefined,
+        path: undefined
+      });
+      expect(undefinedOptions.domain).toBeUndefined();
+    });
+  });
+});