@api-client/core 0.18.12 → 0.18.13

package/tests/unit/runtime/http-engine/connections/ConnectionManager.spec.ts

@@ -0,0 +1,379 @@
+import { test } from '@japa/runner'
+import net from 'net'
+import {
+  ConnectionManager,
+  ConnectionOptions,
+  ProxyConnectionOptions,
+  TunnelConnectionOptions,
+} from '../../../../../src/runtime/http-engine/connections/ConnectionManager.js'
+import { DirectConnection } from '../../../../../src/runtime/http-engine/connections/DirectConnection.js'
+import { ProxyConnection } from '../../../../../src/runtime/http-engine/connections/ProxyConnection.js'
+import { TunnelConnection } from '../../../../../src/runtime/http-engine/connections/TunnelConnection.js'
+import { createLogger, type Logger, type ILogObj } from '../../../../../src/lib/logging/index.js'
+import { type RequestStats, type HttpEngineOptions } from '../../../../../src/runtime/http-engine/CoreEngine.js'
+import { HttpCertificate } from '../../../../../src/models/ClientCertificate.js'
+
+test.group('ConnectionManager', (group) => {
+  let connectionManager: ConnectionManager
+  let logger: Logger<ILogObj>
+  let stats: RequestStats
+  let createdSockets: net.Socket[] = []
+
+  group.each.setup(() => {
+    logger = createLogger()
+    stats = {}
+    connectionManager = new ConnectionManager(logger, stats)
+    createdSockets = []
+  })
+
+  group.each.teardown(() => {
+    // Clean up any sockets created during tests
+    for (const socket of createdSockets) {
+      if (!socket.destroyed) {
+        socket.destroy()
+      }
+    }
+    createdSockets = []
+  })
+
+  test('createDirectConnection should return DirectConnection instance', ({ assert }) => {
+    const options = {
+      host: 'example.com',
+      port: 80,
+      protocol: 'http:',
+      logger,
+      stats,
+    }
+
+    const connection = connectionManager.createDirectConnection(options)
+    assert.instanceOf(connection, DirectConnection, 'creates DirectConnection instance')
+  })
+
+  test('createProxyConnection should return ProxyConnection instance', ({ assert }) => {
+    const options = {
+      host: 'example.com',
+      port: 80,
+      protocol: 'http:',
+      proxy: '127.0.0.1:8080',
+      proxyIsSsl: false,
+      targetUrl: 'http://example.com:80',
+      logger,
+      stats,
+    }
+
+    const connection = connectionManager.createProxyConnection(options)
+    assert.instanceOf(connection, ProxyConnection, 'creates ProxyConnection instance')
+  })
+
+  test('createTunnelConnection should return TunnelConnection instance', ({ assert }) => {
+    const options = {
+      host: 'example.com',
+      port: 443,
+      protocol: 'https:',
+      proxy: '127.0.0.1:8080',
+      proxyIsSsl: false,
+      targetUrl: 'https://example.com:443',
+      targetHost: 'example.com',
+      targetPort: 443,
+      logger,
+      stats,
+    }
+
+    const connection = connectionManager.createTunnelConnection(options)
+    assert.instanceOf(connection, TunnelConnection, 'creates TunnelConnection instance')
+  })
+
+  test('should create direct connection when no proxy is configured', async ({ assert }) => {
+    const mockSocket = new net.Socket()
+    createdSockets.push(mockSocket)
+
+    // Mock DirectConnection.connect to return our mock socket
+    const originalCreateDirectConnection = connectionManager.createDirectConnection
+    let capturedOptions: ConnectionOptions | undefined
+
+    connectionManager.createDirectConnection = (options) => {
+      capturedOptions = options
+      return {
+        connect: async () => mockSocket,
+      } as DirectConnection
+    }
+
+    const engineOptions: HttpEngineOptions = {
+      timeout: 5000,
+      validateCertificates: true,
+    }
+
+    const result = await connectionManager.createConnection('example.com', 80, 'http:', engineOptions)
+
+    assert.deepEqual(result, mockSocket, 'returns the socket from DirectConnection')
+    assert.equal(capturedOptions!.host, 'example.com', 'passes correct host')
+    assert.equal(capturedOptions!.port, 80, 'passes correct port')
+    assert.equal(capturedOptions!.protocol, 'http:', 'passes correct protocol')
+    assert.equal(capturedOptions!.timeout, 5000, 'passes timeout option')
+    assert.equal(capturedOptions!.validateCertificates, true, 'passes certificate validation option')
+    assert.equal(capturedOptions!.logger, logger, 'passes logger')
+    assert.equal(capturedOptions!.stats, stats, 'passes stats')
+
+    // Restore original method
+    connectionManager.createDirectConnection = originalCreateDirectConnection
+  })
+
+  test('should create proxy connection for HTTP through proxy', async ({ assert }) => {
+    const mockSocket = new net.Socket()
+    createdSockets.push(mockSocket)
+
+    // Mock ProxyConnection.connect to return our mock socket
+    const originalCreateProxyConnection = connectionManager.createProxyConnection
+    let capturedOptions: ProxyConnectionOptions | undefined
+
+    connectionManager.createProxyConnection = (options) => {
+      capturedOptions = options
+      return {
+        connect: async () => mockSocket,
+      } as ProxyConnection
+    }
+
+    const engineOptions: HttpEngineOptions = {
+      proxy: '127.0.0.1:8080',
+      timeout: 5000,
+      validateCertificates: false,
+      proxyUsername: 'user',
+      proxyPassword: 'pass',
+      proxyAuthorization: 'Basic',
+    }
+
+    const result = await connectionManager.createConnection('example.com', 80, 'http:', engineOptions)
+
+    assert.equal(result, mockSocket, 'returns the socket from ProxyConnection')
+    assert.equal(capturedOptions!.host, 'example.com', 'passes correct host')
+    assert.equal(capturedOptions!.port, 80, 'passes correct port')
+    assert.equal(capturedOptions!.protocol, 'http:', 'passes correct protocol')
+    assert.equal(capturedOptions!.proxy, '127.0.0.1:8080', 'passes proxy configuration')
+    assert.equal(capturedOptions!.proxyIsSsl, false, 'detects non-SSL proxy')
+    assert.equal(capturedOptions!.targetUrl, 'http://example.com:80', 'constructs target URL')
+    assert.equal(capturedOptions!.proxyUsername, 'user', 'passes proxy username')
+    assert.equal(capturedOptions!.proxyPassword, 'pass', 'passes proxy password')
+    assert.equal(capturedOptions!.proxyAuthorization, 'Basic', 'passes proxy authorization')
+
+    // Restore original method
+    connectionManager.createProxyConnection = originalCreateProxyConnection
+  })
+
+  test('should create tunnel connection for HTTPS through proxy', async ({ assert }) => {
+    const mockSocket = new net.Socket()
+    createdSockets.push(mockSocket)
+
+    // Mock TunnelConnection.connect to return our mock socket
+    const originalCreateTunnelConnection = connectionManager.createTunnelConnection
+    let capturedOptions: TunnelConnectionOptions | undefined
+
+    connectionManager.createTunnelConnection = (options) => {
+      capturedOptions = options
+      return {
+        connect: async () => mockSocket,
+      } as TunnelConnection
+    }
+
+    const engineOptions: HttpEngineOptions = {
+      proxy: 'https://proxy.example.com:8443',
+      timeout: 10000,
+      validateCertificates: true,
+      proxyUsername: 'admin',
+      proxyPassword: 'secret',
+    }
+
+    const result = await connectionManager.createConnection('secure.example.com', 443, 'https:', engineOptions)
+
+    assert.equal(result, mockSocket, 'returns the socket from TunnelConnection')
+    assert.equal(capturedOptions!.host, 'secure.example.com', 'passes correct host')
+    assert.equal(capturedOptions!.port, 443, 'passes correct port')
+    assert.equal(capturedOptions!.protocol, 'https:', 'passes correct protocol')
+    assert.equal(capturedOptions!.proxy, 'https://proxy.example.com:8443', 'passes proxy configuration')
+    assert.equal(capturedOptions!.proxyIsSsl, true, 'detects SSL proxy')
+    assert.equal(capturedOptions!.targetUrl, 'https://secure.example.com:443', 'constructs target URL')
+    assert.equal(capturedOptions!.targetHost, 'secure.example.com', 'passes target host')
+    assert.equal(capturedOptions!.targetPort, 443, 'passes target port')
+    assert.equal(capturedOptions!.proxyUsername, 'admin', 'passes proxy username')
+    assert.equal(capturedOptions!.proxyPassword, 'secret', 'passes proxy password')
+
+    // Restore original method
+    connectionManager.createTunnelConnection = originalCreateTunnelConnection
+  })
+
+  test('should detect SSL proxy correctly with https: scheme', async ({ assert }) => {
+    const mockSocket = new net.Socket()
+    createdSockets.push(mockSocket)
+
+    const originalCreateProxyConnection = connectionManager.createProxyConnection
+    let capturedOptions: ProxyConnectionOptions | undefined
+
+    connectionManager.createProxyConnection = (options) => {
+      capturedOptions = options
+      return {
+        connect: async () => mockSocket,
+      } as ProxyConnection
+    }
+
+    const engineOptions: HttpEngineOptions = {
+      proxy: 'https://secure-proxy.example.com:8443',
+    }
+
+    await connectionManager.createConnection('example.com', 80, 'http:', engineOptions)
+
+    assert.equal(capturedOptions!.proxyIsSsl, true, 'correctly identifies SSL proxy')
+
+    // Restore original method
+    connectionManager.createProxyConnection = originalCreateProxyConnection
+  })
+
+  test('should detect non-SSL proxy correctly without https: scheme', async ({ assert }) => {
+    const mockSocket = new net.Socket()
+    createdSockets.push(mockSocket)
+
+    const originalCreateProxyConnection = connectionManager.createProxyConnection
+    let capturedOptions: ProxyConnectionOptions | undefined
+
+    connectionManager.createProxyConnection = (options) => {
+      capturedOptions = options
+      return {
+        connect: async () => mockSocket,
+      } as ProxyConnection
+    }
+
+    const engineOptions: HttpEngineOptions = {
+      proxy: '192.168.1.100:3128',
+    }
+
+    const socket = await connectionManager.createConnection('example.com', 80, 'http:', engineOptions)
+    createdSockets.push(socket)
+
+    assert.equal(capturedOptions!.proxyIsSsl, false, 'correctly identifies non-SSL proxy')
+
+    // Restore original method
+    connectionManager.createProxyConnection = originalCreateProxyConnection
+  })
+
+  test('should pass client certificates to connection options', async ({ assert }) => {
+    const mockSocket = new net.Socket()
+    createdSockets.push(mockSocket)
+    const mockCertificates: HttpCertificate[] = [
+      {
+        key: 'abcd1234',
+        kind: 'Core#Certificate',
+        name: 'test-cert',
+        cert: { data: Buffer.from('cert-data') },
+        certKey: { data: Buffer.from('key-data'), passphrase: 'secret' },
+        type: 'pem',
+      },
+    ]
+
+    const originalCreateDirectConnection = connectionManager.createDirectConnection
+    let capturedOptions: ConnectionOptions | undefined
+
+    connectionManager.createDirectConnection = (options) => {
+      capturedOptions = options
+      return {
+        connect: async () => mockSocket,
+      } as DirectConnection
+    }
+
+    const engineOptions: HttpEngineOptions = {
+      certificates: mockCertificates,
+      validateCertificates: false,
+    }
+
+    await connectionManager.createConnection('client-cert.example.com', 443, 'https:', engineOptions)
+
+    assert.equal(capturedOptions!.certificates, mockCertificates, 'passes client certificates')
+    assert.equal(capturedOptions!.validateCertificates, false, 'passes certificate validation setting')
+
+    // Restore original method
+    connectionManager.createDirectConnection = originalCreateDirectConnection
+  })
+
+  test('should handle undefined optional parameters', async ({ assert }) => {
+    const mockSocket = new net.Socket()
+    createdSockets.push(mockSocket)
+
+    const originalCreateDirectConnection = connectionManager.createDirectConnection
+    let capturedOptions: ConnectionOptions | undefined
+
+    connectionManager.createDirectConnection = (options) => {
+      capturedOptions = options
+      return {
+        connect: async () => mockSocket,
+      } as DirectConnection
+    }
+
+    const engineOptions: HttpEngineOptions = {}
+
+    await connectionManager.createConnection('example.com', 80, 'http:', engineOptions)
+
+    assert.isUndefined(capturedOptions!.timeout, 'handles undefined timeout')
+    assert.isUndefined(capturedOptions!.validateCertificates, 'handles undefined certificate validation')
+    assert.isUndefined(capturedOptions!.certificates, 'handles undefined certificates')
+
+    // Restore original method
+    connectionManager.createDirectConnection = originalCreateDirectConnection
+  })
+
+  test('should handle custom ports correctly', async ({ assert }) => {
+    const mockSocket = new net.Socket()
+    createdSockets.push(mockSocket)
+
+    const originalCreateProxyConnection = connectionManager.createProxyConnection
+    let capturedOptions: ProxyConnectionOptions | undefined
+
+    connectionManager.createProxyConnection = (options) => {
+      capturedOptions = options
+      return {
+        connect: async () => mockSocket,
+      } as ProxyConnection
+    }
+
+    const engineOptions: HttpEngineOptions = {
+      proxy: '127.0.0.1:8080',
+    }
+
+    await connectionManager.createConnection('api.example.com', 8090, 'http:', engineOptions)
+
+    assert.equal(capturedOptions!.targetUrl, 'http://api.example.com:8090', 'constructs URL with custom port')
+
+    // Restore original method
+    connectionManager.createProxyConnection = originalCreateProxyConnection
+  })
+
+  test('should create working connection through proxy', async ({ assert, httpConfig }) => {
+    const engineOptions: HttpEngineOptions = {
+      proxy: `127.0.0.1:${httpConfig.proxyHttpPort}`,
+      timeout: 5000,
+      validateCertificates: false,
+    }
+
+    // Try to create a real connection through the proxy
+    const socket = await connectionManager.createConnection('httpbin.org', 80, 'http:', engineOptions)
+    createdSockets.push(socket)
+
+    assert.ok(socket, 'creates a real socket')
+    assert.instanceOf(socket, net.Socket, 'returns a net.Socket instance')
+
+    // Note: socket will be cleaned up in teardown
+  }).timeout(10000)
+
+  test('should create working HTTPS tunnel through proxy', async ({ assert, httpConfig }) => {
+    const engineOptions: HttpEngineOptions = {
+      proxy: `https://127.0.0.1:${httpConfig.proxyHttpsPort}`,
+      timeout: 5000,
+      validateCertificates: false,
+    }
+
+    // Try to create a real HTTPS tunnel through the proxy
+    const socket = await connectionManager.createConnection('httpbin.org', 443, 'https:', engineOptions)
+    createdSockets.push(socket)
+
+    assert.ok(socket, 'creates a real socket')
+    assert.instanceOf(socket, net.Socket, 'returns a net.Socket instance')
+
+    // Note: socket will be cleaned up in teardown
+  }).timeout(10000)
+})

