@coveo/quantic 3.33.0 → 3.33.1

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

@@ -0,0 +1,340 @@
+/* eslint-disable jest/expect-expect */
+// @ts-ignore
+import {createElement} from 'lwc';
+import QuanticResultChildren from '../quanticResultChildren';
+
+const loadRelatedItems = 'Load related items';
+const hideRelatedItems = 'Hide related items';
+jest.mock(
+  '@salesforce/label/c.quantic_LoadRelatedItems',
+  () => ({default: loadRelatedItems}),
+  {
+    virtual: true,
+  }
+);
+jest.mock(
+  '@salesforce/label/c.quantic_HideRelatedItems',
+  () => ({default: hideRelatedItems}),
+  {
+    virtual: true,
+  }
+);
+
+const functionsMocks = {
+  loadCollection: jest.fn(() => {}),
+  logShowLessFoldedResults: jest.fn(() => {}),
+  logShowMoreFoldedResults: jest.fn(() => {}),
+};
+
+const mockedFoldedResultListController = {
+  loadCollection: functionsMocks.loadCollection,
+  logShowLessFoldedResults: functionsMocks.logShowLessFoldedResults,
+  logShowMoreFoldedResults: functionsMocks.logShowMoreFoldedResults,
+};
+
+const selectors = {
+  quanticResult: 'c-quantic-result',
+  toggleButton: '.result-children__toggle-button lightning-button',
+  placeholder: 'c-quantic-placeholder',
+  noMoreChildrenMessage: '.result-children__no-more-children-message',
+};
+
+const exampleFoldedResultOne = {
+  result: {
+    uniqueId: '123',
+    title: 'example result one',
+  },
+  children: [],
+};
+const exampleFoldedResultTwo = {
+  result: {
+    uniqueId: '456',
+    title: 'example result two',
+  },
+  children: [],
+};
+const exampleEngineId = 'example engine id';
+const exampleTemplateId = 'example template id';
+const exampleCollection = {
+  result: {
+    uniqueId: '789',
+    title: 'example parent result',
+  },
+  children: [exampleFoldedResultOne],
+  isLoadingMoreResults: false,
+  moreResultsAvailable: true,
+};
+const exampleCollectionWithAllResultsLoaded = {
+  ...exampleCollection,
+  children: [exampleFoldedResultOne, exampleFoldedResultTwo],
+  isLoadingMoreResults: false,
+  moreResultsAvailable: false,
+};
+const exampleCollectionWithAdditionalGrandChild = {
+  ...exampleCollection,
+  children: [
+    {
+      ...exampleFoldedResultOne,
+      children: [...exampleFoldedResultOne.children, exampleFoldedResultTwo],
+    },
+  ],
+  isLoadingMoreResults: false,
+  moreResultsAvailable: false,
+};
+const exampleCollectionWithNoMoreResults = {
+  ...exampleCollection,
+  moreResultsAvailable: false,
+};
+
+const defaultOptions = {
+  engineId: exampleEngineId,
+  templateId: exampleTemplateId,
+  foldedResultListController: mockedFoldedResultListController,
+  collection: exampleCollection,
+};
+
+function createTestComponent(options = defaultOptions) {
+  const element = createElement('c-quantic-result-children', {
+    is: QuanticResultChildren,
+  });
+
+  Object.assign(element, options);
+
+  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 cleanup() {
+  jest.clearAllMocks();
+  // 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);
+  }
+}
+
+function expectProperChildResultsDisplay(element, collection) {
+  const childResults = element.shadowRoot.querySelectorAll(
+    selectors.quanticResult
+  );
+  expect(childResults.length).toBe(collection.children.length);
+  collection.children.forEach((foldedResult, index) => {
+    expect(childResults[index].engineId).toBe(exampleEngineId);
+    expect(childResults[index].templateId).toBe(exampleTemplateId);
+    expect(childResults[index].result).toEqual(foldedResult.result);
+    expect(childResults[index].collection).toEqual(foldedResult);
+  });
+}
+
+async function clickFoldedResultToggleButton(element, label) {
+  const foldedResultToggleButton = element.shadowRoot.querySelector(
+    selectors.toggleButton
+  );
+  expect(foldedResultToggleButton).not.toBeNull();
+  expect(foldedResultToggleButton.label).toBe(label);
+  foldedResultToggleButton.click();
+  await flushPromises();
+}
+
+describe('c-quantic-result-children', () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  describe('when there are no child results available in the collection', () => {
+    it('should not display any child results and the no more child results message', async () => {
+      const element = createTestComponent({
+        ...defaultOptions,
+        collection: {
+          ...exampleCollection,
+          moreResultsAvailable: false,
+          children: [],
+        },
+      });
+      await flushPromises();
+
+      const childResult = element.shadowRoot.querySelector(
+        selectors.quanticResult
+      );
+
+      const noMoreChildrenMessage = element.shadowRoot.querySelector(
+        selectors.noMoreChildrenMessage
+      );
+
+      expect(childResult).toBeNull();
+      expect(noMoreChildrenMessage).toBeNull();
+    });
+  });
+
+  describe('when there are more child results available in the collection', () => {
+    it('should display the first partition of the child results', async () => {
+      const element = createTestComponent();
+      await flushPromises();
+
+      expectProperChildResultsDisplay(element, exampleCollection);
+    });
+
+    describe('when more child results are expanded or collapsed', () => {
+      describe('when the child results are being loaded', () => {
+        it('should display the result placeholder', async () => {
+          const element = createTestComponent();
+          await flushPromises();
+
+          await clickFoldedResultToggleButton(element, loadRelatedItems);
+          element.collection = {
+            ...exampleCollection,
+            isLoadingMoreResults: true,
+          };
+          await flushPromises();
+
+          const placeholder = element.shadowRoot.querySelector(
+            selectors.placeholder
+          );
+          expect(placeholder.numberOfRows).toBe(
+            exampleCollection.children.length
+          );
+        });
+      });
+
+      it('should call the right actions and properly display the child results', async () => {
+        const element = createTestComponent();
+        await flushPromises();
+        const foldedResultToggleButton = element.shadowRoot.querySelector(
+          selectors.toggleButton
+        );
+
+        await clickFoldedResultToggleButton(element, loadRelatedItems);
+        expect(functionsMocks.loadCollection).toHaveBeenCalledTimes(1);
+        element.collection = exampleCollectionWithAllResultsLoaded;
+        await flushPromises();
+        expectProperChildResultsDisplay(
+          element,
+          exampleCollectionWithAllResultsLoaded
+        );
+
+        await clickFoldedResultToggleButton(element, hideRelatedItems);
+        expect(functionsMocks.logShowLessFoldedResults).toHaveBeenCalledTimes(
+          1
+        );
+        expectProperChildResultsDisplay(element, exampleCollection);
+
+        await clickFoldedResultToggleButton(element, loadRelatedItems);
+        expect(functionsMocks.logShowMoreFoldedResults).toHaveBeenCalledTimes(
+          1
+        );
+        expectProperChildResultsDisplay(
+          element,
+          exampleCollectionWithAllResultsLoaded
+        );
+        expect(foldedResultToggleButton.label).toBe(hideRelatedItems);
+      });
+
+      describe('when only grand children are available in the collection', () => {
+        it('should properly display the expanded child results', async () => {
+          const element = createTestComponent();
+          await flushPromises();
+          const foldedResultToggleButton = element.shadowRoot.querySelector(
+            selectors.toggleButton
+          );
+
+          await clickFoldedResultToggleButton(element, loadRelatedItems);
+          expect(functionsMocks.loadCollection).toHaveBeenCalledTimes(1);
+          element.collection = exampleCollectionWithAdditionalGrandChild;
+          await flushPromises();
+          expectProperChildResultsDisplay(
+            element,
+            exampleCollectionWithAdditionalGrandChild
+          );
+
+          const noMoreChildrenMessage = element.shadowRoot.querySelector(
+            selectors.noMoreChildrenMessage
+          );
+          expect(noMoreChildrenMessage).toBeNull();
+          expect(foldedResultToggleButton.label).toBe(hideRelatedItems);
+        });
+      });
+    });
+  });
+
+  describe('when there are no more child results available in the collection', () => {
+    it('should display the first partition of the child results', async () => {
+      const element = createTestComponent();
+      await flushPromises();
+
+      expectProperChildResultsDisplay(element, exampleCollection);
+    });
+
+    describe('when trying to load more child results', () => {
+      it('should display the no more child results message', async () => {
+        const element = createTestComponent();
+        await flushPromises();
+
+        await clickFoldedResultToggleButton(element, loadRelatedItems);
+        element.collection = {
+          ...exampleCollection,
+          moreResultsAvailable: false,
+        };
+        await flushPromises();
+
+        const foldedResultToggleButton = element.shadowRoot.querySelector(
+          selectors.toggleButton
+        );
+        const noMoreChildrenMessage = element.shadowRoot.querySelector(
+          selectors.noMoreChildrenMessage
+        );
+
+        expect(functionsMocks.loadCollection).toHaveBeenCalledTimes(1);
+        expectProperChildResultsDisplay(element, exampleCollection);
+        expect(foldedResultToggleButton).toBeNull();
+        expect(noMoreChildrenMessage).not.toBeNull();
+      });
+    });
+
+    describe('when executing a search query after loading the child results', () => {
+      it('should no longer display the no more child results message and display the child results toggle', async () => {
+        const element = createTestComponent();
+        await flushPromises();
+
+        await clickFoldedResultToggleButton(element, loadRelatedItems);
+
+        expect(functionsMocks.loadCollection).toHaveBeenCalledTimes(1);
+        element.collection = exampleCollectionWithNoMoreResults;
+        await flushPromises();
+
+        let foldedResultToggleButton = element.shadowRoot.querySelector(
+          selectors.toggleButton
+        );
+        let noMoreChildrenMessage = element.shadowRoot.querySelector(
+          selectors.noMoreChildrenMessage
+        );
+
+        expectProperChildResultsDisplay(
+          element,
+          exampleCollectionWithNoMoreResults
+        );
+        expect(foldedResultToggleButton).toBeNull();
+        expect(noMoreChildrenMessage).not.toBeNull();
+
+        // Simulates new search query
+        element.collection = exampleCollection;
+        await flushPromises();
+
+        foldedResultToggleButton = element.shadowRoot.querySelector(
+          selectors.toggleButton
+        );
+        noMoreChildrenMessage = element.shadowRoot.querySelector(
+          selectors.noMoreChildrenMessage
+        );
+
+        expectProperChildResultsDisplay(element, exampleCollection);
+        expect(foldedResultToggleButton).not.toBeNull();
+        expect(noMoreChildrenMessage).toBeNull();
+        expect(foldedResultToggleButton.label).toBe(loadRelatedItems);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,300 @@
+/* eslint-disable no-import-assign */
+import QuanticResultCopyToClipboard from '../quanticResultCopyToClipboard';
+import {cleanup, buildCreateTestComponent} from 'c/testUtils';
+import * as mockHeadlessLoader from 'c/quanticHeadlessLoader';
+import * as quanticUtils from 'c/quanticUtils';
+
+const defaultTemplate = '${title}\n${clickUri}';
+
+jest.mock('c/quanticHeadlessLoader');
+jest.mock('c/quanticUtils', () => ({
+  ...jest.requireActual('c/quanticUtils'),
+  copyToClipboard: jest.fn(() => Promise.resolve()),
+  buildTemplateTextFromResult: jest.fn(() => defaultTemplate),
+}));
+
+let isInitialized = false;
+const functionMocks = {
+  logCopyToClipboard: jest.fn(() => Promise.resolve()),
+  dispatch: jest.fn(() => {}),
+};
+
+const exampleEngine = {
+  id: 'exampleEngineId',
+  dispatch: functionMocks.dispatch,
+};
+
+const defaultOptions = {
+  engineId: exampleEngine.id,
+  result: {
+    clickUri: 'https://example.com',
+    title: 'Example Title',
+  },
+  label: 'Copy',
+  successLabel: 'Copied',
+  textTemplate: defaultTemplate,
+};
+
+const copyToClipboardEvent = new CustomEvent('quantic__copytoclipboard', {
+  bubbles: true,
+});
+
+const selectors = {
+  initializationError: 'c-quantic-component-error',
+  quanticResultAction: 'c-quantic-result-action',
+};
+
+const createTestComponent = buildCreateTestComponent(
+  QuanticResultCopyToClipboard,
+  'c-quantic-result-copy-to-clipboard',
+  defaultOptions
+);
+
+function prepareHeadlessState() {
+  // @ts-ignore
+  mockHeadlessLoader.getHeadlessBundle = () => {
+    return {
+      loadInsightAnalyticsActions: jest.fn(() => {
+        return {
+          logCopyToClipboard: functionMocks.logCopyToClipboard,
+        };
+      }),
+    };
+  };
+}
+
+function mockSuccessfulHeadlessInitialization() {
+  // @ts-ignore
+  mockHeadlessLoader.initializeWithHeadless = (element, _, initialize) => {
+    if (element instanceof QuanticResultCopyToClipboard && !isInitialized) {
+      isInitialized = true;
+      initialize(exampleEngine);
+    }
+  };
+}
+
+function mockErroneousHeadlessInitialization() {
+  // @ts-ignore
+  mockHeadlessLoader.initializeWithHeadless = (element) => {
+    if (element instanceof QuanticResultCopyToClipboard) {
+      element.setInitializationError();
+    }
+  };
+}
+
+async function flushPromises() {
+  return Promise.resolve();
+}
+
+describe('c-quantic-result-copy-to-clipboard', () => {
+  afterEach(() => {
+    cleanup();
+    isInitialized = false;
+  });
+
+  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(() => {
+      prepareHeadlessState();
+      mockSuccessfulHeadlessInitialization();
+      console.error = jest.fn();
+      console.warn = jest.fn();
+    });
+
+    it('should render the Quantic Result Action properly', async () => {
+      const expectedIconName = 'utility:copy';
+      const expectedEventName = 'quantic__copytoclipboard';
+
+      const element = createTestComponent();
+      await flushPromises();
+
+      const resultAction = element.shadowRoot.querySelector(
+        selectors.quanticResultAction
+      );
+
+      expect(resultAction).not.toBeNull();
+      expect(resultAction.label).toBe(defaultOptions.label);
+      expect(resultAction.iconName).toEqual(expectedIconName);
+      expect(resultAction.eventName).toEqual(expectedEventName);
+    });
+
+    describe('when passing custom options', () => {
+      it('should render the Quantic Result Action component with the provided custom label', async () => {
+        const customLabel = 'Custom Label';
+        const element = createTestComponent({
+          ...defaultOptions,
+          label: customLabel,
+        });
+        await flushPromises();
+
+        const resultAction = element.shadowRoot.querySelector(
+          selectors.quanticResultAction
+        );
+
+        expect(resultAction).not.toBeNull();
+        expect(resultAction.label).toBe(customLabel);
+      });
+
+      it('should call the buildTemplateTextFromResult function with a provided custom textTemplate', async () => {
+        const customTemplate = 'Custom: ${title} - ${clickUri}';
+        const mockBuildTemplateTextFromResult =
+          quanticUtils.buildTemplateTextFromResult;
+        const element = createTestComponent({
+          ...defaultOptions,
+          textTemplate: customTemplate,
+        });
+        await flushPromises();
+
+        element.dispatchEvent(copyToClipboardEvent);
+
+        expect(mockBuildTemplateTextFromResult).toHaveBeenCalledTimes(1);
+        expect(mockBuildTemplateTextFromResult).toHaveBeenCalledWith(
+          customTemplate,
+          defaultOptions.result
+        );
+      });
+
+      it('should render the Quantic Result Action component with the provided custom successLabel', async () => {
+        const customSuccessLabel = 'Custom Success Label';
+        const element = createTestComponent({
+          ...defaultOptions,
+          successLabel: customSuccessLabel,
+        });
+        await flushPromises();
+
+        const resultAction = element.shadowRoot.querySelector(
+          selectors.quanticResultAction
+        );
+
+        element.dispatchEvent(copyToClipboardEvent);
+        await flushPromises();
+
+        expect(resultAction.label).toBe(customSuccessLabel);
+      });
+    });
+
+    describe('when receiving the copy to clipboard event', () => {
+      it('should call the buildTemplateTextFromResult function with the correct parameters', async () => {
+        const mockBuildTemplateTextFromResult =
+          quanticUtils.buildTemplateTextFromResult;
+        const element = createTestComponent();
+
+        element.dispatchEvent(copyToClipboardEvent);
+        await flushPromises();
+
+        expect(mockBuildTemplateTextFromResult).toHaveBeenCalledTimes(1);
+        expect(mockBuildTemplateTextFromResult).toHaveBeenCalledWith(
+          defaultOptions.textTemplate,
+          defaultOptions.result
+        );
+      });
+
+      describe('when calling the copyToClipboard function', () => {
+        it('should dispatch the logCopyToClipboard action', async () => {
+          const element = createTestComponent();
+          await flushPromises();
+
+          const resultAction = element.shadowRoot.querySelector(
+            selectors.quanticResultAction
+          );
+          expect(resultAction).not.toBeNull();
+
+          await element.dispatchEvent(copyToClipboardEvent);
+
+          expect(functionMocks.logCopyToClipboard).toHaveBeenCalledTimes(1);
+          expect(functionMocks.logCopyToClipboard).toHaveBeenCalledWith(
+            defaultOptions.result
+          );
+        });
+
+        it('should call the copyToClipboard function with the correct parameters when the promise resolved', async () => {
+          const mockCopyToClipboard = quanticUtils.copyToClipboard;
+          const element = createTestComponent();
+          await flushPromises();
+
+          const resultAction = element.shadowRoot.querySelector(
+            selectors.quanticResultAction
+          );
+
+          await element.dispatchEvent(copyToClipboardEvent);
+          await flushPromises();
+
+          expect(mockCopyToClipboard).toHaveBeenCalledTimes(1);
+          expect(mockCopyToClipboard).toHaveBeenCalledWith(
+            defaultOptions.textTemplate
+          );
+          expect(resultAction.loading).toBe(false);
+        });
+
+        it('should log an error in the console when the promise is rejected', async () => {
+          const mockCopyToClipboard = quanticUtils.copyToClipboard;
+          const element = createTestComponent();
+          await flushPromises();
+
+          const resultAction = element.shadowRoot.querySelector(
+            selectors.quanticResultAction
+          );
+
+          // @ts-ignore
+          mockCopyToClipboard.mockImplementationOnce(() =>
+            Promise.reject(new Error('Copy to clipboard error'))
+          );
+
+          await element.dispatchEvent(copyToClipboardEvent);
+          await flushPromises();
+
+          expect(console.error).toHaveBeenCalledWith(
+            'Copy to clipboard action failed.',
+            expect.any(Error)
+          );
+          expect(resultAction.loading).toBe(false);
+        });
+
+        describe('when the tooltip is displayed', () => {
+          beforeAll(() => {
+            jest.useFakeTimers();
+          });
+
+          afterAll(() => {
+            jest.useRealTimers();
+          });
+
+          it('should display the success label then reset the initial label after 1000ms', async () => {
+            const element = createTestComponent();
+            await flushPromises();
+
+            const resultAction = element.shadowRoot.querySelector(
+              selectors.quanticResultAction
+            );
+            expect(resultAction).not.toBeNull();
+
+            element.dispatchEvent(copyToClipboardEvent);
+            await flushPromises();
+
+            expect(resultAction.label).toBe(defaultOptions.successLabel);
+
+            await jest.advanceTimersByTimeAsync(1000);
+
+            expect(resultAction.label).toBe(defaultOptions.label);
+          });
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,46 @@
+import {ResultCopyToClipboard} from './pageObject';
+import {quanticBase} from '../../../../../../playwright/fixtures/baseFixture';
+import {insightSearchRequestRegex} from '../../../../../../playwright/utils/requests';
+import {InsightSetupObject} from '../../../../../../playwright/page-object/insightSetupObject';
+import {SearchObject} from '../../../../../../playwright/page-object/searchObject';
+
+const pageUrl = 's/quantic-result-copy-to-clipboard';
+
+interface ResultCopyToClipboardOptions {
+  engineId: string;
+  result: string;
+  label: string;
+  successLabel: string;
+  textTemplate: string;
+}
+
+type QuanticResultCopyToClipboardE2EInsightFixtures = {
+  resultCopyToClipboard: ResultCopyToClipboard;
+  search: SearchObject;
+  options: Partial<ResultCopyToClipboardOptions>;
+  insightSetup: InsightSetupObject;
+};
+
+export const testInsight =
+  quanticBase.extend<QuanticResultCopyToClipboardE2EInsightFixtures>({
+    options: {},
+    search: async ({page}, use) => {
+      await use(new SearchObject(page, insightSearchRequestRegex));
+    },
+    insightSetup: async ({page}, use) => {
+      await use(new InsightSetupObject(page));
+    },
+    resultCopyToClipboard: async (
+      {page, options, search, configuration, insightSetup},
+      use
+    ) => {
+      await page.goto(pageUrl);
+      configuration.configure(options);
+      await insightSetup.waitForInsightInterfaceInitialization();
+      await search.performSearch();
+      await search.waitForSearchResponse();
+      await use(new ResultCopyToClipboard(page));
+    },
+  });
+
+export {expect} from '@playwright/test';