@coveo/quantic 3.33.0 → 3.33.2

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

@@ -0,0 +1,404 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,102 @@
+/* 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();
+        }
+      });
+    });
+  });
+});