odac 1.1.0 → 1.2.0

package/test/core/Lang.test.js

@@ -1,250 +0,0 @@
-// 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 'Odac' for the 'Odac' key", () => {
-    const lang = new Lang()
-    expect(lang.get('Odac')).toBe('Odac')
-  })
-
-  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/Odac.test.js

@@ -1,234 +0,0 @@
-// Mock fs before requiring any modules that might use it
-jest.mock('fs', () => ({
-  promises: {
-    writeFile: jest.fn().mockResolvedValue()
-  },
-  readFileSync: jest.fn().mockReturnValue('{"Status": "Status"}'),
-  writeFileSync: jest.fn(),
-  existsSync: jest.fn().mockReturnValue(true),
-  mkdirSync: jest.fn()
-}))
-
-// Mock process.mainModule to avoid Config initialization issues
-process.mainModule = {path: '/mock/node_modules/odac/bin'}
-
-// Import the module to ensure global setup
-require('../../core/Odac.js')
-
-describe('Odac', () => {
-  describe('global setup', () => {
-    it('should have global Odac instance', () => {
-      expect(global.Odac).toBeDefined()
-      expect(global.Odac._registry).toBeInstanceOf(Map)
-      expect(global.Odac._singletons).toBeInstanceOf(Map)
-    })
-
-    it('should have global __ function', () => {
-      expect(global.__).toBeDefined()
-      expect(typeof global.__).toBe('function')
-    })
-
-    it('should call Lang.get through global __ function', () => {
-      const result = global.__('Status')
-      expect(result).toBe('Status')
-    })
-
-    it('should not recreate global if already exists', () => {
-      const existingOdac = global.Odac
-
-      // Clear module cache and re-require
-      delete require.cache[require.resolve('../../core/Odac.js')]
-      require('../../core/Odac.js')
-
-      expect(global.Odac).toBe(existingOdac)
-    })
-  })
-
-  describe('Odac instance methods', () => {
-    it('should have core method', () => {
-      expect(typeof global.Odac.core).toBe('function')
-    })
-
-    it('should have cli method', () => {
-      expect(typeof global.Odac.cli).toBe('function')
-    })
-
-    it('should have server method', () => {
-      expect(typeof global.Odac.server).toBe('function')
-    })
-
-    it('should have watchdog method', () => {
-      expect(typeof global.Odac.watchdog).toBe('function')
-    })
-  })
-
-  describe('module loading functionality', () => {
-    it('should load core modules', () => {
-      const lang = global.Odac.core('Lang')
-      expect(lang).toBeDefined()
-      expect(global.Odac._registry.has('core:Lang')).toBe(true)
-    })
-
-    it('should return singleton instances by default', () => {
-      const lang1 = global.Odac.core('Lang')
-      const lang2 = global.Odac.core('Lang')
-      expect(lang1).toBe(lang2)
-    })
-
-    it('should cache singleton instances', () => {
-      const lang1 = global.Odac.core('Lang')
-      const lang2 = global.Odac.core('Lang')
-
-      expect(lang1).toBe(lang2)
-      expect(global.Odac._singletons.has('core:Lang')).toBe(true)
-    })
-
-    it('should return new instances when singleton is false', () => {
-      // Clear any existing Lang registration first to test non-singleton behavior
-      global.Odac._registry.delete('core:Lang')
-      global.Odac._singletons.delete('core:Lang')
-
-      const lang1 = global.Odac.core('Lang', false)
-      const lang2 = global.Odac.core('Lang', false)
-      expect(lang1).not.toBe(lang2)
-    })
-
-    it('should call init method if module has one', () => {
-      // Test with Config module which has init method
-      const config = global.Odac.core('Config')
-      expect(config).toBeDefined()
-    })
-
-    it('should retrieve Config module as singleton', () => {
-      // Get Config instance twice
-      const config1 = global.Odac.core('Config')
-      const config2 = global.Odac.core('Config')
-
-      // Should be the same instance (singleton behavior)
-      expect(config1).toBe(config2)
-      expect(config1).toBeInstanceOf(Object)
-
-      // Should be registered in singleton cache
-      expect(global.Odac._singletons.has('core:Config')).toBe(true)
-      expect(global.Odac._singletons.get('core:Config')).toBe(config1)
-
-      // Should have Config class properties
-      expect(config1.config).toBeDefined()
-      expect(typeof config1.force).toBe('function')
-      expect(typeof config1.reload).toBe('function')
-    })
-
-    it('should handle modules without init method', () => {
-      // Test with Process module which doesn't have init method
-      const process = global.Odac.core('Process')
-      expect(process).toBeDefined()
-    })
-  })
-
-  describe('different module types', () => {
-    it('should load cli modules with correct path prefix', () => {
-      // This will fail but we can test the path construction
-      expect(() => {
-        global.Odac.cli('NonExistentCli')
-      }).toThrow()
-    })
-
-    it('should load server modules with correct path prefix', () => {
-      // This will fail but we can test the path construction
-      expect(() => {
-        global.Odac.server('NonExistentServer')
-      }).toThrow()
-    })
-
-    it('should load watchdog modules with correct path prefix', () => {
-      // This will fail but we can test the path construction
-      expect(() => {
-        global.Odac.watchdog('NonExistentWatchdog')
-      }).toThrow()
-    })
-  })
-
-  describe('registry functionality', () => {
-    it('should maintain separate registries for different module types', () => {
-      // Load a core module
-      global.Odac.core('Lang')
-
-      expect(global.Odac._registry.has('core:Lang')).toBe(true)
-      expect(global.Odac._registry.size).toBeGreaterThan(0)
-    })
-
-    it('should store registry entries with correct structure', () => {
-      global.Odac.core('Lang')
-
-      const entry = global.Odac._registry.get('core:Lang')
-      expect(entry).toBeDefined()
-      expect(entry).toHaveProperty('value')
-      expect(entry).toHaveProperty('singleton')
-    })
-
-    it('should handle non-singleton registry entries', () => {
-      // Clear existing registration
-      global.Odac._registry.delete('core:Lang')
-      global.Odac._singletons.delete('core:Lang')
-
-      global.Odac.core('Lang', false)
-
-      const entry = global.Odac._registry.get('core:Lang')
-      expect(entry.singleton).toBe(false)
-    })
-  })
-
-  describe('instantiation behavior', () => {
-    it('should instantiate function modules', () => {
-      const lang = global.Odac.core('Lang')
-      expect(lang).toBeInstanceOf(Object)
-    })
-
-    it('should handle non-function modules', () => {
-      const config = global.Odac.core('Config')
-      expect(config).toBeDefined()
-    })
-  })
-
-  describe('error handling', () => {
-    it('should handle module loading errors gracefully', () => {
-      expect(() => {
-        global.Odac.core('NonExistentModule')
-      }).toThrow()
-    })
-
-    it('should throw specific error for non-existent registry entries', () => {
-      // Create a new Odac instance to test private methods
-      const OdacClass = global.Odac.constructor
-      const testInstance = new OdacClass()
-
-      expect(() => {
-        // This should trigger the resolve error
-        testInstance.core('NonExistentModule')
-      }).toThrow()
-    })
-  })
-
-  describe('module caching', () => {
-    beforeEach(() => {
-      // Clear any existing registrations for clean tests
-      global.Odac._registry.clear()
-      global.Odac._singletons.clear()
-    })
-
-    it('should not re-register already registered modules', () => {
-      // Load Lang module twice
-      const lang1 = global.Odac.core('Lang')
-      const lang2 = global.Odac.core('Lang')
-
-      expect(lang1).toBe(lang2)
-    })
-
-    it('should maintain singleton cache correctly', () => {
-      const lang = global.Odac.core('Lang')
-
-      expect(global.Odac._singletons.has('core:Lang')).toBe(true)
-      expect(global.Odac._singletons.get('core:Lang')).toBe(lang)
-    })
-  })
-})

package/test/core/Process.test.js

@@ -1,156 +0,0 @@
-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.Odac = {
-  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.Odac.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.Odac.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.Odac.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.Odac.core = () => ({
-        config: {
-          server: {},
-          websites: {},
-          services: []
-        }
-      })
-
-      await proc.stopAll()
-
-      expect(stopSpy).not.toHaveBeenCalled()
-    })
-
-    it('should handle missing top-level config keys', async () => {
-      global.Odac.core = () => ({
-        config: {}
-      })
-
-      await proc.stopAll()
-
-      expect(stopSpy).not.toHaveBeenCalled()
-    })
-  })
-})