odac 1.4.1 → 1.4.3

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,118 @@
+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()
+  })
+
+  test('should use fresh token on reconnect', () => {
+    let tokenCounter = 0
+    mockXhr.response = JSON.stringify({token: 'initial-token'})
+    mockXhr.responseText = JSON.stringify({token: 'initial-token'})
+    mockXhr.onload = null
+    mockXhr.send = jest.fn(function () {
+      tokenCounter++
+      this.response = JSON.stringify({token: `token-${tokenCounter}`})
+      this.responseText = this.response
+      if (this.onload) this.onload()
+    })
+    mockDocument.cookie = 'odac_client=test-client'
+
+    window.Odac.ws('/test-ws', {token: true, autoReconnect: true, reconnectDelay: 100})
+    const firstCall = WebSocket.mock.calls[0]
+    expect(firstCall[1]).toEqual(expect.arrayContaining([expect.stringMatching(/^odac-token-/)]))
+    const firstToken = firstCall[1][0]
+
+    const socketInstance = WebSocket.mock.results[0].value
+    socketInstance.onopen()
+
+    global.setTimeout = jest.fn(fn => fn())
+    socketInstance.readyState = 3
+    socketInstance.onclose({code: 1006})
+
+    expect(WebSocket.mock.calls.length).toBeGreaterThan(1)
+    const secondCall = WebSocket.mock.calls[1]
+    expect(secondCall[1]).toEqual(expect.arrayContaining([expect.stringMatching(/^odac-token-/)]))
+    const secondToken = secondCall[1][0]
+    expect(secondToken).not.toBe(firstToken)
+  })
+})

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

package/test/Config/init.test.js

@@ -0,0 +1,66 @@
+const fs = require('fs')
+const os = require('os')
+const Config = require('../../src/Config')
+
+jest.mock('fs')
+jest.mock('os')
+
+describe('Config.init()', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    global.__dir = '/mock/project'
+    Config.system = undefined
+    Config.encrypt.key = 'odac'
+  })
+
+  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')
+  })
+})

package/test/Config/interpolate.test.js

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

package/test/Database/ConnectionFactory/buildConnectionConfig.test.js

@@ -0,0 +1,13 @@
+const {buildConnectionConfig} = require('../../../src/Database/ConnectionFactory')
+
+describe('ConnectionFactory.buildConnectionConfig()', () => {
+  it('should create sqlite filename config', () => {
+    const config = buildConnectionConfig({database: 'db.sqlite3'}, 'sqlite3')
+    expect(config).toEqual({filename: 'db.sqlite3'})
+  })
+
+  it('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})
+  })
+})

package/test/Database/ConnectionFactory/buildConnections.test.js

