@buenojs/bueno 0.8.0

package/tests/unit/middleware.test.ts

@@ -0,0 +1,184 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { Middleware, compose, createPipeline } from '../../src/middleware';
+import { Context } from '../../src/context';
+
+describe('Middleware Pipeline', () => {
+  let mockRequest: Request;
+  let context: Context;
+
+  beforeEach(() => {
+    mockRequest = new Request('http://localhost:3000/test', { method: 'GET' });
+    context = new Context(mockRequest, {});
+  });
+
+  describe('compose', () => {
+    test('should compose empty middleware array', async () => {
+      const pipeline = compose([]);
+      const handler = () => new Response('OK');
+      const response = await pipeline(context, handler);
+      
+      expect(response.status).toBe(200);
+    });
+
+    test('should compose single middleware', async () => {
+      const middleware: Middleware = async (ctx, next) => {
+        ctx.set('executed', true);
+        return await next();
+      };
+
+      const pipeline = compose([middleware]);
+      const handler = () => new Response('OK');
+      const response = await pipeline(context, handler);
+
+      expect(context.get('executed')).toBe(true);
+      expect(response.status).toBe(200);
+    });
+
+    test('should compose multiple middleware in order', async () => {
+      const order: number[] = [];
+      
+      const middleware1: Middleware = async (ctx, next) => {
+        order.push(1);
+        await next();
+        order.push(4);
+      };
+
+      const middleware2: Middleware = async (ctx, next) => {
+        order.push(2);
+        await next();
+        order.push(3);
+      };
+
+      const pipeline = compose([middleware1, middleware2]);
+      const handler = () => {
+        order.push(5);
+        return new Response('OK');
+      };
+
+      await pipeline(context, handler);
+      
+      expect(order).toEqual([1, 2, 5, 3, 4]);
+    });
+
+    test('should pass context through middleware', async () => {
+      const middleware: Middleware = async (ctx, next) => {
+        ctx.set('before', 'value1');
+        const response = await next();
+        ctx.set('after', 'value2');
+        return response;
+      };
+
+      const pipeline = compose([middleware]);
+      await pipeline(context, () => new Response('OK'));
+
+      expect(context.get('before')).toBe('value1');
+      expect(context.get('after')).toBe('value2');
+    });
+
+    test('should allow early termination', async () => {
+      const middleware: Middleware = async (ctx, next) => {
+        return new Response('Unauthorized', { status: 401 });
+      };
+
+      const pipeline = compose([middleware]);
+      const handler = () => {
+        throw new Error('Should not be called');
+      };
+
+      const response = await pipeline(context, handler);
+      expect(response.status).toBe(401);
+    });
+
+    test('should handle errors in middleware', async () => {
+      const middleware: Middleware = async (ctx, next) => {
+        try {
+          return await next();
+        } catch (error) {
+          return new Response('Internal Server Error', { status: 500 });
+        }
+      };
+
+      const pipeline = compose([middleware]);
+      const handler = () => {
+        throw new Error('Handler error');
+      };
+
+      const response = await pipeline(context, handler);
+      expect(response.status).toBe(500);
+    });
+  });
+
+  describe('createPipeline', () => {
+    test('should create reusable pipeline', async () => {
+      const pipeline = createPipeline();
+      
+      pipeline.use(async (ctx, next) => {
+        ctx.set('step1', true);
+        return await next();
+      });
+
+      pipeline.use(async (ctx, next) => {
+        ctx.set('step2', true);
+        return await next();
+      });
+
+      const response = await pipeline.execute(context, () => new Response('OK'));
+
+      expect(context.get('step1')).toBe(true);
+      expect(context.get('step2')).toBe(true);
+      expect(response.status).toBe(200);
+    });
+
+    test('should allow adding middleware after creation', async () => {
+      const pipeline = createPipeline();
+      
+      pipeline.use(async (ctx, next) => {
+        ctx.set('count', 1);
+        return await next();
+      });
+
+      let response = await pipeline.execute(context, () => new Response('OK'));
+      expect(context.get('count')).toBe(1);
+
+      // Add more middleware
+      pipeline.use(async (ctx, next) => {
+        ctx.set('count', (ctx.get('count') as number) + 1);
+        return await next();
+      });
+
+      const ctx2 = new Context(mockRequest, {});
+      response = await pipeline.execute(ctx2, () => new Response('OK'));
+      expect(ctx2.get('count')).toBe(2);
+    });
+  });
+
+  describe('Built-in Middleware', () => {
+    test('logger middleware should work', async () => {
+      const { logger } = await import('../../src/middleware/built-in');
+      
+      const pipeline = compose([logger()]);
+      const response = await pipeline(context, () => new Response('OK'));
+      
+      expect(response.status).toBe(200);
+    });
+
+    test('CORS middleware should add headers', async () => {
+      const { cors } = await import('../../src/middleware/built-in');
+      
+      const pipeline = compose([cors()]);
+      const response = await pipeline(context, () => new Response('OK'));
+      
+      expect(response.headers.get('Access-Control-Allow-Origin')).toBe('*');
+    });
+
+    test('requestId middleware should set request ID', async () => {
+      const { requestId } = await import('../../src/middleware/built-in');
+      
+      const pipeline = compose([requestId()]);
+      const response = await pipeline(context, () => new Response('OK'));
+      
+      expect(context.get('requestId')).toBeDefined();
+      expect(response.headers.get('X-Request-Id')).toBeDefined();
+    });
+  });
+});

