@internetarchive/bookreader 5.0.0-42-a2 → 5.0.0-44-a1

package/tests/{karma → jest}/BookNavigator/bookmarks/bookmark-edit.test.js

@@ -1,10 +1,9 @@
 import {
   html,
   fixture,
-  expect,
   oneEvent,
-} from '@open-wc/testing';
-import '../../../../src/BookNavigator/bookmarks/bookmark-edit.js';
+} from '@open-wc/testing-helpers';
+import '@/src/BookNavigator/bookmarks/bookmark-edit.js';
 
 const bookmarkColors = [{
   id: 0,
@@ -36,42 +35,42 @@ const bookmark = {
 };
 
 describe('<ia-bookmark-edit>', () => {
-  it('sets default properties', async () => {
+  test('sets default properties', async () => {
     const el = await fixture(container(bookmark));
 
-    expect(el.bookmark).to.equal(bookmark);
-    expect(el.renderHeader).to.be.false;
+    expect(el.bookmark).toEqual(bookmark);
+    expect(el.renderHeader).toBeFalsy();
   });
 
-  it('renders bookmark thumb and page number', async () => {
+  test('renders bookmark thumb and page number', async () => {
     const el = await fixture(container(bookmark));
 
-    expect(el.shadowRoot.querySelector('img').getAttribute('src')).to.equal(bookmark.thumbnail);
-    expect(el.shadowRoot.querySelector('h4').innerText).to.equal(`Page ${bookmark.page}`);
+    expect(el.shadowRoot.querySelector('img').getAttribute('src')).toEqual(bookmark.thumbnail);
+    expect(el.shadowRoot.querySelector('h4').textContent).toEqual(`Page ${bookmark.page}`);
   });
 
-  it('renders an optional header section', async () => {
+  test('renders an optional header section', async () => {
     const el = await fixture(container(bookmark));
     el.renderHeader = true;
 
     await el.updateComplete;
 
-    expect(el.shadowRoot.querySelector('header')).to.exist;
+    expect(el.shadowRoot.querySelector('header')).toBeDefined();
   });
 
-  it('toggles rendering of the bookmark thumbnail and page number', async () => {
+  test('toggles rendering of the bookmark thumbnail and page number', async () => {
     const el = await fixture(container(bookmark));
-    expect(el.shadowRoot.querySelector('img')).to.exist;
-    expect(el.shadowRoot.querySelector('h4')).to.exist;
+    expect(el.shadowRoot.querySelector('img')).toBeDefined();
+    expect(el.shadowRoot.querySelector('h4')).toBeDefined();
 
     el.showBookmark = false;
     await el.updateComplete;
 
-    expect(el.shadowRoot.querySelector('img')).to.not.exist;
-    expect(el.shadowRoot.querySelector('h4')).to.not.exist;
+    expect(el.shadowRoot.querySelector('img')).toBe(null);
+    expect(el.shadowRoot.querySelector('h4')).toBe(null);
   });
 
-  it('emits a custom event when the bookmark color is changed', async () => {
+  test('emits a custom event when the bookmark color is changed', async () => {
     const el = await fixture(container(bookmark));
 
     setTimeout(() => (
@@ -79,10 +78,10 @@ describe('<ia-bookmark-edit>', () => {
     ));
     const response = await oneEvent(el, 'bookmarkColorChanged');
 
-    expect(response).to.exist;
+    expect(response).toBeDefined();
   });
 
-  it('emits a custom event when the edit form is submitted', async () => {
+  test('emits a custom event when the edit form is submitted', async () => {
     const el = await fixture(container(bookmark));
 
     setTimeout(() => (
@@ -90,10 +89,10 @@ describe('<ia-bookmark-edit>', () => {
     ));
     const response = await oneEvent(el, 'saveBookmark');
 
-    expect(response).to.exist;
+    expect(response).toBeDefined();
   });
 
-  it('emits a custom event when the delete button is clicked', async () => {
+  test('emits a custom event when the delete button is clicked', async () => {
     const el = await fixture(container(bookmark));
 
     setTimeout(() => (
@@ -101,10 +100,10 @@ describe('<ia-bookmark-edit>', () => {
     ));
     const response = await oneEvent(el, 'deleteBookmark');
 
-    expect(response).to.exist;
+    expect(response).toBeDefined();
   });
 
-  it('updates bookmark color when a color input changed', async () => {
+  test('updates bookmark color when a color input changed', async () => {
     const el = await fixture(container(bookmark));
 
     setTimeout(() => (
@@ -112,10 +111,10 @@ describe('<ia-bookmark-edit>', () => {
     ));
     await oneEvent(el, 'bookmarkColorChanged');
 
-    expect(el.bookmark.color).to.equal(2);
+    expect(el.bookmark.color).toEqual(2);
   });
 
-  it('updates bookmark note when the note textarea changed', async () => {
+  test('updates bookmark note when the note textarea changed', async () => {
     const el = await fixture(container(bookmark));
     const textarea = el.shadowRoot.querySelector('textarea');
     const updatedNote = 'New note';
@@ -128,6 +127,6 @@ describe('<ia-bookmark-edit>', () => {
 
     await oneEvent(textarea, 'change');
 
-    expect(el.bookmark.note).to.contain(updatedNote);
+    expect(el.bookmark.note).toContain(updatedNote);
   });
 });

package/tests/{karma → jest}/BookNavigator/bookmarks/bookmarks-list.test.js

@@ -1,10 +1,9 @@
 import {
   html,
   fixture,
-  expect,
   oneEvent,
-} from '@open-wc/testing';
-import '../../../../src/BookNavigator/bookmarks/bookmarks-list.js';
+} from '@open-wc/testing-helpers';
+import '@/src/BookNavigator/bookmarks/bookmarks-list.js';
 
 const bookmarks = [{
   id: 1,
@@ -41,24 +40,24 @@ describe('<ia-bookmarks-list>', () => {
   it('sets default properties', async () => {
     const el = await fixture(container(bookmarks));
 
-    expect(el.bookmarks).to.equal(bookmarks);
-    expect(el.activeBookmarkID).to.be.undefined;
-    expect(el.renderHeader).to.be.false;
+    expect(el.bookmarks).toEqual(bookmarks);
+    expect(el.activeBookmarkID).toBeUndefined();
+    expect(el.renderHeader).toBeFalsy();
   });
 
-  it('renders bookmarks that contain page numbers', async () => {
+  test('renders bookmarks that contain page numbers', async () => {
     const el = await fixture(container(bookmarks));
 
-    expect(el.shadowRoot.textContent).to.include(`Page ${bookmarks[0].page}`);
+    expect(el.shadowRoot.textContent).toContain(`Page ${bookmarks[0].page}`);
   });
 
-  it('renders bookmarks that contain an optional note', async () => {
+  test('renders bookmarks that contain an optional note', async () => {
     const el = await fixture(container(bookmarks));
 
-    expect(el.shadowRoot.innerHTML).to.include(bookmarks[1].note);
+    expect(el.shadowRoot.innerHTML).toContain(bookmarks[1].note);
   });
 
-  it('emits a custom event when a bookmark is clicked', async () => {
+  test('emits a custom event when a bookmark is clicked', async () => {
     const el = await fixture(container(bookmarks));
 
     setTimeout(() => (
@@ -66,10 +65,10 @@ describe('<ia-bookmarks-list>', () => {
     ));
     const response = await oneEvent(el, 'bookmarkSelected');
 
-    expect(response).to.exist;
+    expect(response).toBeDefined();
   });
 
-  it('emits a custom event when an edit button is clicked', async () => {
+  test('emits a custom event when an edit button is clicked', async () => {
     const el = await fixture(container(bookmarks));
 
     setTimeout(() => (
@@ -77,10 +76,10 @@ describe('<ia-bookmarks-list>', () => {
     ));
     const response = await oneEvent(el, 'bookmarkEdited');
 
-    expect(response).to.exist;
+    expect(response).toBeDefined();
   });
 
-  it('emits a saveBookmark event', async () => {
+  test('emits a saveBookmark event', async () => {
     const el = await fixture(container(bookmarks));
 
     setTimeout(() => (
@@ -88,10 +87,10 @@ describe('<ia-bookmarks-list>', () => {
     ));
     const response = await oneEvent(el, 'saveBookmark');
 
-    expect(response).to.exist;
+    expect(response).toBeDefined();
   });
 
-  it('emits a deleteBookmark event', async () => {
+  test('emits a deleteBookmark event', async () => {
     const el = await fixture(container(bookmarks));
 
     setTimeout(() => (
@@ -99,10 +98,10 @@ describe('<ia-bookmarks-list>', () => {
     ));
     const response = await oneEvent(el, 'deleteBookmark');
 
-    expect(response).to.exist;
+    expect(response).toBeDefined();
   });
 
-  it('emits a bookmarkColorChanged event', async () => {
+  test('emits a bookmarkColorChanged event', async () => {
     const el = await fixture(container(bookmarks));
 
     setTimeout(() => (
@@ -110,18 +109,18 @@ describe('<ia-bookmarks-list>', () => {
     ));
     const response = await oneEvent(el, 'bookmarkColorChanged');
 
-    expect(response).to.exist;
+    expect(response).toBeDefined();
   });
 
-  it('sets editedBookmark when an edit button is clicked', async () => {
+  test('sets editedBookmark when an edit button is clicked', async () => {
     const el = await fixture(container(bookmarks));
     let prevState = el.editedBookmark;
 
     el.shadowRoot.querySelector('li button').click();
     await el.updateComplete;
 
-    expect(el.editedBookmark).not.to.equal(prevState);
-    expect(el.editedBookmark.page).to.equal(bookmarks[0].page);
+    expect(el.editedBookmark).not.toEqual(prevState);
+    expect(el.editedBookmark.page).toEqual(bookmarks[0].page);
 
     // When clicking the same edit button while in edit mode, should toggle
     // edit mode off and remove editedBookmark pointer
@@ -129,11 +128,11 @@ describe('<ia-bookmarks-list>', () => {
     el.shadowRoot.querySelector('li button').click();
     await el.updateComplete;
 
-    expect(el.editedBookmark).not.to.equal(prevState);
-    expect(el.editedBookmark.page).not.to.equal(bookmarks[0].page);
+    expect(el.editedBookmark).not.toEqual(prevState);
+    expect(el.editedBookmark.page).not.toEqual(bookmarks[0].page);
   });
 
-  it('resets editedBookmark when saveBookmark callback called', async () => {
+  test('resets editedBookmark when saveBookmark callback called', async () => {
     const el = await fixture(container(bookmarks));
 
     [el.editedBookmark] = bookmarks;
@@ -141,11 +140,11 @@ describe('<ia-bookmarks-list>', () => {
     el.saveBookmark({ detail: { bookmark: bookmarks[0] } });
     await el.updateComplete;
 
-    expect(el.editedBookmark).not.to.equal(bookmarks[0]);
-    expect(el.editedBookmark).not.to.have.keys(['page', 'thumbnail', 'id']);
+    expect(el.editedBookmark).not.toEqual(bookmarks[0]);
+    expect(el.editedBookmark).not.toHaveProperty('page', 'thumbnail', 'id');
   });
 
-  it('resets editedBookmark when deleteBookmark callback called', async () => {
+  test('resets editedBookmark when deleteBookmark callback called', async () => {
     const el = await fixture(container(bookmarks));
 
     [el.editedBookmark] = bookmarks;
@@ -153,33 +152,33 @@ describe('<ia-bookmarks-list>', () => {
     el.deleteBookmark({ detail: { id: bookmarks[0].id } });
     await el.updateComplete;
 
-    expect(el.editedBookmark).not.to.equal(bookmarks[0]);
-    expect(el.editedBookmark).not.to.have.keys(['page', 'thumbnail', 'id']);
+    expect(el.editedBookmark).not.toEqual(bookmarks[0]);
+    expect(el.editedBookmark).not.toHaveProperty('page', 'thumbnail', 'id');
   });
 
-  it('renders the bookmarks count', async () => {
+  test('renders the bookmarks count', async () => {
     const el = await fixture(container([bookmarks[0]]));
     const bookmarksCount = await fixture(el.bookmarksCount);
 
-    expect(bookmarksCount.textContent).to.include('(1)');
+    expect(bookmarksCount.textContent).toContain('(1)');
   });
 
-  it('does not render the bookmarks count when no bookmarks present', async () => {
+  test('does not render the bookmarks count when no bookmarks present', async () => {
     const el = await fixture(container());
     el.renderHeader = true;
 
     await el.updateComplete;
 
-    expect(el.shadowRoot.querySelector('header small')).not.to.exist;
+    expect(el.shadowRoot.querySelector('header small')).toBe(null);
   });
 
-  it('renders an optional header section', async () => {
+  test('renders an optional header section', async () => {
     const el = await fixture(container(bookmarks));
     el.renderHeader = true;
 
     await el.updateComplete;
 
-    expect(el.shadowRoot.querySelector('header')).to.exist;
+    expect(el.shadowRoot.querySelector('header')).toBeDefined();
   });
 
   // skipped:
@@ -192,7 +191,7 @@ describe('<ia-bookmarks-list>', () => {
     ));
     const response = await oneEvent(el, 'addBookmark');
 
-    expect(response).to.exist;
+    expect(response).toBeDefined();
   });
 
   // skipped:
@@ -200,23 +199,23 @@ describe('<ia-bookmarks-list>', () => {
   xit('renders an optional add bookmark button', async () => {
     const el = await fixture(container(bookmarks));
 
-    expect(el.shadowRoot.querySelector('.add-bookmark')).to.exist;
+    expect(el.shadowRoot.querySelector('.add-bookmark')).toBeDefined();
 
     el.renderAddBookmarkButton = false;
     await el.updateComplete;
 
-    expect(el.shadowRoot.querySelector('.add-bookmark')).not.to.exist;
+    expect(el.shadowRoot.querySelector('.add-bookmark')).not.toBeDefined();
   });
 
   // skipped:
   // TypeError: Cannot read property 'getAttribute' of null
   xit('can toggle disable behavior of add bookmark button', async () => {
     const el = await fixture(container(bookmarks));
-    expect(el.shadowRoot.querySelector('.add-bookmark').getAttribute('disabled')).to.be.null;
+    expect(el.shadowRoot.querySelector('.add-bookmark').getAttribute('disabled')).toBeNull();
 
     el.disableAddBookmarkButton = true;
     await el.updateComplete;
 
-    expect(el.shadowRoot.querySelector('.add-bookmark').getAttribute('disabled')).to.equal('disabled');
+    expect(el.shadowRoot.querySelector('.add-bookmark').getAttribute('disabled')).toEqual('disabled');
   });
 });

package/tests/jest/BookNavigator/bookmarks/ia-bookmarks.test.js

@@ -0,0 +1,45 @@
+import {
+  html,
+  fixtureSync,
+  fixtureCleanup,
+} from '@open-wc/testing-helpers';
+import '@/src/BookNavigator/bookmarks/ia-bookmarks.js';
+import sinon from 'sinon';
+
+afterEach(() => {
+  sinon.restore();
+  fixtureCleanup();
+});
+
+describe('<ia-bookmarks>', () => {
+  test('uses `setup` to start component', async () => {
+    const el = fixtureSync(html`<ia-bookmarks displayMode="bookmarks"></ia-bookmarks>`);
+    el.bookreader = {
+      bookId: 'foo',
+      $,
+      currentIndex: () => 0,
+    };
+    await el.updateComplete;
+    const fetchUserBookmarks = sinon.spy(el, 'fetchUserBookmarks');
+    const fetchBookmarks = sinon.stub(el, 'fetchBookmarks');
+
+    el.setup();
+    await el.updateComplete;
+
+    expect(fetchUserBookmarks.callCount).toEqual(1);
+    expect(fetchBookmarks.callCount).toEqual(1);
+  });
+
+  test('does not fetch user bookmarks if displayMode = login', async () => {
+    const el = fixtureSync(html`<ia-bookmarks displayMode="login"></ia-bookmarks>`);
+    await el.updateComplete;
+    const fetchSpy = sinon.spy(el, 'fetchUserBookmarks');
+    const fetchBookmarks = sinon.stub(el, 'fetchBookmarks');
+
+    el.setup();
+    await el.updateComplete;
+
+    expect(fetchSpy.callCount).toEqual(0);
+    expect(fetchBookmarks.callCount).toEqual(0);
+  });
+});

package/tests/{karma → jest}/BookNavigator/downloads/downloads-provider.test.js

@@ -1,6 +1,6 @@
-import { expect, fixtureCleanup, fixtureSync } from '@open-wc/testing';
+import { fixtureCleanup, fixtureSync } from '@open-wc/testing-helpers';
 import sinon from 'sinon';
-import DownloadsProvider from '../../../../src/BookNavigator/downloads/downloads-provider';
+import DownloadsProvider from '@/src/BookNavigator/downloads/downloads-provider';
 
 const downloadableTypes = [
   ["PDF", "//archive.org/download/theworksofplato01platiala/theworksofplato01platiala.pdf"],
@@ -29,39 +29,39 @@ afterEach(() => {
 });
 
 describe('Downloads Provider', () => {
-  it('constructor - initial setup', () => {
+  test('constructor - initial setup', () => {
     const isBookProtected = false;
     const provider = new DownloadsProvider(isBookProtected);
 
-    expect(provider.id).to.equal('downloads');
-    expect(provider.icon).to.exist;
-    expect(fixtureSync(provider.icon).tagName).to.equal('IA-ICON-DL');
-    expect(provider.label).to.equal('Downloadable files');
-    expect(provider.menuDetails).to.exist;
-    expect(provider.component).to.exist;
+    expect(provider.id).toEqual('downloads');
+    expect(provider.icon).toBeDefined();
+    expect(fixtureSync(provider.icon).tagName).toEqual('IA-ICON-DL');
+    expect(provider.label).toEqual('Downloadable files');
+    expect(provider.menuDetails).toBeDefined();
+    expect(provider.component).toBeDefined();
 
     provider.update(downloadableTypes);
 
-    expect(provider.isBookProtected).to.equal(false);
+    expect(provider.isBookProtected).toEqual(false);
 
-    expect(provider.downloads[0].type).to.equals("PDF");
-    expect(provider.downloads[1].type).to.equals("ePub");
+    expect(provider.downloads[0].type).toEqual("PDF");
+    expect(provider.downloads[1].type).toEqual("ePub");
 
-    expect(provider.menuDetails).to.equal(`(${downloads.length} formats)`);
+    expect(provider.menuDetails).toEqual(`(${downloads.length} formats)`);
   });
 
-  it('render view if book is protected', () => {
+  test('render view if book is protected', () => {
     const provider = new DownloadsProvider({
       bookreader: { options: { isProtected: true } }
     });
 
-    expect(provider.isBookProtected).to.equal(true);
+    expect(provider.isBookProtected).toEqual(true);
 
     provider.update(downloadableTypes);
 
-    expect(provider.downloads[0].type).to.equals("Encrypted Adobe PDF");
-    expect(provider.downloads[1].type).to.equals("Encrypted Adobe ePub");
+    expect(provider.downloads[0].type).toEqual("Encrypted Adobe PDF");
+    expect(provider.downloads[1].type).toEqual("Encrypted Adobe ePub");
 
-    expect(provider.downloads.length).to.equals(downloads.length);
+    expect(provider.downloads.length).toEqual(downloads.length);
   });
 });

package/tests/{karma → jest}/BookNavigator/downloads/downloads.test.js

@@ -1,11 +1,10 @@
 import {
   html,
   fixture,
-  expect,
   fixtureCleanup,
-} from '@open-wc/testing';
+} from '@open-wc/testing-helpers';
 import sinon from 'sinon';
-import '../../../../src/BookNavigator/downloads/downloads';
+import '@/src/BookNavigator/downloads/downloads';
 
 
 const downloads = [
@@ -41,14 +40,14 @@ afterEach(() => {
 });
 
 describe('<ia-book-downloads>', () => {
-  it('sets default properties', async () => {
+  test('sets default properties', async () => {
     const el = await fixture(container(downloads));
     await el.updateComplete;
 
-    expect(el.downloads.length).to.equal(2);
-    expect(el.shadowRoot.querySelector("ul").childElementCount).to.equal(2);
-    expect(el.isBookProtected).to.equal(false);
+    expect(el.downloads.length).toEqual(2);
+    expect(el.shadowRoot.querySelector("ul").childElementCount).toEqual(2);
+    expect(el.isBookProtected).toEqual(false);
 
-    expect(el.shadowRoot.querySelector("ul li a").textContent).to.include("Get PDF");
+    expect(el.shadowRoot.querySelector("ul li a").textContent).toContain("Get PDF");
   });
 });

package/tests/{karma → jest}/BookNavigator/search/search-provider.test.js

@@ -1,6 +1,6 @@
-import { expect, fixtureCleanup, fixtureSync } from '@open-wc/testing';
+import { fixtureCleanup, fixtureSync } from '@open-wc/testing-helpers';
 import sinon from 'sinon';
-import searchProvider from '../../../../src/BookNavigator/search/search-provider';
+import searchProvider from '@/src/BookNavigator/search/search-provider';
 
 afterEach(() => {
   sinon.restore();
@@ -14,26 +14,26 @@ describe('Search Provider', () => {
       bookreader: {}
     });
 
-    expect(provider.bookreader).to.exist;
-    expect(provider.onProviderChange).to.exist;
-    expect(provider.id).to.equal('search');
-    expect(provider.icon).to.exist;
-    expect(fixtureSync(provider.icon).tagName).to.equal('IA-ICON-SEARCH');
-    expect(provider.label).to.equal('Search inside');
-    expect(provider.menuDetails).to.exist;
-    expect(provider.component).to.exist;
+    expect(provider.bookreader).toBeDefined();
+    expect(provider.onProviderChange).toBeDefined();
+    expect(provider.id).toEqual('search');
+    expect(provider.icon).toBeDefined();
+    expect(fixtureSync(provider.icon).tagName).toEqual('IA-ICON-SEARCH');
+    expect(provider.label).toEqual('Search inside');
+    expect(provider.menuDetails).toBeDefined();
+    expect(provider.component).toBeDefined();
   });
   describe('Search request life cycles', () => {
-    it('Event: catches `BookReader:SearchStarted`', async() => {
+    test('Event: catches `BookReader:SearchStarted`', async() => {
       const provider = new searchProvider({
         onProviderChange: sinon.fake(),
         bookreader: {}
       });
       sinon.spy(provider, 'updateMenu');
       window.dispatchEvent(new CustomEvent('BookReader:SearchStarted', { detail: { props: { term: 'foo' }}}));
-      expect(provider.updateMenu.callCount).to.equal(1);
+      expect(provider.updateMenu.callCount).toEqual(1);
     });
-    it('Event: catches `BookReader:SearchCallback`', async() => {
+    test('Event: catches `BookReader:SearchCallback`', async() => {
       const provider = new searchProvider({
         onProviderChange: sinon.fake(),
         bookreader: {}
@@ -41,10 +41,10 @@ describe('Search Provider', () => {
       sinon.spy(provider, 'updateMenu');
       const brStub = {};
       window.dispatchEvent(new CustomEvent('BookReader:SearchCallback', { detail: { props: { instance: brStub, results: { matches: []} }}}));
-      expect(provider.updateMenu.callCount).to.equal(1);
-      expect(provider.bookreader).to.equal(brStub);
+      expect(provider.updateMenu.callCount).toEqual(1);
+      expect(provider.bookreader).toEqual(brStub);
     });
-    it('Event: catches `BookReader:SearchCallbackEmpty`', async() => {
+    test('Event: catches `BookReader:SearchCallbackEmpty`', async() => {
       const provider = new searchProvider({
         onProviderChange: sinon.fake(),
         bookreader: {}
@@ -53,11 +53,11 @@ describe('Search Provider', () => {
       sinon.spy(provider, 'updateMenu');
       const brStub = {};
       window.dispatchEvent(new CustomEvent('BookReader:SearchCallbackEmpty', { detail: { props: { instance: brStub }}}));
-      expect(provider.onSearchRequestError.getCall(0).args[1]).to.equal('noResults');
-      expect(provider.updateMenu.callCount).to.equal(1);
-      expect(provider.bookreader).to.equal(brStub);
+      expect(provider.onSearchRequestError.getCall(0).args[1]).toEqual('noResults');
+      expect(provider.updateMenu.callCount).toEqual(1);
+      expect(provider.bookreader).toEqual(brStub);
     });
-    it('Event: catches `BookReader:SearchCallbackNotIndexed`', async() => {
+    test('Event: catches `BookReader:SearchCallbackNotIndexed`', async() => {
       const provider = new searchProvider({
         onProviderChange: sinon.fake(),
         bookreader: {}
@@ -66,11 +66,11 @@ describe('Search Provider', () => {
       sinon.spy(provider, 'onSearchRequestError');
       sinon.spy(provider, 'updateMenu');
       window.dispatchEvent(new CustomEvent('BookReader:SearchCallbackNotIndexed', { detail: { props: { instance: brStub }}}));
-      expect(provider.onSearchRequestError.getCall(0).args[1]).to.equal('notIndexed');
-      expect(provider.updateMenu.callCount).to.equal(1);
-      expect(provider.bookreader).to.equal(brStub);
+      expect(provider.onSearchRequestError.getCall(0).args[1]).toEqual('notIndexed');
+      expect(provider.updateMenu.callCount).toEqual(1);
+      expect(provider.bookreader).toEqual(brStub);
     });
-    it('Event: catches `BookReader:SearchCallbackError`', async() => {
+    test('Event: catches `BookReader:SearchCallbackError`', async() => {
       const provider = new searchProvider({
         onProviderChange: sinon.fake(),
         bookreader: {}
@@ -79,11 +79,11 @@ describe('Search Provider', () => {
       sinon.spy(provider, 'updateMenu');
       const brStub = {};
       window.dispatchEvent(new CustomEvent('BookReader:SearchCallbackError', { detail: { props: { instance: brStub }}}));
-      expect(provider.onSearchRequestError.getCall(0).args[1]).to.equal(undefined);
-      expect(provider.updateMenu.callCount).to.equal(1);
-      expect(provider.bookreader).to.equal(brStub);
+      expect(provider.onSearchRequestError.getCall(0).args[1]).toEqual(undefined);
+      expect(provider.updateMenu.callCount).toEqual(1);
+      expect(provider.bookreader).toEqual(brStub);
     });
-    it('Event: catches `component@resultSelected` - user clicks result in side panel - & turns page', async() => {
+    test('Event: catches `component@resultSelected` - user clicks result in side panel - & turns page', async() => {
       const provider = new searchProvider({
         onProviderChange: sinon.fake(),
         bookreader: {
@@ -100,7 +100,7 @@ describe('Search Provider', () => {
           { detail: searchResultStub })
       );
 
-      expect(provider.bookreader._searchPluginGoToResult.callCount).to.equal(1);
+      expect(provider.bookreader._searchPluginGoToResult.callCount).toEqual(1);
     });
   });
 });