odac 1.0.1 → 1.2.0

package/test/server/__mocks__/mailparser.js

@@ -1,81 +0,0 @@
-/**
- * Mock implementation of mailparser for server tests
- */
-
-const {createMockEmailMessage} = require('./testFactories')
-
-const simpleParser = jest.fn((source, options, callback) => {
-  if (typeof options === 'function') {
-    callback = options
-    options = {}
-  }
-
-  // Create a mock parsed email
-  const mockParsedEmail = createMockEmailMessage()
-
-  // Allow customization through options
-  if (options.from) mockParsedEmail.from.value[0].address = options.from
-  if (options.to) mockParsedEmail.to[0].address = options.to
-  if (options.subject) mockParsedEmail.subject = options.subject
-  if (options.text) mockParsedEmail.text = options.text
-  if (options.html) mockParsedEmail.html = options.html
-
-  // Simulate async parsing
-  setTimeout(() => {
-    if (callback) {
-      callback(null, mockParsedEmail)
-    }
-  }, 0)
-
-  // Return a promise if no callback provided
-  if (!callback) {
-    return Promise.resolve(mockParsedEmail)
-  }
-})
-
-// Mock for streaming parser
-const parseHeaders = jest.fn((source, callback) => {
-  const mockHeaders = new Map([
-    ['from', 'sender@example.com'],
-    ['to', 'recipient@example.com'],
-    ['subject', 'Test Email'],
-    ['date', new Date().toISOString()],
-    ['message-id', '<test@example.com>']
-  ])
-
-  setTimeout(() => {
-    if (callback) {
-      callback(null, mockHeaders)
-    }
-  }, 0)
-
-  if (!callback) {
-    return Promise.resolve(mockHeaders)
-  }
-})
-
-// Mock for attachment parsing
-const parseAttachment = jest.fn((attachment, callback) => {
-  const mockAttachment = {
-    filename: 'test.txt',
-    contentType: 'text/plain',
-    size: 100,
-    content: Buffer.from('test attachment content')
-  }
-
-  setTimeout(() => {
-    if (callback) {
-      callback(null, mockAttachment)
-    }
-  }, 0)
-
-  if (!callback) {
-    return Promise.resolve(mockAttachment)
-  }
-})
-
-module.exports = {
-  simpleParser,
-  parseHeaders,
-  parseAttachment
-}

package/test/server/__mocks__/net.js

