@buenojs/bueno 0.8.0

package/tests/unit/security.test.ts

@@ -0,0 +1,174 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { Password, JWT, CSRF, createAuthMiddleware } from '../../src/security';
+import { Context } from '../../src/context';
+
+describe('Security', () => {
+  describe('Password', () => {
+    test('should hash password', async () => {
+      const password = 'mySecretPassword123';
+      const hash = await Password.hash(password);
+      
+      expect(hash).toBeDefined();
+      expect(hash).not.toBe(password);
+      expect(hash.length).toBeGreaterThan(0);
+    });
+
+    test('should verify correct password', async () => {
+      const password = 'mySecretPassword123';
+      const hash = await Password.hash(password);
+      
+      const isValid = await Password.verify(password, hash);
+      expect(isValid).toBe(true);
+    });
+
+    test('should reject wrong password', async () => {
+      const password = 'mySecretPassword123';
+      const hash = await Password.hash(password);
+      
+      const isValid = await Password.verify('wrongPassword', hash);
+      expect(isValid).toBe(false);
+    });
+
+    test('should generate unique hashes for same password', async () => {
+      const password = 'mySecretPassword123';
+      const hash1 = await Password.hash(password);
+      const hash2 = await Password.hash(password);
+      
+      expect(hash1).not.toBe(hash2);
+    });
+  });
+
+  describe('JWT', () => {
+    const secret = 'test-secret-key';
+    let jwt: JWT;
+
+    beforeEach(() => {
+      jwt = new JWT(secret);
+    });
+
+    test('should sign payload', async () => {
+      const payload = { userId: 123, email: 'test@example.com' };
+      const token = await jwt.sign(payload);
+      
+      expect(token).toBeDefined();
+      expect(typeof token).toBe('string');
+      expect(token.split('.').length).toBe(3); // header.payload.signature
+    });
+
+    test('should verify and decode token', async () => {
+      const payload = { userId: 123, email: 'test@example.com' };
+      const token = await jwt.sign(payload);
+      
+      const decoded = await jwt.verify(token);
+      
+      expect(decoded).toBeDefined();
+      expect(decoded?.userId).toBe(123);
+      expect(decoded?.email).toBe('test@example.com');
+    });
+
+    test('should reject invalid token', async () => {
+      const decoded = await jwt.verify('invalid.token.here');
+      expect(decoded).toBeNull();
+    });
+
+    test('should reject token signed with different secret', async () => {
+      const payload = { userId: 123 };
+      const token = await jwt.sign(payload);
+      
+      const otherJwt = new JWT('different-secret');
+      const decoded = await otherJwt.verify(token);
+      
+      expect(decoded).toBeNull();
+    });
+
+    test('should handle expired tokens', async () => {
+      const jwtWithExpiry = new JWT(secret, { expiresIn: -1 }); // Already expired
+      
+      const payload = { userId: 123 };
+      const token = await jwtWithExpiry.sign(payload);
+      
+      // Wait a moment for expiry
+      const decoded = await jwtWithExpiry.verify(token);
+      expect(decoded).toBeNull();
+    });
+  });
+
+  describe('CSRF', () => {
+    test('should generate CSRF token', () => {
+      const token = CSRF.generate();
+      
+      expect(token).toBeDefined();
+      expect(typeof token).toBe('string');
+      expect(token.length).toBeGreaterThan(0);
+    });
+
+    test('should generate unique tokens', () => {
+      const token1 = CSRF.generate();
+      const token2 = CSRF.generate();
+      
+      expect(token1).not.toBe(token2);
+    });
+
+    test('should validate token with same value', () => {
+      const token = CSRF.generate();
+      
+      expect(CSRF.verify(token, token)).toBe(true);
+    });
+
+    test('should reject invalid token', () => {
+      expect(CSRF.verify('invalid-token', 'different-token')).toBe(false);
+    });
+  });
+
+  describe('Auth Middleware', () => {
+    const secret = 'test-secret';
+    let jwt: JWT;
+
+    beforeEach(() => {
+      jwt = new JWT(secret);
+    });
+
+    test('should allow valid JWT', async () => {
+      const token = await jwt.sign({ userId: 1 });
+      const request = new Request('http://localhost:3000/protected', {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+      const context = new Context(request, {});
+
+      const middleware = createAuthMiddleware({ jwt });
+      let passed = false;
+      
+      const response = await middleware(context, async () => {
+        passed = true;
+        return new Response('OK');
+      });
+
+      expect(passed).toBe(true);
+      expect(context.get('user')).toBeDefined();
+    });
+
+    test('should reject missing token', async () => {
+      const request = new Request('http://localhost:3000/protected');
+      const context = new Context(request, {});
+
+      const middleware = createAuthMiddleware({ jwt });
+      
+      const response = await middleware(context, async () => new Response('OK'));
+
+      expect(response.status).toBe(401);
+    });
+
+    test('should reject invalid token', async () => {
+      const request = new Request('http://localhost:3000/protected', {
+        headers: { Authorization: 'Bearer invalid-token' },
+      });
+      const context = new Context(request, {});
+
+      const middleware = createAuthMiddleware({ jwt });
+      
+      const response = await middleware(context, async () => new Response('OK'));
+
+      expect(response.status).toBe(401);
+    });
+  });
+});

package/tests/unit/telemetry.test.ts

@@ -0,0 +1,371 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  Span,
+  SpanEvent,
+  SpanKind,
+  StatusCode,
+  SpanStatus,
+  SpanOptions,
+  OTLPExporterOptions,
+  SamplerType,
+  TracerOptions,
+  TraceContext,
+  OTLPExporter,
+  Tracer,
+  generateTraceId,
+  generateSpanId,
+  nowNanoseconds,
+  createTracer,
+  traceMiddleware,
+  traceDatabase,
+  createTracedFetch,
+  SpanBuilder,
+  span,
+} from '../../src/telemetry/index.ts';
+
+describe('Telemetry Module', () => {
+  test('generateTraceId should return 32 hex characters', () => {
+    const traceId = generateTraceId();
+    expect(traceId).toHaveLength(32);
+    expect(/^[0-9a-f]{32}$/.test(traceId)).toBe(true);
+  });
+
+  test('generateSpanId should return 16 hex characters', () => {
+    const spanId = generateSpanId();
+    expect(spanId).toHaveLength(16);
+    expect(/^[0-9a-f]{16}$/.test(spanId)).toBe(true);
+  });
+
+  test('nowNanoseconds should return a number', () => {
+    const now = nowNanoseconds();
+    expect(typeof now).toBe('number');
+    expect(now).toBeGreaterThan(0);
+  });
+
+  test('Tracer should create spans', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    const span = tracer.startSpan('test-operation', { kind: 'internal' });
+    
+    expect(span.name).toBe('test-operation');
+    expect(span.kind).toBe('internal');
+    expect(span.traceId).toHaveLength(32);
+    expect(span.spanId).toHaveLength(16);
+    expect(span.ended).toBe(false);
+  });
+
+  test('Tracer should end spans', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    const span = tracer.startSpan('test-operation');
+    
+    tracer.endSpan(span);
+    
+    expect(span.ended).toBe(true);
+    expect(span.endTime).toBeDefined();
+    expect(span.duration).toBeDefined();
+    expect(span.duration).toBeGreaterThanOrEqual(0);
+  });
+
+  test('Tracer should add attributes', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    const span = tracer.startSpan('test-operation');
+    
+    tracer.setAttribute(span, 'key1', 'value1');
+    tracer.setAttribute(span, 'key2', 123);
+    tracer.setAttribute(span, 'key3', true);
+    
+    expect(span.attributes['key1']).toBe('value1');
+    expect(span.attributes['key2']).toBe(123);
+    expect(span.attributes['key3']).toBe(true);
+  });
+
+  test('Tracer should add events', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    const span = tracer.startSpan('test-operation');
+    
+    tracer.addEvent(span, 'event1', { detail: 'test' });
+    
+    expect(span.events).toHaveLength(1);
+    expect(span.events[0].name).toBe('event1');
+    expect(span.events[0].attributes).toEqual({ detail: 'test' });
+  });
+
+  test('Tracer should set status', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    const span = tracer.startSpan('test-operation');
+    
+    tracer.setStatus(span, 'ok');
+    expect(span.status.code).toBe('ok');
+    
+    tracer.setStatus(span, 'error', 'Something went wrong');
+    expect(span.status.code).toBe('error');
+    expect(span.status.message).toBe('Something went wrong');
+  });
+
+  test('Tracer should record errors', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    const span = tracer.startSpan('test-operation');
+    
+    const error = new Error('Test error');
+    tracer.setError(span, error);
+    
+    expect(span.status.code).toBe('error');
+    expect(span.status.message).toBe('Test error');
+    expect(span.events).toHaveLength(1);
+    expect(span.events[0].name).toBe('exception');
+  });
+
+  test('Tracer.withSpan should manage span lifecycle', async () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    
+    const result = await tracer.withSpan('test-operation', async (span) => {
+      tracer.setAttribute(span, 'test', 'value');
+      return 'success';
+    });
+    
+    expect(result).toBe('success');
+  });
+
+  test('Tracer.withSpan should record errors', async () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    
+    try {
+      await tracer.withSpan('test-operation', async () => {
+        throw new Error('Test error');
+      });
+      expect(true).toBe(false); // Should not reach here
+    } catch (e) {
+      expect((e as Error).message).toBe('Test error');
+    }
+  });
+
+  test('Tracer should inject context', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    const span = tracer.startSpan('test-operation');
+    
+    const carrier: Record<string, string> = {};
+    tracer.injectContext(carrier, span);
+    
+    expect(carrier['traceparent']).toBeDefined();
+    expect(carrier['traceparent']).toMatch(/^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$/);
+  });
+
+  test('Tracer should extract context', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    
+    const carrier = {
+      traceparent: '00-0123456789abcdef0123456789abcdef-0123456789abcdef-01',
+    };
+    
+    const context = tracer.extractContext(carrier);
+    
+    expect(context).not.toBeNull();
+    expect(context!.traceId).toBe('0123456789abcdef0123456789abcdef');
+    expect(context!.spanId).toBe('0123456789abcdef');
+    expect(context!.traceFlags).toBe(1);
+  });
+
+  test('Tracer should return null for invalid traceparent', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    
+    expect(tracer.extractContext({})).toBeNull();
+    expect(tracer.extractContext({ traceparent: 'invalid' })).toBeNull();
+  });
+
+  test('createTracer should create a configured tracer', () => {
+    const tracer = createTracer('my-service', {
+      sampler: 'always',
+    });
+    
+    expect(tracer).toBeInstanceOf(Tracer);
+  });
+
+  test('Tracer should support never sampler', () => {
+    const tracer = new Tracer({ serviceName: 'test-service', sampler: 'never' });
+    const span = tracer.startSpan('test-operation');
+    
+    // Span should still be created but not exported
+    expect(span.name).toBe('test-operation');
+  });
+
+  test('Tracer should support probabilistic sampler', () => {
+    const tracer = new Tracer({ 
+      serviceName: 'test-service', 
+      sampler: 'probabilistic',
+      probability: 0.5,
+    });
+    
+    // Create multiple spans and verify some are sampled
+    const spans = [];
+    for (let i = 0; i < 10; i++) {
+      spans.push(tracer.startSpan('test-operation'));
+    }
+    
+    // All spans should be created
+    expect(spans).toHaveLength(10);
+  });
+
+  test('Tracer should create child spans', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    const parentSpan = tracer.startSpan('parent-operation');
+    
+    const childSpan = tracer.startSpan('child-operation', { parent: parentSpan });
+    
+    expect(childSpan.traceId).toBe(parentSpan.traceId);
+    expect(childSpan.parentSpanId).toBe(parentSpan.spanId);
+  });
+
+  test('Tracer should set multiple attributes at once', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    const span = tracer.startSpan('test-operation');
+    
+    tracer.setAttributes(span, {
+      key1: 'value1',
+      key2: 123,
+      key3: true,
+    });
+    
+    expect(span.attributes['key1']).toBe('value1');
+    expect(span.attributes['key2']).toBe(123);
+    expect(span.attributes['key3']).toBe(true);
+  });
+
+  test('Tracer should update span name', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    const span = tracer.startSpan('test-operation');
+    
+    tracer.updateName(span, 'updated-operation');
+    
+    expect(span.name).toBe('updated-operation');
+  });
+
+  test('Tracer should not modify ended spans', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    const span = tracer.startSpan('test-operation');
+    
+    tracer.endSpan(span);
+    
+    // These should be no-ops
+    tracer.setAttribute(span, 'key', 'value');
+    tracer.addEvent(span, 'event');
+    tracer.setStatus(span, 'error');
+    
+    expect(span.attributes).toEqual({});
+    expect(span.events).toHaveLength(0);
+    expect(span.status.code).toBe('unset');
+  });
+
+  test('Tracer should get current span', async () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    
+    expect(tracer.getCurrentSpan()).toBeNull();
+    
+    await tracer.withSpan('test-operation', async (span) => {
+      expect(tracer.getCurrentSpan()).toBe(span);
+    });
+    
+    expect(tracer.getCurrentSpan()).toBeNull();
+  });
+
+  test('SpanBuilder should provide fluent API', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    
+    const spanObj = span(tracer, 'test-operation', { kind: 'server' })
+      .setAttribute('key1', 'value1')
+      .setAttributes({ key2: 123, key3: true })
+      .addEvent('event1', { detail: 'test' })
+      .setStatus('ok')
+      .end();
+    
+    expect(spanObj.name).toBe('test-operation');
+    expect(spanObj.kind).toBe('server');
+    expect(spanObj.attributes['key1']).toBe('value1');
+    expect(spanObj.attributes['key2']).toBe(123);
+    expect(spanObj.events).toHaveLength(1);
+    expect(spanObj.status.code).toBe('ok');
+    expect(spanObj.ended).toBe(true);
+  });
+
+  test('OTLPExporter should be created with options', () => {
+    const exporter = new OTLPExporter({
+      endpoint: 'http://localhost:4318/v1/traces',
+      headers: { 'Authorization': 'Bearer token' },
+      exportInterval: 5000,
+      maxBatchSize: 100,
+    });
+    
+    expect(exporter).toBeInstanceOf(OTLPExporter);
+  });
+
+  test('OTLPExporter should set service name', () => {
+    const exporter = new OTLPExporter({
+      endpoint: 'http://localhost:4318/v1/traces',
+    });
+    
+    exporter.setServiceName('test-service');
+    exporter.setResourceAttributes({ version: '1.0.0' });
+  });
+
+  test('OTLPExporter should handle empty flush', async () => {
+    const exporter = new OTLPExporter({
+      endpoint: 'http://localhost:4318/v1/traces',
+    });
+    
+    // Should not throw
+    await exporter.flush();
+    await exporter.close();
+  });
+
+  test('traceDatabase should wrap database methods', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    
+    const db = {
+      query: async (sql: string) => [{ id: 1 }],
+      execute: async (sql: string) => { },
+    };
+    
+    const tracedDb = traceDatabase(tracer, db, 'postgresql');
+    
+    expect(typeof tracedDb.query).toBe('function');
+    expect(typeof tracedDb.execute).toBe('function');
+  });
+
+  test('createTracedFetch should create traced fetch function', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    const tracedFetch = createTracedFetch(tracer);
+    
+    expect(typeof tracedFetch).toBe('function');
+  });
+
+  test('Tracer should start span from extracted context', () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    
+    const context: TraceContext = {
+      traceId: '0123456789abcdef0123456789abcdef',
+      spanId: '0123456789abcdef',
+      traceFlags: 1,
+    };
+    
+    const span = tracer.startSpanFromContext('child-operation', context);
+    
+    expect(span.traceId).toBe(context.traceId);
+    expect(span.parentSpanId).toBe(context.spanId);
+  });
+
+  test('Tracer should handle nested withSpan calls', async () => {
+    const tracer = new Tracer({ serviceName: 'test-service' });
+    
+    await tracer.withSpan('parent', async (parentSpan) => {
+      expect(tracer.getCurrentSpan()).toBe(parentSpan);
+      
+      await tracer.withSpan('child', async (childSpan) => {
+        expect(tracer.getCurrentSpan()).toBe(childSpan);
+        expect(childSpan.parentSpanId).toBe(parentSpan.spanId);
+        expect(childSpan.traceId).toBe(parentSpan.traceId);
+      });
+      
+      expect(tracer.getCurrentSpan()).toBe(parentSpan);
+    });
+    
+    expect(tracer.getCurrentSpan()).toBeNull();
+  });
+});

