@buenojs/bueno 0.8.0

package/tests/unit/linear-router.test.ts

@@ -0,0 +1,280 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { LinearRouter } from '../../src/router/linear';
+import type { HTTPMethod, RouteHandler } from '../../src/types';
+
+describe('LinearRouter', () => {
+  let router: LinearRouter;
+
+  const mockHandler: RouteHandler = () => new Response('OK');
+  const handler1: RouteHandler = () => new Response('handler1');
+  const handler2: RouteHandler = () => new Response('handler2');
+
+  beforeEach(() => {
+    router = new LinearRouter();
+  });
+
+  describe('Router Type', () => {
+    test('should return "linear" as router type', () => {
+      expect(router.getRouterType()).toBe('linear');
+    });
+  });
+
+  describe('Static Route Registration', () => {
+    test('should register a GET route', () => {
+      router.get('/users', mockHandler);
+      const match = router.match('GET', '/users');
+      expect(match).toBeDefined();
+      expect(match?.handler).toBe(mockHandler);
+      expect(match?.params).toEqual({});
+    });
+
+    test('should register a POST route', () => {
+      router.post('/users', mockHandler);
+      const match = router.match('POST', '/users');
+      expect(match).toBeDefined();
+    });
+
+    test('should register routes for all HTTP methods', () => {
+      router.get('/get', mockHandler);
+      router.post('/post', mockHandler);
+      router.put('/put', mockHandler);
+      router.patch('/patch', mockHandler);
+      router.delete('/delete', mockHandler);
+      router.head('/head', mockHandler);
+      router.options('/options', mockHandler);
+
+      expect(router.match('GET', '/get')).toBeDefined();
+      expect(router.match('POST', '/post')).toBeDefined();
+      expect(router.match('PUT', '/put')).toBeDefined();
+      expect(router.match('PATCH', '/patch')).toBeDefined();
+      expect(router.match('DELETE', '/delete')).toBeDefined();
+      expect(router.match('HEAD', '/head')).toBeDefined();
+      expect(router.match('OPTIONS', '/options')).toBeDefined();
+    });
+
+    test('should register route with all method', () => {
+      router.all('/catch-all', mockHandler);
+      expect(router.match('GET', '/catch-all')).toBeDefined();
+      expect(router.match('POST', '/catch-all')).toBeDefined();
+      expect(router.match('PUT', '/catch-all')).toBeDefined();
+    });
+
+    test('should be case-insensitive for static routes', () => {
+      router.get('/Users', mockHandler);
+      expect(router.match('GET', '/users')).toBeDefined();
+      expect(router.match('GET', '/USERS')).toBeDefined();
+      expect(router.match('GET', '/UsErS')).toBeDefined();
+    });
+
+    test('should normalize trailing slashes for static routes', () => {
+      router.get('/users', mockHandler);
+      expect(router.match('GET', '/users')).toBeDefined();
+      expect(router.match('GET', '/users/')).toBeDefined();
+    });
+  });
+
+  describe('Static Route Performance (O(1))', () => {
+    test('should match static routes in constant time', () => {
+      // Add multiple static routes
+      router.get('/users', handler1);
+      router.get('/posts', handler2);
+      router.get('/comments', mockHandler);
+      router.get('/tags', mockHandler);
+      router.get('/categories', mockHandler);
+
+      // All should match correctly regardless of order
+      expect(router.match('GET', '/users')?.handler).toBe(handler1);
+      expect(router.match('GET', '/posts')?.handler).toBe(handler2);
+      expect(router.match('GET', '/comments')?.handler).toBe(mockHandler);
+    });
+
+    test('should return empty params for static routes', () => {
+      router.get('/static-path', mockHandler);
+      const match = router.match('GET', '/static-path');
+      expect(match?.params).toEqual({});
+    });
+  });
+
+  describe('Dynamic Route Registration', () => {
+    test('should match single path parameter', () => {
+      router.get('/users/:id', mockHandler);
+      const match = router.match('GET', '/users/123');
+      expect(match).toBeDefined();
+      expect(match?.params).toEqual({ id: '123' });
+    });
+
+    test('should match multiple path parameters', () => {
+      router.get('/users/:userId/posts/:postId', mockHandler);
+      const match = router.match('GET', '/users/42/posts/100');
+      expect(match?.params).toEqual({ userId: '42', postId: '100' });
+    });
+
+    test('should match wildcard routes', () => {
+      router.get('/files/*', mockHandler);
+      expect(router.match('GET', '/files/path/to/file.txt')).toBeDefined();
+      expect(router.match('GET', '/files/')).toBeDefined();
+    });
+
+    test('should capture wildcard content', () => {
+      router.get('/files/*', mockHandler);
+      const match = router.match('GET', '/files/docs/readme.md');
+      expect(match?.params['*']).toBe('docs/readme.md');
+    });
+
+    test('should match optional parameters', () => {
+      router.get('/users/:id?', mockHandler);
+      expect(router.match('GET', '/users')).toBeDefined();
+      expect(router.match('GET', '/users/123')?.params).toEqual({ id: '123' });
+    });
+
+    test('should match regex patterns', () => {
+      router.get('/users/:id<\\d+>', mockHandler);
+      expect(router.match('GET', '/users/123')).toBeDefined();
+      expect(router.match('GET', '/users/abc')).toBeUndefined();
+    });
+  });
+
+  describe('Route Priority', () => {
+    test('should match static routes before dynamic (via separate storage)', () => {
+      // In LinearRouter, static and dynamic routes are stored separately
+      // Static routes are checked first (O(1) Map lookup)
+      router.get('/users/me', handler1);
+      router.get('/users/:id', handler2);
+
+      // Static route should match first
+      const match = router.match('GET', '/users/me');
+      expect(match?.handler).toBe(handler1);
+
+      // Dynamic route for other values
+      const match2 = router.match('GET', '/users/123');
+      expect(match2?.handler).toBe(handler2);
+    });
+  });
+
+  describe('Route Groups', () => {
+    test('should create route group with prefix', () => {
+      const api = router.group('/api');
+      api.get('/users', mockHandler);
+
+      expect(router.match('GET', '/api/users')).toBeDefined();
+      expect(router.match('GET', '/users')).toBeUndefined();
+    });
+
+    test('should support nested route groups', () => {
+      const api = router.group('/api');
+      const v1 = api.group('/v1');
+      v1.get('/users', mockHandler);
+
+      expect(router.match('GET', '/api/v1/users')).toBeDefined();
+    });
+
+    test('should apply middleware to route group', () => {
+      const middleware = () => new Response('middleware');
+      const api = router.group('/api', { middleware });
+      api.get('/users', mockHandler);
+
+      const match = router.match('GET', '/api/users');
+      expect(match?.middleware).toBeDefined();
+      expect(match?.middleware?.length).toBe(1);
+    });
+
+    test('should support group with both static and dynamic routes', () => {
+      const api = router.group('/api');
+      api.get('/users', handler1);
+      api.get('/users/:id', handler2);
+
+      expect(router.match('GET', '/api/users')?.handler).toBe(handler1);
+      expect(router.match('GET', '/api/users/123')?.handler).toBe(handler2);
+    });
+  });
+
+  describe('Route Information', () => {
+    test('should list all routes', () => {
+      router.get('/users', mockHandler);
+      router.post('/users', mockHandler);
+      router.get('/users/:id', mockHandler);
+
+      const routes = router.getRoutes();
+      expect(routes.length).toBe(3);
+    });
+
+    test('should include route metadata', () => {
+      router.get('/users', mockHandler, { name: 'users.list' });
+      const routes = router.getRoutes();
+      expect(routes[0].name).toBe('users.list');
+    });
+
+    test('should return route count breakdown', () => {
+      router.get('/users', mockHandler);       // static
+      router.get('/posts', mockHandler);       // static
+      router.get('/users/:id', mockHandler);   // dynamic
+      router.get('/posts/:id/comments', mockHandler); // dynamic
+
+      const count = router.getRouteCount();
+      expect(count.static).toBe(2);
+      expect(count.dynamic).toBe(2);
+      expect(count.total).toBe(4);
+    });
+  });
+
+  describe('Middleware', () => {
+    test('should accept handler with middleware', () => {
+      const middleware = () => new Response('middleware');
+      router.get('/protected', mockHandler, { middleware: [middleware] });
+
+      const match = router.match('GET', '/protected');
+      expect(match?.middleware).toHaveLength(1);
+    });
+
+    test('should accept single middleware', () => {
+      const middleware = () => new Response('middleware');
+      router.get('/protected', mockHandler, { middleware });
+
+      const match = router.match('GET', '/protected');
+      expect(match?.middleware).toHaveLength(1);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    test('should return undefined for non-matching route', () => {
+      router.get('/users', mockHandler);
+      expect(router.match('GET', '/posts')).toBeUndefined();
+    });
+
+    test('should return undefined for wrong method', () => {
+      router.get('/users', mockHandler);
+      expect(router.match('POST', '/users')).toBeUndefined();
+    });
+
+    test('should handle root path', () => {
+      router.get('/', mockHandler);
+      expect(router.match('GET', '/')).toBeDefined();
+    });
+
+    test('should handle empty optional param', () => {
+      router.get('/search/:query?', mockHandler);
+      const match = router.match('GET', '/search');
+      expect(match).toBeDefined();
+    });
+
+    test('should handle "ALL" method for dynamic routes', () => {
+      router.all('/api/*', mockHandler);
+      expect(router.match('GET', '/api/users')).toBeDefined();
+      expect(router.match('POST', '/api/users')).toBeDefined();
+      expect(router.match('DELETE', '/api/users/123')).toBeDefined();
+    });
+  });
+
+  describe('Async Handlers', () => {
+    test('should accept async handlers', async () => {
+      const asyncHandler: RouteHandler = async () => {
+        await Promise.resolve();
+        return new Response('async');
+      };
+
+      router.get('/async', asyncHandler);
+      const match = router.match('GET', '/async');
+      expect(match?.handler).toBe(asyncHandler);
+    });
+  });
+});

package/tests/unit/lock.test.ts

@@ -0,0 +1,336 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import {
+  DistributedLock,
+  createDistributedLock,
+  createMemoryLock,
+  LockAcquireError,
+} from '../../src/lock';
+
+describe('DistributedLock (In-Memory)', () => {
+  let lock: DistributedLock;
+
+  beforeEach(() => {
+    lock = createMemoryLock();
+  });
+
+  afterEach(() => {
+    lock.disconnect();
+  });
+
+  describe('Basic Lock Acquisition', () => {
+    test('should acquire a lock successfully', async () => {
+      const handle = await lock.acquire('test-key');
+
+      expect(handle.acquired).toBe(true);
+      expect(handle.key).toBe('lock:test-key');
+      expect(handle.value).toBeDefined();
+      expect(handle.value.length).toBe(32); // 16 bytes = 32 hex chars
+    });
+
+    test('should prevent concurrent access', async () => {
+      const handle1 = await lock.acquire('shared-key');
+      expect(handle1.acquired).toBe(true);
+
+      const handle2 = await lock.acquire('shared-key', { retryCount: 0 });
+      expect(handle2.acquired).toBe(false);
+    });
+
+    test('should release a lock', async () => {
+      const handle = await lock.acquire('release-test');
+      expect(handle.acquired).toBe(true);
+
+      const released = await handle.release();
+      expect(released).toBe(true);
+
+      // Should be able to acquire again
+      const handle2 = await lock.acquire('release-test');
+      expect(handle2.acquired).toBe(true);
+    });
+
+    test('should not release a lock we dont own', async () => {
+      const handle = await lock.acquire('ownership-test');
+      
+      // Create another lock instance trying to release
+      const otherLock = createMemoryLock();
+      const otherHandle = await otherLock.acquire('ownership-test', { retryCount: 0 });
+      
+      // Other lock should fail to acquire
+      expect(otherHandle.acquired).toBe(false);
+      
+      // Other handle release should return false
+      const released = await otherHandle.release();
+      expect(released).toBe(false);
+
+      otherLock.disconnect();
+    });
+  });
+
+  describe('Lock Extension', () => {
+    test('should extend a lock', async () => {
+      const handle = await lock.acquire('extend-test', { ttl: 1000 });
+      expect(handle.acquired).toBe(true);
+
+      const extended = await handle.extend(2000);
+      expect(extended).toBe(true);
+
+      const remaining = await handle.getRemainingTTL();
+      expect(remaining).toBeGreaterThan(1000);
+    });
+
+    test('should not extend a released lock', async () => {
+      const handle = await lock.acquire('extend-released-test');
+      await handle.release();
+
+      const extended = await handle.extend(1000);
+      expect(extended).toBe(false);
+    });
+  });
+
+  describe('Lock Validity', () => {
+    test('should check if lock is valid', async () => {
+      const handle = await lock.acquire('validity-test');
+      expect(await handle.isValid()).toBe(true);
+
+      await handle.release();
+      expect(await handle.isValid()).toBe(false);
+    });
+
+    test('should get remaining TTL', async () => {
+      const handle = await lock.acquire('ttl-test', { ttl: 5000 });
+      const remaining = await handle.getRemainingTTL();
+
+      expect(remaining).toBeGreaterThan(4000);
+      expect(remaining).toBeLessThanOrEqual(5000);
+    });
+
+    test('should return -1 for invalid lock TTL', async () => {
+      const handle = await lock.acquire('ttl-invalid-test', { retryCount: 0 });
+      
+      if (!handle.acquired) {
+        const remaining = await handle.getRemainingTTL();
+        expect(remaining).toBe(-1);
+      }
+    });
+  });
+
+  describe('Retry Logic', () => {
+    test('should retry on failure', async () => {
+      const handle1 = await lock.acquire('retry-test', { ttl: 100 });
+
+      // Start acquiring the same lock
+      const acquirePromise = lock.acquire('retry-test', {
+        ttl: 500,
+        retryCount: 5,
+        retryDelay: 50,
+      });
+
+      // Release the first lock after a short delay
+      setTimeout(() => handle1.release(), 80);
+
+      const handle2 = await acquirePromise;
+      expect(handle2.acquired).toBe(true);
+    });
+
+    test('should fail after max retries', async () => {
+      const handle1 = await lock.acquire('max-retry-test', { ttl: 10000 });
+
+      const handle2 = await lock.acquire('max-retry-test', {
+        ttl: 500,
+        retryCount: 2,
+        retryDelay: 10,
+      });
+
+      expect(handle2.acquired).toBe(false);
+
+      await handle1.release();
+    });
+  });
+
+  describe('withLock Helper', () => {
+    test('should execute function with lock', async () => {
+      const result = await lock.withLock('withlock-test', async (handle) => {
+        expect(handle.acquired).toBe(true);
+        return 'success';
+      });
+
+      expect(result).toBe('success');
+
+      // Lock should be released
+      const handle2 = await lock.acquire('withlock-test');
+      expect(handle2.acquired).toBe(true);
+    });
+
+    test('should release lock on error', async () => {
+      try {
+        await lock.withLock('error-test', async () => {
+          throw new Error('Test error');
+        });
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        expect((error as Error).message).toBe('Test error');
+      }
+
+      // Lock should be released even after error
+      const handle = await lock.acquire('error-test');
+      expect(handle.acquired).toBe(true);
+    });
+
+    test('should throw LockAcquireError if lock fails', async () => {
+      const handle1 = await lock.acquire('acquire-fail-test', { ttl: 10000 });
+
+      try {
+        await lock.withLock('acquire-fail-test', async () => 'success', {
+          retryCount: 0,
+        });
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        expect(error).toBeInstanceOf(LockAcquireError);
+      }
+
+      await handle1.release();
+    });
+  });
+
+  describe('withAutoExtend', () => {
+    test('should auto-extend lock for long operations', async () => {
+      const result = await lock.withAutoExtend(
+        'autoextend-test',
+        async (handle) => {
+          // Simulate long operation
+          await new Promise(resolve => setTimeout(resolve, 100));
+          
+          // Lock should still be valid
+          expect(await handle.isValid()).toBe(true);
+          
+          return 'completed';
+        },
+        { ttl: 50 } // Short TTL to trigger extension
+      );
+
+      expect(result).toBe('completed');
+    });
+  });
+
+  describe('tryLock', () => {
+    test('should try to acquire without waiting', async () => {
+      const handle = await lock.tryLock('trylock-test');
+      expect(handle.acquired).toBe(true);
+
+      const handle2 = await lock.tryLock('trylock-test');
+      expect(handle2.acquired).toBe(false);
+    });
+  });
+
+  describe('isLocked', () => {
+    test('should check if a key is locked', async () => {
+      expect(await lock.isLocked('check-locked')).toBe(false);
+
+      const handle = await lock.acquire('check-locked');
+      expect(await lock.isLocked('check-locked')).toBe(true);
+
+      await handle.release();
+      expect(await lock.isLocked('check-locked')).toBe(false);
+    });
+  });
+});
+
+describe('DistributedLock Factory Functions', () => {
+  test('createDistributedLock should create memory lock by default', () => {
+    const lock = createDistributedLock();
+    expect(lock.getDriverType()).toBe('memory');
+    lock.disconnect();
+  });
+
+  test('createMemoryLock should create memory lock', () => {
+    const lock = createMemoryLock();
+    expect(lock.getDriverType()).toBe('memory');
+    lock.disconnect();
+  });
+});
+
+describe('DistributedLock Connection State', () => {
+  test('should be connected after initialization for memory', () => {
+    const lock = createMemoryLock();
+    expect(lock.isConnected).toBe(true);
+    lock.disconnect();
+  });
+
+  test('should not be connected after disconnect', async () => {
+    const lock = createMemoryLock();
+    await lock.disconnect();
+    expect(lock.isConnected).toBe(false);
+  });
+});
+
+describe('Default Lock Instance', () => {
+  test('should use default lock instance', async () => {
+    const { getDefaultLock, lock: withLockFn } = await import('../../src/lock');
+    
+    const result = await withLockFn('default-test', async () => 'default-result');
+    expect(result).toBe('default-result');
+
+    const defaultLock = getDefaultLock();
+    expect(defaultLock).toBeDefined();
+  });
+});
+
+describe('Key Prefix', () => {
+  test('should use custom key prefix', async () => {
+    const lock = createDistributedLock({ keyPrefix: 'myapp:lock:' });
+    
+    const handle = await lock.acquire('prefixed-key');
+    expect(handle.key).toBe('myapp:lock:prefixed-key');
+
+    lock.disconnect();
+  });
+});
+
+describe('Concurrent Access Simulation', () => {
+  test('should handle sequential lock attempts', async () => {
+    const lock = createMemoryLock();
+    const results: number[] = [];
+    const lockKey = 'sequential-test';
+
+    // Sequential execution - each waits for the previous to complete
+    await lock.withLock(lockKey, async () => {
+      results.push(1);
+      await new Promise(r => setTimeout(r, 20));
+    });
+    
+    await lock.withLock(lockKey, async () => {
+      results.push(2);
+      await new Promise(r => setTimeout(r, 20));
+    });
+    
+    await lock.withLock(lockKey, async () => {
+      results.push(3);
+      await new Promise(r => setTimeout(r, 20));
+    });
+
+    expect(results).toEqual([1, 2, 3]);
+
+    lock.disconnect();
+  });
+
+  test('should allow retry on lock contention', async () => {
+    const lock = createMemoryLock();
+    const lockKey = 'retry-contention-test';
+    
+    // Acquire lock
+    const handle1 = await lock.acquire(lockKey, { ttl: 10000 });
+    expect(handle1.acquired).toBe(true);
+    
+    // Try to acquire with retry - should fail initially
+    let acquired = false;
+    const acquirePromise = lock.acquire(lockKey, { retryCount: 5, retryDelay: 20 });
+    
+    // Release after a short delay
+    setTimeout(() => handle1.release(), 50);
+    
+    const handle2 = await acquirePromise;
+    expect(handle2.acquired).toBe(true);
+    
+    await handle2.release();
+    lock.disconnect();
+  });
+});