@internetarchive/bookreader 5.0.0-18

package/tests/BookReader/Mode1UpLit.test.js

@@ -0,0 +1,87 @@
+import { BookModel } from '../../src/BookReader/BookModel.js';
+import { Mode1UpLit } from '../../src/BookReader/Mode1UpLit.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() {},
+    updateNavIndexThrottled() {},
+    data: []
+  }, overrides);
+}
+
+describe('pageTops', () => {
+  afterEach(() => document.body.innerHTML = '');
+
+  test('Works with empty book', async () => {
+    const br = make_dummy_br({ data: [] });
+    const book = new BookModel(br);
+    const mode = new Mode1UpLit(book, br);
+    document.body.appendChild(mode);
+    await mode.requestUpdate();
+    expect(mode.pageTops).toEqual({});
+  });
+
+  test('Iterates all pages', async () => {
+    const br = make_dummy_br({ data: SAMPLE_DATA });
+    const book = new BookModel(br);
+    const mode = new Mode1UpLit(book, br);
+    document.body.appendChild(mode);
+    await mode.requestUpdate();
+    expect(Object.values(mode.pageTops)).toHaveLength(6);
+  });
+
+  test('Computes tops', async () => {
+    const br = make_dummy_br({ data: SAMPLE_DATA });
+    const book = new BookModel(br);
+    const mode = new Mode1UpLit(book, br);
+    document.body.appendChild(mode);
+    await mode.requestUpdate();
+    const tops = Object.entries(mode.pageTops);
+    expect(tops.map(([index, top]) => [index, top.toFixed(1)])).toEqual([
+      // Recall these are in inches
+      ['0', '0.2'],
+      ['1', '0.6'],
+      ['2', '1.1'],
+      ['3', '1.5'],
+      ['4', '2.0'],
+      ['5', '2.4'],
+    ]);
+  });
+});
+
+describe('worldUnitsToRenderedPixels', () => {
+  test('0 case', () => {
+    const mode = new Mode1UpLit(null, null);
+    expect(mode.worldUnitsToRenderedPixels(0)).toBe(0);
+  });
+  test('Misc cases', () => {
+    const mode = new Mode1UpLit(null, null);
+    mode.screenDPI = 100;
+    mode.realWorldReduce = 1;
+    expect(mode.worldUnitsToRenderedPixels(1)).toBe(100);
+    mode.screenDPI = 100;
+    mode.realWorldReduce = 2;
+    expect(mode.worldUnitsToRenderedPixels(1)).toBe(50);
+    mode.screenDPI = 78;
+    mode.realWorldReduce = 1;
+    expect(mode.worldUnitsToRenderedPixels(1)).toBe(78);
+  });
+});

package/tests/BookReader/Mode2Up.test.js

@@ -0,0 +1,245 @@
+
+import sinon from 'sinon';
+import { deepCopy } from '../utils.js';
+import BookReader from '../../src/BookReader.js';
+/** @typedef {import('../../src/BookReader/options.js').BookReaderOptions} BookReaderOptions */
+
+beforeAll(() => {
+  global.alert = jest.fn();
+});
+afterEach(() => {
+  jest.restoreAllMocks();
+  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' },
+    { 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('zoom', () => {
+  const br = new BookReader({ data: SAMPLE_DATA });
+  br.init();
+
+  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('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.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.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.calculateSpreadSize();
+
+    test('leftLeafCss', () => {
+      expect(Object.keys(br._modes.mode2Up.leftLeafCss)).toEqual([
+        'position',
+        'right',
+        'top',
+        'zIndex',
+        'height',
+        'left',
+        'width',
+      ]);
+    });
+    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.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'
+      ]);
+    });
+  });
+  describe('full width container, overlay + spine', () => {
+    test('mainContainerCss', () => {
+      const br = new BookReader({ data: SAMPLE_DATA });
+      br.init();
+      br.calculateSpreadSize();
+
+      expect(Object.keys(br._modes.mode2Up.mainContainerCss)).toEqual(['height', 'width', 'position']);
+    });
+    test('spreadCoverCss', () => {
+      const br = new BookReader({ data: SAMPLE_DATA });
+      br.init();
+      br.calculateSpreadSize();
+      expect(Object.keys(br._modes.mode2Up.spreadCoverCss)).toEqual(['width', 'height', 'visibility']);
+    });
+    test('spineCss', () => {
+      const br = new BookReader({ data: SAMPLE_DATA });
+      br.init();
+      br.calculateSpreadSize();
+      expect(Object.keys(br._modes.mode2Up.spineCss)).toEqual(['width', 'height', 'left', 'top']);
+    });
+  });
+});
+
+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');
+
+      br.prepareTwoPageView(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);
+    });
+  });
+});
+
+test('uses ImageCache', () => {
+  const br = new BookReader({ data: SAMPLE_DATA });
+  br.init();
+  expect(Object.keys(br.imageCache.cache).length).toBeGreaterThan(2);
+});

