@coveo/quantic 3.44.1 → 3.44.2

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

@@ -1,404 +0,0 @@
-jest.mock('c/quanticHeadlessLoader');
-
-import QuanticDocumentSuggestion from 'c/quanticDocumentSuggestion';
-import {buildCreateTestComponent, cleanup, flushPromises} from 'c/testUtils';
-import * as quanticHeadlessLoader from 'c/quanticHeadlessLoader';
-const headlessLoaderMock = jest.mocked(quanticHeadlessLoader);
-
-const engineMock = {
-  id: 'exampleEngineIdMock',
-  dispatch: jest.fn(),
-};
-headlessLoaderMock.initializeWithHeadless.mockImplementation(
-  async (element, _, initialize) => {
-    initialize(engineMock);
-  }
-);
-headlessLoaderMock.getHeadlessEnginePromise.mockImplementation(() =>
-  Promise.resolve(engineMock.id)
-);
-
-let updateSuggestions;
-const documentSuggestionListMock = {
-  subscribe: jest.fn((callback) => {
-    updateSuggestions = async () => {
-      callback();
-      await flushPromises();
-    };
-    return () => {}; // Fake unsubscribe function
-  }),
-};
-
-const functionsMocks = {
-  fetchDocumentSuggestions: jest.fn(),
-  logDocumentSuggestionClick: jest.fn(),
-  logDocumentSuggestionRating: jest.fn(),
-};
-
-const headlessCaseAssistMock = {
-  buildDocumentSuggestionList: jest
-    .fn()
-    .mockReturnValue(documentSuggestionListMock),
-  buildQuickview: jest.fn().mockReturnValue(documentSuggestionListMock),
-  loadCaseAssistAnalyticsActions: jest.fn().mockReturnValue({
-    logDocumentSuggestionClick: functionsMocks.logDocumentSuggestionClick,
-    logDocumentSuggestionRating: functionsMocks.logDocumentSuggestionRating,
-  }),
-  loadDocumentSuggestionActions: jest.fn().mockReturnValue({
-    fetchDocumentSuggestions: functionsMocks.fetchDocumentSuggestions,
-  }),
-};
-
-// @ts-ignore
-global.CoveoHeadlessCaseAssist = headlessCaseAssistMock;
-headlessLoaderMock.getHeadlessBundle.mockReturnValue(headlessCaseAssistMock);
-
-const createTestComponent = buildCreateTestComponent(
-  QuanticDocumentSuggestion,
-  'c-quantic-document-suggestion',
-  {
-    engineId: engineMock.id,
-  }
-);
-
-const selectors = {
-  container: '.slds-card',
-  accordion: 'lightning-accordion',
-  accordionSection: 'lightning-accordion-section',
-  noSuggestions: 'slot[name="no-suggestions"]',
-  spinner: '.loading-holder lightning-spinner',
-  quickview: 'c-quantic-result-quickview',
-  componentError: 'c-quantic-component-error',
-};
-
-function mockErroneousHeadlessInitialization() {
-  headlessLoaderMock.initializeWithHeadless.mockImplementation(
-    async (element) => {
-      if (element instanceof QuanticDocumentSuggestion) {
-        element.setInitializationError();
-      }
-    }
-  );
-}
-
-describe('c-quantic-document-suggestion', () => {
-  beforeEach(() => {
-    documentSuggestionListMock.state = {
-      documents: [],
-      loading: false,
-    };
-  });
-
-  afterEach(() => {
-    cleanup();
-  });
-
-  describe('on initialization', () => {
-    it('should initialize the component and subscribe to the controller', async () => {
-      createTestComponent();
-
-      expect(headlessLoaderMock.registerComponentForInit).toHaveBeenCalled();
-      expect(headlessLoaderMock.initializeWithHeadless).toHaveBeenCalled();
-      expect(
-        headlessCaseAssistMock.buildDocumentSuggestionList
-      ).toHaveBeenCalledTimes(1);
-      expect(
-        headlessCaseAssistMock.buildDocumentSuggestionList
-      ).toHaveBeenCalledWith(engineMock);
-      expect(
-        headlessCaseAssistMock.loadCaseAssistAnalyticsActions
-      ).toHaveBeenCalledTimes(1);
-      expect(
-        headlessCaseAssistMock.loadDocumentSuggestionActions
-      ).toHaveBeenCalledTimes(1);
-      expect(engineMock.dispatch).not.toHaveBeenCalled();
-      expect(documentSuggestionListMock.subscribe).toHaveBeenCalledTimes(1);
-      expect(updateSuggestions).toBeDefined();
-    });
-  });
-
-  describe('when loading suggestions', () => {
-    it('should render the loading holder only', async () => {
-      const element = createTestComponent();
-      documentSuggestionListMock.state.loading = true;
-      updateSuggestions();
-      await flushPromises();
-
-      const spinner = element.shadowRoot.querySelector(selectors.spinner);
-      const container = element.shadowRoot.querySelector(selectors.container);
-      const noSuggestions = element.shadowRoot.querySelector(
-        selectors.noSuggestions
-      );
-      expect(spinner).toBeTruthy();
-      expect(container).toBeFalsy();
-      expect(noSuggestions).toBeFalsy();
-    });
-  });
-
-  describe('when there are no suggestions', () => {
-    it('should render the no-suggestions message', async () => {
-      const element = createTestComponent();
-      await updateSuggestions();
-
-      const accordion = element.shadowRoot.querySelector(selectors.accordion);
-      const noSuggestions = element.shadowRoot.querySelector(
-        selectors.noSuggestions
-      );
-      expect(accordion).toBeFalsy();
-      expect(noSuggestions).toBeTruthy();
-    });
-  });
-
-  describe('when fetchOnInit property is set to true', () => {
-    it('should fetch document suggestion on initialization', async () => {
-      createTestComponent({
-        fetchOnInit: true,
-      });
-      await flushPromises();
-
-      expect(functionsMocks.fetchDocumentSuggestions).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('with suggestions', () => {
-    beforeEach(() => {
-      documentSuggestionListMock.state.documents = [
-        {
-          uniqueId: 'ego',
-          fields: {
-            uri: 'weed eater',
-          },
-        },
-        {
-          uniqueId: 'stihl',
-          fields: {
-            uri: 'chainsaw',
-          },
-        },
-      ];
-    });
-
-    it('should render the component and all parts with default options', async () => {
-      const element = createTestComponent();
-      await flushPromises();
-      expect(functionsMocks.fetchDocumentSuggestions).not.toHaveBeenCalled();
-      expect(headlessLoaderMock.registerComponentForInit).toHaveBeenCalled();
-
-      const accordion = element.shadowRoot.querySelector(selectors.accordion);
-      const noSuggestions = element.shadowRoot.querySelector(
-        selectors.noSuggestions
-      );
-      const componentError = element.shadowRoot.querySelector(
-        selectors.componentError
-      );
-
-      expect(accordion).toBeFalsy();
-      expect(noSuggestions).toBeTruthy();
-      expect(componentError).toBeFalsy();
-
-      await updateSuggestions();
-
-      const updatedNoSuggestions = element.shadowRoot.querySelector(
-        selectors.noSuggestions
-      );
-      const container = element.shadowRoot.querySelector(selectors.container);
-      const updatedAccordion = element.shadowRoot.querySelector(
-        selectors.accordion
-      );
-
-      expect(updatedNoSuggestions).toBeFalsy();
-      expect(container).toBeTruthy();
-      expect(updatedAccordion).toBeTruthy();
-
-      const sections = element.shadowRoot.querySelectorAll(
-        selectors.accordionSection
-      );
-      expect(sections.length).toBe(
-        documentSuggestionListMock.state.documents.length
-      );
-
-      sections.forEach((section, index) => {
-        const {uniqueId, title} =
-          documentSuggestionListMock.state.documents[index];
-        expect(section.label).toBe(title);
-        expect(section.getAttribute('data-id')).toBe(uniqueId);
-        expect(section.querySelector(selectors.quickview)).toBeTruthy();
-        expect(
-          section
-            .querySelector('slot[name="actions"]')
-            .getAttribute('data-doc-id')
-        ).toBe(uniqueId);
-        expect(
-          section
-            .querySelector('slot[name="rating"]')
-            .getAttribute('data-doc-id')
-        ).toBe(uniqueId);
-      });
-    });
-
-    it('should not render quickview button when withoutQuickview is set to true', async () => {
-      const element = createTestComponent({
-        withoutQuickview: true,
-      });
-      await updateSuggestions();
-
-      expect(element.shadowRoot.querySelector(selectors.quickview)).toBeFalsy();
-    });
-
-    it('should log a suggestion click if the suggestion is not opened', async () => {
-      const element = createTestComponent();
-      await updateSuggestions();
-
-      const sections = element.shadowRoot.querySelectorAll(
-        selectors.accordionSection
-      );
-      const accordion = element.shadowRoot.querySelector(selectors.accordion);
-
-      // First document is already opened and will be collapsed, no click event logged.
-      sections[0].click();
-      expect(functionsMocks.logDocumentSuggestionClick).toHaveBeenCalledTimes(
-        0
-      );
-      accordion.activeSectionName = sections[1].name;
-
-      sections[1].click();
-      await flushPromises();
-      expect(functionsMocks.logDocumentSuggestionClick).toHaveBeenCalledTimes(
-        1
-      );
-      expect(functionsMocks.logDocumentSuggestionClick).toHaveBeenCalledWith(
-        documentSuggestionListMock.state.documents[1].uniqueId
-      );
-    });
-
-    it('should log analytics when rating a document', async () => {
-      const element = createTestComponent();
-      await updateSuggestions();
-
-      const customEvent = new CustomEvent('quantic__rating', {
-        detail: {id: 'mastercraft', score: 2},
-      });
-      element.shadowRoot.dispatchEvent(customEvent);
-      expect(functionsMocks.logDocumentSuggestionRating).toHaveBeenCalledTimes(
-        1
-      );
-      expect(functionsMocks.logDocumentSuggestionRating).toHaveBeenCalledWith(
-        'mastercraft',
-        2
-      );
-    });
-
-    it('should truncate documents to maxDocuments if the state contains more', async () => {
-      const element = createTestComponent({
-        maxDocuments: 1,
-      });
-      await updateSuggestions();
-
-      const sections = element.shadowRoot.querySelectorAll(
-        selectors.accordionSection
-      );
-      expect(sections.length).toBe(1);
-    });
-
-    it('should open the documents depending on numberOfAutoOpenedDocuments', async () => {
-      const element = createTestComponent({
-        fetchOnInit: true,
-        numberOfAutoOpenedDocuments: 2,
-      });
-      await updateSuggestions();
-
-      const accordion = element.shadowRoot.querySelector(selectors.accordion);
-      const sections = element.shadowRoot.querySelectorAll(
-        selectors.accordionSection
-      );
-      expect(sections.length).toBe(2);
-      expect(accordion.activeSectionName).toEqual([
-        sections[0].name,
-        sections[1].name,
-      ]);
-    });
-  });
-
-  describe('when two document suggestions have a similar title', () => {
-    it('should open the right document suggestion when clicked', async () => {
-      documentSuggestionListMock.state.documents = [
-        {
-          title: 'dewalt',
-          uniqueId: 'dw745',
-          fields: {
-            uri: 'table saw',
-          },
-        },
-        {
-          title: 'dewalt',
-          uniqueId: 'dw560',
-          fields: {
-            uri: 'router',
-          },
-        },
-      ];
-
-      const element = createTestComponent({
-        numberOfAutoOpenedDocuments: 0,
-      });
-      await updateSuggestions();
-
-      const sectionToClick = element.shadowRoot.querySelectorAll(
-        selectors.accordionSection
-      )[1];
-      const accordion = element.shadowRoot.querySelector(selectors.accordion);
-      accordion.activeSectionName = sectionToClick.name;
-      sectionToClick.click();
-      expect(sectionToClick.name).toBe(
-        documentSuggestionListMock.state.documents[1].uniqueId
-      );
-      expect(functionsMocks.logDocumentSuggestionClick).toHaveBeenCalledTimes(
-        1
-      );
-      expect(functionsMocks.logDocumentSuggestionClick).toHaveBeenCalledWith(
-        sectionToClick.name
-      );
-    });
-  });
-
-  describe('with invalid options', () => {
-    it('should set an error message if maxDocuments is invalid', async () => {
-      const element = createTestComponent({
-        maxDocuments: 0,
-      });
-      await flushPromises();
-
-      const componentError = element.shadowRoot.querySelector(
-        selectors.componentError
-      );
-      expect(componentError).toBeTruthy();
-    });
-    it('should set an error message if numberOfAutoOpenedDocuments is invalid', async () => {
-      const element = createTestComponent({
-        numberOfAutoOpenedDocuments: -1,
-      });
-      await flushPromises();
-
-      const componentError = element.shadowRoot.querySelector(
-        selectors.componentError
-      );
-      expect(componentError).toBeTruthy();
-    });
-  });
-
-  describe('when an initialization error occurs', () => {
-    beforeEach(() => {
-      mockErroneousHeadlessInitialization();
-    });
-
-    it('should display the initialization error component', async () => {
-      const element = createTestComponent();
-      await flushPromises();
-
-      const componentError = element.shadowRoot.querySelector(
-        selectors.componentError
-      );
-      expect(componentError).toBeTruthy();
-    });
-  });
-});

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

@@ -1,38 +0,0 @@
-import {DocumentSuggestionObject} from './pageObject';
-import {quanticBase} from '../../../../../../playwright/fixtures/baseFixture';
-import {SearchObject} from '../../../../../../playwright/page-object/searchObject';
-import {CaseAssistObject} from '../../../../../../playwright/page-object/caseAssistObject';
-
-const pageUrl = 's/quantic-document-suggestion';
-
-interface DocumentSuggestionOptions {
-  engineId: string;
-  searchEngineId: string;
-  maxDocuments: number;
-  fetchOnInit: boolean;
-  withoutQuickview: boolean;
-  numberOfAutoOpenedDocuments: number;
-}
-
-type QuanticDocumentSuggestionE2EFixtures = {
-  documentSuggestion: DocumentSuggestionObject;
-  search: SearchObject;
-  caseAssist: CaseAssistObject;
-  options: Partial<DocumentSuggestionOptions>;
-  urlHash: string;
-};
-
-export const test = quanticBase.extend<QuanticDocumentSuggestionE2EFixtures>({
-  options: {},
-  urlHash: '',
-  caseAssist: async ({page}, use) => {
-    await use(new CaseAssistObject(page));
-  },
-  documentSuggestion: async ({page, options, configuration}, use) => {
-    await page.goto(pageUrl);
-    await configuration.configure(options);
-    await use(new DocumentSuggestionObject(page));
-  },
-});
-
-export {expect} from '@playwright/test';

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

@@ -1,52 +0,0 @@
-import type {Locator, Page, Request} from '@playwright/test';
-import {
-  isUaClickEvent,
-  isEventProtocol,
-} from '../../../../../../playwright/utils/requests';
-
-export class DocumentSuggestionObject {
-  private page: Page;
-
-  constructor(page: Page) {
-    this.page = page;
-  }
-
-  get documentSuggestion() {
-    return this.page.locator('c-quantic-document-suggestion');
-  }
-
-  get accordion() {
-    return this.page.locator('lightning-accordion');
-  }
-
-  get sections() {
-    return this.page.locator('lightning-accordion-section');
-  }
-
-  get noSuggestionsMessage() {
-    return this.page.getByText('No suggestions', {exact: true});
-  }
-
-  sectionContent(index: number): Locator {
-    return this.sections.nth(index).locator('div.slds-accordion__content');
-  }
-
-  async clickSuggestion(index: number): Promise<void> {
-    await this.sections.nth(index).click();
-  }
-
-  async waitForSuggestionClickEvent(mode: string): Promise<Request> {
-    return this.page.waitForRequest((request) => {
-      if (mode === 'legacy' && isUaClickEvent(request)) {
-        const requestBody = request.postDataJSON?.();
-        const event = JSON.parse(requestBody.clickEvent);
-        return event.actionCause === 'documentSuggestionClick';
-      } else if (mode === 'next' && isEventProtocol(request)) {
-        const requestBody = request.postDataJSON?.();
-        const requestData = requestBody[0];
-        return requestData.meta.type === 'CaseAssist.DocumentSuggestionClick';
-      }
-      return false;
-    });
-  }
-}

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

@@ -1,102 +0,0 @@
-/* eslint-disable no-await-in-loop */
-import {test, expect} from './fixture';
-
-const fakeTrackingId = 'tracking_id_123';
-
-['legacy', 'next'].forEach((mode) => {
-  test.describe(`quantic document suggestion with analytics mode: ${mode}`, () => {
-    let analyticsMode = 'legacy';
-    test.beforeEach(async ({documentSuggestion, page}) => {
-      analyticsMode = mode;
-      if (analyticsMode === 'next') {
-        await page.context().addCookies([
-          {
-            name: 'Coveo-Pendragon',
-            value: fakeTrackingId,
-            domain: '.my.site.com',
-            path: '/',
-          },
-          {
-            name: 'LSKey-c$Coveo-Pendragon',
-            value: fakeTrackingId,
-            domain: '.my.site.com',
-            path: '/',
-          },
-        ]);
-      }
-
-      await expect(documentSuggestion.noSuggestionsMessage).toBeVisible();
-    });
-
-    test('should handle clicking on a document suggestion', async ({
-      page,
-      documentSuggestion,
-      caseAssist,
-    }) => {
-      const responsePromise = caseAssist.waitForDocumentSuggestionResponse();
-      await caseAssist.fetchSuggestions();
-      const response = await responsePromise;
-      const suggestions = await response.json();
-      const clickedPosition = 2;
-
-      // Hack(?) to have the request payload in the analytics request next.
-      await page.route('*analytics*', (route) => {
-        route.continue();
-      });
-
-      const analyticsPromise =
-        documentSuggestion.waitForSuggestionClickEvent(analyticsMode);
-      await documentSuggestion.clickSuggestion(clickedPosition);
-      const analyticsRequest = await analyticsPromise;
-      const payload = analyticsRequest.postDataJSON?.();
-
-      if (analyticsMode === 'legacy') {
-        expect(payload).toBeDefined();
-        const event = JSON.parse(payload.clickEvent);
-        expect(event.actionCause).toBe('documentSuggestionClick');
-        expect(event.documentPosition).toBe(clickedPosition + 1);
-        expect(event.documentTitle).toBe(
-          suggestions.documents[clickedPosition].title
-        );
-        expect(event.documentUrl).toBe(
-          suggestions.documents[clickedPosition].clickUri
-        );
-      } else {
-        expect(payload).toBeDefined();
-        expect(payload.length).toBe(1);
-        expect(payload[0].meta.config.trackingId).toBe(fakeTrackingId);
-        expect(payload[0].meta.type).toBe('CaseAssist.DocumentSuggestionClick');
-        expect(payload[0].responseId).toBeDefined();
-        expect(payload[0].position).toBe(clickedPosition + 1);
-        expect(payload[0].itemMetadata.title).toBe(
-          suggestions.documents[clickedPosition].title
-        );
-        expect(payload[0].itemMetadata.uniqueFieldName).toBe('uniqueId');
-        expect(payload[0].itemMetadata.uniqueFieldValue).toBe(
-          suggestions.documents[clickedPosition].uniqueId
-        );
-      }
-    });
-
-    test.describe('when numberOfAutoOpenedDocuments is set to the same as maxDocument', () => {
-      test.use({
-        options: {
-          maxDocuments: 6,
-          numberOfAutoOpenedDocuments: 6,
-        },
-      });
-
-      test('should open all documents', async ({
-        documentSuggestion,
-        caseAssist,
-      }) => {
-        await caseAssist.fetchSuggestions();
-        await expect(documentSuggestion.accordion).toBeVisible();
-        const sections = await documentSuggestion.sections.count();
-        for (let index = 0; index < sections; index++) {
-          await expect(documentSuggestion.sectionContent(index)).toBeVisible();
-        }
-      });
-    });
-  });
-});