odac 0.9.0

package/test/server/__mocks__/testHelpers.js

@@ -0,0 +1,363 @@
+/**
+ * Shared test utilities for common assertions and setup patterns
+ * Provides helper functions to reduce boilerplate in server tests
+ */
+
+const {mockCandy, mockLangGet} = require('./globalCandy')
+
+/**
+ * Sets up the global Candy mock and __ function for tests
+ * Should be called in beforeEach or beforeAll
+ */
+const setupGlobalMocks = () => {
+  // Set up global Candy mock
+  global.Candy = mockCandy
+
+  // Set up global __ function mock
+  global.__ = mockLangGet
+
+  // Clear all previous mock calls
+  mockCandy.clearMocks()
+  mockLangGet.mockClear()
+}
+
+/**
+ * Cleans up global mocks after tests
+ * Should be called in afterEach or afterAll
+ */
+const cleanupGlobalMocks = () => {
+  mockCandy.resetMocks()
+  mockLangGet.mockClear()
+
+  // Reset global references
+  delete global.Candy
+  delete global.__
+}
+
+/**
+ * Creates a mock timer that can be controlled in tests
+ */
+const createMockTimer = () => {
+  const timer = {
+    id: Math.floor(Math.random() * 1000),
+    callback: null,
+    interval: 0,
+    active: false,
+    unref: jest.fn(() => timer)
+  }
+
+  return timer
+}
+
+/**
+ * Helper to mock setTimeout and setInterval
+ */
+const mockTimers = () => {
+  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()}
+    timers.set(id, timer)
+    return timer
+  })
+
+  const mockClearTimeout = jest.fn(id => {
+    timers.delete(id)
+  })
+
+  const mockClearInterval = jest.fn(id => {
+    timers.delete(id)
+  })
+
+  // Helper to execute timer callbacks
+  const executeTimer = id => {
+    const timer = timers.get(id)
+    if (timer && timer.callback) {
+      timer.callback()
+    }
+  }
+
+  // Helper to execute all timers
+  const executeAllTimers = () => {
+    timers.forEach((timer, id) => {
+      if (timer.callback) {
+        timer.callback()
+      }
+    })
+  }
+
+  return {
+    setTimeout: mockSetTimeout,
+    setInterval: mockSetInterval,
+    clearTimeout: mockClearTimeout,
+    clearInterval: mockClearInterval,
+    executeTimer,
+    executeAllTimers,
+    getTimers: () => timers
+  }
+}
+
+/**
+ * Helper to create a mock EventEmitter
+ */
+const createMockEventEmitter = () => {
+  const listeners = new Map()
+
+  const emitter = {
+    on: jest.fn((event, listener) => {
+      if (!listeners.has(event)) {
+        listeners.set(event, [])
+      }
+      listeners.get(event).push(listener)
+      return emitter
+    }),
+
+    once: jest.fn((event, listener) => {
+      const onceWrapper = (...args) => {
+        listener(...args)
+        emitter.removeListener(event, onceWrapper)
+      }
+      return emitter.on(event, onceWrapper)
+    }),
+
+    emit: jest.fn((event, ...args) => {
+      const eventListeners = listeners.get(event)
+      if (eventListeners) {
+        eventListeners.forEach(listener => listener(...args))
+        return true
+      }
+      return false
+    }),
+
+    removeListener: jest.fn((event, listener) => {
+      const eventListeners = listeners.get(event)
+      if (eventListeners) {
+        const index = eventListeners.indexOf(listener)
+        if (index > -1) {
+          eventListeners.splice(index, 1)
+        }
+      }
+      return emitter
+    }),
+
+    removeAllListeners: jest.fn(event => {
+      if (event) {
+        listeners.delete(event)
+      } else {
+        listeners.clear()
+      }
+      return emitter
+    }),
+
+    listenerCount: jest.fn(event => {
+      const eventListeners = listeners.get(event)
+      return eventListeners ? eventListeners.length : 0
+    }),
+
+    // Helper methods for testing
+    getListeners: event => listeners.get(event) || [],
+    getAllListeners: () => listeners
+  }
+
+  return emitter
+}
+
+/**
+ * Helper to wait for async operations in tests
+ */
+const waitFor = (ms = 0) => {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+/**
+ * Helper to wait for a condition to be true
+ */
+const waitForCondition = async (condition, timeout = 1000, interval = 10) => {
+  const start = Date.now()
+
+  while (Date.now() - start < timeout) {
+    if (await condition()) {
+      return true
+    }
+    await waitFor(interval)
+  }
+
+  throw new Error(`Condition not met within ${timeout}ms`)
+}
+
+/**
+ * Helper to capture console output during tests
+ */
+const captureConsole = () => {
+  const originalLog = console.log
+  const originalError = console.error
+  const originalWarn = console.warn
+  const originalInfo = console.info
+
+  const logs = []
+  const errors = []
+  const warnings = []
+  const infos = []
+
+  console.log = jest.fn((...args) => {
+    logs.push(args.join(' '))
+  })
+
+  console.error = jest.fn((...args) => {
+    errors.push(args.join(' '))
+  })
+
+  console.warn = jest.fn((...args) => {
+    warnings.push(args.join(' '))
+  })
+
+  console.info = jest.fn((...args) => {
+    infos.push(args.join(' '))
+  })
+
+  const restore = () => {
+    console.log = originalLog
+    console.error = originalError
+    console.warn = originalWarn
+    console.info = originalInfo
+  }
+
+  return {
+    logs,
+    errors,
+    warnings,
+    infos,
+    restore
+  }
+}
+
+/**
+ * Helper to create a mock stream
+ */
+const createMockStream = (readable = true, writable = true) => {
+  const stream = createMockEventEmitter()
+
+  Object.assign(stream, {
+    readable,
+    writable,
+    destroyed: false,
+
+    read: jest.fn(),
+    write: jest.fn((chunk, encoding, callback) => {
+      if (typeof encoding === 'function') {
+        callback = encoding
+      }
+      if (callback) callback()
+      return true
+    }),
+    end: jest.fn((chunk, encoding, callback) => {
+      if (chunk) stream.write(chunk, encoding)
+      if (typeof encoding === 'function') {
+        callback = encoding
+      }
+      if (typeof chunk === 'function') {
+        callback = chunk
+      }
+      if (callback) callback()
+      stream.emit('end')
+    }),
+    destroy: jest.fn(error => {
+      stream.destroyed = true
+      if (error) {
+        stream.emit('error', error)
+      }
+      stream.emit('close')
+    }),
+    pipe: jest.fn(destination => {
+      return destination
+    })
+  })
+
+  return stream
+}
+
+/**
+ * Helper assertions for common test patterns
+ */
+const assertions = {
+  /**
+   * Assert that a mock function was called with specific arguments
+   */
+  toHaveBeenCalledWithArgs: (mockFn, ...expectedArgs) => {
+    expect(mockFn).toHaveBeenCalledWith(...expectedArgs)
+  },
+
+  /**
+   * Assert that an object has all required properties
+   */
+  toHaveRequiredProperties: (obj, properties) => {
+    properties.forEach(prop => {
+      expect(obj).toHaveProperty(prop)
+    })
+  },
+
+  /**
+   * Assert that a function throws a specific error
+   */
+  toThrowErrorWithMessage: (fn, expectedMessage) => {
+    expect(fn).toThrow(expectedMessage)
+  },
+
+  /**
+   * Assert that an async function resolves to a specific value
+   */
+  toResolveWith: async (promise, expectedValue) => {
+    const result = await promise
+    expect(result).toEqual(expectedValue)
+  },
+
+  /**
+   * Assert that an async function rejects with a specific error
+   */
+  toRejectWith: async (promise, expectedError) => {
+    await expect(promise).rejects.toThrow(expectedError)
+  }
+}
+
+/**
+ * Helper to create a test suite with common setup/teardown
+ */
+const createTestSuite = (suiteName, setupFn, teardownFn) => {
+  return testFn => {
+    describe(suiteName, () => {
+      beforeEach(() => {
+        setupGlobalMocks()
+        if (setupFn) setupFn()
+      })
+
+      afterEach(() => {
+        if (teardownFn) teardownFn()
+        cleanupGlobalMocks()
+      })
+
+      testFn()
+    })
+  }
+}
+
+module.exports = {
+  setupGlobalMocks,
+  cleanupGlobalMocks,
+  createMockTimer,
+  mockTimers,
+  createMockEventEmitter,
+  waitFor,
+  waitForCondition,
+  captureConsole,
+  createMockStream,
+  assertions,
+  createTestSuite
+}

package/test/server/__mocks__/tls.js

@@ -0,0 +1,229 @@
+/**
+ * Mock implementation of tls module for server tests
+ */
+
+const {createMockEventEmitter, createMockStream} = require('./testHelpers')
+
+const createMockSecureContext = (options = {}) => {
+  return {
+    context: 'mock-secure-context',
+    options: options,
+    // Mock methods that might be called on the context
+    setCert: jest.fn(),
+    setKey: jest.fn(),
+    addCACert: jest.fn(),
+    addCRL: jest.fn(),
+    addRootCerts: jest.fn()
+  }
+}
+
+const createMockTLSSocket = (socket, options = {}) => {
+  const tlsSocket = Object.assign(createMockStream(true, true), createMockEventEmitter())
+
+  Object.assign(tlsSocket, {
+    // TLS-specific properties
+    authorized: true,
+    authorizationError: null,
+    encrypted: true,
+
+    // Certificate information
+    getPeerCertificate: jest.fn((detailed = false) => {
+      return {
+        subject: {
+          CN: 'example.com',
+          O: 'Test Organization',
+          C: 'US'
+        },
+        issuer: {
+          CN: 'Test CA',
+          O: 'Test CA Organization',
+          C: 'US'
+        },
+        valid_from: 'Jan 1 00:00:00 2023 GMT',
+        valid_to: 'Jan 1 00:00:00 2024 GMT',
+        fingerprint: 'AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD',
+        serialNumber: '01',
+        raw: Buffer.from('mock-certificate-data')
+      }
+    }),
+
+    getCipher: jest.fn(() => {
+      return {
+        name: 'ECDHE-RSA-AES128-GCM-SHA256',
+        version: 'TLSv1.2'
+      }
+    }),
+
+    getProtocol: jest.fn(() => 'TLSv1.2'),
+
+    getSession: jest.fn(() => Buffer.from('mock-session-data')),
+
+    getTLSTicket: jest.fn(() => Buffer.from('mock-tls-ticket')),
+
+    renegotiate: jest.fn((options, callback) => {
+      if (typeof options === 'function') {
+        callback = options
+        options = {}
+      }
+      setTimeout(() => {
+        if (callback) callback(null)
+      }, 0)
+      return true
+    }),
+
+    setMaxSendFragment: jest.fn(size => {
+      return true
+    }),
+
+    // Underlying socket
+    socket: socket || createMockStream(true, true)
+  })
+
+  return tlsSocket
+}
+
+const createMockServer = (options = {}, secureConnectionListener) => {
+  if (typeof options === 'function') {
+    secureConnectionListener = options
+    options = {}
+  }
+
+  const server = Object.assign(createMockEventEmitter(), {
+    listening: false,
+    maxConnections: null,
+    connections: 0,
+
+    listen: jest.fn((port, hostname, backlog, callback) => {
+      // Handle various argument combinations
+      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.listening = true
+
+      setTimeout(() => {
+        server.emit('listening')
+        if (callback) callback()
+      }, 0)
+
+      return server
+    }),
+
+    close: jest.fn(callback => {
+      server.listening = false
+
+      setTimeout(() => {
+        server.emit('close')
+        if (callback) callback()
+      }, 0)
+
+      return server
+    }),
+
+    address: jest.fn(() => {
+      return {
+        port: 443,
+        family: 'IPv4',
+        address: '0.0.0.0'
+      }
+    }),
+
+    getConnections: jest.fn(callback => {
+      setTimeout(() => {
+        callback(null, server.connections)
+      }, 0)
+    }),
+
+    // Test helper methods
+    simulateConnection: socket => {
+      const tlsSocket = createMockTLSSocket(socket)
+      server.connections++
+
+      if (secureConnectionListener) {
+        secureConnectionListener(tlsSocket)
+      }
+
+      server.emit('secureConnection', tlsSocket)
+      return tlsSocket
+    },
+
+    simulateError: error => {
+      server.emit('error', error)
+    }
+  })
+
+  return server
+}
+
+const tls = {
+  // Create secure context
+  createSecureContext: jest.fn((options = {}) => {
+    return createMockSecureContext(options)
+  }),
+
+  // Create TLS server
+  createServer: jest.fn((options, secureConnectionListener) => {
+    return createMockServer(options, secureConnectionListener)
+  }),
+
+  // Create TLS connection
+  connect: jest.fn((port, host, options, callback) => {
+    // Handle various argument combinations
+    if (typeof port === 'object') {
+      options = port
+      port = options.port
+      host = options.host
+    } else if (typeof host === 'object') {
+      callback = options
+      options = host
+      host = 'localhost'
+    } else if (typeof host === 'function') {
+      callback = host
+      host = 'localhost'
+      options = {}
+    } else if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+
+    const socket = createMockTLSSocket()
+
+    setTimeout(() => {
+      socket.emit('connect')
+      socket.emit('secureConnect')
+      if (callback) callback()
+    }, 0)
+
+    return socket
+  }),
+
+  // Get ciphers
+  getCiphers: jest.fn(() => {
+    return [
+      'ECDHE-RSA-AES128-GCM-SHA256',
+      'ECDHE-RSA-AES256-GCM-SHA384',
+      'ECDHE-RSA-AES128-SHA256',
+      'ECDHE-RSA-AES256-SHA384',
+      'AES128-GCM-SHA256',
+      'AES256-GCM-SHA384'
+    ]
+  }),
+
+  // Constants
+  CLIENT_RENEG_LIMIT: 3,
+  CLIENT_RENEG_WINDOW: 600,
+
+  // Test helpers
+  __createMockSecureContext: createMockSecureContext,
+  __createMockTLSSocket: createMockTLSSocket,
+  __createMockServer: createMockServer
+}
+
+module.exports = tls

package/watchdog/index.js

@@ -0,0 +1,3 @@
+require('../core/Candy.js')
+
+Candy.watchdog('Watchdog')