package/tests/unit/runtime/http-engine/connections/DigestAuthHandler.spec.ts

@@ -0,0 +1,164 @@
+import { test } from '@japa/runner'
+import { DigestAuthHandler } from '../../../../../src/runtime/http-engine/connections/DigestAuthHandler.js'
+import { createLogger, type Logger, type ILogObj } from '../../../../../src/lib/logging/index.js'
+
+test.group('DigestAuthHandler', (group) => {
+  let handler: DigestAuthHandler
+  let logger: Logger<ILogObj>
+
+  group.each.setup(() => {
+    logger = createLogger()
+    handler = new DigestAuthHandler('testuser', 'testpass', logger)
+  })
+
+  test('should parse a basic Digest challenge', ({ assert }) => {
+    const challenge = handler.parseChallenge(
+      'Digest realm="testrealm", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", algorithm=MD5'
+    )
+
+    assert.equal(challenge.realm, 'testrealm')
+    assert.equal(challenge.nonce, 'dcd98b7102dd2f0e8b11d0f600bfb0c093')
+    assert.equal(challenge.algorithm, 'MD5')
+  })
+
+  test('should parse a challenge with qop', ({ assert }) => {
+    const challenge = handler.parseChallenge(
+      'Digest realm="testrealm", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", qop="auth"'
+    )
+
+    assert.equal(challenge.realm, 'testrealm')
+    assert.equal(challenge.nonce, 'dcd98b7102dd2f0e8b11d0f600bfb0c093')
+    assert.equal(challenge.qop, 'auth')
+  })
+
+  test('should throw error for non-Digest challenge', ({ assert }) => {
+    assert.throws(() => {
+      handler.parseChallenge('Basic realm="testrealm"')
+    }, 'Not a Digest authentication challenge')
+  })
+
+  test('should throw error for invalid challenge', ({ assert }) => {
+    assert.throws(() => {
+      handler.parseChallenge('Digest realm="testrealm"')
+    }, 'Invalid Digest challenge: missing realm or nonce')
+  })
+
+  test('should generate response without qop', ({ assert }) => {
+    const challenge = handler.parseChallenge(
+      'Digest realm="testrealm", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", algorithm=MD5'
+    )
+
+    const response = handler.generateResponse(challenge, 'CONNECT', '/')
+
+    assert.include(response, 'Digest')
+    assert.include(response, 'username="testuser"')
+    assert.include(response, 'realm="testrealm"')
+    assert.include(response, 'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093"')
+    assert.include(response, 'uri="/"')
+    assert.include(response, 'response=')
+    assert.include(response, 'algorithm="MD5"')
+  })
+
+  test('should generate response with qop', ({ assert }) => {
+    const challenge = handler.parseChallenge(
+      'Digest realm="testrealm", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", qop="auth", algorithm=MD5'
+    )
+
+    const response = handler.generateResponse(challenge, 'CONNECT', '/')
+
+    assert.include(response, 'Digest')
+    assert.include(response, 'username="testuser"')
+    assert.include(response, 'realm="testrealm"')
+    assert.include(response, 'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093"')
+    assert.include(response, 'uri="/"')
+    assert.include(response, 'response=')
+    assert.include(response, 'qop="auth"')
+    assert.include(response, 'nc=')
+    assert.include(response, 'cnonce=')
+  })
+
+  test('should handle opaque parameter', ({ assert }) => {
+    const challenge = handler.parseChallenge(
+      'Digest realm="testrealm", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", ' +
+        'opaque="5ccc069c403ebaf9f0171e9517f40e41"'
+    )
+
+    const response = handler.generateResponse(challenge, 'CONNECT', '/')
+
+    assert.include(response, 'opaque="5ccc069c403ebaf9f0171e9517f40e41"')
+  })
+
+  test('should throw error for unsupported qop', ({ assert }) => {
+    const challenge = handler.parseChallenge(
+      'Digest realm="testrealm", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", qop="auth-int"'
+    )
+
+    assert.throws(() => {
+      handler.generateResponse(challenge, 'CONNECT', '/')
+    }, 'Unsupported qop value: auth-int')
+  })
+
+  test('should increment nonce count for each request', ({ assert }) => {
+    const challenge = handler.parseChallenge(
+      'Digest realm="testrealm", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", qop="auth"'
+    )
+
+    const response1 = handler.generateResponse(challenge, 'CONNECT', '/')
+    const response2 = handler.generateResponse(challenge, 'CONNECT', '/')
+
+    // Extract nc values
+    const nc1Match = response1.match(/nc="([^"]+)"/)
+    const nc2Match = response2.match(/nc="([^"]+)"/)
+
+    assert.isNotNull(nc1Match)
+    assert.isNotNull(nc2Match)
+    assert.equal(nc1Match![1], '00000001')
+    assert.equal(nc2Match![1], '00000002')
+  })
+
+  test('should reset nonce count and generate new cnonce', ({ assert }) => {
+    const challenge = handler.parseChallenge(
+      'Digest realm="testrealm", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", qop="auth"'
+    )
+
+    const response1 = handler.generateResponse(challenge, 'CONNECT', '/')
+    handler.reset()
+    const response2 = handler.generateResponse(challenge, 'CONNECT', '/')
+
+    // Extract nc and cnonce values
+    const nc1Match = response1.match(/nc="([^"]+)"/)
+    const nc2Match = response2.match(/nc="([^"]+)"/)
+    const cnonce1Match = response1.match(/cnonce="([^"]+)"/)
+    const cnonce2Match = response2.match(/cnonce="([^"]+)"/)
+
+    assert.equal(nc1Match![1], '00000001')
+    assert.equal(nc2Match![1], '00000001') // Reset to 1
+    assert.notEqual(cnonce1Match![1], cnonce2Match![1]) // Different cnonce
+  })
+
+  test('should detect stale challenges', ({ assert }) => {
+    const staleChallenge = handler.parseChallenge(
+      'Digest realm="testrealm", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", stale=true'
+    )
+
+    const freshChallenge = handler.parseChallenge(
+      'Digest realm="testrealm", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", stale=false'
+    )
+
+    assert.isTrue(handler.isStale(staleChallenge))
+    assert.isFalse(handler.isStale(freshChallenge))
+  })
+
+  test('should calculate correct HA1', ({ assert }) => {
+    // This test verifies the MD5 calculation is correct
+    // HA1 = MD5(username:realm:password)
+    const challenge = handler.parseChallenge('Digest realm="testrealm", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093"')
+
+    const response = handler.generateResponse(challenge, 'CONNECT', '/')
+    const responseMatch = response.match(/response="([^"]+)"/)
+
+    assert.isNotNull(responseMatch)
+    // The response should be a valid MD5 hash
+    assert.match(responseMatch![1], /^[a-f0-9]{32}$/)
+  })
+})