@internetarchive/bookreader 5.0.0-18

package/tests/BookReader/BookModel.test.js

@@ -0,0 +1,312 @@
+import sinon from 'sinon';
+import { deepCopy } from '../utils.js';
+import { BookModel } from '../../src/BookReader/BookModel.js';
+/** @typedef {import('../../src/BookReader/options.js').BookReaderOptions} BookReaderOptions */
+
+afterEach(() => {
+  sinon.restore();
+});
+
+/** @type {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' },
+  ],
+];
+
+describe('getMedianPageSize', () => {
+  test('handles single page data', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA.slice(0, 1) });
+    expect(bm.getMedianPageSize()).toEqual({ width: 123, height: 123 });
+  });
+
+  test('handles odd pages data', () => {
+    const sizes = [
+      {width: 300, height: 2200},
+      {width: 200, height: 2100},
+      {width: 100, height: 2300},
+    ];
+    const data = deepCopy(SAMPLE_DATA);
+    delete data[2];
+    Object.assign(data[0][0], sizes[0]);
+    Object.assign(data[1][0], sizes[1]);
+    Object.assign(data[1][1], sizes[2]);
+    const bm = new BookModel({ data });
+    expect(bm.getMedianPageSize()).toEqual({ width: 200, height: 2200 });
+  });
+
+
+  test('handles even pages data', () => {
+    const sizes = [
+      {width: 300, height: 2200},
+      {width: 200, height: 2100},
+      {width: 100, height: 2300},
+      {width: 400, height: 2400},
+    ];
+    const data = deepCopy(SAMPLE_DATA);
+    Object.assign(data[0][0], sizes[0]);
+    Object.assign(data[1][0], sizes[1]);
+    Object.assign(data[1][1], sizes[2]);
+    Object.assign(data[2][0], sizes[3]);
+    const bm = new BookModel({ data });
+    expect(bm.getMedianPageSize()).toEqual({ width: 300, height: 2300 });
+  });
+
+  test('caches result', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    const firstResult = bm.getMedianPageSize();
+    expect(bm.getMedianPageSize()).toBe(firstResult);
+    expect(bm.getMedianPageSize()).toBe(firstResult);
+    expect(bm.getMedianPageSize()).toBe(firstResult);
+  });
+});
+
+describe('getPageIndices', () => {
+  test('handles unique indices', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    expect(bm.getPageIndices('1')).toEqual([0]);
+  });
+
+  test('handles invalid indices', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    expect(bm.getPageIndices('foo')).toEqual([]);
+    expect(bm.getPageIndices('123')).toEqual([]);
+  });
+
+  test('handles non-unique indices', () => {
+    const data = deepCopy(SAMPLE_DATA);
+    data[0][0].pageNum = '2';
+    const bm = new BookModel({ data });
+    expect(bm.getPageIndices('2')).toEqual([0, 1]);
+  });
+
+  test('handles n-prefixed pages', () => {
+    const data = deepCopy(SAMPLE_DATA);
+    data[0][0].pageNum = 'n0';
+    const bm = new BookModel({ data });
+    expect(bm.getPageIndices('n0')).toEqual([0]);
+  });
+});
+
+test('getPageName', () => {
+  const bm = new BookModel({ data: SAMPLE_DATA });
+  expect(bm.getPageName(0)).toEqual('Page 1');
+  expect(bm.getPageName(1)).toEqual('Page 2');
+});
+
+describe('numLeafs', () => {
+  test('reads from data', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    expect(bm.getNumLeafs()).toBe(4);
+  });
+
+  test('numLeafs can be overriden', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA, numLeafs: 12 });
+    expect(bm.getNumLeafs()).toBe(12);
+  });
+});
+
+test('getPageNum', () => {
+  const bm = new BookModel({ data: SAMPLE_DATA });
+  expect(bm.getPageNum(0)).toBe('1');
+});
+
+test('getPageProp gets values from correct document', () => {
+  const bm = new BookModel({ data: SAMPLE_DATA });
+  expect(bm.getPageProp(1, 'uri')).toBe(SAMPLE_DATA[1][0].uri);
+});
+
+describe('getSpreadIndices', () => {
+  test('Works for left to right text', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA, pageProgression: 'lr' });
+    expect(bm.getSpreadIndices(1)).toEqual([1, 2]);
+    expect(bm.getSpreadIndices(2)).toEqual([1, 2]);
+  });
+});
+
+describe('leafNumToIndex', () => {
+  test('returns input if no leafNum in data', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    expect(bm.leafNumToIndex(1)).toBe(1);
+    expect(bm.leafNumToIndex(2)).toBe(2);
+    expect(bm.leafNumToIndex(3)).toBe(3);
+  });
+
+  test('returns true index when leafNum does not point to index', () => {
+    const data = deepCopy(SAMPLE_DATA);
+    for (const spread of data) {
+      for (const page of spread) {
+        page.leafNum = parseFloat(page.pageNum) + 2;
+      }
+    }
+
+    const bm = new BookModel({ data });
+    expect(bm.leafNumToIndex(3)).toBe(0);
+  });
+});
+
+describe('parsePageString', () => {
+  test('handles leaf-prefixed PageString', () => {
+    const data = deepCopy(SAMPLE_DATA);
+    for (const spread of data) {
+      for (const page of spread) {
+        page.leafNum = parseFloat(page.pageNum) + 2;
+      }
+    }
+
+    const bm = new BookModel({ data });
+    expect(bm.parsePageString('leaf3')).toBe(0);
+  });
+});
+
+describe('pagesIterator', () => {
+  test('Goes through all pages', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    let i = 0;
+    for (const page of bm.pagesIterator()) {
+      expect(page.index).toBe(i++);
+    }
+  });
+
+  test('Can combine unviewables', () => {
+    const data = deepCopy(SAMPLE_DATA);
+    // add some more pages
+    data.splice(2, 0, deepCopy(data[0]));
+    data[1].forEach(page => page.viewable = false);
+    const bm = new BookModel({ data });
+    for (const page of bm.pagesIterator({combineConsecutiveUnviewables: true})) {
+      expect(page.isConsecutiveUnviewable).toBe(false);
+    }
+  });
+});
+
+describe('_getDataFlattened', () => {
+  test('Assigns correct page sides', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    expect(bm._getDataFlattened().map(page => page.pageSide)).toEqual(['R', 'L', 'R', 'L']);
+  });
+
+  test('Memoized based on data length', () => {
+    const data = deepCopy(SAMPLE_DATA);
+    const bm = new BookModel({ data });
+    const firstResult = bm._getDataFlattened();
+    expect(bm._getDataFlattened()).toBe(firstResult);
+    expect(bm._getDataFlattened()).toBe(firstResult);
+    bm.br.data = data.slice(0, 1);
+    expect(bm._getDataFlattened()).not.toBe(firstResult);
+  });
+
+  test('Assigns unviewablesStart', () => {
+    const data = deepCopy(SAMPLE_DATA);
+    data.slice(1, -1)
+      .forEach(spread => spread.forEach(page => {
+        page.viewable = false;
+      }));
+    const bm = new BookModel({ data });
+    const pages = bm._getDataFlattened();
+    expect(pages[0].unviewablesStart).toBeUndefined();
+    expect(pages[1].unviewablesStart).toBe(1);
+    expect(pages[2].unviewablesStart).toBe(1);
+    expect(pages[3].unviewablesStart).toBeUndefined();
+  });
+});
+
+describe('getPage', () => {
+  test('loops around by default', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    expect(bm.getPage(-1).index).toBe(3);
+    expect(bm.getPage(-2).index).toBe(2);
+    expect(bm.getPage(-3).index).toBe(1);
+    expect(bm.getPage(4).index).toBe(0);
+    expect(bm.getPage(5).index).toBe(1);
+  });
+
+  test('does not loop if loop=false', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    expect(bm.getPage(-1, false)).toBeUndefined();
+    expect(bm.getPage(-2, false)).toBeUndefined();
+    expect(bm.getPage(4, false)).toBeUndefined();
+    expect(bm.getPage(5, false)).toBeUndefined();
+  });
+});
+
+describe('PageModel', () => {
+  test('constructor copies fields from book model', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    const spy = sinon.spy(bm, 'getPageWidth');
+    const page = bm.getPage(0);
+    expect(spy.callCount).toBe(1);
+    expect(page.width).toBe(SAMPLE_DATA[0][0].width);
+  });
+
+  test('prev at start of book returns null', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    expect(bm.getPage(0).prev).toBeUndefined();
+  });
+
+  test('prev to return previous', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    expect(bm.getPage(1).prev.index).toBe(0);
+    expect(bm.getPage(3).prev.prev.index).toBe(1);
+  });
+
+  test('next at end of book returns null', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    expect(bm.getPage(-1).next).toBeUndefined();
+  });
+
+  test('next to return next page', () => {
+    const bm = new BookModel({ data: SAMPLE_DATA });
+    expect(bm.getPage(0).next.index).toBe(1);
+    expect(bm.getPage(1).next.next.index).toBe(3);
+  });
+
+  describe('findNext combineConsecutiveUnviewables=true', () => {
+    const data = deepCopy(SAMPLE_DATA);
+    // add some more pages
+    data.splice(2, 0, deepCopy(data[0]));
+    data[1].forEach(page => page.viewable = false);
+
+    const bm = new BookModel({ data });
+
+    test('does not skip the first unviewable page', () => {
+      expect(bm.getPage(0).findNext({ combineConsecutiveUnviewables: true }).index).toBe(1);
+    });
+
+    test('skips consecutive unviewables', () => {
+      expect(bm.getPage(1).findNext({ combineConsecutiveUnviewables: true }).index).toBe(3);
+    });
+
+    test('at end is undefined', () => {
+      expect(bm.getPage(-1).findNext({ combineConsecutiveUnviewables: true })).toBeUndefined();
+    });
+  });
+
+  describe('findPrev', () => {
+    const data = deepCopy(SAMPLE_DATA);
+    // add some more pages
+    data.splice(2, 0, deepCopy(data[0]));
+    data[1].forEach(page => page.viewable = false);
+
+    const bm = new BookModel({ data });
+
+    test('works if called on first unviewable', () => {
+      expect(bm.getPage(1).findPrev({ combineConsecutiveUnviewables: true }).index).toBe(0);
+    });
+
+    test('works if called within unviewable chunk', () => {
+      expect(bm.getPage(2).findPrev({ combineConsecutiveUnviewables: true }).index).toBe(1);
+    });
+
+    test('at start is undefined', () => {
+      expect(bm.getPage(0).findPrev({ combineConsecutiveUnviewables: true })).toBeUndefined();
+    });
+  });
+});

package/tests/BookReader/BookReaderPublicFunctions.test.js

@@ -0,0 +1,164 @@
+import BookReader from '../../src/BookReader';
+
+beforeAll(() => {
+  global.alert = jest.fn();
+});
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe('BookReader.prototype.toggleFullscreen', ()  => {
+  test('uses `isFullscreen` to check fullscreen state', () => {
+    const isFSmock = jest.fn();
+    isFSmock.mockReturnValueOnce(false);
+    const br = new BookReader();
+    br.mode = br.constMode1up;
+    br.enterFullscreen = jest.fn();
+    br.isFullscreen = isFSmock;
+
+    br.toggleFullscreen();
+    expect(br.isFullscreen).toHaveBeenCalled();
+  });
+
+  test('will always emit an event', async () => {
+    const br = new BookReader();
+    br.mode = br.constMode2up;
+    br.trigger = jest.fn();
+    br.switchMode = jest.fn();
+    br.refs.$brContainer = {
+      css: jest.fn(),
+      animate: (options, speed, style, callback) => callback()
+    };
+
+    await br.toggleFullscreen();
+    expect(br.trigger).toHaveBeenCalled();
+  });
+
+  test('will start with opening fullscreen', () => {
+    const br = new BookReader();
+    br.mode = br.constMode2up;
+    br.enterFullscreen = jest.fn();
+
+    br.toggleFullscreen();
+    expect(br.enterFullscreen).toHaveBeenCalled();
+  });
+
+  test('will close fullscreen if BookReader is in fullscreen', () => {
+    const br = new BookReader();
+    br.mode = br.constMode1up;
+    br.exitFullScreen = jest.fn();
+    br.isFullscreenActive = true;
+
+    br.toggleFullscreen();
+    expect(br.exitFullScreen).toHaveBeenCalled();
+  });
+});
+
+describe('BookReader.prototype.enterFullscreen', ()  => {
+  test('will bind `_fullscreenCloseHandler` by default', () => {
+    const br = new BookReader();
+    br.mode = br.constMode1up;
+    br.switchMode = jest.fn();
+    br.updateBrClasses = jest.fn();
+    br.refs.$brContainer = {
+      css: jest.fn(),
+      animate: jest.fn(),
+    };
+    expect(br._fullscreenCloseHandler).toBeUndefined();
+
+    br.enterFullscreen();
+    expect(br._fullscreenCloseHandler).toBeDefined();
+  });
+
+  test('fires certain events when called', async () => {
+    const br = new BookReader();
+    br.mode = br.constMode2up;
+    br.switchMode = jest.fn();
+    br.updateBrClasses = jest.fn();
+    br.trigger = jest.fn();
+    br.resize = jest.fn();
+    br.jumpToIndex = jest.fn();
+    br.refs.$brContainer = {
+      css: jest.fn(),
+      animate: (options, speed, style, callback) => callback()
+    };
+
+    await br.enterFullscreen();
+    expect(br.switchMode).toHaveBeenCalledTimes(1);
+    expect(br.updateBrClasses).toHaveBeenCalledTimes(0); // book nav's fullscreen manager will set these classes
+    expect(br.trigger).toHaveBeenCalledTimes(1);
+    expect(br.resize).toHaveBeenCalledTimes(1);
+    expect(br.jumpToIndex).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('BookReader.prototype.exitFullScreen', () => {
+  test('fires certain events when called', async () => {
+    const br = new BookReader();
+    br.mode = br.constMode2up;
+    br.switchMode = jest.fn();
+    br.updateBrClasses = jest.fn();
+    br.trigger = jest.fn();
+    br.resize = jest.fn();
+    br.refs.$brContainer = {
+      css: jest.fn(),
+      animate: (options, speed, style, callback) => callback()
+    };
+    await br.exitFullScreen();
+    expect(br.switchMode).toHaveBeenCalledTimes(1);
+    expect(br.updateBrClasses).toHaveBeenCalledTimes(1);
+    expect(br.trigger).toHaveBeenCalledTimes(1);
+    expect(br.resize).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('BookReader.prototype.trigger', () => {
+  test('fires custom event', () => {
+    const br = new BookReader();
+    global.br = br;
+    global.dispatchEvent = jest.fn();
+
+    const props = {bar: 1};
+    br.trigger('foo', props);
+    expect(global.dispatchEvent.mock.calls.length).toBe(1);
+  });
+});
+
+describe('`BookReader.prototype.prev`', () => {
+  const br = new BookReader();
+  global.br = br;
+  br.trigger = jest.fn();
+  br.flipBackToIndex = jest.fn();
+  br.jumpToIndex = jest.fn();
+
+  test('does not take action if user is on front page', () => {
+    br.firstIndex = 0;
+    br.prev();
+    expect(br.trigger.mock.calls.length).toBe(0);
+    expect(br.flipBackToIndex.mock.calls.length).toBe(0);
+    expect(br.jumpToIndex.mock.calls.length).toBe(0);
+  });
+
+  describe('2up mode', () => {
+    test('fires event and turns the page', () => {
+      br.firstIndex = 10;
+      br.mode = br.constMode2up;
+      br.prev();
+      expect(br.jumpToIndex.mock.calls.length).toBe(0); // <--  does not get called
+      expect(br.trigger.mock.calls.length).toBe(1);
+      expect(br.flipBackToIndex.mock.calls.length).toBe(1);
+    });
+  });
+
+  describe('non 2up mode', () => {
+    test('jumps to provided index', () => {
+      br.firstIndex = 100;
+      br.mode = br.constMode1up;
+      br.prev();
+      expect(br.jumpToIndex.mock.calls.length).toBe(1);  // <--  gets called
+      expect(br.trigger.mock.calls.length).toBe(1); // <-- gets called by `jumpToIndex` internally
+      expect(br.flipBackToIndex.mock.calls.length).toBe(1); // <-- gets called by `jumpToIndex` internally
+    });
+  });
+});
+

package/tests/BookReader/DebugConsole.test.js

@@ -0,0 +1,25 @@
+import sinon from 'sinon';
+import { DebugConsole } from '../../src/BookReader/DebugConsole.js';
+
+beforeEach(() => {
+  sinon.stub(console, 'log');
+});
+afterEach(() => {
+  sinon.restore();
+});
+
+test('hijacks console.log', () => {
+  const _realLog = console.log;
+  expect(_realLog).toBe(console.log);
+  new DebugConsole().init();
+  expect(_realLog).not.toBe(console.log);
+});
+
+test('logging the same thing twice does not create more entries', () => {
+  const dc = new DebugConsole();
+  dc.init();
+  dc.logToScreen(['hello']);
+  dc.logToScreen(['hello']);
+  expect(dc.$log.children('.log-entry')).toHaveLength(1);
+  expect(dc.$log.find('.count').text()).toBe('(2)');
+});

package/tests/BookReader/ImageCache.test.js

@@ -0,0 +1,150 @@
+import sinon from 'sinon';
+import { BookModel } from '../../src/BookReader/BookModel.js';
+import { ImageCache } from '../../src/BookReader/ImageCache.js';
+import { Pow2ReduceSet } from '../../src/BookReader/ReduceSet.js';
+/** @typedef {import('../../src/BookReader/options.js').BookReaderOptions} BookReaderOptions */
+
+afterEach(() => {
+  jest.restoreAllMocks();
+  sinon.restore();
+});
+
+const CACHE_MOCK = { 1: [{ reduce: 3, loaded: true }] };
+const FIRST_PAGE_MOCK = { width: 123, height: 123, uri: 'https://archive.org/image0.jpg', pageNum: '1' };
+/** @type {BookReaderOptions['data']} */
+const SAMPLE_DATA = [
+  [ FIRST_PAGE_MOCK ],
+  [
+    { 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' },
+  ],
+];
+
+describe('Image Cache', () => {
+  describe('`image` call', () => {
+    test('calling `image` will create an image if none is cached', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(new BookModel({ data: SAMPLE_DATA, reduceSet }), reduceSet);
+      ic.cache = {};
+      ic.image(1, 5);
+      expect(Object.keys(ic.cache).length).toBe(1);
+      expect(ic.cache['1'].length).toBe(1);
+    });
+    test('will pull from cache if image of a good quality has been stored', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(new BookModel({ data: SAMPLE_DATA, reduceSet }), reduceSet);
+      const serveImgElSpy = sinon.spy(ic, '_serveImageElement');
+      ic.cache = CACHE_MOCK;
+      ic.image(1, 5);
+      expect(serveImgElSpy.callCount).toBe(1);
+    });
+  });
+
+  describe('`imageLoaded` call', () => {
+    test('returns true if image in cache', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(new BookModel({ data: SAMPLE_DATA, reduceSet }), reduceSet);
+      ic.cache = CACHE_MOCK;
+      const isImgLoaded = ic.imageLoaded(1, 3);
+      expect(isImgLoaded).toBe(true);
+    });
+    test('returns true if image reducer in cache is good enough', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(new BookModel({ data: SAMPLE_DATA, reduceSet }), reduceSet);
+      ic.cache = CACHE_MOCK;
+      const isImgLoaded = ic.imageLoaded(1, 5);
+      expect(isImgLoaded).toBe(true);
+    });
+    test('returns false if no image in cache', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(new BookModel({ data: SAMPLE_DATA, reduceSet }), reduceSet);
+      ic.cache = CACHE_MOCK;
+      const isImgLoaded = ic.imageLoaded(2, 3);
+      expect(isImgLoaded).toBe(false);
+    });
+    test('returns false if reducer to check is better than cache', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(new BookModel({ data: SAMPLE_DATA, reduceSet }), reduceSet);
+      ic.cache = CACHE_MOCK;
+      const isImgLoaded = ic.imageLoaded(1, 2);
+      expect(isImgLoaded).toBe(false);
+    });
+    test('returns false if image has not loaded', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(new BookModel({ data: SAMPLE_DATA, reduceSet }), reduceSet);
+      ic.cache = { 1: [{ reduce: 4, loaded: false }] };
+      const isImgLoaded = ic.imageLoaded(1, 2);
+      expect(isImgLoaded).toBe(false);
+    });
+  });
+
+  describe('`getBestLoadedReduce` call', () => {
+    test('handles empty cache', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(new BookModel({ data: SAMPLE_DATA, reduceSet }), reduceSet);
+      ic.cache = {};
+      expect(ic.getBestLoadedReduce(0)).toBeNull();
+    });
+
+    test('handles empty page-level cache', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(new BookModel({ data: SAMPLE_DATA, reduceSet }), reduceSet);
+      ic.cache = { 0: [] };
+      expect(ic.getBestLoadedReduce(0)).toBeNull();
+      ic.cache = { 0: [{ reduce: 10, loaded: false }] };
+      expect(ic.getBestLoadedReduce(0)).toBeNull();
+    });
+
+    test('chooses highest quality sufficient image', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(new BookModel({ data: SAMPLE_DATA, reduceSet }), reduceSet);
+      ic.cache = { 0: [{ reduce: 1, loaded: true }, { reduce: 4, loaded: true }, { reduce: 10, loaded: true }] };
+      expect(ic.getBestLoadedReduce(0, 5)).toBe(10);
+    });
+
+    test('chooses closest image if no lower images', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(new BookModel({ data: SAMPLE_DATA, reduceSet }), reduceSet);
+      ic.cache = { 0: [{ reduce: 1, loaded: true }, { reduce: 4, loaded: true }] };
+      expect(ic.getBestLoadedReduce(0, 5)).toBe(4);
+    });
+  });
+
+  describe('`_serveImageElement` call', () => {
+    test('returns jQuery image element', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(new BookModel({ data: SAMPLE_DATA, reduceSet }), reduceSet);
+      const img = ic._serveImageElement(0);
+      expect($(img).length).toBe(1);
+      expect($(img)[0].classList.contains('BRpageimage')).toBe(true);
+      expect($(img).attr('src')).toBe(FIRST_PAGE_MOCK.uri);
+    });
+
+    test('does not set srcset when useSrcSet=false', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(
+        new BookModel({ data: SAMPLE_DATA, reduceSet }),
+        { useSrcSet: false, reduceSet },
+      );
+      const $img = ic._serveImageElement(0);
+      expect($img[0].hasAttribute('srcset')).toBe(false);
+    });
+
+    test('sets srcset when useSrcSet=true', () => {
+      const reduceSet = Pow2ReduceSet;
+      const ic = new ImageCache(
+        new BookModel({ data: SAMPLE_DATA, reduceSet }),
+        { useSrcSet: true, reduceSet },
+      );
+      const $img = ic._serveImageElement(0, 9);
+      expect($img.attr('srcset')).toBeTruthy();
+    });
+  });
+});