@internetarchive/bookreader 5.0.0-18

package/tests/plugins/plugin.text_selection.test.js

@@ -0,0 +1,193 @@
+import sinon from 'sinon';
+
+import '../../src/BookReader.js';
+import { BookreaderWithTextSelection, TextSelectionPlugin, Cache } from '../../src/plugins/plugin.text_selection.js';
+
+
+/** @type {BookReader} */
+
+// djvu.xml book infos copied from https://ia803103.us.archive.org/14/items/goodytwoshoes00newyiala/goodytwoshoes00newyiala_djvu.xml
+const FAKE_XML_1WORD = `<OBJECT data="file://localhost//tmp/derive/goodytwoshoes00newyiala//goodytwoshoes00newyiala.djvu" height="3192" type="image/x.djvu" usemap="goodytwoshoes00newyiala_0001.djvu" width="2454">
+<PARAGRAPH><LINE><WORD coords="1216,2768,1256,2640">test</WORD></LINE></PARAGRAPH>
+</OBJECT>`;
+const FAKE_XML_MULT_WORDS = `<OBJECT data="file://localhost//tmp/derive/goodytwoshoes00newyiala//goodytwoshoes00newyiala.djvu" height="3192" type="image/x.djvu" usemap="goodytwoshoes00newyiala_0001.djvu" width="2454">
+<PARAGRAPH><LINE><WORD coords="1216,2768,1256,2640">test1</WORD>
+<WORD coords="1400,2768,1500,2640">test2</WORD>
+<WORD coords="1600,2768,1700,2640">test3</WORD></LINE></PARAGRAPH></OBJECT>`;
+const FAKE_XML_5COORDS = `<OBJECT data="file://localhost//tmp/derive/goodytwoshoes00newyiala//goodytwoshoes00newyiala.djvu" height="3192" type="image/x.djvu" usemap="goodytwoshoes00newyiala_0001.djvu" width="2454">
+<PARAGRAPH><LINE><WORD coords="1216,2768,1256,2640,2690">test</WORD></LINE></PARAGRAPH></OBJECT>`;
+const FAKE_XML_EMPTY = '';
+
+describe("Generic tests", () => {
+  let br;
+  beforeEach(() => {
+    document.body.innerHTML = '<div id="BookReader">';
+    br = new BookreaderWithTextSelection({
+      data: [
+        [
+          { width: 800, height: 1200,
+            uri: '//archive.org/download/BookReader/img/page001.jpg' },
+        ],
+        [
+          { width: 800, height: 1200,
+            uri: '//archive.org/download/BookReader/img/page002.jpg' },
+          { width: 800, height: 1200,
+            uri: '//archive.org/download/BookReader/img/page003.jpg' },
+        ],
+        [
+          { width: 800, height: 1200,
+            uri: '//archive.org/download/BookReader/img/page004.jpg' },
+          { width: 800, height: 1200,
+            uri: '//archive.org/download/BookReader/img/page005.jpg' },
+        ]
+      ],
+    });
+    br.init();
+  });
+
+  test("_createPageContainer overridden function still creates a BRpagecontainer element", () => {
+    const spy = sinon.spy(br.textSelectionPlugin, 'createTextLayer');
+    sinon.stub(br.textSelectionPlugin, "getPageText")
+      .returns($(new DOMParser().parseFromString(FAKE_XML_1WORD, "text/xml")));
+    const container = br._createPageContainer(1, {});
+    expect(container).toBeTruthy();
+    expect(spy.callCount).toBe(1);
+  });
+
+  // test loading first object from sample data
+  test("_createPageContainer handles index 0", () => {
+    const spy = sinon.spy(br.textSelectionPlugin, 'createTextLayer');
+    br._createPageContainer(0, {});
+    expect(spy.callCount).toBe(1);
+  });
+
+  // test loading last object from sample data
+  test("_createPageContainer handles index -1", () => {
+    const spy = sinon.spy(br.textSelectionPlugin, 'createTextLayer');
+    br._createPageContainer(-1, {});
+    expect(spy.callCount).toBe(0);
+  });
+
+  test("createTextLayer will render the last page and create text layer properly", async () => {
+    const $container = br.refs.$brContainer;
+    sinon.stub(br.textSelectionPlugin, "getPageText")
+      .returns($(new DOMParser().parseFromString(FAKE_XML_1WORD, "text/xml")));
+    const pageIndex = br.data.length - 1;
+    await br.textSelectionPlugin.createTextLayer({ $container, page: { index: pageIndex, width: 100, height: 100 }});
+    expect($container.find(".textSelectionSVG").length).toBe(1);
+    expect($container.find(".BRparagElement").length).toBe(1);
+  });
+
+  test("createTextLayer will not create text layer if there are too many words", async () => {
+    const $container = br.refs.$brContainer;
+    const xml = FAKE_XML_1WORD.replace(/<WORD.*<\/WORD>/, FAKE_XML_1WORD.match(/<WORD.*<\/WORD>/)[0].repeat(3000));
+    sinon.stub(br.textSelectionPlugin, "getPageText")
+      .returns($(new DOMParser().parseFromString(xml, "text/xml")));
+    await br.textSelectionPlugin.createTextLayer({ $container, page: { index: 0, width: 100, height: 100 }});
+    expect($container.find(".textSelectionSVG").length).toBe(0);
+    expect($container.find(".BRparagElement").length).toBe(0);
+    expect($container.find(".BRwordElement").length).toBe(0);
+  });
+
+  test("createTextLayer creates an svg layer with paragraph with 1 word element", async () => {
+    const $container = br.refs.$brContainer;
+    sinon.stub(br.textSelectionPlugin, "getPageText")
+      .returns($(new DOMParser().parseFromString(FAKE_XML_1WORD, "text/xml")));
+    await br.textSelectionPlugin.createTextLayer({ $container, page: { index: 1, width: 100, height: 100 }});
+    expect($container.find(".textSelectionSVG").length).toBe(1);
+    expect($container.find(".BRparagElement").length).toBe(1);
+    expect($container.find(".BRwordElement").length).toBe(1);
+    expect($container.find(".BRwordElement").text()).toBe("test");
+  });
+
+  test("createTextLayer creates an svg layer with paragraph with multiple word elements", async () => {
+    const $container = br.refs.$brContainer;
+    sinon.stub(br.textSelectionPlugin, "getPageText")
+      .returns($(new DOMParser().parseFromString(FAKE_XML_MULT_WORDS, "text/xml")));
+    await br.textSelectionPlugin.createTextLayer({ $container, page: { index: 2, width: 100, height: 100 }});
+    expect($container.find(".textSelectionSVG").length).toBe(1);
+    expect($container.find(".BRparagElement").length).toBe(1);
+    expect($container.find(".BRwordElement").length).toBe(5);
+    expect($container.find(".BRwordElement").last()).not.toBe(" ");
+  });
+
+  test("createTextLayer creates an svg layer with paragraph with word with 5 params coordinates", async () => {
+    const $container = br.refs.$brContainer;
+    sinon.stub(br.textSelectionPlugin, "getPageText")
+      .returns($(new DOMParser().parseFromString(FAKE_XML_5COORDS, "text/xml")));
+    await br.textSelectionPlugin.createTextLayer({ $container, page: { index: 3, width: 100, height: 100 }});
+    expect($container.find(".textSelectionSVG").length).toBe(1);
+    expect($container.find(".BRparagElement").length).toBe(1);
+    expect($container.find(".BRwordElement").length).toBe(1);
+  });
+
+  test("createTextLayer can handle empty xml", async () => {
+    const $container = br.refs.$brContainer;
+    sinon.stub(br.textSelectionPlugin, "getPageText")
+      .returns($(new DOMParser().parseFromString(FAKE_XML_EMPTY, "text/xml")));
+    await br.textSelectionPlugin.createTextLayer({ $container, page: { index: 4, width: 100, height: 100 }});
+    expect($container.find(".textSelectionSVG").length).toBe(1);
+    expect($container.find(".BRparagElement").length).toBe(0);
+    expect($container.find(".BRwordElement").length).toBe(0);
+  });
+
+  const LONG_PRESS_DURATION = 500;
+  test("calling stopPageFlip does not allow long click to flip the page", () => {
+    const $container = br.refs.$brContainer;
+    br.textSelectionPlugin.stopPageFlip($container);
+    const currIndex = br.currentIndex();
+    $container.find("BRwordElement").mousedown();
+    // Waits for long press
+    setTimeout(() => {
+      $container.find("BRwordElement").mousedown();
+      // Waits for flipping animation
+      setTimeout(() => {
+        expect(br.currentIndex()).toBe(currIndex);
+      }, 2000);
+    }, LONG_PRESS_DURATION);
+  });
+});
+
+describe("textSelectionPlugin constructor", () => {
+  test("textSelectionPlugin constructor with firefox browser", () => {
+    const tsp = new TextSelectionPlugin({}, {}, true);
+    expect(tsp.djvuPagesPromise).toBe(null);
+    expect(tsp.svgParagraphElement).toBe("g");
+    expect(tsp.svgWordElement).toBe("text");
+  });
+
+  test("textSelectionPlugin constructor not on firefox browser", () => {
+    const tsp = new TextSelectionPlugin({}, {}, false);
+    expect(tsp.djvuPagesPromise).toBe(null);
+    expect(tsp.svgParagraphElement).toBe("text");
+    expect(tsp.svgWordElement).toBe("tspan");
+  });
+});
+
+describe("Cache", () => {
+  test('Adding works', () => {
+    const c = new Cache(10);
+    c.add(35);
+    expect(c.entries).toEqual([35]);
+  });
+
+  test('Size does not grow beyond limit', () => {
+    const c = new Cache(2);
+    c.add(35);
+    c.add(32);
+    c.add(12);
+    c.add(11);
+    c.add(112);
+    expect(c.entries).toHaveLength(2);
+  });
+
+  test('Oldest evicted first', () => {
+    const c = new Cache(2);
+    c.add(35);
+    c.add(32);
+    c.add(12);
+    c.add(12);
+    c.add(10);
+    expect(c.entries).toEqual([12, 10]);
+  });
+});

