@coveo/quantic 3.33.0 → 3.33.2

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

@@ -0,0 +1,80 @@
+import {DidYouMeanObject} from './pageObject';
+import {quanticBase} from '../../../../../../playwright/fixtures/baseFixture';
+import {
+  insightSearchRequestRegex,
+  searchRequestRegex,
+} from '../../../../../../playwright/utils/requests';
+import {InsightSetupObject} from '../../../../../../playwright/page-object/insightSetupObject';
+import {
+  DidYouMeanLegacyData,
+  QueryTriggerData,
+  SearchObjectWithDidYouMeanOrTrigger,
+} from '../../../../../../playwright/page-object/searchObjectWithDidYouMean';
+import mockData from './data';
+import {useCaseEnum} from '../../../../../../playwright/utils/useCase';
+
+const pageUrl = 's/quantic-did-you-mean';
+
+interface DidYouMeanOptions {
+  disableQueryAutoCorrection: boolean;
+  queryCorrectionMode: string;
+}
+
+type QuanticDidYouMeanE2ESearchFixtures = {
+  didYouMeanData?: DidYouMeanLegacyData;
+  queryTriggerData?: QueryTriggerData;
+  didYouMean: DidYouMeanObject;
+  search: SearchObjectWithDidYouMeanOrTrigger;
+  options: Partial<DidYouMeanOptions>;
+};
+
+type QuanticDidYouMeanE2EInsightFixtures =
+  QuanticDidYouMeanE2ESearchFixtures & {
+    insightSetup: InsightSetupObject;
+  };
+
+export const testSearch =
+  quanticBase.extend<QuanticDidYouMeanE2ESearchFixtures>({
+    didYouMeanData: mockData.didYouMeanData,
+    queryTriggerData: mockData.queryTriggerData,
+    options: {},
+    search: async ({page}, use) => {
+      await use(
+        new SearchObjectWithDidYouMeanOrTrigger(page, searchRequestRegex)
+      );
+    },
+    didYouMean: async ({page, options, configuration, search}, use) => {
+      await page.goto(pageUrl);
+      configuration.configure(options);
+      await search.waitForSearchResponse();
+      await use(new DidYouMeanObject(page));
+    },
+  });
+
+export const testInsight =
+  quanticBase.extend<QuanticDidYouMeanE2EInsightFixtures>({
+    didYouMeanData: mockData.didYouMeanData,
+    queryTriggerData: mockData.queryTriggerData,
+    options: {},
+    search: async ({page}, use) => {
+      await use(
+        new SearchObjectWithDidYouMeanOrTrigger(page, insightSearchRequestRegex)
+      );
+    },
+    insightSetup: async ({page}, use) => {
+      await use(new InsightSetupObject(page));
+    },
+    didYouMean: async (
+      {page, options, search, configuration, insightSetup},
+      use
+    ) => {
+      await page.goto(pageUrl);
+      configuration.configure({...options, useCase: useCaseEnum.insight});
+      await insightSetup.waitForInsightInterfaceInitialization();
+      await search.performSearch();
+      await search.waitForSearchResponse();
+      await use(new DidYouMeanObject(page));
+    },
+  });
+
+export {expect} from '@playwright/test';

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

