@internetarchive/bookreader 5.0.0-18

package/tests/plugins/tts/AbstractTTSEngine.test.js

@@ -0,0 +1,153 @@
+import sinon from 'sinon';
+import { afterEventLoop } from '../../utils.js';
+import AbstractTTSEngine from '../../../src/plugins/tts/AbstractTTSEngine.js';
+import PageChunkIterator from '../../../src/plugins/tts/PageChunkIterator.js';
+/** @typedef {import('../../../src/plugins/tts/AbstractTTSEngine.js').TTSEngineOptions} TTSEngineOptions */
+
+// Skipping because it's flaky. Fix in #672
+describe.skip('AbstractTTSEngine', () => {
+  test('stops playing once done', () => {
+    class DummyEngine extends AbstractTTSEngine {
+      getVoices() { return []; }
+    }
+    const d = new DummyEngine(DUMMY_TTS_ENGINE_OPTS);
+    d._chunkIterator = { next: sinon.stub().resolves(PageChunkIterator.AT_END) };
+    const stopStub = sinon.stub(d, 'stop');
+    expect(stopStub.callCount).toBe(0);
+    d.step();
+    return afterEventLoop()
+      .then(() => expect(stopStub.callCount).toBe(1));
+  });
+});
+
+for (const dummyVoice of [dummyVoice, dummyVoiceUnderscores]) {
+  describe(`getBestBookVoice with BCP47 ${dummyVoice == dummyVoiceUnderscores ? '+' : '-'} underscores`, () => {
+    const { getBestBookVoice } = AbstractTTSEngine;
+
+    test('undefined if no voices', () => {
+      expect(getBestBookVoice([], 'en', [])).toBe(undefined);
+    });
+
+    test('returns first voice if no matching', () => {
+      const enVoice = dummyVoice({lang: "en-US"});
+      expect(getBestBookVoice([enVoice], 'fr', [])).toBe(enVoice);
+    });
+
+    test('choose first matching voice', () => {
+      const voices = [
+        dummyVoice({lang: "en-GB"}),
+        dummyVoice({lang: "en-US"}),
+      ];
+      expect(getBestBookVoice(voices, 'en', [])).toBe(voices[0]);
+    });
+
+    test('choose first matching default voice', () => {
+      const voices = [
+        dummyVoice({lang: "en-GB"}),
+        dummyVoice({lang: "en-US", default: true}),
+      ];
+      expect(getBestBookVoice(voices, 'en', [])).toBe(voices[1]);
+    });
+
+    test('does not choose default if better language match exists', () => {
+      const voices = [
+        dummyVoice({lang: "en-US", default: true}),
+        dummyVoice({lang: "fr-FR"}),
+      ];
+      expect(getBestBookVoice(voices, 'fr', [])).toBe(voices[1]);
+    });
+
+    test('choose users dialect if present', () => {
+      const voices = [
+        dummyVoice({lang: "en-GB"}),
+        dummyVoice({lang: "en-CA"}),
+        dummyVoice({lang: "en-US"}),
+      ];
+      expect(getBestBookVoice(voices, 'en', ['en-CA', 'en'])).toBe(voices[1]);
+    });
+
+    test('choose users dialect even if not default', () => {
+      const voices = [
+        dummyVoice({lang: "en-US", default: true}),
+        dummyVoice({lang: "en-GB"}),
+        dummyVoice({lang: "en-CA"}),
+      ];
+      expect(getBestBookVoice(voices, 'en', ['en-CA', 'en'])).toBe(voices[2]);
+    });
+
+    test('choose language even if dialect does not match', () => {
+      const voices = [
+        dummyVoice({lang: "en-GB"}),
+      ];
+      expect(getBestBookVoice(voices, 'en', ['en-CA'])).toBe(voices[0]);
+    });
+
+    test('real world example', () => {
+      // Chrome 77 @ Windows 10
+      const voices = [
+        { default: true, lang: "en-US", name: "Microsoft David Desktop - English (United States)", localService: true, voiceURI: "Microsoft David Desktop - English (United States)" },
+        { default: false, lang: "de-DE", name: "Microsoft Hedda Desktop - German", localService: true, voiceURI: "Microsoft Hedda Desktop - German" },
+        { default: false, lang: "en-US", name: "Microsoft Zira Desktop - English (United States)", localService: true, voiceURI: "Microsoft Zira Desktop - English (United States)" },
+        { default: false, lang: "de-DE", name: "Google Deutsch", localService: false, voiceURI: "Google Deutsch" },
+        { default: false, lang: "en-US", name: "Google US English", localService: false, voiceURI: "Google US English" },
+        { default: false, lang: "en-GB", name: "Google UK English Female", localService: false, voiceURI: "Google UK English Female" },
+        { default: false, lang: "en-GB", name: "Google UK English Male", localService: false, voiceURI: "Google UK English Male" },
+        { default: false, lang: "es-ES", name: "Google español", localService: false, voiceURI: "Google español" },
+        { default: false, lang: "es-US", name: "Google español de Estados Unidos", localService: false, voiceURI: "Google español de Estados Unidos" },
+        { default: false, lang: "fr-FR", name: "Google français", localService: false, voiceURI: "Google français" },
+        { default: false, lang: "hi-IN", name: "Google हिन्दी", localService: false, voiceURI: "Google हिन्दी" },
+        { default: false, lang: "id-ID", name: "Google Bahasa Indonesia", localService: false, voiceURI: "Google Bahasa Indonesia" },
+        { default: false, lang: "it-IT", name: "Google italiano", localService: false, voiceURI: "Google italiano" },
+        { default: false, lang: "ja-JP", name: "Google 日本語", localService: false, voiceURI: "Google 日本語" },
+        { default: false, lang: "ko-KR", name: "Google 한국의", localService: false, voiceURI: "Google 한국의" },
+        { default: false, lang: "nl-NL", name: "Google Nederlands", localService: false, voiceURI: "Google Nederlands" },
+        { default: false, lang: "pl-PL", name: "Google polski", localService: false, voiceURI: "Google polski" },
+        { default: false, lang: "pt-BR", name: "Google português do Brasil", localService: false, voiceURI: "Google português do Brasil" },
+        { default: false, lang: "ru-RU", name: "Google русский", localService: false, voiceURI: "Google русский" },
+        { default: false, lang: "zh-CN", name: "Google 普通话（中国大陆）", localService: false, voiceURI: "Google 普通话（中国大陆）" },
+        { default: false, lang: "zh-HK", name: "Google 粤語（香港）", localService: false, voiceURI: "Google 粤語（香港）" },
+        { default: false, lang: "zh-TW", name: "Google 國語（臺灣）", localService: false, voiceURI: "Google 國語（臺灣）" }
+      ];
+
+      expect(getBestBookVoice(voices, 'en', ['en-CA', 'en'])).toBe(voices[0]);
+    });
+  });
+}
+
+/** @type {TTSEngineOptions} */
+export const DUMMY_TTS_ENGINE_OPTS = {
+  server: 'blah',
+  bookPath: 'blah',
+  bookLanguage: 'blah',
+  onLoadingStart() {},
+  onLoadingComplete() {},
+  onDone() {},
+  beforeChunkPlay() { return Promise.resolve(); },
+  afterChunkPlay() {},
+};
+
+/**
+ * @param {SpeechSynthesisVoice}
+ * @return {SpeechSynthesisVoice}
+ **/
+function dummyVoice(overrides) {
+  return Object.assign({
+    default: false,
+    lang: "en-US",
+    name: "Microsoft David",
+    localService: false,
+    voiceURI: "",
+  }, overrides);
+}
+
+/**
+ * Construct a voice-like object using underscores instead of hyphenes
+ * (Like Chrome/Android)
+ * @param {SpeechSynthesisVoice}
+ * @return {SpeechSynthesisVoice}
+ **/
+function dummyVoiceUnderscores(overrides) {
+  const voice = dummyVoice(overrides);
+  voice.lang = voice.lang.replace('-', '_');
+  return voice;
+}

