shaka-player 4.6.4 → 4.7.0

package/test/net/networking_utils_unit.js

@@ -1,37 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-const testGetMimeType = async (expertedMimeType, contentType) => {
-  const netEngine = new shaka.test.FakeNetworkingEngine()
-      .setHeaders('dummy://foo', {'content-type': contentType});
-  const mimeType = await shaka.net.NetworkingUtils
-      .getMimeType('dummy://foo', netEngine,
-          shaka.net.NetworkingEngine.defaultRetryParameters());
-  expect(mimeType).toBe(expertedMimeType);
-};
-
-describe('NetworkingUtils', () => {
-  describe('getMimeType', () => {
-    it('test correct mimeType', () => {
-      testGetMimeType('application/dash+xml', 'application/dash+xml');
-    });
-
-    it('test mimeType with charset', () => {
-      testGetMimeType('application/dash+xml',
-          'application/dash+xml;charset=UTF-8');
-    });
-
-    it('test content-type with uppercase letters', () => {
-      testGetMimeType('application/dash+xml',
-          'Application/Dash+XML');
-    });
-
-    it('test content-type with uppercase letters and charset', () => {
-      testGetMimeType('text/html',
-          'Text/HTML;Charset="utf-8"');
-    });
-  });
-});

package/test/offline/download_progress_estimator_unit.js

@@ -1,90 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-describe('DownloadProgressEstimator', () => {
-  /** @type {!shaka.offline.DownloadProgressEstimator} */
-  let estimator;
-
-  beforeEach(() => {
-    estimator = new shaka.offline.DownloadProgressEstimator();
-  });
-
-  it('closing updates total download', () => {
-    const id = estimator.open(/* estimate= */ 12);
-    estimator.close(id, /* actual= */ 13);
-
-    expect(estimator.getTotalDownloaded()).toBe(13);
-  });
-
-  // If we call |close| with an id that was not returned by |open|, then it
-  // should be ignored.
-  it('closing with invalid id is ignored', () => {
-    expect(estimator.getTotalDownloaded()).toBe(0);
-    estimator.close(72, /* actual= */ 13);
-    expect(estimator.getTotalDownloaded()).toBe(0);
-  });
-
-  it('closing the same id twice has no effect', () => {
-    expect(estimator.getEstimatedProgress()).toBe(0);
-
-    estimator.open(/* estimate= */ 15);
-    const id = estimator.open(/* estimate= */ 5);
-
-    expect(estimator.getEstimatedProgress()).toBe(0);
-
-    estimator.close(id, /* actual= */ 5);
-    expect(estimator.getEstimatedProgress()).toBeCloseTo(0.25);
-    expect(estimator.getTotalDownloaded()).toBe(5);
-
-    // We will close |id| again, but nothing should change. We will even say
-    // the downloaded size is different, but that should not change anything.
-    estimator.close(id, /* actual= */ 200);
-    expect(estimator.getEstimatedProgress()).toBeCloseTo(0.25);
-    expect(estimator.getTotalDownloaded()).toBe(5);
-  });
-
-  // Calling both |open| and |close| should affect our progress. Calling |open|
-  // should cause our progress to grow smaller (we are saying there is more work
-  // to do) and calling |close| should cause our progress to grow larger (we are
-  // saying we completed work).
-  it('opening and closing updates progress', () => {
-    expect(estimator.getEstimatedProgress()).toBe(0);
-
-    const id0 = estimator.open(/* estimate= */ 5);
-    const id1 = estimator.open(/* estimate= */ 15);
-
-    expect(estimator.getEstimatedProgress()).toBe(0);
-
-    estimator.close(id0, /* actual= */ 5);
-    expect(estimator.getEstimatedProgress()).toBeCloseTo(0.25);
-
-    estimator.close(id1, /* actual= */ 15);
-    expect(estimator.getEstimatedProgress()).toBeCloseTo(1.0);
-
-    // Open a new estimate with a size equal to all previous estimates. Since
-    // everything else was closed, this should drop our progress from 100% to
-    // 50%.
-    estimator.open(/* estimate= */ 20);
-    expect(estimator.getEstimatedProgress()).toBeCloseTo(0.5);
-  });
-
-  // When tracking progress, we want to use the estimated size. This means no
-  // matter what value we provide for the actual downloaded size, it should not
-  // affect the progress (the original estimate should be used).
-  it('actual bytes do not affect progres', () => {
-    expect(estimator.getEstimatedProgress()).toBe(0);
-
-    estimator.open(/* estimate= */ 15);
-    const id = estimator.open(/* estimate= */ 5);
-
-    expect(estimator.getEstimatedProgress()).toBe(0);
-
-    // Use an actual value so large that if used for progress, it would break
-    // the progress value bounds.
-    estimator.close(id, /* actual= */ 200);
-    expect(estimator.getEstimatedProgress()).toBeCloseTo(0.25);
-  });
-});

