odac 1.4.1 → 1.4.3

package/test/WebSocket/Server/broadcast.test.js

@@ -0,0 +1,33 @@
+const {WebSocketServer} = require('../../../src/WebSocket.js')
+
+describe('WebSocketServer Broadcast', () => {
+  let server
+
+  beforeEach(() => {
+    server = new WebSocketServer()
+  })
+
+  it('should send message to all connected clients', () => {
+    const client1 = {id: 'c1', send: jest.fn()}
+    const client2 = {id: 'c2', send: jest.fn()}
+
+    server.clients.set('c1', client1)
+    server.clients.set('c2', client2)
+
+    server.broadcast('hello')
+    expect(client1.send).toHaveBeenCalledWith('hello')
+    expect(client2.send).toHaveBeenCalledWith('hello')
+  })
+
+  it('should exclude specified client from broadcast', () => {
+    const client1 = {id: 'c1', send: jest.fn()}
+    const client2 = {id: 'c2', send: jest.fn()}
+
+    server.clients.set('c1', client1)
+    server.clients.set('c2', client2)
+
+    server.broadcast('hello', 'c1')
+    expect(client1.send).not.toHaveBeenCalled()
+    expect(client2.send).toHaveBeenCalledWith('hello')
+  })
+})

package/test/WebSocket/Server/route.test.js

@@ -0,0 +1,37 @@
+const {WebSocketServer} = require('../../../src/WebSocket.js')
+
+describe('WebSocketServer Route Management', () => {
+  let server
+
+  beforeEach(() => {
+    server = new WebSocketServer()
+  })
+
+  it('should register a route', () => {
+    const handler = jest.fn()
+    server.route('/chat', handler)
+    expect(server.getRoute('/chat').handler).toBe(handler)
+  })
+
+  it('should return null for unregistered route', () => {
+    expect(server.getRoute('/unknown')).toBeNull()
+  })
+
+  it('should match parameterized routes', () => {
+    const handler = jest.fn()
+    server.route('/room/{id}', handler)
+
+    const result = server.getRoute('/room/123')
+    expect(result).toBeDefined()
+    expect(result.handler).toBe(handler)
+    expect(result.params).toEqual({id: '123'})
+  })
+
+  it('should match multiple parameters', () => {
+    const handler = jest.fn()
+    server.route('/chat/{room}/user/{userId}', handler)
+
+    const result = server.getRoute('/chat/general/user/42')
+    expect(result.params).toEqual({room: 'general', userId: '42'})
+  })
+})

package/test/Client.test.js