package/tests/plugins/tts/FestivalTTSEngine.test.js

@@ -0,0 +1,59 @@
+import FestivalTTSEngine from '../../../src/plugins/tts/FestivalTTSEngine.js';
+import sinon from 'sinon';
+import { afterEventLoop } from '../../utils.js';
+import { DUMMY_TTS_ENGINE_OPTS } from './AbstractTTSEngine.test.js';
+import PageChunk from '../../../src/plugins/tts/PageChunk.js';
+import PageChunkIterator from '../../../src/plugins/tts/PageChunkIterator.js';
+/** @typedef {import('../../../src/plugins/tts/AbstractTTSEngine.js').TTSEngineOptions} TTSEngineOptions */
+
+describe('iOSCaptureUserIntentHack', () => {
+  test('synchronously calls createSound/play to capture user intent', () => {
+    const mockSound = createMockSound();
+    const sm = {
+      supported: sinon.stub().returns(true),
+      createSound: sinon.stub().returns(mockSound),
+    };
+    window.soundManager = sm;
+    const engine = new FestivalTTSEngine(DUMMY_TTS_ENGINE_OPTS);
+    engine.iOSCaptureUserIntentHack();
+
+    expect(sm.createSound.callCount).toBe(1);
+    expect(mockSound.play.callCount).toBe(1);
+  });
+});
+
+describe('misc', () => {
+  test('starts playing even if onload not called until play starts', async () => {
+    const sm = {
+      supported: sinon.stub().returns(true),
+      createSound: sinon.stub().returns(createMockSound()),
+      stopAll: sinon.stub(),
+    };
+    window.soundManager = sm;
+    const engine = new FestivalTTSEngine(DUMMY_TTS_ENGINE_OPTS);
+    sinon.stub(engine, 'playSound').returns(new Promise(() => {}));
+    sinon.stub(engine, 'stop');
+    sinon.stub(PageChunkIterator.prototype, '_fetchPageChunks').resolves([dummyPageChunk()]);
+    engine.start(0, 5);
+
+    // because things happen in callbacks, need to run code at end of the JS event loop
+    await afterEventLoop();
+    expect(sm.createSound.callCount).toBe(1);
+    expect(PageChunkIterator.prototype._fetchPageChunks.callCount).toBeGreaterThanOrEqual(1);
+    expect(engine.playSound.callCount).toBe(1);
+  });
+});
+
+/** @returns {SMSound} */
+function createMockSound() {
+  return {
+    load: sinon.stub(),
+    play: sinon.stub(),
+    destruct: sinon.stub(),
+  };
+}
+
+/** @return {PageChunk} */
+function dummyPageChunk() {
+  return new PageChunk(0, 0, 'Once upon a time', []);
+}

