odac 1.0.1 → 1.2.0

package/test/server/__mocks__/sqlite3.js

@@ -1,394 +0,0 @@
-/**
- * Mock implementation of sqlite3 for server tests
- */
-
-const {createMockEventEmitter} = require('./testHelpers')
-
-class MockDatabase {
-  constructor(filename, mode, callback) {
-    Object.assign(this, createMockEventEmitter())
-
-    if (typeof mode === 'function') {
-      callback = mode
-      mode = undefined
-    }
-
-    this.filename = filename
-    this.mode = mode
-    this.open = true
-    this.statements = new Map()
-    this.data = new Map() // Mock data storage
-
-    // Simulate async database opening
-    setTimeout(() => {
-      if (callback) {
-        callback(null) // No error
-      }
-      this.emit('open')
-    }, 0)
-  }
-
-  serialize(callback) {
-    if (callback) {
-      callback()
-    }
-    return this
-  }
-
-  parallelize(callback) {
-    if (callback) {
-      callback()
-    }
-    return this
-  }
-
-  run(sql, params, callback) {
-    if (typeof params === 'function') {
-      callback = params
-      params = []
-    }
-
-    // Mock SQL execution
-    const result = {
-      lastID: Math.floor(Math.random() * 1000) + 1,
-      changes: 1
-    }
-
-    // Store mock data for SELECT queries
-    if (sql.includes('INSERT INTO')) {
-      const tableName = this.extractTableName(sql)
-      if (!this.data.has(tableName)) {
-        this.data.set(tableName, [])
-      }
-      this.data.get(tableName).push({id: result.lastID, ...params})
-    }
-
-    setTimeout(() => {
-      if (callback) {
-        callback.call(result, null)
-      }
-      this.emit('run', sql, params)
-    }, 0)
-
-    return this
-  }
-
-  get(sql, params, callback) {
-    if (typeof params === 'function') {
-      callback = params
-      params = []
-    }
-
-    let row = null
-
-    // Mock data retrieval
-    if (sql.includes('SELECT')) {
-      const tableName = this.extractTableName(sql)
-      const tableData = this.data.get(tableName) || []
-
-      if (tableData.length > 0) {
-        row = tableData[0] // Return first row
-      }
-    }
-
-    setTimeout(() => {
-      if (callback) {
-        callback(null, row)
-      }
-      this.emit('get', sql, params, row)
-    }, 0)
-
-    return this
-  }
-
-  all(sql, params, callback) {
-    if (typeof params === 'function') {
-      callback = params
-      params = []
-    }
-
-    let rows = []
-
-    // Mock data retrieval
-    if (sql.includes('SELECT')) {
-      const tableName = this.extractTableName(sql)
-      rows = this.data.get(tableName) || []
-    }
-
-    setTimeout(() => {
-      if (callback) {
-        callback(null, rows)
-      }
-      this.emit('all', sql, params, rows)
-    }, 0)
-
-    return this
-  }
-
-  each(sql, params, rowCallback, completeCallback) {
-    if (typeof params === 'function') {
-      completeCallback = rowCallback
-      rowCallback = params
-      params = []
-    }
-
-    let rows = []
-    let count = 0
-
-    // Mock data retrieval
-    if (sql.includes('SELECT')) {
-      const tableName = this.extractTableName(sql)
-      rows = this.data.get(tableName) || []
-      count = rows.length
-    }
-
-    setTimeout(() => {
-      // Call row callback for each row
-      rows.forEach(row => {
-        if (rowCallback) {
-          rowCallback(null, row)
-        }
-      })
-
-      // Call complete callback
-      if (completeCallback) {
-        completeCallback(null, count)
-      }
-
-      this.emit('each', sql, params, count)
-    }, 0)
-
-    return this
-  }
-
-  prepare(sql, params, callback) {
-    if (typeof params === 'function') {
-      callback = params
-      params = []
-    }
-
-    const statement = new MockStatement(sql, params, this)
-    const statementId = Math.random().toString(36)
-    this.statements.set(statementId, statement)
-
-    setTimeout(() => {
-      if (callback) {
-        callback(null, statement)
-      }
-      this.emit('prepare', sql, params)
-    }, 0)
-
-    return statement
-  }
-
-  exec(sql, callback) {
-    setTimeout(() => {
-      if (callback) {
-        callback(null)
-      }
-      this.emit('exec', sql)
-    }, 0)
-
-    return this
-  }
-
-  close(callback) {
-    this.open = false
-
-    setTimeout(() => {
-      if (callback) {
-        callback(null)
-      }
-      this.emit('close')
-    }, 0)
-
-    return this
-  }
-
-  // Helper method to extract table name from SQL
-  extractTableName(sql) {
-    const match = sql.match(/(?:FROM|INTO|UPDATE)\s+(\w+)/i)
-    return match ? match[1] : 'unknown'
-  }
-
-  // Test helper methods
-  setMockData(tableName, data) {
-    this.data.set(tableName, data)
-  }
-
-  getMockData(tableName) {
-    return this.data.get(tableName) || []
-  }
-
-  clearMockData() {
-    this.data.clear()
-  }
-}
-
-class MockStatement {
-  constructor(sql, params, database) {
-    Object.assign(this, createMockEventEmitter())
-
-    this.sql = sql
-    this.params = params
-    this.database = database
-    this.finalized = false
-  }
-
-  bind(params, callback) {
-    this.params = Array.isArray(params) ? params : [params]
-
-    setTimeout(() => {
-      if (callback) {
-        callback(null)
-      }
-      this.emit('bind', params)
-    }, 0)
-
-    return this
-  }
-
-  reset(callback) {
-    this.params = []
-
-    setTimeout(() => {
-      if (callback) {
-        callback(null)
-      }
-      this.emit('reset')
-    }, 0)
-
-    return this
-  }
-
-  finalize(callback) {
-    this.finalized = true
-
-    setTimeout(() => {
-      if (callback) {
-        callback(null)
-      }
-      this.emit('finalize')
-    }, 0)
-
-    return this
-  }
-
-  run(params, callback) {
-    if (typeof params === 'function') {
-      callback = params
-      params = this.params
-    }
-
-    const result = {
-      lastID: Math.floor(Math.random() * 1000) + 1,
-      changes: 1
-    }
-
-    setTimeout(() => {
-      if (callback) {
-        callback.call(result, null)
-      }
-      this.emit('run', params)
-    }, 0)
-
-    return this
-  }
-
-  get(params, callback) {
-    if (typeof params === 'function') {
-      callback = params
-      params = this.params
-    }
-
-    const row = {id: 1, data: 'mock'}
-
-    setTimeout(() => {
-      if (callback) {
-        callback(null, row)
-      }
-      this.emit('get', params, row)
-    }, 0)
-
-    return this
-  }
-
-  all(params, callback) {
-    if (typeof params === 'function') {
-      callback = params
-      params = this.params
-    }
-
-    const rows = [{id: 1, data: 'mock'}]
-
-    setTimeout(() => {
-      if (callback) {
-        callback(null, rows)
-      }
-      this.emit('all', params, rows)
-    }, 0)
-
-    return this
-  }
-
-  each(params, rowCallback, completeCallback) {
-    if (typeof params === 'function') {
-      completeCallback = rowCallback
-      rowCallback = params
-      params = this.params
-    }
-
-    const rows = [{id: 1, data: 'mock'}]
-
-    setTimeout(() => {
-      rows.forEach(row => {
-        if (rowCallback) {
-          rowCallback(null, row)
-        }
-      })
-
-      if (completeCallback) {
-        completeCallback(null, rows.length)
-      }
-
-      this.emit('each', params, rows.length)
-    }, 0)
-
-    return this
-  }
-}
-
-// Mock constants
-const OPEN_READONLY = 1
-const OPEN_READWRITE = 2
-const OPEN_CREATE = 4
-const OPEN_FULLMUTEX = 16
-const OPEN_SHAREDCACHE = 32
-const OPEN_PRIVATECACHE = 64
-
-const sqlite3 = {
-  Database: MockDatabase,
-  Statement: MockStatement,
-
-  // Constants
-  OPEN_READONLY,
-  OPEN_READWRITE,
-  OPEN_CREATE,
-  OPEN_FULLMUTEX,
-  OPEN_SHAREDCACHE,
-  OPEN_PRIVATECACHE,
-
-  // Verbose mode
-  verbose: jest.fn(() => ({
-    Database: MockDatabase,
-    Statement: MockStatement,
-    OPEN_READONLY,
-    OPEN_READWRITE,
-    OPEN_CREATE,
-    OPEN_FULLMUTEX,
-    OPEN_SHAREDCACHE,
-    OPEN_PRIVATECACHE
-  }))
-}
-
-module.exports = sqlite3