@@ -1,197 +0,0 @@
-describe('Client (odac.js)', () => {
-  let mockXhr
-
-  beforeEach(() => {
-    jest.resetModules()
-
-    mockXhr = {
-      open: jest.fn(),
-      setRequestHeader: jest.fn(),
-      send: jest.fn(),
-      getResponseHeader: jest.fn(),
-      status: 200,
-      responseText: '{}',
-      response: '{}',
-      onload: null,
-      onerror: null
-    }
-
-    const mockDocument = {
-      getElementById: jest.fn(),
-      querySelectorAll: jest.fn(() => []),
-      querySelector: jest.fn(),
-      addEventListener: jest.fn(),
-      removeEventListener: jest.fn(),
-      dispatchEvent: jest.fn(),
-      documentElement: {dataset: {}},
-      cookie: '',
-      readyState: 'complete',
-      createElement: jest.fn(() => ({
-        setAttribute: jest.fn(),
-        style: {},
-        appendChild: jest.fn(),
-        parentNode: {insertBefore: jest.fn()}
-      }))
-    }
-
-    const mockWindow = {
-      location: {
-        protocol: 'http:',
-        host: 'localhost',
-        href: 'http://localhost/'
-      },
-      history: {
-        pushState: jest.fn()
-      },
-      scrollTo: jest.fn(),
-      addEventListener: jest.fn(),
-      XMLHttpRequest: jest.fn(() => mockXhr),
-      localStorage: {
-        getItem: jest.fn(),
-        setItem: jest.fn(),
-        removeItem: jest.fn()
-      },
-      CustomEvent: jest.fn((name, detail) => ({name, detail})),
-      setTimeout: jest.fn(),
-      clearTimeout: jest.fn(),
-      requestAnimationFrame: jest.fn(cb => cb(Date.now())),
-      WebSocket: jest.fn(() => ({
-        send: jest.fn(),
-        close: jest.fn(),
-        readyState: 1 // OPEN
-      })),
-      FormData: jest.fn()
-    }
-
-    mockWindow.window = mockWindow
-    mockWindow.document = mockDocument
-    mockWindow.WebSocket.OPEN = 1
-    mockWindow.WebSocket.CLOSED = 3
-
-    global.window = mockWindow
-    global.document = mockDocument
-    global.location = mockWindow.location
-    global.XMLHttpRequest = mockWindow.XMLHttpRequest
-    global.localStorage = mockWindow.localStorage
-    global.CustomEvent = mockWindow.CustomEvent
-    global.WebSocket = mockWindow.WebSocket
-    global.setTimeout = mockWindow.setTimeout
-    global.clearTimeout = mockWindow.clearTimeout
-    global.requestAnimationFrame = mockWindow.requestAnimationFrame
-    global.FormData = mockWindow.FormData
-
-    delete require.cache[require.resolve('../client/odac.js')]
-    require('../client/odac.js')
-  })
-
-  afterEach(() => {
-    delete global.window
-    delete global.document
-    delete global.location
-    delete global.XMLHttpRequest
-    delete global.localStorage
-    delete global.CustomEvent
-    delete global.WebSocket
-    delete global.setTimeout
-    delete global.clearTimeout
-    delete global.requestAnimationFrame
-    delete global.FormData
-    delete global.Odac
-  })
-
-  test('Odac should be initialized on window', () => {
-    expect(window.Odac).toBeDefined()
-  })
-
-  describe('data()', () => {
-    test('should retrieve data from odac-data script tag', () => {
-      const mockData = {user: 'emre'}
-      document.getElementById.mockReturnValue({
-        textContent: JSON.stringify(mockData)
-      })
-
-      const result = window.Odac.data()
-      expect(result).toEqual(mockData)
-      expect(document.getElementById).toHaveBeenCalledWith('odac-data')
-    })
-
-    test('should return specific key from data', () => {
-      const mockData = {user: 'emre', role: 'admin'}
-      document.getElementById.mockReturnValue({
-        textContent: JSON.stringify(mockData)
-      })
-
-      expect(window.Odac.data('user')).toBe('emre')
-      expect(window.Odac.data('role')).toBe('admin')
-    })
-  })
-
-  describe('storage()', () => {
-    test('should get item from localStorage', () => {
-      localStorage.getItem.mockReturnValue('val')
-      expect(window.Odac.storage('key')).toBe('val')
-      expect(localStorage.getItem).toHaveBeenCalledWith('key')
-    })
-
-    test('should set item in localStorage', () => {
-      window.Odac.storage('key', 'val')
-      expect(localStorage.setItem).toHaveBeenCalledWith('key', 'val')
-    })
-  })
-
-  describe('token()', () => {
-    test('should fetch token via sync XHR if hash is empty', () => {
-      mockXhr.response = JSON.stringify({token: 'new-token'})
-      document.cookie = 'odac_client=abc'
-
-      const token = window.Odac.token()
-
-      expect(window.XMLHttpRequest).toHaveBeenCalled()
-      expect(token).toBe('new-token')
-    })
-  })
-
-  describe('get()', () => {
-    test('should automatically parse JSON if Content-Type is application/json', () => {
-      const mockCallback = jest.fn()
-      const mockData = {success: true}
-
-      mockXhr.open.mockClear()
-      mockXhr.send.mockClear()
-
-      // Mock token() to avoid side effects and XHR calls
-      jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
-
-      // Setup response for the get request
-      mockXhr.responseText = JSON.stringify(mockData)
-      mockXhr.status = 200
-      mockXhr.statusText = 'OK'
-      mockXhr.getResponseHeader.mockImplementation(header => {
-        if (header === 'Content-Type') return 'application/json'
-        return null
-      })
-
-      window.Odac.get('/api/test', mockCallback)
-
-      // Trigger the completion of the get request
-      if (mockXhr.onload) mockXhr.onload()
-
-      expect(mockCallback).toHaveBeenCalledWith(mockData, expect.anything(), expect.anything())
-    })
-  })
-
-  describe('OdacWebSocket', () => {
-    test('should connect to WebSocket and handle events', () => {
-      const ws = window.Odac.ws('/test-ws', {token: false})
-      expect(window.WebSocket).toHaveBeenCalled()
-
-      const openHandler = jest.fn()
-      ws.on('open', openHandler)
-
-      const socketInstance = WebSocket.mock.results[0].value
-      socketInstance.onopen()
-
-      expect(openHandler).toHaveBeenCalled()
-    })
-  })
-})

package/test/Config.test.js