package/tests/unit/test-cache.test.ts

@@ -0,0 +1,110 @@
+import { describe, test, expect } from "bun:test";
+import {
+	createTestCache,
+	TestCache,
+	assertCacheHas,
+	assertCacheNotHas,
+	assertCacheValue,
+	assertCacheStats,
+} from "../../src/testing/index";
+
+describe("TestCache", () => {
+	test("should create cache with initial data", async () => {
+		const cache = await createTestCache({ user: { id: 1, name: "Test" } });
+		const user = await cache.get("user");
+		expect(user).toEqual({ id: 1, name: "Test" });
+	});
+
+	test("should track operations", async () => {
+		const cache = new TestCache();
+		await cache.set("key1", "value1");
+		await cache.get("key1");
+		await cache.get("missing");
+
+		expect(cache.operations).toHaveLength(3);
+		expect(cache.operations[0].type).toBe("set");
+		expect(cache.operations[1].type).toBe("get");
+	});
+
+	test("should track statistics", async () => {
+		const cache = new TestCache();
+		await cache.set("key1", "value1");
+		await cache.get("key1"); // hit
+		await cache.get("missing"); // miss
+
+		const stats = cache.getStats();
+		expect(stats.hits).toBe(1);
+		expect(stats.misses).toBe(1);
+		expect(stats.sets).toBe(1);
+		expect(stats.keyCount).toBe(1);
+	});
+
+	test("peek should not affect stats", async () => {
+		const cache = new TestCache();
+		await cache.set("key1", "value1");
+		cache.peek("key1");
+		cache.peek("missing");
+
+		const stats = cache.getStats();
+		expect(stats.hits).toBe(0);
+		expect(stats.misses).toBe(0);
+	});
+
+	test("setMany should set multiple entries", async () => {
+		const cache = new TestCache();
+		await cache.setMany({ a: 1, b: 2, c: 3 });
+
+		expect(cache.getKeys()).toContain("a");
+		expect(cache.getKeys()).toContain("b");
+		expect(cache.getKeys()).toContain("c");
+	});
+
+	test("reset should clear everything", async () => {
+		const cache = new TestCache();
+		await cache.set("key1", "value1");
+		await cache.get("key1");
+		cache.reset();
+
+		expect(cache.getKeys()).toHaveLength(0);
+		expect(cache.operations).toHaveLength(0);
+		expect(cache.getStats().sets).toBe(0);
+	});
+
+	test("assertions should work", async () => {
+		const cache = await createTestCache({ existing: "value" });
+
+		assertCacheHas(cache, "existing");
+		assertCacheNotHas(cache, "missing");
+		assertCacheValue(cache, "existing", "value");
+		assertCacheStats(cache, { keyCount: 1 });
+	});
+
+	test("getEntries should return all key-value pairs", async () => {
+		const cache = new TestCache();
+		await cache.set("a", 1);
+		await cache.set("b", 2);
+
+		const entries = cache.getEntries();
+		expect(entries).toHaveLength(2);
+		expect(Object.fromEntries(entries)).toEqual({ a: 1, b: 2 });
+	});
+
+	test("clearAll should clear all keys", async () => {
+		const cache = new TestCache();
+		await cache.set("a", 1);
+		await cache.set("b", 2);
+		await cache.clearAll();
+
+		expect(cache.getKeys()).toHaveLength(0);
+	});
+
+	test("delete should track deletes in stats", async () => {
+		const cache = new TestCache();
+		await cache.set("key1", "value1");
+		await cache.delete("key1");
+
+		const stats = cache.getStats();
+		expect(stats.deletes).toBe(1);
+		expect(stats.keyCount).toBe(0);
+	});
+});