package/tests/plugins/plugin.url.test.js

@@ -0,0 +1,129 @@
+
+import BookReader from '../../src/BookReader.js';
+import '../../src/plugins/plugin.url.js';
+
+let br;
+beforeAll(() => {
+  document.body.innerHTML = '<div id="BookReader">';
+  br = new BookReader();
+});
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('Plugin: URL controller', () => {
+  test('has default option flag', () => {
+    expect(BookReader.defaultOptions.enableUrlPlugin).toEqual(true);
+  });
+
+  test('adds url specific fields to BR', () => {
+    const { defaultOptions } = BookReader;
+    expect(defaultOptions).toHaveProperty('urlTrackIndex0');
+    expect(defaultOptions).toHaveProperty('urlTrackedParams');
+    expect(defaultOptions).toHaveProperty('urlHistoryBasePath');
+    expect(defaultOptions).toHaveProperty('urlMode');
+    expect(defaultOptions).toHaveProperty('updateWindowTitle');
+    expect(defaultOptions).toHaveProperty('defaults');
+    expect(defaultOptions).toHaveProperty('bookId');
+  });
+
+  test('has a whitelist of params that it tracks', () => {
+    ['page', 'search', 'mode', 'region', 'highlight'];
+    const { defaultOptions: { urlTrackedParams } } = BookReader;
+    expect(Array.isArray(urlTrackedParams)).toEqual(true);
+    expect(urlTrackedParams.find(param => param === 'page')).toBeTruthy();
+    expect(urlTrackedParams.find(param => param === 'search')).toBeTruthy();
+    expect(urlTrackedParams.find(param => param === 'mode')).toBeTruthy();
+    expect(urlTrackedParams.find(param => param === 'region')).toBeTruthy();
+    expect(urlTrackedParams.find(param => param === 'highlight')).toBeTruthy();
+  });
+
+  test('initializes polling for url changes if using hash', () => {
+    BookReader.prototype.urlStartLocationPolling = jest.fn();
+    br.init();
+
+    expect(br.urlStartLocationPolling).toHaveBeenCalled();
+  });
+
+  test('updates URL when index changes', () => {
+    window.history.replaceState = jest.fn();
+    BookReader.prototype.currentIndex = jest.fn(() => 1);
+    BookReader.prototype.urlReadFragment = jest.fn(() => '/page/2/mode/1up');
+    BookReader.prototype.paramsFromCurrent = jest.fn(() => ({
+      index: 88,
+      mode: 1,
+      search: ''
+    }));
+    br.options.urlMode = 'history';
+    br.init();
+    br.urlUpdateFragment();
+
+    expect(window.history.replaceState).toHaveBeenCalled();
+  });
+
+  test('updates URL when mode changes', () => {
+    window.history.replaceState = jest.fn();
+    BookReader.prototype.currentIndex = jest.fn(() => 1);
+    BookReader.prototype.urlReadFragment = jest.fn(() => '/page/2/mode/1up');
+    BookReader.prototype.paramsFromCurrent = jest.fn(() => ({
+      index: 2,
+      mode: 2,
+      search: ''
+    }));
+    br.options.urlMode = 'history';
+    br.init();
+    br.urlUpdateFragment();
+
+    expect(window.history.replaceState).toHaveBeenCalled();
+  });
+
+  test('updates URL when search changes', () => {
+    window.history.replaceState = jest.fn();
+    BookReader.prototype.currentIndex = jest.fn(() => 1);
+    BookReader.prototype.urlReadFragment = jest.fn(() => '');
+    BookReader.prototype.paramsFromCurrent = jest.fn(() => ({
+      index: 1,
+      mode: 2,
+      search: 'foo'
+    }));
+    BookReader.prototype.search = jest.fn();
+    br.options.urlMode = 'history';
+    br.init();
+    br.urlUpdateFragment();
+
+    expect(window.history.replaceState).toHaveBeenCalled();
+  });
+
+  test('does not update URL when search in query string', () => {
+    window.history.replaceState = jest.fn();
+    BookReader.prototype.currentIndex = jest.fn(() => 1);
+    BookReader.prototype.urlReadFragment = jest.fn(() => 'mode/2up');
+    BookReader.prototype.getLocationSearch = jest.fn(() => '?q=foo');
+    BookReader.prototype.paramsFromCurrent = jest.fn(() => ({
+      index: 1,
+      mode: 2,
+      search: 'foo'
+    }));
+    BookReader.prototype.search = jest.fn();
+    br.options.initialSearchTerm = 'foo';
+    br.options.urlMode = 'history';
+    br.init();
+    br.urlUpdateFragment();
+
+    expect(window.history.replaceState).toHaveBeenCalledTimes(0);
+  });
+
+  test('only q= param is selected from url query params', () => {
+    const INTIAL_URL = "http://127.0.0.1:8080/BookReaderDemo/demo-internetarchive.html?ocaid=adventuresofoli00dick&q=foo";
+    const result = br.urlParamsFiltersOnlySearch(INTIAL_URL);
+    expect(result).toBe("?q=foo");
+  });
+
+  test('only q= param is selected from url query params with special character', () => {
+    const INTIAL_URL = "http://127.0.0.1:8080/BookReaderDemo/demo-internetarchive.html?ocaid=adventuresofoli00dick&q=foo%24%24";
+    const result = br.urlParamsFiltersOnlySearch(INTIAL_URL);
+    expect(result).toBe("?q=foo%24%24");
+  });
+});
+

