odac 1.1.0 → 1.2.0

package/test/Lang.test.js

@@ -0,0 +1,92 @@
+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"'))
+    })
+  })
+})

package/test/Odac.test.js

@@ -0,0 +1,86 @@
+const Odac = require('../src/Odac')
+
+// Mock all dependencies
+jest.mock('../src/Storage', () => ({init: jest.fn()}))
+jest.mock('../src/Env', () => ({init: jest.fn(), get: jest.fn()}))
+jest.mock('../src/Config', () => ({
+  init: jest.fn(),
+  request: {timeout: 10000},
+  lang: {default: 'en'}
+}))
+jest.mock('../src/Database', () => ({init: jest.fn()}))
+jest.mock('../src/Ipc', () => ({init: jest.fn(), subscribe: jest.fn(), unsubscribe: jest.fn()}))
+jest.mock('../src/Route', () => {
+  return jest.fn().mockImplementation(() => ({
+    init: jest.fn(),
+    routes: {
+      www: {}
+    }
+  }))
+})
+jest.mock('../src/Server', () => ({init: jest.fn()}))
+
+describe('Odac', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    global.__dir = '/mock/project'
+  })
+
+  describe('init', () => {
+    it('should initialize all components and set global.Odac', async () => {
+      await Odac.init()
+      expect(global.Odac).toBeDefined()
+      expect(global.Odac.Storage).toBeDefined()
+      expect(global.Odac.Config).toBeDefined()
+      expect(global.Odac.Env).toBeDefined()
+      expect(global.Odac.Database).toBeDefined()
+      expect(global.Odac.Ipc).toBeDefined()
+      expect(global.Odac.Route).toBeDefined()
+      expect(global.Odac.Server).toBeDefined()
+      expect(typeof global.__).toBe('function')
+    })
+  })
+
+  describe('instance', () => {
+    it('should create a context object without req/res', () => {
+      const ctx = Odac.instance('id-123')
+      expect(ctx.Config).toBeDefined()
+      expect(ctx.Database).toBeDefined()
+      expect(ctx.Ipc).toBeDefined()
+      expect(ctx.Request).toBeUndefined()
+    })
+
+    it('should create a context object with req/res', () => {
+      const mockReq = {url: '/', method: 'GET', headers: {host: 'example.com'}, connection: {remoteAddress: '127.0.0.1'}, on: jest.fn()}
+      const mockRes = {}
+      const ctx = Odac.instance('id-123', mockReq, mockRes)
+      expect(ctx.Request).toBeDefined()
+      expect(ctx.Auth).toBeDefined()
+      expect(ctx.Token).toBeDefined()
+      expect(ctx.Lang).toBeDefined()
+      expect(ctx.View).toBeDefined()
+    })
+
+    it('should provide helper methods on the context', () => {
+      const mockReq = {url: '/', method: 'GET', headers: {host: 'example.com'}, connection: {remoteAddress: '127.0.0.1'}, on: jest.fn()}
+      const mockRes = {end: jest.fn(), write: jest.fn()}
+      const ctx = Odac.instance('id-123', mockReq, mockRes)
+
+      expect(typeof ctx.env).toBe('function')
+      expect(typeof ctx.return).toBe('function')
+      expect(typeof ctx.write).toBe('function')
+    })
+
+    it('should handle Ipc subscription through Proxy', async () => {
+      const ctx = Odac.instance('id-123')
+      const callback = jest.fn()
+      const IpcSingleton = require('../src/Ipc')
+      IpcSingleton.subscribe.mockResolvedValue('sub-id')
+
+      await ctx.Ipc.subscribe('test-channel', callback)
+
+      expect(IpcSingleton.subscribe).toHaveBeenCalledWith('test-channel', callback)
+      expect(ctx._ipcSubs).toHaveLength(1)
+    })
+  })
+})

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

@@ -1,4 +1,4 @@
-const Route = require('../../framework/src/Route.js')
+const Route = require('../../src/Route.js')
 
 describe('Middleware System', () => {
   let route
@@ -52,7 +52,7 @@ describe('Middleware System', () => {
 
   test('chaining should work: auth.use().page()', () => {
     route.auth.use('admin').page('/admin', () => {})
-    expect(route.routes.test.page['/admin'].middlewares).toEqual(['admin'])
+    expect(route.routes.test['#page']['/admin'].middlewares).toEqual(['admin'])
   })
 
   test('middlewares should be attached to routes', () => {

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

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/{framework/WebSocket.test.js → WebSocket.test.js}

@@ -1,4 +1,4 @@
-const {WebSocketServer} = require('../../framework/src/WebSocket.js')
+const {WebSocketServer} = require('../src/WebSocket.js')
 
 describe('WebSocketServer', () => {
   let server
@@ -67,7 +67,7 @@ describe('WebSocketServer', () => {
 })
 
 describe('Route WebSocket Integration', () => {
-  const Route = require('../../framework/src/Route.js')
+  const Route = require('../src/Route.js')
 
   beforeEach(() => {
     global.Odac = {

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()
-  })
-})