odac 0.9.0

package/test/server/__mocks__/https.js

@@ -0,0 +1,272 @@
+/**
+ * Mock implementation of the https module for server tests
+ * Extends the http mock with SSL/TLS specific functionality
+ */
+
+const http = require('./http')
+const {createMockEventEmitter} = require('./testHelpers')
+
+// Track active HTTPS servers
+const activeHttpsServers = new Map()
+let nextHttpsServerId = 1
+
+const createMockHttpsServer = (options = {}) => {
+  const server = createMockEventEmitter()
+  const serverId = nextHttpsServerId++
+
+  // Inherit from HTTP server mock
+  const httpServer = http.createServer()
+  Object.setPrototypeOf(server, httpServer)
+  Object.assign(server, httpServer)
+
+  // Override and add HTTPS-specific properties
+  Object.assign(server, {
+    // SSL/TLS properties
+    cert: options.cert || null,
+    key: options.key || null,
+    ca: options.ca || null,
+    ciphers: options.ciphers || null,
+    secureProtocol: options.secureProtocol || 'TLSv1_2_method',
+
+    // SNI callback
+    SNICallback: options.SNICallback || null,
+
+    // Override listen to handle HTTPS port default
+    listen: jest.fn((port, hostname, backlog, callback) => {
+      // Handle different argument patterns
+      if (typeof port === 'function') {
+        callback = port
+        port = 443
+      } else if (typeof hostname === 'function') {
+        callback = hostname
+        hostname = undefined
+      } else if (typeof backlog === 'function') {
+        callback = backlog
+        backlog = undefined
+      }
+
+      server._port = port || 443
+      server._hostname = hostname || '0.0.0.0'
+      server.listening = true
+
+      if (callback) {
+        server.once('listening', callback)
+      }
+
+      setTimeout(() => {
+        server.emit('listening')
+      }, 0)
+
+      return server
+    }),
+
+    // SSL/TLS specific methods
+    addContext: jest.fn((hostname, context) => {
+      if (!server._contexts) {
+        server._contexts = new Map()
+      }
+      server._contexts.set(hostname, context)
+      return server
+    }),
+
+    // Test helpers
+    __simulateSecureConnection: (socket, options = {}) => {
+      const secureSocket = Object.assign(socket, {
+        encrypted: true,
+        authorized: options.authorized !== false,
+        authorizationError: options.authorizationError || null,
+        getPeerCertificate: jest.fn(() => ({
+          subject: {CN: options.commonName || 'localhost'},
+          issuer: {CN: 'Test CA'},
+          valid_from: new Date().toISOString(),
+          valid_to: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString(),
+          fingerprint: 'AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD'
+        })),
+        getCipher: jest.fn(() => ({
+          name: 'ECDHE-RSA-AES128-GCM-SHA256',
+          version: 'TLSv1.2'
+        })),
+        getProtocol: jest.fn(() => 'TLSv1.2'),
+        getSession: jest.fn(() => Buffer.alloc(0))
+      })
+
+      setTimeout(() => {
+        server.emit('secureConnection', secureSocket)
+      }, 0)
+
+      return secureSocket
+    },
+
+    __simulateClientError: (error, socket) => {
+      server.emit('clientError', error, socket)
+    },
+
+    __getContexts: () => server._contexts || new Map()
+  })
+
+  activeHttpsServers.set(serverId, server)
+  return server
+}
+
+const createMockHttpsClientRequest = (options = {}) => {
+  const request = createMockEventEmitter()
+
+  // Inherit from HTTP client request mock
+  const httpRequest = http.request(options)
+  Object.setPrototypeOf(request, httpRequest)
+  Object.assign(request, httpRequest)
+
+  // Add HTTPS-specific properties
+  Object.assign(request, {
+    // SSL/TLS properties
+    rejectUnauthorized: options.rejectUnauthorized !== false,
+    servername: options.servername || options.hostname,
+
+    // Override end to simulate SSL handshake
+    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 SSL handshake and response
+      setTimeout(() => {
+        // Emit secureConnect event
+        request.emit('secureConnect')
+
+        const response = http.IncomingMessage()
+        Object.assign(response, {
+          statusCode: 200,
+          statusMessage: 'OK',
+          headers: {'content-type': 'text/plain'},
+          connection: {
+            encrypted: true,
+            authorized: true,
+            getPeerCertificate: jest.fn(() => ({
+              subject: {CN: options.servername || 'localhost'},
+              issuer: {CN: 'Test CA'},
+              valid_from: new Date().toISOString(),
+              valid_to: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString()
+            }))
+          }
+        })
+
+        request.emit('response', response)
+
+        // Simulate response data
+        setTimeout(() => {
+          response.__simulateData('Mock HTTPS response data')
+          response.__simulateEnd()
+        }, 0)
+
+        if (callback) callback()
+      }, 0)
+
+      return request
+    })
+  })
+
+  return request
+}
+
+const https = {
+  // Server creation
+  createServer: jest.fn((options, requestListener) => {
+    if (typeof options === 'function') {
+      requestListener = options
+      options = {}
+    }
+
+    const server = createMockHttpsServer(options)
+
+    if (requestListener) {
+      server.on('request', requestListener)
+    }
+
+    return server
+  }),
+
+  // Client requests
+  request: jest.fn((options, callback) => {
+    if (typeof options === 'string') {
+      const url = new URL(options)
+      options = {
+        hostname: url.hostname,
+        port: url.port || 443,
+        path: url.pathname + url.search,
+        method: 'GET'
+      }
+    }
+
+    const req = createMockHttpsClientRequest(options)
+
+    if (callback) {
+      req.once('response', callback)
+    }
+
+    return req
+  }),
+
+  get: jest.fn((options, callback) => {
+    const req = https.request(options, callback)
+    req.end()
+    return req
+  }),
+
+  // Classes
+  Server: jest.fn(function (options, requestListener) {
+    return createMockHttpsServer(options, requestListener)
+  }),
+
+  Agent: jest.fn(function (options = {}) {
+    return {
+      maxSockets: options.maxSockets || Infinity,
+      maxFreeSockets: options.maxFreeSockets || 256,
+      timeout: options.timeout || 0,
+      keepAlive: options.keepAlive || false,
+      keepAliveMsecs: options.keepAliveMsecs || 1000,
+      maxCachedSessions: options.maxCachedSessions || 100,
+      servername: options.servername,
+
+      // Methods
+      createConnection: jest.fn(),
+      keepSocketAlive: jest.fn(),
+      reuseSocket: jest.fn(),
+      destroy: jest.fn()
+    }
+  }),
+
+  // Global agent
+  globalAgent: {
+    maxSockets: Infinity,
+    maxFreeSockets: 256,
+    timeout: 0,
+    keepAlive: false,
+    keepAliveMsecs: 1000,
+    maxCachedSessions: 100
+  },
+
+  // Inherit HTTP constants and methods
+  METHODS: http.METHODS,
+  STATUS_CODES: http.STATUS_CODES,
+
+  // Test helpers
+  __getActiveServers: () => new Map(activeHttpsServers),
+  __clearAll: () => {
+    activeHttpsServers.clear()
+    nextHttpsServerId = 1
+    http.__clearAll()
+  }
+}
+
+module.exports = https

