|
|
@@ -0,0 +1,420 @@
|
|
|
+import test from 'node:test'
|
|
|
+import assert from 'node:assert/strict'
|
|
|
+import { readFile } from 'node:fs/promises'
|
|
|
+import { createVideoPlayer } from '../../src/modules/cockpit/services/videoPlayer.js'
|
|
|
+
|
|
|
+const settle = () => new Promise((resolve) => setImmediate(resolve))
|
|
|
+const offerSdp = 'v=0\r\no=- 1 1 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\nm=video 9 UDP/TLS/RTP/SAVPF 96\r\na=recvonly\r\n'
|
|
|
+const answerSdp = 'v=0\r\no=- 2 2 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\nm=video 9 UDP/TLS/RTP/SAVPF 96\r\na=sendonly\r\n'
|
|
|
+const signalingUrl = 'https://media.test/index/api/webrtc?app=rtp&stream=camera%2F01&type=play'
|
|
|
+const answer = () => new Response(JSON.stringify({ code: 0, type: 'answer', sdp: answerSdp }), {
|
|
|
+ headers: { 'Content-Type': 'application/json' },
|
|
|
+})
|
|
|
+
|
|
|
+class Peer extends EventTarget {
|
|
|
+ static instances = []
|
|
|
+ constructor(configuration) {
|
|
|
+ super()
|
|
|
+ this.configuration = configuration
|
|
|
+ this.iceGatheringState = 'new'
|
|
|
+ this.connectionState = 'new'
|
|
|
+ this.receivers = []
|
|
|
+ this.transceivers = []
|
|
|
+ Peer.instances.push(this)
|
|
|
+ }
|
|
|
+ addTransceiver(kind, options) { this.transceivers.push({ kind, ...options }) }
|
|
|
+ async createOffer() { return { type: 'offer', sdp: offerSdp } }
|
|
|
+ async setLocalDescription(description) { this.localDescription = description; this.iceGatheringState = 'gathering' }
|
|
|
+ async setRemoteDescription(description) { this.remoteDescription = description }
|
|
|
+ gather() {
|
|
|
+ this.localDescription = { type: 'offer', sdp: offerSdp + 'a=candidate:1 1 udp 1 192.0.2.1 5000 typ host\r\n' }
|
|
|
+ this.iceGatheringState = 'complete'
|
|
|
+ this.dispatchEvent(new Event('icegatheringstatechange'))
|
|
|
+ }
|
|
|
+ receive(track, streamless = false) {
|
|
|
+ this.receivers.push({ track })
|
|
|
+ const stream = { getTracks: () => [track] }
|
|
|
+ this.dispatchEvent(Object.assign(new Event('track'), { track, streams: streamless ? [] : [stream] }))
|
|
|
+ return stream
|
|
|
+ }
|
|
|
+ getReceivers() { return this.receivers }
|
|
|
+ close() { this.connectionState = 'closed' }
|
|
|
+}
|
|
|
+
|
|
|
+class Clock {
|
|
|
+ now = 0
|
|
|
+ next = 1
|
|
|
+ tasks = new Map()
|
|
|
+ setTimeout(callback, delay) { const id = this.next++; this.tasks.set(id, { at: this.now + delay, callback }); return id }
|
|
|
+ clearTimeout(id) { this.tasks.delete(id) }
|
|
|
+ advance(ms) {
|
|
|
+ const end = this.now + ms
|
|
|
+ while (true) {
|
|
|
+ const entry = [...this.tasks].sort((a, b) => a[1].at - b[1].at).find(([, item]) => item.at <= end)
|
|
|
+ if (!entry) break
|
|
|
+ const [id, item] = entry
|
|
|
+ this.tasks.delete(id); this.now = item.at; item.callback()
|
|
|
+ }
|
|
|
+ this.now = end
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+class Track extends EventTarget {
|
|
|
+ kind = 'video'
|
|
|
+ readyState = 'live'
|
|
|
+ stop() { this.readyState = 'ended' }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+class Video extends EventTarget {
|
|
|
+ constructor(protocol = 'https:') {
|
|
|
+ super()
|
|
|
+ this.ownerDocument = { location: { protocol } }
|
|
|
+ this.attributes = new Map()
|
|
|
+ this.srcObject = null
|
|
|
+ this.paused = true
|
|
|
+ this.loads = 0
|
|
|
+ }
|
|
|
+ set src(value) { this.setAttribute('src', value) }
|
|
|
+ get src() { return this.getAttribute('src') || '' }
|
|
|
+ setAttribute(name, value) { this.attributes.set(name, String(value)) }
|
|
|
+ getAttribute(name) { return this.attributes.get(name) ?? null }
|
|
|
+ removeAttribute(name) { this.attributes.delete(name) }
|
|
|
+ play() { this.paused = false; return Promise.resolve() }
|
|
|
+ pause() { this.paused = true }
|
|
|
+ load() { this.loads++ }
|
|
|
+ fire(type) { this.dispatchEvent(new Event(type)) }
|
|
|
+}
|
|
|
+
|
|
|
+// 已确认接缝：真实driver + HTMLMediaElement/Peer/HTTP/时钟的外部边界替身。
|
|
|
+// 只观察媒体元素、回调、信令合同与本地资源释放，不读取driver私有状态。
|
|
|
+test('原生视频仅在playing后就绪，销毁时清空媒体且不再报告迟到事件', async () => {
|
|
|
+ const video = new Video()
|
|
|
+ const ready = [], errors = []
|
|
|
+ const player = createVideoPlayer(video, { kind: 'native', url: 'https://media.test/live.mp4' }, {
|
|
|
+ onReady: () => ready.push('画面就绪'), onError: (error) => errors.push(error),
|
|
|
+ })
|
|
|
+ await settle()
|
|
|
+ assert.equal(video.src, 'https://media.test/live.mp4')
|
|
|
+ assert.equal(video.muted, true)
|
|
|
+ video.fire('loadedmetadata')
|
|
|
+ assert.deepEqual(ready, [])
|
|
|
+ video.fire('playing')
|
|
|
+ assert.deepEqual(ready, ['画面就绪'])
|
|
|
+ player.destroy()
|
|
|
+ player.destroy()
|
|
|
+ assert.equal(video.src, '')
|
|
|
+ assert.equal(video.srcObject, null)
|
|
|
+ assert.equal(video.paused, true)
|
|
|
+ video.fire('playing')
|
|
|
+ video.fire('error')
|
|
|
+ assert.deepEqual(ready, ['画面就绪'])
|
|
|
+ assert.deepEqual(errors, [])
|
|
|
+})
|
|
|
+
|
|
|
+test('协议、凭据、混合内容和非原生媒体地址在触达媒体前被拒绝', async () => {
|
|
|
+ const invalid = [
|
|
|
+ { kind: 'native', url: 'javascript:alert(1)' },
|
|
|
+ { kind: 'native', url: 'webrtc://media.test/live' },
|
|
|
+ { kind: 'native', url: '/live.mp4' },
|
|
|
+ { kind: 'native', url: 'https://user:secret@media.test/live.mp4' },
|
|
|
+ { kind: 'native', url: 'http://media.test/live.mp4' },
|
|
|
+ { kind: 'native', url: 'https://media.test/live.flv?token=secret' },
|
|
|
+ { kind: 'native', url: 'https://media.test/index/api/webrtc?app=live&type=play' },
|
|
|
+ { kind: 'unknown', url: 'https://media.test/live.mp4' },
|
|
|
+ ]
|
|
|
+ for (const media of invalid) {
|
|
|
+ const video = new Video(), errors = []
|
|
|
+ const player = createVideoPlayer(video, media, { onError: (error) => errors.push(error) })
|
|
|
+ await settle()
|
|
|
+ assert.equal(video.src, '')
|
|
|
+ assert.equal(errors.length, 1)
|
|
|
+ assert.equal(errors[0].code, 'VIDEO_URL_INVALID')
|
|
|
+ assert.doesNotMatch(errors[0].message, /secret|media\.test/)
|
|
|
+ player.destroy()
|
|
|
+ }
|
|
|
+})
|
|
|
+
|
|
|
+test('WebRTC收集ICE后发送实际ZLM SDP，接收轨道且playing才就绪', async () => {
|
|
|
+ const video = new Video(), requests = [], ready = [], errors = []
|
|
|
+ const player = createVideoPlayer(video, { kind: 'webrtc', url: signalingUrl }, {
|
|
|
+ PeerConnection: Peer,
|
|
|
+ fetchImpl: async (url, init) => { requests.push({ url, ...init }); return answer() },
|
|
|
+ onReady: () => ready.push('已播放'), onError: (error) => errors.push(error),
|
|
|
+ })
|
|
|
+ await settle()
|
|
|
+ const peer = Peer.instances.at(-1)
|
|
|
+ assert.ok(peer, '通过浏览器Peer边界建立连接')
|
|
|
+ assert.deepEqual(peer.configuration?.iceServers || [], [])
|
|
|
+ assert.deepEqual(peer.transceivers, [{ kind: 'video', direction: 'recvonly' }, { kind: 'audio', direction: 'recvonly' }])
|
|
|
+ assert.equal(requests.length, 0, '不提交尚未收集完的offer')
|
|
|
+ assert.equal(video.src, '', '信令地址不得进入video src')
|
|
|
+ peer.gather()
|
|
|
+ await settle()
|
|
|
+ assert.equal(requests.length, 1)
|
|
|
+ assert.equal(requests[0].url, signalingUrl)
|
|
|
+ assert.equal(requests[0].method, 'POST')
|
|
|
+ assert.equal(new Headers(requests[0].headers).get('content-type'), 'text/plain')
|
|
|
+ assert.equal(new Headers(requests[0].headers).get('authorization'), null)
|
|
|
+ assert.equal(requests[0].credentials, 'omit')
|
|
|
+ assert.equal(requests[0].redirect, 'error')
|
|
|
+ assert.match(requests[0].body, /a=candidate:1/)
|
|
|
+ assert.deepEqual(peer.remoteDescription, { type: 'answer', sdp: answerSdp })
|
|
|
+ const track = new Track(), stream = peer.receive(track)
|
|
|
+ await settle()
|
|
|
+ assert.equal(video.srcObject, stream)
|
|
|
+ assert.deepEqual(ready, [])
|
|
|
+ video.fire('playing')
|
|
|
+ assert.deepEqual(ready, ['已播放'])
|
|
|
+ player.destroy()
|
|
|
+ assert.equal(peer.connectionState, 'closed')
|
|
|
+ assert.equal(track.readyState, 'ended')
|
|
|
+ assert.equal(video.srcObject, null)
|
|
|
+ assert.deepEqual(errors, [])
|
|
|
+ assert.equal(requests.length, 1, '本地销毁不调用后端stop或重连')
|
|
|
+})
|
|
|
+
|
|
|
+test('ICE收集最多等待5秒，超时关闭Peer且不发出不完整信令', async () => {
|
|
|
+ const video = new Video(), clock = new Clock(), errors = [], requests = []
|
|
|
+ const player = createVideoPlayer(video, { kind: 'webrtc', url: signalingUrl }, {
|
|
|
+ PeerConnection: Peer, timers: clock,
|
|
|
+ fetchImpl: async (...args) => { requests.push(args); return answer() },
|
|
|
+ onError: (error) => errors.push(error),
|
|
|
+ })
|
|
|
+ await settle()
|
|
|
+ const peer = Peer.instances.at(-1)
|
|
|
+ clock.advance(4999)
|
|
|
+ assert.equal(errors.length, 0)
|
|
|
+ clock.advance(1)
|
|
|
+ await settle()
|
|
|
+ assert.equal(errors.length, 1)
|
|
|
+ assert.equal(errors[0].code, 'VIDEO_ICE_TIMEOUT')
|
|
|
+ assert.equal(peer.connectionState, 'closed')
|
|
|
+ assert.deepEqual(requests, [])
|
|
|
+ player.destroy()
|
|
|
+})
|
|
|
+
|
|
|
+test('媒体错误、轨道结束与Peer断流会释放本地资源并只报一次失败', async () => {
|
|
|
+ for (const failure of ['video-error', 'video-ended', 'track-ended', 'peer-failed', 'peer-disconnected', 'ice-failed']) {
|
|
|
+ const video = new Video(), errors = [], ready = [], requests = []
|
|
|
+ const player = createVideoPlayer(video, { kind: 'webrtc', url: signalingUrl }, {
|
|
|
+ PeerConnection: Peer,
|
|
|
+ fetchImpl: async (...args) => { requests.push(args); return answer() },
|
|
|
+ onError: (error) => errors.push(error), onReady: () => ready.push('已播放'),
|
|
|
+ })
|
|
|
+ await settle()
|
|
|
+ const peer = Peer.instances.at(-1)
|
|
|
+ peer.gather(); await settle()
|
|
|
+ const track = new Track()
|
|
|
+ peer.receive(track); await settle()
|
|
|
+ video.fire('playing')
|
|
|
+ if (failure.startsWith('video-')) video.fire(failure.slice(6))
|
|
|
+ if (failure === 'track-ended') track.dispatchEvent(new Event('ended'))
|
|
|
+ if (failure.startsWith('peer-')) {
|
|
|
+ peer.connectionState = failure.slice(5)
|
|
|
+ peer.dispatchEvent(new Event('connectionstatechange'))
|
|
|
+ }
|
|
|
+ if (failure === 'ice-failed') {
|
|
|
+ peer.iceConnectionState = 'failed'
|
|
|
+ peer.dispatchEvent(new Event('iceconnectionstatechange'))
|
|
|
+ }
|
|
|
+ await settle()
|
|
|
+ assert.equal(errors.length, 1, failure)
|
|
|
+ assert.equal(peer.connectionState, 'closed', failure)
|
|
|
+ assert.equal(track.readyState, 'ended', failure)
|
|
|
+ assert.equal(video.srcObject, null, failure)
|
|
|
+ video.fire('error'); video.fire('playing')
|
|
|
+ assert.equal(errors.length, 1)
|
|
|
+ assert.deepEqual(ready, ['已播放'])
|
|
|
+ assert.equal(requests.length, 1)
|
|
|
+ player.destroy()
|
|
|
+ }
|
|
|
+})
|
|
|
+
|
|
|
+test('销毁中的ICE和迟到信令不会再挂轨道、报就绪或请求后端停止', async () => {
|
|
|
+ const clock = new Clock(), errors = [], requests = []
|
|
|
+ const first = createVideoPlayer(new Video(), { kind: 'webrtc', url: signalingUrl }, {
|
|
|
+ PeerConnection: Peer, timers: clock, onError: (error) => errors.push(error),
|
|
|
+ fetchImpl: async (...args) => { requests.push(args); return answer() },
|
|
|
+ })
|
|
|
+ await settle()
|
|
|
+ const waiting = Peer.instances.at(-1)
|
|
|
+ first.destroy(); clock.advance(10000); waiting.gather(); await settle()
|
|
|
+ assert.equal(waiting.connectionState, 'closed')
|
|
|
+ assert.equal(requests.length, 0)
|
|
|
+ assert.equal(errors.length, 0)
|
|
|
+
|
|
|
+ const video = new Video(), ready = []
|
|
|
+ let resolveResponse
|
|
|
+ const response = new Promise((resolve) => { resolveResponse = resolve })
|
|
|
+ const second = createVideoPlayer(video, { kind: 'webrtc', url: signalingUrl }, {
|
|
|
+ PeerConnection: Peer, onReady: () => ready.push(true), onError: (error) => errors.push(error),
|
|
|
+ fetchImpl: (url, init) => { requests.push({ url, ...init }); return response },
|
|
|
+ })
|
|
|
+ await settle()
|
|
|
+ const peer = Peer.instances.at(-1)
|
|
|
+ peer.gather(); await settle()
|
|
|
+ assert.equal(requests.length, 1)
|
|
|
+ second.destroy()
|
|
|
+ assert.equal(requests[0].signal.aborted, true)
|
|
|
+ resolveResponse(answer()); await settle()
|
|
|
+ assert.equal(peer.remoteDescription, undefined)
|
|
|
+ assert.equal(video.srcObject, null)
|
|
|
+ video.fire('playing')
|
|
|
+ assert.deepEqual(ready, [])
|
|
|
+ assert.deepEqual(errors, [])
|
|
|
+ assert.equal(requests.length, 1)
|
|
|
+})
|
|
|
+
|
|
|
+test('HTML、非成功信令与非法answer不被视作可播放媒体', async () => {
|
|
|
+ const responses = [
|
|
|
+ () => new Response('<html>secret</html>', { headers: { 'Content-Type': 'text/html' } }),
|
|
|
+ () => new Response('upstream secret', { status: 502 }),
|
|
|
+ () => new Response(JSON.stringify({ code: 1, msg: 'secret' }), { headers: { 'Content-Type': 'application/json' } }),
|
|
|
+ () => new Response(JSON.stringify({ code: 0, type: 'offer', sdp: answerSdp }), { headers: { 'Content-Type': 'application/json' } }),
|
|
|
+ () => new Response(JSON.stringify({ code: 0, type: 'answer', sdp: '<html>secret</html>' }), { headers: { 'Content-Type': 'application/json' } }),
|
|
|
+ () => new Response('null', { headers: { 'Content-Type': 'application/json' } }),
|
|
|
+ () => { throw new Error('upstream secret at https://media.test/token') },
|
|
|
+ ]
|
|
|
+ for (const response of responses) {
|
|
|
+ const video = new Video(), errors = [], ready = []
|
|
|
+ const player = createVideoPlayer(video, { kind: 'webrtc', url: signalingUrl }, {
|
|
|
+ PeerConnection: Peer, fetchImpl: async () => response(),
|
|
|
+ onError: (error) => errors.push(error), onReady: () => ready.push(true),
|
|
|
+ })
|
|
|
+ await settle()
|
|
|
+ const peer = Peer.instances.at(-1)
|
|
|
+ peer.gather(); await settle()
|
|
|
+ assert.equal(errors.length, 1)
|
|
|
+ assert.equal(errors[0].code, 'VIDEO_SIGNALING_FAILED')
|
|
|
+ assert.doesNotMatch(errors[0].message, /secret|media\.test|token/)
|
|
|
+ assert.equal(peer.remoteDescription, undefined)
|
|
|
+ assert.equal(peer.connectionState, 'closed')
|
|
|
+ assert.equal(video.src, '')
|
|
|
+ assert.deepEqual(ready, [])
|
|
|
+ player.destroy()
|
|
|
+ }
|
|
|
+})
|
|
|
+
|
|
|
+test('原生播放拒绝和缺失WebRTC能力均返回可清理的失败而非伪就绪', async () => {
|
|
|
+ const video = new Video(), errors = [], ready = []
|
|
|
+ video.play = () => Promise.reject(new Error('autoplay secret'))
|
|
|
+ const player = createVideoPlayer(video, { kind: 'native', url: 'https://media.test/live.mp4' }, {
|
|
|
+ onError: (error) => errors.push(error), onReady: () => ready.push(true),
|
|
|
+ })
|
|
|
+ await settle()
|
|
|
+ assert.equal(errors[0].code, 'VIDEO_PLAYBACK_FAILED')
|
|
|
+ assert.doesNotMatch(errors[0].message, /secret/)
|
|
|
+ assert.equal(video.src, '')
|
|
|
+ video.fire('playing')
|
|
|
+ assert.deepEqual(ready, [])
|
|
|
+ player.destroy()
|
|
|
+ const unsupported = createVideoPlayer(new Video(), { kind: 'webrtc', url: signalingUrl }, {
|
|
|
+ onError: (error) => errors.push(error),
|
|
|
+ })
|
|
|
+ await settle()
|
|
|
+ assert.equal(errors[1].code, 'VIDEO_UNSUPPORTED')
|
|
|
+ unsupported.destroy()
|
|
|
+})
|
|
|
+
|
|
|
+test('无关联stream的音视频轨道保留在同一媒体流，只有视频轨道可报画面就绪', async () => {
|
|
|
+ class MediaStream {
|
|
|
+ tracks = []
|
|
|
+ addTrack(track) { this.tracks.push(track) }
|
|
|
+ getTracks() { return this.tracks }
|
|
|
+ }
|
|
|
+ const video = new Video(), errors = [], ready = []
|
|
|
+ video.ownerDocument.defaultView = { MediaStream }
|
|
|
+ const player = createVideoPlayer(video, { kind: 'webrtc', url: signalingUrl }, {
|
|
|
+ PeerConnection: Peer, fetchImpl: async () => answer(),
|
|
|
+ onError: (error) => errors.push(error), onReady: () => ready.push('画面就绪'),
|
|
|
+ })
|
|
|
+ await settle()
|
|
|
+ const peer = Peer.instances.at(-1)
|
|
|
+ peer.gather(); await settle()
|
|
|
+ const audio = new Track(), picture = new Track()
|
|
|
+ audio.kind = 'audio'
|
|
|
+ peer.receive(audio, true); await settle()
|
|
|
+ assert.deepEqual(errors, [])
|
|
|
+ video.fire('playing')
|
|
|
+ assert.deepEqual(ready, [], '不能把只有音频当作视频画面就绪')
|
|
|
+ peer.receive(picture, true); await settle()
|
|
|
+ assert.deepEqual(video.srcObject.getTracks(), [audio, picture])
|
|
|
+ video.fire('playing')
|
|
|
+ assert.deepEqual(ready, ['画面就绪'])
|
|
|
+ player.destroy()
|
|
|
+ assert.equal(audio.readyState, 'ended')
|
|
|
+ assert.equal(picture.readyState, 'ended')
|
|
|
+})
|
|
|
+
|
|
|
+test('Vue播放器公开media与ready接缝可挂载，换媒体和卸载清理旧播放', async () => {
|
|
|
+ const { parseHTML } = await import('linkedom')
|
|
|
+ const { window } = parseHTML('<html><body><div id="host"></div></body></html>')
|
|
|
+ const previous = new Map()
|
|
|
+ for (const name of ['window', 'document', 'Element', 'HTMLElement', 'SVGElement']) {
|
|
|
+ previous.set(name, Object.getOwnPropertyDescriptor(globalThis, name))
|
|
|
+ Object.defineProperty(globalThis, name, { configurable: true, writable: true, value: window[name] })
|
|
|
+ }
|
|
|
+ // LinkeDOM不实现媒体播放；只在HTMLVideoElement外部边界提供播放/清理替身。
|
|
|
+ const createElement = window.document.createElement.bind(window.document)
|
|
|
+ window.document.createElement = (name, ...args) => {
|
|
|
+ const element = createElement(name, ...args)
|
|
|
+ if (name === 'video') {
|
|
|
+ Object.defineProperty(element, 'src', {
|
|
|
+ get: () => element.getAttribute('src') || '',
|
|
|
+ set: (value) => element.setAttribute('src', value),
|
|
|
+ })
|
|
|
+ element.play = () => Promise.resolve()
|
|
|
+ element.pause = () => { element.dataset.paused = 'true' }
|
|
|
+ element.load = () => {}
|
|
|
+ }
|
|
|
+ return element
|
|
|
+ }
|
|
|
+ let app
|
|
|
+ try {
|
|
|
+ const { parse, compileScript } = await import('@vue/compiler-sfc')
|
|
|
+ const file = new URL('../../src/modules/cockpit/components/VideoPlayer.vue', import.meta.url)
|
|
|
+ const { descriptor, errors: parseErrors } = parse(await readFile(file, 'utf8'), { filename: file.pathname })
|
|
|
+ assert.deepEqual(parseErrors, [])
|
|
|
+ const compiled = compileScript(descriptor, { id: 'player-test', inlineTemplate: true })
|
|
|
+ const code = compiled.content
|
|
|
+ .replace(/from ["']vue["']/g, `from ${JSON.stringify(import.meta.resolve('vue'))}`)
|
|
|
+ .replace(/from ["']\.\.\/services\/videoPlayer\.js["']/g,
|
|
|
+ `from ${JSON.stringify(new URL('../../src/modules/cockpit/services/videoPlayer.js', import.meta.url).href)}`)
|
|
|
+ const { default: Component } = await import(`data:text/javascript;base64,${Buffer.from(code).toString('base64')}`)
|
|
|
+ const { createApp, h, shallowRef, nextTick } = await import('vue')
|
|
|
+ const media = shallowRef({ kind: 'native', url: 'https://media.test/first.mp4' })
|
|
|
+ const ready = [], errors = []
|
|
|
+ app = createApp({ render: () => h(Component, {
|
|
|
+ media: media.value, onReady: () => ready.push('ready'), onError: (error) => errors.push(error),
|
|
|
+ }) })
|
|
|
+ app.mount(window.document.querySelector('#host'))
|
|
|
+ await nextTick(); await settle()
|
|
|
+ const video = window.document.querySelector('video')
|
|
|
+ assert.ok(video)
|
|
|
+ assert.equal(video.src, 'https://media.test/first.mp4')
|
|
|
+ assert.equal(video.hasAttribute('controls'), true)
|
|
|
+ assert.match(video.getAttribute('controlslist'), /nodownload/)
|
|
|
+ assert.equal(video.hasAttribute('disablepictureinpicture'), true)
|
|
|
+ assert.equal(video.hasAttribute('disableremoteplayback'), true)
|
|
|
+ video.dispatchEvent(new window.Event('playing'))
|
|
|
+ assert.deepEqual(ready, ['ready'])
|
|
|
+ media.value = { kind: 'native', url: 'https://media.test/second.mp4' }
|
|
|
+ await nextTick(); await settle()
|
|
|
+ assert.equal(video.src, 'https://media.test/second.mp4')
|
|
|
+ assert.equal(video.dataset.paused, 'true')
|
|
|
+ video.dispatchEvent(new window.Event('playing'))
|
|
|
+ assert.deepEqual(ready, ['ready', 'ready'])
|
|
|
+ app.unmount(); app = null
|
|
|
+ assert.equal(video.getAttribute('src'), null)
|
|
|
+ video.dispatchEvent(new window.Event('playing'))
|
|
|
+ assert.deepEqual(ready, ['ready', 'ready'])
|
|
|
+ assert.deepEqual(errors, [])
|
|
|
+ } finally {
|
|
|
+ app?.unmount()
|
|
|
+ for (const [name, descriptor] of previous) {
|
|
|
+ if (descriptor) Object.defineProperty(globalThis, name, descriptor)
|
|
|
+ else delete globalThis[name]
|
|
|
+ }
|
|
|
+ }
|
|
|
+})
|
