odac 0.9.0

package/test/core/Lang.test.js

@@ -0,0 +1,250 @@
+// Mock fs before requiring Lang
+jest.mock('fs', () => ({
+  promises: {
+    writeFile: jest.fn().mockResolvedValue()
+  },
+  readFileSync: jest.fn()
+}))
+
+const fs = require('fs')
+const path = require('path')
+const Lang = require('../../core/Lang')
+
+describe('Lang', () => {
+  let originalConsoleError
+
+  beforeEach(() => {
+    // Reset mocks before each test
+    fs.readFileSync.mockClear()
+    fs.promises.writeFile.mockClear()
+
+    // Mock console.error to prevent noise in tests
+    originalConsoleError = console.error
+    console.error = jest.fn()
+  })
+
+  afterEach(() => {
+    // Restore console.error
+    console.error = originalConsoleError
+  })
+
+  it("should return 'CandyPack' for the 'CandyPack' key", () => {
+    const lang = new Lang()
+    expect(lang.get('CandyPack')).toBe('CandyPack')
+  })
+
+  it('should return the translation for an existing key', () => {
+    const mockStrings = {'test.key': 'Test Value'}
+    fs.readFileSync.mockReturnValue(JSON.stringify(mockStrings))
+
+    const lang = new Lang()
+    expect(lang.get('test.key')).toBe('Test Value')
+  })
+
+  it('should replace placeholders with arguments', () => {
+    const mockStrings = {greeting: 'Hello, %s! Welcome, %s.'}
+    fs.readFileSync.mockReturnValue(JSON.stringify(mockStrings))
+
+    const lang = new Lang()
+    expect(lang.get('greeting', 'John', 'Jane')).toBe('Hello, John! Welcome, Jane.')
+  })
+
+  it('should return the key and try to save it if it does not exist', () => {
+    fs.readFileSync.mockImplementation(() => {
+      throw new Error('File not found')
+    })
+
+    const lang = new Lang()
+    const key = 'non.existent.key'
+
+    expect(lang.get(key)).toBe(key)
+
+    // Verify that save was called
+    expect(fs.promises.writeFile).toHaveBeenCalled()
+  })
+
+  it('should handle multiple placeholders correctly', () => {
+    const mockStrings = {format: '%s %s %s'}
+    fs.readFileSync.mockReturnValue(JSON.stringify(mockStrings))
+    const lang = new Lang()
+    expect(lang.get('format', 'a', 'b', 'c')).toBe('a b c')
+  })
+
+  describe('File saving behavior', () => {
+    it('should not modify existing file when all keys exist', () => {
+      const existingStrings = {
+        'existing.key1': 'Value 1',
+        'existing.key2': 'Value 2',
+        'existing.key3': 'Value 3'
+      }
+
+      fs.readFileSync.mockReturnValue(JSON.stringify(existingStrings))
+
+      const lang = new Lang()
+
+      // Access existing keys multiple times
+      lang.get('existing.key1')
+      lang.get('existing.key2')
+      lang.get('existing.key3')
+      lang.get('existing.key1') // Access again
+
+      // Verify writeFile was only called once during initialization (if file didn't exist)
+      // Since we're mocking readFileSync to return data, it should not call writeFile
+      expect(fs.promises.writeFile).not.toHaveBeenCalled()
+    })
+
+    it('should save file with correct format when new key is added', () => {
+      const existingStrings = {'existing.key': 'Existing Value'}
+      fs.readFileSync.mockReturnValue(JSON.stringify(existingStrings))
+
+      const lang = new Lang()
+
+      // Add a new key
+      const result = lang.get('new.key')
+
+      expect(result).toBe('new.key')
+      expect(fs.promises.writeFile).toHaveBeenCalledTimes(1)
+
+      // Verify the file is saved with correct format and content
+      const [filePath, content, encoding] = fs.promises.writeFile.mock.calls[0]
+
+      expect(encoding).toBe('utf8')
+      expect(filePath).toMatch(/locale\/.*\.json$/)
+
+      const savedData = JSON.parse(content)
+      expect(savedData).toEqual({
+        'existing.key': 'Existing Value',
+        'new.key': 'new.key'
+      })
+
+      // Verify JSON formatting (4 spaces indentation)
+      expect(content).toMatch(/{\n    /)
+    })
+
+    it('should preserve existing data when adding new keys', () => {
+      const existingStrings = {
+        key1: 'Value 1',
+        key2: 'Value 2'
+      }
+
+      fs.readFileSync.mockReturnValue(JSON.stringify(existingStrings))
+
+      const lang = new Lang()
+
+      // Add multiple new keys
+      lang.get('new.key1')
+      lang.get('new.key2')
+
+      expect(fs.promises.writeFile).toHaveBeenCalledTimes(2)
+
+      // Check the final saved state
+      const lastCall = fs.promises.writeFile.mock.calls[fs.promises.writeFile.mock.calls.length - 1]
+      const savedContent = JSON.parse(lastCall[1])
+
+      expect(savedContent).toEqual({
+        key1: 'Value 1',
+        key2: 'Value 2',
+        'new.key1': 'new.key1',
+        'new.key2': 'new.key2'
+      })
+    })
+
+    it('should handle file save errors gracefully', () => {
+      fs.readFileSync.mockImplementation(() => {
+        throw new Error('File not found')
+      })
+
+      // Mock writeFile to throw synchronously (simulating immediate error)
+      fs.promises.writeFile.mockImplementation(() => {
+        throw new Error('Write permission denied')
+      })
+
+      const lang = new Lang()
+
+      // This should not throw an error even if save fails
+      expect(() => lang.get('test.key')).not.toThrow()
+
+      // Verify error was logged
+      expect(console.error).toHaveBeenCalledWith('Error saving language file:', expect.any(Error))
+    })
+
+    it('should create file with empty object when file does not exist', () => {
+      fs.readFileSync.mockImplementation(() => {
+        throw new Error('ENOENT: no such file or directory')
+      })
+
+      const lang = new Lang()
+
+      // Should save empty object initially
+      expect(fs.promises.writeFile).toHaveBeenCalledTimes(1)
+
+      const [filePath, content, encoding] = fs.promises.writeFile.mock.calls[0]
+      expect(content).toBe('{}')
+      expect(encoding).toBe('utf8')
+    })
+
+    it('should not save duplicate keys', () => {
+      const existingStrings = {'existing.key': 'Existing Value'}
+      fs.readFileSync.mockReturnValue(JSON.stringify(existingStrings))
+
+      const lang = new Lang()
+
+      // Access the same new key multiple times
+      lang.get('new.key')
+      lang.get('new.key')
+      lang.get('new.key')
+
+      // Should only save once when the key is first added
+      expect(fs.promises.writeFile).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('Locale file path validation', () => {
+    it('should use correct locale file path', () => {
+      const mockLocale = 'en-US'
+      const originalIntl = global.Intl
+
+      // Mock Intl to return specific locale
+      global.Intl = {
+        DateTimeFormat: () => ({
+          resolvedOptions: () => ({locale: mockLocale})
+        })
+      }
+
+      fs.readFileSync.mockImplementation(() => {
+        throw new Error('File not found')
+      })
+
+      new Lang()
+
+      expect(fs.promises.writeFile).toHaveBeenCalledWith(expect.stringContaining(`locale/${mockLocale}.json`), expect.any(String), 'utf8')
+
+      // Restore original Intl
+      global.Intl = originalIntl
+    })
+  })
+
+  describe('Mock verification', () => {
+    it('should ensure fs operations are mocked and not writing real files', () => {
+      // Verify that fs.promises.writeFile is a mock function
+      expect(jest.isMockFunction(fs.promises.writeFile)).toBe(true)
+      expect(jest.isMockFunction(fs.readFileSync)).toBe(true)
+
+      // Create a Lang instance that would normally write to file
+      fs.readFileSync.mockImplementation(() => {
+        throw new Error('File not found')
+      })
+
+      const lang = new Lang()
+      lang.get('test.mock.key')
+
+      // Verify mock was called but no real file operation occurred
+      expect(fs.promises.writeFile).toHaveBeenCalled()
+
+      // The mock should have been called with the expected parameters
+      const [filePath, content] = fs.promises.writeFile.mock.calls[0]
+      expect(filePath).toMatch(/locale\/.*\.json$/)
+      expect(content).toBe('{}')
+    })
+  })
+})

package/test/core/Process.test.js

@@ -0,0 +1,156 @@
+const Process = require('../../core/Process')
+const findProcess = require('find-process')
+
+// Note: jest.mock is automatically hoisted.
+// Since Process.js uses `require('find-process').default`, jest will automatically
+// create a mock with a `default` property that is a jest.fn().
+jest.mock('find-process')
+const processKillSpy = jest.spyOn(process, 'kill').mockImplementation(() => {})
+
+global.Candy = {
+  core: () => ({
+    config: {}
+  })
+}
+
+describe('Process', () => {
+  let proc
+
+  beforeEach(() => {
+    proc = new Process()
+    // The mock function is on the .default property of the module mock
+    findProcess.default.mockClear()
+    processKillSpy.mockClear()
+    global.Candy.core = () => ({config: {}})
+  })
+
+  it('should be defined', () => {
+    expect(proc).toBeDefined()
+  })
+
+  describe('stop(pid)', () => {
+    it('should kill a "node" process with the given pid', async () => {
+      const pid = 123
+      findProcess.default.mockResolvedValue([{pid: pid, name: 'node'}])
+
+      await proc.stop(pid)
+
+      expect(findProcess.default).toHaveBeenCalledWith('pid', pid)
+      expect(processKillSpy).toHaveBeenCalledWith(pid, 'SIGTERM')
+    })
+
+    it('should not kill a process if it is not a "node" process', async () => {
+      const pid = 456
+      findProcess.default.mockResolvedValue([{pid: pid, name: 'other-process'}])
+
+      await proc.stop(pid)
+
+      expect(findProcess.default).toHaveBeenCalledWith('pid', pid)
+      expect(processKillSpy).not.toHaveBeenCalled()
+    })
+
+    it('should not try to kill a process if no process is found', async () => {
+      const pid = 789
+      findProcess.default.mockResolvedValue([])
+
+      await proc.stop(pid)
+
+      expect(findProcess.default).toHaveBeenCalledWith('pid', pid)
+      expect(processKillSpy).not.toHaveBeenCalled()
+    })
+
+    it('should resolve even if find-process throws an error', async () => {
+      const pid = 101
+      findProcess.default.mockRejectedValue(new Error('find-process failed'))
+
+      await expect(proc.stop(pid)).resolves.toBeUndefined()
+      expect(processKillSpy).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('stopAll()', () => {
+    let stopSpy
+
+    beforeEach(() => {
+      // It's safer to store the spy in a variable and restore it from there.
+      stopSpy = jest.spyOn(proc, 'stop').mockResolvedValue(undefined)
+    })
+
+    afterEach(() => {
+      stopSpy.mockRestore()
+    })
+
+    it('should call stop for all configured pids', async () => {
+      global.Candy.core = () => ({
+        config: {
+          server: {
+            watchdog: 100,
+            pid: 200
+          },
+          websites: {
+            'example.com': {pid: 301},
+            'test.com': {pid: 302}
+          },
+          services: [
+            {name: 'service1', pid: 401},
+            {name: 'service2', pid: 402}
+          ]
+        }
+      })
+
+      await proc.stopAll()
+
+      expect(stopSpy).toHaveBeenCalledTimes(6)
+      expect(stopSpy).toHaveBeenCalledWith(100)
+      expect(stopSpy).toHaveBeenCalledWith(200)
+      expect(stopSpy).toHaveBeenCalledWith(301)
+      expect(stopSpy).toHaveBeenCalledWith(302)
+      expect(stopSpy).toHaveBeenCalledWith(401)
+      expect(stopSpy).toHaveBeenCalledWith(402)
+    })
+
+    it('should handle partial configurations gracefully', async () => {
+      global.Candy.core = () => ({
+        config: {
+          server: {
+            pid: 200
+          },
+          websites: {
+            'example.com': {pid: 301}
+          },
+          services: []
+        }
+      })
+
+      await proc.stopAll()
+
+      expect(stopSpy).toHaveBeenCalledTimes(2)
+      expect(stopSpy).toHaveBeenCalledWith(200)
+      expect(stopSpy).toHaveBeenCalledWith(301)
+    })
+
+    it('should not call stop if no pids are configured', async () => {
+      global.Candy.core = () => ({
+        config: {
+          server: {},
+          websites: {},
+          services: []
+        }
+      })
+
+      await proc.stopAll()
+
+      expect(stopSpy).not.toHaveBeenCalled()
+    })
+
+    it('should handle missing top-level config keys', async () => {
+      global.Candy.core = () => ({
+        config: {}
+      })
+
+      await proc.stopAll()
+
+      expect(stopSpy).not.toHaveBeenCalled()
+    })
+  })
+})

package/test/framework/Route.test.js

@@ -0,0 +1,239 @@
+const Route = require('../../framework/src/Route')
+
+describe('Route', () => {
+  let route
+
+  beforeEach(() => {
+    route = new Route()
+    global.Candy = {
+      Route: {},
+      Config: {}
+    }
+    global.__dir = process.cwd()
+  })
+
+  afterEach(() => {
+    delete global.Candy
+    delete global.__dir
+  })
+
+  describe('check - token request', () => {
+    it('should handle token request with undefined route gracefully', async () => {
+      const mockCandy = {
+        Request: {
+          url: '/',
+          method: 'get',
+          route: 'undefined_route',
+          ssl: false,
+          host: 'example.com',
+          header: jest.fn(key => {
+            const headers = {
+              'X-Candy': 'token',
+              Referer: 'http://example.com/',
+              'X-Candy-Client': 'test-client'
+            }
+            return headers[key]
+          }),
+          cookie: jest.fn(key => {
+            if (key === 'candy_client') return 'test-client'
+            return null
+          })
+        },
+        token: jest.fn(() => 'test-token')
+      }
+
+      route.routes = {}
+
+      const result = await route.check(mockCandy)
+
+      expect(result).toBeDefined()
+      expect(result.token).toBe('test-token')
+      expect(result.page).toBeUndefined()
+      expect(mockCandy.Request.header).toHaveBeenCalledWith('Access-Control-Allow-Origin', 'http://example.com')
+      expect(mockCandy.Request.header).toHaveBeenCalledWith('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0')
+    })
+
+    it('should handle token request with route but no page defined', async () => {
+      const mockCandy = {
+        Request: {
+          url: '/',
+          method: 'get',
+          route: 'test_route',
+          ssl: true,
+          host: 'example.com',
+          header: jest.fn(key => {
+            const headers = {
+              'X-Candy': 'token',
+              Referer: 'https://example.com/',
+              'X-Candy-Client': 'test-client'
+            }
+            return headers[key]
+          }),
+          cookie: jest.fn(key => {
+            if (key === 'candy_client') return 'test-client'
+            return null
+          })
+        },
+        token: jest.fn(() => 'test-token-2')
+      }
+
+      route.routes = {
+        test_route: {}
+      }
+
+      const result = await route.check(mockCandy)
+
+      expect(result).toBeDefined()
+      expect(result.token).toBe('test-token-2')
+      expect(result.page).toBeUndefined()
+    })
+
+    it('should handle token request with route and page but no url match', async () => {
+      const mockCandy = {
+        Request: {
+          url: '/',
+          method: 'get',
+          route: 'test_route',
+          ssl: false,
+          host: 'example.com',
+          header: jest.fn(key => {
+            const headers = {
+              'X-Candy': 'token',
+              Referer: 'http://example.com/',
+              'X-Candy-Client': 'test-client'
+            }
+            return headers[key]
+          }),
+          cookie: jest.fn(key => {
+            if (key === 'candy_client') return 'test-client'
+            return null
+          })
+        },
+        token: jest.fn(() => 'test-token-3')
+      }
+
+      route.routes = {
+        test_route: {
+          page: {
+            '/other': {file: 'other.js'}
+          }
+        }
+      }
+
+      const result = await route.check(mockCandy)
+
+      expect(result).toBeDefined()
+      expect(result.token).toBe('test-token-3')
+      expect(result.page).toBeUndefined()
+    })
+
+    it('should not return token when referer does not match', async () => {
+      const mockCandy = {
+        Request: {
+          url: '/',
+          method: 'get',
+          route: 'test_route',
+          ssl: false,
+          host: 'example.com',
+          header: jest.fn(key => {
+            const headers = {
+              'X-Candy': 'token',
+              Referer: 'http://malicious.com/',
+              'X-Candy-Client': 'test-client'
+            }
+            return headers[key]
+          }),
+          cookie: jest.fn(key => {
+            if (key === 'candy_client') return 'test-client'
+            return null
+          }),
+          abort: jest.fn()
+        },
+        Config: {},
+        token: jest.fn(() => 'test-token')
+      }
+
+      route.routes = {
+        test_route: {
+          page: {}
+        }
+      }
+
+      await route.check(mockCandy)
+
+      expect(mockCandy.Request.header).not.toHaveBeenCalledWith('Access-Control-Allow-Origin', expect.any(String))
+    })
+
+    it('should not return token when client cookie does not match', async () => {
+      const mockCandy = {
+        Request: {
+          url: '/',
+          method: 'get',
+          route: 'test_route',
+          ssl: false,
+          host: 'example.com',
+          header: jest.fn(key => {
+            const headers = {
+              'X-Candy': 'token',
+              Referer: 'http://example.com/',
+              'X-Candy-Client': 'test-client'
+            }
+            return headers[key]
+          }),
+          cookie: jest.fn(key => {
+            if (key === 'candy_client') return 'different-client'
+            return null
+          }),
+          abort: jest.fn()
+        },
+        Config: {},
+        token: jest.fn(() => 'test-token')
+      }
+
+      route.routes = {
+        test_route: {
+          page: {}
+        }
+      }
+
+      await route.check(mockCandy)
+
+      expect(mockCandy.Request.header).not.toHaveBeenCalledWith('Access-Control-Allow-Origin', expect.any(String))
+    })
+  })
+
+  describe('set', () => {
+    it('should register a route with function handler', () => {
+      global.Candy.Route.buff = 'test_route'
+      const handler = jest.fn()
+
+      route.set('get', '/test', handler)
+
+      expect(route.routes.test_route).toBeDefined()
+      expect(route.routes.test_route.get).toBeDefined()
+      expect(route.routes.test_route.get['/test']).toBeDefined()
+      expect(route.routes.test_route.get['/test'].cache).toBe(handler)
+      expect(route.routes.test_route.get['/test'].type).toBe('function')
+    })
+
+    it('should handle array of methods', () => {
+      global.Candy.Route.buff = 'test_route'
+      const handler = jest.fn()
+
+      route.set(['get', 'post'], '/test', handler)
+
+      expect(route.routes.test_route.get['/test']).toBeDefined()
+      expect(route.routes.test_route.post['/test']).toBeDefined()
+    })
+
+    it('should strip trailing slash from url', () => {
+      global.Candy.Route.buff = 'test_route'
+      const handler = jest.fn()
+
+      route.set('get', '/test/', handler)
+
+      expect(route.routes.test_route.get['/test']).toBeDefined()
+      expect(route.routes.test_route.get['/test/']).toBeUndefined()
+    })
+  })
+})