bxo 0.0.5-dev.6 → 0.0.5-dev.61

package/tests/integration/bxo.test.ts

@@ -0,0 +1,598 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'bun:test';
+import BXO, { z } from '../../src/index';
+
+describe('BXO Framework Integration', () => {
+  let app: BXO;
+  let baseUrl: string;
+
+  beforeAll(() => {
+    app = new BXO();
+    baseUrl = 'http://localhost:3001';
+  });
+
+  afterEach(async () => {
+    if (app.isServerRunning()) {
+      await app.stop();
+    }
+  });
+
+  afterAll(async () => {
+    if (app.isServerRunning()) {
+      await app.stop();
+    }
+  });
+
+  describe('Basic Routing', () => {
+    it('should handle GET requests', async () => {
+      app.get('/test-get', () => {
+        return { message: 'GET successful' };
+      });
+
+      await app.start(3001);
+
+      const response = await fetch(`${baseUrl}/test-get`);
+      const data = await response.json() as { message: string };
+
+      expect(response.status).toBe(200);
+      expect(data.message).toBe('GET successful');
+    });
+
+    it('should handle POST requests', async () => {
+      app.post('/test-post', (ctx) => {
+        return { message: 'POST successful', body: ctx.body };
+      });
+
+      const response = await fetch(`${baseUrl}/test-post`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ test: 'data' })
+      });
+
+      const data = await response.json() as { message: string, body: { test: string } };
+
+      expect(response.status).toBe(200);
+      expect(data.message).toBe('POST successful');
+      expect(data.body.test).toBe('data');
+    });
+
+    it('should handle PUT requests', async () => {
+      app.put('/test-put', (ctx) => {
+        return { message: 'PUT successful', body: ctx.body };
+      });
+
+      const response = await fetch(`${baseUrl}/test-put`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ test: 'data' })
+      });
+
+      const data = await response.json() as { message: string };
+
+      expect(response.status).toBe(200);
+      expect(data.message).toBe('PUT successful');
+    });
+
+    it('should handle DELETE requests', async () => {
+      app.delete('/test-delete', () => {
+        return { message: 'DELETE successful' };
+      });
+
+      const response = await fetch(`${baseUrl}/test-delete`, {
+        method: 'DELETE'
+      });
+
+      const data = await response.json() as { message: string };
+
+      expect(response.status).toBe(200);
+      expect(data.message).toBe('DELETE successful');
+    });
+
+    it('should handle PATCH requests', async () => {
+      app.patch('/test-patch', (ctx) => {
+        return { message: 'PATCH successful', body: ctx.body };
+      });
+
+      const response = await fetch(`${baseUrl}/test-patch`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ test: 'data' })
+      });
+
+      const data = await response.json() as { message: string };
+
+      expect(response.status).toBe(200);
+      expect(data.message).toBe('PATCH successful');
+    });
+  });
+
+  describe('Route Parameters', () => {
+    it('should handle route parameters', async () => {
+      app.get('/users/:id', (ctx) => {
+        return { userId: ctx.params.id, message: 'User found' };
+      });
+
+      const response = await fetch(`${baseUrl}/users/123`);
+      const data = await response.json() as { userId: string, message: string };
+
+      expect(response.status).toBe(200);
+      expect(data.userId).toBe('123');
+      expect(data.message).toBe('User found');
+    });
+
+    it('should handle nested route parameters', async () => {
+      app.get('/users/:id/posts/:postId', (ctx) => {
+        return {
+          userId: ctx.params.id,
+          postId: ctx.params.postId,
+          message: 'Post found'
+        };
+      });
+
+      const response = await fetch(`${baseUrl}/users/123/posts/456`);
+      const data = await response.json() as { userId: string, postId: string, message: string };
+
+      expect(response.status).toBe(200);
+      expect(data.userId).toBe('123');
+      expect(data.postId).toBe('456');
+      expect(data.message).toBe('Post found');
+    });
+  });
+
+  describe('Query Parameters', () => {
+    it('should handle query parameters', async () => {
+      app.get('/search', (ctx) => {
+        return { query: ctx.query, message: 'Search completed' };
+      });
+
+      const response = await fetch(`${baseUrl}/search?q=test&page=1`);
+      const data = await response.json() as { query: { q: string, page: string }, message: string };
+
+      expect(response.status).toBe(200);
+      expect(data.query.q).toBe('test');
+      expect(data.query.page).toBe('1');
+      expect(data.message).toBe('Search completed');
+    });
+  });
+
+  describe('Request Body', () => {
+    it('should handle JSON body', async () => {
+      app.post('/api/users', (ctx) => {
+        return { user: ctx.body, message: 'User created' };
+      });
+
+      const userData = { name: 'John', email: 'john@example.com' };
+      const response = await fetch(`${baseUrl}/api/users`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(userData)
+      });
+
+      const data = await response.json() as { user: { name: string, email: string }, message: string };
+
+      expect(response.status).toBe(200);
+      expect(data.user.name).toBe('John');
+      expect(data.user.email).toBe('john@example.com');
+      expect(data.message).toBe('User created');
+    });
+
+    it('should handle form data', async () => {
+      app.post('/api/contact', (ctx) => {
+        return { formData: ctx.body, message: 'Form submitted' };
+      });
+
+      const formData = new FormData();
+      formData.append('name', 'John');
+      formData.append('email', 'john@example.com');
+
+      const response = await fetch(`${baseUrl}/api/contact`, {
+        method: 'POST',
+        body: formData
+      });
+
+      const data = await response.json() as { formData: { name: string, email: string }, message: string };
+
+      expect(response.status).toBe(200);
+      expect(data.formData.name).toBe('John');
+      expect(data.formData.email).toBe('john@example.com');
+      expect(data.message).toBe('Form submitted');
+    });
+
+    it('should handle form data with arrays', async () => {
+      app.post('/api/records', (ctx) => {
+        return { formData: ctx.body, message: 'Records submitted' };
+      });
+
+      const formData = new FormData();
+      formData.append('app', 'zodula');
+      formData.append('model', 'zodula_User');
+      formData.append('recordIds[]', 'asdfasdfdsa');
+      formData.append('recordIds[]', 'jarupak.sri@gmail.com');
+      formData.append('fields', '*');
+
+      const response = await fetch(`${baseUrl}/api/records`, {
+        method: 'POST',
+        body: formData
+      });
+
+      const data = await response.json() as { 
+        formData: { 
+          app: string, 
+          model: string, 
+          recordIds: string[], 
+          fields: string 
+        }, 
+        message: string 
+      };
+
+      expect(response.status).toBe(200);
+      expect(data.formData.app).toBe('zodula');
+      expect(data.formData.model).toBe('zodula_User');
+      expect(Array.isArray(data.formData.recordIds)).toBe(true);
+      expect(data.formData.recordIds).toEqual(['asdfasdfdsa', 'jarupak.sri@gmail.com']);
+      expect(data.formData.fields).toBe('*');
+      expect(data.message).toBe('Records submitted');
+    });
+
+    it('should handle form data with nested objects', async () => {
+      app.post('/api/nested', (ctx) => {
+        return { formData: ctx.body, message: 'Nested data submitted' };
+      });
+
+      const formData = new FormData();
+      formData.append('test[test]', 'test');
+      formData.append('test[new]', 'new');
+      formData.append('test[hi][hi]', 'hi');
+
+      const response = await fetch(`${baseUrl}/api/nested`, {
+        method: 'POST',
+        body: formData
+      });
+
+      const data = await response.json() as { 
+        formData: { 
+          test: {
+            test: string,
+            new: string,
+            hi: {
+              hi: string
+            }
+          }
+        }, 
+        message: string 
+      };
+
+      expect(response.status).toBe(200);
+      expect(data.formData.test).toEqual({
+        test: 'test',
+        new: 'new',
+        hi: {
+          hi: 'hi'
+        }
+      });
+      expect(data.message).toBe('Nested data submitted');
+    });
+
+    it('should handle form data with nested arrays and files', async () => {
+      app.post('/api/records-with-files', (ctx) => {
+        return { formData: ctx.body, message: 'Records with files submitted' };
+      });
+
+      const formData = new FormData();
+      formData.append('records[0][qrPayment]', new File(['test file content'], 'test.png', { type: 'image/png' }));
+      formData.append('records[1][qrPayment]', new File(['test file content 2'], 'test2.png', { type: 'image/png' }));
+      formData.append('records[0][name]', 'Record 1');
+      formData.append('records[1][name]', 'Record 2');
+
+      const response = await fetch(`${baseUrl}/api/records-with-files`, {
+        method: 'POST',
+        body: formData
+      });
+
+      const data = await response.json() as { 
+        formData: { 
+          records: Array<{
+            qrPayment: {
+              type: string;
+              name: string;
+              size: number;
+              lastModified: number;
+            },
+            name: string
+          }>
+        }, 
+        message: string 
+      };
+
+      expect(response.status).toBe(200);
+      expect(Array.isArray(data.formData.records)).toBe(true);
+      expect(data.formData.records).toHaveLength(2);
+      expect(data.formData.records[0]?.name).toBe('Record 1');
+      expect(data.formData.records[1]?.name).toBe('Record 2');
+      expect(data.formData.records[0]?.qrPayment).toEqual({
+        type: 'File',
+        name: 'test.png',
+        size: 17,
+        lastModified: 0
+      });
+      expect(data.formData.records[1]?.qrPayment).toEqual({
+        type: 'File',
+        name: 'test2.png',
+        size: 19,
+        lastModified: 0
+      });
+      expect(data.message).toBe('Records with files submitted');
+    });
+
+    it('should have File objects in ctx.body', async () => {
+      app.post('/api/files-test', (ctx) => {
+        // Check if the files are actual File instances
+        const body = ctx.body as {
+          records: Array<{
+            qrPayment: File;
+            name: string;
+          }>;
+        };
+        const records = body.records;
+        console.log('File instance check:');
+        console.log('records[0].qrPayment instanceof File:', records[0]?.qrPayment instanceof File);
+        console.log('records[1].qrPayment instanceof File:', records[1]?.qrPayment instanceof File);
+        console.log('File name:', records[0]?.qrPayment.name);
+        console.log('File size:', records[0]?.qrPayment.size);
+        console.log('File type:', records[0]?.qrPayment.type);
+        
+        return { 
+          message: 'Files received',
+          fileInfo: {
+            isFile0: records[0]?.qrPayment instanceof File,
+            isFile1: records[1]?.qrPayment instanceof File,
+            name0: records[0]?.qrPayment.name,
+            size0: records[0]?.qrPayment.size,
+            type0: records[0]?.qrPayment.type
+          }
+        };
+      });
+
+      const formData = new FormData();
+      formData.append('records[0][qrPayment]', new File(['test file content'], 'test.png', { type: 'image/png' }));
+      formData.append('records[1][qrPayment]', new File(['test file content 2'], 'test2.png', { type: 'image/png' }));
+      formData.append('records[0][name]', 'Record 1');
+      formData.append('records[1][name]', 'Record 2');
+
+      const response = await fetch(`${baseUrl}/api/files-test`, {
+        method: 'POST',
+        body: formData
+      });
+
+      const data = await response.json() as {
+        message: string;
+        fileInfo: {
+          isFile0: boolean;
+          isFile1: boolean;
+          name0: string;
+          size0: number;
+          type0: string;
+        };
+      };
+
+      expect(response.status).toBe(200);
+      expect(data.fileInfo.isFile0).toBe(true);
+      expect(data.fileInfo.isFile1).toBe(true);
+      expect(data.fileInfo.name0).toBe('test.png');
+      expect(data.fileInfo.size0).toBe(17);
+      expect(data.fileInfo.type0).toBe('image/png');
+    });
+  });
+
+  describe('Response Handling', () => {
+    it('should handle string responses', async () => {
+      app.get('/text', () => {
+        return 'Hello World';
+      });
+
+      const response = await fetch(`${baseUrl}/text`);
+      const text = await response.text();
+
+      expect(response.status).toBe(200);
+      expect(text).toBe('Hello World');
+      expect(response.headers.get('content-type')).toBe('text/plain');
+    });
+
+    it('should handle object responses', async () => {
+      app.get('/json', () => {
+        return { message: 'Hello World', status: 'success' };
+      });
+
+      const response = await fetch(`${baseUrl}/json`);
+      const data = await response.json() as { message: string, status: string };
+
+      expect(response.status).toBe(200);
+      expect(data.message).toBe('Hello World');
+      expect(data.status).toBe('success');
+      expect(response.headers.get('content-type')).toBe('application/json');
+    });
+
+    it('should handle Response objects', async () => {
+      app.get('/custom-response', () => {
+        return new Response('Custom response', {
+          status: 201,
+          headers: { 'x-custom': 'value' }
+        });
+      });
+
+      const response = await fetch(`${baseUrl}/custom-response`);
+      const text = await response.text();
+
+      expect(response.status).toBe(201);
+      expect(text).toBe('Custom response');
+      expect(response.headers.get('x-custom')).toBe('value');
+    });
+  });
+
+  describe('Status and Headers', () => {
+    it('should handle custom status codes', async () => {
+      app.get('/not-found', (ctx) => {
+        ctx.status(404, 'Not Found');
+        return { error: 'Resource not found' };
+      });
+
+      const response = await fetch(`${baseUrl}/not-found`);
+      const data = await response.json() as { error: string };
+
+      expect(response.status).toBe(404);
+      expect(data.error).toBe('Resource not found');
+    });
+
+    it('should handle custom headers', async () => {
+      app.get('/custom-headers', (ctx) => {
+        ctx.set.headers['x-custom'] = 'value';
+        ctx.set.headers['authorization'] = 'Bearer token';
+        return { message: 'Headers set' };
+      });
+
+      const response = await fetch(`${baseUrl}/custom-headers`);
+      const data = await response.json() as { message: string };
+
+      expect(response.status).toBe(200);
+      expect(response.headers.get('x-custom')).toBe('value');
+      expect(response.headers.get('authorization')).toBe('Bearer token');
+      expect(data.message).toBe('Headers set');
+    });
+  });
+
+  describe('Cookies', () => {
+    it('should handle setting cookies', async () => {
+      app.get('/set-cookie', (ctx) => {
+        ctx.set.cookies('session', 'abc123', {
+          httpOnly: true,
+          secure: false
+        });
+        return { message: 'Cookie set' };
+      });
+
+      const response = await fetch(`${baseUrl}/set-cookie`);
+      const data = await response.json() as { message: string };
+
+      expect(response.status).toBe(200);
+      expect(response.headers.get('set-cookie')).toContain('session=abc123');
+      expect(response.headers.get('set-cookie')).toContain('HttpOnly');
+      expect(data.message).toBe('Cookie set');
+    });
+  });
+
+  describe('Redirects', () => {
+    it('should handle redirects', async () => {
+      app.get('/redirect', (ctx) => {
+        return ctx.redirect('/target', 301);
+      });
+
+      const response = await fetch(`${baseUrl}/redirect`, {
+        redirect: 'manual'
+      });
+
+      expect(response.status).toBe(301);
+      expect(response.headers.get('location')).toBe('/target');
+    });
+
+    it('should handle implicit redirects', async () => {
+      app.get('/implicit-redirect', (ctx) => {
+        ctx.set.headers['Location'] = '/target';
+        ctx.set.status = 302;
+        // Don't return anything - should create redirect automatically
+      });
+
+      const response = await fetch(`${baseUrl}/implicit-redirect`, {
+        redirect: 'manual'
+      });
+
+      expect(response.status).toBe(302);
+      expect(response.headers.get('location')).toBe('/target');
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle 404 for non-existent routes', async () => {
+      const response = await fetch(`${baseUrl}/non-existent`);
+
+      expect(response.status).toBe(404);
+      expect(await response.text()).toBe('Not Found');
+    });
+
+    it('should handle validation errors', async () => {
+      app.post('/validate', (ctx) => {
+        return { data: ctx.body };
+      }, {
+        body: z.object({
+          name: z.string().min(1),
+          email: z.string().email()
+        })
+      });
+
+      const response = await fetch(`${baseUrl}/validate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: '', email: 'invalid' })
+      });
+
+      expect(response.status).toBe(400);
+      const data = await response.json() as { error: string };
+      expect(data.error).toContain('Validation failed');
+    });
+  });
+
+  describe('WebSocket Support', () => {
+    it('should handle WebSocket routes', async () => {
+      app.ws('/ws', {
+        onOpen: (ws) => {
+          ws.send('Connected');
+        },
+        onMessage: (ws, message) => {
+          ws.send(`Echo: ${message}`);
+        }
+      });
+
+      // WebSocket testing would require a WebSocket client
+      // For now, just verify the route is registered
+      expect(app.wsRoutes).toHaveLength(1);
+      expect(app.wsRoutes[0]?.path).toBe('/ws');
+    });
+  });
+
+  describe('Lifecycle Hooks', () => {
+    it('should execute lifecycle hooks', async () => {
+      let beforeStartCalled = false;
+      let afterStartCalled = false;
+
+      app.onBeforeStart(() => {
+        beforeStartCalled = true;
+      });
+
+      app.onAfterStart(() => {
+        afterStartCalled = true;
+      });
+
+      await app.start(3002);
+
+      expect(beforeStartCalled).toBe(true);
+      expect(afterStartCalled).toBe(true);
+
+      await app.stop();
+    });
+  });
+
+  describe('Server Information', () => {
+    it('should provide server information', async () => {
+      await app.start(3003);
+
+      const info = app.info;
+
+      expect(info.running).toBe(true);
+      expect(info.server).toBe('Bun');
+      expect(info.port).toBe(3003);
+      expect(info.hostname).toBe('localhost');
+      expect(info.runtime).toBe('Bun');
+      expect(info.totalRoutes).toBeGreaterThan(0);
+
+      await app.stop();
+    });
+  });
+});

package/tests/run-tests.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+
+import { spawn } from 'child_process';
+
+console.log('🧪 Running BXO Framework Tests...\n');
+
+// Run unit tests
+console.log('📋 Running Unit Tests...');
+const unitTests = spawn('bun', ['test', 'tests/unit/'], {
+  stdio: 'inherit',
+  shell: true
+});
+
+unitTests.on('close', (code) => {
+  if (code === 0) {
+    console.log('\n✅ Unit tests passed!\n');
+    
+    // Run integration tests
+    console.log('🔗 Running Integration Tests...');
+    const integrationTests = spawn('bun', ['test', 'tests/integration/'], {
+      stdio: 'inherit',
+      shell: true
+    });
+
+    integrationTests.on('close', (integrationCode) => {
+      if (integrationCode === 0) {
+        console.log('\n✅ Integration tests passed!');
+        console.log('\n🎉 All tests completed successfully!');
+        process.exit(0);
+      } else {
+        console.log('\n❌ Integration tests failed!');
+        process.exit(integrationCode);
+      }
+    });
+  } else {
+    console.log('\n❌ Unit tests failed!');
+    process.exit(code);
+  }
+});
+
+unitTests.on('error', (error) => {
+  console.error('❌ Error running unit tests:', error);
+  process.exit(1);
+});