@internetarchive/bookreader 5.0.0-9-multiple-files → 5.0.0-90

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

@@ -0,0 +1,250 @@
+import sinon from 'sinon';
+import { afterEventLoop, eventTargetMixin } from '../utils.js';
+import {
+  clamp,
+  cssPercentage,
+  debounce,
+  decodeURIComponentPlus,
+  encodeURIComponentPlus,
+  escapeHTML,
+  escapeRegExp,
+  getActiveElement,
+  isInputActive,
+  parseAnimationSpeed,
+  poll,
+  polyfillCustomEvent,
+  PolyfilledCustomEvent,
+  promisifyEvent,
+  sleep,
+} from '@/src/BookReader/utils.js';
+
+test('clamp function returns Math.min(Math.max(value, min), max)', () => {
+  expect(clamp(2,1,3)).toEqual(2);
+});
+
+test('calculate a percentage suitable for CSS', () => {
+  expect(cssPercentage(2,1)).toEqual('200%');
+});
+
+test('escapeHTML function which replaces the string', () => {
+  expect(escapeHTML('Me & You')).toEqual('Me & You');
+  expect(escapeHTML('Me > You')).toEqual('Me > You');
+  expect(escapeHTML('Me < You')).toEqual('Me &lt; You');
+  expect(escapeHTML('Me " You')).toEqual('Me &quot; You');
+});
+
+test('Decodes a URI component and converts + to emptyStr', () => {
+  expect(decodeURIComponentPlus("https%3A%2F%2Farchive.org%2Fskr+")).toEqual("https://archive.org/skr ");
+  expect(decodeURIComponentPlus("%3Fx%3D+test")).toEqual("?x= test");
+});
+
+test('Encodes a URI component and converts emptyStr to +', () => {
+  expect(encodeURIComponentPlus("?x=test ")).toEqual("%3Fx%3Dtest+");
+  expect(encodeURIComponentPlus("ABC abc 123")).toEqual("ABC+abc+123");
+});
+
+describe('getActiveElement', () => {
+  test('Can ignore shadow DOM', () => {
+    const doc = {activeElement: { shadowRoot: {activeElement: {}}}};
+    expect(getActiveElement(doc, false)).toBe(doc.activeElement);
+  });
+
+  test('Can traverse shadow DOM', () => {
+    const doc = {activeElement: { shadowRoot: {activeElement: {}}}};
+    expect(getActiveElement(doc, true)).toBe(doc.activeElement.shadowRoot.activeElement);
+  });
+
+  test('Handles non-shadow elements', () => {
+    const doc = {activeElement: {}};
+    expect(getActiveElement(doc, true)).toBe(doc.activeElement);
+  });
+
+  test('Handles no active element', () => {
+    const doc = {activeElement: null};
+    expect(getActiveElement(doc, true)).toBe(null);
+  });
+});
+
+describe('isInputActive', () => {
+  test('Handles no activeElement', () => {
+    expect(isInputActive({activeElement: null})).toBe(false);
+  });
+
+  test('Handles deep input activeElement', () => {
+    const doc = {activeElement: { shadowRoot: {activeElement: { tagName: 'INPUT' }}}};
+    expect(isInputActive(doc)).toBe(true);
+  });
+
+  test('Handles deep non-input activeElement', () => {
+    const doc = {activeElement: { shadowRoot: {activeElement: { tagName: 'A' }}}};
+    expect(isInputActive(doc)).toBe(false);
+  });
+
+  test('Handles textarea activeElement', () => {
+    const doc = {activeElement: { tagName: 'TEXTAREA' }};
+    expect(isInputActive(doc)).toBe(true);
+  });
+});
+
+describe('debounce', () => {
+  /** @type {sinon.SinonFakeTimers} */
+  let clock;
+  beforeEach(() => clock = sinon.useFakeTimers());
+  afterEach(() => clock.restore());
+
+  test('testing debounce', () => {
+    const func = jest.fn();
+    const debouncedFunc = debounce(func, 1000);
+    // Call it immediately
+    debouncedFunc();
+    expect(func).toHaveBeenCalledTimes(0); // func not called
+
+    // Call it several times with 500ms between each call
+    for (let i = 0; i < 10; i++) {
+      clock.tick(500);
+      debouncedFunc();
+    }
+    expect(func).toHaveBeenCalledTimes(0); // func not called
+
+    // wait 1000ms
+    clock.tick(1000);
+    expect(func).toHaveBeenCalledTimes(1);  // func called
+  });
+});
+
+
+describe('polyfillCustomEvent', () => {
+  test('Overrides when missing', () => {
+    const win = {};
+    polyfillCustomEvent(win);
+    expect(win).toHaveProperty('CustomEvent');
+  });
+
+  test('Overrides when not a function', () => {
+    const win = { CustomEvent: {} };
+    polyfillCustomEvent(win);
+    expect(typeof win.CustomEvent).toBe('function');
+  });
+});
+
+describe('PolyfilledCustomEvent', () => {
+  test('Can be called as a constructor', () => {
+    new PolyfilledCustomEvent('foo');
+  });
+
+  test('Calls deprecated browser methods', () => {
+    const createEventSpy = sinon.spy(document, 'createEvent');
+    const initCustomEventSpy = sinon.spy(CustomEvent.prototype, 'initCustomEvent');
+    new PolyfilledCustomEvent('foo');
+    expect(createEventSpy.callCount).toBe(1);
+    expect(initCustomEventSpy.callCount).toBe(1);
+  });
+});
+
+describe('poll', () => {
+  beforeEach(() => jest.useFakeTimers());
+  afterEach(() => jest.useRealTimers());
+  test('polls until condition is true', async () => {
+    const fakeSleep = sinon.spy((ms) => jest.advanceTimersByTime(ms));
+
+    const returns = [null, null, 'foo'];
+    const check = sinon.spy(() => returns.shift());
+    const result = await poll(check, {_sleep: fakeSleep});
+    expect(fakeSleep.callCount).toBe(2);
+    expect(result).toBe('foo');
+    expect(check.callCount).toBe(3);
+  });
+
+  test('times out eventually', async () => {
+    const fakeSleep = sinon.spy((ms) => jest.advanceTimersByTime(ms));
+
+    const check = sinon.stub().returns(null);
+    const result = await poll(check, {_sleep: fakeSleep});
+    expect(result).toBeUndefined();
+    expect(check.callCount).toBe(10);
+  });
+});
+
+describe('sleep', () => {
+  test('Sleep 0 doest not called immediately', async () => {
+    const spy = sinon.spy();
+    sleep(0).then(spy);
+    expect(spy.callCount).toBe(0);
+    await afterEventLoop();
+    expect(spy.callCount).toBe(1);
+  });
+
+  test('Waits the appropriate ms', async () => {
+    const clock = sinon.useFakeTimers();
+    const spy = sinon.spy();
+    sleep(10).then(spy);
+    expect(spy.callCount).toBe(0);
+    clock.tick(10);
+    expect(spy.callCount).toBe(0);
+    clock.restore();
+
+    await afterEventLoop();
+    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);
+  });
+});
+
+describe('escapeRegex', () => {
+  test('Escapes regex', () => {
+    expect(escapeRegExp('.*')).toBe('\\.\\*');
+    expect(escapeRegExp('foo')).toBe('foo');
+    expect(escapeRegExp('foo.bar')).toBe('foo\\.bar');
+    expect(escapeRegExp('{{{')).toBe('\\{\\{\\{');
+    expect(escapeRegExp('')).toBe('');
+    expect(escapeRegExp('https://example.com')).toBe('https://example\\.com');
+  });
+});
+
+describe('parseAnimationSpeed', () => {
+  test('Parses numbers', () => {
+    expect(parseAnimationSpeed(100)).toBe(100);
+    expect(parseAnimationSpeed(0)).toBe(0);
+    expect(parseAnimationSpeed(1000)).toBe(1000);
+  });
+
+  test('Parses strings', () => {
+    expect(parseAnimationSpeed('slow')).toBe(600);
+    expect(parseAnimationSpeed('fast')).toBe(200);
+    expect(parseAnimationSpeed('100')).toBe(100);
+  });
+
+  test('Handles invalid input', () => {
+    expect(parseAnimationSpeed('foo')).toBeFalsy();
+    expect(parseAnimationSpeed('')).toBeFalsy();
+    expect(parseAnimationSpeed(null)).toBeFalsy();
+  });
+});

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

