test(ads): [PKG-ADS-02] cover legacy timing and real media contracts

test/helpers/ads.js

@@ -0,0 +1,216 @@
+import assert from 'node:assert/strict'
+import { execFileSync } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+import vm from 'node:vm'
+import validator from 'option-validator'
+import { ensureArchive, hash, readMember } from '../../refactor/scripts/releases.mjs'
+import { loadPackage } from './load.js'
+
+function commonJS(bytes) {
+  const module = { exports: {} }
+  vm.runInNewContext(bytes.toString(), {
+    module,
+    exports: module.exports,
+    get document() { return globalThis.document },
+    get window() { return globalThis.window },
+    setTimeout: (...args) => globalThis.setTimeout(...args),
+    clearTimeout: id => globalThis.clearTimeout(id),
+    console,
+  }, { timeout: 5000 })
+  return module.exports.default || module.exports
+}
+
+export async function adsImplementations() {
+  const baseline = JSON.parse(fs.readFileSync(new URL('../../refactor/baselines/ads-release.json', import.meta.url)))
+  const archive = await ensureArchive(baseline.release)
+  const member = `package/${baseline.release.manifest.main}`
+  const bytes = readMember(archive, member)
+  assert.equal(hash(bytes), baseline.release.files[member])
+  const file = 'packages/artplayer-plugin-ads/dist/artplayer-plugin-ads.js'
+  const historical = execFileSync('git', ['show', `${baseline.sourceCommit}:${file}`])
+  assert.equal(hash(historical.toString().replaceAll('\r\n', '\n')), baseline.source[file])
+  const implementations = [
+    { name: 'source', factory: (await loadPackage('artplayer-plugin-ads')).default },
+    { name: 'published-1.0.6', historical: true, factory: commonJS(bytes) },
+    { name: 'frozen-workspace-2.1.0', historical: true, factory: commonJS(historical) },
+  ]
+  for (const file of (process.env.ARTPLAYER_TEST_ADS || '').split(path.delimiter).filter(Boolean)) {
+    const bytes = fs.readFileSync(file)
+    const factory = file.endsWith('.mjs') ? (await import(`data:text/javascript;base64,${bytes.toString('base64')}`)).default : commonJS(bytes)
+    implementations.push({ name: `artifact-${path.basename(file)}`, factory })
+  }
+  return implementations
+}
+
+// Intent fixture only: these nodes do not model layout, HTML parsing or media decoding.
+export function adsEnvironment(t) {
+  const document = Object.assign(new EventTarget(), { hidden: false })
+  const opened = []
+  for (const [name, value] of Object.entries({ document, window: { open: url => opened.push(url) } })) {
+    const previous = Object.getOwnPropertyDescriptor(globalThis, name)
+    Object.defineProperty(globalThis, name, { configurable: true, value })
+    t.after(() => previous ? Object.defineProperty(globalThis, name, previous) : Reflect.deleteProperty(globalThis, name))
+  }
+  const timers = new Map()
+  let nextId = 0
+  let now = 0
+  t.mock.method(globalThis, 'setTimeout', (callback, delay) => {
+    const id = ++nextId
+    timers.set(id, { callback, at: now + Number(delay) })
+    return id
+  })
+  t.mock.method(globalThis, 'clearTimeout', id => timers.delete(id))
+  t.mock.method(Date, 'now', () => now)
+  function tick(milliseconds) {
+    const end = now + milliseconds
+    let steps = 0
+    while (true) {
+      const entry = [...timers].sort((a, b) => a[1].at - b[1].at)[0]
+      if (!entry || entry[1].at > end)
+        break
+      assert(++steps < 10000, 'Unexpected endless timer chain')
+      const [id, timer] = entry
+      timers.delete(id)
+      now = timer.at
+      timer.callback()
+    }
+    now = end
+  }
+  function host() {
+    const calls = []
+    const listeners = new Map()
+    const proxies = []
+    const nodes = new Map()
+    let normalized
+    class Node extends EventTarget {
+      constructor(tag = 'div', className = '', html = '') {
+        super()
+        this.tagName = tag.toUpperCase()
+        this.className = className
+        this.innerHTML = html
+        this.style = {}
+        this.children = []
+        this.muted = false
+        this.paused = true
+        this.ownerDocument = document
+        if (className)
+          nodes.set(className, this)
+      }
+
+      play() {
+        calls.push(['ad.play'])
+        this.paused = false
+        return Promise.resolve()
+      }
+
+      pause() {
+        calls.push(['ad.pause'])
+        this.paused = true
+      }
+    }
+    const prefix = 'artplayer-plugin-ads'
+    function append(parent, value) {
+      if (typeof value !== 'string') {
+        parent.children.push(value)
+        return value
+      }
+      const match = value.match(/^<(\w+)\s[^>]*class="([^"]*)"[^>]*>([\s\S]*)<\/\w+>$/)
+      assert(match, 'Extend the fixture for a new wrapper; do not claim a real HTML parser')
+      const [, tag, className, inner] = match
+      const node = new Node(tag, className, inner)
+      parent.children.push(node)
+      for (const child of inner.matchAll(/<div class="([^"]+)"[^>]*>([\s\S]*?)<\/div>/g))
+        node.children.push(new Node('div', child[1], child[2]))
+      return node
+    }
+    const art = {
+      template: { $player: new Node() },
+      icons: Object.fromEntries(['volume', 'volumeClose', 'fullscreenOn', 'fullscreenOff', 'loading'].map(name => [name, new Node('span', name)])),
+      constructor: {
+        version: '5.4.1',
+        validator(value, schema) {
+          normalized = validator(value, schema)
+          return normalized
+        },
+        utils: {
+          append,
+          query: (selector, parent) => parent.children.find(child => child.className === selector.slice(1)),
+          setStyle(node, name, value) {
+            calls.push(['style', node?.className, name, value])
+            node.style[name] = value
+          },
+          errorHandle(condition, message) {
+            if (!condition)
+              throw new Error(message)
+          },
+        },
+      },
+      playing: false,
+      fullscreen: false,
+      isDestroy: false,
+      on(name, callback) {
+        if (!listeners.has(name))
+          listeners.set(name, new Set())
+        listeners.get(name).add(callback)
+        return art
+      },
+      off(name, callback) {
+        listeners.get(name)?.delete(callback)
+        return art
+      },
+      once(name, callback) {
+        const once = (...args) => {
+          art.off(name, once)
+          callback(...args)
+        }
+        return art.on(name, once)
+      },
+      emit(name, ...args) {
+        calls.push(['emit', name, ...args])
+        for (const callback of [...(listeners.get(name) || [])]) callback(...args)
+        return art
+      },
+      proxy(target, name, callback) {
+        target.addEventListener(name, callback)
+        const off = () => target.removeEventListener(name, callback)
+        proxies.push(off)
+        return off
+      },
+      play() {
+        calls.push(['content.play', art.isDestroy])
+        art.playing = true
+        art.emit('play')
+        return Promise.resolve()
+      },
+      pause() {
+        calls.push(['content.pause'])
+        art.playing = false
+        art.emit('pause')
+      },
+      destroy() {
+        art.isDestroy = true
+        art.emit('destroy')
+        proxies.splice(0).forEach(off => off())
+        listeners.clear()
+      },
+    }
+    return {
+      art,
+      nodes,
+      calls,
+      listeners,
+      get normalized() { return normalized },
+      node: suffix => nodes.get(suffix ? `${prefix}-${suffix}` : prefix),
+      start() { art.emit('ready').emit('play') },
+      fire(suffix, name) { nodes.get(`${prefix}-${suffix}`).dispatchEvent(new Event(name)) },
+      visibility(hidden) {
+        document.hidden = hidden
+        document.dispatchEvent(new Event('visibilitychange'))
+        art.emit('document:visibilitychange')
+      },
+    }
+  }
+  return { host, tick, timers, document, opened }
+}