1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 | import videojs from 'video.js';
|
12 | import '../../examples/basic-ad-plugin/example-plugin.js';
|
13 | import QUnit from 'qunit';
|
14 | import document from 'global/document';
|
15 |
|
16 | QUnit.module('Events and Prerolls', {
|
17 | beforeEach() {
|
18 | this.video = document.createElement('video');
|
19 |
|
20 | this.fixture = document.querySelector('#qunit-fixture');
|
21 | this.fixture.appendChild(this.video);
|
22 |
|
23 | this.player = videojs(this.video);
|
24 |
|
25 | this.player.exampleAds({
|
26 | adServerUrl: '/test/integration/lib/inventory.json'
|
27 | });
|
28 |
|
29 | this.player.src({
|
30 | src: 'http://vjs.zencdn.net/v/oceans.webm',
|
31 | type: 'video/webm'
|
32 | });
|
33 |
|
34 |
|
35 | this.player.muted(true);
|
36 | },
|
37 |
|
38 | afterEach() {
|
39 | this.player.dispose();
|
40 | }
|
41 | });
|
42 |
|
43 | QUnit.test('playing event and prerolls: 0 before preroll, 1+ after', function(assert) {
|
44 | const done = assert.async();
|
45 |
|
46 | let beforePreroll = true;
|
47 | let playingBeforePreroll = 0;
|
48 | let playingAfterPreroll = 0;
|
49 |
|
50 | this.player.on('adend', () => {
|
51 | beforePreroll = false;
|
52 | });
|
53 |
|
54 | this.player.on('playing', () => {
|
55 | if (beforePreroll) {
|
56 | playingBeforePreroll++;
|
57 | } else {
|
58 | playingAfterPreroll++;
|
59 | }
|
60 | });
|
61 |
|
62 | this.player.on(['error', 'aderror'], () => {
|
63 | assert.ok(false, 'no errors');
|
64 | done();
|
65 | });
|
66 |
|
67 | this.player.on('timeupdate', () => {
|
68 | if (this.player.currentTime() > 1) {
|
69 | assert.equal(playingBeforePreroll, 0, 'no playing before preroll');
|
70 | assert.ok(playingAfterPreroll > 0, 'playing after preroll');
|
71 | done();
|
72 | }
|
73 | });
|
74 |
|
75 | this.player.ready(this.player.play);
|
76 |
|
77 | });
|
78 |
|
79 | QUnit.test('ended event and prerolls: not even once', function(assert) {
|
80 | const done = assert.async();
|
81 |
|
82 | let ended = 0;
|
83 |
|
84 | this.player.on('ended', () => {
|
85 | ended++;
|
86 | });
|
87 |
|
88 | this.player.on(['error', 'aderror'], () => {
|
89 | assert.ok(false, 'no errors');
|
90 | done();
|
91 | });
|
92 |
|
93 | this.player.on('timeupdate', () => {
|
94 | if (this.player.currentTime() > 1) {
|
95 | assert.equal(ended, 0, 'no ended events');
|
96 | done();
|
97 | }
|
98 | });
|
99 |
|
100 | this.player.ready(this.player.play);
|
101 |
|
102 | });
|
103 |
|
104 | QUnit.test('loadstart event and prerolls: 1 before preroll, 0 after', function(assert) {
|
105 | const done = assert.async();
|
106 |
|
107 | let beforePreroll = true;
|
108 | let loadstartBeforePreroll = 0;
|
109 | let loadstartAfterPreroll = 0;
|
110 |
|
111 | this.player.on('adend', () => {
|
112 | beforePreroll = false;
|
113 | });
|
114 |
|
115 | this.player.on('loadstart', (e) => {
|
116 | if (beforePreroll) {
|
117 | loadstartBeforePreroll++;
|
118 | } else {
|
119 | loadstartAfterPreroll++;
|
120 | }
|
121 | });
|
122 |
|
123 | this.player.on(['error', 'aderror'], () => {
|
124 | assert.ok(false, 'no errors');
|
125 | done();
|
126 | });
|
127 |
|
128 | this.player.on('timeupdate', (e) => {
|
129 | if (this.player.currentTime() > 1) {
|
130 | assert.equal(loadstartBeforePreroll, 1, 'loadstart before preroll');
|
131 | assert.equal(loadstartAfterPreroll, 0, 'loadstart after preroll');
|
132 | done();
|
133 | }
|
134 | });
|
135 |
|
136 | this.player.ready(this.player.play);
|
137 |
|
138 | });
|
139 |
|
140 | QUnit.test('loadedmetadata event and prerolls: 1 before preroll, 0 after', function(assert) {
|
141 | const done = assert.async();
|
142 |
|
143 | let beforePreroll = true;
|
144 | let loadedmetadataBeforePreroll = 0;
|
145 | let loadedmetadataAfterPreroll = 0;
|
146 |
|
147 | this.player.on('adend', () => {
|
148 | beforePreroll = false;
|
149 | });
|
150 |
|
151 | this.player.on('loadedmetadata', (e) => {
|
152 | if (beforePreroll) {
|
153 | loadedmetadataBeforePreroll++;
|
154 | } else {
|
155 | loadedmetadataAfterPreroll++;
|
156 | }
|
157 | });
|
158 |
|
159 | this.player.on(['error', 'aderror'], () => {
|
160 | assert.ok(false, 'no errors');
|
161 | done();
|
162 | });
|
163 |
|
164 | this.player.on('timeupdate', (e) => {
|
165 | if (this.player.currentTime() > 1) {
|
166 | assert.equal(loadedmetadataBeforePreroll, 1, 'loadedmetadata before preroll');
|
167 | assert.equal(loadedmetadataAfterPreroll, 0, 'loadedmetadata after preroll');
|
168 | done();
|
169 | }
|
170 | });
|
171 |
|
172 | this.player.ready(this.player.play);
|
173 |
|
174 | });
|
175 |
|
176 | QUnit.test('loadeddata event and prerolls: 1 before preroll, 0 after', function(assert) {
|
177 | const done = assert.async();
|
178 |
|
179 | let beforePreroll = true;
|
180 | let loadeddataBeforePreroll = 0;
|
181 | let loadeddataAfterPreroll = 0;
|
182 |
|
183 | this.player.on('adend', () => {
|
184 | beforePreroll = false;
|
185 | });
|
186 |
|
187 | this.player.on('loadeddata', (e) => {
|
188 | if (beforePreroll) {
|
189 | loadeddataBeforePreroll++;
|
190 | } else {
|
191 | loadeddataAfterPreroll++;
|
192 | }
|
193 | });
|
194 |
|
195 | this.player.on(['error', 'aderror'], () => {
|
196 | assert.ok(false, 'no errors');
|
197 | done();
|
198 | });
|
199 |
|
200 | this.player.on('timeupdate', (e) => {
|
201 | if (this.player.currentTime() > 1) {
|
202 | assert.equal(loadeddataBeforePreroll, 1, 'loadeddata before preroll');
|
203 | assert.equal(loadeddataAfterPreroll, 0, 'loadeddata after preroll');
|
204 | done();
|
205 | }
|
206 | });
|
207 |
|
208 | this.player.ready(this.player.play);
|
209 |
|
210 | });
|
211 |
|
212 | QUnit.test('play event and prerolls: 1 before preroll, 0 after', function(assert) {
|
213 | const done = assert.async();
|
214 |
|
215 | let beforePreroll = true;
|
216 | let playBeforePreroll = 0;
|
217 | let playAfterPreroll = 0;
|
218 |
|
219 | this.player.on('adend', () => {
|
220 | beforePreroll = false;
|
221 | });
|
222 |
|
223 | this.player.on('play', () => {
|
224 | if (beforePreroll) {
|
225 | playBeforePreroll++;
|
226 | } else {
|
227 | playAfterPreroll++;
|
228 | }
|
229 | });
|
230 |
|
231 | this.player.on(['error', 'aderror'], () => {
|
232 | assert.ok(false, 'no errors');
|
233 | done();
|
234 | });
|
235 |
|
236 | this.player.on('timeupdate', () => {
|
237 | if (this.player.currentTime() > 1) {
|
238 |
|
239 | assert.equal(playBeforePreroll, 1, 'play before preroll');
|
240 | assert.equal(playAfterPreroll, 0, 'play after preroll');
|
241 | done();
|
242 | }
|
243 | });
|
244 |
|
245 | this.player.ready(this.player.play);
|
246 |
|
247 | });
|
248 |
|
249 | QUnit.test('Event prefixing and prerolls', function(assert) {
|
250 | const done = assert.async();
|
251 |
|
252 | let beforePreroll = true;
|
253 | const seenInAdMode = [];
|
254 | const seenInContentResuming = [];
|
255 | const seenOutsideAdModeBefore = [];
|
256 | const seenOutsideAdModeAfter = [];
|
257 |
|
258 | this.player.on('adend', () => {
|
259 | beforePreroll = false;
|
260 | });
|
261 |
|
262 | let events = [
|
263 | 'suspend',
|
264 | 'abort',
|
265 | 'error',
|
266 | 'emptied',
|
267 | 'stalled',
|
268 | 'canplay',
|
269 | 'canplaythrough',
|
270 | 'waiting',
|
271 | 'seeking',
|
272 | 'durationchange',
|
273 | 'timeupdate',
|
274 | 'progress',
|
275 | 'pause',
|
276 | 'ratechange',
|
277 | 'volumechange',
|
278 | 'firstplay',
|
279 | 'suspend'
|
280 | ];
|
281 |
|
282 | events = events.concat(events.map(function(e) {
|
283 | return 'ad' + e;
|
284 | }));
|
285 |
|
286 | events = events.concat(events.map(function(e) {
|
287 | return 'content' + e;
|
288 | }));
|
289 |
|
290 | this.player.on(events, (e) => {
|
291 | const str = e.type;
|
292 |
|
293 | if (this.player.ads.isInAdMode()) {
|
294 | if (this.player.ads.isContentResuming()) {
|
295 | seenInContentResuming.push(str);
|
296 | } else {
|
297 | seenInAdMode.push(str);
|
298 | }
|
299 | } else if (beforePreroll) {
|
300 | seenOutsideAdModeBefore.push(str);
|
301 | } else {
|
302 | seenOutsideAdModeAfter.push(str);
|
303 | }
|
304 | });
|
305 |
|
306 | this.player.on(['error', 'aderror'], () => {
|
307 | assert.ok(false, 'no errors');
|
308 | done();
|
309 | });
|
310 |
|
311 | this.player.on('timeupdate', () => {
|
312 | if (this.player.currentTime() > 0) {
|
313 |
|
314 | seenOutsideAdModeBefore.forEach((event) => {
|
315 | assert.ok(!/^ad/.test(event), event + ' has no ad prefix before preroll');
|
316 | assert.ok(!/^content/.test(event), event + ' has no content prefix before preroll');
|
317 | });
|
318 |
|
319 | seenInAdMode.forEach((event) => {
|
320 | assert.ok(/^ad/.test(event), event + ' has ad prefix during preroll');
|
321 | });
|
322 |
|
323 | seenInContentResuming.forEach((event) => {
|
324 | assert.ok(/^content/.test(event), event + ' has content prefix during preroll');
|
325 | });
|
326 |
|
327 | seenOutsideAdModeAfter.forEach((event) => {
|
328 | assert.ok(!/^ad/.test(event), event + ' has no ad prefix after preroll');
|
329 | assert.ok(!/^content/.test(event), event + ' has no content prefix after preroll');
|
330 | });
|
331 |
|
332 | done();
|
333 | }
|
334 | });
|
335 |
|
336 | this.player.ready(this.player.play);
|
337 |
|
338 | });
|