@coveo/quantic 3.44.1 → 3.44.2

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

@@ -1,23 +0,0 @@
-export const allOptions = [
-  {id: '0', value: 'Very low', label: 'Very low', validFor: []},
-  {id: '1', value: 'Low', label: 'Low', validFor: []},
-  {id: '2', value: 'Medium', label: 'Medium', validFor: []},
-  {id: '3', value: 'High', label: 'High', validFor: []},
-  {id: '4', value: 'Very high', label: 'Very high', validFor: []},
-];
-
-export const caseClassificationSuggestions = [
-  {
-    value: 'Very low',
-    confidence: 1,
-    id: '0',
-  },
-  {
-    value: 'Low',
-    confidence: 1,
-    id: '1',
-  },
-];
-
-export const sfDefaultField = 'Priority';
-export const coveoDefaultField = 'sfpriority';

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

@@ -1,51 +0,0 @@
-import {CaseClassificationObject} from './pageObject';
-import {quanticBase} from '../../../../../../playwright/fixtures/baseFixture';
-import {CaseAssistObject} from '../../../../../../playwright/page-object/caseAssistObject';
-import {
-  allOptions,
-  caseClassificationSuggestions,
-  coveoDefaultField,
-  sfDefaultField,
-} from './data';
-
-const pageUrl = 's/quantic-case-classification';
-
-interface CaseClassificationOptions {
-  fetchOnInit: boolean;
-  fetchClassificationOnChange: boolean;
-  fetchDocumentSuggestionOnChange: boolean;
-}
-type QuanticCaseClassificationE2EFixtures = {
-  caseClassification: CaseClassificationObject;
-  caseAssist: CaseAssistObject;
-  options: Partial<CaseClassificationOptions>;
-};
-
-export const test = quanticBase.extend<QuanticCaseClassificationE2EFixtures>({
-  options: {},
-  caseAssist: async ({page}, use) => {
-    await use(new CaseAssistObject(page));
-  },
-  caseClassification: async (
-    {page, options, configuration, caseAssist},
-    use
-  ) => {
-    const caseClassificationObject = new CaseClassificationObject(page);
-    caseClassificationObject.mockSfPicklistValues(sfDefaultField, allOptions);
-    caseClassificationObject.mockCaseClassification(
-      coveoDefaultField,
-      caseClassificationSuggestions
-    );
-    await page.goto(pageUrl);
-    await configuration.configure({...options});
-    await caseClassificationObject.allOptionsSelectInput.waitFor();
-
-    const caseClassificationsResponsePromise =
-      caseAssist.waitForCaseClassificationsResponse();
-    await caseAssist.fetchClassifications();
-    await caseClassificationsResponsePromise;
-    await use(caseClassificationObject);
-  },
-});
-
-export {expect} from '@playwright/test';

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