package/tests/plugins/tts/PageChunk.test.js

@@ -0,0 +1,57 @@
+import PageChunk from '../../../src/plugins/tts/PageChunk.js';
+
+describe('_fixChunkRects', () => {
+  const { _fixChunkRects } = PageChunk;
+
+  test('Handles empty array', () => {
+    const rects = [];
+    expect(_fixChunkRects(rects)).toBe(rects);
+    expect(rects).toEqual([]);
+  });
+
+  test('Does not modify normal values values normal', () => {
+    const rects = [[100,100,500,80], [200,200,500,180], [300,300,500,280]];
+    expect(_fixChunkRects(rects)).toBe(rects);
+    expect(rects).toEqual([[100,100,500,80], [200,200,500,180], [300,300,500,280]]);
+  });
+
+  test('Fixes outlier values in first rect', () => {
+    const rects = [[100,2300,2300,0], [200,200,200,180], [300,300,200,280]];
+    expect(_fixChunkRects(rects)).toBe(rects);
+    expect(rects).toEqual([[100,2300,200,2280], [200,200,200,180], [300,300,200,280]]);
+  });
+});
+
+describe('_fromTextWrapperResponse', () => {
+  const { _fromTextWrapperResponse } = PageChunk;
+
+  test('Handles empty array', () => {
+    expect(_fromTextWrapperResponse(0, [])).toEqual([]);
+  });
+
+  test('Basic test', () => {
+    const chunks = _fromTextWrapperResponse(0, [['Line', [0,100,100,0]]]);
+    expect(chunks).toEqual([new PageChunk(0, 0, 'Line', [[0,100,100,0]])]);
+  });
+});
+
+describe('_removeDanglingHyphens', () => {
+  const { _removeDanglingHyphens } = PageChunk;
+
+  test('No change to empty string', () => {
+    expect(_removeDanglingHyphens('')).toEqual('');
+  });
+
+  test('No change when no hyphens string', () => {
+    expect(_removeDanglingHyphens('Hello world!')).toEqual('Hello world!');
+  });
+
+  test('No change to hyphens mid-word', () => {
+    expect(_removeDanglingHyphens('It is mid-word!')).toEqual('It is mid-word!');
+  });
+
+  test('Removes hyphens followed by spaces', () => {
+    expect(_removeDanglingHyphens('It is not mid- word!')).toEqual('It is not midword!');
+    expect(_removeDanglingHyphens('mid- word fid- word')).toEqual('midword fidword');
+  });
+});

