odac 1.4.0 → 1.4.2

package/test/{Auth.test.js → Auth/check.test.js}

@@ -1,6 +1,6 @@
-const Auth = require('../src/Auth.js')
+const Auth = require('../../src/Auth.js')
 
-describe('Auth - Refresh Token Rotation', () => {
+describe('Auth.check()', () => {
   let reqMock
   let authInstance
 
@@ -65,7 +65,8 @@ describe('Auth - Refresh Token Rotation', () => {
         return cookieStore[name] || null
       }),
       header: jest.fn(() => 'TestBrowser'),
-      ip: '127.0.0.1'
+      ip: '127.0.0.1',
+      res: {} // HTTP context (non-null res indicates Set-Cookie can be delivered)
     }
 
     authInstance = new Auth(reqMock)
@@ -137,11 +138,19 @@ describe('Auth - Refresh Token Rotation', () => {
     // New cookie values must differ from old ones
     expect(xSet[1]).not.toBe('old_x')
     expect(ySet[1]).not.toBe('old_y')
+    // Cookie max-age must use proper HTTP attribute name (hyphenated, not camelCase)
+    expect(xSet[2]['max-age']).toBeDefined()
+    expect(xSet[2].maxAge).toBeUndefined()
   })
 
-  it('should NOT rotate a token already marked as rotated (Epoch Date marker)', async () => {
+  it('should NOT rotate a recently-rotated token still within 5s threshold', async () => {
+    // Simulate a rotated token where active was set to give ~60s grace period
+    // and the rotation JUST happened (< 5 seconds ago)
+    const maxAge = 30 * 24 * 60 * 60 * 1000
+    const rotatedActiveDate = new Date(Date.now() - maxAge + 60000) // Grace period: ~60s left
+
     const mockRecord = {
-      active: new Date(), // Still within maxAge
+      active: rotatedActiveDate,
       browser: 'TestBrowser',
       date: new Date(0), // Epoch marker = already rotated
       id: 'token_2',
@@ -158,11 +167,63 @@ describe('Auth - Refresh Token Rotation', () => {
     const result = await authInstance.check()
 
     expect(result).toBe(true)
-    // No rotation should occur
+    // No rotation should occur (timeSinceRotation < 5000)
     expect(dbMock.insert).not.toHaveBeenCalled()
     expect(dbMock.tracker.updateCalls.length).toBe(0)
   })
 
+  it('should recovery-rotate and DELETE old token when client lost cookies (rotated token > 5s)', async () => {
+    // Simulate a rotated token where 10 seconds have passed since original rotation
+    // Client still has old cookies -> recovery rotation should trigger
+    const maxAge = 30 * 24 * 60 * 60 * 1000
+    const timeSinceRotation = 10000 // 10 seconds since original rotation
+    // active was set to: rotationTime - maxAge + 60000
+    // So: inactiveAge = now - active = now - (rotationTime - maxAge + 60000) = timeSinceRotation + maxAge - 60000
+    const rotatedActiveDate = new Date(Date.now() - maxAge + 60000 - timeSinceRotation)
+
+    const mockRecord = {
+      active: rotatedActiveDate,
+      browser: 'TestBrowser',
+      date: new Date(0), // Epoch marker = rotated
+      id: 'token_recovery',
+      ip: '127.0.0.1',
+      token_x: 'old_x',
+      token_y: 'hashed_old_y',
+      user: 'user_10'
+    }
+
+    const dbMock = createDbMock([mockRecord])
+    global.Odac.DB.user_tokens = dbMock
+    global.Odac.DB.users = dbMock
+
+    const result = await authInstance.check()
+
+    expect(result).toBe(true)
+
+    // Should insert a new token (recovery rotation)
+    expect(dbMock.insert).toHaveBeenCalledTimes(1)
+    const inserted = dbMock.tracker.insertCalls[0]
+    expect(inserted.user).toBe('user_10')
+    expect(inserted.token_x).toBeDefined()
+
+    // Old token should be DELETED, not updated (prevents token multiplication)
+    expect(dbMock.tracker.deleteCalls.length).toBe(1)
+    expect(dbMock.tracker.updateCalls.length).toBe(0)
+
+    // New cookies should be issued
+    const setCalls = reqMock.cookie.mock.calls.filter(c => c.length >= 2)
+    const xSet = setCalls.find(c => c[0] === 'odac_x' && c[2]?.httpOnly === true)
+    const ySet = setCalls.find(c => c[0] === 'odac_y' && c[2]?.httpOnly === true)
+    expect(xSet).toBeDefined()
+    expect(ySet).toBeDefined()
+    expect(xSet[1]).not.toBe('old_x')
+    expect(ySet[1]).not.toBe('old_y')
+
+    // Cookie max-age attribute should use proper HTTP naming (hyphenated)
+    expect(xSet[2]['max-age']).toBeDefined()
+    expect(xSet[2].maxAge).toBeUndefined()
+  })
+
   it('should NOT rotate when tokenAge is within rotationAge threshold', async () => {
     const recentDate = Date.now() - 5 * 60 * 1000 // 5 mins ago -> within 15 min rotationAge
 
@@ -215,6 +276,92 @@ describe('Auth - Refresh Token Rotation', () => {
     expect(dbMock.insert).not.toHaveBeenCalled()
   })
 
+  it('should skip rotation for WebSocket connections (res === null) and update active instead', async () => {
+    const createdAt = Date.now() - 20 * 60 * 1000 // 20 mins ago -> exceeds 15 min rotationAge
+
+    const wsReqMock = {
+      cookie: jest.fn((name, value) => {
+        if (value !== undefined) return
+        return {odac_x: 'old_x', odac_y: 'old_y'}[name] || null
+      }),
+      header: jest.fn(() => 'TestBrowser'),
+      ip: '127.0.0.1',
+      res: null // WebSocket context: no HTTP response available
+    }
+
+    const wsAuth = new Auth(wsReqMock)
+
+    const mockRecord = {
+      active: new Date(),
+      browser: 'TestBrowser',
+      date: new Date(createdAt),
+      id: 'token_ws',
+      ip: '127.0.0.1',
+      token_x: 'old_x',
+      token_y: 'hashed_old_y',
+      user: 'user_10'
+    }
+
+    const dbMock = createDbMock([mockRecord])
+    global.Odac.DB.user_tokens = dbMock
+    global.Odac.DB.users = dbMock
+
+    const result = await wsAuth.check()
+
+    expect(result).toBe(true)
+    // No rotation: no new token inserted
+    expect(dbMock.insert).not.toHaveBeenCalled()
+    // Active timestamp should be refreshed instead
+    expect(dbMock.tracker.updateCalls.length).toBe(1)
+    expect(dbMock.tracker.updateCalls[0].active).toBeInstanceOf(Date)
+    // No new cookies set (nothing to deliver over WS)
+    const setCalls = wsReqMock.cookie.mock.calls.filter(c => c.length >= 2)
+    expect(setCalls.length).toBe(0)
+  })
+
+  it('should skip recovery rotation for WebSocket connections (res === null)', async () => {
+    const maxAge = 30 * 24 * 60 * 60 * 1000
+    const timeSinceRotation = 10000 // 10 seconds since original rotation
+    const rotatedActiveDate = new Date(Date.now() - maxAge + 60000 - timeSinceRotation)
+
+    const wsReqMock = {
+      cookie: jest.fn((name, value) => {
+        if (value !== undefined) return
+        return {odac_x: 'old_x', odac_y: 'old_y'}[name] || null
+      }),
+      header: jest.fn(() => 'TestBrowser'),
+      ip: '127.0.0.1',
+      res: null // WebSocket context
+    }
+
+    const wsAuth = new Auth(wsReqMock)
+
+    const mockRecord = {
+      active: rotatedActiveDate,
+      browser: 'TestBrowser',
+      date: new Date(0), // Epoch marker = rotated
+      id: 'token_ws_recovery',
+      ip: '127.0.0.1',
+      token_x: 'old_x',
+      token_y: 'hashed_old_y',
+      user: 'user_10'
+    }
+
+    const dbMock = createDbMock([mockRecord])
+    global.Odac.DB.user_tokens = dbMock
+    global.Odac.DB.users = dbMock
+
+    const result = await wsAuth.check()
+
+    expect(result).toBe(true)
+    // No recovery rotation: no insert, no delete
+    expect(dbMock.insert).not.toHaveBeenCalled()
+    expect(dbMock.tracker.deleteCalls.length).toBe(0)
+    // No cookies set
+    const setCalls = wsReqMock.cookie.mock.calls.filter(c => c.length >= 2)
+    expect(setCalls.length).toBe(0)
+  })
+
   it('should update active timestamp when inactiveAge exceeds updateAge but tokenAge is within rotationAge', async () => {
     const staleActive = Date.now() - 25 * 60 * 60 * 1000 // 25 hours ago -> exceeds 24h updateAge
     const recentDate = Date.now() - 5 * 60 * 1000 // 5 mins ago -> within rotationAge

package/test/Client/data.test.js

@@ -0,0 +1,91 @@
+describe('Odac.data()', () => {
+  let mockXhr, mockDocument, mockWindow
+
+  beforeEach(() => {
+    jest.resetModules()
+    mockXhr = {
+      open: jest.fn(),
+      setRequestHeader: jest.fn(),
+      send: jest.fn(),
+      getResponseHeader: jest.fn(),
+      status: 200,
+      responseText: '{}',
+      response: '{}',
+      onload: null,
+      onerror: null
+    }
+    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()}}))
+    }
+    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})),
+      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('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')
+  })
+})

package/test/Client/get.test.js

@@ -0,0 +1,90 @@
+describe('Odac.get()', () => {
+  let mockXhr, mockDocument, mockWindow
+
+  beforeEach(() => {
+    jest.resetModules()
+    mockXhr = {
+      open: jest.fn(),
+      setRequestHeader: jest.fn(),
+      send: jest.fn(),
+      getResponseHeader: jest.fn(),
+      status: 200,
+      responseText: '{}',
+      response: '{}',
+      onload: null,
+      onerror: null
+    }
+    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()}}))
+    }
+    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})),
+      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('should automatically parse JSON if Content-Type is application/json', () => {
+    const mockCallback = jest.fn()
+    const mockData = {success: true}
+    jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
+    mockXhr.responseText = JSON.stringify(mockData)
+    mockXhr.status = 200
+    mockXhr.statusText = 'OK'
+    mockXhr.getResponseHeader.mockImplementation(h => (h === 'Content-Type' ? 'application/json' : null))
+
+    window.Odac.get('/api/test', mockCallback)
+    if (mockXhr.onload) mockXhr.onload()
+    expect(mockCallback).toHaveBeenCalledWith(mockData, 'OK', expect.anything())
+  })
+})