@@ -1,152 +0,0 @@
-import type {Locator, Page, Request} from '@playwright/test';
-import {isCollectEvent} from '../../../../../../playwright/utils/requests';
-
-const elementsSelectors = {
-  component: 'c-quantic-case-classification',
-  caseClassificationSuggestionTestId: 'case-classification-suggestion',
-  showSelectInputButtonTestId: 'show-select-input-button',
-  allOptionsSelectInputTestId: 'case-classification-all-options-combobox',
-  selectInputOption: 'lightning-base-combobox-item',
-};
-
-export class CaseClassificationObject {
-  constructor(public page: Page) {
-    this.page = page;
-  }
-
-  get component(): Locator {
-    return this.page.locator(elementsSelectors.component);
-  }
-
-  get caseClassificationSuggestions(): Locator {
-    return this.component.locator(
-      `[data-testid="${elementsSelectors.caseClassificationSuggestionTestId}"]:visible`
-    );
-  }
-
-  get showSelectInputButton(): Locator {
-    return this.component.getByTestId(
-      elementsSelectors.showSelectInputButtonTestId
-    );
-  }
-
-  get allOptionsSelectInput(): Locator {
-    return this.component.getByTestId(
-      elementsSelectors.allOptionsSelectInputTestId
-    );
-  }
-
-  get allOptionsSelectInputValue(): Promise<null | string> {
-    return this.allOptionsSelectInput.locator('button').textContent();
-  }
-
-  get selectInputOption(): Locator {
-    return this.component.locator(elementsSelectors.selectInputOption);
-  }
-
-  get selectedSuggestion(): Locator {
-    return this.component.locator(
-      `[data-testid="${elementsSelectors.caseClassificationSuggestionTestId}"] > input:checked`
-    );
-  }
-
-  async clickCaseClassificationSuggestionAtIndex(index: number): Promise<void> {
-    await this.caseClassificationSuggestions.nth(index).click();
-  }
-
-  async clickShowSelectInputButton(): Promise<void> {
-    await this.showSelectInputButton.click();
-  }
-
-  async clickallOptionsSelectInput(): Promise<void> {
-    await this.allOptionsSelectInput.click();
-  }
-
-  async clickSelectInputOptionAtIndex(index: number): Promise<void> {
-    await this.selectInputOption.nth(index).click();
-  }
-
-  async mockCaseClassification(
-    field: string,
-    value: Array<object>,
-    responseId?: string
-  ) {
-    await this.page.route(
-      '**/rest/organizations/*/caseassists/*/classify',
-      async (route) => {
-        await route.fulfill({
-          status: 200,
-          headers: {
-            'content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            fields: {
-              [field]: {predictions: value},
-            },
-            responseId: responseId ?? '123',
-          }),
-        });
-      }
-    );
-  }
-
-  async mockSfPicklistValues(field: string, values: Array<object>) {
-    await this.page.route(
-      '**/aura?*aura.RecordUi.getPicklistValuesByRecordType=1',
-      async (route) => {
-        const response = await route.fetch();
-        const responseBody = await response.json();
-
-        responseBody.actions[0].returnValue.picklistFieldValues[field].values =
-          values.map((value) => ({
-            ...value,
-            attributes: null,
-          }));
-
-        await route.fulfill({
-          status: response.status(),
-          headers: response.headers(),
-          body: JSON.stringify(responseBody),
-        });
-      }
-    );
-  }
-
-  async waitForCollectAnalytics(
-    expectedAction: string,
-    expectedData: Record<string, any>
-  ): Promise<Request> {
-    const uaRequest = this.page.waitForRequest((request) => {
-      if (isCollectEvent(request)) {
-        const requestBody = request.postDataJSON?.();
-        if (requestBody.svc_action !== expectedAction) {
-          return false;
-        }
-        const dataMatches = Object.keys(expectedData).every(
-          (key) =>
-            JSON.stringify(requestBody.svc_action_data[key]) ===
-            JSON.stringify(expectedData[key])
-        );
-
-        return dataMatches;
-      }
-      return false;
-    });
-    return uaRequest;
-  }
-
-  async waitForTicketClassificationClickCollectAnalytics(
-    expectedData: Record<string, any>
-  ): Promise<Request> {
-    return this.waitForCollectAnalytics(
-      'ticket_classification_click',
-      expectedData
-    );
-  }
-
-  async waitForTicketFieldUpdateCollectAnalytics(
-    expectedData: Record<string, any>
-  ): Promise<Request> {
-    return this.waitForCollectAnalytics('ticket_field_update', expectedData);
-  }
-}

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

