@coveo/quantic 3.10.0-pre.faaf12d7a7 → 3.11.0

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

@@ -12,17 +12,22 @@ jest.mock('c/quanticUtils', () => ({
       DATEFACETS: 'dateFacets',
     },
   },
+  I18nUtils: {
+    format: jest.fn(),
+  },
 }));
 jest.mock('c/quanticHeadlessLoader');
 
 const selectors = {
   facetContent: '[data-test="facet-content"]',
+  componentError: 'c-quantic-component-error',
 };
 
 const exampleFacetId = 'example facet id';
+const exampleField = 'exampleField';
 const exampleFilterId = `${exampleFacetId}_input`;
 const defaultOptions = {
-  field: 'example field',
+  field: exampleField,
 };
 const timeframeFacetControllerMock = {
   subscribe: jest.fn((callback) => callback()),
@@ -31,6 +36,8 @@ const timeframeFacetControllerMock = {
     values: [],
   },
 };
+const parentFacetIdError = `The ${exampleField} c-quantic-timeframe-facet requires dependsOn.parentFacetId to be a valid string.`;
+const expectedValueError = `The ${exampleField} c-quantic-timeframe-facet requires dependsOn.expectedValue to be a valid string.`;
 
 function createTestComponent(options = defaultOptions) {
   prepareHeadlessState();
@@ -87,6 +94,21 @@ const exampleEngine = {
 };
 let isInitialized = false;
 
+function mockBueno() {
+  // @ts-ignore
+  mockHeadlessLoader.getBueno = () => {
+    // @ts-ignore
+    global.Bueno = {
+      isString: jest
+        .fn()
+        .mockImplementation(
+          (value) => Object.prototype.toString.call(value) === '[object String]'
+        ),
+    };
+    return new Promise((resolve) => resolve());
+  };
+}
+
 function mockSuccessfulHeadlessInitialization() {
   // @ts-ignore
   mockHeadlessLoader.initializeWithHeadless = (element, _, initialize) => {
@@ -109,6 +131,7 @@ function cleanup() {
 describe('c-quantic-timeframe-facet', () => {
   beforeAll(() => {
     mockSuccessfulHeadlessInitialization();
+    mockBueno();
   });
 
   afterEach(() => {
@@ -211,6 +234,89 @@ describe('c-quantic-timeframe-facet', () => {
     });
   });
 
+  describe('validation of the dependsOn property', () => {
+    let consoleError;
+    beforeAll(() => {
+      consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+    });
+    describe('when dependsOn.parentFacetId is not provided', () => {
+      it('should display the error component', async () => {
+        const invalidFacetDependency = {
+          expectedValue: 'txt',
+        };
+        const element = createTestComponent({
+          ...defaultOptions,
+          dependsOn: invalidFacetDependency,
+        });
+        await flushPromises();
+
+        const componentError = element.shadowRoot.querySelector(
+          selectors.componentError
+        );
+        const facetContent = element.shadowRoot.querySelector(
+          selectors.facetContent
+        );
+
+        expect(consoleError).toHaveBeenCalledTimes(1);
+        expect(consoleError).toHaveBeenCalledWith(parentFacetIdError);
+        expect(componentError).not.toBeNull();
+        expect(facetContent).toBeNull();
+      });
+    });
+
+    describe('when dependsOn.parentFacetId is not a string', () => {
+      it('should display the error component', async () => {
+        const invalidFacetDependency = {
+          parentFacetId: 1,
+          expectedValue: 'txt',
+        };
+        const element = createTestComponent({
+          ...defaultOptions,
+          dependsOn: invalidFacetDependency,
+        });
+        await flushPromises();
+
+        const componentError = element.shadowRoot.querySelector(
+          selectors.componentError
+        );
+        const facetContent = element.shadowRoot.querySelector(
+          selectors.facetContent
+        );
+
+        expect(consoleError).toHaveBeenCalledTimes(1);
+        expect(consoleError).toHaveBeenCalledWith(parentFacetIdError);
+        expect(componentError).not.toBeNull();
+        expect(facetContent).toBeNull();
+      });
+    });
+
+    describe('when dependsOn.expectedValue is not a string', () => {
+      it('should display the error component', async () => {
+        const invalidFacetDependency = {
+          parentFacetId: 'filetype',
+          expectedValue: 2,
+        };
+        const element = createTestComponent({
+          ...defaultOptions,
+          dependsOn: invalidFacetDependency,
+        });
+        await flushPromises();
+
+        const componentError = element.shadowRoot.querySelector(
+          selectors.componentError
+        );
+        const facetContent = element.shadowRoot.querySelector(
+          selectors.facetContent
+        );
+
+        expect(consoleError).toHaveBeenCalledTimes(1);
+        expect(consoleError).toHaveBeenCalledWith(expectedValueError);
+        expect(componentError).not.toBeNull();
+        expect(facetContent).toBeNull();
+      });
+    });
+  });
+
   describe('when the component is disconnected', () => {
     it('should make the condition manager stop watching the facet', async () => {
       const exampleFacetDependency = {

package/force-app/main/default/lwc/quanticTimeframeFacet/quanticTimeframeFacet.js

@@ -12,6 +12,7 @@ import {
   initializeWithHeadless,
   registerComponentForInit,
   registerToStore,
+  getBueno,
 } from 'c/quanticHeadlessLoader';
 import {
   DateUtils,
@@ -414,6 +415,7 @@ export default class QuanticTimeframeFacet extends LightningElement {
    * @param {SearchEngine} engine
    */
   initialize = (engine) => {
+    this.validateDependsOnProperty();
     this.headless = getHeadlessBundle(this.engineId);
     this.initializeSearchStatusController(engine);
     this.initializeFacetController(engine);
@@ -427,6 +429,26 @@ export default class QuanticTimeframeFacet extends LightningElement {
     });
   };
 
+  validateDependsOnProperty() {
+    if (this.dependsOn) {
+      getBueno(this).then(() => {
+        const {parentFacetId, expectedValue} = this.dependsOn;
+        if (!Bueno.isString(parentFacetId)) {
+          console.error(
+            `The ${this.field} ${this.template.host.localName} requires dependsOn.parentFacetId to be a valid string.`
+          );
+          this.setInitializationError();
+        }
+        if (expectedValue && !Bueno.isString(expectedValue)) {
+          console.error(
+            `The ${this.field} ${this.template.host.localName} requires dependsOn.expectedValue to be a valid string.`
+          );
+          this.setInitializationError();
+        }
+      });
+    }
+  }
+
   /**
    * @param {SearchEngine} engine
    */

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

@@ -119,6 +119,24 @@ describe('c-quantic-user-actions-toggle', () => {
     cleanup();
   });
 
+  describe('controller initialization', () => {
+    it('should build the controller with the right parameters', async () => {
+      createTestComponent();
+      await flushPromises();
+
+      expect(functionsMocks.buildUserActions).toHaveBeenCalledTimes(1);
+      expect(functionsMocks.buildUserActions).toHaveBeenCalledWith(
+        exampleEngine,
+        {
+          options: {
+            ticketCreationDate: exampleTicketCreationDateTime,
+            excludedCustomActions: exampleExcludedCustomActions,
+          },
+        }
+      );
+    });
+  });
+
   it('should display the user actions toggle button', async () => {
     const element = createTestComponent();
     await flushPromises();

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

@@ -0,0 +1,32 @@
+const followingSessionsActions = [
+  {
+    name: 'CUSTOM',
+    value:
+      '{"event_type":"example","event_value":"exampleCustomAction","origin_level_1":"default"}',
+    time: new Date('2024-09-01T15:30:00Z').valueOf(),
+  },
+];
+
+const ticketCreationSessionActions = [
+  {
+    name: 'CUSTOM',
+    value:
+      '{"event_type":"errors","event_value":"One","origin_level_1":"default","origin_level_2":"default"}',
+    time: new Date('2024-08-30T00:10:00Z').valueOf(),
+  },
+];
+
+const precedingSessionsActions = [
+  {
+    name: 'CUSTOM',
+    value:
+      '{"event_type":"example","event_value":"exampleCustomAction","origin_level_1":"default"}',
+    time: new Date('2024-08-29T15:40:00Z').valueOf(),
+  },
+];
+
+export const exampleUserActionsData = [
+  ...followingSessionsActions,
+  ...ticketCreationSessionActions,
+  ...precedingSessionsActions,
+];

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

@@ -0,0 +1,32 @@
+import {quanticBase} from '../../../../../../playwright/fixtures/baseFixture';
+import {UserActionsToggleObject} from './pageObject';
+import {exampleUserActionsData} from './data';
+
+const pageUrl = 's/quantic-user-actions-toggle';
+
+interface UserActionsToggleOptions {
+  userId: string;
+  ticketCreationDateTime: string;
+}
+type QuanticUserActionsToggleE2EFixtures = {
+  userActionsToggle: UserActionsToggleObject;
+  options: UserActionsToggleOptions;
+};
+
+export const testInsight =
+  quanticBase.extend<QuanticUserActionsToggleE2EFixtures>({
+    options: {
+      userId: 'someone@company.com',
+      ticketCreationDateTime: '2024-01-01T00:00:00Z',
+    },
+    userActionsToggle: async ({page, options, configuration}, use) => {
+      await page.goto(pageUrl);
+      configuration.configure({...options});
+      const userActionsToggleObject = new UserActionsToggleObject(page);
+      userActionsToggleObject.mockUserActions(exampleUserActionsData);
+      await userActionsToggleObject.waitForUserActionsResponse(options.userId);
+      await use(userActionsToggleObject);
+    },
+  });
+
+export {expect} from '@playwright/test';

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

@@ -0,0 +1,71 @@
+import {Locator, Page, Request, Response} from '@playwright/test';
+import {isUaCustomEvent} from '../../../../../../playwright/utils/requests';
+
+const userActionsRequestRegex =
+  /\/rest\/organizations\/.*\/machinelearning\/user\/actions$/;
+
+export class UserActionsToggleObject {
+  constructor(public page: Page) {
+    this.page = page;
+  }
+
+  get userActionsToggleButton(): Locator {
+    return this.page.getByRole('button', {name: /User actions/i});
+  }
+
+  get userActionsModal(): Locator {
+    return this.page.locator(
+      'c-quantic-user-actions-toggle > c-quantic-modal > div'
+    );
+  }
+
+  get userActionsModalCloseButton(): Locator {
+    return this.page
+      .locator('c-quantic-user-actions-toggle > c-quantic-modal')
+      .getByRole('button', {name: 'Close'});
+  }
+
+  async mockUserActions(
+    userActions: Array<{name: string; value: string; time: number}>
+  ) {
+    await this.page.route(userActionsRequestRegex, async (route) => {
+      const body = {value: userActions};
+
+      await route.fulfill({
+        body: JSON.stringify(body),
+        status: 200,
+        headers: {
+          'content-type': 'text/html',
+        },
+      });
+    });
+  }
+
+  async waitForUserActionsResponse(userId: string): Promise<Response> {
+    return this.page.waitForResponse((response) => {
+      const request = response.request();
+      if (request.url().match(userActionsRequestRegex)) {
+        const requestBody = request.postDataJSON?.();
+        return requestBody?.objectId === userId;
+      }
+      return false;
+    });
+  }
+
+  async waitForOpenUserActionsUaAnalytics(): Promise<Request> {
+    const uaRequest = this.page.waitForRequest((request) => {
+      if (isUaCustomEvent(request)) {
+        const requestBody = request.postDataJSON?.();
+        const expectedFields = {
+          eventType: 'User Actions',
+          eventValue: 'openUserActions',
+        };
+        return Object.keys(expectedFields).every(
+          (key) => requestBody?.[key] === expectedFields[key]
+        );
+      }
+      return false;
+    });
+    return uaRequest;
+  }
+}

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

@@ -0,0 +1,39 @@
+import {testInsight, expect} from './fixture';
+
+const exampleUserId = 'exampleUserId';
+const exampleTicketCreateDateTime = encodeURIComponent('2024-08-30');
+
+testInsight.use({
+  options: {
+    userId: exampleUserId,
+    ticketCreationDateTime: exampleTicketCreateDateTime,
+  },
+});
+
+testInsight.describe('quantic user actions toggle', () => {
+  testInsight.describe('when opening the user action modal', () => {
+    testInsight(
+      'should open the user actions timeline and log analytics',
+      async ({userActionsToggle}) => {
+        await expect(userActionsToggle.userActionsModal).not.toBeVisible();
+        const uaPromise = userActionsToggle.waitForOpenUserActionsUaAnalytics();
+        await userActionsToggle.userActionsToggleButton.click();
+        await expect(userActionsToggle.userActionsModal).toBeVisible();
+        await uaPromise;
+      }
+    );
+  });
+
+  testInsight.describe('when closing the user action modal', () => {
+    testInsight(
+      'should close the user actions timeline',
+      async ({userActionsToggle}) => {
+        await expect(userActionsToggle.userActionsModal).not.toBeVisible();
+        await userActionsToggle.userActionsToggleButton.click();
+        await expect(userActionsToggle.userActionsModal).toBeVisible();
+        await userActionsToggle.userActionsModalCloseButton.click();
+        await expect(userActionsToggle.userActionsModal).not.toBeVisible();
+      }
+    );
+  });
+});

package/force-app/main/default/staticresources/coveobueno/browser/bueno.js

@@ -14,7 +14,7 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */(function (g, f) {if ("object" == typeof exports && "object" == typeof module) {module.exports = f();} else if ("function" == typeof define && define.amd) {define("Bueno", [], f);} else if ("object" == typeof exports) {exports["Bueno"] = f();} else {g["Bueno"] = f();}}(typeof self !== 'undefined' ? self : typeof globalThis !== 'undefined' ? globalThis : this, () => {var exports = {};var module = { exports };
+ */(function(g,f){if(typeof exports=="object"&&typeof module<"u"){module.exports=f()}else if("function"==typeof define && define.amd){define("Bueno",f)}else {g["Bueno"]=f()}}(typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : this,function(){var exports={};var __exports=exports;var module={exports};
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -393,20 +393,5 @@ var EnumValue = class {
     return this.value.required;
   }
 };
-;if (typeof module.exports == "object" && typeof exports == "object") {
-  var __cp = (to, from, except, desc) => {
-    if ((from && typeof from === "object") || typeof from === "function") {
-      for (let key of Object.getOwnPropertyNames(from)) {
-        if (!Object.prototype.hasOwnProperty.call(to, key) && key !== except)
-        Object.defineProperty(to, key, {
-          get: () => from[key],
-          enumerable: !(desc = Object.getOwnPropertyDescriptor(from, key)) || desc.enumerable,
-        });
-      }
-    }
-    return to;
-  };
-  module.exports = __cp(module.exports, exports);
-}
-return module.exports;
-}))
+
+if(__exports != exports)module.exports = exports;return module.exports}));