@coveo/quantic 3.44.1 → 3.44.2

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

@@ -1,447 +0,0 @@
-/* eslint-disable no-import-assign */
-// @ts-ignore
-import QuanticGeneratedAnswerContent from 'c/quanticGeneratedAnswerContent';
-import {createElement} from 'lwc';
-import {loadMarkdownDependencies} from 'c/quanticUtils';
-import * as mockHeadlessLoader from 'c/quanticHeadlessLoader';
-
-const mockAnswerHeight = 250;
-
-jest.mock('c/quanticHeadlessLoader');
-jest.mock('c/quanticUtils', () => ({
-  loadMarkdownDependencies: jest.fn(
-    () =>
-      new Promise((resolve) => {
-        resolve();
-      })
-  ),
-  transformMarkdownToHtml: jest.fn((value) => value),
-  LinkUtils: {
-    bindAnalyticsToLink: jest.fn(() => jest.fn()),
-  },
-  getAbsoluteHeight: jest.fn(() => mockAnswerHeight),
-}));
-
-const mockMarkedUse = jest.fn();
-const mockMarkedParse = jest.fn((text) => text);
-global.marked = {
-  use: mockMarkedUse,
-  parse: mockMarkedParse,
-};
-
-const SELECTORS = {
-  textAnswerContainer: 'span.generated-answer-content__answer',
-  markdownAnswerContainer: 'div.generated-answer-content__answer',
-  inlineLink: 'a[data-answer-inline-link]',
-  inlineLinkIconContainer: 'span.slds-icon_container',
-  inlineLinkIconSvg: 'svg.slds-icon',
-};
-
-const exampleEngineId = 'example-engine-id';
-const exampleAnswerId = 'example-answer-id';
-
-const defaultOptions = {
-  isStreaming: false,
-  answerContentFormat: 'text/plain',
-  answer: '',
-};
-
-const exampleEngine = {id: 'dummy-engine'};
-let isInitialized = false;
-
-const mockBuildInteractiveGeneratedAnswerInlineLink = jest.fn(() => ({
-  select: jest.fn(),
-  beginDelayedSelect: jest.fn(),
-  cancelPendingSelect: jest.fn(),
-}));
-
-function prepareHeadlessState() {
-  // @ts-ignore
-  mockHeadlessLoader.getHeadlessBundle = () => ({
-    buildInteractiveGeneratedAnswerInlineLink:
-      mockBuildInteractiveGeneratedAnswerInlineLink,
-  });
-}
-
-function mockSuccessfulHeadlessInitialization() {
-  // @ts-ignore
-  mockHeadlessLoader.initializeWithHeadless = (element, _, initialize) => {
-    if (element instanceof QuanticGeneratedAnswerContent && !isInitialized) {
-      isInitialized = true;
-      initialize(exampleEngine);
-    }
-  };
-}
-
-function createTestComponent(options = defaultOptions) {
-  const element = createElement('c-quantic-generated-answer-content', {
-    is: QuanticGeneratedAnswerContent,
-  });
-  for (const [key, value] of Object.entries(options)) {
-    element[key] = value;
-  }
-
-  document.body.appendChild(element);
-  return element;
-}
-
-/**
- * Builds an HTML string containing anchor tags with the data-answer-inline-link
- * attribute, which is what the component's processInlineLinks method targets.
- * @param {Array<{href: string, text: string}>} links
- * @returns {string}
- */
-function buildAnswerWithInlineLinks(links) {
-  return links
-    .map(
-      ({href, text}) => `<a href="${href}" data-answer-inline-link>${text}</a>`
-    )
-    .join(' ');
-}
-
-// 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));
-}
-
-describe('c-quantic-generated-answer-content', () => {
-  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;
-  }
-
-  afterEach(() => {
-    cleanup();
-  });
-
-  describe('text/plain answer content', () => {
-    it('should render a simple text/plain answer when not streaming', async () => {
-      const element = createTestComponent({
-        ...defaultOptions,
-        answer: 'Hello, world!',
-      });
-      await flushPromises();
-
-      const answerContent = element.shadowRoot.querySelector(
-        SELECTORS.textAnswerContainer
-      );
-
-      expect(answerContent.textContent).toBe('Hello, world!');
-      expect(answerContent.className).toBe('generated-answer-content__answer');
-    });
-
-    it('should render a text/plain answer when streaming', async () => {
-      const element = createTestComponent({
-        ...defaultOptions,
-        answer: 'Hello, world!',
-        isStreaming: true,
-      });
-      await flushPromises();
-
-      const answerContent = element.shadowRoot.querySelector(
-        SELECTORS.textAnswerContainer
-      );
-
-      expect(answerContent.textContent).toBe('Hello, world!');
-      expect(answerContent.className).toContain(
-        'generated-answer-content__answer--streaming'
-      );
-    });
-  });
-
-  describe('text/markdown answer content', () => {
-    it('should render a simple markdown answer when not streaming', async () => {
-      const element = createTestComponent({
-        ...defaultOptions,
-        answerContentFormat: 'text/markdown',
-        answer: 'Hello, world!',
-      });
-      await flushPromises();
-
-      const answerContent = element.shadowRoot.querySelector(
-        SELECTORS.markdownAnswerContainer
-      );
-
-      expect(answerContent.textContent).toBe('Hello, world!');
-      expect(answerContent.className).toBe('generated-answer-content__answer');
-    });
-
-    it('should render a simple markdown answer when streaming', async () => {
-      const element = createTestComponent({
-        ...defaultOptions,
-        answerContentFormat: 'text/markdown',
-        answer: 'Hello, world!',
-        isStreaming: true,
-      });
-      await flushPromises();
-
-      const answerContent = element.shadowRoot.querySelector(
-        SELECTORS.markdownAnswerContainer
-      );
-
-      expect(answerContent.textContent).toBe('Hello, world!');
-      expect(answerContent.className).toContain(
-        'generated-answer-content__answer--streaming'
-      );
-    });
-  });
-
-  describe('the reactivity of the answerContentFormat property', () => {
-    it('should load the markdown dependencies when the answerContentFormat property is changed to text/markdown', async () => {
-      const element = createTestComponent({
-        ...defaultOptions,
-        answerContentFormat: 'text/plain',
-      });
-      await flushPromises();
-      expect(loadMarkdownDependencies).not.toHaveBeenCalled();
-
-      element.answerContentFormat = 'text/markdown';
-      await flushPromises();
-      expect(loadMarkdownDependencies).toHaveBeenCalled();
-    });
-  });
-
-  describe('inline links in a markdown answer', () => {
-    const exampleLinks = [
-      {href: 'https://example.com/1', text: 'Link one'},
-      {href: 'https://example.com/2', text: 'Link two'},
-    ];
-
-    beforeEach(() => {
-      mockSuccessfulHeadlessInitialization();
-      prepareHeadlessState();
-    });
-
-    describe('when the answer contains anchors with data-answer-inline-link', () => {
-      it('should set target="_blank" and append an icon span to each inline link anchor', async () => {
-        const {LinkUtils} = jest.requireMock('c/quanticUtils');
-        LinkUtils.bindAnalyticsToLink.mockReturnValue(jest.fn());
-
-        const element = createTestComponent({
-          ...defaultOptions,
-          engineId: exampleEngineId,
-          answerId: exampleAnswerId,
-          answerContentFormat: 'text/markdown',
-          answer: buildAnswerWithInlineLinks(exampleLinks),
-        });
-        await flushPromises();
-
-        const answerContainer = element.shadowRoot.querySelector(
-          SELECTORS.markdownAnswerContainer
-        );
-        const anchors = answerContainer.querySelectorAll(SELECTORS.inlineLink);
-
-        expect(anchors).toHaveLength(exampleLinks.length);
-        anchors.forEach((anchor) => {
-          expect(anchor.target).toBe('_blank');
-        });
-        anchors.forEach((anchor) => {
-          const iconSpan = anchor.querySelector(
-            SELECTORS.inlineLinkIconContainer
-          );
-          expect(iconSpan).not.toBeNull();
-          expect(iconSpan.classList).toContain('slds-icon-utility-new_window');
-          expect(iconSpan.classList).toContain('slds-current-color');
-          expect(
-            iconSpan.querySelector(SELECTORS.inlineLinkIconSvg)
-          ).not.toBeNull();
-        });
-      });
-
-      it('should call buildInteractiveGeneratedAnswerInlineLink with the correct parameters for each inline link', async () => {
-        const {LinkUtils} = jest.requireMock('c/quanticUtils');
-        LinkUtils.bindAnalyticsToLink.mockReturnValue(jest.fn());
-
-        createTestComponent({
-          ...defaultOptions,
-          engineId: exampleEngineId,
-          answerId: exampleAnswerId,
-          answerContentFormat: 'text/markdown',
-          answer: buildAnswerWithInlineLinks(exampleLinks),
-        });
-        await flushPromises();
-
-        expect(
-          mockBuildInteractiveGeneratedAnswerInlineLink
-        ).toHaveBeenCalledTimes(exampleLinks.length);
-        expect(LinkUtils.bindAnalyticsToLink).toHaveBeenCalledTimes(
-          exampleLinks.length
-        );
-
-        exampleLinks.forEach((anchor, index) => {
-          expect(
-            mockBuildInteractiveGeneratedAnswerInlineLink
-          ).toHaveBeenNthCalledWith(index + 1, exampleEngine, {
-            options: {
-              link: {
-                linkURL: anchor.href,
-                linkText: anchor.text,
-              },
-              answerId: exampleAnswerId,
-            },
-          });
-        });
-      });
-
-      it('should call LinkUtils.bindAnalyticsToLink for each inline link with the anchor and its controller', async () => {
-        const {LinkUtils} = jest.requireMock('c/quanticUtils');
-        const mockUnbind = jest.fn();
-        LinkUtils.bindAnalyticsToLink.mockReturnValue(mockUnbind);
-
-        const element = createTestComponent({
-          ...defaultOptions,
-          engineId: exampleEngineId,
-          answerId: exampleAnswerId,
-          answerContentFormat: 'text/markdown',
-          answer: buildAnswerWithInlineLinks(exampleLinks),
-        });
-        await flushPromises();
-
-        expect(LinkUtils.bindAnalyticsToLink).toHaveBeenCalledTimes(
-          exampleLinks.length
-        );
-
-        const answerContainer = element.shadowRoot.querySelector(
-          SELECTORS.markdownAnswerContainer
-        );
-        const anchors = Array.from(
-          answerContainer.querySelectorAll(SELECTORS.inlineLink)
-        );
-
-        anchors.forEach((anchor, index) => {
-          expect(LinkUtils.bindAnalyticsToLink).toHaveBeenNthCalledWith(
-            index + 1,
-            anchor,
-            expect.objectContaining({
-              select: expect.any(Function),
-              beginDelayedSelect: expect.any(Function),
-              cancelPendingSelect: expect.any(Function),
-            })
-          );
-        });
-      });
-    });
-
-    describe('when the answer does not contain anchors with data-answer-inline-link', () => {
-      it('should not call buildInteractiveGeneratedAnswerInlineLink and LinkUtils.bindAnalyticsToLink', async () => {
-        const {LinkUtils} = jest.requireMock('c/quanticUtils');
-
-        createTestComponent({
-          ...defaultOptions,
-          engineId: exampleEngineId,
-          answerId: exampleAnswerId,
-          answerContentFormat: 'text/markdown',
-          answer: '<p>No inline links here</p>',
-        });
-        await flushPromises();
-
-        expect(
-          mockBuildInteractiveGeneratedAnswerInlineLink
-        ).not.toHaveBeenCalled();
-        expect(LinkUtils.bindAnalyticsToLink).not.toHaveBeenCalled();
-      });
-    });
-
-    describe('when the headless bundle does not expose buildInteractiveGeneratedAnswerInlineLink', () => {
-      it('should not throw and should not call LinkUtils.bindAnalyticsToLink', async () => {
-        // @ts-ignore
-        mockHeadlessLoader.getHeadlessBundle = () => ({});
-        const {LinkUtils} = jest.requireMock('c/quanticUtils');
-
-        expect(() => {
-          createTestComponent({
-            ...defaultOptions,
-            engineId: exampleEngineId,
-            answerId: exampleAnswerId,
-            answerContentFormat: 'text/markdown',
-            answer: buildAnswerWithInlineLinks(exampleLinks),
-          });
-        }).not.toThrow();
-
-        await flushPromises();
-
-        expect(LinkUtils.bindAnalyticsToLink).not.toHaveBeenCalled();
-      });
-    });
-
-    describe('when the answer is updated', () => {
-      it('should clean up previous inline link bindings before processing the new answer', async () => {
-        const {LinkUtils} = jest.requireMock('c/quanticUtils');
-        const mockUnbind = jest.fn();
-        LinkUtils.bindAnalyticsToLink.mockReturnValue(mockUnbind);
-
-        const element = createTestComponent({
-          ...defaultOptions,
-          engineId: exampleEngineId,
-          answerId: exampleAnswerId,
-          answerContentFormat: 'text/markdown',
-          answer: buildAnswerWithInlineLinks(exampleLinks),
-        });
-        await flushPromises();
-
-        expect(mockUnbind).not.toHaveBeenCalled();
-
-        const updatedLinks = [
-          {href: 'https://example.com/3', text: 'Link three'},
-        ];
-        element.answer = buildAnswerWithInlineLinks(updatedLinks);
-        await flushPromises();
-
-        expect(mockUnbind).toHaveBeenCalledTimes(exampleLinks.length);
-      });
-    });
-
-    describe('when the component is disconnected', () => {
-      it('should call the unbind function for each inline link binding', async () => {
-        const {LinkUtils} = jest.requireMock('c/quanticUtils');
-        const mockUnbind = jest.fn();
-        LinkUtils.bindAnalyticsToLink.mockReturnValue(mockUnbind);
-
-        const element = createTestComponent({
-          ...defaultOptions,
-          engineId: exampleEngineId,
-          answerId: exampleAnswerId,
-          answerContentFormat: 'text/markdown',
-          answer: buildAnswerWithInlineLinks(exampleLinks),
-        });
-        await flushPromises();
-
-        expect(mockUnbind).not.toHaveBeenCalled();
-
-        document.body.removeChild(element);
-        await flushPromises();
-
-        expect(mockUnbind).toHaveBeenCalledTimes(exampleLinks.length);
-      });
-    });
-  });
-
-  describe('the quantic__answercontentupdated event', () => {
-    beforeEach(() => {
-      mockSuccessfulHeadlessInitialization();
-      prepareHeadlessState();
-    });
-
-    it('should dispatch the event with the measured height when the markdown content is updated', async () => {
-      const element = createTestComponent({
-        ...defaultOptions,
-        answerContentFormat: 'text/markdown',
-        answer: 'Hello, world!',
-      });
-      const handler = jest.fn();
-      element.addEventListener('quantic__answercontentupdated', handler);
-      await flushPromises();
-
-      expect(handler).toHaveBeenCalledTimes(1);
-      const event = handler.mock.calls[0][0];
-      expect(event.detail).toEqual({height: mockAnswerHeight});
-      expect(event.bubbles).toBe(true);
-      expect(event.composed).toBe(true);
-    });
-  });
-});

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

