@coveo/quantic 3.33.0 → 3.33.1

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

@@ -0,0 +1,261 @@
+import * as mockHeadlessLoader from 'c/quanticHeadlessLoader';
+import {
+  getNavigateCalledWith,
+  getGenerateUrlCalledWith,
+} from 'lightning/navigation';
+// @ts-ignore
+import {createElement} from 'lwc';
+import QuanticResultLink from '../quanticResultLink';
+
+const exampleResult = {
+  clickUri: 'https://coveo.com/',
+};
+
+const selectors = {
+  quanticTextField: 'c-quantic-result-highlighted-text-field',
+};
+
+jest.mock('c/quanticHeadlessLoader');
+
+function createTestComponent(options) {
+  const element = createElement('c-quantic-result-link', {
+    is: QuanticResultLink,
+  });
+
+  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));
+}
+
+// Helper function to mock headless for this suite of tests.
+function mockHeadlessAndBueno() {
+  jest.spyOn(mockHeadlessLoader, 'getHeadlessBundle').mockReturnValue({
+    buildInteractiveResult: () => ({
+      select: jest.fn(),
+      beginDelayedSelect: jest.fn(),
+      cancelPendingSelect: jest.fn(),
+    }),
+  });
+
+  jest.spyOn(mockHeadlessLoader, 'getHeadlessEnginePromise').mockReturnValue(
+    new Promise((resolve) => {
+      resolve();
+    })
+  );
+
+  jest.spyOn(mockHeadlessLoader, 'getBueno').mockReturnValue(
+    new Promise(() => {
+      // @ts-ignore
+      global.Bueno = {
+        isString: jest
+          .fn()
+          .mockImplementation(
+            (value) =>
+              Object.prototype.toString.call(value) === '[object String]'
+          ),
+      };
+    })
+  );
+}
+
+describe('c-quantic-result-link', () => {
+  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();
+  }
+
+  beforeEach(() => {
+    mockHeadlessAndBueno();
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  describe('when the result is of type Salesforce', () => {
+    const exampleSalesforceResult = {
+      ...exampleResult,
+      raw: {
+        sfid: '123',
+      },
+    };
+    it('should call the navigation mixin to get the Salesforce record URL', async () => {
+      createTestComponent({result: exampleSalesforceResult});
+      await flushPromises();
+
+      const {pageReference} = getGenerateUrlCalledWith();
+
+      expect(pageReference.attributes.recordId).toBe(
+        exampleSalesforceResult.raw.sfid
+      );
+    });
+
+    it('should open the result link in a Salesforce console subtab', async () => {
+      const element = createTestComponent({result: exampleSalesforceResult});
+      await flushPromises();
+
+      const linkSalesforce = element.shadowRoot.querySelector('a');
+      linkSalesforce.click();
+
+      const {pageReference} = getNavigateCalledWith();
+
+      expect(pageReference.attributes.recordId).toBe(
+        exampleSalesforceResult.raw.sfid
+      );
+    });
+
+    describe('when the result is a knowledge article', () => {
+      const exampleKnowledgeArticleResult = {
+        ...exampleResult,
+        raw: {
+          sfid: '1234',
+          sfkavid: '1234',
+        },
+      };
+      it('should open the result link in a Salesforce console subtab', async () => {
+        const element = createTestComponent({
+          result: exampleKnowledgeArticleResult,
+        });
+        await flushPromises();
+
+        const LinkKnowledgeArticle = element.shadowRoot.querySelector('a');
+        LinkKnowledgeArticle.click();
+
+        const {pageReference} = getNavigateCalledWith();
+
+        expect(pageReference.attributes.recordId).toBe(
+          exampleKnowledgeArticleResult.raw.sfkavid
+        );
+      });
+    });
+
+    describe('when the result is a case comment', () => {
+      const exampleCaseCommentResult = {
+        ...exampleResult,
+        raw: {
+          sfid: '1234',
+          sfparentid: '5678',
+          documenttype: 'CaseComment',
+        },
+      };
+      it('should open the parent of the result in a Salesforce console subtab', async () => {
+        const element = createTestComponent({result: exampleCaseCommentResult});
+        await flushPromises();
+
+        const link = element.shadowRoot.querySelector('a');
+        link.click();
+
+        const {pageReference} = getNavigateCalledWith();
+
+        expect(pageReference.attributes.recordId).toBe(
+          exampleCaseCommentResult.raw.sfparentid
+        );
+      });
+    });
+  });
+
+  describe('when the result is NOT of type salesforce', () => {
+    it('should open the result link in the current browser tab', async () => {
+      const element = createTestComponent({result: exampleResult});
+      await flushPromises();
+
+      const link = element.shadowRoot.querySelector('a');
+
+      expect(link.getAttribute('href')).toEqual(exampleResult.clickUri);
+      expect(link.getAttribute('target')).toEqual('_self');
+    });
+
+    describe('with a custom value for the target property', () => {
+      it('should open the result link based on the value of the target property', async () => {
+        const customTarget = '_blank';
+        const element = createTestComponent({
+          result: exampleResult,
+          target: customTarget,
+        });
+        await flushPromises();
+
+        const link = element.shadowRoot.querySelector('a');
+
+        expect(link.getAttribute('href')).toEqual(exampleResult.clickUri);
+        expect(link.getAttribute('target')).toEqual(customTarget);
+      });
+    });
+  });
+
+  describe('with a custom value for the displayed field property', () => {
+    it('should display the correct field as the link text', async () => {
+      const customFieldToDisplay = 'exampleField';
+
+      const element = createTestComponent({
+        result: {
+          ...exampleResult,
+          raw: {[customFieldToDisplay]: 'exampleValue'},
+        },
+        displayedField: customFieldToDisplay,
+      });
+      await flushPromises();
+
+      const quanticTextFieldComponent = element.shadowRoot.querySelector(
+        selectors.quanticTextField
+      );
+
+      expect(quanticTextFieldComponent).not.toBeNull();
+      expect(quanticTextFieldComponent.field).toBe(customFieldToDisplay);
+    });
+  });
+
+  describe('with the default value for the displayed field property', () => {
+    describe('when the title field exists on the result', () => {
+      it('should display the title field as the link text', async () => {
+        const defaultFieldToDisplay = 'title';
+
+        const element = createTestComponent({
+          result: {
+            ...exampleResult,
+            [defaultFieldToDisplay]: 'example title',
+          },
+        });
+        await flushPromises();
+
+        const quanticTextFieldComponent = element.shadowRoot.querySelector(
+          selectors.quanticTextField
+        );
+
+        expect(quanticTextFieldComponent).not.toBeNull();
+        expect(quanticTextFieldComponent.field).toBe(defaultFieldToDisplay);
+      });
+    });
+
+    describe('when the title field does not exist on the result', () => {
+      it('should fall back to display the click uri field as the link text', async () => {
+        const fallbackFieldToDisplay = 'clickUri';
+
+        const element = createTestComponent({
+          result: {
+            ...exampleResult,
+            [fallbackFieldToDisplay]: 'example clickUri',
+          },
+        });
+        await flushPromises();
+
+        const quanticTextFieldComponent = element.shadowRoot.querySelector(
+          selectors.quanticTextField
+        );
+
+        expect(quanticTextFieldComponent).not.toBeNull();
+        expect(quanticTextFieldComponent.field).toBe(fallbackFieldToDisplay);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,342 @@
+/* eslint-disable no-import-assign */
+import QuanticResultList from 'c/quanticResultList';
+import * as mockHeadlessLoader from 'c/quanticHeadlessLoader';
+import {buildCreateTestComponent, cleanup, flushPromises} from 'c/testUtils';
+
+jest.mock('c/quanticHeadlessLoader');
+
+let isInitialized = false;
+
+const exampleEngine = {
+  id: 'exampleEngineId',
+};
+
+const defaultFieldsToInclude =
+  'date,author,source,language,filetype,documenttype,parents,sfknowledgearticleid,sfid,sfkbid,sfkavid,sfparentid';
+
+const defaultOptions = {
+  engineId: exampleEngine.id,
+};
+
+const initialResultListState = {
+  results: [],
+  searchResponseId: 'foo',
+  moreResultsAvailable: false,
+};
+let resultListState = initialResultListState;
+
+const initialSearchStatusState = {
+  hasError: false,
+};
+let searchStatusState = initialSearchStatusState;
+
+const selectors = {
+  resultList: 'c-quantic-result-list',
+  placeholder: 'c-quantic-placeholder',
+  initializationError: 'c-quantic-component-error',
+  quanticResult: 'c-quantic-result',
+};
+
+const initialResultsPerPageState = {
+  numberOfResults: 0,
+};
+let resultsPerPageState = initialResultsPerPageState;
+
+const functionsMocks = {
+  buildResultList: jest.fn(() => ({
+    state: resultListState,
+    subscribe: functionsMocks.resultsListSubscriber,
+    fetchMoreResults: functionsMocks.fetchMoreResults,
+  })),
+  buildSearchStatus: jest.fn(() => ({
+    state: searchStatusState,
+    subscribe: functionsMocks.searchStatusStateSubscriber,
+  })),
+  buildResultsPerPage: jest.fn(() => ({
+    state: resultsPerPageState,
+    subscribe: functionsMocks.resultsPerPageSubscriber,
+  })),
+  buildResultTemplatesManager: jest.fn(),
+  resultsListSubscriber: jest.fn((cb) => {
+    cb();
+    return functionsMocks.resultListUnsubscriber;
+  }),
+  searchStatusStateSubscriber: jest.fn((cb) => {
+    cb();
+    return functionsMocks.searchStatusStateUnsubscriber;
+  }),
+  resultsPerPageSubscriber: jest.fn((cb) => {
+    cb();
+    return functionsMocks.resultsPerPageUnsubscriber;
+  }),
+  resultListUnsubscriber: jest.fn(),
+  searchStatusStateUnsubscriber: jest.fn(),
+  resultsPerPageUnsubscriber: jest.fn(),
+  fetchMoreResults: jest.fn(),
+};
+
+function prepareHeadlessState() {
+  // @ts-ignore
+  mockHeadlessLoader.getHeadlessBundle = () => {
+    return {
+      buildResultList: functionsMocks.buildResultList,
+      buildSearchStatus: functionsMocks.buildSearchStatus,
+      buildResultsPerPage: functionsMocks.buildResultsPerPage,
+      buildResultTemplatesManager: functionsMocks.buildResultTemplatesManager,
+    };
+  };
+}
+
+function mockSuccessfulHeadlessInitialization() {
+  // @ts-ignore
+  mockHeadlessLoader.initializeWithHeadless = (element, _, initialize) => {
+    if (element instanceof QuanticResultList && !isInitialized) {
+      isInitialized = true;
+      initialize(exampleEngine);
+    }
+  };
+}
+
+function mockErroneousHeadlessInitialization() {
+  // @ts-ignore
+  mockHeadlessLoader.initializeWithHeadless = (element) => {
+    if (element instanceof QuanticResultList) {
+      element.setInitializationError();
+    }
+  };
+}
+
+const createTestComponent = buildCreateTestComponent(
+  QuanticResultList,
+  'c-quantic-result-list',
+  defaultOptions
+);
+
+describe('c-quantic-result-list', () => {
+  beforeEach(() => {
+    mockSuccessfulHeadlessInitialization();
+    prepareHeadlessState();
+  });
+
+  afterEach(() => {
+    cleanup();
+    resultListState = initialResultListState;
+    searchStatusState = initialSearchStatusState;
+    resultsPerPageState = initialResultsPerPageState;
+    isInitialized = false;
+  });
+
+  describe('controller initialization', () => {
+    beforeEach(() => {
+      mockSuccessfulHeadlessInitialization();
+      prepareHeadlessState();
+    });
+
+    it('should initialize the result list, search status, results per page, and result templates manager controllers with the correct engine and options', async () => {
+      createTestComponent();
+      await flushPromises();
+
+      expect(functionsMocks.buildResultList).toHaveBeenCalledTimes(1);
+      expect(functionsMocks.buildResultList).toHaveBeenCalledWith(
+        exampleEngine,
+        {
+          options: {
+            fieldsToInclude: defaultFieldsToInclude.split(','),
+          },
+        }
+      );
+      expect(functionsMocks.resultsListSubscriber).toHaveBeenCalledTimes(1);
+
+      expect(functionsMocks.buildSearchStatus).toHaveBeenCalledTimes(1);
+      expect(functionsMocks.buildSearchStatus).toHaveBeenCalledWith(
+        exampleEngine
+      );
+      expect(functionsMocks.searchStatusStateSubscriber).toHaveBeenCalledTimes(
+        1
+      );
+
+      expect(functionsMocks.buildResultsPerPage).toHaveBeenCalledTimes(1);
+      expect(functionsMocks.buildResultsPerPage).toHaveBeenCalledWith(
+        exampleEngine
+      );
+      expect(functionsMocks.resultsPerPageSubscriber).toHaveBeenCalledTimes(1);
+
+      expect(functionsMocks.buildResultTemplatesManager).toHaveBeenCalledTimes(
+        1
+      );
+      expect(functionsMocks.buildResultTemplatesManager).toHaveBeenCalledWith(
+        exampleEngine
+      );
+    });
+
+    it('should emit the #quantic__registerresulttemplates custom event', async () => {
+      const jestHandler = jest.fn();
+      document.addEventListener(
+        'quantic__registerresulttemplates',
+        jestHandler
+      );
+      createTestComponent();
+      await flushPromises();
+
+      expect(jestHandler).toHaveBeenCalledTimes(1);
+    });
+
+    it('should unsubscribe from the result list, searchStatus and resultPerPage controllers when the component is destroyed', async () => {
+      const element = createTestComponent();
+      await flushPromises();
+
+      document.body.removeChild(element);
+      await flushPromises();
+      expect(functionsMocks.resultListUnsubscriber).toHaveBeenCalledTimes(1);
+      expect(
+        functionsMocks.searchStatusStateUnsubscriber
+      ).toHaveBeenCalledTimes(1);
+      expect(functionsMocks.resultsPerPageUnsubscriber).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 loading', () => {
+    beforeEach(() => {
+      searchStatusState = {
+        ...initialSearchStatusState,
+        isLoading: true,
+        hasError: false,
+        firstSearchExecuted: false,
+      };
+      resultsPerPageState = {
+        ...initialResultsPerPageState,
+        numberOfResults: 10,
+      };
+    });
+
+    it('should display the loading placeholder', async () => {
+      const element = createTestComponent();
+      await flushPromises();
+
+      const placeholder = element.shadowRoot.querySelector(
+        selectors.placeholder
+      );
+
+      expect(placeholder).not.toBeNull();
+      expect(placeholder.numberOfRows).toBe(
+        resultsPerPageState.numberOfResults
+      );
+    });
+
+    describe('when the search status has an error', () => {
+      beforeEach(() => {
+        searchStatusState = {
+          ...initialSearchStatusState,
+          isLoading: true,
+          hasError: true,
+          firstSearchExecuted: false,
+        };
+      });
+
+      it('should not display the loading placeholder', async () => {
+        const element = createTestComponent();
+        await flushPromises();
+
+        const placeholder = element.shadowRoot.querySelector(
+          selectors.placeholder
+        );
+
+        expect(placeholder).toBeNull();
+      });
+    });
+  });
+
+  describe('the #fieldsToInclude property', () => {
+    beforeEach(() => {
+      mockSuccessfulHeadlessInitialization();
+      prepareHeadlessState();
+    });
+
+    it('should correctly send the fields to include to the headless controller', async () => {
+      const fieldsToInclude = 'foo,bar,baz';
+      createTestComponent({fieldsToInclude});
+      await flushPromises();
+
+      expect(functionsMocks.buildResultList).toHaveBeenCalledWith(
+        exampleEngine,
+        {
+          options: {
+            fieldsToInclude: fieldsToInclude.split(','),
+          },
+        }
+      );
+    });
+  });
+
+  describe('rendering results', () => {
+    beforeEach(() => {
+      mockSuccessfulHeadlessInitialization();
+      prepareHeadlessState();
+    });
+
+    it('should render the results', async () => {
+      const mockSearchResponseId = 'mockSearchResponseId';
+      const fakeResults = [
+        {
+          uniqueId: 'foo',
+          title: 'Foo',
+          excerpt: 'Foo',
+          raw: {
+            foo: 'foo',
+          },
+        },
+        {
+          uniqueId: 'Bar',
+          title: 'Bar',
+          excerpt: 'Bar',
+          raw: {
+            foo: 'bar',
+          },
+        },
+      ];
+      resultListState = {
+        ...initialResultListState,
+        searchResponseId: mockSearchResponseId,
+        results: fakeResults,
+      };
+
+      const element = createTestComponent();
+      await flushPromises();
+
+      const results = element.shadowRoot.querySelectorAll(
+        selectors.quanticResult
+      );
+      expect(results.length).toBe(fakeResults.length);
+      results.forEach((resultElement, index) => {
+        expect(resultElement.engineId).toBe(exampleEngine.id);
+        const fakeResult = fakeResults[index];
+        expect(resultElement.result).toEqual({
+          ...fakeResult,
+          keyResultList: `${mockSearchResponseId}_${fakeResult.uniqueId}`,
+        });
+        expect(resultElement.resultTemplateManager).toEqual(
+          functionsMocks.buildResultTemplatesManager()
+        );
+      });
+    });
+  });
+});

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

@@ -0,0 +1,66 @@
+import {ResultListObject} from './pageObject';
+import {quanticBase} from '../../../../../../playwright/fixtures/baseFixture';
+import {
+  insightSearchRequestRegex,
+  searchRequestRegex,
+} 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-result-list';
+
+interface ResultListOptions {
+  fieldsToInclude: string;
+}
+
+type QuanticResultListE2ESearchFixtures = {
+  resultList: ResultListObject;
+  search: SearchObject;
+  options: Partial<ResultListOptions>;
+};
+
+type QuanticResultListE2EInsightFixtures =
+  QuanticResultListE2ESearchFixtures & {
+    insightSetup: InsightSetupObject;
+  };
+
+export const testSearch =
+  quanticBase.extend<QuanticResultListE2ESearchFixtures>({
+    options: {},
+    search: async ({page}, use) => {
+      await use(new SearchObject(page, searchRequestRegex));
+    },
+    resultList: async ({page, options, configuration, search}, use) => {
+      await page.goto(pageUrl);
+      configuration.configure(options);
+      await search.waitForSearchResponse();
+      await search.waitForSearchResultsVisible();
+      await use(new ResultListObject(page));
+    },
+  });
+
+export const testInsight =
+  quanticBase.extend<QuanticResultListE2EInsightFixtures>({
+    options: {},
+    search: async ({page}, use) => {
+      await use(new SearchObject(page, insightSearchRequestRegex));
+    },
+    insightSetup: async ({page}, use) => {
+      await use(new InsightSetupObject(page));
+    },
+    resultList: 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 search.waitForSearchResultsVisible();
+      await use(new ResultListObject(page));
+    },
+  });
+
+export {expect} from '@playwright/test';