@@ -0,0 +1,190 @@
+import BookReader from '@/src/BookReader.js';
+import * as utils from '@/src/BookReader/utils.js';
+
+let br;
+beforeAll(() => {
+  document.body.innerHTML = '<div id="BookReader">';
+  br = new BookReader();
+});
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+/**
+ * Only run init() once. Otherwise multiple EventListeners will be added.
+ */
+test('Initialzation enables IntersectionObserver and defaults', () => {
+  const observe = jest.fn();
+  window.IntersectionObserver = jest.fn(() => ({
+    observe,
+  }));
+  br.init();
+  expect(br.hasKeyFocus).toBe(true);
+  expect(observe).toHaveBeenCalledTimes(1);
+});
+
+describe('Keyboard shortcuts turned off', () => {
+
+  test('Focus flag disables', () => {
+    br.next = jest.fn();
+    br.hasKeyFocus = false;
+    const keyEvent = new KeyboardEvent('keydown', {'key': 'ArrowDown'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.next).toHaveBeenCalledTimes(0);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(0);
+    // Must reset for following tests
+    br.hasKeyFocus = true;
+  });
+
+  test('Input active disables', () => {
+    // eslint-disable-next-line no-import-assign
+    utils.isInputActive = jest.fn(() => true);
+    br.next = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': 'ArrowDown'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.next).toHaveBeenCalledTimes(0);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(0);
+    // Must reset for following tests
+    utils.isInputActive.mockReset();
+  });
+
+});
+
+describe('Keyboard shortcuts', () => {
+
+  test('Home key', () => {
+    br.first = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': 'Home'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.first).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  test('End key', () => {
+    br.last = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': 'End'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.last).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  test('ArrowDown key', () => {
+    br.mode = br.constMode2up;
+    br.next = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': 'ArrowDown'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.next).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  test('PageDown key', () => {
+    br.mode = br.constMode2up;
+    br.next = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': 'PageDown'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.next).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  test('ArrowUp key', () => {
+    br.mode = br.constMode2up;
+    br.prev = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': 'ArrowUp'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.prev).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  test('PageUp key', () => {
+    br.mode = br.constMode2up;
+    br.prev = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': 'PageUp'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.prev).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  test('ArrowLeft key', () => {
+    br.mode = br.constMode2up;
+    br.left = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': 'ArrowLeft'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.left).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  test('ArrowRight key', () => {
+    br.mode = br.constMode2up;
+    br.right = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': 'ArrowRight'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.right).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  test('Subtract key', () => {
+    br.zoom = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': 'Subtract'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.zoom).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  test('- key', () => {
+    br.zoom = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': '-'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.zoom).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  test('Add key', () => {
+    br.zoom = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': 'Add'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.zoom).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  test('+ key', () => {
+    br.zoom = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': '+'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.zoom).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  test('= key', () => {
+    br.zoom = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': '='});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.zoom).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+  test('F key', () => {
+    br.toggleFullscreen = jest.fn();
+    const keyEvent = new KeyboardEvent('keydown', {'key': 'F'});
+    keyEvent.preventDefault = jest.fn();
+    document.dispatchEvent(keyEvent);
+    expect(br.toggleFullscreen).toHaveBeenCalledTimes(1);
+    expect(keyEvent.preventDefault).toHaveBeenCalledTimes(1);
+  });
+
+});

package/tests/{BookReader.options.test.js → jest/BookReader.options.test.js}

@@ -1,5 +1,5 @@
 
-import BookReader from '../src/BookReader.js';
+import BookReader from '@/src/BookReader.js';
 
 beforeAll(() => {
   document.body.innerHTML = '<div id="BookReader">';
@@ -21,7 +21,7 @@ describe('BookReader options', () => {
   describe('`startFullscreen`', () => {
     it('initializes BookReader to fullscreen', () => {
       const br = new BookReader({
-        startFullscreen: true
+        startFullscreen: true,
       });
       br.init();
 
@@ -36,4 +36,12 @@ describe('BookReader options', () => {
       expect(br.options.autoResize).toBe(true);
     });
   });
+
+  describe('`showNavbar`', () => {
+    it('is on by default', () => {
+      const br = new BookReader();
+      br.init();
+      expect(br.options.showNavbar).toBe(true);
+    });
+  });
 });

package/tests/{BookReader.test.js → jest/BookReader.test.js}

@@ -1,8 +1,9 @@
 
-import BookReader from '../src/BookReader.js';
-import '../src/plugins/plugin.resume.js';
-import '../src/plugins/plugin.url.js';
+import BookReader, {_modeStringToNumber} from '@/src/BookReader.js';
+import '@/src/plugins/plugin.resume.js';
+import '@/src/plugins/url/plugin.url.js';
 
+/** @type {import('@/src/BookReader.js').default} */
 let br;
 beforeAll(() => {
   document.body.innerHTML = '<div id="BookReader">';
@@ -33,35 +34,35 @@ test('has registered fullscreen toggle event', () => {
 });
 
 test('checks cookie when initParams called', () => {
-  br.getResumeValue = jest.fn(() => 15);
+  br._plugins.resume.getResumeValue = jest.fn(() => 15);
   br.urlReadFragment = jest.fn(() => '');
 
   const params = br.initParams();
-  expect(br.getResumeValue).toHaveBeenCalledTimes(1);
+  expect(br._plugins.resume.getResumeValue).toHaveBeenCalledTimes(1);
   expect(params.init).toBe(true);
   expect(params.index).toBe(15);
   expect(params.fragmentChange).toBe(true);
 });
 
 test('does not check cookie when initParams called', () => {
-  br.getResumeValue = jest.fn(() => null);
+  br._plugins.resume.getResumeValue = jest.fn(() => null);
   br.urlReadFragment = jest.fn(() => '');
-  br.options.enablePageResume = false;
+  br.options.plugins.resume.enabled = false;
 
   const params = br.initParams();
-  expect(br.getResumeValue).toHaveBeenCalledTimes(0);
+  expect(br._plugins.resume.getResumeValue).toHaveBeenCalledTimes(0);
   expect(params.init).toBe(true);
   expect(params.index).toBe(0);
   expect(params.fragmentChange).toBe(false);
 });
 
 test('gets index from fragment when both fragment and cookie when InitParams called', () => {
-  br.getResumeValue = jest.fn(() => 15);
+  br._plugins.resume.getResumeValue = jest.fn(() => 15);
   br.urlReadFragment = jest.fn(() => 'page/n4');
-  br.options.enablePageResume = true;
+  br.options.plugins.resume.enabled = true;
 
   const params = br.initParams();
-  expect(br.getResumeValue).toHaveBeenCalledTimes(1);
+  expect(br._plugins.resume.getResumeValue).toHaveBeenCalledTimes(1);
   expect(params.init).toBe(true);
   expect(params.index).toBe(4);
   expect(params.fragmentChange).toBe(true);
@@ -91,7 +92,7 @@ test('calls switchMode with init option when init called', () => {
 });
 
 test('has suppressFragmentChange true when init with no input', () => {
-  br.getResumeValue = jest.fn(() => null);
+  br._plugins.resume.getResumeValue = jest.fn(() => null);
   br.urlReadFragment = jest.fn(() => '');
   br.urlReadHashFragment = jest.fn(() => '');
   br.switchMode = jest.fn();
@@ -102,7 +103,7 @@ test('has suppressFragmentChange true when init with no input', () => {
 });
 
 test('has suppressFragmentChange false when init with cookie', () => {
-  br.getResumeValue = jest.fn(() => 5);
+  br._plugins.resume.getResumeValue = jest.fn(() => 5);
   br.urlReadFragment = jest.fn(() => '');
   br.switchMode = jest.fn();
 
@@ -112,7 +113,7 @@ test('has suppressFragmentChange false when init with cookie', () => {
 });
 
 test('has suppressFragmentChange false when init with fragment', () => {
-  br.getResumeValue = jest.fn(() => null);
+  br._plugins.resume.getResumeValue = jest.fn(() => null);
   br.urlReadFragment = jest.fn(() => 'mode/1up');
   br.switchMode = jest.fn();
 
@@ -122,9 +123,9 @@ test('has suppressFragmentChange false when init with fragment', () => {
 });
 
 test('has suppressFragmentChange false when init with hash fragment', () => {
-  br.getResumeValue = jest.fn(() => null);
+  br._plugins.resume.getResumeValue = jest.fn(() => null);
   br.urlReadFragment = jest.fn(() => '');
-  br.urlReadHashFragment = jest.fn(() => 'mode/1up')
+  br.urlReadHashFragment = jest.fn(() => 'mode/1up');
   br.switchMode = jest.fn();
   br.options.urlMode = 'history',
 
@@ -137,7 +138,7 @@ test('adds q= term to urlMode=history query string', () => {
   expect(br.queryStringFromParams(
     { search: 'test value' },
     'name=value',
-    'history'
+    'history',
   )).toBe('?name=value&q=test+value');
 });
 
@@ -145,7 +146,7 @@ test('replaces q= term in urlMode=history query string', () => {
   expect(br.queryStringFromParams(
     { search: 'test+value' },
     'q=foo&a=1&b=2&c=3',
-    'history'
+    'history',
   )).toBe('?q=test%2Bvalue&a=1&b=2&c=3');
 });
 
@@ -153,43 +154,24 @@ test('does not add q= term to urlMode=hash query string', () => {
   expect(br.queryStringFromParams(
     { search: 'test value' },
     'name=value',
-    'hash'
+    'hash',
   )).toBe('?name=value');
 });
 
-test('_getPageURISrcset with 0 page book', () => {
-  br._models.book.getNumLeafs = jest.fn(() => 0);
-  br._models.book.getPageURI = jest.fn((index, scale, rotate) => "correctURL.png&scale=" + scale);
-  br.init();
-  expect(br._getPageURISrcset(5, undefined, undefined)).toBe("");
-});
-
-test('_getPageURISrcset with negative index', () => {
-  br._models.book.getNumLeafs = jest.fn(() => 0);
-  br._models.book.getPageURI = jest.fn((index, scale, rotate) => "correctURL.png&scale=" + scale);
-  br.init();
-  expect(br._getPageURISrcset(-7, undefined, undefined)).toBe("");
-});
-
-test('_getPageURISrcset with 0 elements in srcset', () => {
-  br._models.book.getNumLeafs = jest.fn(() => 30);
-  br._models.book.getPageURI = jest.fn((index, scale, rotate) => "correctURL.png&scale=" + scale);
-  br.init();
-  expect(br._getPageURISrcset(5, 1, undefined)).toBe("");
-});
-
-test('_getPageURISrcset with 2 elements in srcset', () => {
-  br._models.book.getNumLeafs = jest.fn(() => 30);
-  br._models.book.getPageURI = jest.fn((index, scale, rotate) => "correctURL.png&scale=" + scale);
-  br.init();
-  expect(br._getPageURISrcset(5, 5, undefined)).toBe("correctURL.png&scale=2 2x, correctURL.png&scale=1 4x");
-});
-
-test('_getPageURISrcset with the most elements in srcset', () => {
-  br._models.book.getNumLeafs = jest.fn(() => 30);
-  br._models.book.getPageURI = jest.fn((index, scale, rotate) => "correctURL.png&scale=" + scale);
-  br.init();
-  expect(br._getPageURISrcset(5, 35, undefined)).toBe("correctURL.png&scale=16 2x, correctURL.png&scale=8 4x, correctURL.png&scale=4 8x, correctURL.png&scale=2 16x, correctURL.png&scale=1 32x");
+describe('Navigation Bars', () => {
+  test('Standard navigation is being used by default', () => {
+    br.initNavbar = jest.fn();
+    br.options.ui = '';
+    br.init();
+    expect(br.initNavbar).toHaveBeenCalledTimes(1);
+  });
+  test('Standard navigation is being used by default - when bookreader is embedded', () => {
+    br.initNavbar = jest.fn();
+    br.options.ui = 'embed';
+    br.init();
+    expect(br.initNavbar).toHaveBeenCalledTimes(1);
+    expect(br.options.ui).toEqual('embed');
+  });
 });
 
 describe('quantizeReduce', () => {
@@ -247,7 +229,7 @@ describe('nextReduce', () => {
       // auto doesn't get read by nextReduce (bug)
       // It looks like width/height are set for 1up, and auto is set for 2up,
       // and neither is set for thumb
-      { reduce: 6.2, autofit: "auto" }
+      { reduce: 6.2, autofit: "auto" },
     ];
 
     const currentReduces = [
@@ -299,3 +281,11 @@ describe('nextReduce', () => {
     });
   });
 });
+
+describe('_modeStringToNumber', () => {
+  test('Returns correct number', () => {
+    expect(_modeStringToNumber('mode/1up')).toBe(1);
+    expect(_modeStringToNumber('mode/2up')).toBe(2);
+    expect(_modeStringToNumber('mode/thumb')).toBe(3);
+  });
+});

package/tests/jest/plugins/plugin.archive_analytics.test.js

@@ -0,0 +1,20 @@
+import sinon from 'sinon';
+import {ArchiveAnalyticsPlugin} from '@/src/plugins/plugin.archive_analytics.js';
+
+describe('sendEvent', () => {
+  test('logs if debug set to true', () => {
+    const stub = sinon.stub(console, 'log');
+    const p = new ArchiveAnalyticsPlugin({});
+    p.setup({ debug: true });
+    p.sendEvent();
+    expect(stub.callCount).toBe(1);
+    stub.restore();
+  });
+
+  test('Does not error if window.archive_analytics is undefined', () => {
+    const p = new ArchiveAnalyticsPlugin({});
+    const spy = sinon.spy(p.sendEvent);
+    p.sendEvent();
+    expect(spy.threw()).toBe(false);
+  });
+});