package/test/Client/storage.test.js

@@ -0,0 +1,87 @@
+describe('Odac.storage()', () => {
+  let mockXhr, mockDocument, mockWindow
+
+  beforeEach(() => {
+    jest.resetModules()
+    mockXhr = {
+      open: jest.fn(),
+      setRequestHeader: jest.fn(),
+      send: jest.fn(),
+      getResponseHeader: jest.fn(),
+      status: 200,
+      responseText: '{}',
+      response: '{}',
+      onload: null,
+      onerror: null
+    }
+    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()}}))
+    }
+    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})),
+      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('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')
+  })
+})

package/test/Client/token.test.js

@@ -0,0 +1,82 @@
+describe('Odac.token()', () => {
+  let mockXhr, mockDocument, mockWindow
+
+  beforeEach(() => {
+    jest.resetModules()
+    mockXhr = {
+      open: jest.fn(),
+      setRequestHeader: jest.fn(),
+      send: jest.fn(),
+      getResponseHeader: jest.fn(),
+      status: 200,
+      responseText: '{}',
+      response: JSON.stringify({token: 'new-token'}),
+      onload: null,
+      onerror: null
+    }
+    mockDocument = {
+      getElementById: jest.fn(),
+      querySelectorAll: jest.fn(() => []),
+      querySelector: jest.fn(),
+      addEventListener: jest.fn(),
+      removeEventListener: jest.fn(),
+      dispatchEvent: jest.fn(),
+      documentElement: {dataset: {}},
+      cookie: 'odac_client=abc',
+      readyState: 'complete',
+      createElement: jest.fn(() => ({setAttribute: jest.fn(), style: {}, appendChild: jest.fn(), parentNode: {insertBefore: jest.fn()}}))
+    }
+    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})),
+      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('should fetch token via sync XHR if hash is empty', () => {
+    const token = window.Odac.token()
+    expect(window.XMLHttpRequest).toHaveBeenCalled()
+    expect(token).toBe('new-token')
+  })
+})

package/test/Client/ws.test.js

@@ -0,0 +1,86 @@
+describe('Odac.ws()', () => {
+  let mockXhr, mockDocument, mockWindow
+
+  beforeEach(() => {
+    jest.resetModules()
+    mockXhr = {
+      open: jest.fn(),
+      setRequestHeader: jest.fn(),
+      send: jest.fn(),
+      getResponseHeader: jest.fn(),
+      status: 200,
+      responseText: '{}',
+      response: '{}',
+      onload: null,
+      onerror: null
+    }
+    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()}}))
+    }
+    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})),
+      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('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/deepMerge.test.js

@@ -0,0 +1,14 @@
+const Config = require('../../src/Config')
+
+describe('Config._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
+    })
+  })
+})