@vouchfor/embeds 0.0.0-experiment.75edba9 → 0.0.0-experiment.77626fa

package/src/components/{Embed → PlayerEmbed}/controllers/fetcher.ts

@@ -1,29 +1,29 @@
 import { Task } from '@lit/task';
 import { v4 as uuidv4 } from 'uuid';
 
-import type { Embed, EmbedProps } from '..';
+import type { PlayerEmbed, PlayerEmbedProps } from '..';
 import type { ReactiveControllerHost } from 'lit';
 import type { Environment } from '~/utils/env';
 
 import { getEnvUrls } from '~/utils/env';
 
-type EmbedHost = ReactiveControllerHost & Embed;
+type PlayerEmbedHost = ReactiveControllerHost & PlayerEmbed;
 
 type FetchTaskDeps = [
-  EmbedProps['env'],
-  EmbedProps['apiKey'],
-  EmbedProps['data'],
-  EmbedProps['vouchId'],
-  EmbedProps['templateId']
+  PlayerEmbedProps['env'],
+  PlayerEmbedProps['apiKey'],
+  PlayerEmbedProps['data'],
+  PlayerEmbedProps['vouchId'],
+  PlayerEmbedProps['templateId']
 ];
 
-type FilterTaskDeps = [EmbedProps['data'], EmbedProps['questions']];
+type FilterTaskDeps = [PlayerEmbedProps['data'], PlayerEmbedProps['questions']];
 
 class FetcherController {
-  host: EmbedHost;
+  host: PlayerEmbedHost;
 
   private _fetching = false;
-  private _vouch: EmbedProps['data'];
+  private _vouch: PlayerEmbedProps['data'];
 
   set fetching(value) {
     if (this._fetching !== value) {
@@ -97,7 +97,7 @@ class FetcherController {
     return template;
   };
 
-  constructor(host: EmbedHost) {
+  constructor(host: PlayerEmbedHost) {
     this.host = host;
     new Task<FetchTaskDeps, void>(
       this.host,

package/src/components/{Embed/controllers/tracking.ts → PlayerEmbed/controllers/tracking/index.ts}

@@ -1,16 +1,13 @@
-import { TEMPLATE_VERSION } from '@vouchfor/canvas-video';
-import { v4 as uuidv4 } from 'uuid';
-
-import type { Embed } from '..';
+import type { PlayerEmbed } from '../..';
 import type { VideoEventDetail } from '@vouchfor/media-player';
 import type { ReactiveController, ReactiveControllerHost } from 'lit';
 
-import packageJson from '../../../../package.json';
+import { findVouchId, getReportingMetadata, getUids } from './utils';
 import { getEnvUrls } from '~/utils/env';
 
 const MINIMUM_SEND_THRESHOLD = 1;
 
-type EmbedHost = ReactiveControllerHost & Embed;
+type PlayerEmbedHost = ReactiveControllerHost & PlayerEmbed;
 
 type TrackingEvent = 'VOUCH_LOADED' | 'VOUCH_RESPONSE_VIEWED' | 'VIDEO_PLAYED' | 'VIDEO_STREAMED';
 type TrackingPayload = {
@@ -20,6 +17,13 @@ type TrackingPayload = {
   streamEnd?: number;
 };
 
+type BatchEvent = {
+  event: TrackingEvent;
+  payload: TrackingPayload & {
+    time: string;
+  };
+};
+
 type TimeMap = {
   [key: string]: number;
 };
@@ -29,12 +33,9 @@ type BooleanMap = {
 };
 
 class TrackingController implements ReactiveController {
-  host: EmbedHost;
-
-  private _tabId: string | undefined = undefined;
-  private _clientId: string | undefined = undefined;
-  private _visitorId: string | undefined = undefined;
+  host: PlayerEmbedHost;
 
+  private _batchedEvents: BatchEvent[] = [];
   private _hasPlayed = false;
   private _hasLoaded: BooleanMap = {};
   private _answersViewed: BooleanMap = {};
@@ -42,126 +43,53 @@ class TrackingController implements ReactiveController {
   private _streamLatestTime: TimeMap = {};
   private _currentlyPlayingVideo: VideoEventDetail | null = null;
 
-  constructor(host: EmbedHost) {
+  constructor(host: PlayerEmbedHost) {
     this.host = host;
     host.addController(this);
   }
 
-  private _findVouchId(payload?: TrackingPayload) {
-    if (payload && 'vouchId' in payload) {
-      return payload.vouchId;
-    }
-    if (this.host.vouch) {
-      return this.host.vouch.id;
-    }
-    return null;
-  }
-
-  private _createVisitor = (visitorId: string) => {
-    const { publicApiUrl } = getEnvUrls(this.host.env);
-    window.localStorage?.setItem?.('vouch-uid-visitor', visitorId);
-    navigator.sendBeacon(`${publicApiUrl}/api/visitor`, JSON.stringify({ visitorId }));
-    return visitorId;
-  };
-
-  private _getUids() {
-    if (typeof window === 'undefined') {
-      return {
-        client: null,
-        tab: null,
-        request: uuidv4()
-      };
-    }
-
-    // Persisted for a user for the same device + browser, so we can e.g. search for all logs related to that browser
-    const visitorId =
-      this._visitorId || window.localStorage?.getItem?.('vouch-uid-visitor') || this._createVisitor(uuidv4());
-    // Persisted for a user for the same device + browser, so we can e.g. search for all logs related to that browser
-    const clientId = this._clientId || window.localStorage?.getItem?.('vouch-uid-client') || uuidv4();
-    // Persisted in session storage, so we can search for everything the user has done in a specific tab
-    const tabId = this._tabId || window.sessionStorage?.getItem?.('vouch-uid-tab') || uuidv4();
-    // Not persisted, allows us to search for any logs related to a single FE request
-    // E.g. BE should pass this request ID through all other services to be able to group logs
-    const requestId = uuidv4();
-
-    // Cache and persist uids
-    if (visitorId !== this._visitorId) {
-      this._visitorId = visitorId;
-      window.localStorage?.setItem?.('vouch-uid-visitor', visitorId);
-    }
-
-    if (clientId !== this._clientId) {
-      this._clientId = clientId;
-      window.localStorage?.setItem?.('vouch-uid-client', clientId);
-    }
+  private _createTrackingEvent = (event: TrackingEvent, payload?: TrackingPayload) => {
+    const vouchId = findVouchId(payload, this.host.vouch);
 
-    if (tabId !== this._tabId) {
-      this._tabId = tabId;
-      window.sessionStorage?.setItem?.('vouch-uid-tab', tabId);
+    if (!vouchId || this.host.disableTracking) {
+      return;
     }
 
-    return {
-      client: clientId,
-      tab: tabId,
-      request: requestId,
-      visitor: visitorId
-    };
-  }
-
-  private _getReportingMetadata = () => {
-    const [country, region] = Intl.DateTimeFormat().resolvedOptions().timeZone?.split?.('/') ?? [];
-
-    const utmParams: any = {};
-    [...new URLSearchParams(location.search).entries()].forEach(([key, value]) => {
-      if (/utm/.test(key)) {
-        const param = key.toLowerCase().replace(/[-_][a-z0-9]/g, (group) => group.slice(-1).toUpperCase());
-        utmParams[param] = value;
+    this._batchedEvents.push({
+      event,
+      payload: {
+        ...payload,
+        vouchId,
+        time: new Date().toISOString()
       }
     });
-
-    return {
-      source: this.host.trackingSource,
-      time: new Date(),
-      region,
-      country,
-      screenHeight: window.screen.height,
-      screenWidth: window.screen.width,
-      referrer: document.referrer,
-      currentUrl: location.href,
-      embedType: 'media-player-embed',
-      embedVersion: packageJson.version,
-      templateVersion: TEMPLATE_VERSION,
-      ...utmParams
-    };
   };
 
-  private _sendTrackingEvent = (event: TrackingEvent, payload?: TrackingPayload) => {
-    const vouchId = this._findVouchId(payload);
-
-    if (!vouchId || this.host.disableTracking) {
+  private _sendTrackingEvent = () => {
+    if (this._batchedEvents.length <= 0) {
       return;
     }
 
     const { publicApiUrl } = getEnvUrls(this.host.env);
-    const { client, tab, request, visitor } = this._getUids();
+    const { client, tab, request, visitor } = getUids(this.host.env);
 
     navigator.sendBeacon(
-      `${publicApiUrl}/api/v2/events`,
+      `${publicApiUrl}/api/batchevents`,
       JSON.stringify({
-        event,
         payload: {
-          ...payload,
-          vouchId
+          events: this._batchedEvents
         },
         context: {
           'x-uid-client': client,
           'x-uid-tab': tab,
           'x-uid-request': request,
           'x-uid-visitor': visitor,
-          'x-reporting-metadata': this._getReportingMetadata()
+          'x-reporting-metadata': getReportingMetadata(this.host.trackingSource)
         }
       })
     );
+
+    this._batchedEvents = [];
   };
 
   private _streamEnded = () => {
@@ -171,7 +99,7 @@ class TrackingController implements ReactiveController {
       if (this._streamLatestTime[key] > this._streamStartTime[key] + MINIMUM_SEND_THRESHOLD) {
         // Send a video streamed event any time the stream ends to capture the time between starting
         // the video and the video stopping for any reason (pausing, deleting the embed node or closing the browser)
-        this._sendTrackingEvent('VIDEO_STREAMED', {
+        this._createTrackingEvent('VIDEO_STREAMED', {
           answerId: id,
           streamStart: this._streamStartTime[key],
           streamEnd: this._streamLatestTime[key]
@@ -191,7 +119,7 @@ class TrackingController implements ReactiveController {
 
     // Only send loaded event once per session
     if (!this._hasLoaded[vouchId]) {
-      this._sendTrackingEvent('VOUCH_LOADED', { vouchId });
+      this._createTrackingEvent('VOUCH_LOADED', { vouchId });
       this._hasLoaded[vouchId] = true;
     }
   };
@@ -199,26 +127,21 @@ class TrackingController implements ReactiveController {
   private _handlePlay = () => {
     // Only send the video played event once per session
     if (!this._hasPlayed) {
-      this._sendTrackingEvent('VIDEO_PLAYED', {
+      this._createTrackingEvent('VIDEO_PLAYED', {
         streamStart: this.host.currentTime
       });
       this._hasPlayed = true;
     }
   };
 
-  private _handleVideoPlay = ({ detail: { id, key, node } }: CustomEvent<VideoEventDetail>) => {
+  private _handleVideoPlay = ({ detail: { id, key } }: CustomEvent<VideoEventDetail>) => {
     // Only increment play count once per session
     if (!this._answersViewed[key]) {
-      this._sendTrackingEvent('VOUCH_RESPONSE_VIEWED', {
+      this._createTrackingEvent('VOUCH_RESPONSE_VIEWED', {
         answerId: id
       });
       this._answersViewed[key] = true;
     }
-
-    if (!this._streamStartTime[key]) {
-      this._streamStartTime[key] = node.currentTime;
-      this._streamLatestTime[key] = node.currentTime;
-    }
   };
 
   private _handleVideoTimeUpdate = ({ detail: { id, key, node } }: CustomEvent<VideoEventDetail>) => {
@@ -230,12 +153,17 @@ class TrackingController implements ReactiveController {
     ) {
       this._currentlyPlayingVideo = { id, key, node };
       this._streamLatestTime[key] = node.currentTime;
+
+      if (!this._streamStartTime[key]) {
+        this._streamStartTime[key] = node.currentTime;
+        this._streamLatestTime[key] = node.currentTime;
+      }
     }
   };
 
   private _handleVideoPause = ({ detail: { id, key } }: CustomEvent<VideoEventDetail>) => {
     if (this._streamLatestTime[key] > this._streamStartTime[key] + MINIMUM_SEND_THRESHOLD) {
-      this._sendTrackingEvent('VIDEO_STREAMED', {
+      this._createTrackingEvent('VIDEO_STREAMED', {
         answerId: id,
         streamStart: this._streamStartTime[key],
         streamEnd: this._streamLatestTime[key]
@@ -247,9 +175,7 @@ class TrackingController implements ReactiveController {
 
   private _pageUnloading = () => {
     this._streamEnded();
-    // This will try to send the same stream event again so we delete the start and latest
-    // time in stream ended so that there is no times to send and the pause event does nothing
-    this.host.pause();
+    this._sendTrackingEvent();
   };
 
   private _handleVisibilityChange = () => {
@@ -278,7 +204,9 @@ class TrackingController implements ReactiveController {
   }
 
   hostDisconnected() {
-    this._streamEnded();
+    // Send events if DOM node is destroyed
+    this._pageUnloading();
+
     if ('onvisibilitychange' in document) {
       document.removeEventListener('visibilitychange', this._handleVisibilityChange);
     } else {
@@ -293,3 +221,4 @@ class TrackingController implements ReactiveController {
 }
 
 export { TrackingController };
+export type { TrackingEvent, TrackingPayload };

package/src/components/PlayerEmbed/controllers/tracking/utils.ts

@@ -0,0 +1,95 @@
+import { TEMPLATE_VERSION } from '@vouchfor/canvas-video';
+import { v4 as uuidv4 } from 'uuid';
+
+import type { TrackingPayload } from '.';
+import type { Vouch } from '@vouchfor/video-utils';
+import type { Environment } from '~/utils/env';
+
+import packageJson from '~/../package.json';
+import { getEnvUrls } from '~/utils/env';
+
+function createVisitor(env: Environment) {
+  const { publicApiUrl } = getEnvUrls(env);
+  const visitorId = uuidv4();
+  navigator.sendBeacon(`${publicApiUrl}/api/visitor`, JSON.stringify({ visitorId }));
+  return visitorId;
+}
+
+function getUids(env: Environment) {
+  if (typeof window === 'undefined') {
+    return {
+      client: null,
+      tab: null,
+      request: uuidv4()
+    };
+  }
+
+  // Persisted for a user for the same device + browser, so we can e.g. search for all logs related to that browser
+  let visitorId = window.localStorage?.getItem?.('vouch-uid-visitor');
+  // Persisted for a user for the same device + browser, so we can e.g. search for all logs related to that browser
+  let clientId = window.localStorage?.getItem?.('vouch-uid-client');
+  // Persisted in session storage, so we can search for everything the user has done in a specific tab
+  let tabId = window.sessionStorage?.getItem?.('vouch-uid-tab');
+  // Not persisted, allows us to search for any logs related to a single FE request
+  // E.g. BE should pass this request ID through all other services to be able to group logs
+  const requestId = uuidv4();
+
+  // Cache uids
+  if (!visitorId) {
+    visitorId = createVisitor(env);
+    window.localStorage?.setItem?.('vouch-uid-visitor', visitorId);
+  }
+
+  if (!clientId) {
+    clientId = uuidv4();
+    window.localStorage?.setItem?.('vouch-uid-client', clientId);
+  }
+
+  if (!tabId) {
+    tabId = uuidv4();
+    window.sessionStorage?.setItem?.('vouch-uid-tab', tabId);
+  }
+
+  return {
+    client: clientId,
+    tab: tabId,
+    request: requestId,
+    visitor: visitorId
+  };
+}
+
+function findVouchId(payload?: TrackingPayload, vouch?: Vouch) {
+  if (payload && 'vouchId' in payload) {
+    return payload.vouchId;
+  }
+  return vouch?.id ?? null;
+}
+
+function getReportingMetadata(source = 'embedded_player') {
+  const [country, region] = Intl.DateTimeFormat().resolvedOptions().timeZone?.split?.('/') ?? [];
+
+  const utmParams: any = {};
+  [...new URLSearchParams(location.search).entries()].forEach(([key, value]) => {
+    if (/utm/.test(key)) {
+      const param = key.toLowerCase().replace(/[-_][a-z0-9]/g, (group) => group.slice(-1).toUpperCase());
+      utmParams[param] = value;
+    }
+  });
+
+  return {
+    source,
+    time: new Date(),
+    region,
+    country,
+    screenHeight: window.screen.height,
+    screenWidth: window.screen.width,
+    referrer: document.referrer,
+    currentUrl: location.href,
+    embedType: 'media-player-embed',
+    embedVersion: packageJson.version,
+    templateVersion: TEMPLATE_VERSION,
+    ...utmParams
+  };
+}
+
+export { getUids, findVouchId, getReportingMetadata };

package/src/components/{Embed → PlayerEmbed}/index.ts

@@ -5,7 +5,6 @@ import { createRef, ref } from 'lit/directives/ref.js';
 
 import type { Scene, Scenes, TemplateInstance } from '@vouchfor/canvas-video';
 import type { MediaPlayer, MediaPlayerProps } from '@vouchfor/media-player';
-import type { Ref } from 'lit/directives/ref.js';
 import type { Environment } from '~/utils/env';
 
 import { EventForwardController } from './controllers/event-forwarder';
@@ -14,7 +13,10 @@ import { TrackingController } from './controllers/tracking';
 
 import '@vouchfor/media-player';
 
-type EmbedProps = Pick<MediaPlayerProps, 'data' | 'aspectRatio' | 'preload' | 'autoplay' | 'controls'> & {
+type PlayerEmbedProps = Pick<
+  MediaPlayerProps,
+  'data' | 'aspectRatio' | 'language' | 'preload' | 'autoplay' | 'controls'
+> & {
   env: Environment;
   apiKey: string;
   disableTracking?: boolean;
@@ -25,8 +27,8 @@ type EmbedProps = Pick<MediaPlayerProps, 'data' | 'aspectRatio' | 'preload' | 'a
   questions?: number[];
 };
 
-@customElement('vouch-embed')
-class Embed extends LitElement {
+@customElement('vouch-embed-player')
+class PlayerEmbed extends LitElement {
   static styles = [
     css`
       :host {
@@ -35,22 +37,21 @@ class Embed extends LitElement {
     `
   ];
 
-  private _mediaPlayerRef: Ref<MediaPlayer> = createRef();
+  @property({ type: Object }) data: PlayerEmbedProps['data'];
+  @property({ type: String }) vouchId: PlayerEmbedProps['vouchId'];
+  @property({ type: String }) templateId: PlayerEmbedProps['templateId'];
+  @property({ type: Array }) questions: PlayerEmbedProps['questions'];
 
-  @property({ type: Object }) data: EmbedProps['data'];
-  @property({ type: String }) vouchId: EmbedProps['vouchId'];
-  @property({ type: String }) templateId: EmbedProps['templateId'];
-  @property({ type: Array }) questions: EmbedProps['questions'];
+  @property({ type: String }) env: PlayerEmbedProps['env'] = 'prod';
+  @property({ type: String }) apiKey: PlayerEmbedProps['apiKey'] = '';
+  @property({ type: Boolean }) disableTracking: PlayerEmbedProps['disableTracking'] = false;
+  @property({ type: String }) trackingSource: PlayerEmbedProps['trackingSource'] = 'embedded_player';
 
-  @property({ type: String }) env: EmbedProps['env'] = 'prod';
-  @property({ type: String }) apiKey: EmbedProps['apiKey'] = '';
-  @property({ type: Boolean }) disableTracking: EmbedProps['disableTracking'] = false;
-  @property({ type: String }) trackingSource: EmbedProps['trackingSource'] = 'embedded_player';
-
-  @property({ type: Array }) controls: EmbedProps['controls'];
-  @property({ type: String }) preload: EmbedProps['preload'] = 'auto';
-  @property({ type: Boolean }) autoplay: EmbedProps['autoplay'] = false;
-  @property({ type: Number }) aspectRatio: EmbedProps['aspectRatio'] = 0;
+  @property({ type: Array }) controls: PlayerEmbedProps['controls'];
+  @property({ type: String }) preload: PlayerEmbedProps['preload'] = 'auto';
+  @property({ type: Boolean }) autoplay: PlayerEmbedProps['autoplay'] = false;
+  @property({ type: Number }) aspectRatio: PlayerEmbedProps['aspectRatio'] = 0;
+  @property({ type: String }) language?: MediaPlayerProps['language'];
 
   private eventController = new EventForwardController(this, [
     'durationchange',
@@ -63,6 +64,7 @@ class Embed extends LitElement {
     'playing',
     'ratechange',
     'scenechange',
+    'scenesupdate',
     'seeking',
     'seeked',
     'timeupdate',
@@ -85,17 +87,23 @@ class Embed extends LitElement {
   // @ts-ignore
   private _trackingController = new TrackingController(this);
 
-  @state() vouch: EmbedProps['data'];
+  @state() vouch: PlayerEmbedProps['data'];
   @state() template: TemplateInstance | undefined;
 
   get fetching() {
     return this._fetcherController.fetching;
   }
 
+  private _mediaPlayerRef = createRef<MediaPlayer>();
+
   get waiting() {
     return this._mediaPlayerRef.value?.waiting;
   }
 
+  get initialised() {
+    return this._mediaPlayerRef.value?.initialised;
+  }
+
   get seeking() {
     return this._mediaPlayerRef.value?.seeking;
   }
@@ -180,12 +188,42 @@ class Embed extends LitElement {
     this._mediaPlayerRef.value?.pause();
   }
 
+  reset(time = 0, play = false) {
+    this._mediaPlayerRef.value?.reset(time, play);
+  }
+
   setScene(index: number) {
     this._mediaPlayerRef.value?.setScene(index);
   }
 
+  private _renderStyles() {
+    if (!this.aspectRatio) {
+      return html`
+        <style>
+          :host {
+            width: 100%;
+            height: 100%;
+          }
+        </style>
+      `;
+    }
+
+    if (typeof this.aspectRatio === 'number') {
+      return html`
+        <style>
+          :host {
+            aspect-ratio: ${this.aspectRatio};
+          }
+        </style>
+      `;
+    }
+
+    return null;
+  }
+
   render() {
     return html`
+      ${this._renderStyles()}
       <vmp-media-player
         ${ref(this._mediaPlayerRef)}
         ${this.eventController.register()}
@@ -195,6 +233,7 @@ class Embed extends LitElement {
         .template=${this.template}
         aspectRatio=${ifDefined(this.aspectRatio)}
         preload=${ifDefined(this.preload)}
+        language=${ifDefined(this.language)}
         .controls=${this.controls}
       ></vmp-media-player>
     `;
@@ -203,15 +242,15 @@ class Embed extends LitElement {
 
 declare global {
   interface HTMLElementTagNameMap {
-    'vouch-embed': Embed;
+    'vouch-embed-player': PlayerEmbed;
   }
 
   namespace JSX {
     interface IntrinsicElements {
-      'vouch-embed': Embed;
+      'vouch-embed-player': PlayerEmbed;
     }
   }
 }
 
-export { Embed };
-export type { EmbedProps };
+export { PlayerEmbed };
+export type { PlayerEmbedProps };

package/src/components/PlayerEmbed/tests/PlayerEmbed.spec.ts

@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { expect, fixture, waitUntil } from '@open-wc/testing';
+import { html } from 'lit';
+import sinon from 'sinon';
+
+import type { PlayerEmbed } from '../index.js';
+import type { VideoMap } from '@vouchfor/media-player';
+
+import { data } from './data.js';
+
+// Can't use typescript aliases with esbuild file transforms apparently
+// No idea what a good way to actually build before testing is, the examples give nothing
+// https://modern-web.dev/guides/test-runner/typescript/
+import '../../../test/lib/embeds.js';
+
+function getVideo(videos: VideoMap) {
+  return Object.values(videos)[0];
+}
+
+function playerLoaded(player: PlayerEmbed) {
+  return waitUntil(
+    () => {
+      return player.mediaPlayer?.initialised;
+    },
+    'Player has not loaded video',
+    { timeout: 20000 }
+  );
+}
+
+describe('Embeds', () => {
+  it('passes', async () => {
+    const player = await fixture<PlayerEmbed>(
+      html`<vouch-embed-player env="dev" .data=${data} aspectratio=${1}></vouch-embed-player>`
+    );
+    // @ts-ignore - accessing private property
+    const sendTrackingSpy = sinon.spy(player._trackingController, '_sendTrackingEvent');
+    // @ts-ignore - accessing private property
+    const createTrackingSpy = sinon.spy(player._trackingController, '_createTrackingEvent');
+
+    await playerLoaded(player);
+    // Have to mute the player because we can't programmatically play videos with sound
+    player.muted = true;
+    player.play();
+    expect(player.paused).eq(false);
+    await waitUntil(
+      () => {
+        // Video plays for 3 seconds
+        return (getVideo(player.mediaPlayer!.videos)?.node?.currentTime ?? 0) > 3;
+      },
+      'Video did not play for 3 seconds',
+      { timeout: 20000 }
+    );
+    expect(getVideo(player.mediaPlayer!.videos)?.node?.paused).eq(false);
+    player.pause();
+    expect(getVideo(player.mediaPlayer!.videos)?.node?.paused).eq(true);
+    expect(sendTrackingSpy.callCount).to.be.eq(0);
+    // Destroy node because events are sent when node is removed from the document
+    player.remove();
+    expect(sendTrackingSpy.callCount).to.be.eq(1);
+    expect(createTrackingSpy.args[0]).to.eql([
+      'VIDEO_PLAYED',
+      {
+        streamStart: 0
+      }
+    ]);
+    expect(createTrackingSpy.args[1]).to.eql([
+      'VOUCH_RESPONSE_VIEWED',
+      {
+        answerId: '5c66bb3a-ed68-41a0-a601-a49865104418'
+      }
+    ]);
+    expect(createTrackingSpy.args[2][0]).to.eq('VIDEO_STREAMED');
+    // Remove streamStart and streamEnd as these are non-deterministic
+    expect({ ...createTrackingSpy.args[2][1], streamStart: undefined, streamEnd: undefined }).to.eql({
+      answerId: '5c66bb3a-ed68-41a0-a601-a49865104418',
+      streamStart: undefined,
+      streamEnd: undefined
+    });
+  });
+});