@coveo/quantic 3.44.1 → 3.44.2

package/force-app/main/default/lwc/quanticFacetManager/e2e/data.ts

@@ -1,59 +0,0 @@
-/**
- * Facet response builder for the facet manager example page
- * (`exampleQuanticFacetManager.html`), which registers three facets:
- * a `language` facet, a `date` timeframe facet, and an `objecttype` facet.
- */
-const facetManagerData = [
-  {
-    facetId: 'language',
-    field: 'language',
-    moreValuesAvailable: false,
-    values: [{value: 'English', state: 'idle', numberOfResults: 100}],
-    indexScore: 0.3,
-  },
-  {
-    facetId: 'date',
-    field: 'date',
-    moreValuesAvailable: false,
-    values: [
-      {
-        start: 'past-1-week',
-        end: 'now',
-        endInclusive: false,
-        state: 'idle',
-        numberOfResults: 10,
-      },
-      {
-        start: 'past-1-month',
-        end: 'now',
-        endInclusive: false,
-        state: 'idle',
-        numberOfResults: 20,
-      },
-      {
-        start: 'past-6-month',
-        end: 'now',
-        endInclusive: false,
-        state: 'idle',
-        numberOfResults: 30,
-      },
-      {
-        start: 'past-1-year',
-        end: 'now',
-        endInclusive: false,
-        state: 'idle',
-        numberOfResults: 40,
-      },
-    ],
-    indexScore: 0.2,
-  },
-  {
-    facetId: 'objecttype',
-    field: 'objecttype',
-    moreValuesAvailable: false,
-    values: [{value: 'People', state: 'idle', numberOfResults: 50}],
-    indexScore: 0.1,
-  },
-];
-
-export default facetManagerData;

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

@@ -1,75 +0,0 @@
-import {FacetManagerObject} from './pageObject';
-import {facetBase} from '../../../../../../playwright/fixtures/baseFacetFixture';
-import {
-  searchRequestRegex,
-  insightSearchRequestRegex,
-} from '../../../../../../playwright/utils/requests';
-import {InsightSetupObject} from '../../../../../../playwright/page-object/insightSetupObject';
-import {useCaseEnum} from '../../../../../../playwright/utils/useCase';
-import {BaseFacetObject} from '../../../../../../playwright/page-object/baseFacetObject';
-import facetManagerData from './data';
-
-const pageUrl = 's/quantic-facet-manager';
-
-interface FacetManagerOptions {}
-
-type QuanticFacetManagerE2ESearchFixtures = {
-  facetManager: FacetManagerObject;
-  options: Partial<FacetManagerOptions>;
-};
-
-type QuanticFacetManagerE2EInsightFixtures =
-  QuanticFacetManagerE2ESearchFixtures & {
-    insightSetup: InsightSetupObject;
-  };
-
-export const testSearch =
-  facetBase.extend<QuanticFacetManagerE2ESearchFixtures>({
-    options: {},
-    facetResponses: {responses: [facetManagerData]},
-    baseFacet: async ({page}, use) => {
-      await use(new BaseFacetObject(page, searchRequestRegex));
-    },
-    facetManager: async (
-      {page, options, configuration, baseFacet, facetResponses},
-      use
-    ) => {
-      await baseFacet.mockSearchWithFacetResponseSequence(
-        facetResponses?.responses
-      );
-      await page.goto(pageUrl);
-      configuration.configure(options);
-      await baseFacet.waitForSearchResponse();
-
-      await use(new FacetManagerObject(page));
-    },
-  });
-
-export const testInsight =
-  facetBase.extend<QuanticFacetManagerE2EInsightFixtures>({
-    options: {},
-    facetResponses: {responses: [facetManagerData]},
-    baseFacet: async ({page}, use) => {
-      await use(new BaseFacetObject(page, insightSearchRequestRegex));
-    },
-    insightSetup: async ({page}, use) => {
-      await use(new InsightSetupObject(page));
-    },
-    facetManager: async (
-      {page, options, baseFacet, configuration, insightSetup, facetResponses},
-      use
-    ) => {
-      await baseFacet.mockSearchWithFacetResponseSequence(
-        facetResponses?.responses
-      );
-      await page.goto(pageUrl);
-      configuration.configure({...options, useCase: useCaseEnum.insight});
-      await insightSetup.waitForInsightInterfaceInitialization();
-      const searchResponsePromise = baseFacet.waitForSearchResponse();
-      await baseFacet.performSearch();
-      await searchResponsePromise;
-      await use(new FacetManagerObject(page));
-    },
-  });
-
-export {expect} from '@playwright/test';