@@ -1,269 +0,0 @@
-import {test, expect} from './fixture';
-import {
-  caseClassificationSuggestions,
-  coveoDefaultField,
-  allOptions,
-} from './data';
-
-test.describe('quantic case classification', () => {
-  test.describe('the analytics', () => {
-    test.describe('when new case classifications suggestions are received', () => {
-      test('should log the proper ticket classification click collect event for the automatically selected suggestion', async ({
-        caseClassification,
-        caseAssist,
-      }) => {
-        const indexOfNewSuggestion = 1;
-        const {
-          id: selectedSuggestionId,
-          value: selectedSuggestionValue,
-          confidence: selectedSuggestionConfidence,
-        } = caseClassificationSuggestions[indexOfNewSuggestion];
-        caseClassification.mockCaseClassification(coveoDefaultField, [
-          caseClassificationSuggestions[indexOfNewSuggestion],
-        ]);
-
-        const automaticallySelectedSuggestionCollectEventPromise =
-          caseClassification.waitForTicketClassificationClickCollectAnalytics({
-            classificationId: selectedSuggestionId,
-            responseId: '123',
-            fieldName: coveoDefaultField,
-            classification: {
-              value: selectedSuggestionValue,
-              confidence: selectedSuggestionConfidence,
-            },
-            autoSelection: true,
-          });
-
-        await caseAssist.fetchClassifications();
-        await automaticallySelectedSuggestionCollectEventPromise;
-      });
-    });
-
-    test.describe('clicking on a case classification suggestion', () => {
-      test('should log the proper collect events', async ({
-        caseClassification,
-      }) => {
-        const selectedSuggestionIndex = 1;
-        const {
-          id: selectedSuggestionId,
-          value: selectedSuggestionValue,
-          confidence: selectedSuggestionConfidence,
-        } = caseClassificationSuggestions[selectedSuggestionIndex];
-        const selectedSuggestionCollectEventPromise =
-          caseClassification.waitForTicketClassificationClickCollectAnalytics({
-            classificationId: selectedSuggestionId,
-            responseId: '123',
-            fieldName: coveoDefaultField,
-            classification: {
-              value: selectedSuggestionValue,
-              confidence: selectedSuggestionConfidence,
-            },
-          });
-        const fieldUpdateCollectEventPromise =
-          caseClassification.waitForTicketFieldUpdateCollectAnalytics({
-            fieldName: coveoDefaultField,
-          });
-        await caseClassification.clickCaseClassificationSuggestionAtIndex(
-          selectedSuggestionIndex
-        );
-        await selectedSuggestionCollectEventPromise;
-        await fieldUpdateCollectEventPromise;
-      });
-    });
-
-    test.describe('clicking on a case classification option', () => {
-      test('should log the proper collect events', async ({
-        caseClassification,
-      }) => {
-        const fieldUpdateCollectEventPromise =
-          caseClassification.waitForTicketFieldUpdateCollectAnalytics({
-            fieldName: coveoDefaultField,
-          });
-
-        await caseClassification.clickShowSelectInputButton();
-        await caseClassification.clickallOptionsSelectInput();
-        await caseClassification.clickSelectInputOptionAtIndex(3);
-        await fieldUpdateCollectEventPromise;
-      });
-    });
-  });
-
-  test.describe('when the property fetchClassificationOnChange is set to true', () => {
-    test.use({
-      options: {fetchClassificationOnChange: true},
-    });
-
-    test('should trigger a new classification request when a case classification suggestion is clicked', async ({
-      caseClassification,
-      caseAssist,
-    }) => {
-      const caseClassificationsResponsePromise =
-        caseAssist.waitForCaseClassificationsResponse();
-
-      await caseClassification.clickCaseClassificationSuggestionAtIndex(1);
-
-      await caseClassificationsResponsePromise;
-    });
-
-    test('should trigger a new classification request when a case classification option is clicked', async ({
-      caseClassification,
-      caseAssist,
-    }) => {
-      const caseClassificationsResponsePromise =
-        caseAssist.waitForCaseClassificationsResponse();
-
-      await caseClassification.clickShowSelectInputButton();
-      await caseClassification.clickallOptionsSelectInput();
-      await caseClassification.clickSelectInputOptionAtIndex(3);
-
-      await caseClassificationsResponsePromise;
-    });
-  });
-
-  test.describe('when the property fetchDocumentSuggestionOnChange is set to true', () => {
-    test.use({
-      options: {fetchDocumentSuggestionOnChange: true},
-    });
-
-    test('should trigger a new document suggestions request when a case classification suggestion is clicked', async ({
-      caseClassification,
-      caseAssist,
-    }) => {
-      const documentSuggestionResponsePromise =
-        caseAssist.waitForDocumentSuggestionResponse();
-
-      await caseClassification.clickCaseClassificationSuggestionAtIndex(1);
-
-      await documentSuggestionResponsePromise;
-    });
-
-    test('should trigger a new document suggestions request when a case classification option is clicked', async ({
-      caseClassification,
-      caseAssist,
-    }) => {
-      const documentSuggestionResponsePromise =
-        caseAssist.waitForDocumentSuggestionResponse();
-
-      await caseClassification.clickShowSelectInputButton();
-      await caseClassification.clickallOptionsSelectInput();
-      await caseClassification.clickSelectInputOptionAtIndex(3);
-
-      await documentSuggestionResponsePromise;
-    });
-  });
-
-  test.describe('the behaviour of the case classifications', () => {
-    test.describe('when selecting a suggestion and then receiving new suggestions that include the selected suggestion', () => {
-      test('should keep the suggestion by the user selected and display it as an inline option', async ({
-        caseClassification,
-        caseAssist,
-      }) => {
-        const selectedSuggestionIndex = 1;
-        await caseClassification.clickCaseClassificationSuggestionAtIndex(
-          selectedSuggestionIndex
-        );
-        await expect(caseClassification.selectedSuggestion).toHaveValue(
-          caseClassificationSuggestions[selectedSuggestionIndex].value
-        );
-
-        caseClassification.mockCaseClassification(
-          coveoDefaultField,
-          caseClassificationSuggestions
-        );
-        const caseClassificationsResponsePromise =
-          caseAssist.waitForCaseClassificationsResponse();
-        await caseAssist.fetchClassifications();
-        await caseClassificationsResponsePromise;
-        await expect(caseClassification.selectedSuggestion).toHaveValue(
-          caseClassificationSuggestions[selectedSuggestionIndex].value
-        );
-      });
-    });
-
-    test.describe('when selecting a specific suggestion and then receiving new suggestions that does not contain the previously selected option', () => {
-      test('should keep the suggestion selected by the user and display it in the select input', async ({
-        caseClassification,
-        caseAssist,
-      }) => {
-        const selectedSuggestionIndex = 1;
-        await caseClassification.clickCaseClassificationSuggestionAtIndex(
-          selectedSuggestionIndex
-        );
-        await expect(caseClassification.selectedSuggestion).toHaveValue(
-          caseClassificationSuggestions[selectedSuggestionIndex].value
-        );
-
-        caseClassification.mockCaseClassification(coveoDefaultField, [
-          caseClassificationSuggestions[0],
-        ]);
-        const caseClassificationsResponsePromise =
-          caseAssist.waitForCaseClassificationsResponse();
-        await caseAssist.fetchClassifications();
-        await caseClassificationsResponsePromise;
-
-        await expect(caseClassification.allOptionsSelectInput).toHaveText(
-          caseClassificationSuggestions[selectedSuggestionIndex].value
-        );
-      });
-    });
-
-    test.describe('when selecting an option from the select input and then fetching suggestions', () => {
-      test('should keep the option selected by the user, display it in the select input and hide the suggestions', async ({
-        caseClassification,
-        caseAssist,
-      }) => {
-        const selectedOptionIndex = 3;
-        await caseClassification.clickShowSelectInputButton();
-        await caseClassification.clickallOptionsSelectInput();
-        await caseClassification.clickSelectInputOptionAtIndex(
-          selectedOptionIndex
-        );
-
-        caseClassification.mockCaseClassification(coveoDefaultField, [
-          caseClassificationSuggestions[0],
-        ]);
-        const caseClassificationsResponsePromise =
-          caseAssist.waitForCaseClassificationsResponse();
-        await caseAssist.fetchClassifications();
-        await caseClassificationsResponsePromise;
-        await expect(await caseClassification.allOptionsSelectInputValue).toBe(
-          allOptions[selectedOptionIndex].value
-        );
-        await expect(
-          caseClassification.caseClassificationSuggestions
-        ).toHaveCount(0);
-      });
-    });
-
-    test.describe('when receiving new suggestions without changing the by default auto-selected suggestion', () => {
-      test('should auto-select the suggestion with the highest confidence from the newly received suggestions', async ({
-        caseClassification,
-        caseAssist,
-      }) => {
-        const firstAutomaticallySelectedSuggestionIndex = 0;
-        await expect(caseClassification.selectedSuggestion).toHaveValue(
-          caseClassificationSuggestions[
-            firstAutomaticallySelectedSuggestionIndex
-          ].value
-        );
-
-        const secondAutomaticallySelectedSuggestionIndex = 1;
-
-        caseClassification.mockCaseClassification(coveoDefaultField, [
-          caseClassificationSuggestions[
-            secondAutomaticallySelectedSuggestionIndex
-          ],
-        ]);
-        const caseClassificationsResponsePromise =
-          caseAssist.waitForCaseClassificationsResponse();
-        await caseAssist.fetchClassifications();
-        await caseClassificationsResponsePromise;
-        await expect(caseClassification.selectedSuggestion).toHaveValue(
-          caseClassificationSuggestions[
-            secondAutomaticallySelectedSuggestionIndex
-          ].value
-        );
-      });
-    });
-  });
-});