package/test/server/__mocks__/index.js

@@ -0,0 +1,249 @@
+/**
+ * Index file for all server test mocks
+ * Provides easy access to all mock modules and utilities
+ */
+
+// Import all mock modules
+const fs = require('./fs')
+const net = require('./net')
+const http = require('./http')
+const https = require('./https')
+const child_process = require('./child_process')
+const crypto = require('./crypto')
+const os = require('./os')
+const path = require('./path')
+
+// Import test utilities
+const {mockCandy, mockLangGet, MockCandyPack} = require('./globalCandy')
+const testFactories = require('./testFactories')
+const testHelpers = require('./testHelpers')
+
+/**
+ * Setup all Node.js module mocks for Jest
+ * Call this in your test setup to mock all Node.js built-in modules
+ */
+const setupNodeMocks = () => {
+  jest.mock('fs', () => require('./fs'))
+  jest.mock('net', () => require('./net'))
+  jest.mock('http', () => require('./http'))
+  jest.mock('https', () => require('./https'))
+  jest.mock('child_process', () => require('./child_process'))
+  jest.mock('crypto', () => require('./crypto'))
+  jest.mock('os', () => require('./os'))
+  jest.mock('path', () => require('./path'))
+}
+
+/**
+ * Setup global mocks (Candy and __ function)
+ * Call this in beforeEach to set up global mocks
+ */
+const setupGlobalMocks = () => {
+  global.Candy = mockCandy
+  global.__ = mockLangGet
+
+  // Clear all previous mock calls
+  mockCandy.clearMocks()
+  mockLangGet.mockClear()
+}
+
+/**
+ * Cleanup all mocks
+ * Call this in afterEach to clean up mocks
+ */
+const cleanupAllMocks = () => {
+  // Clear global mocks
+  mockCandy.resetMocks()
+  mockLangGet.mockClear()
+
+  // Clear Node.js module mocks
+  fs.__resetFileSystem()
+  net.__clearAll()
+  http.__clearAll()
+  https.__clearAll()
+  child_process.__clearAll()
+  crypto.__resetMocks()
+  os.__resetMocks()
+  path.__resetMocks()
+
+  // Reset global references
+  delete global.Candy
+  delete global.__
+}
+
+/**
+ * Create a complete test environment with all mocks
+ * Returns an object with all mock modules and utilities
+ */
+const createTestEnvironment = () => {
+  setupNodeMocks()
+  setupGlobalMocks()
+
+  return {
+    // Mock modules
+    mocks: {
+      fs,
+      net,
+      http,
+      https,
+      child_process,
+      crypto,
+      os,
+      path
+    },
+
+    // Global mocks
+    global: {
+      Candy: mockCandy,
+      __: mockLangGet
+    },
+
+    // Test utilities
+    factories: testFactories,
+    helpers: testHelpers,
+
+    // Cleanup function
+    cleanup: cleanupAllMocks
+  }
+}
+
+/**
+ * Timer mock utilities for controlling time in tests
+ */
+const createTimerMocks = () => {
+  const timers = new Map()
+  let timerId = 1
+
+  const mockSetTimeout = jest.fn((callback, delay) => {
+    const id = timerId++
+    timers.set(id, {callback, delay, type: 'timeout'})
+    return id
+  })
+
+  const mockSetInterval = jest.fn((callback, delay) => {
+    const id = timerId++
+    const timer = {
+      callback,
+      delay,
+      type: 'interval',
+      unref: jest.fn(() => timer)
+    }
+    timers.set(id, timer)
+    return timer
+  })
+
+  const mockClearTimeout = jest.fn(id => {
+    timers.delete(id)
+  })
+
+  const mockClearInterval = jest.fn(id => {
+    timers.delete(id)
+  })
+
+  // Apply mocks to global
+  global.setTimeout = mockSetTimeout
+  global.setInterval = mockSetInterval
+  global.clearTimeout = mockClearTimeout
+  global.clearInterval = mockClearInterval
+
+  return {
+    setTimeout: mockSetTimeout,
+    setInterval: mockSetInterval,
+    clearTimeout: mockClearTimeout,
+    clearInterval: mockClearInterval,
+
+    // Helper functions
+    executeTimer: id => {
+      const timer = timers.get(id)
+      if (timer && timer.callback) {
+        timer.callback()
+      }
+    },
+
+    executeAllTimers: () => {
+      timers.forEach(timer => {
+        if (timer.callback) {
+          timer.callback()
+        }
+      })
+    },
+
+    getTimers: () => new Map(timers),
+
+    clearAllTimers: () => {
+      timers.clear()
+      timerId = 1
+    }
+  }
+}
+
+/**
+ * Process mock utilities for controlling process behavior
+ */
+const createProcessMocks = () => {
+  const originalProcess = {...process}
+
+  const mockProcess = {
+    ...process,
+    exit: jest.fn(),
+    kill: jest.fn(),
+    nextTick: jest.fn(callback => {
+      setTimeout(callback, 0)
+    }),
+    env: {...process.env},
+    argv: [...process.argv],
+    cwd: jest.fn(() => '/mock/cwd'),
+    chdir: jest.fn(directory => {
+      mockProcess._cwd = directory
+    }),
+
+    // Test helpers
+    __setEnv: env => {
+      mockProcess.env = {...env}
+    },
+
+    __setArgv: argv => {
+      mockProcess.argv = [...argv]
+    },
+
+    __setCwd: cwd => {
+      mockProcess.cwd.mockReturnValue(cwd)
+    },
+
+    __reset: () => {
+      Object.assign(mockProcess, originalProcess)
+      mockProcess.env = {...originalProcess.env}
+      mockProcess.argv = [...originalProcess.argv]
+    }
+  }
+
+  return mockProcess
+}
+
+module.exports = {
+  // Mock modules
+  fs,
+  net,
+  http,
+  https,
+  child_process,
+  crypto,
+  os,
+  path,
+
+  // Global mocks
+  mockCandy,
+  mockLangGet,
+  MockCandyPack,
+
+  // Test utilities
+  testFactories,
+  testHelpers,
+
+  // Setup functions
+  setupNodeMocks,
+  setupGlobalMocks,
+  cleanupAllMocks,
+  createTestEnvironment,
+  createTimerMocks,
+  createProcessMocks
+}