package/tests/unit/modules.test.ts

@@ -0,0 +1,142 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { Module, Controller, Injectable, createApp, AppModule } from '../../src/modules';
+import { Container, Token } from '../../src/container';
+
+// Helper to check metadata (since we use WeakMap storage)
+function hasInjectable(target: abstract new (...args: unknown[]) => unknown): boolean {
+  // Check if class has Injectable metadata by trying to instantiate
+  // In a real scenario, the metadata is stored internally
+  return true; // Simplified for test
+}
+
+// Test fixtures
+interface IUserService {
+  getUser(id: string): { id: string; name: string };
+}
+
+interface IUserRepository {
+  findById(id: string): { id: string; name: string } | null;
+}
+
+const USER_SERVICE_TOKEN = Token<IUserService>('IUserService');
+const USER_REPOSITORY_TOKEN = Token<IUserRepository>('IUserRepository');
+
+class UserRepository implements IUserRepository {
+  private users = new Map([
+    ['1', { id: '1', name: 'John' }],
+    ['2', { id: '2', name: 'Jane' }],
+  ]);
+
+  findById(id: string): { id: string; name: string } | null {
+    return this.users.get(id) ?? null;
+  }
+}
+
+class UserService implements IUserService {
+  constructor(private repo: IUserRepository) {}
+
+  getUser(id: string): { id: string; name: string } {
+    const user = this.repo.findById(id);
+    return user ?? { id, name: 'Unknown' };
+  }
+}
+
+class UsersController {
+  constructor(private userService: IUserService) {}
+
+  findAll() {
+    return [{ id: '1', name: 'John' }, { id: '2', name: 'Jane' }];
+  }
+
+  findOne(id: string) {
+    return this.userService.getUser(id);
+  }
+}
+
+@Module({
+  providers: [
+    { token: USER_REPOSITORY_TOKEN, useClass: UserRepository },
+    { token: USER_SERVICE_TOKEN, useClass: UserService, inject: [USER_REPOSITORY_TOKEN] },
+  ],
+  controllers: [UsersController],
+  exports: [USER_SERVICE_TOKEN],
+})
+class UsersModule {}
+
+@Module({
+  imports: [UsersModule],
+})
+class TestAppModule {}
+
+describe('Module System', () => {
+  describe('@Injectable Decorator', () => {
+    test('should mark class as injectable', () => {
+      @Injectable()
+      class TestService {}
+      
+      // Class should be returned unchanged
+      expect(TestService).toBeDefined();
+    });
+  });
+
+  describe('@Controller Decorator', () => {
+    test('should mark class as controller with path', () => {
+      @Controller('/api')
+      class TestController {}
+      
+      // Class should be returned unchanged
+      expect(TestController).toBeDefined();
+    });
+  });
+
+  describe('@Module Decorator', () => {
+    test('should define module metadata', () => {
+      @Module({
+        providers: [],
+        controllers: [],
+      })
+      class TestModule {}
+      
+      // Module should be defined
+      expect(TestModule).toBeDefined();
+    });
+  });
+
+  describe('AppModule', () => {
+    test('should create module from class', () => {
+      const appModule = new AppModule(TestAppModule);
+      expect(appModule).toBeDefined();
+    });
+
+    test('should collect providers from module tree', () => {
+      const appModule = new AppModule(TestAppModule);
+      const providers = appModule.getProviders();
+      
+      expect(providers.length).toBeGreaterThan(0);
+    });
+
+    test('should collect controllers from module tree', () => {
+      const appModule = new AppModule(TestAppModule);
+      const controllers = appModule.getControllers();
+      
+      expect(controllers.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('createApp', () => {
+    test('should create application with module', () => {
+      const app = createApp(TestAppModule);
+      expect(app).toBeDefined();
+      expect(app.container).toBeInstanceOf(Container);
+    });
+
+    test('should resolve imported module providers', async () => {
+      const app = createApp(TestAppModule);
+      await app.init();
+      const userService = app.container.resolve(USER_SERVICE_TOKEN);
+      
+      expect(userService).toBeDefined();
+      expect(userService.getUser('1')).toEqual({ id: '1', name: 'John' });
+    });
+  });
+});

package/tests/unit/pubsub.test.ts

@@ -0,0 +1,257 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { PubSub, createPubSub, createMemoryPubSub } from '../../src/websocket';
+
+describe('PubSub (In-Memory)', () => {
+  let pubsub: PubSub;
+
+  beforeEach(() => {
+    pubsub = createMemoryPubSub();
+  });
+
+  afterEach(() => {
+    pubsub.destroy();
+  });
+
+  describe('Basic Operations', () => {
+    test('should publish and receive messages', async () => {
+      const messages: unknown[] = [];
+      
+      await pubsub.subscribe('test-channel', (message) => {
+        messages.push(message.data);
+      });
+
+      await pubsub.publish('test-channel', 'hello world');
+      await pubsub.publish('test-channel', { foo: 'bar' });
+
+      expect(messages.length).toBe(2);
+      expect(messages[0]).toBe('hello world');
+      expect(messages[1]).toEqual({ foo: 'bar' });
+    });
+
+    test('should support multiple subscribers on same channel', async () => {
+      const messages1: unknown[] = [];
+      const messages2: unknown[] = [];
+
+      await pubsub.subscribe('shared-channel', (msg) => { messages1.push(msg.data); });
+      await pubsub.subscribe('shared-channel', (msg) => { messages2.push(msg.data); });
+
+      const delivered = await pubsub.publish('shared-channel', 'broadcast');
+
+      expect(delivered).toBe(2);
+      expect(messages1).toEqual(['broadcast']);
+      expect(messages2).toEqual(['broadcast']);
+    });
+
+    test('should return unsubscribe function', async () => {
+      const messages: unknown[] = [];
+
+      const unsubscribe = await pubsub.subscribe('temp-channel', (msg) => {
+        messages.push(msg.data);
+      });
+
+      await pubsub.publish('temp-channel', 'message 1');
+      expect(messages.length).toBe(1);
+
+      // Unsubscribe
+      await unsubscribe();
+
+      await pubsub.publish('temp-channel', 'message 2');
+      expect(messages.length).toBe(1); // Should still be 1
+    });
+
+    test('should handle async callbacks', async () => {
+      const messages: string[] = [];
+
+      await pubsub.subscribe('async-channel', async (msg) => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        messages.push(`processed: ${msg.data}`);
+      });
+
+      await pubsub.publish('async-channel', 'test');
+
+      // Wait for async callback
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      expect(messages).toEqual(['processed: test']);
+    });
+  });
+
+  describe('Pattern Subscriptions', () => {
+    test('should match pattern with * wildcard', async () => {
+      const messages: string[] = [];
+
+      await pubsub.psubscribe('user:*', (msg) => {
+        messages.push(msg.channel);
+      });
+
+      await pubsub.publish('user:123', 'data');
+      await pubsub.publish('user:456', 'data');
+      await pubsub.publish('post:789', 'data');
+
+      expect(messages).toEqual(['user:123', 'user:456']);
+    });
+
+    test('should match pattern with ? single char', async () => {
+      const messages: string[] = [];
+
+      await pubsub.psubscribe('user:?', (msg) => {
+        messages.push(msg.channel);
+      });
+
+      await pubsub.publish('user:1', 'data');
+      await pubsub.publish('user:a', 'data');
+      await pubsub.publish('user:12', 'data'); // Should not match (2 chars)
+
+      expect(messages).toEqual(['user:1', 'user:a']);
+    });
+
+    test('should match complex patterns', async () => {
+      const messages: string[] = [];
+
+      await pubsub.psubscribe('app:*:event', (msg) => {
+        messages.push(msg.channel);
+      });
+
+      await pubsub.publish('app:user:event', 'data');
+      await pubsub.publish('app:order:event', 'data');
+      await pubsub.publish('app:user:other', 'data');
+
+      expect(messages).toEqual(['app:user:event', 'app:order:event']);
+    });
+
+    test('should include pattern in message', async () => {
+      let receivedPattern: string | undefined;
+
+      await pubsub.psubscribe('test:*', (msg) => {
+        receivedPattern = msg.pattern;
+      });
+
+      await pubsub.publish('test:channel', 'data');
+
+      expect(receivedPattern).toBe('test:*');
+    });
+  });
+
+  describe('Subscriber Management', () => {
+    test('should count channel subscribers', async () => {
+      expect(pubsub.getChannelSubscribers('my-channel')).toBe(0);
+
+      await pubsub.subscribe('my-channel', () => {});
+      expect(pubsub.getChannelSubscribers('my-channel')).toBe(1);
+
+      await pubsub.subscribe('my-channel', () => {});
+      expect(pubsub.getChannelSubscribers('my-channel')).toBe(2);
+    });
+
+    test('should count pattern subscribers', async () => {
+      expect(pubsub.getPatternSubscribers('test:*')).toBe(0);
+
+      await pubsub.psubscribe('test:*', () => {});
+      expect(pubsub.getPatternSubscribers('test:*')).toBe(1);
+    });
+
+    test('should count total subscribers', async () => {
+      await pubsub.subscribe('channel1', () => {});
+      await pubsub.subscribe('channel2', () => {});
+      await pubsub.psubscribe('pattern:*', () => {});
+
+      expect(pubsub.getTotalSubscribers()).toBe(3);
+    });
+
+    test('should unsubscribe all from channel', async () => {
+      await pubsub.subscribe('multi-channel', () => {});
+      await pubsub.subscribe('multi-channel', () => {});
+
+      expect(pubsub.getChannelSubscribers('multi-channel')).toBe(2);
+
+      await pubsub.unsubscribe('multi-channel');
+
+      expect(pubsub.getChannelSubscribers('multi-channel')).toBe(0);
+    });
+
+    test('should punsubscribe all from pattern', async () => {
+      await pubsub.psubscribe('test:*', () => {});
+      await pubsub.psubscribe('test:*', () => {});
+
+      expect(pubsub.getPatternSubscribers('test:*')).toBe(2);
+
+      await pubsub.punsubscribe('test:*');
+
+      expect(pubsub.getPatternSubscribers('test:*')).toBe(0);
+    });
+  });
+
+  describe('Clear Operations', () => {
+    test('should clear all subscriptions', async () => {
+      await pubsub.subscribe('channel1', () => {});
+      await pubsub.subscribe('channel2', () => {});
+      await pubsub.psubscribe('pattern:*', () => {});
+
+      await pubsub.clear();
+
+      expect(pubsub.getTotalSubscribers()).toBe(0);
+    });
+  });
+
+  describe('Message Structure', () => {
+    test('should include timestamp in message', async () => {
+      let receivedTimestamp: number | undefined;
+      const beforeTime = Date.now();
+
+      await pubsub.subscribe('timestamp-channel', (msg) => {
+        receivedTimestamp = msg.timestamp;
+      });
+
+      await pubsub.publish('timestamp-channel', 'test');
+
+      expect(receivedTimestamp).toBeDefined();
+      expect(receivedTimestamp!).toBeGreaterThanOrEqual(beforeTime);
+    });
+
+    test('should include channel in message', async () => {
+      let receivedChannel: string | undefined;
+
+      await pubsub.subscribe('my-channel', (msg) => {
+        receivedChannel = msg.channel;
+      });
+
+      await pubsub.publish('my-channel', 'test');
+
+      expect(receivedChannel).toBe('my-channel');
+    });
+  });
+});
+
+describe('PubSub Factory Functions', () => {
+  test('createPubSub should create memory pubsub by default', () => {
+    const pubsub = createPubSub();
+    expect(pubsub.getDriverType()).toBe('memory');
+    pubsub.destroy();
+  });
+
+  test('createPubSub with driver option', () => {
+    const memPubsub = createPubSub({ driver: 'memory' });
+    expect(memPubsub.getDriverType()).toBe('memory');
+    memPubsub.destroy();
+  });
+
+  test('createMemoryPubSub should create memory pubsub', () => {
+    const pubsub = createMemoryPubSub();
+    expect(pubsub.getDriverType()).toBe('memory');
+    pubsub.destroy();
+  });
+});
+
+describe('PubSub Connection State', () => {
+  test('should be connected after initialization for memory', () => {
+    const pubsub = createMemoryPubSub();
+    expect(pubsub.isConnected).toBe(true);
+    pubsub.destroy();
+  });
+
+  test('should not be connected after destroy', () => {
+    const pubsub = createMemoryPubSub();
+    pubsub.destroy();
+    expect(pubsub.isConnected).toBe(false);
+  });
+});