@internetarchive/ia-item-navigator 0.0.0-a10 → 0.0.0-a12

package/test/ia-item-navigator.test.ts

@@ -1,129 +1,113 @@
 /* eslint-disable camelcase */
-/* eslint-disable import/no-duplicates */
 import { html, fixture, expect } from '@open-wc/testing';
 import Sinon from 'sinon';
-// import { MetadataResponse, Metadata, File, Review, SpeechMusicASREntry } from '@internetarchive/search-service';
-import {
-  SharedResizeObserver,
-  // SharedResizeObserverInterface
-} from '@internetarchive/shared-resize-observer';
 
-// import { IntLoadingStateUpdatedEvent } from '../src/interfaces/event-interfaces';
+import { SharedResizeObserver } from '@internetarchive/shared-resize-observer';
+import { IntNavController } from '../src/interfaces/nav-controller-interface';
 import { ItemNavigator } from '../src/item-navigator';
 import '../src/item-navigator';
-// import { IaItemInspector } from '../src/item-inspector/item-inspector';
 
-// class ItemStub implements MetadataResponse {
-//   constructor() {
-//     this.rawResponse = '';
-//     this.created = 1;
-//     this.d1 = 'hello';
-//     this.d2 = 'boop';
-//     this.dir = 'whee';
-//     this.files = [];
-//     this.files_count = 0;
-//     this.item_last_updated = 2020;
-//     this.item_size = 111;
-//     this.metadata = { identifier: 'foo' } as Metadata;
-//     this.server = 'foo-server';
-//     this.uniq = 2;
-//     this.workable_servers = ['abc'];
-//   }
-
-//   rawResponse: any;
-
-//   created: number;
-
-//   d1: string;
-
-//   d2: string;
-
-//   dir: string;
-
-//   files: File[];
-
-//   files_count: number;
-
-//   item_last_updated: number;
-
-//   item_size: number;
-
-//   metadata: Metadata;
-
-//   server: string;
-
-//   uniq: number;
-
-//   workable_servers: string[];
-
-//   speech_vs_music_asr?: SpeechMusicASREntry[] | undefined;
-
-//   reviews?: Review[] | undefined;
-// };
+import '../test/book-nav-stub';
+import { ItemStub, menuProvider, shortcut } from '../test/ia-stub';
+import { IntManageSideMenuEvent } from '../src/interfaces/event-interfaces';
 
 afterEach(() => {
   Sinon.restore();
 });
 
 describe('ItemNavigator', () => {
-  describe('Loading Behavior', () => {
-    it('shows the spinning loader', async () => {
+  describe('Theaters', () => {
+    it('shows <ia-no-theater-available> by default', async () => {
       const el = await fixture<ItemNavigator>(
-        html`<ia-item-navigator></ia-item-navigator>`
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
       );
-      expect(el.shadowRoot?.querySelector('ia-itemnav-loader')).to.be.exist;
+      expect(el.shadowRoot?.querySelector('ia-no-theater-available')).to.exist;
+    });
+
+    it('shows <book-navigator> if `this.itemType = "bookreader"`', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator
+          .itemType=${`bookreader`}
+          .item=${new ItemStub()}
+        ></ia-item-navigator>`
+      );
+
+      await el.updateComplete;
+
+      el.toggleMenu();
+      await el.updateComplete;
+
+      const bookNavigator = el.shadowRoot?.querySelector(
+        'book-navigator'
+      ) as IntNavController;
+      await bookNavigator.updateComplete;
+
+      console.log('132234234324324324');
+      // TODO: add BookNavigator type & import via @internetarchive/bookreader
+      // For now, let's check that the BookNavigator element and its properties exist w/ stub
+      expect(bookNavigator).to.exist;
+      expect(bookNavigator?.modal).to.exist;
+      expect(bookNavigator?.baseHost).to.exist;
+      expect(bookNavigator?.book).to.exist;
+      expect(bookNavigator?.signedIn).to.be.null;
+      expect(bookNavigator?.sharedObserver).to.exist;
+      expect(bookNavigator?.sideMenuOpen).to.exist;
     });
-    it('hides reader section if not `loaded`', async () => {
+  });
+  describe('`el.loaded`', () => {
+    it('toggles the spinning loader', async () => {
       const el = await fixture<ItemNavigator>(
         html`<ia-item-navigator></ia-item-navigator>`
       );
-      const mainTheaterSection = el.shadowRoot?.querySelector('#reader');
-      expect(mainTheaterSection).to.be.exist;
-      expect(mainTheaterSection?.classList.contains('hide')).to.be.true;
-      expect(el.loaded).to.be.false;
-      expect(el.hasAttribute('loaded')).to.equal(false);
+      expect(el.loaded).to.be.null; // initial load
+      expect(el.shadowRoot?.querySelector('ia-itemnav-loader')).to.exist;
     });
-    it('shows reader once `loaded`', async () => {
+    it('hides reader section if `!loaded`', async () => {
       const el = await fixture<ItemNavigator>(
         html`<ia-item-navigator></ia-item-navigator>`
       );
-      el.loaded = true;
-      await el.updateComplete;
+
+      expect(
+        el.shadowRoot?.querySelector('#reader')?.getAttribute('class')
+      ).to.contain('hide');
+    });
+    it('shows reader when `loaded` ', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
 
       const mainTheaterSection = el.shadowRoot?.querySelector('#reader');
       expect(mainTheaterSection?.classList.contains('hide')).to.be.false;
       expect(el.loaded).to.be.true;
       // `loaded` property is reflected as DOM attribute
       expect(el.hasAttribute('loaded')).to.equal(true);
+      expect(el.shadowRoot?.querySelector('ia-no-theater-available')).to.exist;
     });
+    it('listens to `@loadingStateUpdated` to update `loaded`', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator></ia-item-navigator>`
+      );
 
-    // it('listens to event `loadingStateUpdated` to signal load', async () => {
-    //   const item = new ItemStub() as MetadataResponse;
-    //   const el = await fixture<ItemNavigator>(
-    //     html`<ia-item-navigator .item=${item}></ia-item-navigator>`
-    //   );
-    //   // const loadSpy = Sinon.spy();
-    //   // el.loadingStateUpdated = loadSpy;
-    //   await el.updateComplete;
-
-    //   expect(el?.item).to.not.be.undefined;
-
-    //   const mainTheaterSection = el.shadowRoot?.querySelector('#reader');
-
-    //   const contentController = mainTheaterSection?.querySelector('ia-item-inspector');
-
-    //   expect(contentController).to.equal(32324);
-
-    //   // const loadingEvent = new CustomEvent('loadingStateUpdated', { detail: { loaded: true }}) as IntLoadingStateUpdatedEvent;
-    //   // contentController?.emitLoadingStatusUpdate(true);
+      await el.updateComplete;
+      const spy = Sinon.spy();
+      el.loadingStateUpdated = spy;
+      el.loaded = false;
+      await el.updateComplete;
+      // check base properties
+      expect(el.loaded).to.equal(false);
+      expect(el.item).to.be.undefined;
 
-    //   // await contentController?.updateComplete;
-    //   // await el.updateComplete;
+      // hydrate item
+      el.item = new ItemStub();
+      await el.updateComplete;
 
-    // });
+      // spy fires
+      expect(spy.called).to.equal(true);
+      expect(spy.callCount).to.equal(1);
+    });
   });
 
-  describe('It uses a shared ResizeObserver', () => {
+  describe('`el.sharedObserver`', () => {
     it('can create one', async () => {
       const el = await fixture<ItemNavigator>(
         html`<ia-item-navigator></ia-item-navigator>`
@@ -146,7 +130,7 @@ describe('ItemNavigator', () => {
     });
   });
 
-  describe('It uses a shared modal component', () => {
+  describe('`el.modal`', () => {
     it('can create one', async () => {
       const el = await fixture<ItemNavigator>(
         html`<ia-item-navigator></ia-item-navigator>`
@@ -171,59 +155,123 @@ describe('ItemNavigator', () => {
     });
   });
 
-  // describe('full browser window immersion "fullscreen"', () => {
-  //   it('creates reflected attribute `viewportinfullscreen`', () =>{
-  //     /** to help with external styling adjustmnents */
-  //   });
-  // });
+  describe('full browser window immersion "fullscreen"', () => {
+    it('creates reflected attribute `viewportinfullscreen`', async () => {
+      /** to help with external styling adjustmnents */
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator></ia-item-navigator>`
+      );
+      expect(el.getAttribute('viewportinfullscreen')).to.be.null;
+
+      el.viewportInFullscreen = true;
+      await el.updateComplete;
+
+      expect(el.getAttribute('viewportinfullscreen')).to.exist;
+    });
+  });
 
-  // describe('Loads side menu contents', () =>{
-  // });
+  /* Side menu & shortcuts tests */
+  describe('el.menuOpened', () => {
+    it('toggles side menu open', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
 
-  // describe('Menu Shortcuts', () => {
-  // });
+      el.menuContents = [menuProvider];
+      await el.updateComplete;
 
-  //   it('passes the a11y audit', async () => {
-  //     const el = await fixture<YourWebComponent>(
-  //       html`<your-webcomponent></your-webcomponent>`
-  //     );
+      const nav = el.shadowRoot?.querySelector('nav');
 
-  //     await expect(el).shadowDom.to.be.accessible();
-  //   });
-});
+      expect(nav?.querySelector('#menu')).to.exist;
+      // side menu starts closed
+      expect(el.menuOpened).to.be.false;
+      expect(nav?.querySelector('#menu')?.getAttribute('class')).to.contain(
+        'hidden'
+      );
+
+      // let's open menu
+      el.toggleMenu();
+      await el.updateComplete;
+
+      expect(el.menuOpened).to.be.true;
+      expect(nav?.querySelector('#menu')?.getAttribute('class')).to.not.contain(
+        'hidden'
+      );
+    });
+
+    it('opens menu shortcut with `@manageSideMenuEvents`', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
+      const detail = {
+        menuId: 'fullscreen',
+        action: 'open',
+      };
+
+      el.menuContents = [menuProvider];
+      await el.updateComplete;
+      const frame = el.shadowRoot?.querySelector('#frame');
+      // default menu open behavior is to side menu open, not overlay
+      expect(frame?.getAttribute('class')).to.contain('shift');
+
+      expect(el.menuOpened).to.be.false;
+      expect(el.openMenu).to.be.empty;
+      expect(frame?.getAttribute('class')).to.not.contain('open');
+
+      const event = new CustomEvent('updateSideMenu', {
+        detail,
+      }) as IntManageSideMenuEvent;
+      el.manageSideMenuEvents(event);
+      await el.updateComplete;
+
+      expect(el.shouldRenderMenu).to.be.true;
+      expect(el.menuOpened).to.be.true;
+      expect(el.openMenu).to.equal(detail.menuId);
+
+      expect(frame?.getAttribute('class')).to.contain('open');
+    });
+  });
+
+  describe('el.menuContents', () => {
+    it('draws side menu when populated', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
+
+      el.menuContents = [menuProvider];
+      await el.updateComplete;
+      expect(el.menuContents.length).to.exist;
+      expect(el.shouldRenderMenu).to.be.true;
+
+      const nav = el.shadowRoot?.querySelector('nav');
+      expect(nav).to.exist;
 
-// describe('YourWebComponent', () => {
-//   it('has a default title "Hey there" and counter 5', async () => {
-//     const el = await fixture<YourWebComponent>(
-//       html`<your-webcomponent></your-webcomponent>`
-//     );
-
-//     expect(el.title).to.equal('Hey there');
-//     expect(el.counter).to.equal(5);
-//   });
-
-//   it('increases the counter on button click', async () => {
-//     const el = await fixture<YourWebComponent>(
-//       html`<your-webcomponent></your-webcomponent>`
-//     );
-//     el.shadowRoot!.querySelector('button')!.click();
-
-//     expect(el.counter).to.equal(6);
-//   });
-
-//   it('can override the title via attribute', async () => {
-//     const el = await fixture<YourWebComponent>(
-//       html`<your-webcomponent title="attribute title"></your-webcomponent>`
-//     );
-
-//     expect(el.title).to.equal('attribute title');
-//   });
-
-//   it('passes the a11y audit', async () => {
-//     const el = await fixture<YourWebComponent>(
-//       html`<your-webcomponent></your-webcomponent>`
-//     );
-
-//     await expect(el).shadowDom.to.be.accessible();
-//   });
-// });
+      const menuSlider = nav?.querySelector('ia-menu-slider');
+      expect(menuSlider).to.exist;
+      expect(menuSlider?.getAttribute('manuallyhandleclose')).to.exist;
+      expect(menuSlider?.getAttribute('open')).to.exist;
+    });
+  });
+
+  describe('`el.menuShortcuts`', () => {
+    it('displays shortcut & toggle side menu button', async () => {
+      const el = await fixture<ItemNavigator>(
+        html`<ia-item-navigator .item=${new ItemStub()}></ia-item-navigator>`
+      );
+
+      el.menuContents = [menuProvider];
+      el.menuShortcuts = [shortcut];
+      await el.updateComplete;
+
+      const nav = el.shadowRoot?.querySelector('nav');
+
+      expect(el.menuShortcuts.length).to.exist;
+      expect(nav).to.exist;
+      expect(nav?.querySelector('.shortcuts')).to.exist;
+      expect(
+        nav?.querySelector('.shortcuts')?.querySelector('i.fullscreen-test')
+      ).to.exist;
+      expect(nav?.querySelector('.toggle-menu')).to.exist;
+    });
+  });
+});

package/test/ia-stub.ts

@@ -1,3 +1,79 @@
-// const parsed = JSON.parse(raw);
+/* eslint-disable camelcase */
+import {
+  MetadataResponse,
+  Metadata,
+  File,
+  Review,
+  SpeechMusicASREntry,
+} from '@internetarchive/search-service';
+import { html } from 'lit-html';
+import {
+  IntMenuShortcut,
+  IntMenuProvider,
+} from '../src/interfaces/menu-interfaces';
 
-// export default parsed;
+export class ItemStub implements MetadataResponse {
+  constructor() {
+    this.rawResponse = '';
+    this.created = 1;
+    this.d1 = 'hello';
+    this.d2 = 'boop';
+    this.dir = 'whee';
+    this.files = [];
+    this.files_count = 0;
+    this.item_last_updated = 2020;
+    this.item_size = 111;
+    this.metadata = { identifier: 'foo' } as Metadata;
+    this.server = 'foo-server';
+    this.uniq = 2;
+    this.workable_servers = ['abc'];
+  }
+
+  rawResponse: any;
+
+  created: number;
+
+  d1: string;
+
+  d2: string;
+
+  dir: string;
+
+  files: File[];
+
+  files_count: number;
+
+  item_last_updated: number;
+
+  item_size: number;
+
+  metadata: Metadata;
+
+  server: string;
+
+  uniq: number;
+
+  workable_servers: string[];
+
+  speech_vs_music_asr?: SpeechMusicASREntry[] | undefined;
+
+  reviews?: Review[] | undefined;
+}
+
+export const shortcut = {
+  id: 'fullscreen',
+  icon: html`<i class="fas fullscreen-test"></i>`,
+} as IntMenuShortcut;
+
+export const menuProvider = {
+  ...shortcut,
+  label: 'foo',
+  menuDetails: html`<div>foo</div>`,
+  selected: true,
+  followable: false,
+  href: 'https://archive.foo',
+  item: new ItemStub(),
+  baseHost: 'https://archive.foo',
+  subPrefix: 'bar',
+  updated: () => {},
+} as IntMenuProvider;

package/test/no-theater-available.test.ts

@@ -0,0 +1,32 @@
+import { html, fixture, expect } from '@open-wc/testing';
+import { IANoTheaterAvailable } from '../src/no-theater-available';
+import '../src/no-theater-available';
+
+describe('IANoTheaterAvailable', () => {
+  it('Fires `loadingStateUpdated` on identifier change', async () => {
+    const el = await fixture<IANoTheaterAvailable>(
+      html`<ia-no-theater-available
+        .identifier=${`foo`}
+      ></ia-no-theater-available>`
+    );
+    let eventFired = false;
+    el.addEventListener('loadingStateUpdated', () => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      eventFired = true;
+    });
+    expect(eventFired).to.be.false;
+
+    el.identifier = 'bar';
+    await el.updateComplete;
+    expect(eventFired).to.be.true;
+  });
+  it('Has link to item download page', async () => {
+    const el = await fixture<IANoTheaterAvailable>(
+      html`<ia-no-theater-available
+        .identifier=${`foo`}
+      ></ia-no-theater-available>`
+    );
+    expect(el.downloadUrl).to.equal('/download/foo');
+    expect(el?.shadowRoot?.querySelector('a')?.href).to.contain(el.downloadUrl);
+  });
+});