@@ -0,0 +1,31 @@
+const mockKnex = jest.fn()
+jest.mock(
+  'knex',
+  () =>
+    (...args) =>
+      mockKnex(...args)
+)
+
+const {buildConnections} = require('../../../src/Database/ConnectionFactory')
+
+describe('ConnectionFactory.buildConnections()', () => {
+  beforeEach(() => {
+    mockKnex.mockReset()
+    mockKnex.mockImplementation(options => ({options, raw: jest.fn()}))
+  })
+
+  it('should support single database config', () => {
+    const connections = buildConnections({type: 'mysql', user: 'root', database: 'app'})
+    expect(Object.keys(connections)).toEqual(['default'])
+    expect(mockKnex).toHaveBeenCalledTimes(1)
+  })
+
+  it('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/Database/ConnectionFactory/resolveClient.test.js

@@ -0,0 +1,12 @@
+const {resolveClient} = require('../../../src/Database/ConnectionFactory')
+
+describe('ConnectionFactory.resolveClient()', () => {
+  it('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')
+  })
+})

package/test/Database/Migration/migrate_column.test.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const path = require('node:path')
+const fs = require('node:fs')
+const os = require('node:os')
+const knex = require('knex')
+const Migration = require('../../../src/Database/Migration')
+
+let db, tmpDir
+
+beforeEach(async () => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'odac-migration-column-'))
+  db = knex({client: 'sqlite3', connection: {filename: ':memory:'}, useNullAsDefault: true})
+  Migration.init(tmpDir, {default: db})
+})
+
+afterEach(async () => {
+  await db.destroy()
+  fs.rmSync(tmpDir, {recursive: true, force: true})
+})
+
+function writeSchema(name, content) {
+  const dir = path.join(tmpDir, 'schema')
+  fs.mkdirSync(dir, {recursive: true})
+  fs.writeFileSync(path.join(dir, `${name}.js`), `module.exports = ${JSON.stringify(content, null, 2)}`)
+}
+
+describe('Migration.migrate() - Column Diff', () => {
+  it('should add a new column to an existing table', async () => {
+    writeSchema('posts', {columns: {id: {type: 'increments'}, title: {type: 'string'}}})
+    await Migration.migrate()
+
+    writeSchema('posts', {columns: {id: {type: 'increments'}, title: {type: 'string'}, body: {type: 'text', nullable: true}}})
+    const result = await Migration.migrate()
+    const addOps = result.default.schema.filter(op => op.type === 'add_column')
+
+    expect(addOps).toEqual(expect.arrayContaining([expect.objectContaining({type: 'add_column', column: 'body', table: 'posts'})]))
+    const info = await db('posts').columnInfo()
+    expect(info).toHaveProperty('body')
+  })
+
+  it('should drop a column removed from schema', async () => {
+    writeSchema('items', {columns: {id: {type: 'increments'}, name: {type: 'string'}, obsolete: {type: 'string'}}})
+    await Migration.migrate()
+
+    writeSchema('items', {columns: {id: {type: 'increments'}, name: {type: 'string'}}})
+    const result = await Migration.migrate()
+    const dropOps = result.default.schema.filter(op => op.type === 'drop_column')
+
+    expect(dropOps).toEqual(expect.arrayContaining([expect.objectContaining({type: 'drop_column', column: 'obsolete', table: 'items'})]))
+  })
+})

package/test/Database/Migration/migrate_files.test.js

@@ -0,0 +1,70 @@
+'use strict'
+
+const path = require('node:path')
+const fs = require('node:fs')
+const os = require('node:os')
+const knex = require('knex')
+const Migration = require('../../../src/Database/Migration')
+
+let db, tmpDir
+
+beforeEach(async () => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'odac-migration-files-'))
+  db = knex({client: 'sqlite3', connection: {filename: ':memory:'}, useNullAsDefault: true})
+  Migration.init(tmpDir, {default: db})
+})
+
+afterEach(async () => {
+  await db.destroy()
+  fs.rmSync(tmpDir, {recursive: true, force: true})
+})
+
+function writeMigrationFile(name, upFn, downFn) {
+  const dir = path.join(tmpDir, 'migration')
+  fs.mkdirSync(dir, {recursive: true})
+
+  const content = `
+    module.exports = {
+      up: ${upFn.toString()},
+      down: ${downFn ? downFn.toString() : 'undefined'}
+    }
+  `
+  fs.writeFileSync(path.join(dir, name), content)
+}
+
+describe('Migration.migrate() - Migration Files', () => {
+  it('should run pending migration files in order', async () => {
+    await db.schema.createTable('counters', t => {
+      t.increments('id')
+      t.string('name')
+      t.integer('value').defaultTo(0)
+    })
+
+    writeMigrationFile('20260225_001_init.js', async db => {
+      await db('counters').insert({name: 'visits', value: 0})
+    })
+    writeMigrationFile('20260225_002_add.js', async db => {
+      await db('counters').insert({name: 'signups', value: 0})
+    })
+
+    const result = await Migration.migrate()
+    expect(result.default.files).toHaveLength(2)
+
+    const rows = await db('counters').select()
+    expect(rows).toHaveLength(2)
+  })
+
+  it('should not re-run already applied migration files', async () => {
+    await db.schema.createTable('data', t => {
+      t.increments('id')
+      t.string('value')
+    })
+
+    writeMigrationFile('20260225_001_insert.js', async db => {
+      await db('data').insert({value: 'test'})
+    })
+    await Migration.migrate()
+    const result2 = await Migration.migrate()
+    expect(result2.default.files).toHaveLength(0)
+  })
+})