odac 0.9.0

package/test/server/__mocks__/http-proxy.js

@@ -0,0 +1,105 @@
+/**
+ * Mock implementation of http-proxy module for server tests
+ */
+
+const {createMockEventEmitter} = require('./testHelpers')
+
+const createMockProxyServer = (options = {}) => {
+  const proxy = Object.assign(createMockEventEmitter(), {
+    options: options,
+
+    // Main proxy methods
+    web: jest.fn((req, res, options, callback) => {
+      // Simulate successful proxying
+      setTimeout(() => {
+        if (callback) callback()
+      }, 0)
+    }),
+
+    ws: jest.fn((req, socket, head, options, callback) => {
+      // Simulate WebSocket proxying
+      setTimeout(() => {
+        if (callback) callback()
+      }, 0)
+    }),
+
+    listen: jest.fn((port, hostname, callback) => {
+      if (typeof hostname === 'function') {
+        callback = hostname
+        hostname = undefined
+      }
+
+      setTimeout(() => {
+        if (callback) callback()
+      }, 0)
+
+      return proxy
+    }),
+
+    close: jest.fn(callback => {
+      setTimeout(() => {
+        if (callback) callback()
+      }, 0)
+    }),
+
+    // Test helper methods
+    simulateProxyReq: (proxyReq, req, res, options) => {
+      proxy.emit('proxyReq', proxyReq, req, res, options)
+    },
+
+    simulateProxyRes: (proxyRes, req, res) => {
+      proxy.emit('proxyRes', proxyRes, req, res)
+    },
+
+    simulateError: (error, req, res, target) => {
+      proxy.emit('error', error, req, res, target)
+    },
+
+    simulateOpen: proxySocket => {
+      proxy.emit('open', proxySocket)
+    },
+
+    simulateClose: (res, socket, head) => {
+      proxy.emit('close', res, socket, head)
+    }
+  })
+
+  return proxy
+}
+
+const httpProxy = {
+  createProxyServer: jest.fn((options = {}) => {
+    return createMockProxyServer(options)
+  }),
+
+  createServer: jest.fn((options = {}, requestListener) => {
+    if (typeof options === 'function') {
+      requestListener = options
+      options = {}
+    }
+
+    const proxy = createMockProxyServer(options)
+
+    // Add server-like methods
+    proxy.listen = jest.fn((port, hostname, callback) => {
+      if (typeof hostname === 'function') {
+        callback = hostname
+        hostname = undefined
+      }
+
+      setTimeout(() => {
+        proxy.emit('listening')
+        if (callback) callback()
+      }, 0)
+
+      return proxy
+    })
+
+    return proxy
+  }),
+
+  // Test helpers
+  __createMockProxyServer: createMockProxyServer
+}
+
+module.exports = httpProxy

package/test/server/__mocks__/http.js