package/test/server/__mocks__/mail/server.js

@@ -0,0 +1,100 @@
+/**
+ * Mock implementation of mail/server for server tests
+ */
+
+const {createMockEventEmitter} = require('../testHelpers')
+
+class MockMailServer {
+  constructor(options = {}) {
+    Object.assign(this, createMockEventEmitter())
+
+    this.options = options
+    this.listening = false
+    this.port = null
+
+    // Store callbacks for testing
+    this.onAuth = options.onAuth
+    this.onAppend = options.onAppend
+    this.onExpunge = options.onExpunge
+    this.onCreate = options.onCreate
+    this.onDelete = options.onDelete
+    this.onRename = options.onRename
+    this.onFetch = options.onFetch
+    this.onList = options.onList
+    this.onLsub = options.onLsub
+    this.onSelect = options.onSelect
+    this.onStore = options.onStore
+    this.onError = options.onError
+  }
+
+  listen(port, hostname, callback) {
+    if (typeof hostname === 'function') {
+      callback = hostname
+      hostname = undefined
+    }
+
+    this.port = port
+    this.listening = true
+
+    setTimeout(() => {
+      this.emit('listening')
+      if (callback) callback()
+    }, 0)
+
+    return this
+  }
+
+  close(callback) {
+    this.listening = false
+    this.port = null
+
+    setTimeout(() => {
+      this.emit('close')
+      if (callback) callback()
+    }, 0)
+
+    return this
+  }
+
+  // Test helper methods
+  simulateConnection(session = {}) {
+    const mockSession = {
+      remoteAddress: '127.0.0.1',
+      remotePort: 12345,
+      user: null,
+      ...session
+    }
+
+    this.emit('connect', mockSession)
+    return mockSession
+  }
+
+  simulateAuth(auth, session, callback) {
+    if (this.onAuth) {
+      this.onAuth(auth, session, callback)
+    } else if (callback) {
+      callback(null, {user: auth.username})
+    }
+  }
+
+  simulateAppend(data, callback) {
+    if (this.onAppend) {
+      this.onAppend(data, callback)
+    } else if (callback) {
+      callback()
+    }
+  }
+
+  simulateError(error) {
+    if (this.onError) {
+      this.onError(error)
+    }
+    this.emit('error', error)
+  }
+}
+
+const mockMailServer = jest.fn().mockImplementation(options => {
+  return new MockMailServer(options)
+})
+
+module.exports = mockMailServer

package/test/server/__mocks__/mail/smtp.js

@@ -0,0 +1,31 @@
+/**
+ * Mock implementation of mail/smtp for server tests
+ */
+
+const smtp = {
+  send: jest.fn(mailData => {
+    // Mock successful send
+    return Promise.resolve({
+      messageId: mailData.messageId || '<mock@example.com>',
+      accepted: mailData.to ? [mailData.to.value[0].address] : ['recipient@example.com'],
+      rejected: [],
+      pending: [],
+      response: '250 Message accepted'
+    })
+  }),
+
+  // Test helper methods
+  __setMockResponse: response => {
+    smtp.send.mockResolvedValue(response)
+  },
+
+  __setMockError: error => {
+    smtp.send.mockRejectedValue(error)
+  },
+
+  __resetMock: () => {
+    smtp.send.mockClear()
+  }
+}
+
+module.exports = smtp