renamed http-client to http and fixed tests

libs/http/test/mock-server.test.ts

@@ -0,0 +1,131 @@
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { MockServer } from './mock-server.js';
+
+/**
+ * Tests for the MockServer utility
+ * Ensures our test infrastructure works correctly
+ */
+
+describe('MockServer', () => {
+  let mockServer: MockServer;
+  let baseUrl: string;
+  
+  beforeAll(async () => {
+    mockServer = new MockServer();
+    await mockServer.start();
+    baseUrl = mockServer.getBaseUrl();
+  });
+  
+  afterAll(async () => {
+    await mockServer.stop();
+  });
+
+  describe('Server lifecycle', () => {
+    test('should start and provide base URL', () => {
+      expect(baseUrl).toMatch(/^http:\/\/localhost:\d+$/);
+      expect(mockServer.getBaseUrl()).toBe(baseUrl);
+    });
+
+    test('should be reachable', async () => {
+      const response = await fetch(`${baseUrl}/`);
+      expect(response.ok).toBe(true);
+    });
+  });
+
+  describe('Status endpoints', () => {
+    test('should return correct status codes', async () => {
+      const statusCodes = [200, 201, 400, 401, 403, 404, 500, 503];
+      
+      for (const status of statusCodes) {
+        const response = await fetch(`${baseUrl}/status/${status}`);
+        expect(response.status).toBe(status);
+      }
+    });
+  });
+
+  describe('Headers endpoint', () => {
+    test('should echo request headers', async () => {
+      const response = await fetch(`${baseUrl}/headers`, {
+        headers: {
+          'X-Test-Header': 'test-value',
+          'User-Agent': 'MockServer-Test'
+        }      });
+      
+      expect(response.ok).toBe(true);
+      const data = await response.json();
+      expect(data.headers).toHaveProperty('x-test-header', 'test-value');
+      expect(data.headers).toHaveProperty('user-agent', 'MockServer-Test');
+    });
+  });
+
+  describe('Basic auth endpoint', () => {
+    test('should authenticate valid credentials', async () => {
+      const username = 'testuser';
+      const password = 'testpass';
+      const credentials = btoa(`${username}:${password}`);
+      
+      const response = await fetch(`${baseUrl}/basic-auth/${username}/${password}`, {
+        headers: {
+          'Authorization': `Basic ${credentials}`
+        }
+      });
+      
+      expect(response.ok).toBe(true);
+      const data = await response.json();
+      expect(data.authenticated).toBe(true);
+      expect(data.user).toBe(username);
+    });
+
+    test('should reject invalid credentials', async () => {
+      const credentials = btoa('wrong:credentials');
+      
+      const response = await fetch(`${baseUrl}/basic-auth/user/pass`, {
+        headers: {
+          'Authorization': `Basic ${credentials}`
+        }
+      });
+      
+      expect(response.status).toBe(401);
+    });
+
+    test('should reject missing auth header', async () => {
+      const response = await fetch(`${baseUrl}/basic-auth/user/pass`);
+      expect(response.status).toBe(401);
+    });
+  });
+
+  describe('POST endpoint', () => {
+    test('should echo POST data', async () => {
+      const testData = {
+        message: 'Hello, MockServer!',
+        timestamp: Date.now()
+      };
+      
+      const response = await fetch(`${baseUrl}/post`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(testData)
+      });
+      
+      expect(response.ok).toBe(true);
+      const data = await response.json();
+      expect(data.data).toEqual(testData);
+      expect(data.method).toBe('POST');
+      expect(data.headers).toHaveProperty('content-type', 'application/json');
+    });
+  });
+
+  describe('Default endpoint', () => {
+    test('should return request information', async () => {
+      const response = await fetch(`${baseUrl}/unknown-endpoint`);
+      
+      expect(response.ok).toBe(true);
+      const data = await response.json();
+      expect(data.url).toBe(`${baseUrl}/unknown-endpoint`);
+      expect(data.method).toBe('GET');
+      expect(data.headers).toBeDefined();
+    });
+  });
+});