@coveo/quantic 3.33.0 → 3.33.1

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

@@ -0,0 +1,229 @@
+/* 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

@@ -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 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

@@ -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/lwc/quanticUtils/__tests__/citationAnchoringUtils.test.js

@@ -0,0 +1,84 @@
+import {
+  extractTextToHighlight,
+  generateTextFragmentUrl,
+} from '../citationAnchoringUtils';
+
+describe('c/citationAnchoringUtils', () => {
+  describe('extractTextToHighlight', () => {
+    it('returns the first sentence of a passage', () => {
+      const text =
+        'This is the first sentence. This is the second sentence. This is the third sentence.';
+      const result = extractTextToHighlight(text);
+      expect(result).toBe('This is the first sentence.');
+    });
+
+    it('returns first full sentence even when passages begin in the middle of a sentence', () => {
+      const text =
+        'middle of a sentence. This is the first full sentence. This is the second sentence.';
+      const result = extractTextToHighlight(text);
+      expect(result).toBe('This is the first full sentence.');
+    });
+
+    it('returns the first five words as a fallback if no sentences are found', () => {
+      const text = 'This is a test using the fallback';
+      const result = extractTextToHighlight(text);
+      expect(result).toBe('This is a test using');
+    });
+
+    it('handles text with fewer than 5 words', () => {
+      const text = 'short text';
+      const result = extractTextToHighlight(text);
+      expect(result).toBe('short text');
+    });
+
+    it('handles empty strings', () => {
+      const text = '';
+      const result = extractTextToHighlight(text);
+      expect(result).toBe('');
+    });
+
+    it('trims whitespace from extracted sentence', () => {
+      const text =
+        '   This is a sentence with leading spaces. This is another sentence.';
+      const result = extractTextToHighlight(text);
+      expect(result).toBe('This is a sentence with leading spaces.');
+    });
+
+    it("handles text with decimal numbers that shouldn't break sentence detection", () => {
+      const text =
+        'This sentence has the decimal 3.1415 in it. This is another sentence.';
+      const result = extractTextToHighlight(text);
+      expect(result).toBe('This sentence has the decimal 3.1415 in it.');
+    });
+
+    it('handles ellipses in sentences', () => {
+      const text = 'This is the first sentence... This is the second sentence.';
+      const result = extractTextToHighlight(text);
+      expect(result).toBe('This is the first sentence...');
+    });
+
+    it('handles multiple punctuation marks', () => {
+      const text = 'This is the first sentence!? Yes, it is.';
+      const result = extractTextToHighlight(text);
+      expect(result).toBe('This is the first sentence!?');
+    });
+
+    it('handles commas within sentences', () => {
+      const text =
+        'This is the first sentence, which has a comma. This is the second.';
+      const result = extractTextToHighlight(text);
+      expect(result).toBe('This is the first sentence, which has a comma.');
+    });
+  });
+
+  describe('generateTextFragmentUrl', () => {
+    it('generates a text fragment URL with the correct encoding', () => {
+      const uri = 'https://example.com';
+      const text = 'This is a sample text.';
+      const result = generateTextFragmentUrl(uri, text);
+      expect(result).toBe(
+        'https://example.com#:~:text=This%20is%20a%20sample%20text.'
+      );
+    });
+  });
+});

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

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

@@ -0,0 +1,71 @@
+// 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 'marked';
+
+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>');
+    });
+  });
+});