@internetarchive/bookreader 5.0.0-58 → 5.0.0-59

package/tests/jest/BookReader/Mode2Up.test.js

@@ -1,7 +1,9 @@
 
 import sinon from 'sinon';
-import { deepCopy } from '../utils.js';
+import { Mode2Up } from '@/src/BookReader/Mode2Up.js';
 import BookReader from '@/src/BookReader.js';
+import { BookModel } from '@/src/BookReader/BookModel.js';
+import { afterEventLoop } from '../utils';
 /** @typedef {import('@/src/BookReader/options.js').BookReaderOptions} BookReaderOptions */
 
 beforeAll(() => {
@@ -31,238 +33,66 @@ const SAMPLE_DATA = [
 ];
 
 
-describe('zoom', () => {
-  const br = new BookReader({ data: SAMPLE_DATA });
-  br.init();
+describe('Mode2Up', () => {
+  /** @type {BookReader} */
+  let br;
+  /** @type {BookModel} */
+  let bookModel;
+  /** @type {Mode2Up} */
+  let mode2Up;
 
-  const stopAnim = sinon.spy(br, 'stopFlipAnimations');
-  const resizeSpread = sinon.spy(br._modes.mode2Up, 'resizeSpread');
-  br._modes.mode2Up.zoom('in');
-
-  test('stops animations when zooming', () => {
-    expect(stopAnim.callCount).toBe(1);
-  });
-  test('always redraws when zooming', () => {
-    expect(resizeSpread.callCount).toBe(0);
-  });
-});
-
-describe('page flip directions', () => {
-  test('animates the left page in the correct direction', () => {
-    const br = new BookReader({ data: SAMPLE_DATA });
-    br.init();
-
-    const fake = sinon.fake();
-    const fakeAnimWithCB = sinon.fake.yields();
-    const fakeAnim = sinon.fake((...args) =>
-      typeof args[args.length - 1] === 'function' ? fakeAnimWithCB(...args) : fake
-    );
-    sinon.replace(jQuery.prototype, 'animate', fakeAnim);
-
-    const fakeCSS = sinon.spy(jQuery.prototype, 'css');
-
-    br.next();
-
-    expect(fakeAnimWithCB.callCount).toBe(2);
-    // Find the call to .css() immediately preceding the second animation with a callback (i.e., the left page animation)
-    const preSecondAnimCssCallIndex = fakeCSS.getCalls().findIndex(call => call.calledAfter(fakeAnimWithCB.getCall(1))) - 1;
-    expect(fakeCSS.getCall(preSecondAnimCssCallIndex).args[0].left).toBe('');
-  });
-});
-
-describe('prefetch', () => {
-  test('loads nearby pages', () => {
-    const br = new BookReader({ data: SAMPLE_DATA });
-    const mode2Up = br._modes.mode2Up;
-    br.init();
-    mode2Up.prefetch();
-    expect(Object.keys(mode2Up.pageContainers).length).toBeGreaterThan(2);
-  });
-
-  test('works when at end of book', () => {
-    const br = new BookReader({ data: SAMPLE_DATA });
-    const mode2Up = br._modes.mode2Up;
-    br.init();
-    br.jumpToIndex(-1);
-    mode2Up.prefetch();
-    expect(Object.keys(mode2Up.pageContainers).length).toBeGreaterThan(2);
-  });
-
-  test('skips consecutive unviewables', () => {
-    const data = deepCopy(SAMPLE_DATA);
-    data[1].forEach(page => page.viewable = false);
-    const br = new BookReader({ data });
-    const mode2Up = br._modes.mode2Up;
-    br.init();
-    mode2Up.prefetch();
-    expect(mode2Up.pageContainers).not.toContain(2);
-  });
-});
-
-describe('draw 2up leaves', () => {
-  test('calls `drawLeafs` on init as default', () => {
-    const br = new BookReader({ data: SAMPLE_DATA });
-    const drawLeafs = sinon.spy(br._modes.mode2Up, 'drawLeafs');
-
-    br.init();
-    expect(drawLeafs.callCount).toBe(1);
-  });
-
-  test('sets `this.displayedIndices`', () => {
-    const extremelyWrongValueForDisplayedIndices = null;
-    const br = new BookReader({ data: SAMPLE_DATA });
-
-    br.init();
-    br.displayedIndices = extremelyWrongValueForDisplayedIndices;
-    expect(br.displayedIndices).toBe(extremelyWrongValueForDisplayedIndices);
-
-    br._modes.mode2Up.drawLeafs();
-
-    expect(br.displayedIndices).not.toBe(extremelyWrongValueForDisplayedIndices);
-    expect(br.displayedIndices.length).toBe(2); // is array
-    expect(br.displayedIndices).toEqual([-1, 0]); // default to starting index on right, placeholder for left
-  });
-});
-
-describe('resizeSpread', () => {
-  test('only resizes spread', () => {
-    const br = new BookReader({ data: SAMPLE_DATA });
-    br.init();
-    const resizeBRcontainer = sinon.spy(br, 'resizeBRcontainer');
-    const calculateSpreadSize = sinon.spy(br._modes.mode2Up, 'calculateSpreadSize');
-    const drawLeafs = sinon.spy(br._modes.mode2Up, 'drawLeafs');
-    const centerView = sinon.spy(br._modes.mode2Up, 'centerView');
-
-    br._modes.mode2Up.resizeSpread();
-    expect(drawLeafs.callCount).toBe(0);  // no draw
-    expect(resizeBRcontainer.callCount).toBe(1);
-    expect(calculateSpreadSize.callCount).toBe(1);
-    expect(centerView.callCount).toBe(1);
-  });
-});
-
-describe('2up Container sizing', () => {
-  test('baseLeafCss', () => {
-    const br = new BookReader({ data: SAMPLE_DATA });
-    br.init();
-    br._modes.mode2Up.calculateSpreadSize();
-    expect(Object.keys(br._modes.mode2Up.baseLeafCss)).toEqual(['position', 'right', 'top', 'zIndex']);
-  });
-  test('heightCss', () => {
-    const br = new BookReader({ data: SAMPLE_DATA });
-    br.init();
-    br._modes.mode2Up.calculateSpreadSize();
-    const heightStub = 1000;
-    br.twoPage.height = heightStub;
-    expect(Object.keys(br._modes.mode2Up.heightCss)).toEqual(['height']);
-    expect(br._modes.mode2Up.heightCss).toEqual({height: `${heightStub}px`});
-  });
-  describe('left side', () => {
-    const br = new BookReader({ data: SAMPLE_DATA });
-    br.init();
-    br._modes.mode2Up.calculateSpreadSize();
-
-    test('leftLeafCss', () => {
-      expect(Object.keys(br._modes.mode2Up.leftLeafCss)).toEqual([
-        'position',
-        'right',
-        'top',
-        'zIndex',
-        'height',
-        'left',
-        'width',
-      ]);
+  beforeEach(() => {
+    br = new BookReader({
+      data: SAMPLE_DATA,
+      el: document.createElement('div'),
     });
-    test('leafEdgeLCss', () => {
-      expect(Object.keys(br._modes.mode2Up.leafEdgeLCss)).toEqual([
-        'height',
-        'width',
-        'left',
-        'top',
-        'border'
-      ]);
-    });
-  });
-  describe('right side', () => {
-    const br = new BookReader({ data: SAMPLE_DATA });
     br.init();
-    br._modes.mode2Up.calculateSpreadSize();
-
-    test('rightLeafCss', () => {
-      expect(Object.keys(br._modes.mode2Up.rightLeafCss)).toEqual([
-        'position',
-        'right',
-        'top',
-        'zIndex',
-        'height',
-        'left',
-        'width',
-      ]);
-    });
-    test('leafEdgeRCss', () => {
-      expect(Object.keys(br._modes.mode2Up.leafEdgeRCss)).toEqual([
-        'height',
-        'width',
-        'left',
-        'top',
-        'border'
-      ]);
-    });
+    bookModel = new BookModel(br);
+    mode2Up = new Mode2Up(br, bookModel);
   });
-  describe('full width container, overlay + spine', () => {
-    test('mainContainerCss', () => {
-      const br = new BookReader({ data: SAMPLE_DATA });
-      br.init();
-      br._modes.mode2Up.calculateSpreadSize();
 
-      expect(Object.keys(br._modes.mode2Up.mainContainerCss)).toEqual(['height', 'width', 'position']);
-    });
-    test('spreadCoverCss', () => {
-      const br = new BookReader({ data: SAMPLE_DATA });
-      br.init();
-      br._modes.mode2Up.calculateSpreadSize();
-      expect(Object.keys(br._modes.mode2Up.spreadCoverCss)).toEqual(['width', 'height', 'visibility']);
-    });
-    test('spineCss', () => {
-      const br = new BookReader({ data: SAMPLE_DATA });
-      br.init();
-      br._modes.mode2Up.calculateSpreadSize();
-      expect(Object.keys(br._modes.mode2Up.spineCss)).toEqual(['width', 'height', 'left', 'top']);
+  describe('prepare', () => {
+    it('initializes DOM properly', async () => {
+      const spyAppend = sinon.spy(br.refs.$brContainer, 'append');
+      const spyRequestUpdate = sinon.spy(mode2Up.mode2UpLit, 'requestUpdate');
+      const initFirstRenderSpy = sinon.spy(mode2Up.mode2UpLit, 'initFirstRender');
+      const jumpToIndexSpy = sinon.spy(mode2Up.mode2UpLit, 'jumpToIndex');
+      sinon.stub(mode2Up.mode2UpLit, 'updateComplete').get(() => Promise.resolve());
+      mode2Up.prepare();
+
+      expect(br.refs.$brContainer[0].style.overflow).toEqual('hidden');
+      expect(spyAppend.calledWith(mode2Up.$el)).toBe(true);
+      expect(mode2Up.mode2UpLit.style.opacity).toEqual('0');
+
+      await afterEventLoop();
+
+      expect(initFirstRenderSpy.called).toBe(true);
+      expect(jumpToIndexSpy.called).toBe(false);
+      expect(mode2Up.everShown).toBe(true);
+      expect(spyRequestUpdate.called).toBe(true);
+      expect(mode2Up.mode2UpLit.style.opacity).toEqual('1');
     });
   });
-});
-
-describe('prepareTwoPageView', () => {
-  describe('drawing spread', () => {
-    test('always draws new spread if `drawNewSpread` is true ', () => {
-      const br = new BookReader({ data: SAMPLE_DATA });
-      const mode2Up = br._modes.mode2Up;
-      br.init();
-      const drawLeafs = sinon.spy(mode2Up, 'drawLeafs');
-      const resizeSpread = sinon.spy(mode2Up, 'resizeSpread');
-      const calculateSpreadSize = sinon.spy(mode2Up, 'calculateSpreadSize');
-      const prunePageContainers = sinon.spy(mode2Up, 'prunePageContainers');
-      const prefetch = sinon.spy(mode2Up, 'prefetch');
-      const centerView = sinon.spy(mode2Up, 'centerView');
-      const preparePopUp = sinon.spy(mode2Up, 'preparePopUp');
-      const updateBrClasses = sinon.spy(br, 'updateBrClasses');
 
-      mode2Up.prepare(undefined, undefined, true);
-      expect(prefetch.callCount).toBe(1);
-
-      expect(resizeSpread.callCount).toBe(0);
-      expect(drawLeafs.callCount).toBe(1);
-      expect(calculateSpreadSize.callCount).toBe(1);
-      expect(prunePageContainers.callCount).toBe(1);
-      expect(centerView.callCount).toBe(1);
-      expect(preparePopUp.callCount).toBe(1);
-      expect(updateBrClasses.callCount).toBe(1);
+  describe('resizePageView', () => {
+    it('updates autoFit when possible', async () => {
+      const updateClientSizesSpy = sinon.stub(mode2Up.mode2UpLit.htmlDimensionsCacher, 'updateClientSizes');
+      const resizeViaAutofitSpy = sinon.spy(mode2Up.mode2UpLit, 'resizeViaAutofit');
+      const recenterStub = sinon.stub(mode2Up.mode2UpLit, 'recenter');
+
+      mode2Up.resizePageView();
+      expect(updateClientSizesSpy.called).toBe(true);
+      expect(resizeViaAutofitSpy.called).toBe(true);
+      expect(recenterStub.called).toBe(true);
+
+      // Test with scale and autoFit as 'none'
+      mode2Up.mode2UpLit.scale = 0.1;
+      mode2Up.mode2UpLit.autoFit = 'none';
+      mode2Up.resizePageView();
+
+      expect(mode2Up.mode2UpLit.autoFit).toEqual('auto');
+      expect(resizeViaAutofitSpy.callCount).toEqual(2);
+      expect(recenterStub.callCount).toEqual(2);
     });
   });
 });
-
-test('uses ImageCache', () => {
-  const br = new BookReader({ data: SAMPLE_DATA });
-  br.init();
-  expect(Object.keys(br.imageCache.cache).length).toBeGreaterThan(2);
-});

package/tests/jest/BookReader/Mode2UpLit.test.js

@@ -0,0 +1,190 @@
+import sinon from "sinon";
+import { BookModel } from "@/src/BookReader/BookModel.js";
+import { Mode2UpLit } from "@/src/BookReader/Mode2UpLit.js";
+
+/** @type {import('@/src/BookReader/options.js').BookReaderOptions['data']} */
+const SAMPLE_DATA = [
+  [
+    {
+      width: 123,
+      height: 123,
+      uri: "https://archive.org/image0.jpg",
+      pageNum: "1",
+    },
+  ],
+  [
+    {
+      width: 123,
+      height: 123,
+      uri: "https://archive.org/image1.jpg",
+      pageNum: "2",
+    },
+    {
+      width: 123,
+      height: 123,
+      uri: "https://archive.org/image2.jpg",
+      pageNum: "3",
+    },
+  ],
+  [
+    {
+      width: 123,
+      height: 123,
+      uri: "https://archive.org/image3.jpg",
+      pageNum: "4",
+    },
+    {
+      width: 123,
+      height: 123,
+      uri: "https://archive.org/image4.jpg",
+      pageNum: "5",
+    },
+  ],
+  [
+    {
+      width: 123,
+      height: 123,
+      uri: "https://archive.org/image5.jpg",
+      pageNum: "6",
+    },
+  ],
+];
+
+function make_dummy_br(overrides = {}) {
+  return Object.assign({
+    updateFirstIndex() {},
+    _components: {
+      navbar: {
+        updateNavIndexThrottled() {},
+      },
+    },
+    data: [],
+  }, overrides);
+}
+
+afterEach(() => {
+  sinon.restore();
+});
+
+describe("computePageHeight", () => {
+  test("Always returns the median", () => {
+    const mode = new Mode2UpLit({
+      getMedianPageSizeInches: () => ({ width: 100, height: 200 }),
+    }, null);
+    expect(mode.computePageHeight(null)).toEqual(200);
+    expect(mode.computePageHeight({ widthInches: 300, heightInches: 400 }))
+      .toEqual(200);
+  });
+});
+
+describe("computePageWidth", () => {
+  test("returns relative to pageHeight", () => {
+    const mode = new Mode2UpLit(null, null);
+    sinon.stub(mode, "computePageHeight").returns(6);
+
+    expect(mode.computePageWidth({ widthInches: 2, heightInches: 6 })).toEqual(
+      2,
+    );
+    expect(mode.computePageWidth({ widthInches: 3, heightInches: 6 })).toEqual(
+      3,
+    );
+    expect(mode.computePageWidth({ widthInches: 2, heightInches: 4 })).toEqual(
+      2 * 6 / 4,
+    );
+  });
+});
+
+describe("computePositions", () => {
+  const LEFT_COVER_EXPECTED = {
+    leafEdgesLeftStart: -0.246,
+    leafEdgesLeftMainWidth: 0,
+    leafEdgesLeftMovingStart: -0.246,
+    leafEdgesLeftMovingWidth: 0,
+    leafEdgesLeftEnd: -0.246,
+    leafEdgesLeftFullWidth: 0,
+    pageLeftStart: -0.246,
+    pageLeftWidth: 0.246,
+    pageLeftEnd: 0,
+    gutter: 0,
+    pageRightStart: 0,
+    pageRightWidth: 0.246,
+    pageRightEnd: 0.246,
+    leafEdgesRightStart: 0.246,
+    leafEdgesRightMovingWidth: 0,
+    leafEdgesRightMainStart: 0.246,
+    leafEdgesRightMainWidth: 0.006,
+    leafEdgesRightEnd: 0.252,
+    leafEdgesRightFullWidth: 0.006,
+    spreadWidth: 0.492,
+    bookWidth: 0.498
+  };
+  const SPREAD_EXPECTED = {
+    leafEdgesLeftStart: -0.246,
+    leafEdgesLeftMainWidth: 0.002,
+    leafEdgesLeftMovingStart: -0.244,
+    leafEdgesLeftMovingWidth: 0,
+    leafEdgesLeftEnd: -0.244,
+    leafEdgesLeftFullWidth: 0.002,
+    pageLeftStart: -0.244,
+    pageLeftWidth: 0.246,
+    pageLeftEnd: 0.002,
+    gutter: 0.002,
+    pageRightStart: 0.002,
+    pageRightWidth: 0.246,
+    pageRightEnd: 0.248,
+    leafEdgesRightStart: 0.248,
+    leafEdgesRightMovingWidth: 0,
+    leafEdgesRightMainStart: 0.248,
+    leafEdgesRightMainWidth: 0.004,
+    leafEdgesRightEnd: 0.252,
+    leafEdgesRightFullWidth: 0.004,
+    spreadWidth: 0.492,
+    bookWidth: 0.498
+  };
+  const RIGHT_COVER_EXPECTED = {
+    leafEdgesLeftStart: -0.242,
+    leafEdgesLeftMainWidth: 0.006,
+    leafEdgesLeftMovingStart: -0.236,
+    leafEdgesLeftMovingWidth: 0,
+    leafEdgesLeftEnd: -0.236,
+    leafEdgesLeftFullWidth: 0.006,
+    pageLeftStart: -0.236,
+    pageLeftWidth: 0.246,
+    pageLeftEnd: 0.01,
+    gutter: 0.01,
+    pageRightStart: 0.01,
+    pageRightWidth: 0,
+    pageRightEnd: 0.01,
+    leafEdgesRightStart: 0.01,
+    leafEdgesRightMovingWidth: 0,
+    leafEdgesRightMainStart: 0.01,
+    leafEdgesRightMainWidth: 0,
+    leafEdgesRightEnd: 0.01,
+    leafEdgesRightFullWidth: 0,
+    spreadWidth: 0.246,
+    bookWidth: 0.252
+  };
+
+  test("left cover page", () => {
+    const br = make_dummy_br({ data: SAMPLE_DATA });
+    const book = new BookModel(br);
+    const mode = new Mode2UpLit(book, br);
+    expect(mode.computePositions(null, book.getPage(0))).toEqual(LEFT_COVER_EXPECTED);
+  });
+
+  test("spread", () => {
+    const br = make_dummy_br({ data: SAMPLE_DATA });
+    const book = new BookModel(br);
+    const mode = new Mode2UpLit(book, br);
+
+    expect(mode.computePositions(book.getPage(1), book.getPage(2))).toEqual(SPREAD_EXPECTED);
+  });
+
+  test("right cover page", () => {
+    const br = make_dummy_br({ data: SAMPLE_DATA });
+    const book = new BookModel(br);
+    const mode = new Mode2UpLit(book, br);
+
+    expect(mode.computePositions(book.getPage(-1), null)).toEqual(RIGHT_COVER_EXPECTED);
+  });
+});

package/tests/jest/BookReader/ModeCoordinateSpace.test.js

@@ -0,0 +1,16 @@
+import { ModeCoordinateSpace } from "@/src/BookReader/ModeCoordinateSpace";
+
+describe("worldUnitsToRenderedPixels", () => {
+  test("0 case", () => {
+    const mcs = new ModeCoordinateSpace({ scale: 1 });
+    expect(mcs.worldUnitsToRenderedPixels(0)).toBe(0);
+  });
+
+  test("Misc cases", () => {
+    const mcs = new ModeCoordinateSpace({ scale: 1 });
+    mcs.screenDPI = 100;
+    expect(mcs.worldUnitsToRenderedPixels(1)).toBe(100);
+    mcs.screenDPI = 78;
+    expect(mcs.worldUnitsToRenderedPixels(1)).toBe(78);
+  });
+});

package/tests/jest/BookReader/ModeSmoothZoom.test.js

@@ -146,4 +146,30 @@ describe('ModeSmoothZoom', () => {
       expect(mode.scale).not.toBe(1);
     });
   });
+
+  describe("updateViewportOnZoom", () => {
+    test("adjusts scroll position when zooming in", () => {
+      const mode = dummy_mode();
+      const msz = new ModeSmoothZoom(mode);
+      mode.$container.scrollTop = 100;
+      mode.$container.scrollLeft = 100;
+
+      msz.updateViewportOnZoom(2, 1);
+
+      expect(mode.$container.scrollTop).toBeGreaterThan(100);
+      expect(mode.$container.scrollLeft).toBeGreaterThan(100);
+    });
+
+    test("updates scroll position when zooming out", () => {
+      const mode = dummy_mode();
+      const msz = new ModeSmoothZoom(mode);
+      mode.$container.scrollTop = 100;
+      mode.$container.scrollLeft = 100;
+
+      msz.updateViewportOnZoom(0.5, 1);
+
+      expect(mode.$container.scrollTop).toBeLessThan(100);
+      expect(mode.$container.scrollLeft).toBeLessThan(100);
+    });
+  });
 });

package/tests/jest/BookReader/Navbar/Navbar.test.js

@@ -63,14 +63,14 @@ describe('Navbar slider', () => {
 
   test('on slide change, actual page changes', () => {
     const $slider = navbar.$root.find('.BRpager');
-    const jumpToIndexSpy = sinon.spy(br, 'jumpToIndex');
+    const jumpToIndexStub = sinon.stub(br, 'jumpToIndex');
     expect(br.currentIndex()).toBe(0);
 
     $slider.trigger('slidechange', { value: 3 });
 
     expect(navbar.$root.find('.BRcurrentpage').text().includes('3'));
-    expect(jumpToIndexSpy.callCount).toBe(1);
-    expect(jumpToIndexSpy.args[0][0]).toBe(3);
+    expect(jumpToIndexStub.callCount).toBe(1);
+    expect(jumpToIndexStub.args[0][0]).toBe(3);
   });
 });
 

package/tests/jest/BookReader/utils.test.js

@@ -1,5 +1,5 @@
 import sinon from 'sinon';
-import { afterEventLoop } from '../utils.js';
+import { afterEventLoop, eventTargetMixin } from '../utils.js';
 import {
   clamp,
   cssPercentage,
@@ -12,6 +12,7 @@ import {
   poll,
   polyfillCustomEvent,
   PolyfilledCustomEvent,
+  promisifyEvent,
   sleep,
 } from '@/src/BookReader/utils.js';
 
@@ -184,3 +185,33 @@ describe('sleep', () => {
     expect(spy.callCount).toBe(1);
   });
 });
+
+describe('promisifyEvent', () => {
+  test('Resolves once event fires', async () => {
+    const fakeTarget = eventTargetMixin();
+    const resolveSpy = sinon.spy();
+    promisifyEvent(fakeTarget, 'pause').then(resolveSpy);
+
+    await afterEventLoop();
+    expect(resolveSpy.callCount).toBe(0);
+    fakeTarget.dispatchEvent('pause', {});
+    await afterEventLoop();
+    expect(resolveSpy.callCount).toBe(1);
+  });
+
+  test('Only resolves once', async () => {
+    const fakeTarget = eventTargetMixin();
+    const resolveSpy = sinon.spy();
+    promisifyEvent(fakeTarget, 'pause').then(resolveSpy);
+
+    await afterEventLoop();
+    expect(resolveSpy.callCount).toBe(0);
+    fakeTarget.dispatchEvent('pause', {});
+    fakeTarget.dispatchEvent('pause', {});
+    fakeTarget.dispatchEvent('pause', {});
+    fakeTarget.dispatchEvent('pause', {});
+
+    await afterEventLoop();
+    expect(resolveSpy.callCount).toBe(1);
+  });
+});

package/tests/jest/plugins/tts/utils.test.js

@@ -1,39 +1,5 @@
-import sinon from 'sinon';
-import { afterEventLoop, eventTargetMixin } from '../../utils.js';
 import * as utils from '@/src/plugins/tts/utils.js';
 
-describe('promisifyEvent', () => {
-  const { promisifyEvent } = utils;
-
-  test('Resolves once event fires', async () => {
-    const fakeTarget = eventTargetMixin();
-    const resolveSpy = sinon.spy();
-    promisifyEvent(fakeTarget, 'pause').then(resolveSpy);
-
-    await afterEventLoop();
-    expect(resolveSpy.callCount).toBe(0);
-    fakeTarget.dispatchEvent('pause', {});
-    await afterEventLoop();
-    expect(resolveSpy.callCount).toBe(1);
-  });
-
-  test('Only resolves once', async () => {
-    const fakeTarget = eventTargetMixin();
-    const resolveSpy = sinon.spy();
-    promisifyEvent(fakeTarget, 'pause').then(resolveSpy);
-
-    await afterEventLoop();
-    expect(resolveSpy.callCount).toBe(0);
-    fakeTarget.dispatchEvent('pause', {});
-    fakeTarget.dispatchEvent('pause', {});
-    fakeTarget.dispatchEvent('pause', {});
-    fakeTarget.dispatchEvent('pause', {});
-
-    await afterEventLoop();
-    expect(resolveSpy.callCount).toBe(1);
-  });
-});
-
 describe('approximateWordCount', () => {
   const { approximateWordCount } = utils;