package/tests/BookReader/ModeSmoothZoom.test.js

@@ -0,0 +1,149 @@
+import sinon from 'sinon';
+import { EventTargetSpy } from '../utils.js';
+import { ModeSmoothZoom } from '../../src/BookReader/ModeSmoothZoom.js';
+/** @typedef {import('../../src/BookReader/ModeSmoothZoom.js').SmoothZoomable} SmoothZoomable */
+
+/**
+ * @param {Partial<SmoothZoomable>} overrides
+ * @returns {SmoothZoomable}
+ */
+function dummy_mode(overrides = {}) {
+  return {
+    $container: document.createElement('div'),
+    $visibleWorld: document.createElement('div'),
+    scale: 1,
+    htmlDimensionsCacher: {
+      clientWidth: 100,
+      clientHeight: 100,
+      boundingClientRect: { left: 0, top: 0 },
+    },
+    scaleCenter: {x: 0.5, y: 0.5},
+    ...overrides
+  };
+}
+
+afterEach(() => sinon.restore());
+
+describe('ModeSmoothZoom', () => {
+  test('preventsDefault on iOS-only gesture events', () => {
+    const mode = dummy_mode();
+    const msz = new ModeSmoothZoom(mode);
+    msz.attach();
+    for (const event_name of ['gesturestart', 'gesturechange', 'gestureend']) {
+      const ev = new Event(event_name, {});
+      const prevDefaultSpy = sinon.spy(ev, 'preventDefault');
+      mode.$container.dispatchEvent(ev);
+      expect(prevDefaultSpy.callCount).toBe(1);
+    }
+  });
+
+  test('pinchCancel alias for pinchEnd', () => {
+    const mode = dummy_mode();
+    const msz = new ModeSmoothZoom(mode);
+    const pinchEndSpy = sinon.spy(msz, '_pinchEnd');
+    msz._pinchStart();
+    msz._pinchCancel();
+    expect(pinchEndSpy.callCount).toBe(1);
+  });
+
+  test('sets will-change', async () => {
+    const mode = dummy_mode();
+    const msz = new ModeSmoothZoom(mode);
+    expect(mode.$visibleWorld.style.willChange).toBeFalsy();
+    msz._pinchStart();
+    expect(mode.$visibleWorld.style.willChange).toBe('transform');
+    await msz._pinchEnd();
+    expect(mode.$visibleWorld.style.willChange).toBe('auto');
+  });
+
+  test('pinch move updates scale', () => {
+    const mode = dummy_mode();
+    const msz = new ModeSmoothZoom(mode);
+    // disable buffering
+    msz.bufferFn = (callback) => callback();
+    msz._pinchStart();
+    expect(mode.scale).toBe(1);
+    msz._pinchMove({ scale: 2, center: { x: 0, y: 0 }});
+    expect(mode.scale).toBe(2);
+  });
+
+  test('updateScaleCenter sets scaleCenter in unitless coordinates', () => {
+    const mode = dummy_mode({
+      htmlDimensionsCacher: {
+        clientWidth: 200,
+        clientHeight: 100,
+        boundingClientRect: {
+          left: 5,
+          top: 50
+        }
+      }
+    });
+    const msz = new ModeSmoothZoom(mode);
+    expect(mode.scaleCenter).toEqual({ x: 0.5, y: 0.5 });
+    msz.updateScaleCenter({ clientX: 85, clientY: 110 });
+    expect(mode.scaleCenter).toEqual({ x: 0.4, y: 0.6 });
+  });
+
+  test('detaches all listeners', () => {
+    const mode = dummy_mode();
+    const msz = new ModeSmoothZoom(mode);
+    const containerEventSpy = EventTargetSpy.wrap(mode.$container);
+    const visibleWorldSpy = EventTargetSpy.wrap(mode.$visibleWorld);
+    const hammerEventSpy = new EventTargetSpy();
+    msz.hammer.on = hammerEventSpy.addEventListener.bind(hammerEventSpy);
+    msz.hammer.off = hammerEventSpy.removeEventListener.bind(hammerEventSpy);
+
+    msz.attach();
+    expect(containerEventSpy._totalListenerCount).toBeGreaterThan(0);
+    expect(hammerEventSpy._totalListenerCount).toBeGreaterThan(0);
+
+    msz.detach();
+    expect(containerEventSpy._totalListenerCount).toBe(0);
+    expect(visibleWorldSpy._totalListenerCount).toBe(0);
+    expect(hammerEventSpy._totalListenerCount).toBe(0);
+  });
+
+  test('attach can be called twice without double attachments', () => {
+    const mode = dummy_mode();
+    const msz = new ModeSmoothZoom(mode);
+    const containerEventSpy = EventTargetSpy.wrap(mode.$container);
+    const visibleWorldSpy = EventTargetSpy.wrap(mode.$visibleWorld);
+    const hammerEventSpy = new EventTargetSpy();
+    msz.hammer.on = hammerEventSpy.addEventListener.bind(hammerEventSpy);
+    msz.hammer.off = hammerEventSpy.removeEventListener.bind(hammerEventSpy);
+    msz.attach();
+
+    const containerListenersCount = containerEventSpy._totalListenerCount;
+    const visibleWorldListenersCount = visibleWorldSpy._totalListenerCount;
+    const hammerListenersCount = hammerEventSpy._totalListenerCount;
+
+    msz.attach();
+    expect(containerEventSpy._totalListenerCount).toBe(containerListenersCount);
+    expect(visibleWorldSpy._totalListenerCount).toBe(visibleWorldListenersCount);
+    expect(hammerEventSpy._totalListenerCount).toBe(hammerListenersCount);
+  });
+
+  describe('_handleCtrlWheel', () => {
+    test('non-ctrl wheel events ignored', () => {
+      const mode = dummy_mode();
+      const msz = new ModeSmoothZoom(mode);
+      expect(mode.scale).toBe(1);
+      const ev = new WheelEvent('wheel', { ctrlKey: false, deltaY: 20 });
+      const preventDefaultSpy = sinon.spy(ev, 'preventDefault');
+      msz._handleCtrlWheel(ev);
+      expect(preventDefaultSpy.callCount).toBe(0);
+      expect(mode.scale).toBe(1);
+    });
+
+    test('ctrl-wheel events update scale', () => {
+      const mode = dummy_mode();
+      const msz = new ModeSmoothZoom(mode);
+      expect(mode.scale).toBe(1);
+      const ev = new WheelEvent('wheel', { ctrlKey: true, deltaY: 20 });
+      const preventDefaultSpy = sinon.spy(ev, 'preventDefault');
+      msz._handleCtrlWheel(ev);
+      expect(preventDefaultSpy.callCount).toBe(1);
+      expect(mode.scale).not.toBe(1);
+    });
+  });
+});

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