package/tests/plugins/plugin.vendor-fullscreen.test.js

@@ -0,0 +1,65 @@
+
+import BookReader from '../../src/BookReader.js';
+import * as util from '../../src/plugins/plugin.vendor-fullscreen.js';
+
+let br;
+beforeEach(() => {
+  document.body.innerHTML = '<div id="BookReader">';
+  br = new BookReader();
+  br.init();
+});
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('Plugin: Vendor-fullscreen', () => {
+  test('has option flag', () => {
+    expect(BookReader.defaultOptions.enableVendorFullscreenPlugin).toEqual(true);
+  });
+
+  test('enterFullWindow will run when enter in Fullscreen mode', () => {
+    const enterFullWindow = br.enterFullWindow;
+    br.updateBrClasses = jest.fn();
+    br.resize = jest.fn();
+    br.init();
+    br.enterFullWindow();
+
+    expect(enterFullWindow).toBeTruthy();
+
+    // br.isVendorFullscreenActive set to `true` when enterFullWindow Called
+    expect(br.isVendorFullscreenActive).toEqual(true);
+
+    // br.updateBrClasses trigger when enterFullWindow called
+    expect(br.updateBrClasses).toHaveBeenCalledTimes(2);
+
+    // br.resize trigger when enterFullWindow called
+    expect(br.resize).toHaveBeenCalledTimes(1);
+  });
+
+  test('exitFullWindow will run when exit Fullscreen mode', () => {
+    const exitFullWindow = br.exitFullWindow;
+    br.updateBrClasses = jest.fn();
+    br.init();
+    br.exitFullWindow();
+
+    expect(exitFullWindow).toBeTruthy();
+
+    // br.isFullscreenActive set to `false` when exitFullWindow Called
+    expect(br.isFullscreenActive).toEqual(false);
+
+    // br.updateBrClasses trigger when exitFullWindow called
+    expect(br.updateBrClasses).toHaveBeenCalledTimes(2);
+  });
+
+  test('isFullscreen returns true when fullscreen activated', () => {
+    br.init();
+    br.isVendorFullscreenActive = true;
+    expect(br.isFullscreen).toBeTruthy();
+  });
+
+  test('util: isFullscreenActive', () => {
+    document.fullscreenElement = true;
+    expect(util.isFullscreenActive).toBeTruthy();
+  });
+});

