@coveo/quantic 3.16.0 → 3.16.1-pre.9c01cf606f

package/force-app/main/default/lwc/quanticFacetManager/__tests__/quanticFacetManager.test.js

@@ -1,178 +0,0 @@
-/* eslint-disable no-import-assign */
-import QuanticFacetManager from '../quanticFacetManager';
-// @ts-ignore
-import {createElement} from 'lwc';
-import * as mockHeadlessLoader from 'c/quanticHeadlessLoader';
-
-jest.mock('c/quanticHeadlessLoader');
-
-let isInitialized = false;
-
-const exampleEngine = {
-  id: 'exampleEngineId',
-};
-
-const defaultSearchStatusState = {
-  hasResults: true,
-  firstSearchExecuted: true,
-};
-
-let searchStatusState = defaultSearchStatusState;
-
-const defaultOptions = {
-  engineId: exampleEngine.id,
-};
-
-const selectors = {
-  initializationError: 'c-quantic-component-error',
-  facetManagerHost: '.facet-manager__host',
-};
-
-const functionsMocks = {
-  buildFacetManager: jest.fn(() => ({
-    state: {},
-    subscribe: functionsMocks.facetManagerStateSubscriber,
-  })),
-  buildSearchStatus: jest.fn(() => ({
-    state: searchStatusState,
-    subscribe: functionsMocks.searchStatusStateSubscriber,
-  })),
-  facetManagerStateSubscriber: jest.fn((cb) => {
-    cb();
-    return functionsMocks.facetManagerStateUnsubscriber;
-  }),
-  searchStatusStateSubscriber: jest.fn((cb) => {
-    cb();
-    return functionsMocks.searchStatusStateUnsubscriber;
-  }),
-  facetManagerStateUnsubscriber: jest.fn(),
-  searchStatusStateUnsubscriber: jest.fn(),
-};
-
-function createTestComponent(options = defaultOptions) {
-  const element = createElement('c-quantic-facet-manager', {
-    is: QuanticFacetManager,
-  });
-  for (const [key, value] of Object.entries(options)) {
-    element[key] = value;
-  }
-  document.body.appendChild(element);
-  return element;
-}
-
-// Helper function to wait until the microtask queue is empty.
-function flushPromises() {
-  return new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-function prepareHeadlessState() {
-  // @ts-ignore
-  mockHeadlessLoader.getHeadlessBundle = () => {
-    return {
-      buildFacetManager: functionsMocks.buildFacetManager,
-      buildSearchStatus: functionsMocks.buildSearchStatus,
-    };
-  };
-}
-
-function mockSuccessfulHeadlessInitialization() {
-  // @ts-ignore
-  mockHeadlessLoader.initializeWithHeadless = (element, _, initialize) => {
-    if (element instanceof QuanticFacetManager && !isInitialized) {
-      isInitialized = true;
-      initialize(exampleEngine);
-    }
-  };
-}
-
-function mockErroneousHeadlessInitialization() {
-  // @ts-ignore
-  mockHeadlessLoader.initializeWithHeadless = (element) => {
-    if (element instanceof QuanticFacetManager) {
-      element.setInitializationError();
-    }
-  };
-}
-
-function cleanup() {
-  // The jsdom instance is shared across test cases in a single file so reset the DOM
-  while (document.body.firstChild) {
-    document.body.removeChild(document.body.firstChild);
-  }
-  jest.clearAllMocks();
-  isInitialized = false;
-}
-
-describe('c-quantic-facet-manager', () => {
-  afterEach(() => {
-    cleanup();
-  });
-
-  describe('controller initialization', () => {
-    beforeEach(() => {
-      mockSuccessfulHeadlessInitialization();
-      prepareHeadlessState();
-    });
-
-    it('should build the facet manager controller with the proper parameters and subscribe to its state', async () => {
-      createTestComponent();
-      await flushPromises();
-
-      expect(functionsMocks.buildFacetManager).toHaveBeenCalledTimes(1);
-      expect(functionsMocks.buildFacetManager).toHaveBeenCalledWith(
-        exampleEngine
-      );
-      expect(functionsMocks.facetManagerStateSubscriber).toHaveBeenCalledTimes(
-        1
-      );
-    });
-
-    it('should build the search status controller with the proper parameters and subscribe to its state', async () => {
-      createTestComponent();
-      await flushPromises();
-
-      expect(functionsMocks.buildSearchStatus).toHaveBeenCalledTimes(1);
-      expect(functionsMocks.buildSearchStatus).toHaveBeenCalledWith(
-        exampleEngine
-      );
-      expect(functionsMocks.searchStatusStateSubscriber).toHaveBeenCalledTimes(
-        1
-      );
-    });
-  });
-
-  describe('when an initialization error occurs', () => {
-    beforeEach(() => {
-      mockErroneousHeadlessInitialization();
-    });
-
-    it('should display the initialization error component', async () => {
-      const element = createTestComponent();
-      await flushPromises();
-
-      const initializationError = element.shadowRoot.querySelector(
-        selectors.initializationError
-      );
-
-      expect(initializationError).not.toBeNull();
-    });
-  });
-
-  describe('when the component is initialized', () => {
-    beforeEach(() => {
-      mockSuccessfulHeadlessInitialization();
-      prepareHeadlessState();
-    });
-
-    it('should properly render the facet manager component', async () => {
-      const element = createTestComponent();
-      await flushPromises();
-
-      const facetManager = element.shadowRoot.querySelector(
-        selectors.facetManagerHost
-      );
-
-      expect(facetManager).not.toBeNull();
-    });
-  });
-});

package/force-app/main/default/lwc/quanticFacetManager/e2e/fixture.ts

@@ -1,63 +0,0 @@
-import {FacetManagerObject} from './pageObject';
-import {quanticBase} from '../../../../../../playwright/fixtures/baseFixture';
-import {
-  searchRequestRegex,
-  insightSearchRequestRegex,
-} from '../../../../../../playwright/utils/requests';
-import {InsightSetupObject} from '../../../../../../playwright/page-object/insightSetupObject';
-import {useCaseEnum} from '../../../../../../playwright/utils/useCase';
-import {SearchObject} from '../../../../../../playwright/page-object/searchObject';
-
-const pageUrl = 's/quantic-facet-manager';
-
-interface FacetManagerOptions {}
-
-type QuanticFacetManagerE2ESearchFixtures = {
-  facetManager: FacetManagerObject;
-  search: SearchObject;
-  options: Partial<FacetManagerOptions>;
-};
-
-type QuanticFacetManagerE2EInsightFixtures =
-  QuanticFacetManagerE2ESearchFixtures & {
-    insightSetup: InsightSetupObject;
-  };
-
-export const testSearch =
-  quanticBase.extend<QuanticFacetManagerE2ESearchFixtures>({
-    options: {},
-    search: async ({page}, use) => {
-      await use(new SearchObject(page, searchRequestRegex));
-    },
-    facetManager: async ({page, options, configuration, search}, use) => {
-      await page.goto(pageUrl);
-      configuration.configure(options);
-      await search.waitForSearchResponse();
-
-      await use(new FacetManagerObject(page));
-    },
-  });
-
-export const testInsight =
-  quanticBase.extend<QuanticFacetManagerE2EInsightFixtures>({
-    options: {},
-    search: async ({page}, use) => {
-      await use(new SearchObject(page, insightSearchRequestRegex));
-    },
-    insightSetup: async ({page}, use) => {
-      await use(new InsightSetupObject(page));
-    },
-    facetManager: async (
-      {page, options, search, configuration, insightSetup},
-      use
-    ) => {
-      await page.goto(pageUrl);
-      configuration.configure({...options, useCase: useCaseEnum.insight});
-      await insightSetup.waitForInsightInterfaceInitialization();
-      await search.performSearch();
-      await search.waitForSearchResponse();
-      await use(new FacetManagerObject(page));
-    },
-  });
-
-export {expect} from '@playwright/test';

package/force-app/main/default/lwc/quanticFacetManager/e2e/pageObject.ts

@@ -1,23 +0,0 @@
-import type {Locator, Page} from '@playwright/test';
-
-export class FacetManagerObject {
-  constructor(public page: Page) {
-    this.page = page;
-  }
-
-  get facetManager(): Locator {
-    return this.page.locator('c-quantic-facet-manager');
-  }
-
-  get facetManagerItems(): Locator {
-    return this.facetManager.getByTestId('facet-manager__item');
-  }
-
-  get itemTemplateSlot(): Locator {
-    return this.facetManager.locator('slot[name="itemTemplate"]');
-  }
-
-  getFacetManagerItemByIndex(index: number): Locator {
-    return this.facetManagerItems.nth(index);
-  }
-}

package/force-app/main/default/lwc/quanticFacetManager/e2e/quanticFacetManager.e2e.ts

@@ -1,82 +0,0 @@
-import {testSearch, testInsight, expect} from './fixture';
-import {useCaseTestCases} from '../../../../../../playwright/utils/useCase';
-
-const fixtures = {
-  search: testSearch,
-  insight: testInsight,
-};
-
-const exampleFacetsOrder = ['objecttype', 'date', 'language'];
-
-/**
- * Filters out any facetId which contains a filter input "_input" because they are not displayed in the facet manager.
- */
-function filterInputFacets(facets: any): string[] {
-  return facets
-    .map((facet: any) => facet.facetId)
-    .filter((id: string) => !/_input$/.test(id));
-}
-
-useCaseTestCases.forEach((useCase) => {
-  let test = fixtures[useCase.value];
-
-  test.describe(`quantic facet manager ${useCase.label}`, () => {
-    test('should load facets in the same order as in the initial search response', async ({
-      facetManager,
-      search,
-    }) => {
-      const searchResponsePromise = search.waitForSearchResponse();
-      await search.performSearch();
-
-      const searchResponse = await searchResponsePromise;
-      const {facets} = await searchResponse.json();
-      expect(facets).not.toBeNull();
-
-      const filteredIds = filterInputFacets(facets);
-
-      filteredIds.forEach(async (facetId: any, index: number) => {
-        const facetManagerItem = facetManager.getFacetManagerItemByIndex(index);
-        expect(await facetManagerItem.getAttribute('data-facet-id')).toEqual(
-          facetId
-        );
-      });
-    });
-
-    test.describe('when the facets are reordered', () => {
-      test('should load facets in the reordered order', async ({
-        facetManager,
-        search,
-      }) => {
-        await search.mockSearchFacetOrder(exampleFacetsOrder);
-        const searchResponsePromise = search.waitForSearchResponse();
-        await search.performSearch();
-
-        const searchResponse = await searchResponsePromise;
-        const {facets} = await searchResponse.json();
-        expect(facets).not.toBeNull();
-
-        exampleFacetsOrder.forEach(async (facetId: string, index: number) => {
-          const facetManagerItem =
-            facetManager.getFacetManagerItemByIndex(index);
-          expect(await facetManagerItem.getAttribute('data-facet-id')).toEqual(
-            facetId
-          );
-        });
-      });
-    });
-
-    test.describe('when an itemTemplate slot is provided', () => {
-      test('should customize the element that wraps each facet according to the itemTemplate slot', async ({
-        facetManager,
-      }) => {
-        const expectedClass = 'slds-m-around_xx-large';
-        expect(facetManager.itemTemplateSlot).not.toBeNull();
-
-        const facetManagerItems = await facetManager.facetManagerItems.all();
-        facetManagerItems.forEach(async (item: any) => {
-          expect(await item.getAttribute('class')).toContain(expectedClass);
-        });
-      });
-    });
-  });
-});