@@ -0,0 +1,169 @@
+import sinon from 'sinon';
+import { getNavPageNumHtml } from '../../../src/BookReader/Navbar/Navbar.js';
+import BookReader from '../../../src/BookReader.js';
+
+describe('getNavPageNumHtml', () => {
+  const f = getNavPageNumHtml;
+  test('handle n-prefixed page numbers', () => {
+    expect(f(3, 40, 'n3', '', 40)).toBe('(4 of 40)');
+  });
+
+  test('handle regular page numbers', () => {
+    expect(f(3, 40, '14', '', 40)).toBe('14 of 40');
+  });
+
+  test('handle no max page', () => {
+    expect(f(3, 40, '14', '', null)).toBe('14');
+  });
+});
+
+/** @type {BookReader} */
+let br;
+/** @type {Navbar} */
+let navbar;
+beforeEach(() => {
+  document.body.innerHTML = '<div id="BookReader">';
+  br = new BookReader({
+    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();
+  navbar = br._components.navbar;
+});
+
+afterEach(() => sinon.restore());
+
+describe('Navbar slider', () => {
+  test('while sliding, visible page number updates, but does not flip', () => {
+    const $slider = navbar.$root.find('.BRpager');
+    const jumpToIndexSpy = sinon.spy(br, 'jumpToIndex');
+    expect(br.currentIndex()).toBe(0);
+
+    $slider.trigger('slide', { value: 3 });
+
+    expect(navbar.$root.find('.BRcurrentpage').text().includes('3'));
+    expect(jumpToIndexSpy.callCount).toBe(0);
+  });
+
+  test('on slide change, actual page changes', () => {
+    const $slider = navbar.$root.find('.BRpager');
+    const jumpToIndexSpy = sinon.spy(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);
+  });
+});
+
+describe('Navbar controls overrides', () => {
+  const createBRWithOverrides = (overrides) => {
+    br = new BookReader($.extend(true, br.options, overrides));
+    br.init();
+    navbar = br._components.navbar;
+  };
+
+  test(`when a view mode is excluded,
+      the mode should not be used in viewport toggling`, () => {
+    const overrides = {
+      controls: {
+        viewmode: {
+          visible: true,
+          className: 'viewmode',
+          excludedModes: [1],
+        }
+      }
+    };
+    createBRWithOverrides(overrides);
+
+    const $viewMode = navbar.$root.find('.viewmode');
+
+    expect($viewMode.find('.icon-thumb').length).toBe(1);
+    $viewMode.click();
+    expect($viewMode.find('.icon-twopg').length).toBe(1);
+    $viewMode.click();
+    expect($viewMode.find('.icon-thumb').length).toBe(1);
+  });
+
+  test('when a control is set to visible: false, do not return a button template', () => {
+    const overrides = {
+      controls: {
+        onePage: {
+          visible: false
+        }
+      }
+    };
+    createBRWithOverrides(overrides);
+
+    expect(navbar.$root.find('.onepg').length).toBe(0);
+    expect(navbar.$root.find('.twopg').length).toBe(1);
+  });
+
+  test(`when a control's className is overridden,
+      the class should be used in place of the default`, () => {
+    const overrides = {
+      controls: {
+        onePage: {
+          className: 'foo'
+        }
+      }
+    };
+    createBRWithOverrides(overrides);
+
+    expect(navbar.$root.find(`.${overrides.controls.onePage.className}`).length).toBe(1);
+    expect(navbar.$root.find('.onepg').length).toBe(0);
+  });
+
+  test(`when a control's template is overridden,
+      the HTML output should match the template provided`, () => {
+    const overrides = {
+      controls: {
+        onePage: {
+          template: () => (
+            '<button id="foo"></button>'
+          )
+        }
+      }
+    };
+    createBRWithOverrides(overrides);
+
+    expect(navbar.$root.find('#foo').length).toBe(1);
+    expect(navbar.$root.find('.onepg').length).toBe(0);
+  });
+
+  test(`when viewmode control set to visible,
+      the individual view mode controls are not rendered`, () => {
+    const overrides = {
+      controls: {
+        viewmode: {
+          visible: true
+        },
+        onePage: {
+          visible: false
+        }
+      }
+    };
+    createBRWithOverrides(overrides);
+
+    expect(navbar.$root.find('.viewmode').length).toBe(1);
+    expect(navbar.$root.find('.onepg').length).toBe(0);
+  });
+});