@@ -0,0 +1,173 @@
+import type {Locator, Page, Request} from '@playwright/test';
+import {
+  isUaSearchEvent,
+  isSearchRequest,
+  isUaCustomEvent,
+} from '../../../../../../playwright/utils/requests';
+
+export class DidYouMeanObject {
+  constructor(public page: Page) {
+    this.page = page;
+  }
+
+  get didYouMeanNoResultsLabel(): Locator {
+    return this.page.getByTestId('no-result-label');
+  }
+
+  get didYouMeanAutomaticQueryCorrectionLabel(): Locator {
+    return this.page.getByTestId('automatic-query-correction-label');
+  }
+
+  get didYouMeanManualCorrectionLabel(): Locator {
+    return this.page.getByTestId('did-you-mean-label');
+  }
+
+  get applyCorrectionButton(): Locator {
+    return this.page.getByTestId('apply-correction-button');
+  }
+
+  get showingResultsForLabel(): Locator {
+    return this.page.getByTestId('showing-results-for-label');
+  }
+
+  get searchInsteadForLabel(): Locator {
+    return this.page.getByTestId('search-instead-for-label');
+  }
+
+  get undoButton(): Locator {
+    return this.page.getByTestId('undo-button');
+  }
+
+  async applyCorrection(): Promise<void> {
+    await this.applyCorrectionButton.click();
+  }
+
+  async undo(): Promise<void> {
+    await this.undoButton.click();
+  }
+
+  async waitForDidYouMeanSearchRequest(
+    expectedQuery: string
+  ): Promise<Request> {
+    const searchRequest = this.page.waitForRequest((request) => {
+      if (isSearchRequest(request)) {
+        const requestBody = request.postDataJSON?.();
+        return (
+          requestBody &&
+          requestBody.enableDidYouMean &&
+          !!requestBody.queryCorrection &&
+          requestBody.q === expectedQuery
+        );
+      }
+      return false;
+    });
+    return searchRequest;
+  }
+
+  async waitForDidYouMeanAutomaticAnalytics(
+    expectedFields: Record<string, any>
+  ): Promise<Request> {
+    return this.waitForDidYouMeanSearchAnalytics(
+      'didyoumeanAutomatic',
+      (data: Record<string, any>) => {
+        return Object.keys(expectedFields).every(
+          (key) => data?.[key] === expectedFields[key]
+        );
+      }
+    );
+  }
+
+  async waitForDidYouMeanManualAnalytics(
+    expectedFields: Record<string, any>
+  ): Promise<Request> {
+    return this.waitForDidYouMeanSearchAnalytics(
+      'didyoumeanClick',
+      (data: Record<string, any>) => {
+        return Object.keys(expectedFields).every(
+          (key) => data?.[key] === expectedFields[key]
+        );
+      }
+    );
+  }
+
+  async waitForQueryTriggerCustomAnalytics(
+    expectedFields: Record<string, any>
+  ): Promise<Request> {
+    return this.waitForCustomUARequest(
+      'queryPipelineTriggers',
+      'query',
+      (data: Record<string, any>) => {
+        return Object.keys(expectedFields).every(
+          (key) => data?.[key] === expectedFields[key]
+        );
+      }
+    );
+  }
+
+  async waitForUndoQueryAnalytics(
+    expectedFields: Record<string, any>
+  ): Promise<Request> {
+    return this.waitForDidYouMeanSearchAnalytics(
+      'undoQuery',
+      (data: Record<string, any>) => {
+        return Object.keys(expectedFields).every(
+          (key) => data?.[key] === expectedFields[key]
+        );
+      }
+    );
+  }
+
+  async waitForDidYouMeanSearchAnalytics(
+    actionCause: string,
+    customChecker?: Function
+  ): Promise<Request> {
+    const uaRequest = this.page.waitForRequest((request) => {
+      if (isUaSearchEvent(request)) {
+        const requestBody = request.postDataJSON?.();
+
+        const expectedFields: Record<string, any> = {
+          actionCause: actionCause,
+        };
+
+        const matchesExpectedFields = Object.keys(expectedFields).every(
+          (key) => requestBody?.[key] === expectedFields[key]
+        );
+
+        return (
+          matchesExpectedFields &&
+          (customChecker ? customChecker(requestBody) : true)
+        );
+      }
+      return false;
+    });
+    return uaRequest;
+  }
+
+  async waitForCustomUARequest(
+    eventType: string,
+    eventValue: string,
+    customChecker?: Function
+  ): Promise<Request> {
+    const uaRequest = this.page.waitForRequest((request) => {
+      if (isUaCustomEvent(request)) {
+        const requestBody = request.postDataJSON?.();
+
+        const expectedFields: Record<string, any> = {
+          eventType,
+          eventValue,
+        };
+
+        const matchesExpectedFields = Object.keys(expectedFields).every(
+          (key) => requestBody?.[key] === expectedFields[key]
+        );
+
+        return (
+          matchesExpectedFields &&
+          (customChecker ? customChecker(requestBody) : true)
+        );
+      }
+      return false;
+    });
+    return uaRequest;
+  }
+}

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

