Add initial set of player tests

integration_test/tests/helper/Sources.ts

@@ -10,4 +10,9 @@ export const Sources = {
     url: 'https://bitmovin-a.akamaihd.net/content/MI201109210084_1/mpds/f08e80da-bf1d-4e3d-8899-f0f6155f6efa.mpd',
     type: SourceType.DASH,
   } as SourceConfig,
+
+  akamaiTestLiveHls: {
+    url: 'https://cph-msl.akamaized.net/hls/live/2000341/test/master.m3u8',
+    type: SourceType.HLS,
+  } as SourceConfig,
 };

integration_test/tests/index.ts

@@ -1,3 +1,5 @@
-import ExampleSpec from './exampleSpec';
+import PlaybackTest from './playbackTest';
+import LoadingTest from './loadingTest';
+import UnloadingTest from './unloadingTest';
 
-export default [ExampleSpec];
+export default [PlaybackTest, LoadingTest, UnloadingTest];

integration_test/tests/loadingTest.ts

@@ -0,0 +1,61 @@
+import { TestScope } from 'cavy';
+import {
+  callPlayerAndExpectEvent,
+  callPlayerAndExpectEvents,
+  EventBag,
+  EventSequence,
+  EventType,
+  FilteredEvent,
+  startPlayerTest,
+} from '../playertesting';
+import { Sources } from './helper/Sources';
+import {
+  DownloadFinishedEvent,
+  HttpRequestType,
+  SourceConfig,
+} from 'bitmovin-player-react-native';
+
+export default (spec: TestScope) => {
+  function loadingSourceTests(sourceConfig: SourceConfig, label: string) {
+    spec.describe(`loading a ${label} source`, () => {
+      spec.it('emits ReadyEvent event', async () => {
+        await startPlayerTest({}, async () => {
+          await callPlayerAndExpectEvent((player) => {
+            player.load(sourceConfig);
+          }, EventType.Ready);
+        });
+      });
+      spec.it('emits SourceLoad and SourceLoaded events', async () => {
+        await startPlayerTest({}, async () => {
+          await callPlayerAndExpectEvents((player) => {
+            player.load(sourceConfig);
+          }, EventSequence(EventType.SourceLoad, EventType.SourceLoaded));
+        });
+      });
+      spec.it('emits DownloadFinished events', async () => {
+        await startPlayerTest({}, async () => {
+          await callPlayerAndExpectEvents(
+            (player) => {
+              player.load(sourceConfig);
+            },
+            EventBag(
+              FilteredEvent<DownloadFinishedEvent>(
+                EventType.DownloadFinished,
+                (event) =>
+                  event.requestType === HttpRequestType.ManifestHlsMaster
+              ),
+              FilteredEvent<DownloadFinishedEvent>(
+                EventType.DownloadFinished,
+                (event) =>
+                  event.requestType === HttpRequestType.ManifestHlsVariant
+              )
+            )
+          );
+        });
+      });
+    });
+  }
+
+  loadingSourceTests(Sources.artOfMotionHls, 'VOD');
+  loadingSourceTests(Sources.akamaiTestLiveHls, 'live');
+};

integration_test/tests/playbackTest.ts

@@ -0,0 +1,61 @@
+import { TestScope } from 'cavy';
+import {
+  callPlayerAndExpectEvent,
+  callPlayerAndExpectEvents,
+  EventSequence,
+  EventType,
+  expectEvents,
+  loadSourceConfig,
+  playFor,
+  RepeatedEvent,
+  startPlayerTest,
+} from '../playertesting';
+import { Sources } from './helper/Sources';
+
+export default (spec: TestScope) => {
+  spec.describe('calling player API when a source is loaded', () => {
+    spec.it(
+      'emits a Play and Playing events after calling play API',
+      async () => {
+        await startPlayerTest({}, async () => {
+          await loadSourceConfig(Sources.artOfMotionHls);
+          await callPlayerAndExpectEvents((player) => {
+            player.play();
+          }, EventSequence(EventType.Play, EventType.Playing));
+        });
+      }
+    );
+    spec.it('emits a Paused event after calling pause API', async () => {
+      await startPlayerTest({}, async () => {
+        await loadSourceConfig(Sources.artOfMotionHls);
+        await playFor(1);
+        await callPlayerAndExpectEvent((player) => {
+          player.pause();
+        }, EventType.Paused);
+      });
+    });
+  });
+  spec.describe('playing a source', () => {
+    spec.it('emits TimeChanged events', async () => {
+      await startPlayerTest({}, async () => {
+        await loadSourceConfig(Sources.artOfMotionHls);
+        await callPlayerAndExpectEvents((player) => {
+          player.play();
+        }, EventSequence(EventType.Play, EventType.Playing));
+        await expectEvents(RepeatedEvent(EventType.TimeChanged, 5));
+      });
+    });
+  });
+  spec.describe('playing a source to its end', () => {
+    spec.it('emits PlaybackFinished event', async () => {
+      await startPlayerTest({}, async () => {
+        await loadSourceConfig(Sources.artOfMotionHls);
+        await callPlayerAndExpectEvent(async (player) => {
+          player.play();
+          const duration = await player.getDuration();
+          player.seek(duration - 3);
+        }, EventType.PlaybackFinished);
+      });
+    });
+  });
+};

integration_test/tests/unloadingTest.ts

@@ -0,0 +1,22 @@
+import { TestScope } from 'cavy';
+import {
+  callPlayerAndExpectEvent,
+  EventType,
+  startPlayerTest,
+} from '../playertesting';
+import { Sources } from './helper/Sources';
+
+export default (spec: TestScope) => {
+  spec.describe('unloading the player', () => {
+    spec.it('emits SourceUnloaded event', async () => {
+      await startPlayerTest({}, async () => {
+        await callPlayerAndExpectEvent((player) => {
+          player.load(Sources.artOfMotionHls);
+        }, EventType.Ready);
+        await callPlayerAndExpectEvent((player) => {
+          player.unload();
+        }, EventType.SourceUnloaded);
+      });
+    });
+  });
+};