odac 1.4.4 → 1.4.6

package/test/Client/load.test.js

@@ -0,0 +1,306 @@
+describe('Odac.load()', () => {
+  let mockXhr, mockDocument, mockWindow
+
+  const setupMocks = (options = {}) => {
+    jest.resetModules()
+    mockXhr = {
+      open: jest.fn(),
+      setRequestHeader: jest.fn(),
+      send: jest.fn(),
+      getResponseHeader: jest.fn(() => null),
+      responseURL: '',
+      status: 200,
+      responseText: '{}',
+      response: '{}',
+      onload: null,
+      onerror: null
+    }
+
+    const transitionElements = options.transitionElements || []
+
+    mockDocument = {
+      getElementById: jest.fn(),
+      querySelectorAll: jest.fn(selector => {
+        if (selector === '[odac-transition]') return transitionElements
+        return []
+      }),
+      querySelector: jest.fn(),
+      addEventListener: jest.fn(),
+      removeEventListener: jest.fn(),
+      dispatchEvent: jest.fn(),
+      documentElement: {dataset: {}},
+      cookie: '',
+      readyState: 'complete',
+      startViewTransition: options.hasViewTransition
+        ? jest.fn(cb => {
+            cb()
+            return {
+              finished: Promise.resolve(),
+              ready: Promise.resolve(),
+              updateCallbackDone: Promise.resolve()
+            }
+          })
+        : undefined,
+      createElement: jest.fn(tag => {
+        const el = {
+          setAttribute: jest.fn(),
+          style: {},
+          appendChild: jest.fn(),
+          parentNode: {insertBefore: jest.fn()},
+          _innerHTML: '',
+          get value() {
+            if (tag === 'textarea') {
+              return this._innerHTML
+                .replace(/&/g, '&')
+                .replace(/&lt;/g, '<')
+                .replace(/&gt;/g, '>')
+                .replace(/&quot;/g, '"')
+                .replace(/&#039;/g, "'")
+            }
+            return ''
+          }
+        }
+        Object.defineProperty(el, 'innerHTML', {
+          get() {
+            return el._innerHTML
+          },
+          set(v) {
+            el._innerHTML = v
+          }
+        })
+        return el
+      })
+    }
+
+    mockWindow = {
+      location: {protocol: 'http:', host: 'localhost', href: 'http://localhost/', replace: jest.fn()},
+      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(),
+      URL: global.URL
+    }
+    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
+  })
+
+  describe('URL validation', () => {
+    beforeEach(() => setupMocks())
+
+    test('should resolve empty string to current URL and proceed with navigation', () => {
+      jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
+      window.Odac.load('', jest.fn())
+      // Empty string resolves to current URL via new URL('', base) — AJAX fires normally
+      expect(mockXhr.send).toHaveBeenCalled()
+    })
+
+    test('should reject javascript: protocol URLs', () => {
+      const result = window.Odac.load('javascript:void(0)', jest.fn())
+      expect(result).toBe(false)
+    })
+
+    test('should reject data: protocol URLs', () => {
+      const result = window.Odac.load('data:text/html,test', jest.fn())
+      expect(result).toBe(false)
+    })
+
+    test('should reject vbscript: protocol URLs', () => {
+      const result = window.Odac.load('vbscript:test', jest.fn())
+      expect(result).toBe(false)
+    })
+
+    test('should reject hash-only URLs', () => {
+      const result = window.Odac.load('#section', jest.fn())
+      expect(result).toBe(false)
+    })
+
+    test('should prevent concurrent navigations', () => {
+      window.Odac.load('/page-1', jest.fn())
+      const result = window.Odac.load('/page-2', jest.fn())
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('fade fallback path', () => {
+    beforeEach(() => setupMocks({hasViewTransition: false}))
+
+    test('should use fade when View Transition API is unavailable', () => {
+      jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
+      window.Odac.load('/test', jest.fn())
+      expect(mockXhr.open).toHaveBeenCalledWith('GET', 'http://localhost/test', true)
+      expect(mockXhr.send).toHaveBeenCalled()
+    })
+
+    test('should fallback to window.location.replace on AJAX error', () => {
+      jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
+      window.Odac.load('/error-page', jest.fn())
+      mockXhr.onerror()
+      expect(mockWindow.location.replace).toHaveBeenCalledWith('http://localhost/error-page')
+    })
+  })
+
+  describe('View Transition API path', () => {
+    let transitionElements
+
+    beforeEach(() => {
+      transitionElements = [
+        {getAttribute: jest.fn(() => 'header'), style: {}, setAttribute: jest.fn()},
+        {getAttribute: jest.fn(() => 'hero'), style: {}, setAttribute: jest.fn()}
+      ]
+      setupMocks({hasViewTransition: true, transitionElements})
+    })
+
+    test('should use View Transition API when supported and odac-transition elements exist', () => {
+      jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
+      window.Odac.load('/new-page', jest.fn())
+
+      expect(transitionElements[0].style.viewTransitionName).toBe('header')
+      expect(transitionElements[1].style.viewTransitionName).toBe('hero')
+      expect(mockXhr.send).toHaveBeenCalled()
+    })
+
+    test('should call startViewTransition on successful AJAX response', () => {
+      jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
+      mockXhr.responseURL = 'http://localhost/new-page'
+      mockXhr.getResponseHeader.mockImplementation(h => (h === 'Content-Type' ? 'application/json' : null))
+
+      window.Odac.load('/new-page', jest.fn())
+
+      mockXhr.responseText = JSON.stringify({title: 'New Page', output: {}})
+      mockXhr.status = 200
+      if (mockXhr.onload) mockXhr.onload()
+
+      expect(mockDocument.startViewTransition).toHaveBeenCalled()
+    })
+
+    test('should apply transition names to elements before snapshot', () => {
+      jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
+      window.Odac.load('/page', jest.fn())
+
+      expect(transitionElements[0].getAttribute).toHaveBeenCalledWith('odac-transition')
+      expect(transitionElements[0].style.viewTransitionName).toBe('header')
+      expect(transitionElements[1].getAttribute).toHaveBeenCalledWith('odac-transition')
+      expect(transitionElements[1].style.viewTransitionName).toBe('hero')
+    })
+
+    test('should fall back to full page load on skeleton change', () => {
+      jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
+      mockXhr.responseURL = 'http://localhost/new-skeleton'
+      mockXhr.getResponseHeader.mockImplementation(h => (h === 'Content-Type' ? 'application/json' : null))
+
+      window.Odac.load('/new-skeleton', jest.fn())
+
+      mockXhr.responseText = JSON.stringify({skeletonChanged: true})
+      mockXhr.status = 200
+      if (mockXhr.onload) mockXhr.onload()
+
+      expect(mockDocument.startViewTransition).not.toHaveBeenCalled()
+      expect(mockWindow.location.href).toBe('http://localhost/new-skeleton')
+    })
+
+    test('should clean transition names on AJAX error', () => {
+      jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
+      window.Odac.load('/fail', jest.fn())
+
+      mockXhr.onerror()
+
+      expect(transitionElements[0].style.viewTransitionName).toBe('')
+      expect(transitionElements[1].style.viewTransitionName).toBe('')
+    })
+  })
+
+  describe('fade fallback when no odac-transition elements', () => {
+    beforeEach(() => setupMocks({hasViewTransition: true, transitionElements: []}))
+
+    test('should use fade path when API exists but no odac-transition elements found', () => {
+      jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
+      window.Odac.load('/page', jest.fn())
+
+      expect(mockDocument.startViewTransition).not.toHaveBeenCalled()
+      expect(mockXhr.send).toHaveBeenCalled()
+    })
+  })
+
+  describe('title HTML entity decoding', () => {
+    beforeEach(() => setupMocks({hasViewTransition: false}))
+
+    test('should decode HTML entities in title during fade navigation', () => {
+      jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
+      mockXhr.responseURL = 'http://localhost/products'
+      mockXhr.getResponseHeader.mockImplementation(h => (h === 'Content-Type' ? 'application/json' : null))
+
+      window.Odac.load('/products', jest.fn())
+
+      mockXhr.responseText = JSON.stringify({title: 'Tom &amp; Jerry', output: {}})
+      mockXhr.status = 200
+      mockXhr.onload()
+
+      expect(mockDocument.title).toBe('Tom & Jerry')
+    })
+
+    test('should decode multiple HTML entities in title', () => {
+      jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
+      mockXhr.responseURL = 'http://localhost/page'
+      mockXhr.getResponseHeader.mockImplementation(h => (h === 'Content-Type' ? 'application/json' : null))
+
+      window.Odac.load('/page', jest.fn())
+
+      mockXhr.responseText = JSON.stringify({title: '&lt;ODAC&gt; &amp; &quot;Framework&quot;', output: {}})
+      mockXhr.status = 200
+      mockXhr.onload()
+
+      expect(mockDocument.title).toBe('<ODAC> & "Framework"')
+    })
+
+    test('should handle title without entities unchanged', () => {
+      jest.spyOn(window.Odac, 'token').mockReturnValue('mock-token')
+      mockXhr.responseURL = 'http://localhost/simple'
+      mockXhr.getResponseHeader.mockImplementation(h => (h === 'Content-Type' ? 'application/json' : null))
+
+      window.Odac.load('/simple', jest.fn())
+
+      mockXhr.responseText = JSON.stringify({title: 'Simple Page Title', output: {}})
+      mockXhr.status = 200
+      mockXhr.onload()
+
+      expect(mockDocument.title).toBe('Simple Page Title')
+    })
+  })
+})

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

@@ -6,6 +6,10 @@ jest.mock(
       mockKnex(...args)
 )
 
+jest.mock('mysql2', () => ({}), {virtual: true})
+jest.mock('pg', () => ({}), {virtual: true})
+jest.mock('sqlite3', () => ({}), {virtual: true})
+
 const {buildConnections} = require('../../../src/Database/ConnectionFactory')
 
 describe('ConnectionFactory.buildConnections()', () => {

package/test/View/parseOdacTag.test.js

@@ -0,0 +1,180 @@
+const fs = require('fs')
+const fsPromises = fs.promises
+const path = require('path')
+const View = require('../../src/View')
+
+const FIXTURE_DIR = path.resolve(__dirname, '_fixtures')
+
+/**
+ * Integration tests for the #parseOdacTag private method.
+ * Since #parseOdacTag is private, we test it indirectly through the
+ * full render pipeline by creating temporary .html view files,
+ * invoking View.print(), and asserting the rendered output.
+ */
+describe('View.#parseOdacTag()', () => {
+  let originalDir
+  let originalCwd
+
+  beforeAll(async () => {
+    await fsPromises.mkdir(path.join(FIXTURE_DIR, 'skeleton'), {recursive: true})
+    await fsPromises.mkdir(path.join(FIXTURE_DIR, 'view', 'content'), {recursive: true})
+  })
+
+  afterAll(async () => {
+    await fsPromises.rm(FIXTURE_DIR, {recursive: true, force: true})
+  })
+
+  beforeEach(() => {
+    originalDir = global.__dir
+    originalCwd = process.cwd()
+    global.__dir = FIXTURE_DIR
+    process.chdir(FIXTURE_DIR)
+
+    if (global.Odac?.View?.cache) {
+      global.Odac.View.cache = {}
+    }
+    if (global.Odac?.View?.skeletons) {
+      global.Odac.View.skeletons = {}
+    }
+
+    // Clear require cache for compiled templates
+    for (const key of Object.keys(require.cache)) {
+      if (key.includes('.cache')) {
+        delete require.cache[key]
+      }
+    }
+  })
+
+  afterEach(() => {
+    global.__dir = originalDir
+    process.chdir(originalCwd)
+  })
+
+  let testCounter = 0
+
+  /**
+   * Writes a view file, triggers render via print(), and captures output.
+   * Uses a unique filename per call to avoid cache collisions between tests.
+   * Returns the rendered HTML string.
+   */
+  async function renderTemplate(templateContent) {
+    const uniqueId = `test_${++testCounter}`
+    const viewFile = path.join(FIXTURE_DIR, 'view', 'content', `${uniqueId}.html`)
+    await fsPromises.writeFile(viewFile, templateContent, 'utf8')
+
+    const skeletonFile = path.join(FIXTURE_DIR, 'skeleton', 'main.html')
+    await fsPromises.writeFile(skeletonFile, '{{ CONTENT }}', 'utf8')
+
+    let capturedOutput = ''
+    const errors = []
+    const originalError = console.error
+    console.error = (...args) => errors.push(args.join(' '))
+
+    const mockOdac = {
+      Config: {debug: true},
+      Var: value => {
+        const str = value === null || value === undefined ? '' : String(value)
+        return {
+          html: () => str.replace(/[&<>"']/g, m => ({'&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'})[m])
+        }
+      },
+      Request: {
+        req: {url: '/test'},
+        res: {finished: false, headersSent: false},
+        isAjaxLoad: false,
+        ajaxLoad: [],
+        variables: {},
+        sharedData: {},
+        page: '',
+        get: () => '',
+        header: () => {},
+        end: output => {
+          capturedOutput = output
+        },
+        hasEarlyHints: () => false,
+        setEarlyHints: () => {}
+      },
+      Lang: {
+        get: (...args) => args[0]
+      },
+      View: {}
+    }
+
+    try {
+      const view = new View(mockOdac)
+      view.skeleton('main')
+      view.set('content', uniqueId)
+      await view.print()
+    } finally {
+      console.error = originalError
+    }
+
+    if (errors.length > 0) {
+      throw new Error(`Template render error: ${errors.join('\n')}`)
+    }
+
+    return capturedOutput
+  }
+
+  describe('single quote escaping in <odac> tags', () => {
+    it('should render a single quote inside <odac> without syntax error', async () => {
+      const result = await renderTemplate("<odac>'</odac>")
+      // Single quotes are HTML-escaped by Odac.Var().html()
+      expect(result).toContain('&#39;')
+    })
+
+    it('should render text with embedded single quotes', async () => {
+      const result = await renderTemplate("<odac>it's working</odac>")
+      expect(result).toContain('it&#39;s working')
+    })
+
+    it('should render multiple single quotes', async () => {
+      const result = await renderTemplate("<odac>it's a developer's life</odac>")
+      expect(result).toContain('it&#39;s a developer&#39;s life')
+    })
+
+    it('should render escaped apostrophe in translation tags', async () => {
+      const result = await renderTemplate("<odac t>it's translated</odac>")
+      expect(result).toContain('it&#39;s translated')
+    })
+  })
+
+  describe('basic <odac> tag rendering', () => {
+    it('should render plain text inside <odac> tags', async () => {
+      const result = await renderTemplate('<odac>hello world</odac>')
+      expect(result).toContain('hello world')
+    })
+
+    it('should strip backend comments (multi-line)', async () => {
+      const result = await renderTemplate('visible<!--odac hidden odac-->visible2')
+      expect(result).toContain('visible')
+      expect(result).toContain('visible2')
+      expect(result).not.toContain('hidden')
+    })
+
+    it('should strip backend comments (single-line)', async () => {
+      const result = await renderTemplate('visible<!--odac hidden -->visible2')
+      expect(result).toContain('visible')
+      expect(result).toContain('visible2')
+      expect(result).not.toContain('hidden')
+    })
+
+    it('should handle empty <odac> tags gracefully', async () => {
+      const result = await renderTemplate('<odac></odac>')
+      expect(typeof result).toBe('string')
+    })
+  })
+
+  describe('special characters in <odac> tags', () => {
+    it('should handle double quotes inside <odac> tags', async () => {
+      const result = await renderTemplate('<odac>say "hello"</odac>')
+      expect(result).toContain('say')
+    })
+
+    it('should handle angle brackets in text (HTML entities)', async () => {
+      const result = await renderTemplate('<odac>&lt;div&gt;</odac>')
+      // Already-escaped entities get double-escaped by Odac.Var().html()
+      expect(result).toContain('&amp;lt;div&amp;gt;')
+    })
+  })
+})