@@ -0,0 +1,219 @@
+import {useCaseTestCases} from '../../../../../../playwright/utils/useCase';
+import {testInsight, testSearch, expect} from './fixture';
+import mockData from './data';
+
+const {
+  originalQuery: expectedOriginalQuery,
+  correctedQuery: expectedCorrectedQuery,
+  didYouMeanData,
+  didYouMeanNextData,
+  queryTriggerData,
+  triggeredQuery: expectedTriggeredQuery,
+} = mockData;
+
+const fixtures = {
+  search: testSearch,
+  insight: testInsight,
+};
+
+useCaseTestCases.forEach((useCase) => {
+  let test = fixtures[useCase.value];
+
+  test.describe(`quantic did you mean ${useCase.label}`, () => {
+    test.describe('when we have an automatic did you mean query correction', () => {
+      test.describe('with queryCorrectionMode set to "legacy"', () => {
+        test.use({
+          didYouMeanData,
+          options: {
+            disableQueryAutoCorrection: false,
+            queryCorrectionMode: 'legacy',
+          },
+        });
+        test('should display the didYouMean component and send the analytics', async ({
+          didYouMean,
+          search,
+        }) => {
+          await search.mockSearchWithDidYouMeanLegacyResponse(didYouMeanData);
+          const automaticallyCorrectSearchPromise =
+            search.waitForSearchResponse();
+          const expectedUaRequestPromise =
+            didYouMean.waitForDidYouMeanAutomaticAnalytics({
+              queryText: expectedCorrectedQuery,
+            });
+          await search.triggerSearchWithInput(expectedOriginalQuery);
+          await expectedUaRequestPromise;
+          await automaticallyCorrectSearchPromise;
+
+          await expect(didYouMean.didYouMeanNoResultsLabel).toBeVisible();
+          await expect(didYouMean.didYouMeanNoResultsLabel).toContainText(
+            expectedOriginalQuery
+          );
+          await expect(
+            didYouMean.didYouMeanAutomaticQueryCorrectionLabel
+          ).toBeVisible();
+          await expect(
+            didYouMean.didYouMeanAutomaticQueryCorrectionLabel
+          ).toContainText(expectedCorrectedQuery);
+        });
+      });
+
+      test.describe('with queryCorrectionMode set to "next"', () => {
+        test.use({
+          didYouMeanData,
+          options: {
+            disableQueryAutoCorrection: false,
+            queryCorrectionMode: 'next',
+          },
+        });
+        test('should display the didYouMean component and send the analytics', async ({
+          didYouMean,
+          search,
+        }) => {
+          await search.mockSearchWithDidYouMeanNextResponse(didYouMeanNextData);
+          const expectedUaRequestPromise =
+            didYouMean.waitForDidYouMeanAutomaticAnalytics({
+              queryText: expectedCorrectedQuery,
+            });
+          await search.triggerSearchWithInput(expectedOriginalQuery);
+          await expectedUaRequestPromise;
+
+          await expect(didYouMean.didYouMeanNoResultsLabel).toBeVisible();
+          await expect(didYouMean.didYouMeanNoResultsLabel).toContainText(
+            expectedOriginalQuery
+          );
+          await expect(
+            didYouMean.didYouMeanAutomaticQueryCorrectionLabel
+          ).toBeVisible();
+          await expect(
+            didYouMean.didYouMeanAutomaticQueryCorrectionLabel
+          ).toContainText(expectedCorrectedQuery);
+        });
+      });
+    });
+
+    test.describe("when we don't have an automatic did you mean query correction", () => {
+      test.describe('with queryCorrectionMode set to "legacy"', () => {
+        test.use({
+          didYouMeanData,
+          options: {
+            disableQueryAutoCorrection: true,
+            queryCorrectionMode: 'legacy',
+          },
+        });
+        test('should display the didYouMean component but not correct the query', async ({
+          didYouMean,
+          search,
+        }) => {
+          await search.mockSearchWithDidYouMeanLegacyResponse(didYouMeanData);
+          await search.triggerSearchWithInput(expectedOriginalQuery);
+
+          await expect(
+            didYouMean.didYouMeanManualCorrectionLabel
+          ).toBeVisible();
+          await expect(didYouMean.applyCorrectionButton).toBeVisible();
+          await expect(didYouMean.applyCorrectionButton).toContainText(
+            expectedCorrectedQuery
+          );
+
+          const correctedSearchResponsePromise = search.waitForSearchResponse();
+          const correctedUAReponsePromise =
+            didYouMean.waitForDidYouMeanManualAnalytics({
+              queryText: expectedCorrectedQuery,
+            });
+          didYouMean.applyCorrection();
+          await correctedUAReponsePromise;
+          const searchResponse = await correctedSearchResponsePromise;
+          const correctedSearchBody = searchResponse
+            .request()
+            ?.postDataJSON?.();
+          expect(correctedSearchBody?.q).toEqual(expectedCorrectedQuery);
+        });
+      });
+
+      test.describe('with queryCorrectionMode set to "next"', () => {
+        test.use({
+          didYouMeanData,
+          options: {
+            disableQueryAutoCorrection: true,
+            queryCorrectionMode: 'next',
+          },
+        });
+        test('should display the didYouMean component and send the analytics', async ({
+          didYouMean,
+          search,
+        }) => {
+          await search.mockSearchWithDidYouMeanNextResponse(didYouMeanNextData);
+          await search.triggerSearchWithInput(expectedOriginalQuery);
+
+          await expect(
+            didYouMean.didYouMeanManualCorrectionLabel
+          ).toBeVisible();
+          await expect(didYouMean.applyCorrectionButton).toBeVisible();
+          await expect(didYouMean.applyCorrectionButton).toContainText(
+            expectedCorrectedQuery
+          );
+
+          const correctedSearchResponsePromise = search.waitForSearchResponse();
+          const correctedUAReponsePromise =
+            didYouMean.waitForDidYouMeanManualAnalytics({
+              queryText: expectedCorrectedQuery,
+            });
+          didYouMean.applyCorrection();
+          await correctedUAReponsePromise;
+          const searchResponse = await correctedSearchResponsePromise;
+          const correctedSearchBody = searchResponse
+            .request()
+            ?.postDataJSON?.();
+          expect(correctedSearchBody?.q).toEqual(expectedCorrectedQuery);
+        });
+      });
+    });
+
+    if (useCase.value === 'search') {
+      test.describe('when we have a query trigger response', () => {
+        test.use({
+          queryTriggerData,
+        });
+
+        test('should search with the triggered query instead of the original query', async ({
+          didYouMean,
+          search,
+        }) => {
+          await search.mockSearchWithQueryTriggerResponse(queryTriggerData);
+          await search.triggerSearchWithInput(expectedOriginalQuery);
+
+          await expect(didYouMean.showingResultsForLabel).toBeVisible();
+          await expect(didYouMean.showingResultsForLabel).toContainText(
+            expectedTriggeredQuery
+          );
+          await expect(didYouMean.undoButton).toBeVisible();
+          await expect(didYouMean.undoButton).toContainText(
+            expectedOriginalQuery
+          );
+        });
+
+        test('when pressing the undo button should send the correct analytics and reset the query', async ({
+          didYouMean,
+          search,
+        }) => {
+          await search.mockSearchWithQueryTriggerResponse(queryTriggerData);
+
+          const queryTriggerCustomUAPromise =
+            didYouMean.waitForQueryTriggerCustomAnalytics({});
+          await search.triggerSearchWithInput(expectedOriginalQuery);
+          await queryTriggerCustomUAPromise;
+
+          const undoSearchResponsePromise = search.waitForSearchResponse();
+          const undoUASearchEvent = didYouMean.waitForUndoQueryAnalytics({
+            queryText: expectedOriginalQuery,
+          });
+          didYouMean.undo();
+          await undoUASearchEvent;
+          const searchResponse = await undoSearchResponsePromise;
+          const searchBody = searchResponse.request()?.postDataJSON?.();
+          expect(searchBody?.q).toEqual(expectedOriginalQuery);
+        });
+      });
+    }
+  });
+});