@coveo/quantic 3.44.1 → 3.44.2

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

@@ -1,340 +0,0 @@
-/* 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

@@ -1,300 +0,0 @@
-/* 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

@@ -1,49 +0,0 @@
-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 search.mockSearchWithBaseResponse();
-      await page.goto(pageUrl);
-      configuration.configure(options);
-      await insightSetup.waitForInsightInterfaceInitialization();
-      await Promise.all([
-        search.waitForSearchResponse(),
-        search.performSearch(),
-      ]);
-      await use(new ResultCopyToClipboard(page));
-    },
-  });
-
-export {expect} from '@playwright/test';