odac 1.1.0 → 1.3.0

package/test/{framework/Route.test.js → Route.test.js}

@@ -1,4 +1,4 @@
-const Route = require('../../framework/src/Route')
+const Route = require('../src/Route')
 
 describe('Route', () => {
   let route
@@ -240,6 +240,110 @@ describe('Route', () => {
     })
   })
 
+  describe('parametric route matching (#controller via check)', () => {
+    const createMockOdac = (url, method = 'get') => ({
+      Auth: {check: jest.fn().mockResolvedValue(true)},
+      Config: {},
+      Request: {
+        abort: jest.fn().mockReturnValue('aborted'),
+        cookie: jest.fn(() => null),
+        data: {url: {}},
+        header: jest.fn(() => ''),
+        host: 'example.com',
+        isAjaxLoad: false,
+        method,
+        page: null,
+        res: {finished: false, writableEnded: false},
+        route: 'test_route',
+        setSession: jest.fn(),
+        ssl: false,
+        url
+      },
+      request: jest.fn().mockResolvedValue(null),
+      token: jest.fn().mockReturnValue(true)
+    })
+
+    const setupParamRoute = async (routeInstance, urlPattern, handler) => {
+      global.Odac.Route.buff = 'test_route'
+      routeInstance.set('get', urlPattern, handler, {token: false})
+      await Promise.all(routeInstance._pendingRouteLoads)
+      routeInstance._pendingRouteLoads = []
+    }
+
+    it('should match single parametric segment and extract params', async () => {
+      const handler = jest.fn().mockReturnValue({ok: true})
+      await setupParamRoute(route, '/users/{id}', handler)
+
+      const mockOdac = createMockOdac('/users/42')
+      await route.check(mockOdac)
+
+      expect(handler).toHaveBeenCalled()
+      expect(mockOdac.Request.data.url.id).toBe('42')
+    })
+
+    it('should match multi-parameter route and extract all params', async () => {
+      const handler = jest.fn().mockReturnValue({ok: true})
+      await setupParamRoute(route, '/users/{userId}/posts/{postId}', handler)
+
+      const mockOdac = createMockOdac('/users/7/posts/99')
+      await route.check(mockOdac)
+
+      expect(handler).toHaveBeenCalled()
+      expect(mockOdac.Request.data.url.userId).toBe('7')
+      expect(mockOdac.Request.data.url.postId).toBe('99')
+    })
+
+    it('should not match when static segments differ', async () => {
+      const handler = jest.fn().mockReturnValue({ok: true})
+      await setupParamRoute(route, '/users/{id}', handler)
+
+      const mockOdac = createMockOdac('/posts/42')
+      await route.check(mockOdac)
+
+      expect(handler).not.toHaveBeenCalled()
+    })
+
+    it('should not match when segment count differs', async () => {
+      const handler = jest.fn().mockReturnValue({ok: true})
+      await setupParamRoute(route, '/users/{id}', handler)
+
+      const mockOdac = createMockOdac('/users/42/extra')
+      await route.check(mockOdac)
+
+      expect(handler).not.toHaveBeenCalled()
+    })
+
+    it('should correctly match among multiple parametric routes (no arr mutation bug)', async () => {
+      const usersHandler = jest.fn().mockReturnValue({users: true})
+      const postsHandler = jest.fn().mockReturnValue({posts: true})
+
+      await setupParamRoute(route, '/users/{id}', usersHandler)
+      await setupParamRoute(route, '/posts/{id}', postsHandler)
+
+      // Request to /posts/5 should match postsHandler, not usersHandler
+      const mockOdac = createMockOdac('/posts/5')
+      await route.check(mockOdac)
+
+      expect(usersHandler).not.toHaveBeenCalled()
+      expect(postsHandler).toHaveBeenCalled()
+      expect(mockOdac.Request.data.url.id).toBe('5')
+    })
+
+    it('should prefer exact match over parametric match', async () => {
+      const exactHandler = jest.fn().mockReturnValue({exact: true})
+      const paramHandler = jest.fn().mockReturnValue({param: true})
+
+      await setupParamRoute(route, '/users/admin', exactHandler)
+      await setupParamRoute(route, '/users/{id}', paramHandler)
+
+      const mockOdac = createMockOdac('/users/admin')
+      await route.check(mockOdac)
+
+      expect(exactHandler).toHaveBeenCalled()
+      expect(paramHandler).not.toHaveBeenCalled()
+    })
+  })
+
   describe('WebSocket cleanup', () => {
     it('should call ws() method successfully', () => {
       const handler = jest.fn()

package/test/{framework/View → View}/EarlyHints.test.js

@@ -1,4 +1,4 @@
-const EarlyHints = require('../../../framework/src/View/EarlyHints')
+const EarlyHints = require('../../src/View/EarlyHints')
 
 describe('EarlyHints', () => {
   let earlyHints

package/test/WebSocket.test.js

@@ -0,0 +1,238 @@
+const {WebSocketServer} = require('../src/WebSocket.js')
+
+describe('WebSocketServer', () => {
+  let server
+
+  beforeEach(() => {
+    server = new WebSocketServer()
+  })
+
+  describe('route', () => {
+    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'})
+    })
+  })
+
+  describe('rooms', () => {
+    it('should join and leave rooms', () => {
+      server.joinRoom('client1', 'room1')
+      server.joinRoom('client2', 'room1')
+
+      server.leaveRoom('client1', 'room1')
+      server.leaveRoom('client2', 'room1')
+    })
+  })
+
+  describe('broadcast', () => {
+    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')
+    })
+  })
+
+  describe('clients', () => {
+    it('should track client count', () => {
+      expect(server.clientCount).toBe(0)
+    })
+  })
+
+  describe('cleanup on disconnect', () => {
+    it('should be handled by Route.setWs wrapper', () => {
+      expect(true).toBe(true)
+    })
+  })
+  describe('maxPayload', () => {
+    it('should close connection if payload exceeds limit', () => {
+      const socket = {
+        pause: jest.fn(),
+        resume: jest.fn(),
+        on: jest.fn(),
+        write: jest.fn(),
+        end: jest.fn(),
+        removeAllListeners: jest.fn()
+      }
+      const {WebSocketClient} = require('../src/WebSocket.js')
+      new WebSocketClient(socket, server, 'test-id', {maxPayload: 10})
+
+      // We must send a MASKED frame because server expects masked frames from client
+      const buffer = Buffer.alloc(100)
+      buffer[0] = 0x81 // fin + text
+      buffer[1] = 0x80 | 20 // masked + length 20
+      // Mask key (4 bytes) + Payload (20 bytes) needed but header check happens first
+
+      const dataHandler = socket.on.mock.calls.find(call => call[0] === 'data')[1]
+      dataHandler(buffer)
+
+      expect(socket.end).toHaveBeenCalled()
+      // Verify close frame sent with 1009
+      // socket.write is called to send the Close frame
+      const writeCall = socket.write.mock.calls[0][0]
+      expect(writeCall[2]).toBe(0x03) // 1009 >> 8
+      expect(writeCall[3]).toBe(0xf1) // 1009 & 0xff
+    })
+  })
+
+  describe('rateLimit', () => {
+    it('should close connection if rate limit exceeded', () => {
+      const socket = {
+        pause: jest.fn(),
+        resume: jest.fn(),
+        on: jest.fn(),
+        write: jest.fn(),
+        end: jest.fn(),
+        removeAllListeners: jest.fn()
+      }
+      const {WebSocketClient} = require('../src/WebSocket.js')
+      new WebSocketClient(socket, server, 'test-id', {
+        rateLimit: {max: 2, window: 1000}
+      })
+
+      // Valid MASKED frame (exact size 7 bytes)
+      const buffer = Buffer.alloc(7)
+      buffer[0] = 0x81
+      buffer[1] = 0x80 | 1 // masked + length 1
+      buffer[2] = 0x00
+      buffer[3] = 0x00
+      buffer[4] = 0x00
+      buffer[5] = 0x00 // mask key (0)
+      buffer[6] = 0x61 // 'a' (masked with 0 remains 'a')
+
+      const dataHandler = socket.on.mock.calls.find(call => call[0] === 'data')[1]
+
+      // Send 3 messages (limit is 2)
+      dataHandler(buffer)
+      dataHandler(buffer)
+      dataHandler(buffer)
+
+      expect(socket.end).toHaveBeenCalled()
+      // Verify close frame sent with 1008
+      const writeCalls = socket.write.mock.calls
+      const writeCall = writeCalls[writeCalls.length - 1][0]
+      expect(writeCall[2]).toBe(0x03) // 1008 >> 8
+      expect(writeCall[3]).toBe(0xf0) // 1008 & 0xff
+    })
+
+    it('should reset count after window', done => {
+      const socket = {
+        pause: jest.fn(),
+        resume: jest.fn(),
+        on: jest.fn(),
+        write: jest.fn(),
+        end: jest.fn(),
+        removeAllListeners: jest.fn()
+      }
+      const {WebSocketClient} = require('../src/WebSocket.js')
+      const client = new WebSocketClient(socket, server, 'test-id', {
+        rateLimit: {max: 2, window: 200}
+      })
+
+      const buffer = Buffer.alloc(7)
+      buffer[0] = 0x81
+      buffer[1] = 0x80 | 1
+      buffer[2] = 0x00
+      buffer[3] = 0x00
+      buffer[4] = 0x00
+      buffer[5] = 0x00
+      buffer[6] = 0x61
+
+      const dataHandler = socket.on.mock.calls.find(call => call[0] === 'data')[1]
+
+      // Send 2 messages
+      dataHandler(buffer)
+      dataHandler(buffer)
+      expect(socket.end).not.toHaveBeenCalled()
+
+      setTimeout(() => {
+        // Send 1 more after window reset
+        dataHandler(buffer)
+
+        try {
+          expect(socket.end).not.toHaveBeenCalled()
+          client.close()
+          done()
+        } catch (error) {
+          client.close()
+          done(error)
+        }
+      }, 300)
+    })
+  })
+})
+
+describe('Route WebSocket Integration', () => {
+  const Route = require('../src/Route.js')
+
+  beforeEach(() => {
+    global.Odac = {
+      Route: new Route()
+    }
+  })
+
+  it('should support ws() method', () => {
+    expect(typeof Odac.Route.ws).toBe('function')
+  })
+
+  it('should support auth.ws() method', () => {
+    expect(typeof Odac.Route.auth.ws).toBe('function')
+  })
+
+  it('should support middleware with ws()', () => {
+    const chain = Odac.Route.use('test-middleware')
+    expect(typeof chain.ws).toBe('function')
+  })
+
+  it('should support middleware with auth.ws()', () => {
+    const chain = Odac.Route.use('test-middleware')
+    expect(typeof chain.auth.ws).toBe('function')
+  })
+
+  it('should support auth.use() with ws()', () => {
+    const chain = Odac.Route.auth.use('test-middleware')
+    expect(typeof chain.ws).toBe('function')
+  })
+})

package/test/scripts/check-coverage.js

@@ -17,7 +17,7 @@ function getStagedFiles() {
     return output
       .split('\n')
       .filter(file => file.endsWith('.js'))
-      .filter(file => file.startsWith('core/') || file.startsWith('server/'))
+      .filter(file => file.startsWith('src/') || file.startsWith('client/'))
       .filter(file => !file.includes('.test.js') && !file.includes('.spec.js'))
   } catch (err) {
     console.error('Error getting staged files:', err.message)
@@ -34,7 +34,7 @@ function checkTestFiles(changedFiles) {
     if (!fs.existsSync(file)) continue
 
     // Determine test file path
-    const testFile = file.replace(/^(core|server)\//, 'test/$1/').replace(/\.js$/, '.test.js')
+    const testFile = file.replace(/^(src|client)\//, 'test/').replace(/\.js$/, '.test.js')
 
     if (!fs.existsSync(testFile)) {
       missingTests.push({
@@ -60,7 +60,7 @@ function runTestsForFiles(files) {
     // Create a pattern to match test files for changed source files
     const testPatterns = files
       .map(file => {
-        const testFile = file.replace(/^(core|server)\//, 'test/$1/').replace(/\.js$/, '.test.js')
+        const testFile = file.replace(/^(src|client)\//, 'test/').replace(/\.js$/, '.test.js')
         return testFile
       })
       .filter(testFile => fs.existsSync(testFile))
@@ -98,7 +98,7 @@ function main() {
   const changedFiles = getStagedFiles()
 
   if (changedFiles.length === 0) {
-    console.log('✓ No core or server files changed\n')
+    console.log('✓ No src or client files changed\n')
     process.exit(0)
   }
 

package/test/cli/Cli.test.js

@@ -1,36 +0,0 @@
-const Cli = require('../../cli/src/Cli.js')
-
-describe('CLI Prefix Argument Parsing', () => {
-  test('parseArg should extract value after prefix', () => {
-    const args = ['web', 'create', '-d', 'example.com', '--other', 'value']
-
-    expect(Cli.parseArg(args, ['-d', '--domain'])).toBe('example.com')
-    expect(Cli.parseArg(args, ['--other'])).toBe('value')
-    expect(Cli.parseArg(args, ['-x', '--missing'])).toBeNull()
-  })
-
-  test('parseArg should handle multiple prefix options', () => {
-    const args = ['mail', 'create', '--email', 'test@example.com', '-p', 'password123']
-
-    expect(Cli.parseArg(args, ['-e', '--email'])).toBe('test@example.com')
-    expect(Cli.parseArg(args, ['-p', '--password'])).toBe('password123')
-  })
-
-  test('parseArg should return null for missing arguments', () => {
-    const args = ['web', 'create']
-
-    expect(Cli.parseArg(args, ['-d', '--domain'])).toBeNull()
-    expect(Cli.parseArg(null, ['-d'])).toBeNull()
-    expect(Cli.parseArg(args, null)).toBeNull()
-  })
-
-  test('parseArg should handle edge cases', () => {
-    const args = ['command', '-d']
-
-    // Missing value after prefix
-    expect(Cli.parseArg(args, ['-d'])).toBeNull()
-
-    // Empty args
-    expect(Cli.parseArg([], ['-d'])).toBeNull()
-  })
-})