renamed http-client to http and fixed tests

libs/http/test/http.test.ts

@@ -0,0 +1,161 @@
+import { describe, test, expect, beforeEach, beforeAll, afterAll } from 'bun:test';
+import { HttpClient, HttpError, ProxyManager } from '../src/index.js';
+import type { ProxyConfig } from '../src/types.js';
+import { MockServer } from './mock-server.js';
+
+// Global mock server instance
+let mockServer: MockServer;
+let mockServerBaseUrl: string;
+
+beforeAll(async () => {
+  // Start mock server for all tests
+  mockServer = new MockServer();
+  await mockServer.start();
+  mockServerBaseUrl = mockServer.getBaseUrl();
+});
+
+afterAll(async () => {
+  // Stop mock server
+  await mockServer.stop();
+});
+
+describe('HttpClient', () => {
+  let client: HttpClient;
+
+  beforeEach(() => {
+    client = new HttpClient();
+  });
+
+  describe('Basic functionality', () => {
+    test('should create client with default config', () => {
+      expect(client).toBeInstanceOf(HttpClient);
+    });
+
+    test('should make GET request', async () => {
+      const response = await client.get(`${mockServerBaseUrl}/`);
+      
+      expect(response.status).toBe(200);
+      expect(response.data).toHaveProperty('url');
+      expect(response.data).toHaveProperty('method', 'GET');
+    });
+
+    test('should make POST request with body', async () => {
+      const testData = {
+        title: 'Test Post',
+        body: 'Test body',
+        userId: 1,
+      };
+      
+      const response = await client.post(`${mockServerBaseUrl}/post`, testData);
+      
+      expect(response.status).toBe(200);
+      expect(response.data).toHaveProperty('data');
+      expect(response.data.data).toEqual(testData);
+    });
+
+    test('should handle custom headers', async () => {
+      const customHeaders = {
+        'X-Custom-Header': 'test-value',
+        'User-Agent': 'StockBot-HTTP-Client/1.0'
+      };
+      
+      const response = await client.get(`${mockServerBaseUrl}/headers`, {
+        headers: customHeaders
+      });
+      
+      expect(response.status).toBe(200);
+      expect(response.data.headers).toHaveProperty('x-custom-header', 'test-value');
+      expect(response.data.headers).toHaveProperty('user-agent', 'StockBot-HTTP-Client/1.0');
+    });
+
+    test('should handle timeout', async () => {
+      const clientWithTimeout = new HttpClient({ timeout: 1 }); // 1ms timeout
+      
+      await expect(
+        clientWithTimeout.get('https://httpbin.org/delay/1')
+      ).rejects.toThrow();
+    });
+  });
+  describe('Error handling', () => {
+    test('should handle HTTP errors', async () => {
+      await expect(
+        client.get(`${mockServerBaseUrl}/status/404`)
+      ).rejects.toThrow(HttpError);
+    });
+
+    test('should handle network errors gracefully', async () => {
+      await expect(
+        client.get('https://nonexistent-domain-that-will-fail-12345.test')
+      ).rejects.toThrow();
+    });
+
+    test('should handle invalid URLs', async () => {
+      await expect(
+        client.get('not:/a:valid/url')
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('HTTP methods', () => {
+    test('should make PUT request', async () => {
+      const testData = { id: 1, name: 'Updated' };
+      const response = await client.put(`${mockServerBaseUrl}/post`, testData);
+      expect(response.status).toBe(200);
+    });
+
+    test('should make DELETE request', async () => {
+      const response = await client.del(`${mockServerBaseUrl}/`);
+      expect(response.status).toBe(200);
+      expect(response.data.method).toBe('DELETE');
+    });
+
+    test('should make PATCH request', async () => {
+      const testData = { name: 'Patched' };
+      const response = await client.patch(`${mockServerBaseUrl}/post`, testData);
+      expect(response.status).toBe(200);
+    });
+  });
+});
+
+describe('ProxyManager', () => {
+  test('should determine when to use Bun fetch', () => {
+    const httpProxy: ProxyConfig = {
+      protocol: 'http',
+      host: 'proxy.example.com',
+      port: 8080
+    };
+    
+    const socksProxy: ProxyConfig = {
+      protocol: 'socks5',
+      host: 'proxy.example.com',
+      port: 1080
+    };
+    
+    expect(ProxyManager.shouldUseBunFetch(httpProxy)).toBe(true);
+    expect(ProxyManager.shouldUseBunFetch(socksProxy)).toBe(false);
+  });
+
+  test('should create proxy URL for Bun fetch', () => {
+    const proxy: ProxyConfig = {
+      protocol: 'http',
+      host: 'proxy.example.com',
+      port: 8080,
+      username: 'user',
+      password: 'pass'
+    };
+    
+    const proxyUrl = ProxyManager.createBunProxyUrl(proxy);
+    expect(proxyUrl).toBe('http://user:pass@proxy.example.com:8080');
+  });
+
+  test('should create proxy URL without credentials', () => {
+    const proxy: ProxyConfig = {
+      protocol: 'https',
+      host: 'proxy.example.com',
+      port: 8080
+    };
+    
+    const proxyUrl = ProxyManager.createBunProxyUrl(proxy);
+    expect(proxyUrl).toBe('https://proxy.example.com:8080');
+  });
+});