@coveo/quantic 3.33.0 → 3.33.2

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

@@ -0,0 +1,324 @@
+// @ts-ignore
+import * as mockHeadlessLoader from 'c/quanticHeadlessLoader';
+// @ts-ignore
+import {createElement} from 'lwc';
+import QuanticResultPrintableUri from '../quanticResultPrintableUri';
+
+const MIN_MAX_NUMBER_OF_PARTS = 3;
+
+jest.mock('c/quanticHeadlessLoader');
+
+// Helper function to mock Headless and Bueno for this suite of tests.
+function mockHeadlessAndBueno() {
+  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]'
+          ),
+      };
+    })
+  );
+}
+
+const selectors = {
+  link: 'c-quantic-result-link',
+  pathItem: '[data-test="path__item"]',
+  pathExpandButton: '[data-test="path__expand-button"]',
+  errorMessage: '[data-test="error"]',
+};
+const exampleEngineId = 'example engine id';
+
+function createTestComponent(options) {
+  const element = createElement('c-quantic-result-printable-uri', {
+    is: QuanticResultPrintableUri,
+  });
+
+  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));
+}
+
+function generateExampleUri(id) {
+  return `https://uri${id}.com/`;
+}
+
+function generateResultParents(numberOfParents) {
+  let parents = '';
+  for (let i = 1; i <= numberOfParents; i++) {
+    parents += `<parent name="parent${i}" uri="${generateExampleUri(i)}" />`;
+  }
+  return `<parents>${parents}</parents>`;
+}
+
+function shouldProperlyDisplayAllPathItems(pathItems) {
+  pathItems.forEach((item, index) => {
+    expect(item.textContent).toBe(`parent${index + 1}`);
+    expect(item.href).toBe(`${generateExampleUri(index + 1)}`);
+  });
+}
+
+describe('c-quantic-result-printable-uri', () => {
+  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(() => {
+    console.error = jest.fn();
+    mockHeadlessAndBueno();
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  describe('when displaying the result path', () => {
+    describe('when the number of parents is lower than the maxNumberOfParts property', () => {
+      const numberOfParents = 2;
+      const exampleResultWithParents = {
+        raw: {
+          parents: generateResultParents(numberOfParents),
+        },
+      };
+      it('should properly display all the result path', async () => {
+        const element = createTestComponent({
+          result: exampleResultWithParents,
+          engineId: exampleEngineId,
+          maxNumberOfParts: 3,
+        });
+        await flushPromises();
+
+        const pathItems = element.shadowRoot.querySelectorAll(
+          selectors.pathItem
+        );
+        expect(pathItems).not.toBeNull();
+        expect(pathItems.length).toBe(numberOfParents);
+        shouldProperlyDisplayAllPathItems(pathItems);
+      });
+    });
+
+    describe('when the number of parents is greater than the maxNumberOfParts property', () => {
+      const numberOfParents = 8;
+      const exampleResultWithParents = {
+        raw: {
+          parents: generateResultParents(numberOfParents),
+        },
+      };
+
+      describe('when the default value of the maxNumberOfParts property is used', () => {
+        it('should properly display the result collapsed path', async () => {
+          const defaultMaxNumberOfParts = 5;
+          const element = createTestComponent({
+            result: exampleResultWithParents,
+            engineId: exampleEngineId,
+          });
+          await flushPromises();
+
+          const pathItems = Array.from(
+            element.shadowRoot.querySelectorAll(selectors.pathItem)
+          );
+          const expandButton = element.shadowRoot.querySelector(
+            selectors.pathExpandButton
+          );
+          expect(pathItems).not.toBeNull();
+          expect(pathItems.length).toBe(defaultMaxNumberOfParts);
+          pathItems
+            .slice(0, defaultMaxNumberOfParts - 1)
+            .forEach((item, index) => {
+              expect(item.textContent).toBe(`parent${index + 1}`);
+              expect(item.href).toBe(`${generateExampleUri(index + 1)}`);
+            });
+
+          expect(expandButton).not.toBeNull();
+
+          expect(pathItems[defaultMaxNumberOfParts - 1].textContent).toBe(
+            `parent${numberOfParents}`
+          );
+          expect(pathItems[defaultMaxNumberOfParts - 1].href).toBe(
+            `${generateExampleUri(numberOfParents)}`
+          );
+        });
+
+        describe('when expanding the result collapsed path', () => {
+          it('should properly display the result expanded path', async () => {
+            const element = createTestComponent({
+              result: exampleResultWithParents,
+              engineId: exampleEngineId,
+            });
+            await flushPromises();
+
+            let expandButton = element.shadowRoot.querySelector(
+              selectors.pathExpandButton
+            );
+
+            expect(expandButton).not.toBeNull();
+
+            await expandButton.click();
+
+            const pathItems = element.shadowRoot.querySelectorAll(
+              selectors.pathItem
+            );
+            expandButton = element.shadowRoot.querySelector(
+              selectors.pathExpandButton
+            );
+
+            expect(expandButton).toBeNull();
+            expect(pathItems).not.toBeNull();
+            expect(pathItems.length).toBe(numberOfParents);
+            shouldProperlyDisplayAllPathItems(pathItems);
+          });
+        });
+      });
+
+      describe('when a custom value of the maxNumberOfParts property is used', () => {
+        const customMaxNumberOfParts = 3;
+
+        it('should properly display the result collapsed path', async () => {
+          const element = createTestComponent({
+            result: exampleResultWithParents,
+            engineId: exampleEngineId,
+            maxNumberOfParts: customMaxNumberOfParts,
+          });
+          await flushPromises();
+
+          const pathItems = Array.from(
+            element.shadowRoot.querySelectorAll(selectors.pathItem)
+          );
+          const expandButton = element.shadowRoot.querySelector(
+            selectors.pathExpandButton
+          );
+          expect(pathItems).not.toBeNull();
+          expect(pathItems.length).toBe(customMaxNumberOfParts);
+          pathItems
+            .slice(0, customMaxNumberOfParts - 1)
+            .forEach((item, index) => {
+              expect(item.textContent).toBe(`parent${index + 1}`);
+              expect(item.href).toBe(`${generateExampleUri(index + 1)}`);
+            });
+
+          expect(expandButton).not.toBeNull();
+
+          expect(pathItems[customMaxNumberOfParts - 1].textContent).toBe(
+            `parent${numberOfParents}`
+          );
+          expect(pathItems[customMaxNumberOfParts - 1].href).toBe(
+            `${generateExampleUri(numberOfParents)}`
+          );
+        });
+
+        describe('when expanding the result collapsed path', () => {
+          it('should properly display the result expanded path', async () => {
+            const element = createTestComponent({
+              result: exampleResultWithParents,
+              engineId: exampleEngineId,
+              maxNumberOfParts: customMaxNumberOfParts,
+            });
+            await flushPromises();
+
+            let expandButton = element.shadowRoot.querySelector(
+              selectors.pathExpandButton
+            );
+
+            expect(expandButton).not.toBeNull();
+
+            await expandButton.click();
+
+            const pathItems = element.shadowRoot.querySelectorAll(
+              selectors.pathItem
+            );
+            expandButton = element.shadowRoot.querySelector(
+              selectors.pathExpandButton
+            );
+
+            expect(expandButton).toBeNull();
+            expect(pathItems).not.toBeNull();
+            expect(pathItems.length).toBe(numberOfParents);
+            shouldProperlyDisplayAllPathItems(pathItems);
+          });
+        });
+      });
+    });
+  });
+
+  describe('when displaying the result url', () => {
+    const exampleResult = {
+      title: 'example title',
+      clickUri: 'https://coveo.com/',
+      raw: {
+        parents: '',
+      },
+    };
+
+    it('should display the printable uri using the quantic result link component', async () => {
+      const customTarget = '_blank';
+      const element = createTestComponent({
+        result: exampleResult,
+        target: customTarget,
+        engineId: exampleEngineId,
+      });
+      await flushPromises();
+
+      const link = element.shadowRoot.querySelector(selectors.link);
+
+      expect(link).not.toBeNull();
+      expect(link.engineId).toBe(exampleEngineId);
+      expect(link.result).toEqual(exampleResult);
+      expect(link.displayedField).toBe('printableUri');
+      expect(link.target).toBe(customTarget);
+    });
+  });
+
+  describe('when given invalid value of the property maxNumberOfParts', () => {
+    const exampleResult = {
+      title: 'example title',
+      clickUri: 'https://coveo.com/',
+      raw: {
+        parents: '',
+      },
+    };
+    const invalidMaxNumberOfParts = 1;
+
+    it('should display an error message', async () => {
+      const element = createTestComponent({
+        engineId: exampleEngineId,
+        result: exampleResult,
+        maxNumberOfParts: invalidMaxNumberOfParts,
+      });
+      await flushPromises();
+
+      const errorMessage = element.shadowRoot.querySelector(
+        selectors.errorMessage
+      );
+
+      expect(errorMessage).not.toBeNull();
+      expect(errorMessage.textContent).toBe(
+        'c-quantic-result-printable-uri Error'
+      );
+      expect(console.error).toHaveBeenCalledWith(
+        `The provided value of ${invalidMaxNumberOfParts} for the maxNumberOfParts option is inadequate. The provided value must be at least ${MIN_MAX_NUMBER_OF_PARTS}.`
+      );
+    });
+  });
+});

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

@@ -0,0 +1,301 @@
+/* eslint-disable jest/no-conditional-expect */
+import * as mockHeadlessLoader from 'c/quanticHeadlessLoader';
+// @ts-ignore
+import {createElement} from 'lwc';
+import QuanticResultQuickview from '../quanticResultQuickview';
+
+const selectors = {
+  quickviewButton: '[data-testid="quick-view-button"]',
+  closeQuickviewButton: '[data-testid="quickview-modal__close-button"]',
+  quickviewContent: 'c-quantic-quickview-content',
+  icon: 'lightning-icon',
+  tooltip: 'c-quantic-tooltip',
+};
+
+jest.mock('c/quanticHeadlessLoader');
+jest.mock(
+  '@salesforce/label/c.quantic_OpenPreview',
+  () => ({default: 'Open preview'}),
+  {
+    virtual: true,
+  }
+);
+jest.mock(
+  '@salesforce/label/c.quantic_OpenFileForPreview',
+  () => ({default: 'Open file for preview'}),
+  {
+    virtual: true,
+  }
+);
+jest.mock(
+  '@salesforce/label/c.quantic_NoPreviewAvailable',
+  () => ({default: 'No preview available'}),
+  {
+    virtual: true,
+  }
+);
+jest.mock('@salesforce/label/c.quantic_Close', () => ({default: 'Close'}), {
+  virtual: true,
+});
+
+const exampleResult = {
+  raw: {
+    date: '123',
+  },
+  title: 'abc',
+  uniqueId: '123',
+};
+
+const functionMocks = {
+  pushRecentResult: jest.fn(),
+  dispatchEvent: jest.fn(),
+};
+
+function createTestComponent(options = {result: exampleResult}) {
+  const element = createElement('c-quantic-result-quick-view', {
+    is: QuanticResultQuickview,
+  });
+
+  if (options) {
+    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() {
+  // eslint-disable-next-line @lwc/lwc/no-async-operation
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+let useCase = 'search';
+
+function mockHeadless(hasPreview = true) {
+  jest.spyOn(mockHeadlessLoader, 'getHeadlessBundle').mockReturnValue({
+    buildQuickview: () => ({
+      state: {resultHasPreview: hasPreview},
+      fetchResultContent: jest.fn(),
+      subscribe: jest.fn((callback) => {
+        callback();
+      }),
+      cancelPendingSelect: jest.fn(),
+    }),
+    buildInteractiveResult: jest.fn(),
+    loadRecentResultsActions: () => ({
+      pushRecentResult: functionMocks.pushRecentResult,
+    }),
+  });
+
+  jest
+    .spyOn(mockHeadlessLoader, 'isHeadlessBundle')
+    .mockReturnValue(useCase === 'search');
+
+  jest.spyOn(mockHeadlessLoader, 'getHeadlessEnginePromise').mockReturnValue(
+    new Promise((resolve) => {
+      resolve({
+        dispatch: jest.fn(),
+      });
+    })
+  );
+}
+
+function mockBueno() {
+  jest.spyOn(mockHeadlessLoader, 'getBueno').mockReturnValue(
+    new Promise(() => {
+      // @ts-ignore
+      global.Bueno = {
+        isString: jest
+          .fn()
+          .mockImplementation(
+            (value) =>
+              Object.prototype.toString.call(value) === '[object String]'
+          ),
+      };
+    })
+  );
+}
+
+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();
+}
+
+describe('c-quantic-result-quick-view', () => {
+  beforeEach(() => {
+    mockHeadless();
+    mockBueno();
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  it('should dispatch the pushRecentResult action', async () => {
+    const element = createTestComponent();
+    await flushPromises();
+
+    const quickViewButton = element.shadowRoot.querySelector(
+      selectors.quickviewButton
+    );
+    expect(quickViewButton.disabled).toBeFalsy();
+    await quickViewButton.click();
+    await flushPromises();
+
+    expect(functionMocks.pushRecentResult).toHaveBeenCalledTimes(1);
+    expect(functionMocks.pushRecentResult).toHaveBeenCalledWith(exampleResult);
+  });
+
+  describe('when the result has no preview', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+      mockHeadless(false);
+      mockBueno();
+    });
+
+    afterEach(() => {
+      cleanup();
+    });
+
+    it('should disable the quickview button', async () => {
+      const element = createTestComponent();
+      await flushPromises();
+
+      const quickViewButton = element.shadowRoot.querySelector(
+        selectors.quickviewButton
+      );
+
+      expect(quickViewButton.disabled).toBeTruthy();
+    });
+  });
+
+  describe('when the component has custom properties', () => {
+    it('should render the custom icon correctly', async () => {
+      const customIcon = 'utility:file';
+      const customOptions = {
+        result: exampleResult,
+        previewButtonIcon: customIcon,
+      };
+      const element = createTestComponent(customOptions);
+      await flushPromises();
+
+      const quickViewIcon = element.shadowRoot.querySelector(selectors.icon);
+
+      expect(quickViewIcon.iconName).toBe(customIcon);
+    });
+
+    it('should render the custom label correctly', async () => {
+      const customOptions = {
+        result: exampleResult,
+        previewButtonLabel: 'Custom Label',
+      };
+      const element = createTestComponent(customOptions);
+      await flushPromises();
+
+      const quickViewButton = element.shadowRoot.querySelector(
+        selectors.quickviewButton
+      );
+
+      expect(quickViewButton.textContent).toContain('Custom Label');
+      expect(quickViewButton.querySelector(selectors.icon).classList).toContain(
+        'slds-button__icon_right'
+      );
+    });
+
+    it.each([['brand'], ['outline_brand'], ['result-action']])(
+      'should render the custom variant %s',
+      async (testVariant) => {
+        const customOptions = {
+          result: exampleResult,
+          previewButtonVariant: testVariant,
+          dispatchEvent: functionMocks.dispatchEvent,
+        };
+
+        const element = createTestComponent(customOptions);
+        await flushPromises();
+
+        const quickViewButton = element.shadowRoot.querySelector(
+          selectors.quickviewButton
+        );
+
+        if (testVariant === 'result-action') {
+          expect(quickViewButton.classList).toContain(
+            'slds-button_icon-border-filled'
+          );
+          expect(functionMocks.dispatchEvent).toHaveBeenCalledTimes(2);
+          expect(functionMocks.dispatchEvent.mock.calls[0][0].type).toBe(
+            'quantic__resultactionregister'
+          );
+        } else {
+          expect(quickViewButton.classList).toContain(
+            `slds-button_${testVariant}`
+          );
+          expect(functionMocks.dispatchEvent).toHaveBeenCalledTimes(1);
+          expect(functionMocks.dispatchEvent.mock.calls[0][0].type).toBe(
+            'quantic__haspreview'
+          );
+        }
+      }
+    );
+
+    it('should render the tooltip correctly', async () => {
+      const customOptions = {
+        result: exampleResult,
+        tooltip: 'Custom Tooltip',
+      };
+      const element = createTestComponent(customOptions);
+      await flushPromises();
+
+      const tooltip = element.shadowRoot.querySelector(selectors.tooltip);
+
+      expect(tooltip.textContent).toBe('Custom Tooltip');
+    });
+  });
+
+  describe('when the quickview is opened and closed', () => {
+    it('should open the quickview modal', async () => {
+      const element = createTestComponent();
+      await flushPromises();
+
+      const quickViewButton = element.shadowRoot.querySelector(
+        selectors.quickviewButton
+      );
+      await quickViewButton.click();
+      await flushPromises();
+
+      const modal = element.shadowRoot.querySelector(
+        selectors.quickviewContent
+      );
+      expect(modal).not.toBeNull();
+    });
+
+    it('should close the quickview modal', async () => {
+      const element = createTestComponent();
+      await flushPromises();
+
+      const quickViewButton = element.shadowRoot.querySelector(
+        selectors.quickviewButton
+      );
+      await quickViewButton.click();
+      await flushPromises();
+
+      const closeButton = element.shadowRoot.querySelector(
+        selectors.closeQuickviewButton
+      );
+      await closeButton.click();
+      await flushPromises();
+
+      const modal = element.shadowRoot.querySelector(
+        selectors.quickviewContent
+      );
+      expect(modal).toBeNull();
+    });
+  });
+});

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

@@ -0,0 +1,81 @@
+import {ResultQuickviewObject} from './pageObject';
+import {quanticBase} from '../../../../../../playwright/fixtures/baseFixture';
+import {
+  searchRequestRegex,
+  insightSearchRequestRegex,
+  searchQuickviewRequestRegex,
+  insightQuickviewRequestRegex,
+} from '../../../../../../playwright/utils/requests';
+import {InsightSetupObject} from '../../../../../../playwright/page-object/insightSetupObject';
+import {useCaseEnum} from '../../../../../../playwright/utils/useCase';
+import {SearchObjectWithQuickview} from '../../../../../../playwright/page-object/searchObjectWithQuickview';
+
+const resultQuickviewUrl = 's/quantic-result-quickview';
+
+interface ResultQuickviewOptions {
+  result: string;
+  maximumPreviewSize: number;
+  previewButtonIcon: string;
+  previewButtonLabel: string;
+  previewButtonVariant: string;
+  tooltip: string;
+}
+type QuanticResultQuickviewE2ESearchFixtures = {
+  resultQuickview: ResultQuickviewObject;
+  search: SearchObjectWithQuickview;
+  options: Partial<ResultQuickviewOptions>;
+};
+
+type QuanticResultQuickviewE2EInsightFixtures =
+  QuanticResultQuickviewE2ESearchFixtures & {
+    insightSetup: InsightSetupObject;
+  };
+
+export const testSearch =
+  quanticBase.extend<QuanticResultQuickviewE2ESearchFixtures>({
+    options: {},
+    search: async ({page}, use) => {
+      await use(
+        new SearchObjectWithQuickview(
+          page,
+          searchRequestRegex,
+          searchQuickviewRequestRegex
+        )
+      );
+    },
+    resultQuickview: async ({page, options, configuration}, use) => {
+      await page.goto(resultQuickviewUrl);
+      await configuration.configure(options);
+      await use(new ResultQuickviewObject(page));
+    },
+  });
+
+export const testInsight =
+  quanticBase.extend<QuanticResultQuickviewE2EInsightFixtures>({
+    options: {},
+    search: async ({page}, use) => {
+      await use(
+        new SearchObjectWithQuickview(
+          page,
+          insightSearchRequestRegex,
+          insightQuickviewRequestRegex
+        )
+      );
+    },
+    insightSetup: async ({page}, use) => {
+      await use(new InsightSetupObject(page));
+    },
+    resultQuickview: async (
+      {page, options, search, configuration, insightSetup},
+      use
+    ) => {
+      await page.goto(resultQuickviewUrl);
+      await configuration.configure({...options, useCase: useCaseEnum.insight});
+      await insightSetup.waitForInsightInterfaceInitialization();
+      await search.performSearch();
+      await search.waitForSearchResponse();
+      await use(new ResultQuickviewObject(page));
+    },
+  });
+
+export {expect} from '@playwright/test';