@@ -1,119 +0,0 @@
-const fs = require('fs')
-const os = require('os')
-
-const Config = require('../src/Config')
-
-jest.mock('fs')
-jest.mock('os')
-
-describe('Config', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-    // Reset global.__dir which is used in Config.js
-    global.__dir = '/mock/project'
-
-    // Reset Config properties to defaults before each test
-    Config.system = undefined
-    Config.encrypt.key = 'odac'
-  })
-
-  describe('init', () => {
-    it('should load system config from home directory', () => {
-      os.homedir.mockReturnValue('/home/user')
-      fs.readFileSync.mockImplementation(path => {
-        if (path === '/home/user/.odac/config.json') {
-          return JSON.stringify({deviceId: '123'})
-        }
-        return '{}'
-      })
-      fs.existsSync.mockReturnValue(false)
-
-      Config.init()
-
-      expect(Config.system).toEqual({deviceId: '123'})
-      expect(fs.readFileSync).toHaveBeenCalledWith('/home/user/.odac/config.json')
-    })
-
-    it('should load project config and merge it', () => {
-      os.homedir.mockReturnValue('/home/user')
-      fs.existsSync.mockImplementation(path => {
-        if (path === '/mock/project/odac.json') return true
-        return false
-      })
-      fs.readFileSync.mockImplementation(path => {
-        if (path === '/mock/project/odac.json') {
-          return JSON.stringify({encrypt: {key: 'secret'}})
-        }
-        return '{}'
-      })
-
-      Config.init()
-
-      // The key gets hashed in init(), so it won't be 'secret' anymore
-      expect(Config.encrypt.key).not.toBe('secret')
-      expect(Config.encrypt.key).toBeInstanceOf(Buffer)
-    })
-
-    it('should interpolate variables in config', () => {
-      process.env.TEST_VAR = 'env_value'
-      os.homedir.mockReturnValue('/home/user')
-      fs.existsSync.mockReturnValue(true)
-      fs.readFileSync.mockReturnValue(
-        JSON.stringify({
-          custom: 'value-${TEST_VAR}'
-        })
-      )
-
-      Config.init()
-
-      expect(Config.custom).toBe('value-env_value')
-    })
-  })
-
-  describe('_interpolate', () => {
-    it('should replace ${VAR} with environment variables', () => {
-      process.env.FOO = 'bar'
-      const result = Config._interpolate('hello-${FOO}')
-      expect(result).toBe('hello-bar')
-    })
-
-    it('should replace ${VAR} when variable name includes hyphen', () => {
-      process.env['MY-VAR'] = 'hyphen-value'
-      const result = Config._interpolate('hello-${MY-VAR}')
-      expect(result).toBe('hello-hyphen-value')
-      delete process.env['MY-VAR']
-    })
-
-    it('should replace ${odac} with client path', () => {
-      // __dirname in Config.js is /.../src, so it replaces /src with /client
-      const result = Config._interpolate('path-${odac}')
-      expect(result).toMatch(/\/client$/)
-    })
-
-    it('should handle nested objects and arrays', () => {
-      process.env.VAR = 'x'
-      const obj = {
-        a: ['${VAR}'],
-        b: {c: '${VAR}'}
-      }
-      const result = Config._interpolate(obj)
-      expect(result).toEqual({
-        a: ['x'],
-        b: {c: 'x'}
-      })
-    })
-  })
-
-  describe('_deepMerge', () => {
-    it('should merge objects deeply', () => {
-      const target = {a: {b: 1}, c: 2}
-      const source = {a: {d: 3}, e: 4}
-      Config._deepMerge(target, source)
-      expect(target).toEqual({
-        a: {b: 1, d: 3},
-        c: 2,
-        e: 4
-      })
-    })
-  })
-})

package/test/Database/ConnectionFactory.test.js