package/tests/plugins/search/plugin.search.test.js

@@ -0,0 +1,173 @@
+
+import BookReader from '../../../src/BookReader.js';
+import '../../../src/plugins/plugin.mobile_nav.js';
+import '../../../src/plugins/search/plugin.search.js';
+
+jest.mock('../../../src/plugins/search/view.js');
+
+let br;
+const namespace = 'BookReader:';
+const triggeredEvents = () => {
+  return $.fn.trigger.mock.calls.map((params) => {
+    if (typeof params[0] === 'string') { return params[0]; }
+    return params[0].type;
+  });
+};
+
+beforeEach(() => {
+  $.ajax = jest.fn().mockImplementation(() => {
+    // return from:
+    // `https://ia800304.us.archive.org/fulltext/inside.php?item_id=adventuresofoli00dick&doc=adventuresofoli00dick&path=/30/items/adventuresofoli00dick&q=child&callback=<serialized jQ CB>`
+    return Promise.resolve({
+      ia: "adventuresofoli00dick",
+      q: "child",
+      indexed: true,
+      page_count: 644,
+      body_length: 666,
+      leaf0_missing: false,
+      matches: [{
+        text: 'For a long; time after it was ushered into this world of sorrow and trouble, by the parish surgeon, it remained a matter of considerable doubt wliether the {{{child}}} Avould survi^ e to bear any name at all; in which case it is somewhat more than probable that these memoirs would never have appeared; or, if they had, that being comprised within a couple of pages, they would have possessed the inestimable meiit of being the most concise and faithful specimen of biography, extant in the literature of any age or country.',
+        par: [{
+          boxes: [{r: 1221, b: 2121, t: 2075, page: 37, l: 1107}],
+          b: 2535,
+          t: 1942,
+          page_width: 1790,
+          r: 1598,
+          l: 50,
+          page_height: 2940,
+          page: 37
+        }]
+      }]
+    });
+  });
+
+  $.fn.trigger = jest.fn();
+  document.body.innerHTML = '<div id="BookReader">';
+  br = new BookReader();
+  br.initToolbar = jest.fn();
+  br.showProgressPopup = jest.fn();
+  br.searchXHR = jest.fn();
+});
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('Plugin: Search', () => {
+  test('has option flag', () => {
+    expect(BookReader.defaultOptions.enableSearch).toEqual(true);
+  });
+
+  test('has added BR property: server', () => {
+    expect(br).toHaveProperty('server');
+    expect(br.server).toBeTruthy();
+  });
+
+  test('has added BR property: bookId', () => {
+    expect(br).toHaveProperty('bookId');
+    expect(br.bookId).toBeFalsy();
+  });
+
+  test('has added BR property: subPrefix', () => {
+    expect(br).toHaveProperty('subPrefix');
+    expect(br.subPrefix).toBeFalsy();
+  });
+
+  test('has added BR property: bookPath', () => {
+    expect(br).toHaveProperty('bookPath');
+    expect(br.bookPath).toBeFalsy();
+  });
+
+  test('has added BR property: searchInsideUrl', () => {
+    expect(br).toHaveProperty('searchInsideUrl');
+    expect(br.searchInsideUrl).toBeTruthy();
+  });
+
+  test('has added BR property: initialSearchTerm', () => {
+    expect(br.options).toHaveProperty('initialSearchTerm');
+    expect(br.options.initialSearchTerm).toBeFalsy();
+  });
+
+  test('On init, it loads the toolbar', () => {
+    br.init();
+    expect(br.initToolbar).toHaveBeenCalled();
+  });
+
+  test('On init, it will run a search if given `options.initialSearchTerm`', () => {
+    br.search = jest.fn();
+    br.options.initialSearchTerm = 'foo';
+    br.init();
+
+    expect(br.search).toHaveBeenCalled();
+    expect(br.search.mock.calls[0][1])
+      .toHaveProperty('goToFirstResult', true);
+    expect(br.search.mock.calls[0][1])
+      .toHaveProperty('suppressFragmentChange', false);
+  });
+
+  test('calling `search` fires ajax call`', () => {
+    br.init();
+    br.search('foo');
+    expect($.ajax).toHaveBeenCalled();
+  });
+
+  test('SearchStarted event fires when search method called', () => {
+    br.init();
+    br.search('foo');
+    expect(triggeredEvents()).toContain(`${namespace}SearchStarted`);
+  });
+
+  test('SearchStarted event fires and should go to first result', () => {
+    br.init();
+    br.search('foo', { goToFirstResult: true});
+    expect(br.options.goToFirstResult).toBeTruthy();
+  });
+
+  test('SearchCallback event fires when AJAX search returns results', () => {
+    br.init();
+    const dfd = br.search('foo');
+    return dfd.then(() => {
+      expect(triggeredEvents()).toContain(`${namespace}SearchCallback`);
+    });
+  });
+
+  test('SearchCallbackError event fires when AJAX search returns error', () => {
+    $.ajax = jest.fn().mockImplementation(() => {
+      return Promise.resolve({
+        error: true,
+      });
+    });
+    br.init();
+    const dfd = br.search('foo');
+    return dfd.then(() => {
+      expect(triggeredEvents()).toContain(`${namespace}SearchCallbackError`);
+    });
+  });
+
+  test('SearchCallbackNotIndexed event fires when AJAX search returns false indexed value', () => {
+    $.ajax = jest.fn().mockImplementation(() => {
+      return Promise.resolve({
+        matches: [],
+        indexed: false,
+      });
+    });
+    br.init();
+    const dfd = br.search('foo');
+    return dfd.then(() => {
+      expect(triggeredEvents()).toContain(`${namespace}SearchCallbackBookNotIndexed`);
+    });
+  });
+
+  test('SearchCallbackEmpty event fires when AJAX search returns no matches', () => {
+    $.ajax = jest.fn().mockImplementation(() => {
+      return Promise.resolve({
+        matches: [],
+      });
+    });
+    br.init();
+    const dfd = br.search('foo');
+    return dfd.then(() => {
+      expect(triggeredEvents()).toContain(`${namespace}SearchCallbackEmpty`);
+    });
+  });
+});

