bxo 0.0.5-dev.51 → 0.0.5-dev.52

package/tests/unit/utils.test.ts

@@ -0,0 +1,310 @@
+import { describe, it, expect } from 'bun:test';
+import {
+  parseQuery,
+  parseHeaders,
+  parseCookies,
+  validateData,
+  validateResponse,
+  cookiesToHeaders,
+  mergeHeadersWithCookies,
+  createRedirectResponse,
+  isFileUpload,
+  getFileFromUpload,
+  getFileInfo,
+  getFileUploads,
+  getFormFields
+} from '../../src/utils';
+import { z } from 'zod';
+
+describe('Utility Functions', () => {
+  describe('parseQuery', () => {
+    it('should parse URLSearchParams correctly', () => {
+      const searchParams = new URLSearchParams('name=john&age=25&city=new%20york');
+      const result = parseQuery(searchParams);
+      
+      expect(result).toEqual({
+        name: 'john',
+        age: '25',
+        city: 'new york'
+      });
+    });
+
+    it('should handle empty search params', () => {
+      const searchParams = new URLSearchParams('');
+      const result = parseQuery(searchParams);
+      
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('parseHeaders', () => {
+    it('should parse Headers object correctly', () => {
+      const headers = new Headers();
+      headers.set('content-type', 'application/json');
+      headers.set('authorization', 'Bearer token123');
+      
+      const result = parseHeaders(headers);
+      
+      expect(result).toEqual({
+        'content-type': 'application/json',
+        'authorization': 'Bearer token123'
+      });
+    });
+  });
+
+  describe('parseCookies', () => {
+    it('should parse cookie header correctly', () => {
+      const cookieHeader = 'name=john; age=25; city=new%20york';
+      const result = parseCookies(cookieHeader);
+      
+      expect(result).toEqual({
+        name: 'john',
+        age: '25',
+        city: 'new york'
+      });
+    });
+
+    it('should handle null cookie header', () => {
+      const result = parseCookies(null);
+      expect(result).toEqual({});
+    });
+
+    it('should handle empty cookie header', () => {
+      const result = parseCookies('');
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('validateData', () => {
+    it('should validate data with schema', () => {
+      const schema = z.object({
+        name: z.string(),
+        age: z.number()
+      });
+      
+      const data = { name: 'john', age: 25 };
+      const result = validateData(schema, data);
+      
+      expect(result).toEqual(data);
+    });
+
+    it('should return data without validation when no schema', () => {
+      const data = { name: 'john', age: 25 };
+      const result = validateData(undefined, data);
+      
+      expect(result).toEqual(data);
+    });
+
+    it('should throw error for invalid data', () => {
+      const schema = z.object({
+        name: z.string(),
+        age: z.number()
+      });
+      
+      const data = { name: 'john', age: 'invalid' };
+      
+      expect(() => validateData(schema, data)).toThrow();
+    });
+  });
+
+  describe('validateResponse', () => {
+    it('should validate response with simple schema', () => {
+      const schema = z.object({
+        message: z.string()
+      });
+      
+      const data = { message: 'success' };
+      const result = validateResponse(schema, data);
+      
+      expect(result).toEqual(data);
+    });
+
+    it('should validate response with status-based schema', () => {
+      const schema = {
+        200: z.object({ message: z.string() }),
+        400: z.object({ error: z.string() })
+      };
+      
+      const data = { message: 'success' };
+      const result = validateResponse(schema, data, 200);
+      
+      expect(result).toEqual(data);
+    });
+
+    it('should return data without validation when no schema', () => {
+      const data = { message: 'success' };
+      const result = validateResponse(undefined, data);
+      
+      expect(result).toEqual(data);
+    });
+  });
+
+  describe('cookiesToHeaders', () => {
+    it('should convert internal cookies to header strings', () => {
+      const cookies = [
+        {
+          name: 'session',
+          value: 'abc123',
+          domain: 'example.com',
+          path: '/',
+          secure: true,
+          httpOnly: true
+        }
+      ];
+      
+      const result = cookiesToHeaders(cookies);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]).toContain('session=abc123');
+      expect(result[0]).toContain('Domain=example.com');
+      expect(result[0]).toContain('Path=/');
+      expect(result[0]).toContain('Secure');
+      expect(result[0]).toContain('HttpOnly');
+    });
+  });
+
+  describe('mergeHeadersWithCookies', () => {
+    it('should merge headers with cookies', () => {
+      const headers = { 'content-type': 'application/json' };
+      const cookies = [
+        { name: 'session', value: 'abc123' }
+      ];
+      
+      const result = mergeHeadersWithCookies(headers, cookies);
+      
+      expect(result.get('content-type')).toBe('application/json');
+      expect(result.get('set-cookie')).toBe('session=abc123');
+    });
+  });
+
+  describe('createRedirectResponse', () => {
+    it('should create redirect response with default status', () => {
+      const result = createRedirectResponse('/new-location');
+      
+      expect(result.status).toBe(302);
+      expect(result.headers.get('location')).toBe('/new-location');
+    });
+
+    it('should create redirect response with custom status', () => {
+      const result = createRedirectResponse('/new-location', 301);
+      
+      expect(result.status).toBe(301);
+      expect(result.headers.get('location')).toBe('/new-location');
+    });
+
+    it('should include additional headers', () => {
+      const headers = { 'x-custom': 'value' };
+      const result = createRedirectResponse('/new-location', 302, headers);
+      
+      expect(result.headers.get('x-custom')).toBe('value');
+    });
+  });
+
+  describe('File Upload Utilities', () => {
+    it('should identify file uploads correctly', () => {
+      const fileUpload = {
+        type: 'file',
+        name: 'test.jpg',
+        size: 1024,
+        lastModified: 1234567890,
+        file: new File(['test'], 'test.jpg'),
+        filename: 'test.jpg',
+        mimetype: 'image/jpeg'
+      };
+      
+      expect(isFileUpload(fileUpload)).toBe(true);
+      expect(isFileUpload('not a file')).toBe(false);
+      expect(isFileUpload({ type: 'text' })).toBe(false);
+    });
+
+    it('should extract file from upload', () => {
+      const file = new File(['test'], 'test.jpg');
+      const fileUpload = {
+        type: 'file',
+        name: 'test.jpg',
+        size: 1024,
+        lastModified: 1234567890,
+        file,
+        filename: 'test.jpg',
+        mimetype: 'image/jpeg'
+      };
+      
+      const result = getFileFromUpload(fileUpload);
+      expect(result).toBe(file);
+    });
+
+    it('should return null for non-file uploads', () => {
+      const result = getFileFromUpload('not a file');
+      expect(result).toBeNull();
+    });
+
+    it('should get file info', () => {
+      const fileUpload = {
+        type: 'file',
+        name: 'test.jpg',
+        size: 1024,
+        lastModified: 1234567890,
+        file: new File(['test'], 'test.jpg'),
+        filename: 'test.jpg',
+        mimetype: 'image/jpeg'
+      };
+      
+      const result = getFileInfo(fileUpload);
+      expect(result).toEqual({
+        name: 'test.jpg',
+        size: 1024,
+        mimetype: 'image/jpeg',
+        lastModified: 1234567890
+      });
+    });
+
+    it('should return null for non-file uploads when getting info', () => {
+      const result = getFileInfo('not a file');
+      expect(result).toBeNull();
+    });
+
+    it('should get all file uploads from form data', () => {
+      const formData = {
+        name: 'john',
+        avatar: {
+          type: 'file',
+          name: 'avatar.jpg',
+          size: 1024,
+          lastModified: 1234567890,
+          file: new File(['test'], 'avatar.jpg'),
+          filename: 'avatar.jpg',
+          mimetype: 'image/jpeg'
+        },
+        email: 'john@example.com'
+      };
+      
+      const result = getFileUploads(formData);
+      
+      expect(Object.keys(result)).toHaveLength(1);
+      expect(result.avatar).toBeInstanceOf(File);
+    });
+
+    it('should get all non-file fields from form data', () => {
+      const formData = {
+        name: 'john',
+        avatar: {
+          type: 'file',
+          name: 'avatar.jpg',
+          size: 1024,
+          lastModified: 1234567890,
+          file: new File(['test'], 'avatar.jpg'),
+          filename: 'avatar.jpg',
+          mimetype: 'image/jpeg'
+        },
+        email: 'john@example.com'
+      };
+      
+      const result = getFormFields(formData);
+      
+      expect(result).toEqual({
+        name: 'john',
+        email: 'john@example.com'
+      });
+    });
+  });
+});