package/tests/plugins/tts/PageChunkIterator.test.js

@@ -0,0 +1,179 @@
+import sinon from 'sinon';
+import PageChunkIterator from "../../../src/plugins/tts/PageChunkIterator";
+import PageChunk from '../../../src/plugins/tts/PageChunk';
+
+describe('Buffers pages', () => {
+  test('Does not error if no room for reverse buffer', async () => {
+    const iterator = new PageChunkIterator(100, 0, {pageBufferSize: 5});
+    sinon.stub(iterator, '_fetchPageChunksDirect').resolves([dummyPageChunk()]);
+    await iterator.next();
+    expect(iterator._fetchPageChunksDirect.callCount).toBe(6);
+    expect(Object.keys(iterator._bufferedPages).length).toBe(6);
+  });
+
+  test('Does not error if no room for forward buffer', async () => {
+    const iterator = new PageChunkIterator(100, 99, {pageBufferSize: 5});
+    sinon.stub(iterator, '_fetchPageChunksDirect').resolves([dummyPageChunk()]);
+    await iterator.next();
+    expect(iterator._fetchPageChunksDirect.callCount).toBe(6);
+    expect(Object.keys(iterator._bufferedPages).length).toBe(6);
+  });
+
+  test('Fewer pages than buffer size', async () => {
+    const iterator = new PageChunkIterator(1, 0, {pageBufferSize: 5});
+    sinon.stub(iterator, '_fetchPageChunksDirect').resolves([dummyPageChunk()]);
+    await iterator.next();
+    expect(iterator._fetchPageChunksDirect.callCount).toBe(1);
+    expect(Object.keys(iterator._bufferedPages).length).toBe(1);
+  });
+
+  test('Buffers data before/after', async () => {
+    const iterator = new PageChunkIterator(100, 50, {pageBufferSize: 5});
+    sinon.stub(iterator, '_fetchPageChunksDirect').resolves([dummyPageChunk()]);
+    await iterator.next();
+    expect(iterator._fetchPageChunksDirect.callCount).toBe(11);
+    expect(Object.keys(iterator._bufferedPages).length).toBe(11);
+  });
+
+  test('Buffer size does not grow indefinitely', async () => {
+    const iterator = new PageChunkIterator(100, 50, {pageBufferSize: 5});
+    sinon.stub(iterator, '_fetchPageChunksDirect').resolves([dummyPageChunk()]);
+    for (let i = 0; i < 5; i++) await iterator.next();
+    expect(Object.keys(iterator._bufferedPages).length).toBe(11);
+  });
+
+  test('Does not make a new request if buffered', async () => {
+    const iterator = new PageChunkIterator(10, 7, {pageBufferSize: 5});
+    sinon.stub(iterator, '_fetchPageChunksDirect').resolves([dummyPageChunk()]);
+
+    await iterator.next();
+    expect(iterator._fetchPageChunksDirect.callCount).toBe(8);
+
+    await iterator.next();
+    expect(iterator._fetchPageChunksDirect.callCount).toBe(8);
+  });
+});
+
+describe('Iterates pages', () => {
+  test('Moves between chunks before moving between pages', async ()  => {
+    const iterator = new PageChunkIterator(100, 50, {pageBufferSize: 5});
+    const chunks = [
+      dummyPageChunk(),
+      dummyPageChunk(),
+      dummyPageChunk(),
+    ];
+    sinon.stub(iterator, '_fetchPageChunksDirect').resolves(chunks);
+
+    for (let i = 0; i < 4; i++) {
+      expect(iterator._cursor.page).toBe(50);
+      expect(iterator._cursor.chunk).toBe(i);
+      await iterator.next();
+    }
+
+    expect(iterator._cursor.page).toBe(51);
+    expect(iterator._cursor.chunk).toBe(1);
+  });
+
+  test('Fires AT_END when done', async () => {
+    const iterator = new PageChunkIterator(1, 0, {pageBufferSize: 5});
+    sinon.stub(iterator, '_fetchPageChunksDirect').resolves([dummyPageChunk()]);
+
+    expect((await iterator.next()) instanceof PageChunk).toBe(true);
+    expect(await iterator.next()).toBe(PageChunkIterator.AT_END);
+  });
+
+  test('Fires AT_END reaching past end', async () => {
+    const iterator = new PageChunkIterator(1, 0, {pageBufferSize: 5});
+    sinon.stub(iterator, '_fetchPageChunksDirect').resolves([dummyPageChunk()]);
+
+    expect((await iterator.next()) instanceof PageChunk).toBe(true);
+    expect(iterator._cursor.page).toBe(0);
+    expect(iterator._cursor.chunk).toBe(1);
+
+    for (let i = 0; i < 4; i++) {
+      expect(await iterator.next()).toBe(PageChunkIterator.AT_END);
+      expect(iterator._cursor.page).toBe(1);
+      expect(iterator._cursor.chunk).toBe(0);
+    }
+  });
+
+  test('Moves backwards between chunks/pages', async () => {
+    const iterator = new PageChunkIterator(100, 50, {pageBufferSize: 5});
+    const chunks = [
+      dummyPageChunk(),
+      dummyPageChunk(),
+      dummyPageChunk(),
+    ];
+    sinon.stub(iterator, '_fetchPageChunksDirect').resolves(chunks);
+    expect(iterator._cursor.page).toBe(50);
+    expect(iterator._cursor.chunk).toBe(0);
+
+    for (let i = 2; i >= 0; i--) {
+      await iterator.decrement();
+      expect(iterator._cursor.page).toBe(49);
+      expect(iterator._cursor.chunk).toBe(i);
+    }
+
+    await iterator.decrement();
+    expect(iterator._cursor.page).toBe(48);
+    expect(iterator._cursor.chunk).toBe(2);
+  });
+
+  test('Moving backwards at start refires start chunk', async () => {
+    const iterator = new PageChunkIterator(100, 0, {pageBufferSize: 5});
+    const chunks = [
+      dummyPageChunk(),
+      dummyPageChunk(),
+      dummyPageChunk(),
+    ];
+    sinon.stub(iterator, '_fetchPageChunksDirect').resolves(chunks);
+
+    for (let i = 0; i < 4; i++) {
+      expect(iterator._cursor.page).toBe(0);
+      expect(iterator._cursor.chunk).toBe(0);
+      await iterator.decrement();
+    }
+  });
+
+  test('Empty book', async () => {
+    const iterator = new PageChunkIterator(100, 0, {pageBufferSize: 5});
+    sinon.stub(iterator, '_fetchPageChunksDirect').resolves([]);
+    const result = await iterator.next();
+    expect(iterator._fetchPageChunksDirect.callCount).toBe(100);
+    expect(result).toBe(PageChunkIterator.AT_END);
+  });
+
+  test('Moving forward through empty pages', async () => {
+    const iterator = new PageChunkIterator(10, 0, {pageBufferSize: 5});
+    const nonEmptyPages = {
+      0: [dummyPageChunk()],
+      5: [dummyPageChunk()],
+    };
+    sinon.stub(iterator, '_fetchPageChunksDirect')
+      .callsFake(async i => nonEmptyPages[i] || []);
+
+    const result0 = await iterator.next();
+    expect(result0).toBe(nonEmptyPages[0][0]);
+
+    const result1 = await iterator.next();
+    expect(result1).toBe(nonEmptyPages[5][0]);
+  });
+
+  test('Moving backward through empty pages', async () => {
+    const iterator = new PageChunkIterator(10, 5, {pageBufferSize: 5});
+    const nonEmptyPages = {
+      0: [dummyPageChunk()],
+      5: [dummyPageChunk()],
+    };
+    sinon.stub(iterator, '_fetchPageChunksDirect')
+      .callsFake(async i => nonEmptyPages[i] || []);
+
+    await iterator.decrement();
+    const result0 = await iterator.next();
+    expect(result0).toBe(nonEmptyPages[0][0]);
+  });
+});
+
+function dummyPageChunk() {
+  return new PageChunk(0, 0, "Line", []);
+}

