odac 0.9.0

package/test/server/Web.test_.js

@@ -0,0 +1,1562 @@
+/**
+ * Unit tests for Web.js module
+ * Tests web hosting, proxy functionality, and website management
+ */
+
+// Mock all required modules before importing Web
+jest.mock('child_process')
+jest.mock('fs')
+jest.mock('http')
+jest.mock('https')
+jest.mock('http-proxy')
+jest.mock('net')
+jest.mock('os')
+jest.mock('path')
+jest.mock('tls')
+
+const childProcess = require('child_process')
+const fs = require('fs')
+const http = require('http')
+const https = require('https')
+const httpProxy = require('http-proxy')
+const net = require('net')
+const os = require('os')
+const path = require('path')
+const tls = require('tls')
+
+// Import test utilities
+const {mockCandy, mockLangGet} = require('./__mocks__/globalCandy')
+const {createMockRequest, createMockResponse} = require('./__mocks__/testFactories')
+const {createMockWebsiteConfig} = require('./__mocks__/testFactories')
+
+describe('Web', () => {
+  let Web
+  let mockConfig
+  let mockLog
+  let mockHttpServer
+  let mockHttpsServer
+  let mockProxyServer
+
+  beforeEach(() => {
+    // Reset all mocks
+    jest.clearAllMocks()
+
+    // Setup global Candy mock
+    mockCandy.resetMocks()
+    mockConfig = mockCandy.core('Config')
+
+    // Initialize config structure
+    mockConfig.config = {
+      websites: {},
+      web: {path: '/var/candypack'},
+      ssl: null
+    }
+
+    // Setup Log mock
+    const mockLogInstance = {
+      log: jest.fn(),
+      error: jest.fn(),
+      info: jest.fn(),
+      debug: jest.fn()
+    }
+    mockCandy.setMock('server', 'Log', {
+      init: jest.fn().mockReturnValue(mockLogInstance)
+    })
+    mockLog = mockLogInstance.log
+
+    // Setup Api mock
+    mockCandy.setMock('server', 'Api', {
+      result: jest.fn((success, message) => ({success, message}))
+    })
+
+    // Setup DNS mock with default methods
+    mockCandy.setMock('server', 'DNS', {
+      record: jest.fn(),
+      ip: '127.0.0.1'
+    })
+
+    // Setup Process mock
+    mockCandy.setMock('core', 'Process', {
+      stop: jest.fn()
+    })
+
+    global.Candy = mockCandy
+    global.__ = jest.fn((key, ...args) => {
+      // Simple mock translation function
+      let result = key
+      args.forEach((arg, index) => {
+        result = result.replace(`%s${index + 1}`, arg).replace('%s', arg)
+      })
+      return result
+    })
+
+    // Setup mock servers
+    mockHttpServer = {
+      listen: jest.fn(),
+      on: jest.fn(),
+      close: jest.fn()
+    }
+
+    mockHttpsServer = {
+      listen: jest.fn(),
+      on: jest.fn(),
+      close: jest.fn()
+    }
+
+    mockProxyServer = {
+      web: jest.fn(),
+      on: jest.fn()
+    }
+
+    // Setup module mocks
+    http.createServer.mockReturnValue(mockHttpServer)
+    https.createServer.mockReturnValue(mockHttpsServer)
+    httpProxy.createProxyServer.mockReturnValue(mockProxyServer)
+
+    // Setup file system mocks
+    fs.existsSync.mockReturnValue(true)
+    fs.mkdirSync.mockImplementation(() => {})
+    fs.cpSync.mockImplementation(() => {})
+    fs.rmSync.mockImplementation(() => {})
+    fs.readFileSync.mockReturnValue('mock-file-content')
+    fs.writeFile.mockImplementation((path, data, callback) => {
+      if (callback) callback(null)
+    })
+
+    // Setup OS mocks
+    os.homedir.mockReturnValue('/home/user')
+    os.platform.mockReturnValue('linux')
+
+    // Setup path mocks
+    path.join.mockImplementation((...args) => args.join('/'))
+
+    // Setup child process mocks
+    const mockChild = {
+      pid: 12345,
+      stdout: {on: jest.fn()},
+      stderr: {on: jest.fn()},
+      on: jest.fn()
+    }
+    childProcess.spawn.mockReturnValue(mockChild)
+    childProcess.execSync.mockImplementation(() => {})
+
+    // Setup net mocks for port checking
+    const mockNetServer = {
+      once: jest.fn(),
+      listen: jest.fn(),
+      close: jest.fn()
+    }
+    net.createServer.mockReturnValue(mockNetServer)
+
+    // Setup TLS mocks
+    const mockSecureContext = {context: 'mock-context'}
+    tls.createSecureContext.mockReturnValue(mockSecureContext)
+
+    // Import Web after mocks are set up
+    Web = require('../../server/src/Web')
+  })
+
+  afterEach(() => {
+    delete global.Candy
+    delete global.__
+  })
+
+  describe('initialization', () => {
+    test('should initialize with default configuration', async () => {
+      await Web.init()
+
+      expect(Web.server).toBeDefined()
+      expect(Web.server).toBeDefined()
+    })
+
+    test('should set default web path based on platform', async () => {
+      // Test Linux/Unix platform
+      os.platform.mockReturnValue('linux')
+      mockConfig.config.web = undefined
+
+      await Web.init()
+
+      expect(mockConfig.config.web.path).toBe('/var/candypack/')
+
+      // Test macOS platform
+      os.platform.mockReturnValue('darwin')
+      mockConfig.config.web = undefined
+
+      await Web.init()
+
+      expect(mockConfig.config.web.path).toBe('/home/user/Candypack/')
+
+      // Test Windows platform
+      os.platform.mockReturnValue('win32')
+      mockConfig.config.web = undefined
+
+      await Web.init()
+
+      expect(mockConfig.config.web.path).toBe('/home/user/Candypack/')
+    })
+
+    test('should create web directory if it does not exist', async () => {
+      fs.existsSync.mockReturnValue(false)
+      mockConfig.config.web = {path: '/custom/path'}
+
+      await Web.init()
+
+      expect(fs.existsSync).toHaveBeenCalledWith('/custom/path')
+    })
+  })
+
+  describe('server creation', () => {
+    beforeEach(async () => {
+      await Web.init()
+      mockConfig.config.websites = {'example.com': createMockWebsiteConfig()}
+    })
+
+    test('should create HTTP server on port 80', () => {
+      Web.server()
+
+      expect(http.createServer).toHaveBeenCalledWith(expect.any(Function))
+      expect(mockHttpServer.listen).toHaveBeenCalledWith(80)
+      expect(mockHttpServer.on).toHaveBeenCalledWith('error', expect.any(Function))
+    })
+
+    test('should handle HTTP server errors', () => {
+      // Create a fresh mock server for this test
+      const freshMockHttpServer = {
+        listen: jest.fn(),
+        on: jest.fn(),
+        close: jest.fn()
+      }
+      http.createServer.mockReturnValue(freshMockHttpServer)
+
+      // Reset the Web module's server instances to force recreation
+      Web['_Web__server_http'] = null
+      Web['_Web__server_https'] = null
+      Web['_Web__loaded'] = true // Ensure Web module is marked as loaded
+
+      // Ensure we have websites configured (required for server creation)
+      mockConfig.config.websites = {'example.com': createMockWebsiteConfig()}
+
+      Web.server()
+
+      // Verify HTTP server was created
+      expect(http.createServer).toHaveBeenCalled()
+
+      // Verify the error handler was attached
+      expect(freshMockHttpServer.on).toHaveBeenCalledWith('error', expect.any(Function))
+
+      // Get the error handler function
+      const errorCall = freshMockHttpServer.on.mock.calls.find(call => call[0] === 'error')
+      const errorHandler = errorCall[1]
+
+      const mockError = new Error('EADDRINUSE')
+      mockError.code = 'EADDRINUSE'
+
+      expect(() => errorHandler(mockError)).not.toThrow()
+      expect(mockLog).toHaveBeenCalledWith('HTTP server error: EADDRINUSE')
+      expect(mockLog).toHaveBeenCalledWith('Port 80 is already in use')
+    })
+
+    test('should create HTTPS server on port 443 with SSL configuration', () => {
+      mockConfig.config.ssl = {
+        key: '/path/to/key.pem',
+        cert: '/path/to/cert.pem'
+      }
+
+      Web.server()
+
+      expect(https.createServer).toHaveBeenCalledWith(
+        expect.objectContaining({
+          SNICallback: expect.any(Function),
+          key: 'mock-file-content',
+          cert: 'mock-file-content'
+        }),
+        expect.any(Function)
+      )
+      expect(mockHttpsServer.listen).toHaveBeenCalledWith(443)
+      expect(mockHttpsServer.on).toHaveBeenCalledWith('error', expect.any(Function))
+    })
+
+    test('should handle HTTPS server errors', () => {
+      mockConfig.config.ssl = {
+        key: '/path/to/key.pem',
+        cert: '/path/to/cert.pem'
+      }
+
+      // Create a fresh mock server for this test
+      const freshMockHttpsServer = {
+        listen: jest.fn(),
+        on: jest.fn(),
+        close: jest.fn()
+      }
+      https.createServer.mockReturnValue(freshMockHttpsServer)
+
+      // Reset the Web module's server instances to force recreation
+      Web['_Web__server_http'] = null
+      Web['_Web__server_https'] = null
+      Web['_Web__loaded'] = true // Ensure Web module is marked as loaded
+
+      // Ensure we have websites configured (required for server creation)
+      mockConfig.config.websites = {'example.com': createMockWebsiteConfig()}
+
+      Web.server()
+
+      // Verify HTTPS server was created
+      expect(https.createServer).toHaveBeenCalled()
+
+      // Verify the error handler was attached
+      expect(freshMockHttpsServer.on).toHaveBeenCalledWith('error', expect.any(Function))
+
+      // Get the error handler function
+      const errorCall = freshMockHttpsServer.on.mock.calls.find(call => call[0] === 'error')
+      const errorHandler = errorCall[1]
+
+      const mockError = new Error('EADDRINUSE')
+      mockError.code = 'EADDRINUSE'
+
+      expect(() => errorHandler(mockError)).not.toThrow()
+      expect(mockLog).toHaveBeenCalledWith('HTTPS server error: EADDRINUSE')
+      expect(mockLog).toHaveBeenCalledWith('Port 443 is already in use')
+    })
+
+    test('should not create HTTPS server without SSL configuration', () => {
+      mockConfig.config.ssl = undefined
+
+      Web.server()
+
+      expect(https.createServer).not.toHaveBeenCalled()
+    })
+
+    test('should not create HTTPS server with missing SSL files', () => {
+      mockConfig.config.ssl = {
+        key: '/path/to/key.pem',
+        cert: '/path/to/cert.pem'
+      }
+      fs.existsSync.mockImplementation(path => !path.includes('key.pem') && !path.includes('cert.pem'))
+
+      Web.server()
+
+      expect(https.createServer).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('website creation', () => {
+    beforeEach(async () => {
+      await Web.init()
+      mockConfig.config.web = {path: '/var/candypack'}
+    })
+
+    test('should create website with valid domain', () => {
+      const mockProgress = jest.fn()
+      const domain = 'example.com'
+
+      const result = Web.create(domain, mockProgress)
+
+      expect(result.success).toBe(true)
+      expect(result.message).toContain('Website example.com created')
+      expect(mockProgress).toHaveBeenCalledWith('domain', 'progress', expect.stringContaining('Setting up domain'))
+      expect(mockProgress).toHaveBeenCalledWith('domain', 'success', expect.stringContaining('Domain example.com set'))
+    })
+
+    test('should reject invalid domain names', () => {
+      const mockProgress = jest.fn()
+
+      // Test short domain
+      let result = Web.create('ab', mockProgress)
+      expect(result.success).toBe(false)
+      expect(result.message).toBe('Invalid domain.')
+
+      // Test domain without dot (except localhost)
+      result = Web.create('invalid', mockProgress)
+      expect(result.success).toBe(false)
+      expect(result.message).toBe('Invalid domain.')
+    })
+
+    test('should allow localhost as valid domain', () => {
+      const mockProgress = jest.fn()
+
+      const result = Web.create('localhost', mockProgress)
+
+      expect(result.success).toBe(true)
+      expect(result.message).toContain('Website localhost created')
+    })
+
+    test('should strip protocol prefixes from domain', () => {
+      const mockProgress = jest.fn()
+
+      Web.create('https://example.com', mockProgress)
+
+      expect(mockConfig.config.websites['example.com']).toBeDefined()
+      expect(mockConfig.config.websites['https://example.com']).toBeUndefined()
+    })
+
+    test('should reject existing domain', () => {
+      const mockProgress = jest.fn()
+      mockConfig.config.websites = {'example.com': {}}
+
+      const result = Web.create('example.com', mockProgress)
+
+      expect(result.success).toBe(false)
+      expect(result.message).toBe('Website example.com already exists.')
+    })
+
+    test('should create website directory structure', () => {
+      const mockProgress = jest.fn()
+      const domain = 'example.com'
+
+      // Mock fs.existsSync to return false for the website directory so it gets created
+      fs.existsSync.mockImplementation(path => {
+        if (path === '/var/candypack/example.com') return false
+        if (path.includes('node_modules')) return false
+        return true
+      })
+
+      Web.create(domain, mockProgress)
+
+      expect(fs.mkdirSync).toHaveBeenCalledWith('/var/candypack/example.com', {recursive: true})
+      expect(fs.cpSync).toHaveBeenCalledWith(expect.stringContaining('web/'), '/var/candypack/example.com', {recursive: true})
+    })
+
+    test('should setup npm link for candypack', () => {
+      const mockProgress = jest.fn()
+      const domain = 'example.com'
+
+      Web.create(domain, mockProgress)
+
+      expect(childProcess.execSync).toHaveBeenCalledWith('npm link candypack', {
+        cwd: '/var/candypack/example.com'
+      })
+    })
+
+    test('should remove node_modules/.bin if it exists', () => {
+      const mockProgress = jest.fn()
+      const domain = 'example.com'
+      fs.existsSync.mockImplementation(path => path.includes('node_modules/.bin'))
+
+      Web.create(domain, mockProgress)
+
+      // Note: The actual Web.js code has a bug - missing '/' in path concatenation
+      expect(fs.rmSync).toHaveBeenCalledWith('/var/candypack/example.com/node_modules/.bin', {recursive: true})
+    })
+
+    test('should create node_modules directory if it does not exist', () => {
+      const mockProgress = jest.fn()
+      const domain = 'example.com'
+      fs.existsSync.mockImplementation(path => !path.includes('node_modules'))
+
+      Web.create(domain, mockProgress)
+
+      expect(fs.mkdirSync).toHaveBeenCalledWith('/var/candypack/example.com/node_modules')
+    })
+
+    test('should setup DNS records for non-localhost domains', () => {
+      const mockProgress = jest.fn()
+      const domain = 'example.com'
+      const mockDNS = {
+        record: jest.fn(),
+        ip: '192.168.1.1'
+      }
+      mockCandy.setMock('server', 'DNS', mockDNS)
+      mockCandy.setMock('server', 'Api', {result: jest.fn((success, message) => ({success, message}))})
+
+      Web.create(domain, mockProgress)
+
+      expect(mockDNS.record).toHaveBeenCalledWith(
+        {name: 'example.com', type: 'A', value: '192.168.1.1'},
+        {name: 'www.example.com', type: 'CNAME', value: 'example.com'},
+        {name: 'example.com', type: 'MX', value: 'example.com'},
+        {name: 'example.com', type: 'TXT', value: 'v=spf1 a mx ip4:192.168.1.1 ~all'},
+        {
+          name: '_dmarc.example.com',
+          type: 'TXT',
+          value: 'v=DMARC1; p=reject; rua=mailto:postmaster@example.com'
+        }
+      )
+      expect(mockProgress).toHaveBeenCalledWith('dns', 'progress', expect.stringContaining('Setting up DNS records'))
+      expect(mockProgress).toHaveBeenCalledWith('dns', 'success', expect.stringContaining('DNS records for example.com set'))
+    })
+
+    test('should not setup DNS records for localhost', () => {
+      const mockProgress = jest.fn()
+      const mockDNS = {record: jest.fn()}
+      mockCandy.setMock('server', 'DNS', mockDNS)
+      mockCandy.setMock('server', 'Api', {result: jest.fn((success, message) => ({success, message}))})
+
+      Web.create('localhost', mockProgress)
+
+      expect(mockDNS.record).not.toHaveBeenCalled()
+    })
+
+    test('should not setup DNS records for IP addresses', () => {
+      const mockProgress = jest.fn()
+      const mockDNS = {record: jest.fn()}
+      mockCandy.setMock('server', 'DNS', mockDNS)
+      mockCandy.setMock('server', 'Api', {result: jest.fn((success, message) => ({success, message}))})
+
+      Web.create('192.168.1.1', mockProgress)
+
+      expect(mockDNS.record).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('request handling and proxy functionality', () => {
+    let mockReq, mockRes
+
+    beforeEach(async () => {
+      await Web.init()
+      mockReq = createMockRequest()
+      mockRes = createMockResponse()
+
+      // Setup a test website
+      mockConfig.config.websites = {
+        'example.com': {
+          domain: 'example.com',
+          path: '/var/candypack/example.com',
+          pid: 12345,
+          port: 3000,
+          cert: {
+            ssl: {
+              key: '/path/to/example.key',
+              cert: '/path/to/example.cert'
+            }
+          }
+        }
+      }
+
+      // Mock watcher to indicate process is running
+      Web['_Web__watcher'] = {12345: true}
+    })
+
+    test('should redirect HTTP requests to HTTPS', () => {
+      // Verify the basic setup first
+      expect(mockConfig.config.websites['example.com']).toBeDefined()
+      expect(mockConfig.config.websites['example.com'].pid).toBe(12345)
+      expect(Web['_Web__watcher'][12345]).toBe(true)
+
+      mockReq.headers.host = 'example.com'
+      mockReq.url = '/test-path'
+
+      Web.request(mockReq, mockRes, false)
+
+      expect(mockRes.writeHead).toHaveBeenCalledWith(301, {
+        Location: 'https://example.com/test-path'
+      })
+      expect(mockRes.end).toHaveBeenCalled()
+    })
+
+    test('should serve default index for requests without host header', () => {
+      mockReq.headers = {}
+
+      Web.request(mockReq, mockRes, true)
+
+      expect(mockRes.write).toHaveBeenCalledWith('CandyPack Server')
+      expect(mockRes.end).toHaveBeenCalled()
+    })
+
+    test('should serve default index for unknown hosts', () => {
+      mockReq.headers.host = 'unknown.com'
+
+      Web.request(mockReq, mockRes, true)
+
+      expect(mockRes.write).toHaveBeenCalledWith('CandyPack Server')
+      expect(mockRes.end).toHaveBeenCalled()
+    })
+
+    test('should resolve subdomain to parent domain', () => {
+      mockReq.headers.host = 'www.example.com'
+      mockReq.url = '/test'
+
+      Web.request(mockReq, mockRes, true)
+
+      expect(httpProxy.createProxyServer).toHaveBeenCalledWith({
+        timeout: 30000,
+        proxyTimeout: 30000,
+        keepAlive: true
+      })
+      expect(mockProxyServer.web).toHaveBeenCalledWith(mockReq, mockRes, {
+        target: 'http://127.0.0.1:3000'
+      })
+    })
+
+    test('should proxy HTTPS requests to website process', () => {
+      mockReq.headers.host = 'example.com'
+      mockReq.url = '/api/test'
+
+      Web.request(mockReq, mockRes, true)
+
+      expect(httpProxy.createProxyServer).toHaveBeenCalledWith({
+        timeout: 30000,
+        proxyTimeout: 30000,
+        keepAlive: true
+      })
+      expect(mockProxyServer.web).toHaveBeenCalledWith(mockReq, mockRes, {
+        target: 'http://127.0.0.1:3000'
+      })
+    })
+
+    test('should serve default index when website process is not running', () => {
+      mockConfig.config.websites['example.com'].pid = null
+      mockReq.headers.host = 'example.com'
+
+      Web.request(mockReq, mockRes, true)
+
+      expect(mockRes.write).toHaveBeenCalledWith('CandyPack Server')
+      expect(mockRes.end).toHaveBeenCalled()
+      expect(httpProxy.createProxyServer).not.toHaveBeenCalled()
+    })
+
+    test('should serve default index when watcher indicates process is not running', () => {
+      Web['_Web__watcher'] = {12345: false}
+      mockReq.headers.host = 'example.com'
+
+      Web.request(mockReq, mockRes, true)
+
+      expect(mockRes.write).toHaveBeenCalledWith('CandyPack Server')
+      expect(mockRes.end).toHaveBeenCalled()
+      expect(httpProxy.createProxyServer).not.toHaveBeenCalled()
+    })
+
+    test('should add custom headers to proxied requests', () => {
+      mockReq.headers.host = 'example.com'
+      mockReq.socket = {remoteAddress: '192.168.1.100'}
+
+      Web.request(mockReq, mockRes, true)
+
+      // Simulate proxyReq event
+      const proxyReqHandler = mockProxyServer.on.mock.calls.find(call => call[0] === 'proxyReq')[1]
+      const mockProxyReq = {
+        setHeader: jest.fn()
+      }
+
+      proxyReqHandler(mockProxyReq, mockReq)
+
+      expect(mockProxyReq.setHeader).toHaveBeenCalledWith('X-Candy-Connection-RemoteAddress', '192.168.1.100')
+      expect(mockProxyReq.setHeader).toHaveBeenCalledWith('X-Candy-Connection-SSL', 'true')
+    })
+
+    test('should handle proxy errors gracefully', () => {
+      mockReq.headers.host = 'example.com'
+
+      Web.request(mockReq, mockRes, true)
+
+      // Simulate proxy error
+      const errorHandler = mockProxyServer.on.mock.calls.find(call => call[0] === 'error')[1]
+      const mockError = new Error('Connection refused')
+
+      errorHandler(mockError, mockReq, mockRes)
+
+      expect(mockLog).toHaveBeenCalledWith('Proxy error for example.com: Connection refused')
+      expect(mockRes.statusCode).toBe(502)
+      expect(mockRes.end).toHaveBeenCalledWith('Bad Gateway')
+    })
+
+    test('should not set response status if headers already sent', () => {
+      mockReq.headers.host = 'example.com'
+      mockRes.headersSent = true
+
+      Web.request(mockReq, mockRes, true)
+
+      // Simulate proxy error
+      const errorHandler = mockProxyServer.on.mock.calls.find(call => call[0] === 'error')[1]
+      const mockError = new Error('Connection refused')
+
+      errorHandler(mockError, mockReq, mockRes)
+
+      expect(mockRes.statusCode).not.toBe(502)
+      expect(mockRes.end).not.toHaveBeenCalledWith('Bad Gateway')
+    })
+
+    test('should handle exceptions in request processing', () => {
+      mockReq.headers.host = 'example.com'
+      httpProxy.createProxyServer.mockImplementation(() => {
+        throw new Error('Proxy creation failed')
+      })
+
+      Web.request(mockReq, mockRes, true)
+
+      expect(mockLog).toHaveBeenCalledWith(expect.any(Error))
+      expect(mockRes.write).toHaveBeenCalledWith('CandyPack Server')
+      expect(mockRes.end).toHaveBeenCalled()
+    })
+
+    test('should handle HTTP requests with query parameters in redirection', () => {
+      mockReq.headers.host = 'example.com'
+      mockReq.url = '/test-path?param=value&other=123'
+
+      Web.request(mockReq, mockRes, false)
+
+      expect(mockRes.writeHead).toHaveBeenCalledWith(301, {
+        Location: 'https://example.com/test-path?param=value&other=123'
+      })
+      expect(mockRes.end).toHaveBeenCalled()
+    })
+
+    test('should handle HTTP requests with fragments in redirection', () => {
+      mockReq.headers.host = 'example.com'
+      mockReq.url = '/test-path#section'
+
+      Web.request(mockReq, mockRes, false)
+
+      expect(mockRes.writeHead).toHaveBeenCalledWith(301, {
+        Location: 'https://example.com/test-path#section'
+      })
+      expect(mockRes.end).toHaveBeenCalled()
+    })
+
+    test('should handle multi-level subdomain resolution', () => {
+      // Setup a multi-level subdomain scenario
+      mockConfig.config.websites = {
+        'example.com': {
+          domain: 'example.com',
+          path: '/var/candypack/example.com',
+          pid: 12345,
+          port: 3000
+        }
+      }
+      Web['_Web__watcher'] = {12345: true}
+
+      mockReq.headers.host = 'api.staging.example.com'
+      mockReq.url = '/test'
+
+      Web.request(mockReq, mockRes, true)
+
+      expect(httpProxy.createProxyServer).toHaveBeenCalledWith({
+        timeout: 30000,
+        proxyTimeout: 30000,
+        keepAlive: true
+      })
+      expect(mockProxyServer.web).toHaveBeenCalledWith(mockReq, mockRes, {
+        target: 'http://127.0.0.1:3000'
+      })
+    })
+
+    test('should handle requests with port numbers in host header', () => {
+      mockReq.headers.host = 'example.com:8080'
+      mockReq.url = '/test'
+
+      Web.request(mockReq, mockRes, true)
+
+      expect(httpProxy.createProxyServer).toHaveBeenCalledWith({
+        timeout: 30000,
+        proxyTimeout: 30000,
+        keepAlive: true
+      })
+      expect(mockProxyServer.web).toHaveBeenCalledWith(mockReq, mockRes, {
+        target: 'http://127.0.0.1:3000'
+      })
+    })
+
+    test('should set correct SSL header for HTTP requests', () => {
+      mockReq.headers.host = 'example.com'
+      mockReq.socket = {remoteAddress: '192.168.1.100'}
+
+      Web.request(mockReq, mockRes, false)
+
+      // HTTP request should redirect, but let's test the header logic by mocking a proxy scenario
+      // Reset mocks and test HTTPS request
+      jest.clearAllMocks()
+
+      Web.request(mockReq, mockRes, true)
+
+      // Simulate proxyReq event for HTTPS
+      const proxyReqHandler = mockProxyServer.on.mock.calls.find(call => call[0] === 'proxyReq')[1]
+      const mockProxyReq = {
+        setHeader: jest.fn()
+      }
+
+      proxyReqHandler(mockProxyReq, mockReq)
+
+      expect(mockProxyReq.setHeader).toHaveBeenCalledWith('X-Candy-Connection-SSL', 'true')
+    })
+
+    test('should handle missing remote address in proxy headers', () => {
+      mockReq.headers.host = 'example.com'
+      mockReq.socket = {} // No remoteAddress property
+
+      Web.request(mockReq, mockRes, true)
+
+      // Simulate proxyReq event
+      const proxyReqHandler = mockProxyServer.on.mock.calls.find(call => call[0] === 'proxyReq')[1]
+      const mockProxyReq = {
+        setHeader: jest.fn()
+      }
+
+      proxyReqHandler(mockProxyReq, mockReq)
+
+      expect(mockProxyReq.setHeader).toHaveBeenCalledWith('X-Candy-Connection-RemoteAddress', '')
+      expect(mockProxyReq.setHeader).toHaveBeenCalledWith('X-Candy-Connection-SSL', 'true')
+    })
+
+    test('should handle proxy timeout configuration', () => {
+      mockReq.headers.host = 'example.com'
+
+      Web.request(mockReq, mockRes, true)
+
+      expect(httpProxy.createProxyServer).toHaveBeenCalledWith({
+        timeout: 30000,
+        proxyTimeout: 30000,
+        keepAlive: true
+      })
+    })
+  })
+
+  describe('process management and monitoring', () => {
+    let mockChild
+
+    beforeEach(async () => {
+      await Web.init()
+      mockConfig.config.web = {path: '/var/candypack'}
+
+      // Setup mock child process
+      mockChild = {
+        pid: 12345,
+        stdout: {on: jest.fn()},
+        stderr: {on: jest.fn()},
+        on: jest.fn()
+      }
+      childProcess.spawn.mockReturnValue(mockChild)
+
+      // Initialize Web module's private properties
+      Web['_Web__active'] = {}
+      Web['_Web__error_counts'] = {}
+      Web['_Web__logs'] = {log: {}, err: {}}
+      Web['_Web__ports'] = {}
+      Web['_Web__started'] = {}
+      Web['_Web__watcher'] = {}
+    })
+
+    test('should test port checking functionality', async () => {
+      const mockNetServer = {
+        once: jest.fn((event, callback) => {
+          if (event === 'listening') {
+            setTimeout(() => callback(), 0)
+          }
+        }),
+        listen: jest.fn(),
+        close: jest.fn()
+      }
+      net.createServer.mockReturnValue(mockNetServer)
+
+      const result = await Web.checkPort(3000)
+
+      expect(result).toBe(true)
+      expect(mockNetServer.listen).toHaveBeenCalledWith(3000, '127.0.0.1')
+      expect(mockNetServer.close).toHaveBeenCalled()
+    })
+
+    test('should detect port conflicts', async () => {
+      const mockNetServer = {
+        once: jest.fn((event, callback) => {
+          if (event === 'error') {
+            setTimeout(() => callback(), 0)
+          }
+        }),
+        listen: jest.fn(),
+        close: jest.fn()
+      }
+      net.createServer.mockReturnValue(mockNetServer)
+
+      const result = await Web.checkPort(3000)
+
+      expect(result).toBe(false)
+    })
+
+    test('should not start process if already active', async () => {
+      const domain = 'example.com'
+      mockConfig.config.websites = {
+        [domain]: {
+          domain,
+          path: '/var/candypack/example.com'
+        }
+      }
+
+      // Mark domain as active
+      Web['_Web__active'][domain] = true
+
+      await Web.start(domain)
+
+      expect(childProcess.spawn).not.toHaveBeenCalled()
+    })
+
+    test('should not start process if website does not exist', async () => {
+      await Web.start('nonexistent.com')
+
+      expect(childProcess.spawn).not.toHaveBeenCalled()
+    })
+
+    test('should respect error cooldown period', async () => {
+      const domain = 'example.com'
+      const now = Date.now()
+      mockConfig.config.websites = {
+        [domain]: {
+          domain,
+          path: '/var/candypack/example.com',
+          status: 'errored',
+          updated: now - 500 // 500ms ago
+        }
+      }
+
+      // Set error count to 2 (should wait 2 seconds)
+      Web['_Web__error_counts'][domain] = 2
+
+      await Web.start(domain)
+
+      expect(childProcess.spawn).not.toHaveBeenCalled()
+    })
+
+    test('should not start process without index.js file', async () => {
+      const domain = 'example.com'
+      mockConfig.config.websites = {
+        [domain]: {
+          domain,
+          path: '/var/candypack/example.com'
+        }
+      }
+
+      // Mock index.js file as missing
+      fs.existsSync.mockImplementation(path => !path.includes('index.js'))
+
+      await Web.start(domain)
+
+      expect(childProcess.spawn).not.toHaveBeenCalled()
+      expect(mockLog).toHaveBeenCalledWith("Website example.com doesn't have index.js file.")
+    })
+
+    test('should automatically restart crashed processes via check method', async () => {
+      const domain = 'example.com'
+      mockConfig.config.websites = {
+        [domain]: {
+          domain,
+          path: '/var/candypack/example.com',
+          pid: null // No process running
+        }
+      }
+
+      // Spy on the start method
+      const startSpy = jest.spyOn(Web, 'start')
+
+      Web.check()
+
+      expect(startSpy).toHaveBeenCalledWith(domain)
+    })
+
+    test('should restart processes when watcher indicates they are not running', async () => {
+      const domain = 'example.com'
+      const pid = 12345
+      mockConfig.config.websites = {
+        [domain]: {
+          domain,
+          path: '/var/candypack/example.com',
+          pid
+        }
+      }
+
+      // Mark process as not running in watcher
+      Web['_Web__watcher'][pid] = false
+
+      const mockProcess = {
+        stop: jest.fn()
+      }
+      mockCandy.setMock('core', 'Process', mockProcess)
+
+      const startSpy = jest.spyOn(Web, 'start')
+
+      Web.check()
+
+      expect(mockProcess.stop).toHaveBeenCalledWith(pid)
+      expect(mockConfig.config.websites[domain].pid).toBeNull()
+      expect(startSpy).toHaveBeenCalledWith(domain)
+    })
+
+    test('should write logs to files during check', async () => {
+      const domain = 'example.com'
+      mockConfig.config.websites = {
+        [domain]: {
+          domain,
+          path: '/var/candypack/example.com',
+          pid: 12345
+        }
+      }
+
+      // Setup logs
+      Web['_Web__logs'].log[domain] = 'Test log content'
+      Web['_Web__logs'].err[domain] = 'Test error content'
+      Web['_Web__watcher'][12345] = true
+
+      os.homedir.mockReturnValue('/home/user')
+
+      Web.check()
+
+      expect(fs.writeFile).toHaveBeenCalledWith('/home/user/.candypack/logs/example.com.log', 'Test log content', expect.any(Function))
+      expect(fs.writeFile).toHaveBeenCalledWith('/var/candypack/example.com/error.log', 'Test error content', expect.any(Function))
+    })
+
+    test('should handle log file write errors gracefully', async () => {
+      const domain = 'example.com'
+      mockConfig.config.websites = {
+        [domain]: {
+          domain,
+          path: '/var/candypack/example.com',
+          pid: 12345
+        }
+      }
+
+      Web['_Web__logs'].log[domain] = 'Test log content'
+      Web['_Web__watcher'][12345] = true
+
+      // Mock fs.writeFile to call callback with error
+      fs.writeFile.mockImplementation((path, data, callback) => {
+        callback(new Error('Write failed'))
+      })
+
+      Web.check()
+
+      // Should not throw, error should be logged
+      expect(mockLog).toHaveBeenCalledWith(expect.any(Error))
+    })
+  })
+
+  describe('website deletion and resource cleanup', () => {
+    beforeEach(async () => {
+      await Web.init()
+    })
+
+    test('should delete website and cleanup all resources', async () => {
+      const domain = 'example.com'
+      const pid = 12345
+      const port = 60000
+
+      mockConfig.config.websites = {
+        [domain]: {
+          domain,
+          path: '/var/candypack/example.com',
+          pid,
+          port
+        }
+      }
+
+      // Setup internal state
+      Web['_Web__watcher'][pid] = true
+      Web['_Web__ports'][port] = true
+      Web['_Web__logs'].log[domain] = 'log content'
+      Web['_Web__logs'].err[domain] = 'error content'
+      Web['_Web__error_counts'][domain] = 2
+      Web['_Web__active'][domain] = false
+      Web['_Web__started'][domain] = Date.now()
+
+      const mockProcess = {
+        stop: jest.fn()
+      }
+      mockCandy.setMock('core', 'Process', mockProcess)
+
+      const result = await Web.delete(domain)
+
+      expect(result.success).toBe(true)
+      expect(result.message).toContain('Website example.com deleted')
+      expect(mockConfig.config.websites[domain]).toBeUndefined()
+      expect(mockProcess.stop).toHaveBeenCalledWith(pid)
+      expect(Web['_Web__watcher'][pid]).toBeUndefined()
+      expect(Web['_Web__ports'][port]).toBeUndefined()
+      expect(Web['_Web__logs'].log[domain]).toBeUndefined()
+      expect(Web['_Web__logs'].err[domain]).toBeUndefined()
+      expect(Web['_Web__error_counts'][domain]).toBeUndefined()
+      expect(Web['_Web__active'][domain]).toBeUndefined()
+      expect(Web['_Web__started'][domain]).toBeUndefined()
+    })
+
+    test('should handle deletion of non-existent website', async () => {
+      const result = await Web.delete('nonexistent.com')
+
+      expect(result.success).toBe(false)
+      expect(result.message).toContain('Website nonexistent.com not found')
+    })
+
+    test('should handle deletion of website without running process', async () => {
+      const domain = 'example.com'
+
+      mockConfig.config.websites = {
+        [domain]: {
+          domain,
+          path: '/var/candypack/example.com',
+          pid: null // No process running
+        }
+      }
+
+      const result = await Web.delete(domain)
+
+      expect(result.success).toBe(true)
+      expect(result.message).toContain('Website example.com deleted')
+      expect(mockConfig.config.websites[domain]).toBeUndefined()
+    })
+
+    test('should strip protocol prefixes from domain in deletion', async () => {
+      const domain = 'example.com'
+
+      mockConfig.config.websites = {
+        [domain]: {
+          domain,
+          path: '/var/candypack/example.com'
+        }
+      }
+
+      const result = await Web.delete('https://example.com')
+
+      expect(result.success).toBe(true)
+      expect(mockConfig.config.websites[domain]).toBeUndefined()
+    })
+
+    test('should stop all website processes via stopAll method', () => {
+      const domain1 = 'example.com'
+      const domain2 = 'test.com'
+      const pid1 = 12345
+      const pid2 = 67890
+
+      mockConfig.config.websites = {
+        [domain1]: {domain: domain1, pid: pid1},
+        [domain2]: {domain: domain2, pid: pid2}
+      }
+
+      const mockProcess = {
+        stop: jest.fn()
+      }
+      mockCandy.setMock('core', 'Process', mockProcess)
+
+      Web.stopAll()
+
+      expect(mockProcess.stop).toHaveBeenCalledWith(pid1)
+      expect(mockProcess.stop).toHaveBeenCalledWith(pid2)
+      expect(mockConfig.config.websites[domain1].pid).toBeNull()
+      expect(mockConfig.config.websites[domain2].pid).toBeNull()
+    })
+
+    test('should handle stopAll with no websites', () => {
+      mockConfig.config.websites = {}
+
+      const mockProcess = {
+        stop: jest.fn()
+      }
+      mockCandy.setMock('core', 'Process', mockProcess)
+
+      expect(() => Web.stopAll()).not.toThrow()
+      expect(mockProcess.stop).not.toHaveBeenCalled()
+    })
+
+    test('should handle stopAll with websites that have no running processes', () => {
+      const domain = 'example.com'
+
+      mockConfig.config.websites = {
+        [domain]: {domain, pid: null}
+      }
+
+      const mockProcess = {
+        stop: jest.fn()
+      }
+      mockCandy.setMock('core', 'Process', mockProcess)
+
+      Web.stopAll()
+
+      expect(mockProcess.stop).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('SSL certificate handling and SNI', () => {
+    beforeEach(async () => {
+      await Web.init()
+      mockConfig.config.ssl = {
+        key: '/path/to/default.key',
+        cert: '/path/to/default.cert'
+      }
+      mockConfig.config.websites = {
+        'example.com': {
+          domain: 'example.com',
+          cert: {
+            ssl: {
+              key: '/path/to/example.key',
+              cert: '/path/to/example.cert'
+            }
+          }
+        },
+        'test.com': {
+          domain: 'test.com',
+          cert: false
+        }
+      }
+    })
+
+    test('should use website-specific SSL certificate via SNI', () => {
+      Web.server()
+
+      const httpsOptions = https.createServer.mock.calls[0][0]
+      const sniCallback = httpsOptions.SNICallback
+      const mockCallback = jest.fn()
+
+      sniCallback('example.com', mockCallback)
+
+      expect(fs.readFileSync).toHaveBeenCalledWith('/path/to/example.key')
+      expect(fs.readFileSync).toHaveBeenCalledWith('/path/to/example.cert')
+      expect(tls.createSecureContext).toHaveBeenCalledWith({
+        key: 'mock-file-content',
+        cert: 'mock-file-content'
+      })
+      expect(mockCallback).toHaveBeenCalledWith(null, expect.any(Object))
+    })
+
+    test('should fall back to default SSL certificate for websites without specific certs', () => {
+      Web.server()
+
+      const httpsOptions = https.createServer.mock.calls[0][0]
+      const sniCallback = httpsOptions.SNICallback
+      const mockCallback = jest.fn()
+
+      sniCallback('test.com', mockCallback)
+
+      expect(tls.createSecureContext).toHaveBeenCalledWith({
+        key: 'mock-file-content',
+        cert: 'mock-file-content'
+      })
+      expect(mockCallback).toHaveBeenCalledWith(null, expect.any(Object))
+    })
+
+    test('should resolve subdomain to parent domain for SSL certificate', () => {
+      Web.server()
+
+      const httpsOptions = https.createServer.mock.calls[0][0]
+      const sniCallback = httpsOptions.SNICallback
+      const mockCallback = jest.fn()
+
+      sniCallback('www.example.com', mockCallback)
+
+      expect(fs.readFileSync).toHaveBeenCalledWith('/path/to/example.key')
+      expect(fs.readFileSync).toHaveBeenCalledWith('/path/to/example.cert')
+    })
+
+    test('should use default certificate for unknown domains', () => {
+      Web.server()
+
+      const httpsOptions = https.createServer.mock.calls[0][0]
+      const sniCallback = httpsOptions.SNICallback
+      const mockCallback = jest.fn()
+
+      sniCallback('unknown.com', mockCallback)
+
+      expect(tls.createSecureContext).toHaveBeenCalledWith({
+        key: 'mock-file-content',
+        cert: 'mock-file-content'
+      })
+      expect(mockCallback).toHaveBeenCalledWith(null, expect.any(Object))
+    })
+
+    test('should handle SSL certificate file read errors', () => {
+      fs.readFileSync.mockImplementation(path => {
+        if (path.includes('example.key')) {
+          throw new Error('File not found')
+        }
+        return 'mock-file-content'
+      })
+
+      Web.server()
+
+      const httpsOptions = https.createServer.mock.calls[0][0]
+      const sniCallback = httpsOptions.SNICallback
+      const mockCallback = jest.fn()
+
+      sniCallback('example.com', mockCallback)
+
+      expect(mockLog).toHaveBeenCalledWith('SSL certificate error for example.com: File not found')
+      expect(mockCallback).toHaveBeenCalledWith(expect.any(Error))
+    })
+
+    test('should handle missing SSL certificate files gracefully', () => {
+      fs.existsSync.mockImplementation(path => !path.includes('example.key') && !path.includes('example.cert'))
+
+      Web.server()
+
+      const httpsOptions = https.createServer.mock.calls[0][0]
+      const sniCallback = httpsOptions.SNICallback
+      const mockCallback = jest.fn()
+
+      sniCallback('example.com', mockCallback)
+
+      // Should fall back to default certificate
+      expect(tls.createSecureContext).toHaveBeenCalledWith({
+        key: 'mock-file-content',
+        cert: 'mock-file-content'
+      })
+      expect(mockCallback).toHaveBeenCalledWith(null, expect.any(Object))
+    })
+
+    test('should handle multi-level subdomain SSL certificate resolution', () => {
+      Web.server()
+
+      const httpsOptions = https.createServer.mock.calls[0][0]
+      const sniCallback = httpsOptions.SNICallback
+      const mockCallback = jest.fn()
+
+      // Test multi-level subdomain resolution (api.staging.example.com -> example.com)
+      sniCallback('api.staging.example.com', mockCallback)
+
+      expect(fs.readFileSync).toHaveBeenCalledWith('/path/to/example.key')
+      expect(fs.readFileSync).toHaveBeenCalledWith('/path/to/example.cert')
+      expect(tls.createSecureContext).toHaveBeenCalledWith({
+        key: 'mock-file-content',
+        cert: 'mock-file-content'
+      })
+      expect(mockCallback).toHaveBeenCalledWith(null, expect.any(Object))
+    })
+
+    test('should handle SSL certificate with missing cert property', () => {
+      mockConfig.config.websites['example.com'].cert = {
+        ssl: {
+          key: '/path/to/example.key'
+          // Missing cert property
+        }
+      }
+
+      Web.server()
+
+      const httpsOptions = https.createServer.mock.calls[0][0]
+      const sniCallback = httpsOptions.SNICallback
+      const mockCallback = jest.fn()
+
+      sniCallback('example.com', mockCallback)
+
+      // Should fall back to default certificate
+      expect(tls.createSecureContext).toHaveBeenCalledWith({
+        key: 'mock-file-content',
+        cert: 'mock-file-content'
+      })
+      expect(mockCallback).toHaveBeenCalledWith(null, expect.any(Object))
+    })
+
+    test('should handle SSL certificate with missing key property', () => {
+      mockConfig.config.websites['example.com'].cert = {
+        ssl: {
+          cert: '/path/to/example.cert'
+          // Missing key property
+        }
+      }
+
+      Web.server()
+
+      const httpsOptions = https.createServer.mock.calls[0][0]
+      const sniCallback = httpsOptions.SNICallback
+      const mockCallback = jest.fn()
+
+      sniCallback('example.com', mockCallback)
+
+      // Should fall back to default certificate
+      expect(tls.createSecureContext).toHaveBeenCalledWith({
+        key: 'mock-file-content',
+        cert: 'mock-file-content'
+      })
+      expect(mockCallback).toHaveBeenCalledWith(null, expect.any(Object))
+    })
+
+    test('should handle SSL certificate with missing ssl property', () => {
+      mockConfig.config.websites['example.com'].cert = {
+        // Missing ssl property
+      }
+
+      Web.server()
+
+      const httpsOptions = https.createServer.mock.calls[0][0]
+      const sniCallback = httpsOptions.SNICallback
+      const mockCallback = jest.fn()
+
+      sniCallback('example.com', mockCallback)
+
+      // Should fall back to default certificate
+      expect(tls.createSecureContext).toHaveBeenCalledWith({
+        key: 'mock-file-content',
+        cert: 'mock-file-content'
+      })
+      expect(mockCallback).toHaveBeenCalledWith(null, expect.any(Object))
+    })
+
+    test('should handle hostname without dots in SNI callback', () => {
+      Web.server()
+
+      const httpsOptions = https.createServer.mock.calls[0][0]
+      const sniCallback = httpsOptions.SNICallback
+      const mockCallback = jest.fn()
+
+      sniCallback('localhost', mockCallback)
+
+      // Should use default certificate for localhost
+      expect(tls.createSecureContext).toHaveBeenCalledWith({
+        key: 'mock-file-content',
+        cert: 'mock-file-content'
+      })
+      expect(mockCallback).toHaveBeenCalledWith(null, expect.any(Object))
+    })
+
+    test('should handle tls.createSecureContext errors', () => {
+      tls.createSecureContext.mockImplementation(() => {
+        throw new Error('Invalid certificate format')
+      })
+
+      Web.server()
+
+      const httpsOptions = https.createServer.mock.calls[0][0]
+      const sniCallback = httpsOptions.SNICallback
+      const mockCallback = jest.fn()
+
+      sniCallback('example.com', mockCallback)
+
+      expect(mockLog).toHaveBeenCalledWith('SSL certificate error for example.com: Invalid certificate format')
+      expect(mockCallback).toHaveBeenCalledWith(expect.any(Error))
+    })
+  })
+
+  describe('website deletion', () => {
+    beforeEach(async () => {
+      await Web.init()
+      mockConfig.config.websites = {
+        'example.com': {
+          domain: 'example.com',
+          path: '/var/candypack/example.com',
+          pid: 12345,
+          port: 3000
+        }
+      }
+      Web['_Web__watcher'] = {12345: true}
+      Web['_Web__ports'] = {3000: true}
+      Web['_Web__logs'] = {
+        log: {'example.com': 'log content'},
+        err: {'example.com': 'error content'}
+      }
+      Web['_Web__error_counts'] = {'example.com': 2}
+      Web['_Web__active'] = {'example.com': false}
+      Web['_Web__started'] = {'example.com': Date.now()}
+    })
+
+    test('should delete website and cleanup all resources', async () => {
+      const mockProcess = {
+        stop: jest.fn()
+      }
+      mockCandy.setMock('core', 'Process', mockProcess)
+
+      const result = await Web.delete('example.com')
+
+      expect(result.success).toBe(true)
+      expect(result.message).toBe('Website example.com deleted.')
+      expect(mockConfig.config.websites['example.com']).toBeUndefined()
+      expect(mockProcess.stop).toHaveBeenCalledWith(12345)
+      expect(Web['_Web__watcher'][12345]).toBeUndefined()
+      expect(Web['_Web__ports'][3000]).toBeUndefined()
+      expect(Web['_Web__logs'].log['example.com']).toBeUndefined()
+      expect(Web['_Web__logs'].err['example.com']).toBeUndefined()
+      expect(Web['_Web__error_counts']['example.com']).toBeUndefined()
+      expect(Web['_Web__active']['example.com']).toBeUndefined()
+      expect(Web['_Web__started']['example.com']).toBeUndefined()
+    })
+
+    test('should strip protocol prefixes before deletion', async () => {
+      const result = await Web.delete('https://example.com')
+
+      expect(result.success).toBe(true)
+      expect(mockConfig.config.websites['example.com']).toBeUndefined()
+    })
+
+    test('should return error for non-existent website', async () => {
+      const result = await Web.delete('nonexistent.com')
+
+      expect(result.success).toBe(false)
+      expect(result.message).toBe('Website nonexistent.com not found.')
+    })
+
+    test('should handle deletion of website without running process', async () => {
+      mockConfig.config.websites['example.com'].pid = null
+
+      const result = await Web.delete('example.com')
+
+      expect(result.success).toBe(true)
+      expect(mockConfig.config.websites['example.com']).toBeUndefined()
+    })
+  })
+
+  describe('utility methods', () => {
+    beforeEach(async () => {
+      await Web.init()
+    })
+
+    test('should list all websites', async () => {
+      mockConfig.config.websites = {
+        'example.com': {},
+        'test.com': {},
+        'demo.com': {}
+      }
+
+      const result = await Web.list()
+
+      expect(result.success).toBe(true)
+      expect(result.message).toContain('example.com')
+      expect(result.message).toContain('test.com')
+      expect(result.message).toContain('demo.com')
+    })
+
+    test('should return error when no websites exist', async () => {
+      mockConfig.config.websites = {}
+
+      const result = await Web.list()
+
+      expect(result.success).toBe(false)
+      expect(result.message).toBe('No websites found.')
+    })
+
+    test('should return website status', async () => {
+      mockConfig.config.websites = {
+        'example.com': {
+          status: 'running',
+          pid: 12345
+        }
+      }
+
+      const result = await Web.status()
+
+      expect(result).toEqual(mockConfig.config.websites)
+    })
+
+    test('should set website configuration', () => {
+      const websiteData = {
+        domain: 'example.com',
+        path: '/var/candypack/example.com',
+        status: 'running'
+      }
+
+      Web.set('example.com', websiteData)
+
+      expect(mockConfig.config.websites['example.com']).toEqual(websiteData)
+    })
+
+    test('should stop all websites', () => {
+      mockConfig.config.websites = {
+        'example.com': {pid: 12345},
+        'test.com': {pid: 67890},
+        'demo.com': {pid: null}
+      }
+
+      const mockProcess = {
+        stop: jest.fn()
+      }
+      mockCandy.setMock('core', 'Process', mockProcess)
+
+      Web.stopAll()
+
+      expect(mockProcess.stop).toHaveBeenCalledWith(12345)
+      expect(mockProcess.stop).toHaveBeenCalledWith(67890)
+      expect(mockProcess.stop).toHaveBeenCalledTimes(2)
+      expect(mockConfig.config.websites['example.com'].pid).toBe(null)
+      expect(mockConfig.config.websites['test.com'].pid).toBe(null)
+    })
+
+    test('should serve default index page', () => {
+      const mockReq = createMockRequest()
+      const mockRes = createMockResponse()
+
+      Web.index(mockReq, mockRes)
+
+      expect(mockRes.write).toHaveBeenCalledWith('CandyPack Server')
+      expect(mockRes.end).toHaveBeenCalled()
+    })
+  })
+})