@internetarchive/collection-browser 0.3.5-alpha.1 → 0.3.5

package/test/collection-facets/facets-template.test.ts

@@ -49,17 +49,19 @@ describe('Render facets', () => {
     expect(el.shadowRoot?.querySelector('.facets-on-modal')).to.exist;
   });
 
-  it('find facet-title and facet-count for perticular facet group', async () => {
+  it('find facet-title and facet-count for particular facet group', async () => {
     const el = await fixture<FacetsTemplate>(
       html`<facets-template .facetGroup=${facetGroup}></facets-template>`
     );
     await el.updateComplete;
 
     const facetInfo = el.shadowRoot?.querySelector('.facet-info-display');
-    expect(facetInfo?.querySelector('.facet-title')?.textContent).equal(
+    expect(facetInfo?.querySelector('.facet-title')?.textContent).to.equal(
       'audio'
     );
-    expect(facetInfo?.querySelector('.facet-count')?.textContent).equal('1001');
+    expect(
+      facetInfo?.querySelector('.facet-count')?.textContent?.trim()
+    ).to.equal('1,001');
   });
 
   it('find the hidden facet item', async () => {

package/test/mocks/mock-search-responses.ts

@@ -1,226 +1,226 @@
-import type { Result } from '@internetarchive/result-type';
-import {
-  ItemHit,
-  SearchResponse,
-  SearchServiceError,
-} from '@internetarchive/search-service';
-
-export const mockSuccessSingleResult: Result<
-  SearchResponse,
-  SearchServiceError
-> = {
-  success: {
-    request: {
-      clientParameters: {
-        user_query: 'collection:foo',
-        sort: [],
-      },
-      finalizedParameters: {
-        user_query: 'collection:foo',
-        sort: [],
-      },
-    },
-    rawResponse: {},
-    response: {
-      totalResults: 1,
-      returnedCount: 1,
-      results: [
-        new ItemHit({
-          fields: {
-            identifier: 'foo',
-            collection: ['foo', 'bar'],
-          },
-        }),
-      ],
-    },
-    responseHeader: {
-      succeeded: true,
-      query_time: 0,
-    },
-  },
-};
-
-export const mockSuccessLoggedInResult: Result<
-  SearchResponse,
-  SearchServiceError
-> = {
-  success: {
-    request: {
-      clientParameters: {
-        user_query: 'loggedin',
-        sort: [],
-      },
-      finalizedParameters: {
-        user_query: 'loggedin',
-        sort: [],
-      },
-    },
-    rawResponse: {},
-    response: {
-      totalResults: 1,
-      returnedCount: 1,
-      results: [
-        new ItemHit({
-          fields: {
-            identifier: 'foo',
-            collection: ['foo', 'loggedin', 'bar'],
-            title: 'foo',
-            mediatype: 'data',
-          },
-        }),
-      ],
-    },
-    responseHeader: {
-      succeeded: true,
-      query_time: 0,
-    },
-  },
-};
-
-export const mockSuccessNoPreviewResult: Result<
-  SearchResponse,
-  SearchServiceError
-> = {
-  success: {
-    request: {
-      clientParameters: {
-        user_query: 'no-preview',
-        sort: [],
-      },
-      finalizedParameters: {
-        user_query: 'no-preview',
-        sort: [],
-      },
-    },
-    rawResponse: {},
-    response: {
-      totalResults: 1,
-      returnedCount: 1,
-      results: [
-        new ItemHit({
-          fields: {
-            identifier: 'foo',
-            collection: ['foo', 'no-preview', 'bar'],
-          },
-        }),
-      ],
-    },
-    responseHeader: {
-      succeeded: true,
-      query_time: 0,
-    },
-  },
-};
-
-export const mockSuccessLoggedInAndNoPreviewResult: Result<
-  SearchResponse,
-  SearchServiceError
-> = {
-  success: {
-    request: {
-      clientParameters: {
-        user_query: 'loggedin-no-preview',
-        sort: [],
-      },
-      finalizedParameters: {
-        user_query: 'loggedin-no-preview',
-        sort: [],
-      },
-    },
-    rawResponse: {},
-    response: {
-      totalResults: 1,
-      returnedCount: 1,
-      results: [
-        new ItemHit({
-          fields: {
-            identifier: 'foo',
-            collection: ['foo', 'loggedin', 'no-preview', 'bar'],
-          },
-        }),
-      ],
-    },
-    responseHeader: {
-      succeeded: true,
-      query_time: 0,
-    },
-  },
-};
-
-export const getMockSuccessSingleResultWithSort: (
-  resultsSpy: Function
-) => Result<SearchResponse, SearchServiceError> = (resultsSpy: Function) => ({
-  success: {
-    request: {
-      clientParameters: {
-        user_query: 'with-sort',
-        sort: ['foo:asc'],
-      },
-      finalizedParameters: {
-        user_query: 'with-sort',
-        sort: ['foo:asc'],
-      },
-    },
-    rawResponse: {},
-    response: {
-      totalResults: 1,
-      returnedCount: 1,
-      get results() {
-        resultsSpy();
-        return [
-          new ItemHit({
-            fields: {
-              identifier: 'foo',
-              collection: ['foo', 'bar'],
-            },
-          }),
-        ];
-      },
-    },
-    responseHeader: {
-      succeeded: true,
-      query_time: 0,
-    },
-  },
-});
-
-export const mockSuccessMultipleResults: Result<
-  SearchResponse,
-  SearchServiceError
-> = {
-  success: {
-    request: {
-      clientParameters: {
-        user_query: 'collection:foo',
-        sort: [],
-      },
-      finalizedParameters: {
-        user_query: 'collection:foo',
-        sort: [],
-      },
-    },
-    rawResponse: {},
-    response: {
-      totalResults: 2,
-      returnedCount: 2,
-      results: [
-        new ItemHit({
-          fields: {
-            identifier: 'foo',
-            collection: ['foo', 'bar'],
-          },
-        }),
-        new ItemHit({
-          fields: {
-            identifier: 'bar',
-            collection: ['baz', 'boop'],
-          },
-        }),
-      ],
-    },
-    responseHeader: {
-      succeeded: true,
-      query_time: 0,
-    },
-  },
-};
+import type { Result } from '@internetarchive/result-type';
+import {
+  ItemHit,
+  SearchResponse,
+  SearchServiceError,
+} from '@internetarchive/search-service';
+
+export const mockSuccessSingleResult: Result<
+  SearchResponse,
+  SearchServiceError
+> = {
+  success: {
+    request: {
+      clientParameters: {
+        user_query: 'collection:foo',
+        sort: [],
+      },
+      finalizedParameters: {
+        user_query: 'collection:foo',
+        sort: [],
+      },
+    },
+    rawResponse: {},
+    response: {
+      totalResults: 1,
+      returnedCount: 1,
+      results: [
+        new ItemHit({
+          fields: {
+            identifier: 'foo',
+            collection: ['foo', 'bar'],
+          },
+        }),
+      ],
+    },
+    responseHeader: {
+      succeeded: true,
+      query_time: 0,
+    },
+  },
+};
+
+export const mockSuccessLoggedInResult: Result<
+  SearchResponse,
+  SearchServiceError
+> = {
+  success: {
+    request: {
+      clientParameters: {
+        user_query: 'loggedin',
+        sort: [],
+      },
+      finalizedParameters: {
+        user_query: 'loggedin',
+        sort: [],
+      },
+    },
+    rawResponse: {},
+    response: {
+      totalResults: 1,
+      returnedCount: 1,
+      results: [
+        new ItemHit({
+          fields: {
+            identifier: 'foo',
+            collection: ['foo', 'loggedin', 'bar'],
+            title: 'foo',
+            mediatype: 'data',
+          },
+        }),
+      ],
+    },
+    responseHeader: {
+      succeeded: true,
+      query_time: 0,
+    },
+  },
+};
+
+export const mockSuccessNoPreviewResult: Result<
+  SearchResponse,
+  SearchServiceError
+> = {
+  success: {
+    request: {
+      clientParameters: {
+        user_query: 'no-preview',
+        sort: [],
+      },
+      finalizedParameters: {
+        user_query: 'no-preview',
+        sort: [],
+      },
+    },
+    rawResponse: {},
+    response: {
+      totalResults: 1,
+      returnedCount: 1,
+      results: [
+        new ItemHit({
+          fields: {
+            identifier: 'foo',
+            collection: ['foo', 'no-preview', 'bar'],
+          },
+        }),
+      ],
+    },
+    responseHeader: {
+      succeeded: true,
+      query_time: 0,
+    },
+  },
+};
+
+export const mockSuccessLoggedInAndNoPreviewResult: Result<
+  SearchResponse,
+  SearchServiceError
+> = {
+  success: {
+    request: {
+      clientParameters: {
+        user_query: 'loggedin-no-preview',
+        sort: [],
+      },
+      finalizedParameters: {
+        user_query: 'loggedin-no-preview',
+        sort: [],
+      },
+    },
+    rawResponse: {},
+    response: {
+      totalResults: 1,
+      returnedCount: 1,
+      results: [
+        new ItemHit({
+          fields: {
+            identifier: 'foo',
+            collection: ['foo', 'loggedin', 'no-preview', 'bar'],
+          },
+        }),
+      ],
+    },
+    responseHeader: {
+      succeeded: true,
+      query_time: 0,
+    },
+  },
+};
+
+export const getMockSuccessSingleResultWithSort: (
+  resultsSpy: Function
+) => Result<SearchResponse, SearchServiceError> = (resultsSpy: Function) => ({
+  success: {
+    request: {
+      clientParameters: {
+        user_query: 'with-sort',
+        sort: ['foo:asc'],
+      },
+      finalizedParameters: {
+        user_query: 'with-sort',
+        sort: ['foo:asc'],
+      },
+    },
+    rawResponse: {},
+    response: {
+      totalResults: 1,
+      returnedCount: 1,
+      get results() {
+        resultsSpy();
+        return [
+          new ItemHit({
+            fields: {
+              identifier: 'foo',
+              collection: ['foo', 'bar'],
+            },
+          }),
+        ];
+      },
+    },
+    responseHeader: {
+      succeeded: true,
+      query_time: 0,
+    },
+  },
+});
+
+export const mockSuccessMultipleResults: Result<
+  SearchResponse,
+  SearchServiceError
+> = {
+  success: {
+    request: {
+      clientParameters: {
+        user_query: 'collection:foo',
+        sort: [],
+      },
+      finalizedParameters: {
+        user_query: 'collection:foo',
+        sort: [],
+      },
+    },
+    rawResponse: {},
+    response: {
+      totalResults: 2,
+      returnedCount: 2,
+      results: [
+        new ItemHit({
+          fields: {
+            identifier: 'foo',
+            collection: ['foo', 'bar'],
+          },
+        }),
+        new ItemHit({
+          fields: {
+            identifier: 'bar',
+            collection: ['baz', 'boop'],
+          },
+        }),
+      ],
+    },
+    responseHeader: {
+      succeeded: true,
+      query_time: 0,
+    },
+  },
+};

package/test/mocks/mock-search-service.ts

@@ -1,61 +1,61 @@
-import type { Result } from '@internetarchive/result-type';
-import type {
-  SearchParams,
-  SearchResponse,
-  SearchServiceInterface,
-  SearchServiceError,
-  SearchType,
-} from '@internetarchive/search-service';
-import {
-  mockSuccessSingleResult,
-  mockSuccessMultipleResults,
-  getMockSuccessSingleResultWithSort,
-  mockSuccessLoggedInResult,
-  mockSuccessNoPreviewResult,
-  mockSuccessLoggedInAndNoPreviewResult,
-} from './mock-search-responses';
-
-export class MockSearchService implements SearchServiceInterface {
-  searchParams?: SearchParams;
-
-  searchType?: SearchType;
-
-  asyncResponse: boolean;
-
-  resultsSpy: Function;
-
-  constructor({ asyncResponse = false, resultsSpy = () => {} } = {}) {
-    this.asyncResponse = asyncResponse;
-    this.resultsSpy = resultsSpy;
-  }
-
-  async search(
-    params: SearchParams,
-    searchType: SearchType
-  ): Promise<Result<SearchResponse, SearchServiceError>> {
-    this.searchParams = params;
-    this.searchType = searchType;
-
-    if (this.asyncResponse) {
-      // Add an artificial 1-tick delay
-      await new Promise(res => {
-        setTimeout(res, 0);
-      });
-    }
-
-    switch (this.searchParams?.query) {
-      case 'single-result':
-        return mockSuccessSingleResult;
-      case 'loggedin':
-        return mockSuccessLoggedInResult;
-      case 'no-preview':
-        return mockSuccessNoPreviewResult;
-      case 'loggedin-no-preview':
-        return mockSuccessLoggedInAndNoPreviewResult;
-      case 'with-sort':
-        return getMockSuccessSingleResultWithSort(this.resultsSpy);
-      default:
-        return mockSuccessMultipleResults;
-    }
-  }
-}
+import type { Result } from '@internetarchive/result-type';
+import type {
+  SearchParams,
+  SearchResponse,
+  SearchServiceInterface,
+  SearchServiceError,
+  SearchType,
+} from '@internetarchive/search-service';
+import {
+  mockSuccessSingleResult,
+  mockSuccessMultipleResults,
+  getMockSuccessSingleResultWithSort,
+  mockSuccessLoggedInResult,
+  mockSuccessNoPreviewResult,
+  mockSuccessLoggedInAndNoPreviewResult,
+} from './mock-search-responses';
+
+export class MockSearchService implements SearchServiceInterface {
+  searchParams?: SearchParams;
+
+  searchType?: SearchType;
+
+  asyncResponse: boolean;
+
+  resultsSpy: Function;
+
+  constructor({ asyncResponse = false, resultsSpy = () => {} } = {}) {
+    this.asyncResponse = asyncResponse;
+    this.resultsSpy = resultsSpy;
+  }
+
+  async search(
+    params: SearchParams,
+    searchType: SearchType
+  ): Promise<Result<SearchResponse, SearchServiceError>> {
+    this.searchParams = params;
+    this.searchType = searchType;
+
+    if (this.asyncResponse) {
+      // Add an artificial 1-tick delay
+      await new Promise(res => {
+        setTimeout(res, 0);
+      });
+    }
+
+    switch (this.searchParams?.query) {
+      case 'single-result':
+        return mockSuccessSingleResult;
+      case 'loggedin':
+        return mockSuccessLoggedInResult;
+      case 'no-preview':
+        return mockSuccessNoPreviewResult;
+      case 'loggedin-no-preview':
+        return mockSuccessLoggedInAndNoPreviewResult;
+      case 'with-sort':
+        return getMockSuccessSingleResultWithSort(this.resultsSpy);
+      default:
+        return mockSuccessMultipleResults;
+    }
+  }
+}

package/test/restoration-state-handler.test.ts

@@ -1,3 +1,4 @@
+import { SearchType } from '@internetarchive/search-service';
 import { expect } from '@open-wc/testing';
 import { RestorationStateHandler } from '../src/restoration-state-handler';
 
@@ -13,6 +14,17 @@ describe('Restoration state handler', () => {
     expect(restorationState.baseQuery).to.equal('boop');
   });
 
+  it('should restore full text search type from URL', async () => {
+    const handler = new RestorationStateHandler({ context: 'search' });
+
+    const url = new URL(window.location.href);
+    url.search = '?sin=TXT';
+    window.history.replaceState({ path: url.href }, '', url.href);
+
+    const restorationState = handler.getRestorationState();
+    expect(restorationState.searchType).to.equal(SearchType.FULLTEXT);
+  });
+
   it('should restore page number from URL', async () => {
     const handler = new RestorationStateHandler({ context: 'search' });