package/tests/plugins/tts/WebTTSEngine.test.js

@@ -0,0 +1,126 @@
+import sinon from 'sinon';
+import { WebTTSSound } from '../../../src/plugins/tts/WebTTSEngine.js';
+import { afterEventLoop, eventTargetMixin } from '../../utils.js';
+
+beforeEach(() => {
+  window.speechSynthesis = {
+    cancel: sinon.stub(),
+    speak: sinon.stub(),
+    pause: sinon.stub(),
+    resume: sinon.stub(),
+    ...eventTargetMixin(),
+  };
+  window.SpeechSynthesisUtterance = function (text) {
+    this.text = text;
+    Object.assign(this, eventTargetMixin());
+  };
+});
+
+afterEach(() => {
+  delete window.speechSynthesis;
+  delete window.SpeechSynthesisUtterance;
+});
+
+
+describe('WebTTSSound', () => {
+  describe('setPlaybackRate', () => {
+    test('works if not playing', () => {
+      const sound = new WebTTSSound('hello world');
+      sound.load();
+      expect(sound.rate).toBe(1);
+      sound.setPlaybackRate(2);
+      expect(sound.rate).toBe(2);
+    });
+
+    test('reloading does not resolve the original promise', async () => {
+      const sound = new WebTTSSound('hello world');
+      sound.load();
+      const finishSpy = sinon.spy();
+      sound.play().then(finishSpy);
+      sound.reload();
+      sound.utterance.dispatchEvent('pause', {});
+      await afterEventLoop();
+      sound.utterance.dispatchEvent('end', {});
+      await afterEventLoop();
+      expect(finishSpy.callCount).toBe(0);
+    });
+  });
+
+  describe('_chromePausingBugFix', () => {
+    test('if speech less than 15s, nothing special', async () => {
+      const clock = sinon.useFakeTimers();
+      const sound = new WebTTSSound('hello world foo bar');
+      sound.load();
+      sound.play();
+      sound._chromePausingBugFix();
+      clock.tick(10000);
+      sound.utterance.dispatchEvent('end', {});
+      clock.restore();
+      await afterEventLoop();
+      expect(speechSynthesis.pause.callCount).toBe(0);
+    });
+
+    test('if speech greater than 15s, pause called', async () => {
+      const clock = sinon.useFakeTimers();
+      const sound = new WebTTSSound('foo bah');
+      sound.load();
+      sound.play();
+      sound._chromePausingBugFix();
+      clock.tick(20000);
+      clock.restore();
+
+      await afterEventLoop();
+      expect(speechSynthesis.pause.callCount).toBe(1);
+    });
+
+    test('on pause reloads if timed out', async () => {
+      const clock = sinon.useFakeTimers();
+      const sound = new WebTTSSound('foo bah');
+      sound.load();
+      sound.play();
+      sound._chromePausingBugFix();
+      sound.pause();
+      clock.tick(2000);
+      clock.restore();
+
+      await afterEventLoop();
+      expect(speechSynthesis.cancel.callCount).toBe(1);
+    });
+  });
+
+  test('fire pause if browser does not do it', async () => {
+    const clock = sinon.useFakeTimers();
+    const languageGetter = jest.spyOn(window.navigator, 'userAgent', 'get');
+    languageGetter.mockReturnValue('firefox android');
+    const sound = new WebTTSSound('foo bah');
+    sound.load();
+    sound.play();
+    const dispatchSpy = sinon.spy(sound.utterance, 'dispatchEvent');
+    sound.pause();
+    clock.tick(1000);
+    clock.restore();
+
+    await afterEventLoop();
+    expect(dispatchSpy.callCount).toBe(1);
+    expect(dispatchSpy.args[0][0].type).toBe('pause');
+  });
+
+  test('fire resume if browser does not do it', async () => {
+    const clock = sinon.useFakeTimers();
+    const languageGetter = jest.spyOn(window.navigator, 'userAgent', 'get');
+    languageGetter.mockReturnValue('firefox android');
+    const sound = new WebTTSSound('foo bah');
+    sound.load();
+    sound.play();
+    sound.started = true;
+    sound.paused = true;
+    const dispatchSpy = sinon.spy(sound.utterance, 'dispatchEvent');
+    sound.resume();
+    clock.tick(1000);
+    clock.restore();
+
+    await afterEventLoop();
+    expect(dispatchSpy.callCount).toBe(1);
+    expect(dispatchSpy.args[0][0].type).toBe('resume');
+  });
+});