package/test/offline/indexeddb_storage_unit.js

@@ -1,192 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-filterDescribe('IndexeddbStorageCell', offlineSupported, () => {
-  const IndexedDBUtils = shaka.test.IndexedDBUtils;
-  const OfflineUtils = shaka.test.OfflineUtils;
-  const Util = shaka.test.Util;
-
-  const dbName = 'shaka-storage-cell-test';
-  const dbVersion = 1;
-  const segmentStore = 'segment-store';
-  const manifestStore = 'manifest-store';
-
-  const noop = () => {};
-
-  /** @type {!Array.<shaka.extern.StorageCell>} */
-  let cells = [];
-
-  /** @type {!Array.<IDBDatabase>} */
-  let connections = [];
-
-  beforeEach(() => {
-    cells = [];
-    connections = [];
-  });
-
-  afterEach(async () => {
-    // If the test did not run, then there will be no cells and no connections,
-    // so we don't need to worry about checking if indexeddb is supported here.
-
-    // Destroy the cells before killing any connections.
-    await Promise.all(cells.map((cell) => cell.destroy()));
-    for (const connection of connections) {
-      connection.close();
-    }
-  });
-
-  it('can add, get, and remove segments', async () => {
-    /** @type {!Array.<shaka.extern.SegmentDataDB>} */
-    const segments = [
-      OfflineUtils.createSegmentData([0]),
-      OfflineUtils.createSegmentData([0, 1]),
-      OfflineUtils.createSegmentData([0, 1, 2]),
-    ];
-
-    await IndexedDBUtils.deleteDB(dbName);
-    const connection = await makeConnection();
-    const cell = makeCell(connection);
-
-    const keys = await cell.addSegments(segments);
-    expect(keys).toBeTruthy();
-    expect(keys.length).toBe(segments.length);
-
-    const found = await cell.getSegments(keys);
-    expect(found).toBeTruthy();
-    expect(found.length).toBe(segments.length);
-    OfflineUtils.expectSegmentToEqual(found[0], segments[0]);
-    OfflineUtils.expectSegmentToEqual(found[1], segments[1]);
-    OfflineUtils.expectSegmentToEqual(found[2], segments[2]);
-
-    await cell.removeSegments(keys, noop);
-    // The get should fail as there should be no entries under the keys
-    // anymore.
-    const expected = Util.jasmineError(new shaka.util.Error(
-        shaka.util.Error.Severity.CRITICAL,
-        shaka.util.Error.Category.STORAGE,
-        shaka.util.Error.Code.KEY_NOT_FOUND,
-        jasmine.any(String)));
-    await expectAsync(cell.getSegments(keys)).toBeRejectedWith(expected);
-  });
-
-  it('can add, get, and remove manifests', async () => {
-    /** @type {!Array.<shaka.extern.ManifestDB>} */
-    const manifests = [
-      OfflineUtils.createManifest('original-uri-1'),
-      OfflineUtils.createManifest('original-uri-2'),
-      OfflineUtils.createManifest('original-uri-3'),
-    ];
-
-    await IndexedDBUtils.deleteDB(dbName);
-    const connection = await makeConnection();
-    const cell = makeCell(connection);
-    const keys = await cell.addManifests(manifests);
-    expect(keys).toBeTruthy();
-    expect(keys.length).toBe(manifests.length);
-
-    const found = await cell.getManifests(keys);
-    expect(found).toBeTruthy();
-    expect(found.length).toBe(manifests.length);
-    expect(found[0]).toEqual(manifests[0]);
-    expect(found[1]).toEqual(manifests[1]);
-    expect(found[2]).toEqual(manifests[2]);
-
-    await cell.removeManifests(keys, noop);
-    // The get should fail as there should be no entries under the keys
-    // anymore.
-    const expected = Util.jasmineError(new shaka.util.Error(
-        shaka.util.Error.Severity.CRITICAL,
-        shaka.util.Error.Category.STORAGE,
-        shaka.util.Error.Code.KEY_NOT_FOUND,
-        jasmine.any(String)));
-    await expectAsync(cell.getManifests(keys)).toBeRejectedWith(expected);
-  });
-
-  it('can add and get all manifests', async () => {
-    /** @type {!Array.<shaka.extern.ManifestDB>} */
-    const manifests = [
-      OfflineUtils.createManifest('original-uri-1'),
-      OfflineUtils.createManifest('original-uri-2'),
-      OfflineUtils.createManifest('original-uri-3'),
-    ];
-
-    await IndexedDBUtils.deleteDB(dbName);
-    const connection = await makeConnection();
-    const cell = await makeCell(connection);
-    const keys = await cell.addManifests(manifests);
-    expect(keys).toBeTruthy();
-    expect(keys.length).toBe(manifests.length);
-
-    const found = await cell.getAllManifests();
-    expect(found).toBeTruthy();
-
-    const actual = keys.map((key) => found.get(key));
-    expect(actual[0]).toEqual(manifests[0]);
-    expect(actual[1]).toEqual(manifests[1]);
-    expect(actual[2]).toEqual(manifests[2]);
-  });
-
-  it('can add, get, and update manifests', async () => {
-    /** @type {shaka.extern.ManifestDB} */
-    const originalManifest = OfflineUtils.createManifest('original');
-    originalManifest.expiration = 1000;
-
-    await IndexedDBUtils.deleteDB(dbName);
-    const connection = await makeConnection();
-    const cell = await makeCell(connection);
-    const keys = await cell.addManifests([originalManifest]);
-    expect(keys).toBeTruthy();
-    expect(keys.length).toBe(1);
-
-    const key = keys[0];
-    const found = await cell.getManifests(keys);
-    expect(found).toBeTruthy();
-    expect(found.length).toBe(1);
-    expect(found[0]).toEqual(originalManifest);
-
-    await cell.updateManifestExpiration(key, 500);
-    const newFound = await cell.getManifests([key]);
-    expect(newFound).toBeTruthy();
-    expect(newFound.length).toBe(1);
-
-    expect(newFound[0]).not.toEqual(originalManifest);
-    originalManifest.expiration = 500;
-    expect(newFound[0]).toEqual(originalManifest);
-  });
-
-  /**
-   * @return {!Promise.<IDBDatabase>}
-   */
-  async function makeConnection() {
-    const upgrade = (db) => {
-      db.createObjectStore(segmentStore, {autoIncrement: true});
-      db.createObjectStore(manifestStore, {autoIncrement: true});
-    };
-
-    const connection =
-        await IndexedDBUtils.makeConnection(dbName, dbVersion, upgrade);
-    // Track the connection so that we can close it when the test is
-    // over.
-    connections.push(connection);
-    return connection;
-  }
-
-  /**
-   * @param {IDBDatabase} connection
-   * @return {shaka.extern.StorageCell}
-   */
-  function makeCell(connection) {
-    const cell = new shaka.offline.indexeddb.V5StorageCell(
-        connection,
-        segmentStore,
-        manifestStore);
-
-    // Track the cell so that we can destroy it when the test is over.
-    cells.push(cell);
-
-    return cell;
-  }
-});