@thinkbun/middleware 1.0.0

package/src/test/middlewares.test.ts

@@ -0,0 +1,265 @@
+import { describe, expect, it } from 'bun:test';
+import { cors, errorHandler, logger, staticServe, validator } from '../index';
+import type { Context } from '@thinkbun/core';
+
+// 创建模拟上下文
+function createMockContext(req: Request): Context {
+  const mockApp: any = {
+    server: {
+      requestIP: () => '127.0.0.1'
+    },
+    logger: console
+  };
+
+  const ctx: any = {
+    req,
+    app: mockApp,
+    responseHeaders: new Headers(),
+    _status: 200,
+    state: {},
+    get status() {
+      return this._status;
+    },
+    set status(code: number) {
+      this._status = code;
+    },
+    get method() {
+      return this.req.method;
+    },
+    get url() {
+      return new URL(this.req.url);
+    },
+    get path() {
+      return this.url.pathname;
+    },
+    get headers() {
+      return this.req.headers;
+    },
+    header(name: string): string | null {
+      return this.req.headers.get(name);
+    },
+    get ip() {
+      return this.app.server.requestIP(this.req);
+    },
+    get userAgent() {
+      return this.header('User-Agent');
+    },
+    get cookies() {
+      return {};
+    },
+    cookie: () => ctx,
+    clearCookie: () => ctx,
+    body: async () => ({}),
+    text: async () => '',
+    json: (data: any, options: any = {}) => new Response(JSON.stringify(data), {
+      status: options.status || ctx.status,
+      headers: new Headers([...ctx.responseHeaders.entries(), ...(options.headers ? Object.entries(options.headers) : [])])
+    }),
+    ok: () => new Response(null, { status: 200, headers: ctx.responseHeaders }),
+    success: (data: any) => ctx.json({ errno: 0, data }),
+    fail: (errno: number, msg: string) => ctx.json({ errno, msg })
+  };
+
+  return ctx;
+}
+
+describe('Middleware Tests', () => {
+  // 测试CORS中间件
+  describe('CORS Middleware', () => {
+    it('should add CORS headers to response', async () => {
+      const req = new Request('http://test:5300/', {
+        headers: {
+          Origin: 'http://example.com'
+        }
+      });
+      const ctx = createMockContext(req);
+      const corsMiddleware = cors();
+      
+      await corsMiddleware(ctx, async () => {});
+      
+      expect(ctx.responseHeaders.get('Access-Control-Allow-Origin')).toBe('*'); // 默认配置下使用*
+      expect(ctx.responseHeaders.get('Access-Control-Allow-Methods')).toBeNull(); // 非OPTIONS请求不会添加这个头
+      expect(ctx.responseHeaders.get('Access-Control-Allow-Headers')).toBeNull(); // 非OPTIONS请求不会添加这个头
+      expect(ctx.responseHeaders.get('Access-Control-Max-Age')).toBeNull(); // 非OPTIONS请求不会添加这个头
+    });
+    
+    it('should handle OPTIONS requests', async () => {
+      const req = new Request('http://test:5300/', {
+        method: 'OPTIONS',
+        headers: {
+          Origin: 'http://example.com',
+          'Access-Control-Request-Methods': 'GET, POST',
+          'Access-Control-Request-Headers': 'Content-Type'
+        }
+      });
+      const ctx = createMockContext(req);
+      const corsMiddleware = cors();
+      
+      const result = await corsMiddleware(ctx, async () => {});
+      
+      expect(result).toBeDefined();
+      expect((result as Response).status).toBe(204);
+    });
+  });
+  
+  // 测试Logger中间件
+  describe('Logger Middleware', () => {
+    it('should log request and response information', async () => {
+      const req = new Request('http://test:5300/');
+      const ctx = createMockContext(req);
+      
+      let logCalled = false;
+      const loggerMiddleware = logger({
+        logger: () => logCalled = true
+      });
+      
+      await loggerMiddleware(ctx, async () => {
+        return new Response('OK', { status: 200 });
+      });
+      
+      expect(logCalled).toBe(true);
+    });
+  });
+  
+  // 测试ErrorHandler中间件
+  describe('ErrorHandler Middleware', () => {
+    it('should handle errors and return JSON response', async () => {
+      const req = new Request('http://test:5300/');
+      const ctx = createMockContext(req);
+      const errorHandlerMiddleware = errorHandler();
+      
+      const result = await errorHandlerMiddleware(ctx, async () => {
+        throw new Error('Test error');
+      });
+      
+      expect(result).toBeDefined();
+      const response = result as Response;
+      expect(response.status).toBe(500);
+      const responseData = await response.json();
+      expect(responseData.error).toBe('Internal Server Error');
+    });
+    
+    it('should handle HTTP errors with specific status codes', async () => {
+      const req = new Request('http://test:5300/');
+      const ctx = createMockContext(req);
+      const errorHandlerMiddleware = errorHandler();
+      
+      // 使用与errorHandler中间件匹配的错误类型
+      const notFoundError = new Error('Not Found');
+      notFoundError.name = 'NotFoundError';
+      
+      const result = await errorHandlerMiddleware(ctx, async () => {
+        throw notFoundError;
+      });
+      
+      expect(result).toBeDefined();
+      const response = result as Response;
+      expect(response.status).toBe(404);
+      const responseData = await response.json();
+      expect(responseData.error).toBe('Not Found');
+    });
+  });
+  
+  // 测试Validator中间件
+  describe('Validator Middleware', () => {
+    it('should validate request body against schema', async () => {
+      const req = new Request('http://test:5300/', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: 'test', age: 25 })
+      });
+      const ctx = createMockContext(req);
+      
+      // Mock the body method
+      ctx.body = async () => ({ name: 'test', age: 25 });
+      
+      // 设置params属性
+      ctx.params = {};
+      
+      const validatorMiddleware = validator({
+        rules: [
+          {
+            path: '/',
+            method: 'POST',
+            schema: {
+              body: {
+                type: 'object',
+                properties: {
+                  name: { type: 'string' },
+                  age: { type: 'number' }
+                },
+                required: ['name', 'age']
+              }
+            }
+          }
+        ]
+      });
+      
+      let nextCalled = false;
+      await validatorMiddleware(ctx, async () => {
+        nextCalled = true;
+      });
+      
+      expect(nextCalled).toBe(true);
+    });
+    
+    it('should throw error for invalid request body', async () => {
+      const req = new Request('http://test:5300/', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: 'test' })
+      });
+      const ctx = createMockContext(req);
+      
+      // Mock the body method
+      ctx.body = async () => ({ name: 'test' });
+      
+      // 设置params属性
+      ctx.params = {};
+      
+      const validatorMiddleware = validator({
+        rules: [
+          {
+            path: '/',
+            method: 'POST',
+            schema: {
+              body: {
+                type: 'object',
+                properties: {
+                  name: { type: 'string' },
+                  age: { type: 'number' }
+                },
+                required: ['name', 'age']
+              }
+            }
+          }
+        ]
+      });
+      
+      await expect(validatorMiddleware(ctx, async () => {})).rejects.toThrow();
+    });
+  });
+  
+  // 测试StaticServe中间件
+  describe('StaticServe Middleware', () => {
+    it('should serve static files', async () => {
+      const req = new Request('http://test:5300/test.txt');
+      const ctx = createMockContext(req);
+      
+      // 这个测试会实际查找文件，所以我们只测试中间件是否能正常执行
+      const staticMiddleware = staticServe({ root: './public' });
+      
+      let nextCalled = false;
+      try {
+        await staticMiddleware(ctx, async () => {
+          nextCalled = true;
+        });
+      } catch (error) {
+        // 忽略文件不存在的错误
+      }
+      
+      // 因为文件可能不存在，所以无论如何都应该调用next
+      expect(nextCalled).toBe(true);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src"],
+}