package/test/server/__mocks__/testFactories.js

@@ -1,299 +0,0 @@
-/**
- * Test data factory functions for consistent mock data generation
- * Provides builders for common data structures used across server tests
- */
-
-/**
- * Factory for creating mock website configurations
- */
-const createMockWebsiteConfig = (domain = 'example.com', overrides = {}) => {
-  return {
-    domain,
-    path: `/var/odac/${domain}`,
-    subdomain: ['www'],
-    cert: {
-      ssl: {
-        key: `/etc/ssl/private/${domain}.key`,
-        cert: `/etc/ssl/certs/${domain}.crt`,
-        expiry: Date.now() + 86400000 * 30 // 30 days from now
-      }
-    },
-    DNS: {
-      A: [{name: domain, value: '127.0.0.1'}],
-      AAAA: [{name: domain, value: '::1'}],
-      CNAME: [{name: `www.${domain}`, value: domain}],
-      MX: [{name: domain, value: `mail.${domain}`, priority: 10}],
-      TXT: [{name: domain, value: 'v=spf1 mx ~all'}],
-      NS: [
-        {name: domain, value: `ns1.${domain}`},
-        {name: domain, value: `ns2.${domain}`}
-      ]
-    },
-    ...overrides
-  }
-}
-
-/**
- * Factory for creating mock service configurations
- */
-const createMockServiceConfig = (name = 'test-service.js', overrides = {}) => {
-  return {
-    id: Math.floor(Math.random() * 1000),
-    name,
-    file: `/path/to/${name}`,
-    active: true,
-    pid: Math.floor(Math.random() * 10000) + 1000,
-    status: 'running',
-    started: Date.now(),
-    restarts: 0,
-    errors: 0,
-    ...overrides
-  }
-}
-
-/**
- * Factory for creating mock mail account data
- */
-const createMockMailAccount = (email = 'test@example.com', overrides = {}) => {
-  const [localPart, domain] = email.split('@')
-  return {
-    email,
-    localPart,
-    domain,
-    password: '$2b$10$hashedpasswordexample',
-    created: Date.now(),
-    lastLogin: null,
-    ...overrides
-  }
-}
-
-/**
- * Factory for creating mock DNS records
- */
-const createMockDNSRecord = (type = 'A', name = 'example.com', value = '127.0.0.1', overrides = {}) => {
-  const baseRecord = {
-    name,
-    type,
-    value,
-    ttl: 300
-  }
-
-  // Add type-specific properties
-  switch (type) {
-    case 'MX':
-      baseRecord.priority = 10
-      break
-    case 'SOA':
-      baseRecord.serial = Math.floor(Date.now() / 1000)
-      baseRecord.refresh = 3600
-      baseRecord.retry = 1800
-      baseRecord.expire = 604800
-      baseRecord.minimum = 86400
-      break
-    case 'SRV':
-      baseRecord.priority = 10
-      baseRecord.weight = 5
-      baseRecord.port = 443
-      break
-  }
-
-  return {
-    ...baseRecord,
-    ...overrides
-  }
-}
-
-/**
- * Factory for creating mock SSL certificate data
- */
-const createMockSSLCertificate = (domain = 'example.com', overrides = {}) => {
-  return {
-    domain,
-    keyPath: `/etc/ssl/private/${domain}.key`,
-    certPath: `/etc/ssl/certs/${domain}.crt`,
-    chainPath: `/etc/ssl/certs/${domain}-chain.crt`,
-    issued: Date.now() - 86400000 * 10, // 10 days ago
-    expiry: Date.now() + 86400000 * 80, // 80 days from now
-    issuer: "Let's Encrypt Authority X3",
-    algorithm: 'RSA',
-    keySize: 2048,
-    ...overrides
-  }
-}
-
-/**
- * Factory for creating mock HTTP request objects
- */
-const createMockRequest = (url = '/', method = 'GET', overrides = {}) => {
-  return {
-    url,
-    method,
-    headers: {
-      host: 'example.com',
-      'user-agent': 'Mozilla/5.0 Test Browser',
-      accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-      ...overrides.headers
-    },
-    connection: {
-      remoteAddress: '127.0.0.1',
-      remotePort: 12345
-    },
-    body: '',
-    query: {},
-    params: {},
-    ...overrides
-  }
-}
-
-/**
- * Factory for creating mock HTTP response objects
- */
-const createMockResponse = (overrides = {}) => {
-  const response = {
-    statusCode: 200,
-    headers: {},
-    headersSent: false,
-    finished: false,
-    setHeader: jest.fn((name, value) => {
-      response.headers[name.toLowerCase()] = value
-    }),
-    getHeader: jest.fn(name => response.headers[name.toLowerCase()]),
-    removeHeader: jest.fn(name => {
-      delete response.headers[name.toLowerCase()]
-    }),
-    writeHead: jest.fn((statusCode, headers) => {
-      response.statusCode = statusCode
-      if (headers) {
-        Object.entries(headers).forEach(([name, value]) => {
-          response.setHeader(name, value)
-        })
-      }
-      response.headersSent = true
-    }),
-    write: jest.fn(),
-    end: jest.fn(data => {
-      if (data) response.write(data)
-      response.finished = true
-    }),
-    ...overrides
-  }
-
-  return response
-}
-
-/**
- * Factory for creating mock TCP socket objects
- */
-const createMockSocket = (overrides = {}) => {
-  return {
-    remoteAddress: '127.0.0.1',
-    remotePort: 12345,
-    localAddress: '127.0.0.1',
-    localPort: 1453,
-    readable: true,
-    writable: true,
-    destroyed: false,
-    write: jest.fn(),
-    end: jest.fn(),
-    destroy: jest.fn(() => {
-      socket.destroyed = true
-    }),
-    on: jest.fn(),
-    once: jest.fn(),
-    emit: jest.fn(),
-    removeListener: jest.fn(),
-    removeAllListeners: jest.fn(),
-    ...overrides
-  }
-}
-
-/**
- * Factory for creating mock child process objects
- */
-const createMockChildProcess = (pid = 12345, overrides = {}) => {
-  return {
-    pid,
-    killed: false,
-    exitCode: null,
-    signalCode: null,
-    connected: true,
-    stdout: {
-      on: jest.fn(),
-      pipe: jest.fn(),
-      readable: true
-    },
-    stderr: {
-      on: jest.fn(),
-      pipe: jest.fn(),
-      readable: true
-    },
-    stdin: {
-      write: jest.fn(),
-      end: jest.fn(),
-      writable: true
-    },
-    kill: jest.fn((signal = 'SIGTERM') => {
-      process.killed = true
-      process.signalCode = signal
-      return true
-    }),
-    send: jest.fn(),
-    disconnect: jest.fn(),
-    on: jest.fn(),
-    once: jest.fn(),
-    emit: jest.fn(),
-    removeListener: jest.fn(),
-    removeAllListeners: jest.fn(),
-    ...overrides
-  }
-}
-
-/**
- * Factory for creating mock database result objects
- */
-const createMockDatabaseResult = (rows = [], overrides = {}) => {
-  return {
-    rows,
-    rowCount: rows.length,
-    command: 'SELECT',
-    fields: [],
-    ...overrides
-  }
-}
-
-/**
- * Factory for creating mock email message objects
- */
-const createMockEmailMessage = (from = 'sender@example.com', to = 'recipient@example.com', overrides = {}) => {
-  return {
-    messageId: `<${Date.now()}.${Math.random()}@example.com>`,
-    from: {address: from, name: ''},
-    to: [{address: to, name: ''}],
-    subject: 'Test Email',
-    date: new Date(),
-    headers: new Map([
-      ['from', from],
-      ['to', to],
-      ['subject', 'Test Email'],
-      ['date', new Date().toISOString()]
-    ]),
-    text: 'This is a test email message.',
-    html: '<p>This is a test email message.</p>',
-    attachments: [],
-    ...overrides
-  }
-}
-
-module.exports = {
-  createMockWebsiteConfig,
-  createMockServiceConfig,
-  createMockMailAccount,
-  createMockDNSRecord,
-  createMockSSLCertificate,
-  createMockRequest,
-  createMockResponse,
-  createMockSocket,
-  createMockChildProcess,
-  createMockDatabaseResult,
-  createMockEmailMessage
-}