@coveo/quantic 3.33.0 → 3.33.2

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

@@ -0,0 +1,81 @@
+import type {Locator, Page, Request} from '@playwright/test';
+import {isUaClickEvent} from '../../../../../../playwright/utils/requests';
+
+export class FoldedResultListObject {
+  constructor(public page: Page) {
+    this.page = page;
+  }
+
+  get resultList(): Locator {
+    return this.page.locator('c-quantic-folded-result-list');
+  }
+
+  get resultLinks(): Locator {
+    return this.resultList.locator('c-quantic-result-link a');
+  }
+
+  getResultLink(index: number): Locator {
+    return this.resultLinks.nth(index);
+  }
+
+  async preventNavigationFromResultLink(index: number): Promise<void> {
+    return this.getResultLink(index).evaluate((el) => {
+      el?.addEventListener?.('click', (event) => {
+        event.preventDefault();
+      });
+    });
+  }
+
+  async clickResultLink(index: number): Promise<void> {
+    await this.resultLinks.nth(index).click();
+  }
+
+  async captureClickEventWorkaround(): Promise<void> {
+    // Hack(?) to have the request payload in the analytics click event.
+    // Without this the payload is not available in the request.
+    return this.page.route('*analytics*', (route) => {
+      route.continue();
+    });
+  }
+
+  async waitForResultLinkClickUaAnalytics(
+    expectedFields: Record<string, any>
+  ): Promise<Request> {
+    return this.waitForClickUaAnalytics(
+      'documentOpen',
+      (data: Record<string, any>) => {
+        const matchesExpectedFields = Object.keys(expectedFields).every(
+          (key) => data?.[key] === expectedFields[key]
+        );
+        return matchesExpectedFields;
+      }
+    );
+  }
+
+  async waitForClickUaAnalytics(
+    actionCause: string,
+    fieldsMatcher?: Function
+  ): Promise<Request> {
+    const uaRequest = this.page.waitForRequest((request) => {
+      if (isUaClickEvent(request)) {
+        const requestBody = request.postDataJSON?.();
+        const requestData = JSON.parse(requestBody.clickEvent);
+
+        const expectedFields: Record<string, any> = {
+          actionCause,
+        };
+
+        const matchesExpectedFields = Object.keys(expectedFields).every(
+          (key) => requestData?.[key] === expectedFields[key]
+        );
+
+        return (
+          matchesExpectedFields &&
+          (fieldsMatcher ? fieldsMatcher(requestData, requestData) : true)
+        );
+      }
+      return false;
+    });
+    return uaRequest;
+  }
+}

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

@@ -0,0 +1,69 @@
+/* eslint-disable @lwc/lwc/no-document-query */
+import {
+  useCaseEnum,
+  useCaseTestCases,
+} from '../../../../../../playwright/utils/useCase';
+import {testInsight, testSearch, expect} from './fixture';
+
+const fixtures = {
+  search: testSearch,
+  insight: testInsight,
+};
+
+const testFieldsToInclude = 'foo,bar,baz';
+const SEARCH_ORIGINCONTEXT = 'Search';
+const INSIGHT_ORIGINCONTEXT = 'InsightPanel';
+
+useCaseTestCases.forEach((useCase) => {
+  let test = fixtures[useCase.value];
+
+  test.describe(`quantic folded result list ${useCase.label}`, () => {
+    test.describe('when performing a search', () => {
+      test.use({
+        options: {
+          fieldsToInclude: testFieldsToInclude,
+        },
+      });
+      test('should send the added fieldsToInclude in the Search API request', async ({
+        resultList,
+        search,
+      }) => {
+        const expectedFieldsToInclude = testFieldsToInclude.split(',');
+        const searchRequestPromise = search.waitForSearchRequest();
+        await search.performSearch();
+        const requestBody = (await searchRequestPromise).postDataJSON();
+        expect(requestBody?.fieldsToInclude).toBeDefined();
+        expect(requestBody).toEqual(
+          expect.objectContaining({
+            fieldsToInclude: expect.arrayContaining(expectedFieldsToInclude),
+          })
+        );
+        await expect(resultList.resultList).toBeVisible();
+      });
+    });
+
+    test.describe('analytics request', () => {
+      test('when clicking a result link should send the expected click event with the correct data', async ({
+        resultList,
+      }) => {
+        await resultList.captureClickEventWorkaround();
+
+        const expectedOriginContext =
+          useCase.value === useCaseEnum.insight
+            ? INSIGHT_ORIGINCONTEXT
+            : SEARCH_ORIGINCONTEXT;
+        const firstResultLink = resultList.getResultLink(0);
+        const firstResultLinkHref = await firstResultLink.getAttribute('href');
+        await resultList.preventNavigationFromResultLink(0);
+
+        const expectedUaRequestPromise =
+          resultList.waitForResultLinkClickUaAnalytics({
+            documentUrl: firstResultLinkHref,
+            originContext: expectedOriginContext,
+          });
+        await resultList.clickResultLink(0);
+        await expectedUaRequestPromise;
+      });
+    });
+  });
+});