package/force-app/main/default/lwc/quanticFacetManager/e2e/pageObject.ts

@@ -1,23 +0,0 @@
-import type {Locator, Page} from '@playwright/test';
-
-export class FacetManagerObject {
-  constructor(public page: Page) {
-    this.page = page;
-  }
-
-  get facetManager(): Locator {
-    return this.page.locator('c-quantic-facet-manager');
-  }
-
-  get facetManagerItems(): Locator {
-    return this.facetManager.getByTestId('facet-manager__item');
-  }
-
-  get itemTemplateSlot(): Locator {
-    return this.facetManager.locator('slot[name="itemTemplate"]');
-  }
-
-  getFacetManagerItemByIndex(index: number): Locator {
-    return this.facetManagerItems.nth(index);
-  }
-}

package/force-app/main/default/lwc/quanticFacetManager/e2e/quanticFacetManager.e2e.ts

@@ -1,82 +0,0 @@
-import {testSearch, testInsight, expect} from './fixture';
-import {useCaseTestCases} from '../../../../../../playwright/utils/useCase';
-
-const fixtures = {
-  search: testSearch,
-  insight: testInsight,
-};
-
-const exampleFacetsOrder = ['objecttype', 'date', 'language'];
-
-/**
- * Filters out any facetId which contains a filter input "_input" because they are not displayed in the facet manager.
- */
-function filterInputFacets(facets: any): string[] {
-  return facets
-    .map((facet: any) => facet.facetId)
-    .filter((id: string) => !/_input$/.test(id));
-}
-
-useCaseTestCases.forEach((useCase) => {
-  let test = fixtures[useCase.value];
-
-  test.describe(`quantic facet manager ${useCase.label}`, () => {
-    test('should load facets in the same order as in the initial search response', async ({
-      facetManager,
-      baseFacet,
-    }) => {
-      const searchResponsePromise = baseFacet.waitForSearchResponse();
-      await baseFacet.performSearch();
-
-      const searchResponse = await searchResponsePromise;
-      const {facets} = await searchResponse.json();
-      expect(facets).not.toBeNull();
-
-      const filteredIds = filterInputFacets(facets);
-
-      filteredIds.forEach(async (facetId: any, index: number) => {
-        const facetManagerItem = facetManager.getFacetManagerItemByIndex(index);
-        expect(await facetManagerItem.getAttribute('data-facet-id')).toEqual(
-          facetId
-        );
-      });
-    });
-
-    test.describe('when the facets are reordered', () => {
-      test('should load facets in the reordered order', async ({
-        facetManager,
-        baseFacet,
-      }) => {
-        await baseFacet.mockSearchFacetOrder(exampleFacetsOrder);
-        const searchResponsePromise = baseFacet.waitForSearchResponse();
-        await baseFacet.performSearch();
-
-        const searchResponse = await searchResponsePromise;
-        const {facets} = await searchResponse.json();
-        expect(facets).not.toBeNull();
-
-        exampleFacetsOrder.forEach(async (facetId: string, index: number) => {
-          const facetManagerItem =
-            facetManager.getFacetManagerItemByIndex(index);
-          expect(await facetManagerItem.getAttribute('data-facet-id')).toEqual(
-            facetId
-          );
-        });
-      });
-    });
-
-    test.describe('when an itemTemplate slot is provided', () => {
-      test('should customize the element that wraps each facet according to the itemTemplate slot', async ({
-        facetManager,
-      }) => {
-        const expectedClass = 'slds-m-around_xx-large';
-        expect(facetManager.itemTemplateSlot).not.toBeNull();
-
-        const facetManagerItems = await facetManager.facetManagerItems.all();
-        facetManagerItems.forEach(async (item: any) => {
-          expect(await item.getAttribute('class')).toContain(expectedClass);
-        });
-      });
-    });
-  });
-});

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