package/tests/plugins/search/plugin.search.view.test.js

@@ -0,0 +1,106 @@
+
+import BookReader from '../../../src/BookReader.js';
+import '../../../src/plugins/plugin.mobile_nav.js';
+import '../../../src/plugins/search/plugin.search.js';
+import '../../../src/plugins/search/view.js';
+
+let br;
+const namespace = 'BookReader:';
+const results = {
+  ia: "adventuresofoli00dick",
+  q: "child",
+  indexed: true,
+  page_count: 644,
+  body_length: 666,
+  leaf0_missing: false,
+  matches: [{
+    text: 'For a long; time after it was ushered into this world of sorrow and trouble, by the parish surgeon, it remained a matter of considerable doubt wliether the {{{child}}} Avould survi^ e to bear any name at all; in which case it is somewhat more than probable that these memoirs would never have appeared; or, if they had, that being comprised within a couple of pages, they would have possessed the inestimable meiit of being the most concise and faithful specimen of biography, extant in the literature of any age or country.',
+    par: [{
+      boxes: [{r: 1221, b: 2121, t: 2075, page: 37, l: 1107}],
+      b: 2535,
+      t: 1942,
+      page_width: 1790,
+      r: 1598,
+      l: 50,
+      page_height: 2940,
+      page: 37
+    }]
+  }]
+};
+beforeEach(() => {
+  $.ajax = jest.fn().mockImplementation(() => {
+    // return from:
+    // `https://ia800304.us.archive.org/fulltext/inside.php?item_id=adventuresofoli00dick&doc=adventuresofoli00dick&path=/30/items/adventuresofoli00dick&q=child&callback=<serialized jQ CB>`
+    return Promise.resolve(results);
+  });
+
+  $.fn.trigger = jest.fn();
+  document.body.innerHTML = '<div id="BookReader">';
+  br = new BookReader();
+  br.initToolbar = jest.fn();
+  br.showProgressPopup = jest.fn();
+});
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('View: Plugin: Search', () => {
+  test('When search runs, the view gets created.', () => {
+    br.search = jest.fn();
+    br.options.initialSearchTerm = 'foo';
+    br.init();
+
+    expect(br.searchView).toBeDefined();
+    expect(br.searchView.handleSearchCallback).toBeDefined();
+  });
+
+  describe("Search results navigation bar", () => {
+    test('Search Results callback creates the results nav', () => {
+      br.init();
+      const event = new CustomEvent(`${namespace}SearchCallback`);
+      const options = { goToFirstResult: false };
+
+      expect(br.searchView.dom.searchNavigation).toBeUndefined();
+
+      br.searchView.handleSearchCallback(event, { results, options});
+      expect(br.searchView.dom.searchNavigation).toBeDefined();
+    });
+    test('has controls', () => {
+      br.init();
+      const event = new CustomEvent(`${namespace}SearchCallback`);
+      const options = { goToFirstResult: false };
+      br.searchView.handleSearchCallback(event, { results, options});
+
+      const searchResultsNav = document.querySelector('.BRsearch-navigation');
+      expect(searchResultsNav).toBeDefined();
+
+      expect(searchResultsNav.querySelectorAll('button').length).toEqual(4);
+      expect(searchResultsNav.querySelector('.clear')).toBeDefined();
+      expect(searchResultsNav.querySelector('.toggle-sidebar')).toBeDefined();
+      expect(searchResultsNav.querySelector('.prev')).toBeDefined();
+      expect(searchResultsNav.querySelector('.next')).toBeDefined();
+    });
+
+    describe('Click events handlers', () => {
+      it('triggers custom event when toggling side menu', () => {
+        br.init();
+        let eventNameTriggered = '';
+        br.trigger = (eventName) => eventNameTriggered = eventName;
+
+        expect(eventNameTriggered).toBeFalsy();
+        br.searchView.toggleSidebar();
+        expect(eventNameTriggered).toEqual('ToggleSearchMenu');
+      });
+      it('triggers custom event when closing navbar', () => {
+        br.init();
+        let eventNameTriggered = '';
+        br.trigger = (eventName) => eventNameTriggered = eventName;
+
+        expect(eventNameTriggered).toBeFalsy();
+        br.searchView.clearSearchFieldAndResults();
+        expect(eventNameTriggered).toEqual('SearchResultsCleared');
+      });
+    });
+  });
+});