@@ -1,80 +0,0 @@
-const mockKnex = jest.fn()
-
-jest.mock(
-  'knex',
-  () =>
-    (...args) =>
-      mockKnex(...args)
-)
-
-const {buildConnections, buildConnectionConfig, resolveClient} = require('../../src/Database/ConnectionFactory')
-
-describe('Database ConnectionFactory', () => {
-  beforeEach(() => {
-    mockKnex.mockReset()
-    mockKnex.mockImplementation(options => ({
-      options,
-      raw: jest.fn()
-    }))
-  })
-
-  it('resolveClient should map known database aliases', () => {
-    expect(resolveClient('postgres')).toBe('pg')
-    expect(resolveClient('postgresql')).toBe('pg')
-    expect(resolveClient('pg')).toBe('pg')
-    expect(resolveClient('sqlite')).toBe('sqlite3')
-    expect(resolveClient('sqlite3')).toBe('sqlite3')
-    expect(resolveClient('mysql')).toBe('mysql2')
-  })
-
-  it('buildConnectionConfig should create sqlite filename config', () => {
-    const config = buildConnectionConfig({database: 'db.sqlite3'}, 'sqlite3')
-    expect(config).toEqual({filename: 'db.sqlite3'})
-  })
-
-  it('buildConnectionConfig should create host based config for non-sqlite', () => {
-    const config = buildConnectionConfig(
-      {
-        user: 'root',
-        password: 'secret',
-        database: 'app',
-        port: 3306
-      },
-      'mysql2'
-    )
-
-    expect(config).toEqual({
-      host: '127.0.0.1',
-      user: 'root',
-      password: 'secret',
-      database: 'app',
-      port: 3306
-    })
-  })
-
-  it('buildConnections should support single database config', () => {
-    const connections = buildConnections({
-      type: 'mysql',
-      user: 'root',
-      database: 'app'
-    })
-
-    expect(Object.keys(connections)).toEqual(['default'])
-    expect(mockKnex).toHaveBeenCalledTimes(1)
-    expect(mockKnex.mock.calls[0][0]).toMatchObject({
-      client: 'mysql2',
-      pool: {min: 0, max: 10},
-      useNullAsDefault: true
-    })
-  })
-
-  it('buildConnections should support multi database config', () => {
-    const connections = buildConnections({
-      analytics: {type: 'postgres', user: 'u', database: 'a'},
-      default: {type: 'sqlite', filename: './dev.sqlite3'}
-    })
-
-    expect(Object.keys(connections).sort()).toEqual(['analytics', 'default'])
-    expect(mockKnex).toHaveBeenCalledTimes(2)
-  })
-})

package/test/Lang.test.js

@@ -1,92 +0,0 @@
-const fs = require('fs')
-const Lang = require('../src/Lang')
-
-jest.mock('fs')
-
-describe('Lang', () => {
-  let mockOdac
-  let lang
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-    global.__dir = '/mock/project'
-
-    mockOdac = {
-      Config: {lang: {default: 'en'}},
-      Var: jest.fn(val => ({
-        is: jest.fn(type => type === 'alpha' && /^[a-zA-Z]+$/.test(val))
-      })),
-      Request: {
-        header: jest.fn()
-      }
-    }
-
-    // Default fs mock behaviors
-    fs.existsSync.mockReturnValue(false)
-    fs.mkdirSync.mockImplementation(() => {})
-    fs.writeFileSync.mockImplementation(() => {})
-    fs.readFileSync.mockImplementation(() => {
-      throw new Error('ENOENT')
-    })
-
-    lang = new Lang(mockOdac)
-  })
-
-  describe('constructor and set', () => {
-    it('should default to en when no config or header', () => {
-      lang = new Lang(mockOdac)
-      // Private #lang is not accessible, but we can check where it tries to save
-      lang.get('test')
-      expect(fs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('/en.json'), expect.any(String))
-    })
-
-    it('should use lang from header if available', () => {
-      mockOdac.Request.header.mockReturnValue('tr-TR')
-      lang = new Lang(mockOdac)
-      lang.get('test')
-      expect(fs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('/tr.json'), expect.any(String))
-    })
-
-    it('should use explicit lang in set()', () => {
-      lang = new Lang(mockOdac)
-      lang.set('fr')
-      lang.get('test')
-      expect(fs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('/fr.json'), expect.any(String))
-    })
-  })
-
-  describe('get', () => {
-    it('should return matching string and support placeholders', () => {
-      // Mock loading tr.json
-      fs.existsSync.mockImplementation(path => path.includes('/tr.json'))
-      fs.readFileSync.mockReturnValue(
-        JSON.stringify({
-          welcome: 'Merhaba %s!'
-        })
-      )
-
-      lang.set('tr')
-      expect(lang.get('welcome', 'Emre')).toBe('Merhaba Emre!')
-    })
-
-    it('should support numbered placeholders', () => {
-      fs.existsSync.mockImplementation(path => path.includes('/en.json'))
-      fs.readFileSync.mockReturnValue(
-        JSON.stringify({
-          order: 'First: %s1, Second: %s2'
-        })
-      )
-
-      lang.set('en')
-      expect(lang.get('order', 'A', 'B')).toBe('First: A, Second: B')
-    })
-
-    it('should auto-save new keys', () => {
-      lang.set('en')
-      const result = lang.get('new_key')
-
-      expect(result).toBe('new_key')
-      expect(fs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('/en.json'), expect.stringContaining('"new_key": "new_key"'))
-    })
-  })
-})