@@ -1,129 +0,0 @@
-/* eslint-disable jest/no-focused-tests */
-// @ts-ignore
-import {createElement} from 'lwc';
-import QuanticGeneratedAnswerCopyToClipboard from '../quanticGeneratedAnswerCopyToClipboard';
-import {copyToClipboard} from 'c/quanticUtils';
-
-const defaultCopyLabel = 'Copy';
-const defaultCopiedLabel = 'Copied';
-const defaultSize = 'xx-small';
-
-jest.mock(
-  '@salesforce/label/c.quantic_Copy',
-  () => ({default: defaultCopyLabel}),
-  {
-    virtual: true,
-  }
-);
-
-jest.mock(
-  '@salesforce/label/c.quantic_Copied',
-  () => ({default: defaultCopiedLabel}),
-  {
-    virtual: true,
-  }
-);
-
-jest.mock('c/quanticUtils', () => ({
-  copyToClipboard: jest.fn(() => Promise.resolve()),
-}));
-
-const selectors = {
-  copyButton: 'c-quantic-stateful-button',
-};
-
-const defaultOptions = {
-  answer: 'Example generated answer',
-  answerId: 'example-answer-id',
-  size: defaultSize,
-};
-
-function createTestComponent(options = defaultOptions) {
-  const element = createElement(
-    'c-quantic-generated-answer-copy-to-clipboard',
-    {
-      is: QuanticGeneratedAnswerCopyToClipboard,
-    }
-  );
-
-  for (const [key, value] of Object.entries(options)) {
-    element[key] = value;
-  }
-
-  document.body.appendChild(element);
-  return element;
-}
-
-// 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));
-}
-
-describe('c-quantic-generated-answer-copy-to-clipboard', () => {
-  function cleanup() {
-    while (document.body.firstChild) {
-      document.body.removeChild(document.body.firstChild);
-    }
-    jest.clearAllMocks();
-  }
-
-  afterEach(() => {
-    cleanup();
-  });
-
-  it('should render the copy button with default size', async () => {
-    const element = createTestComponent();
-    await flushPromises();
-
-    const copyButton = element.shadowRoot.querySelector(selectors.copyButton);
-
-    expect(copyButton).not.toBeNull();
-    expect(copyButton.iconName).toBe('utility:copy');
-    expect(copyButton.iconSize).toBe(defaultSize);
-    expect(copyButton.tooltip).toBe(defaultCopyLabel);
-    expect(copyButton.selected).toBe(false);
-    expect(copyButton.withoutBorders).toBe(true);
-  });
-
-  it('should apply a custom valid size', async () => {
-    const customSize = 'large';
-    const element = createTestComponent({...defaultOptions, size: customSize});
-    await flushPromises();
-
-    const copyButton = element.shadowRoot.querySelector(selectors.copyButton);
-
-    expect(copyButton).not.toBeNull();
-    expect(copyButton.iconSize).toBe(customSize);
-  });
-
-  it('should ignore an invalid size and keep the default value', async () => {
-    const element = createTestComponent({
-      ...defaultOptions,
-      size: 'oliphant',
-    });
-    await flushPromises();
-
-    const copyButton = element.shadowRoot.querySelector(selectors.copyButton);
-
-    expect(copyButton).not.toBeNull();
-    expect(copyButton.iconSize).toBe(defaultSize);
-  });
-
-  it('should copy the answer and dispatch the #quantic__generatedanswercopy event with the answerId', async () => {
-    const element = createTestComponent();
-    const handler = jest.fn();
-    element.addEventListener('quantic__generatedanswercopy', handler);
-    await flushPromises();
-
-    const copyButton = element.shadowRoot.querySelector(selectors.copyButton);
-    copyButton.dispatchEvent(new CustomEvent('quantic__select'));
-    await flushPromises();
-
-    expect(copyToClipboard).toHaveBeenCalledWith(defaultOptions.answer);
-    expect(handler).toHaveBeenCalledTimes(1);
-    expect(handler.mock.calls[0][0].detail).toEqual({
-      answerId: defaultOptions.answerId,
-    });
-  });
-});