@coveo/quantic 3.32.0 → 3.33.1

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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,152 @@
+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

@@ -0,0 +1,269 @@
+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
+        );
+      });
+    });
+  });
+});