@coveo/quantic 3.16.0 → 3.16.1-pre.9c01cf606f

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__/facetDependenciesUtils.test.js

@@ -1,92 +0,0 @@
-import {generateFacetDependencyConditions} from 'c/quanticUtils';
-
-describe('facet dependencies utils', () => {
-  describe('generateFacetDependencyConditions', () => {
-    test('throws error when depending on multiple facets', () => {
-      expect(() =>
-        generateFacetDependencyConditions({facet1: 'value1', facet2: 'value2'})
-      ).toThrow("Depending on multiple facets isn't supported");
-    });
-
-    test('returns an array with a single GenericCondition', () => {
-      const dependsOn = {facet1: 'value1'};
-      const result = generateFacetDependencyConditions(dependsOn);
-
-      expect(result).toHaveLength(1);
-      expect(result[0]).toEqual(
-        expect.objectContaining({
-          parentFacetId: 'facet1',
-          condition: expect.any(Function),
-        })
-      );
-    });
-
-    test('condition function returns true when expected value matches SimpleFacetValue', () => {
-      const dependsOn = {facet1: 'value1'};
-      const result = generateFacetDependencyConditions(dependsOn);
-      const conditionFn = result[0].condition;
-
-      const values = [{value: 'value1', state: 'selected'}];
-      expect(conditionFn(values)).toBe(true);
-    });
-
-    test('condition function returns false when expected value does not match SimpleFacetValue', () => {
-      const dependsOn = {facet1: 'value1'};
-      const result = generateFacetDependencyConditions(dependsOn);
-      const conditionFn = result[0].condition;
-
-      const values = [{value: 'otherValue', state: 'selected'}];
-      expect(conditionFn(values)).toBe(false);
-    });
-
-    test('condition function returns true when expected value matches selected CategoryFacetValue', () => {
-      const dependsOn = {facet1: 'categoryValue'};
-      const result = generateFacetDependencyConditions(dependsOn);
-      const conditionFn = result[0].condition;
-
-      const values = [
-        {
-          value: 'parent',
-          state: 'not-selected',
-          children: [{value: 'categoryValue', state: 'selected', children: []}],
-        },
-      ];
-
-      expect(conditionFn(values)).toBe(true);
-    });
-
-    test('condition function returns false when CategoryFacetValue does not contain expected value', () => {
-      const dependsOn = {facet1: 'nonMatchingValue'};
-      const result = generateFacetDependencyConditions(dependsOn);
-      const conditionFn = result[0].condition;
-
-      const values = [
-        {
-          value: 'parent',
-          state: 'not-selected',
-          children: [{value: 'categoryValue', state: 'selected', children: []}],
-        },
-      ];
-
-      expect(conditionFn(values)).toBe(false);
-    });
-
-    test('condition function returns false when CategoryFacetValue is not selected', () => {
-      const dependsOn = {facet1: 'categoryValue'};
-      const result = generateFacetDependencyConditions(dependsOn);
-      const conditionFn = result[0].condition;
-
-      const values = [
-        {
-          value: 'parent',
-          state: 'not-selected',
-          children: [
-            {value: 'categoryValue', state: 'not-selected', children: []},
-          ],
-        },
-      ];
-
-      expect(conditionFn(values)).toBe(false);
-    });
-  });
-});

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

@@ -1,71 +0,0 @@
-// This is the same js file as what we load inside the LWC via a static resource.
-import {transformMarkdownToHtml} from 'c/quanticUtils';
-import {marked} from '../../../../../../../../node_modules/marked/lib/marked.cjs';
-
-const removeLineBreaks = (text) => text.replace(/\n/g, '');
-
-describe('c/markdownUtils', () => {
-  describe('transformMarkdownToHtml', () => {
-    it('should transform markdown text to HTML', () => {
-      const text = 'Hello, world!';
-      const result = transformMarkdownToHtml(text, marked);
-      expect(removeLineBreaks(result)).toEqual('<p>Hello, world!</p>');
-    });
-
-    it('should transform markdown code to HTML <pre><code>', () => {
-      const text = '```javascript\nconst foo = "bar";\n```';
-      const result = transformMarkdownToHtml(text, marked);
-      expect(removeLineBreaks(result)).toEqual(
-        '<pre><code>const foo = &quot;bar&quot;;</code></pre>'
-      );
-    });
-
-    it('should transform markdown heading to HTML <div> with data-level="answer-heading-${level}"', () => {
-      const text = '# Hello, world!';
-      const result = transformMarkdownToHtml(text, marked);
-      expect(removeLineBreaks(result)).toEqual(
-        '<div data-level="answer-heading-1" aria-label="Hello, world!">Hello, world!</div>'
-      );
-    });
-
-    it('should transform markdown heading with formatting to HTML <div>', () => {
-      const text = '# **bold** and *emphasized* title';
-      const result = transformMarkdownToHtml(text, marked);
-      expect(removeLineBreaks(result)).toEqual(
-        '<div data-level="answer-heading-1" aria-label="bold and emphasized title"><strong>bold</strong> and <em>emphasized</em> title</div>'
-      );
-    });
-
-    it('should transform markdown list item to HTML <li>', () => {
-      const text = '- Hello, world!';
-      const result = transformMarkdownToHtml(text, marked);
-      expect(removeLineBreaks(result)).toEqual(
-        '<ul><li>Hello, world!</li></ul>'
-      );
-    });
-
-    it('should transform markdown table to HTML <div class="scrollable-table">', () => {
-      const text = '| Header |\n| ------ |\n| Cell   |';
-      const result = transformMarkdownToHtml(text, marked);
-      expect(removeLineBreaks(result)).toEqual(
-        '<div class="scrollable-table"><table><thead><tr><th>Header</th></tr></thead><tbody><tr><td>Cell</td></tr></tbody></table></div>'
-      );
-    });
-
-    it('should complete unclosed inline elements such as bold, italic, and code', () => {
-      const textBold = '**bold';
-      const resultBold = transformMarkdownToHtml(textBold, marked);
-      expect(removeLineBreaks(resultBold)).toEqual(
-        '<p><strong>bold</strong></p>'
-      );
-
-      const textItalic = '*italic';
-      const resultItalic = transformMarkdownToHtml(textItalic, marked);
-      expect(removeLineBreaks(resultItalic)).toEqual('<p><em>italic</em></p>');
-
-      const textCode = '`code';
-      const resultCode = transformMarkdownToHtml(textCode, marked);
-      expect(removeLineBreaks(resultCode)).toEqual('<p><code>code</code></p>');
-    });
-  });
-});