@@ -1,403 +0,0 @@
-/* eslint-disable jest/no-focused-tests */
-// @ts-ignore
-import {createElement} from 'lwc';
-import QuanticFeedback from '../quanticFeedback';
-
-const functionsMocks = {
-  exampleHandleLike: jest.fn(),
-  exampleHandleDislike: jest.fn(),
-  exampleHandleExplainWhy: jest.fn(),
-};
-
-const exampleQuestion = 'Example question';
-const exampleSuccessMessage = 'Example success Message';
-const defaultLikeIconName = 'utility:success';
-const defaultLikeLabel = 'yes';
-const defaultDislikeIconName = 'utility:clear';
-const defaultDislikeLabel = 'no';
-const defaultSize = 'xx-small';
-
-jest.mock(
-  '@salesforce/label/c.quantic_Yes',
-  () => ({default: defaultLikeLabel}),
-  {
-    virtual: true,
-  }
-);
-jest.mock(
-  '@salesforce/label/c.quantic_No',
-  () => ({default: defaultDislikeLabel}),
-  {
-    virtual: true,
-  }
-);
-
-const selectors = {
-  feedbackQuestion: '.feedback__question',
-  likeButton: 'c-quantic-stateful-button[data-testid="feedback__like-button"]',
-  dislikeButton:
-    'c-quantic-stateful-button[data-testid="feedback__dislike-button"]',
-  successMessage: '.feedback__success-message',
-  explainWhyButton: '.feedback__explain-why',
-};
-
-const defaultOptions = {
-  state: 'neutral',
-  question: exampleQuestion,
-  hideExplainWhyButton: false,
-  successMessage: exampleSuccessMessage,
-  likeLabel: defaultLikeLabel,
-  dislikeLabel: defaultDislikeLabel,
-};
-
-function setupEventListeners(element) {
-  element.addEventListener('quantic__like', functionsMocks.exampleHandleLike);
-  element.addEventListener(
-    'quantic__dislike',
-    functionsMocks.exampleHandleDislike
-  );
-  element.addEventListener(
-    'quantic__pressexplainwhy',
-    functionsMocks.exampleHandleExplainWhy
-  );
-}
-
-function createTestComponent(options = defaultOptions) {
-  const element = createElement('c-quantic-feedback', {
-    is: QuanticFeedback,
-  });
-
-  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));
-}
-
-describe('c-quantic-feedback', () => {
-  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();
-  }
-
-  afterEach(() => {
-    cleanup();
-  });
-
-  it('should properly display the feedback question', async () => {
-    const element = createTestComponent();
-    await flushPromises();
-
-    const question = element.shadowRoot.querySelector(
-      selectors.feedbackQuestion
-    );
-
-    expect(question).not.toBeNull();
-    expect(question.textContent).toBe(exampleQuestion);
-  });
-
-  it('should not render the feedback question when question is empty', async () => {
-    const element = createTestComponent({...defaultOptions, question: ''});
-    await flushPromises();
-
-    const question = element.shadowRoot.querySelector(
-      selectors.feedbackQuestion
-    );
-
-    expect(question).toBeNull();
-  });
-
-  describe('when the component is in a neutral state', () => {
-    it('should display the feedback buttons in a neutral state', async () => {
-      const element = createTestComponent();
-      await flushPromises();
-
-      const likeButton = element.shadowRoot.querySelector(selectors.likeButton);
-      const dislikeButton = element.shadowRoot.querySelector(
-        selectors.dislikeButton
-      );
-
-      expect(likeButton.iconName).toBe(defaultLikeIconName);
-      expect(likeButton.selected).toBe(false);
-      expect(likeButton.label).toBe(defaultLikeLabel);
-      expect(likeButton.tooltip).toBe(defaultLikeLabel);
-      expect(likeButton.iconSize).toBe(defaultSize);
-      expect(likeButton.withoutBorders).toBe(true);
-
-      expect(dislikeButton.iconName).toBe(defaultDislikeIconName);
-      expect(dislikeButton.selected).toBe(false);
-      expect(dislikeButton.label).toBe(defaultDislikeLabel);
-      expect(dislikeButton.tooltip).toBe(defaultDislikeLabel);
-      expect(dislikeButton.iconSize).toBe(defaultSize);
-      expect(dislikeButton.withoutBorders).toBe(true);
-    });
-
-    it('should not display the success message', async () => {
-      const element = createTestComponent();
-      await flushPromises();
-
-      const successMessage = element.shadowRoot.querySelector(
-        selectors.successMessage
-      );
-
-      expect(successMessage).toBeNull();
-    });
-
-    describe('when the like button is clicked', () => {
-      it('should dispatch the quantic__like" event', async () => {
-        const element = createTestComponent();
-        setupEventListeners(element);
-        await flushPromises();
-
-        const likeButton = element.shadowRoot.querySelector(
-          selectors.likeButton
-        );
-        likeButton.dispatchEvent(new CustomEvent('quantic__select'));
-
-        expect(likeButton).not.toBeNull();
-        expect(functionsMocks.exampleHandleLike).toHaveBeenCalledTimes(1);
-      });
-    });
-
-    describe('when the dislike button is clicked', () => {
-      it('should dispatch the "quantic__dislike" event', async () => {
-        const element = createTestComponent();
-        setupEventListeners(element);
-        await flushPromises();
-
-        const dislikeButton = element.shadowRoot.querySelector(
-          selectors.dislikeButton
-        );
-        dislikeButton.dispatchEvent(new CustomEvent('quantic__select'));
-
-        expect(dislikeButton).not.toBeNull();
-        expect(functionsMocks.exampleHandleDislike).toHaveBeenCalledTimes(1);
-      });
-    });
-
-    describe('when custom properties are passed', () => {
-      const customLikeIconName = 'utility:like';
-      const customLikeLabel = 'like';
-      const customDislikeIconName = 'utility:dislike';
-      const customDislikeLabel = 'dislike';
-      const customSize = 'large';
-
-      it('should display the feedback buttons properly', async () => {
-        const element = createTestComponent({
-          ...defaultOptions,
-          likeIconName: customLikeIconName,
-          likeLabel: customLikeLabel,
-          dislikeIconName: customDislikeIconName,
-          dislikeLabel: customDislikeLabel,
-          size: customSize,
-        });
-        await flushPromises();
-
-        const likeButton = element.shadowRoot.querySelector(
-          selectors.likeButton
-        );
-        const dislikeButton = element.shadowRoot.querySelector(
-          selectors.dislikeButton
-        );
-
-        expect(likeButton.iconName).toBe(customLikeIconName);
-        expect(likeButton.selected).toBe(false);
-        expect(likeButton.label).toBe(customLikeLabel);
-        expect(likeButton.tooltip).toBe(customLikeLabel);
-        expect(likeButton.iconSize).toBe(customSize);
-        expect(likeButton.withoutBorders).toBe(true);
-
-        expect(dislikeButton.iconName).toBe(customDislikeIconName);
-        expect(dislikeButton.selected).toBe(false);
-        expect(dislikeButton.label).toBe(customDislikeLabel);
-        expect(dislikeButton.tooltip).toBe(customDislikeLabel);
-        expect(dislikeButton.iconSize).toBe(customSize);
-        expect(dislikeButton.withoutBorders).toBe(true);
-      });
-    });
-
-    describe('when the property hideLabels is set to true', () => {
-      it('should display the feedback buttons properly', async () => {
-        const element = createTestComponent({
-          ...defaultOptions,
-          hideLabels: true,
-        });
-        await flushPromises();
-
-        const likeButton = element.shadowRoot.querySelector(
-          selectors.likeButton
-        );
-        const dislikeButton = element.shadowRoot.querySelector(
-          selectors.dislikeButton
-        );
-
-        expect(likeButton.label).toBe('');
-        expect(likeButton.tooltip).toBe(defaultLikeLabel);
-        expect(dislikeButton.label).toBe('');
-        expect(dislikeButton.tooltip).toBe(defaultDislikeLabel);
-      });
-    });
-  });
-
-  describe('when the component is in a liked state', () => {
-    it('should display the feedback buttons in a liked state', async () => {
-      const element = createTestComponent({...defaultOptions, state: 'liked'});
-      await flushPromises();
-
-      const likeButton = element.shadowRoot.querySelector(selectors.likeButton);
-      const dislikeButton = element.shadowRoot.querySelector(
-        selectors.dislikeButton
-      );
-
-      expect(likeButton.selected).toBe(true);
-      expect(likeButton.selectedStateColor).toBe('#2e844a');
-      expect(dislikeButton.selected).toBe(false);
-    });
-
-    it('should display the success message', async () => {
-      const element = createTestComponent({...defaultOptions, state: 'liked'});
-      await flushPromises();
-
-      const successMessage = element.shadowRoot.querySelector(
-        selectors.successMessage
-      );
-      const explainWhyButton = element.shadowRoot.querySelector(
-        selectors.explainWhyButton
-      );
-
-      expect(successMessage).not.toBeNull();
-      expect(successMessage.textContent).toBe(exampleSuccessMessage);
-      expect(explainWhyButton).not.toBeNull();
-    });
-
-    describe('when the explain why button is clicked', () => {
-      it('should dispatch the "quantic__pressexplainwhy" event', async () => {
-        const element = createTestComponent({
-          ...defaultOptions,
-          state: 'liked',
-        });
-        setupEventListeners(element);
-        await flushPromises();
-
-        const explainWhyButton = element.shadowRoot.querySelector(
-          selectors.explainWhyButton
-        );
-        explainWhyButton.click();
-
-        expect(explainWhyButton).not.toBeNull();
-        expect(functionsMocks.exampleHandleExplainWhy).toHaveBeenCalledTimes(1);
-      });
-    });
-
-    describe('when the hideExplainWhy property is set to true', () => {
-      it('should display the success message without the explain why button', async () => {
-        const element = createTestComponent({
-          ...defaultOptions,
-          state: 'liked',
-          hideExplainWhyButton: true,
-        });
-        await flushPromises();
-
-        const successMessage = element.shadowRoot.querySelector(
-          selectors.successMessage
-        );
-        const explainWhyButton = element.shadowRoot.querySelector(
-          selectors.explainWhyButton
-        );
-
-        expect(successMessage).not.toBeNull();
-        expect(successMessage.textContent).toBe(exampleSuccessMessage);
-        expect(explainWhyButton).toBeNull();
-      });
-    });
-  });
-
-  describe('when the component is in a disliked state', () => {
-    it('should display the feedback buttons in a disliked state', async () => {
-      const element = createTestComponent({
-        ...defaultOptions,
-        state: 'disliked',
-      });
-      await flushPromises();
-
-      const likeButton = element.shadowRoot.querySelector(selectors.likeButton);
-      const dislikeButton = element.shadowRoot.querySelector(
-        selectors.dislikeButton
-      );
-
-      expect(likeButton.selected).toBe(false);
-      expect(dislikeButton.selected).toBe(true);
-      expect(dislikeButton.selectedStateColor).toBe('#ea001e');
-    });
-
-    it('should display the success message', async () => {
-      const element = createTestComponent({
-        ...defaultOptions,
-        state: 'disliked',
-      });
-      await flushPromises();
-
-      const successMessage = element.shadowRoot.querySelector(
-        selectors.successMessage
-      );
-      const explainWhyButton = element.shadowRoot.querySelector(
-        selectors.explainWhyButton
-      );
-
-      expect(successMessage).not.toBeNull();
-      expect(successMessage.textContent).toBe(exampleSuccessMessage);
-      expect(explainWhyButton).not.toBeNull();
-    });
-
-    describe('when the explain why button is clicked', () => {
-      it('should dispatch the "quantic__pressexplainwhy" event', async () => {
-        const element = createTestComponent({
-          ...defaultOptions,
-          state: 'disliked',
-        });
-        setupEventListeners(element);
-        await flushPromises();
-
-        const explainWhyButton = element.shadowRoot.querySelector(
-          selectors.explainWhyButton
-        );
-        explainWhyButton.click();
-
-        expect(explainWhyButton).not.toBeNull();
-        expect(functionsMocks.exampleHandleExplainWhy).toHaveBeenCalledTimes(1);
-      });
-    });
-
-    describe('when the hideExplainWhy property is set to true', () => {
-      it('should display the success message without the explain why button', async () => {
-        const element = createTestComponent({
-          ...defaultOptions,
-          state: 'disliked',
-          hideExplainWhyButton: true,
-        });
-        await flushPromises();
-
-        const successMessage = element.shadowRoot.querySelector(
-          selectors.successMessage
-        );
-        const explainWhyButton = element.shadowRoot.querySelector(
-          selectors.explainWhyButton
-        );
-
-        expect(successMessage).not.toBeNull();
-        expect(successMessage.textContent).toBe(exampleSuccessMessage);
-        expect(explainWhyButton).toBeNull();
-      });
-    });
-  });
-});