@@ -0,0 +1,575 @@
+/**
+ * Mock implementation of the http module for server tests
+ * Provides comprehensive mocking of HTTP server and client operations
+ */
+
+const {createMockEventEmitter} = require('./testHelpers')
+const {createMockRequest, createMockResponse} = require('./testFactories')
+
+// Track active servers
+const activeServers = new Map()
+let nextServerId = 1
+
+const createMockIncomingMessage = (options = {}) => {
+  const message = createMockEventEmitter()
+
+  Object.assign(message, {
+    // HTTP properties
+    httpVersion: options.httpVersion || '1.1',
+    httpVersionMajor: options.httpVersionMajor || 1,
+    httpVersionMinor: options.httpVersionMinor || 1,
+    complete: false,
+
+    // Request properties
+    url: options.url || '/',
+    method: options.method || 'GET',
+    statusCode: options.statusCode,
+    statusMessage: options.statusMessage,
+
+    // Headers
+    headers: options.headers || {},
+    rawHeaders: options.rawHeaders || [],
+    trailers: {},
+    rawTrailers: [],
+
+    // Connection info
+    connection: {
+      remoteAddress: options.remoteAddress || '127.0.0.1',
+      remotePort: options.remotePort || 12345,
+      localAddress: options.localAddress || '127.0.0.1',
+      localPort: options.localPort || 80
+    },
+    socket: options.socket || null,
+
+    // Stream properties
+    readable: true,
+    readableEnded: false,
+
+    // Methods
+    setTimeout: jest.fn((msecs, callback) => {
+      if (callback) {
+        message.once('timeout', callback)
+      }
+      return message
+    }),
+
+    // Test helpers
+    __simulateData: chunk => {
+      if (message.readable) {
+        message.emit('data', Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))
+      }
+    },
+
+    __simulateEnd: () => {
+      message.complete = true
+      message.readableEnded = true
+      message.emit('end')
+    },
+
+    __simulateError: error => {
+      message.emit('error', error)
+    }
+  })
+
+  return message
+}
+
+const createMockServerResponse = (options = {}) => {
+  const response = createMockEventEmitter()
+
+  Object.assign(response, {
+    // Response properties
+    statusCode: 200,
+    statusMessage: 'OK',
+    headersSent: false,
+    finished: false,
+
+    // Headers
+    headers: {},
+
+    // Connection
+    connection: options.connection || null,
+    socket: options.socket || null,
+
+    // Stream properties
+    writable: true,
+    writableEnded: false,
+
+    // Methods
+    writeHead: jest.fn((statusCode, statusMessage, headers) => {
+      if (typeof statusMessage === 'object') {
+        headers = statusMessage
+        statusMessage = undefined
+      }
+
+      response.statusCode = statusCode
+      if (statusMessage) {
+        response.statusMessage = statusMessage
+      }
+
+      if (headers) {
+        Object.entries(headers).forEach(([name, value]) => {
+          response.setHeader(name, value)
+        })
+      }
+
+      response.headersSent = true
+      return response
+    }),
+
+    setHeader: jest.fn((name, value) => {
+      if (response.headersSent) {
+        throw new Error('Cannot set headers after they are sent to the client')
+      }
+      response.headers[name.toLowerCase()] = value
+      return response
+    }),
+
+    getHeader: jest.fn(name => {
+      return response.headers[name.toLowerCase()]
+    }),
+
+    getHeaders: jest.fn(() => {
+      return {...response.headers}
+    }),
+
+    getHeaderNames: jest.fn(() => {
+      return Object.keys(response.headers)
+    }),
+
+    hasHeader: jest.fn(name => {
+      return name.toLowerCase() in response.headers
+    }),
+
+    removeHeader: jest.fn(name => {
+      delete response.headers[name.toLowerCase()]
+      return response
+    }),
+
+    write: jest.fn((chunk, encoding, callback) => {
+      if (!response.writable) {
+        const error = new Error('Cannot write to finished response')
+        if (callback) callback(error)
+        return false
+      }
+
+      if (!response.headersSent) {
+        response.writeHead(response.statusCode)
+      }
+
+      if (typeof encoding === 'function') {
+        callback = encoding
+        encoding = 'utf8'
+      }
+
+      if (callback) {
+        setTimeout(callback, 0)
+      }
+
+      return true
+    }),
+
+    end: jest.fn((data, encoding, callback) => {
+      if (data) {
+        response.write(data, encoding)
+      }
+
+      if (typeof encoding === 'function') {
+        callback = encoding
+      }
+      if (typeof data === 'function') {
+        callback = data
+      }
+
+      response.finished = true
+      response.writable = false
+      response.writableEnded = true
+
+      setTimeout(() => {
+        response.emit('finish')
+        if (callback) callback()
+      }, 0)
+
+      return response
+    }),
+
+    setTimeout: jest.fn((msecs, callback) => {
+      if (callback) {
+        response.once('timeout', callback)
+      }
+      return response
+    }),
+
+    // Test helpers
+    __simulateError: error => {
+      response.emit('error', error)
+    }
+  })
+
+  return response
+}
+
+const createMockServer = (options = {}) => {
+  const server = createMockEventEmitter()
+  const serverId = nextServerId++
+
+  Object.assign(server, {
+    // Server properties
+    listening: false,
+    maxHeadersCount: null,
+    timeout: 120000,
+    keepAliveTimeout: 5000,
+    headersTimeout: 60000,
+    requestTimeout: 0,
+
+    // Methods
+    listen: jest.fn((port, hostname, backlog, callback) => {
+      // Handle different argument patterns
+      if (typeof port === 'function') {
+        callback = port
+        port = 0
+      } else if (typeof hostname === 'function') {
+        callback = hostname
+        hostname = undefined
+      } else if (typeof backlog === 'function') {
+        callback = backlog
+        backlog = undefined
+      }
+
+      server._port = port || 80
+      server._hostname = hostname || '0.0.0.0'
+      server.listening = true
+
+      if (callback) {
+        server.once('listening', callback)
+      }
+
+      setTimeout(() => {
+        server.emit('listening')
+      }, 0)
+
+      return server
+    }),
+
+    close: jest.fn(callback => {
+      server.listening = false
+
+      if (callback) {
+        server.once('close', callback)
+      }
+
+      setTimeout(() => {
+        server.emit('close')
+      }, 0)
+
+      activeServers.delete(serverId)
+      return server
+    }),
+
+    address: jest.fn(() => {
+      if (!server.listening) return null
+      return {
+        address: server._hostname || '0.0.0.0',
+        family: 'IPv4',
+        port: server._port || 80
+      }
+    }),
+
+    setTimeout: jest.fn((msecs, callback) => {
+      server.timeout = msecs
+      if (callback) {
+        server.on('timeout', callback)
+      }
+      return server
+    }),
+
+    // Test helpers
+    __simulateRequest: (requestOptions = {}, responseOptions = {}) => {
+      if (!server.listening) {
+        throw new Error('Server is not listening')
+      }
+
+      const req = createMockIncomingMessage({
+        url: '/',
+        method: 'GET',
+        headers: {host: 'localhost'},
+        ...requestOptions
+      })
+
+      const res = createMockServerResponse(responseOptions)
+
+      setTimeout(() => {
+        server.emit('request', req, res)
+      }, 0)
+
+      return {req, res}
+    },
+
+    __simulateError: error => {
+      server.emit('error', error)
+    }
+  })
+
+  activeServers.set(serverId, server)
+  return server
+}
+
+const createMockClientRequest = (options = {}) => {
+  const request = createMockEventEmitter()
+
+  Object.assign(request, {
+    // Request properties
+    method: options.method || 'GET',
+    path: options.path || '/',
+    host: options.host || 'localhost',
+    port: options.port || 80,
+
+    // State
+    aborted: false,
+    finished: false,
+
+    // Stream properties
+    writable: true,
+    writableEnded: false,
+
+    // Methods
+    write: jest.fn((chunk, encoding, callback) => {
+      if (!request.writable) {
+        const error = new Error('Cannot write to finished request')
+        if (callback) callback(error)
+        return false
+      }
+
+      if (typeof encoding === 'function') {
+        callback = encoding
+      }
+
+      if (callback) {
+        setTimeout(callback, 0)
+      }
+
+      return true
+    }),
+
+    end: jest.fn((data, encoding, callback) => {
+      if (data) {
+        request.write(data, encoding)
+      }
+
+      if (typeof encoding === 'function') {
+        callback = encoding
+      }
+      if (typeof data === 'function') {
+        callback = data
+      }
+
+      request.finished = true
+      request.writable = false
+      request.writableEnded = true
+
+      // Simulate response
+      setTimeout(() => {
+        const response = createMockIncomingMessage({
+          statusCode: 200,
+          statusMessage: 'OK',
+          headers: {'content-type': 'text/plain'}
+        })
+
+        request.emit('response', response)
+
+        // Simulate response data
+        setTimeout(() => {
+          response.__simulateData('Mock response data')
+          response.__simulateEnd()
+        }, 0)
+
+        if (callback) callback()
+      }, 0)
+
+      return request
+    }),
+
+    abort: jest.fn(() => {
+      request.aborted = true
+      request.emit('abort')
+      return request
+    }),
+
+    setTimeout: jest.fn((timeout, callback) => {
+      if (callback) {
+        request.once('timeout', callback)
+      }
+      return request
+    }),
+
+    setHeader: jest.fn((name, value) => {
+      // Mock implementation
+      return request
+    }),
+
+    getHeader: jest.fn(name => {
+      // Mock implementation
+      return undefined
+    }),
+
+    removeHeader: jest.fn(name => {
+      // Mock implementation
+      return request
+    }),
+
+    // Test helpers
+    __simulateError: error => {
+      request.emit('error', error)
+    },
+
+    __simulateResponse: (responseOptions = {}) => {
+      const response = createMockIncomingMessage({
+        statusCode: 200,
+        statusMessage: 'OK',
+        ...responseOptions
+      })
+
+      setTimeout(() => {
+        request.emit('response', response)
+      }, 0)
+
+      return response
+    }
+  })
+
+  return request
+}
+
+const http = {
+  // Server creation
+  createServer: jest.fn((options, requestListener) => {
+    if (typeof options === 'function') {
+      requestListener = options
+      options = {}
+    }
+
+    const server = createMockServer(options)
+
+    if (requestListener) {
+      server.on('request', requestListener)
+    }
+
+    return server
+  }),
+
+  // Client requests
+  request: jest.fn((options, callback) => {
+    if (typeof options === 'string') {
+      options = new URL(options)
+    }
+
+    const req = createMockClientRequest(options)
+
+    if (callback) {
+      req.once('response', callback)
+    }
+
+    return req
+  }),
+
+  get: jest.fn((options, callback) => {
+    const req = http.request(options, callback)
+    req.end()
+    return req
+  }),
+
+  // Classes
+  Server: jest.fn(function (options, requestListener) {
+    return createMockServer(options, requestListener)
+  }),
+
+  IncomingMessage: jest.fn(function (socket) {
+    return createMockIncomingMessage({socket})
+  }),
+
+  ServerResponse: jest.fn(function (req) {
+    return createMockServerResponse({connection: req?.connection})
+  }),
+
+  ClientRequest: jest.fn(function (options) {
+    return createMockClientRequest(options)
+  }),
+
+  // Constants
+  METHODS: [
+    'ACL',
+    'BIND',
+    'CHECKOUT',
+    'CONNECT',
+    'COPY',
+    'DELETE',
+    'GET',
+    'HEAD',
+    'LINK',
+    'LOCK',
+    'M-SEARCH',
+    'MERGE',
+    'MKACTIVITY',
+    'MKCALENDAR',
+    'MKCOL',
+    'MOVE',
+    'NOTIFY',
+    'OPTIONS',
+    'PATCH',
+    'POST',
+    'PROPFIND',
+    'PROPPATCH',
+    'PURGE',
+    'PUT',
+    'REBIND',
+    'REPORT',
+    'SEARCH',
+    'SOURCE',
+    'SUBSCRIBE',
+    'TRACE',
+    'UNBIND',
+    'UNLINK',
+    'UNLOCK',
+    'UNSUBSCRIBE'
+  ],
+
+  STATUS_CODES: {
+    100: 'Continue',
+    101: 'Switching Protocols',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    204: 'No Content',
+    300: 'Multiple Choices',
+    301: 'Moved Permanently',
+    302: 'Found',
+    304: 'Not Modified',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable'
+  },
+
+  // Global agent
+  globalAgent: {
+    maxSockets: Infinity,
+    maxFreeSockets: 256,
+    timeout: 0,
+    keepAlive: false,
+    keepAliveMsecs: 1000
+  },
+
+  // Test helpers
+  __getActiveServers: () => new Map(activeServers),
+  __clearAll: () => {
+    activeServers.clear()
+    nextServerId = 1
+  }
+}
+
+module.exports = http