@coveo/quantic 3.44.1 → 3.44.2

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

@@ -1,229 +0,0 @@
-/* eslint-disable no-import-assign */
-// @ts-ignore
-import QuanticUserActionsToggle from 'c/quanticUserActionsToggle';
-// @ts-ignore
-import {createElement} from 'lwc';
-import * as mockHeadlessLoader from 'c/quanticHeadlessLoader';
-
-jest.mock('c/quanticHeadlessLoader');
-
-const userActionsIcon = 'utility:clock';
-const userActionsLabel = 'User actions';
-jest.mock(
-  '@salesforce/label/c.quantic_UserActions',
-  () => ({default: userActionsLabel}),
-  {
-    virtual: true,
-  }
-);
-
-const functionsMocks = {
-  buildUserActions: jest.fn(() => ({
-    logOpenUserActions: functionsMocks.logOpenUserActions,
-  })),
-  logOpenUserActions: jest.fn(() => {}),
-};
-
-const selectors = {
-  userActionsToggleButton: '[data-test="user-actions-toggle-button"]',
-  userActionsToggleButtonIcon:
-    '[data-test="user-actions-toggle-button"] lightning-icon',
-  userActionsTimeline:
-    'c-quantic-modal [slot="content"] c-quantic-user-actions-timeline',
-  modalHeaderIcon: 'c-quantic-modal [slot="header"] lightning-icon',
-  modalHeaderLabel:
-    'c-quantic-modal [slot="header"] [data-test="user-actions-modal-label"]',
-  initializationError: 'c-quantic-component-error',
-};
-
-const exampleTicketCreationDateTime = '2024-01-01T00:00:00Z';
-const exampleExcludedCustomActions = ['dummyEvent'];
-const exampleUserId = 'someone@company.com';
-const exampleEngineId = 'exampleEngineId';
-const exampleEngine = {
-  id: exampleEngineId,
-};
-
-const defaultOptions = {
-  engineId: exampleEngineId,
-  ticketCreationDateTime: exampleTicketCreationDateTime,
-  excludedCustomActions: exampleExcludedCustomActions,
-  userId: exampleUserId,
-};
-
-function createTestComponent(options = defaultOptions) {
-  prepareHeadlessState();
-
-  const element = createElement('c-quantic-user-actions-toggle', {
-    is: QuanticUserActionsToggle,
-  });
-  for (const [key, value] of Object.entries(options)) {
-    element[key] = value;
-  }
-
-  document.body.appendChild(element);
-  return element;
-}
-
-function prepareHeadlessState() {
-  // @ts-ignore
-  mockHeadlessLoader.getHeadlessBundle = () => {
-    return {
-      buildUserActions: functionsMocks.buildUserActions,
-    };
-  };
-}
-
-// Helper function to wait until the microtask queue is empty.
-function flushPromises() {
-  // eslint-disable-next-line @lwc/lwc/no-async-operation
-  return new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-let isInitialized = false;
-
-function mockSuccessfulHeadlessInitialization() {
-  // @ts-ignore
-  mockHeadlessLoader.initializeWithHeadless = (element, _, initialize) => {
-    if (element instanceof QuanticUserActionsToggle && !isInitialized) {
-      isInitialized = true;
-      initialize(exampleEngine);
-    }
-  };
-}
-
-function mockErroneousHeadlessInitialization() {
-  // @ts-ignore
-  mockHeadlessLoader.initializeWithHeadless = (element) => {
-    if (element instanceof QuanticUserActionsToggle) {
-      element.setInitializationError();
-    }
-  };
-}
-
-function cleanup() {
-  // The jsdom instance is shared across test cases in a single file so reset the DOM
-  while (document.body.firstChild) {
-    document.body.removeChild(document.body.firstChild);
-  }
-  jest.clearAllMocks();
-  isInitialized = false;
-}
-
-describe('c-quantic-user-actions-toggle', () => {
-  beforeAll(() => {
-    mockSuccessfulHeadlessInitialization();
-  });
-
-  afterEach(() => {
-    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();
-
-    const userActionsToggleButton = element.shadowRoot.querySelector(
-      selectors.userActionsToggleButton
-    );
-    const userActionsToggleButtonIcon = element.shadowRoot.querySelector(
-      selectors.userActionsToggleButtonIcon
-    );
-
-    expect(userActionsToggleButton).not.toBeNull();
-    expect(userActionsToggleButton.title).toBe(userActionsLabel);
-    expect(userActionsToggleButtonIcon.iconName).toBe(userActionsIcon);
-  });
-
-  it('should log analytics when the user action modal is opened', async () => {
-    const element = createTestComponent();
-    await flushPromises();
-
-    const userActionsToggleButton = element.shadowRoot.querySelector(
-      selectors.userActionsToggleButton
-    );
-
-    expect(userActionsToggleButton).not.toBeNull();
-    await userActionsToggleButton.click();
-    await flushPromises();
-
-    expect(functionsMocks.logOpenUserActions).toHaveBeenCalledTimes(1);
-  });
-
-  it('should properly display the user actions modal header', async () => {
-    const element = createTestComponent();
-    await flushPromises();
-
-    const modalHeaderIcon = element.shadowRoot.querySelector(
-      selectors.modalHeaderIcon
-    );
-    const modalHeaderLabel = element.shadowRoot.querySelector(
-      selectors.modalHeaderLabel
-    );
-
-    expect(modalHeaderIcon).not.toBeNull();
-    expect(modalHeaderLabel).not.toBeNull();
-
-    expect(modalHeaderIcon.iconName).toBe(userActionsIcon);
-    expect(modalHeaderIcon.title).toBe(userActionsLabel);
-    expect(modalHeaderLabel.textContent).toBe(userActionsLabel);
-  });
-
-  it('should properly display the user actions timeline inside the modal', async () => {
-    const element = createTestComponent();
-    await flushPromises();
-
-    const userActionsTimeline = element.shadowRoot.querySelector(
-      selectors.userActionsTimeline
-    );
-
-    expect(userActionsTimeline).not.toBeNull();
-    expect(userActionsTimeline.engineId).toBe(exampleEngineId);
-    expect(userActionsTimeline.userId).toBe(exampleUserId);
-    expect(userActionsTimeline.ticketCreationDateTime).toBe(
-      exampleTicketCreationDateTime
-    );
-    expect(userActionsTimeline.excludedCustomActions).toEqual(
-      exampleExcludedCustomActions
-    );
-  });
-
-  describe('when an initialization error occurs', () => {
-    beforeEach(() => {
-      mockErroneousHeadlessInitialization();
-    });
-
-    afterAll(() => {
-      mockSuccessfulHeadlessInitialization();
-    });
-
-    it('should display the initialization error component', async () => {
-      const element = createTestComponent();
-      await flushPromises();
-
-      const initializationError = element.shadowRoot.querySelector(
-        selectors.initializationError
-      );
-
-      expect(initializationError).not.toBeNull();
-    });
-  });
-});

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

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

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

@@ -1,71 +0,0 @@
-import type {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

@@ -1,39 +0,0 @@
-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/lwc/quanticUtils/__tests__/accessibilityUtils.test.js

@@ -1,214 +0,0 @@
-import {
-  AriaLiveRegion,
-  isFocusable,
-  getFirstFocusableElement,
-  getLastFocusableElement,
-  isCustomElement,
-  isParentOf,
-} from 'c/quanticUtils';
-
-describe('accessibilityUtils', () => {
-  describe('AriaLiveRegion', () => {
-    let elem;
-
-    beforeEach(() => {
-      elem = {dispatchEvent: jest.fn()};
-    });
-
-    it('should dispatch a register region event on creation', () => {
-      AriaLiveRegion('test-region', elem);
-      expect(elem.dispatchEvent).toHaveBeenCalledTimes(1);
-      const event = elem.dispatchEvent.mock.calls[0][0];
-      expect(event.type).toBe('quantic__registerregion');
-      expect(event.detail).toEqual({
-        regionName: 'test-region',
-        assertive: false,
-      });
-    });
-
-    it('should dispatch a register region event with assertive flag', () => {
-      AriaLiveRegion('test-region', elem, true);
-      const event = elem.dispatchEvent.mock.calls[0][0];
-      expect(event.detail.assertive).toBe(true);
-    });
-
-    it('should dispatch an aria live message event when dispatchMessage is called', () => {
-      const region = AriaLiveRegion('test-region', elem);
-      region.dispatchMessage('hello');
-      expect(elem.dispatchEvent).toHaveBeenCalledTimes(2);
-      const event = elem.dispatchEvent.mock.calls[1][0];
-      expect(event.type).toBe('quantic__arialivemessage');
-      expect(event.detail).toEqual({
-        regionName: 'test-region',
-        assertive: false,
-        message: 'hello',
-      });
-    });
-  });
-
-  describe('isFocusable', () => {
-    function createElement(tag, attrs = {}) {
-      const el = document.createElement(tag);
-      Object.entries(attrs).forEach(([k, v]) => el.setAttribute(k, v));
-      return el;
-    }
-
-    it('should return true for a button', () => {
-      expect(isFocusable(createElement('button'))).toBe(true);
-    });
-
-    it('should return false for a disabled button', () => {
-      expect(isFocusable(createElement('button', {disabled: ''}))).toBe(false);
-    });
-
-    it('should return true for an anchor with href', () => {
-      expect(isFocusable(createElement('a', {href: '#'}))).toBe(true);
-    });
-
-    it('should return false for an anchor without href', () => {
-      expect(isFocusable(createElement('a'))).toBe(false);
-    });
-
-    it('should return true for an input', () => {
-      expect(isFocusable(createElement('input'))).toBe(true);
-    });
-
-    it('should return false for a disabled input', () => {
-      expect(isFocusable(createElement('input', {disabled: ''}))).toBe(false);
-    });
-
-    it('should return true for an element with tabindex >= 0', () => {
-      expect(isFocusable(createElement('div', {tabindex: '0'}))).toBe(true);
-    });
-
-    it('should return false for an element with tabindex -1', () => {
-      expect(isFocusable(createElement('div', {tabindex: '-1'}))).toBe(false);
-    });
-
-    it('should return true for a contentEditable element', () => {
-      expect(isFocusable(createElement('div', {contentEditable: 'true'}))).toBe(
-        true
-      );
-    });
-
-    it('should return false for a plain div', () => {
-      expect(isFocusable(createElement('div'))).toBe(false);
-    });
-
-    it('should return true for an iframe', () => {
-      expect(isFocusable(createElement('iframe'))).toBe(true);
-    });
-
-    it('should return true for a select', () => {
-      expect(isFocusable(createElement('select'))).toBe(true);
-    });
-
-    it('should return true for a textarea', () => {
-      expect(isFocusable(createElement('textarea'))).toBe(true);
-    });
-  });
-
-  describe('isCustomElement', () => {
-    it('should return true for elements with a hyphen in the tag name', () => {
-      const el = document.createElement('my-component');
-      expect(isCustomElement(el)).toBe(true);
-    });
-
-    it('should return false for standard elements', () => {
-      const el = document.createElement('div');
-      expect(isCustomElement(el)).toBe(false);
-    });
-
-    it('should return false for null', () => {
-      expect(isCustomElement(null)).toBe(false);
-    });
-  });
-
-  describe('getFirstFocusableElement', () => {
-    it('should return null for null input', () => {
-      expect(getFirstFocusableElement(null)).toBeNull();
-    });
-
-    it('should return the element itself if it is focusable and has no focusable children', () => {
-      const btn = document.createElement('button');
-      expect(getFirstFocusableElement(btn)).toBe(btn);
-    });
-
-    it('should return the first focusable child', () => {
-      const div = document.createElement('div');
-      const span = document.createElement('span');
-      const btn1 = document.createElement('button');
-      const btn2 = document.createElement('button');
-      div.appendChild(span);
-      div.appendChild(btn1);
-      div.appendChild(btn2);
-      expect(getFirstFocusableElement(div)).toBe(btn1);
-    });
-
-    it('should return null for a custom element without data-focusable', () => {
-      const el = document.createElement('my-component');
-      expect(getFirstFocusableElement(el)).toBeNull();
-    });
-
-    it('should return the custom element if data-focusable is true', () => {
-      const el = document.createElement('my-component');
-      el.dataset.focusable = 'true';
-      expect(getFirstFocusableElement(el)).toBe(el);
-    });
-
-    it('should return null for a text node', () => {
-      const text = document.createTextNode('hello');
-      expect(getFirstFocusableElement(text)).toBeNull();
-    });
-  });
-
-  describe('getLastFocusableElement', () => {
-    it('should return null for null input', () => {
-      expect(getLastFocusableElement(null)).toBeNull();
-    });
-
-    it('should return the last focusable child', () => {
-      const div = document.createElement('div');
-      const btn1 = document.createElement('button');
-      const btn2 = document.createElement('button');
-      div.appendChild(btn1);
-      div.appendChild(btn2);
-      expect(getLastFocusableElement(div)).toBe(btn2);
-    });
-
-    it('should return the element itself if it is focusable and has no focusable children', () => {
-      const input = document.createElement('input');
-      expect(getLastFocusableElement(input)).toBe(input);
-    });
-  });
-
-  describe('isParentOf', () => {
-    it('should return false for null', () => {
-      expect(isParentOf(null, 'MY-COMPONENT')).toBe(false);
-    });
-
-    it('should return true if the element itself matches the target tag', () => {
-      const el = document.createElement('my-component');
-      expect(isParentOf(el, 'MY-COMPONENT')).toBe(true);
-    });
-
-    it('should return true if a descendant matches the target tag', () => {
-      const wrapper = document.createElement('div');
-      const child = document.createElement('my-component');
-      wrapper.appendChild(child);
-      expect(isParentOf(wrapper, 'MY-COMPONENT')).toBe(true);
-    });
-
-    it('should return false if no descendant matches', () => {
-      const wrapper = document.createElement('div');
-      const child = document.createElement('span');
-      wrapper.appendChild(child);
-      expect(isParentOf(wrapper, 'MY-COMPONENT')).toBe(false);
-    });
-
-    it('should return false for a text node', () => {
-      const text = document.createTextNode('hello');
-      expect(isParentOf(text, 'MY-COMPONENT')).toBe(false);
-    });
-  });
-});