@@ -1,369 +0,0 @@
-/**
- * Mock implementation of the net module for server tests
- * Provides comprehensive mocking of TCP server and socket operations
- */
-
-const {createMockEventEmitter} = require('./testHelpers')
-
-// Track active servers and connections
-const activeServers = new Map()
-const activeConnections = new Map()
-let nextConnectionId = 1
-
-const createMockSocket = (options = {}) => {
-  const socket = createMockEventEmitter()
-  const connectionId = nextConnectionId++
-
-  Object.assign(socket, {
-    // Connection properties
-    remoteAddress: options.remoteAddress || '127.0.0.1',
-    remotePort: options.remotePort || Math.floor(Math.random() * 50000) + 10000,
-    localAddress: options.localAddress || '127.0.0.1',
-    localPort: options.localPort || 1453,
-    remoteFamily: options.remoteFamily || 'IPv4',
-    localFamily: options.localFamily || 'IPv4',
-
-    // State properties
-    readable: true,
-    writable: true,
-    destroyed: false,
-    connecting: false,
-    readyState: 'open',
-
-    // Buffer properties
-    bytesRead: 0,
-    bytesWritten: 0,
-
-    // Methods
-    write: jest.fn((data, encoding, callback) => {
-      if (socket.destroyed || !socket.writable) {
-        const error = new Error('Cannot write to destroyed socket')
-        if (callback) callback(error)
-        return false
-      }
-
-      socket.bytesWritten += Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data, encoding)
-
-      if (callback) {
-        setTimeout(callback, 0)
-      }
-
-      return true
-    }),
-
-    end: jest.fn((data, encoding, callback) => {
-      if (data) {
-        socket.write(data, encoding)
-      }
-
-      if (typeof encoding === 'function') {
-        callback = encoding
-      }
-      if (typeof data === 'function') {
-        callback = data
-      }
-
-      socket.writable = false
-
-      setTimeout(() => {
-        socket.emit('end')
-        if (callback) callback()
-      }, 0)
-
-      return socket
-    }),
-
-    destroy: jest.fn(error => {
-      if (socket.destroyed) return socket
-
-      socket.destroyed = true
-      socket.readable = false
-      socket.writable = false
-      socket.readyState = 'closed'
-
-      activeConnections.delete(connectionId)
-
-      setTimeout(() => {
-        if (error) {
-          socket.emit('error', error)
-        }
-        socket.emit('close', !!error)
-      }, 0)
-
-      return socket
-    }),
-
-    pause: jest.fn(() => {
-      socket.readable = false
-      return socket
-    }),
-
-    resume: jest.fn(() => {
-      socket.readable = true
-      return socket
-    }),
-
-    setTimeout: jest.fn((timeout, callback) => {
-      if (callback) {
-        socket.once('timeout', callback)
-      }
-
-      const timeoutId = setTimeout(() => {
-        socket.emit('timeout')
-      }, timeout)
-
-      socket._timeout = timeoutId
-      return socket
-    }),
-
-    setNoDelay: jest.fn((noDelay = true) => {
-      socket._noDelay = noDelay
-      return socket
-    }),
-
-    setKeepAlive: jest.fn((enable = false, initialDelay = 0) => {
-      socket._keepAlive = enable
-      socket._keepAliveInitialDelay = initialDelay
-      return socket
-    }),
-
-    address: jest.fn(() => ({
-      address: socket.localAddress,
-      family: socket.localFamily,
-      port: socket.localPort
-    })),
-
-    // Test helpers
-    __simulateData: data => {
-      if (!socket.destroyed && socket.readable) {
-        socket.bytesRead += Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data)
-        socket.emit('data', Buffer.isBuffer(data) ? data : Buffer.from(data))
-      }
-    },
-
-    __simulateError: error => {
-      socket.emit('error', error)
-    },
-
-    __simulateClose: (hadError = false) => {
-      socket.destroy()
-    }
-  })
-
-  activeConnections.set(connectionId, socket)
-  return socket
-}
-
-const createMockServer = (options = {}) => {
-  const server = createMockEventEmitter()
-  const serverId = Math.floor(Math.random() * 1000)
-
-  Object.assign(server, {
-    // State properties
-    listening: false,
-    maxConnections: options.maxConnections || 0,
-    connections: 0,
-
-    // Server address info
-    address: jest.fn(() => {
-      if (!server.listening) return null
-      return {
-        address: server._address || '127.0.0.1',
-        family: server._family || 'IPv4',
-        port: server._port || 1453
-      }
-    }),
-
-    // 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 || Math.floor(Math.random() * 50000) + 10000
-      server._address = hostname || '127.0.0.1'
-      server._family = 'IPv4'
-      server.listening = true
-
-      if (callback) {
-        server.once('listening', callback)
-      }
-
-      setTimeout(() => {
-        server.emit('listening')
-      }, 0)
-
-      return server
-    }),
-
-    close: jest.fn(callback => {
-      if (!server.listening) {
-        const error = new Error('Server is not running')
-        if (callback) {
-          setTimeout(() => callback(error), 0)
-        }
-        return server
-      }
-
-      server.listening = false
-
-      // Close all connections
-      activeConnections.forEach(socket => {
-        if (socket.localPort === server._port) {
-          socket.destroy()
-        }
-      })
-
-      if (callback) {
-        server.once('close', callback)
-      }
-
-      setTimeout(() => {
-        server.emit('close')
-      }, 0)
-
-      activeServers.delete(serverId)
-      return server
-    }),
-
-    getConnections: jest.fn(callback => {
-      const count = Array.from(activeConnections.values()).filter(socket => socket.localPort === server._port && !socket.destroyed).length
-
-      if (callback) {
-        setTimeout(() => callback(null, count), 0)
-      }
-
-      return count
-    }),
-
-    ref: jest.fn(() => server),
-    unref: jest.fn(() => server),
-
-    // Test helpers
-    __simulateConnection: (socketOptions = {}) => {
-      if (!server.listening) {
-        throw new Error('Server is not listening')
-      }
-
-      const socket = createMockSocket({
-        localPort: server._port,
-        localAddress: server._address,
-        ...socketOptions
-      })
-
-      server.connections++
-
-      setTimeout(() => {
-        server.emit('connection', socket)
-      }, 0)
-
-      return socket
-    },
-
-    __simulateError: error => {
-      server.emit('error', error)
-    }
-  })
-
-  activeServers.set(serverId, server)
-  return server
-}
-
-const net = {
-  // Server creation
-  createServer: jest.fn((options, connectionListener) => {
-    if (typeof options === 'function') {
-      connectionListener = options
-      options = {}
-    }
-
-    const server = createMockServer(options)
-
-    if (connectionListener) {
-      server.on('connection', connectionListener)
-    }
-
-    return server
-  }),
-
-  // Socket creation
-  createConnection: jest.fn((options, connectListener) => {
-    const socket = createMockSocket()
-
-    if (typeof options === 'number') {
-      options = {port: options}
-    }
-
-    socket.connecting = true
-    socket.readyState = 'opening'
-
-    if (connectListener) {
-      socket.once('connect', connectListener)
-    }
-
-    // Simulate connection
-    setTimeout(() => {
-      socket.connecting = false
-      socket.readyState = 'open'
-      socket.emit('connect')
-    }, 0)
-
-    return socket
-  }),
-
-  connect: jest.fn((...args) => net.createConnection(...args)),
-
-  // Utility functions
-  isIP: jest.fn(input => {
-    if (typeof input !== 'string') return 0
-
-    // Simple IPv4 check
-    const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/
-    if (ipv4Regex.test(input)) {
-      const parts = input.split('.')
-      if (parts.every(part => parseInt(part) >= 0 && parseInt(part) <= 255)) {
-        return 4
-      }
-    }
-
-    // Simple IPv6 check
-    const ipv6Regex = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/
-    if (ipv6Regex.test(input)) {
-      return 6
-    }
-
-    return 0
-  }),
-
-  isIPv4: jest.fn(input => net.isIP(input) === 4),
-  isIPv6: jest.fn(input => net.isIP(input) === 6),
-
-  // Socket class
-  Socket: jest.fn(function (options = {}) {
-    return createMockSocket(options)
-  }),
-
-  // Server class
-  Server: jest.fn(function (options = {}, connectionListener) {
-    return createMockServer(options, connectionListener)
-  }),
-
-  // Test helpers
-  __getActiveServers: () => new Map(activeServers),
-  __getActiveConnections: () => new Map(activeConnections),
-  __clearAll: () => {
-    activeServers.clear()
-    activeConnections.clear()
-    nextConnectionId = 1
-  }
-}
-
-module.exports = net