coveo.analytics 2.30.56 → 2.32.0

package/src/insight/insightClient.spec.ts

@@ -1,14 +1,16 @@
+import {vi} from 'vitest';
+import type {Mock} from 'vitest';
 import {lastCallBody, mockFetch} from '../../tests/fetchMock';
 import CoveoAnalyticsClient from '../client/analytics';
 import {NoopAnalytics} from '../client/noopAnalytics';
 import {
-    CustomEventsTypes,
-    GeneratedAnswerFeedbackReason,
-    GeneratedAnswerFeedbackReasonOption,
-    GeneratedAnswerRephraseFormat,
-    PartialDocumentInformation,
-    SearchPageEvents,
-    StaticFilterToggleValueMetadata,
+  CustomEventsTypes,
+  GeneratedAnswerFeedbackReason,
+  GeneratedAnswerFeedbackReasonOption,
+  GeneratedAnswerRephraseFormat,
+  PartialDocumentInformation,
+  SearchPageEvents,
+  StaticFilterToggleValueMetadata,
 } from '../searchPage/searchPageEvents';
 import {CoveoInsightClient, InsightClientProvider} from './insightClient';
 import doNotTrack from '../donottrack';
@@ -16,1737 +18,1866 @@ import {InsightEvents, InsightStaticFilterToggleValueMetadata} from './insightEv
 import {Cookie} from '../cookieutils';
 
 const baseCaseMetadata = {
-    caseId: '1234',
-    caseNumber: '5678',
-    caseContext: {Case_Subject: 'test subject', Case_Description: 'test description'},
+  caseId: '1234',
+  caseNumber: '5678',
+  caseContext: {
+    Case_Subject: 'test subject',
+    Case_Description: 'test description',
+  },
 };
 
 const expectedBaseCaseMetadata = {
-    CaseId: '1234',
-    CaseNumber: '5678',
-    CaseSubject: 'test subject',
+  CaseId: '1234',
+  CaseNumber: '5678',
+  CaseSubject: 'test subject',
 };
 
-jest.mock('../donottrack', () => {
-    return {
-        default: jest.fn(),
-        doNotTrack: jest.fn(),
-    };
+vi.mock('../donottrack', () => {
+  const doNotTrack = vi.fn();
+  return {
+    __esModule: true,
+    default: doNotTrack,
+    doNotTrack,
+    shouldDisableAnalyticsForPrivacy: (disableBrowserPrivacySignals?: boolean) =>
+      disableBrowserPrivacySignals === true ? false : doNotTrack(),
+  };
 });
 
 const {fetchMock, fetchMockBeforeEach} = mockFetch();
 describe('InsightClient', () => {
-    const fakeFacetState = [
-        {
-            valuePosition: 0,
-            value: 'foo',
-            state: 'selected' as const,
-            facetPosition: 1,
-            displayValue: 'foobar',
-            facetType: 'specific' as const,
-            field: '@foo',
-            id: 'bar',
-            title: 'title',
+  const fakeFacetState = [
+    {
+      valuePosition: 0,
+      value: 'foo',
+      state: 'selected' as const,
+      facetPosition: 1,
+      displayValue: 'foobar',
+      facetType: 'specific' as const,
+      field: '@foo',
+      id: 'bar',
+      title: 'title',
+    },
+  ];
+
+  let client: CoveoInsightClient;
+
+  const provider: InsightClientProvider = {
+    getBaseMetadata: () => ({foo: 'bar'}),
+    getSearchEventRequestPayload: () => ({
+      queryText: 'queryText',
+      responseTime: 123,
+    }),
+    getSearchUID: () => 'my-uid',
+    getPipeline: () => 'my-pipeline',
+    getOriginContext: () => 'origin-context',
+    getOriginLevel1: () => 'origin-level-1',
+    getOriginLevel2: () => 'origin-level-2',
+    getOriginLevel3: () => 'origin-level-3',
+    getLanguage: () => 'en',
+    getFacetState: () => fakeFacetState,
+    getIsAnonymous: () => false,
+    getGeneratedAnswerMetadata: () => ({genratedAnswerMetadata: 'foo'}),
+  };
+
+  const initClient = () => {
+    return new CoveoInsightClient({}, provider);
+  };
+
+  const expectOrigins = () => ({
+    originContext: 'origin-context',
+    originLevel1: 'origin-level-1',
+    originLevel2: 'origin-level-2',
+    originLevel3: 'origin-level-3',
+  });
+
+  const expectMatchPayload = (actionCause: SearchPageEvents | InsightEvents, meta = {}) => {
+    const body: string = lastCallBody(fetchMock);
+    const customData = {foo: 'bar', genratedAnswerMetadata: 'foo', ...meta};
+    expect(JSON.parse(body)).toMatchObject({
+      queryText: 'queryText',
+      responseTime: 123,
+      queryPipeline: 'my-pipeline',
+      actionCause,
+      customData,
+      facetState: fakeFacetState,
+      language: 'en',
+      clientId: 'visitor-id',
+      ...expectOrigins(),
+    });
+  };
+
+  const expectMatchCustomEventPayload = (
+    actionCause: SearchPageEvents | InsightEvents,
+    meta = {}
+  ) => {
+    const body: string = lastCallBody(fetchMock);
+    const customData = {foo: 'bar', ...meta};
+    expect(JSON.parse(body)).toMatchObject({
+      eventValue: actionCause,
+      eventType: CustomEventsTypes[actionCause],
+      lastSearchQueryUid: 'my-uid',
+      customData,
+      language: 'en',
+      clientId: 'visitor-id',
+      ...expectOrigins(),
+    });
+  };
+
+  const expectMatchDocumentPayload = (
+    actionCause: SearchPageEvents,
+    doc: PartialDocumentInformation,
+    meta = {}
+  ) => {
+    const body: string = lastCallBody(fetchMock);
+    const customData = {foo: 'bar', ...meta};
+    expect(JSON.parse(body.toString())).toMatchObject({
+      actionCause,
+      customData,
+      language: 'en',
+      clientId: 'visitor-id',
+      ...doc,
+      ...expectOrigins(),
+    });
+  };
+
+  const fakeDocInfo = {
+    collectionName: 'collection',
+    documentCategory: 'category',
+    documentAuthor: 'author',
+    documentPosition: 1,
+    documentTitle: 'title',
+    documentUri: 'uri',
+    documentUriHash: 'hash',
+    documentUrl: 'url',
+    queryPipeline: 'my-pipeline',
+    rankingModifier: 'modifier',
+    sourceName: 'source',
+  };
+
+  const fakeDocID = {
+    contentIDKey: 'permanentID',
+    contentIDValue: 'the-permanent-id',
+  };
+
+  beforeEach(() => {
+    fetchMockBeforeEach();
+
+    client = initClient();
+    client.coveoAnalyticsClient.runtime.storage.setItem('visitorId', 'visitor-id');
+    fetchMock.mock(/.*/, {
+      visitId: 'visit-id',
+    });
+  });
+
+  afterEach(() => {
+    fetchMock.reset();
+  });
+
+  describe('when the case metadata is not included', () => {
+    it('should send proper payload for #interfaceLoad', async () => {
+      await client.logInterfaceLoad();
+      expectMatchPayload(SearchPageEvents.interfaceLoad);
+    });
+
+    it('should send proper payload for #recentQueryClick', async () => {
+      await client.logRecentQueryClick();
+      expectMatchPayload(SearchPageEvents.recentQueryClick);
+    });
+
+    it('should send proper payload for #clearRecentQueries', async () => {
+      await client.logClearRecentQueries();
+      expectMatchCustomEventPayload(SearchPageEvents.clearRecentQueries);
+    });
+
+    it('should send proper payload for #interfaceChange', async () => {
+      await client.logInterfaceChange({
+        interfaceChangeTo: 'bob',
+      });
+      expectMatchPayload(SearchPageEvents.interfaceChange, {
+        interfaceChangeTo: 'bob',
+      });
+    });
+
+    it('should send proper payload for #fetchMoreResults', async () => {
+      await client.logFetchMoreResults();
+      expectMatchCustomEventPayload(SearchPageEvents.pagerScrolling, {
+        type: 'getMoreResults',
+      });
+    });
+
+    it('should send proper payload for #staticFilterDeselect', async () => {
+      const meta: StaticFilterToggleValueMetadata = {
+        staticFilterId: 'filetypes',
+        staticFilterValue: {
+          caption: 'Youtube',
+          expression: '@filetype="youtubevideo"',
         },
-    ];
-
-    let client: CoveoInsightClient;
-
-    const provider: InsightClientProvider = {
-        getBaseMetadata: () => ({foo: 'bar'}),
-        getSearchEventRequestPayload: () => ({
-            queryText: 'queryText',
-            responseTime: 123,
-        }),
-        getSearchUID: () => 'my-uid',
-        getPipeline: () => 'my-pipeline',
-        getOriginContext: () => 'origin-context',
-        getOriginLevel1: () => 'origin-level-1',
-        getOriginLevel2: () => 'origin-level-2',
-        getOriginLevel3: () => 'origin-level-3',
-        getLanguage: () => 'en',
-        getFacetState: () => fakeFacetState,
-        getIsAnonymous: () => false,
-        getGeneratedAnswerMetadata: () => ({genratedAnswerMetadata: 'foo'}),
-    };
+      };
+      await client.logStaticFilterDeselect(meta);
 
-    const initClient = () => {
-        return new CoveoInsightClient({}, provider);
-    };
+      expectMatchPayload(SearchPageEvents.staticFilterDeselect, meta);
+    });
 
-    const expectOrigins = () => ({
-        originContext: 'origin-context',
-        originLevel1: 'origin-level-1',
-        originLevel2: 'origin-level-2',
-        originLevel3: 'origin-level-3',
-    });
-
-    const expectMatchPayload = (actionCause: SearchPageEvents | InsightEvents, meta = {}) => {
-        const body: string = lastCallBody(fetchMock);
-        const customData = {foo: 'bar', genratedAnswerMetadata: 'foo', ...meta};
-        expect(JSON.parse(body)).toMatchObject({
-            queryText: 'queryText',
-            responseTime: 123,
-            queryPipeline: 'my-pipeline',
-            actionCause,
-            customData,
-            facetState: fakeFacetState,
-            language: 'en',
-            clientId: 'visitor-id',
-            ...expectOrigins(),
-        });
-    };
+    it('should send proper payload for #breadcrumbResetAll', async () => {
+      await client.logBreadcrumbResetAll();
+      expectMatchPayload(SearchPageEvents.breadcrumbResetAll);
+    });
 
-    const expectMatchCustomEventPayload = (actionCause: SearchPageEvents | InsightEvents, meta = {}) => {
-        const body: string = lastCallBody(fetchMock);
-        const customData = {foo: 'bar', ...meta};
-        expect(JSON.parse(body)).toMatchObject({
-            eventValue: actionCause,
-            eventType: CustomEventsTypes[actionCause],
-            lastSearchQueryUid: 'my-uid',
-            customData,
-            language: 'en',
-            clientId: 'visitor-id',
-            ...expectOrigins(),
-        });
-    };
+    it('should send proper payload for #breadcrumbFacet', async () => {
+      const meta = {
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        facetValue: 'qwerty',
+      };
+      await client.logBreadcrumbFacet(meta);
+      expectMatchPayload(SearchPageEvents.breadcrumbFacet, meta);
+    });
 
-    const expectMatchDocumentPayload = (actionCause: SearchPageEvents, doc: PartialDocumentInformation, meta = {}) => {
-        const body: string = lastCallBody(fetchMock);
-        const customData = {foo: 'bar', ...meta};
-        expect(JSON.parse(body.toString())).toMatchObject({
-            actionCause,
-            customData,
-            language: 'en',
-            clientId: 'visitor-id',
-            ...doc,
-            ...expectOrigins(),
-        });
-    };
+    it('should send proper payload for #logFacetSelect', async () => {
+      const meta = {
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        facetValue: 'qwerty',
+      };
+
+      await client.logFacetSelect(meta);
+      expectMatchPayload(SearchPageEvents.facetSelect, meta);
+    });
+
+    it('should send proper payload for #logFacetExclude', async () => {
+      const meta = {
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        facetValue: 'qwerty',
+      };
+
+      await client.logFacetExclude(meta);
+      expectMatchPayload(SearchPageEvents.facetExclude, meta);
+    });
+
+    it('should send proper payload for #logFacetDeselect', async () => {
+      const meta = {
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        facetValue: 'qwerty',
+      };
+
+      await client.logFacetDeselect(meta);
+      expectMatchPayload(SearchPageEvents.facetDeselect, meta);
+    });
+
+    it('should send proper payload for #logFacetUpdateSort', async () => {
+      const meta = {
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        criteria: 'bazz',
+      };
+      await client.logFacetUpdateSort(meta);
+      expectMatchPayload(SearchPageEvents.facetUpdateSort, meta);
+    });
+
+    it('should send proper payload for #logFacetClearAll', async () => {
+      const meta = {
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+      };
+      await client.logFacetClearAll(meta);
+      expectMatchPayload(SearchPageEvents.facetClearAll, meta);
+    });
+
+    it('should send proper payload for #logFacetShowMore', async () => {
+      const meta = {
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+      };
+      await client.logFacetShowMore(meta);
+      expectMatchCustomEventPayload(SearchPageEvents.facetShowMore, meta);
+    });
+
+    it('should send proper payload for #logFacetShowLess', async () => {
+      const meta = {
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+      };
+      await client.logFacetShowLess(meta);
+      expectMatchCustomEventPayload(SearchPageEvents.facetShowLess, meta);
+    });
+
+    it('should send proper payload for #logQueryError', async () => {
+      const meta = {
+        query: 'q',
+        aq: 'aq',
+        cq: 'cq',
+        dq: 'dq',
+        errorMessage: 'boom',
+        errorType: 'a bad one',
+      };
+      await client.logQueryError(meta);
+      expectMatchCustomEventPayload(SearchPageEvents.queryError, meta);
+    });
+
+    it('should send proper payload for #logPagerNumber', async () => {
+      const meta = {pagerNumber: 123};
+      await client.logPagerNumber(meta);
+      expectMatchCustomEventPayload(SearchPageEvents.pagerNumber, meta);
+    });
+
+    it('should send proper payload for #logPagerNext', async () => {
+      const meta = {pagerNumber: 123};
+      await client.logPagerNext(meta);
+      expectMatchCustomEventPayload(SearchPageEvents.pagerNext, meta);
+    });
+
+    it('should send proper payload for #logPagerPrevious', async () => {
+      const meta = {pagerNumber: 123};
+      await client.logPagerPrevious(meta);
+      expectMatchCustomEventPayload(SearchPageEvents.pagerPrevious, meta);
+    });
+
+    it('should send proper payload for #didyoumeanAutomatic', async () => {
+      await client.logDidYouMeanAutomatic();
+      expectMatchPayload(SearchPageEvents.didyoumeanAutomatic);
+    });
+
+    it('should send proper payload for #didyoumeanClick', async () => {
+      await client.logDidYouMeanClick();
+      expectMatchPayload(SearchPageEvents.didyoumeanClick);
+    });
+
+    it('should send proper payload for #resultsSort', async () => {
+      await client.logResultsSort({resultsSortBy: 'date ascending'});
+      expectMatchPayload(SearchPageEvents.resultsSort, {
+        resultsSortBy: 'date ascending',
+      });
+    });
+
+    it('should send proper payload for #searchboxSubmit', async () => {
+      await client.logSearchboxSubmit();
+      expectMatchPayload(SearchPageEvents.searchboxSubmit);
+    });
+
+    it('should send proper payload for #documentOpen', async () => {
+      await client.logDocumentOpen(fakeDocInfo, fakeDocID);
+      expectMatchDocumentPayload(SearchPageEvents.documentOpen, fakeDocInfo, fakeDocID);
+    });
+
+    it('should send proper payload for #copyToClipboard', async () => {
+      await client.logCopyToClipboard(fakeDocInfo, fakeDocID);
+      expectMatchDocumentPayload(SearchPageEvents.copyToClipboard, fakeDocInfo, fakeDocID);
+    });
+
+    it('should send proper payload for #caseSendEmail', async () => {
+      await client.logCaseSendEmail(fakeDocInfo, fakeDocID);
+      expectMatchDocumentPayload(SearchPageEvents.caseSendEmail, fakeDocInfo, fakeDocID);
+    });
+
+    it('should send proper payload for #feedItemTextPost', async () => {
+      await client.logFeedItemTextPost(fakeDocInfo, fakeDocID);
+      expectMatchDocumentPayload(SearchPageEvents.feedItemTextPost, fakeDocInfo, fakeDocID);
+    });
+
+    it('should send proper payload for #documentQuickview', async () => {
+      const expectedMetadata = {
+        ...fakeDocID,
+        documentTitle: fakeDocInfo.documentTitle,
+        documentURL: fakeDocInfo.documentUrl,
+      };
+      await client.logDocumentQuickview(fakeDocInfo, fakeDocID);
+      expectMatchDocumentPayload(SearchPageEvents.documentQuickview, fakeDocInfo, expectedMetadata);
+    });
+
+    it('should send proper payload for #caseAttach', async () => {
+      const expectedMetadata = {
+        ...fakeDocID,
+        documentTitle: fakeDocInfo.documentTitle,
+        documentURL: fakeDocInfo.documentUrl,
+        resultUriHash: fakeDocInfo.documentUriHash,
+      };
+      await client.logCaseAttach(fakeDocInfo, fakeDocID);
+      expectMatchDocumentPayload(SearchPageEvents.caseAttach, fakeDocInfo, expectedMetadata);
+    });
+
+    it('should send proper payload for #caseDetach', async () => {
+      const mockResultUriHash = fakeDocInfo.documentUriHash;
+      const mockPermanentId = fakeDocID.contentIDValue;
+      const expectedMetadata = {
+        resultUriHash: mockResultUriHash,
+        permanentId: mockPermanentId,
+      };
+      await client.logCaseDetach(mockResultUriHash, undefined, mockPermanentId);
+      expectMatchCustomEventPayload(SearchPageEvents.caseDetach, expectedMetadata);
+    });
+
+    it('should send proper payload for #likeSmartSnippet', async () => {
+      await client.logLikeSmartSnippet();
+      expectMatchCustomEventPayload(SearchPageEvents.likeSmartSnippet);
+    });
 
-    const fakeDocInfo = {
-        collectionName: 'collection',
-        documentCategory: 'category',
-        documentAuthor: 'author',
-        documentPosition: 1,
-        documentTitle: 'title',
-        documentUri: 'uri',
-        documentUriHash: 'hash',
-        documentUrl: 'url',
-        queryPipeline: 'my-pipeline',
-        rankingModifier: 'modifier',
-        sourceName: 'source',
+    it('should send proper payload for #dislikeSmartSnippet', async () => {
+      await client.logDislikeSmartSnippet();
+      expectMatchCustomEventPayload(SearchPageEvents.dislikeSmartSnippet);
+    });
+
+    it('should send proper payload for #expandSmartSnippet', async () => {
+      await client.logExpandSmartSnippet();
+      expectMatchCustomEventPayload(SearchPageEvents.expandSmartSnippet);
+    });
+
+    it('should send proper payload for #collapseSmartSnippet', async () => {
+      await client.logCollapseSmartSnippet();
+      expectMatchCustomEventPayload(SearchPageEvents.collapseSmartSnippet);
+    });
+
+    it('should send proper payload for #openSmartSnippetFeedbackModal', async () => {
+      await client.logOpenSmartSnippetFeedbackModal();
+      expectMatchCustomEventPayload(SearchPageEvents.openSmartSnippetFeedbackModal);
+    });
+
+    it('should send proper payload for #closeSmartSnippetFeedbackModal', async () => {
+      await client.logCloseSmartSnippetFeedbackModal();
+      expectMatchCustomEventPayload(SearchPageEvents.closeSmartSnippetFeedbackModal);
+    });
+
+    it('should send proper payload for #sendSmartSnippetReason', async () => {
+      const reason = 'other';
+      const details = 'example details';
+      const expectedMetadata = {
+        reason,
+        details,
+      };
+
+      await client.logSmartSnippetFeedbackReason(reason, details);
+      expectMatchCustomEventPayload(SearchPageEvents.sendSmartSnippetReason, expectedMetadata);
+    });
+
+    it('should send proper payload for #expandSmartSnippetSuggestion', async () => {
+      const exampleSmartSnippetSuggestion = {
+        question: 'Abc',
+        answerSnippet: 'Def',
+        documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
+      };
+
+      await client.logExpandSmartSnippetSuggestion(exampleSmartSnippetSuggestion);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.expandSmartSnippetSuggestion,
+        exampleSmartSnippetSuggestion
+      );
+    });
+
+    it('should send proper payload for #collapseSmartSnippetSuggestion', async () => {
+      const exampleSmartSnippetSuggestion = {
+        question: 'Abc',
+        answerSnippet: 'Def',
+        documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
+      };
+
+      await client.logCollapseSmartSnippetSuggestion(exampleSmartSnippetSuggestion);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.collapseSmartSnippetSuggestion,
+        exampleSmartSnippetSuggestion
+      );
+    });
+
+    it('should send proper payload for #openSmartSnippetSource', async () => {
+      await client.logOpenSmartSnippetSource(fakeDocInfo, fakeDocID);
+      expectMatchDocumentPayload(SearchPageEvents.openSmartSnippetSource, fakeDocInfo, fakeDocID);
+    });
+
+    it('should send proper payload for #openSmartSnippetInlineLink', async () => {
+      const meta = {
+        ...fakeDocID,
+        linkText: 'Some text',
+        linkURL: 'https://invalid.com',
+      };
+
+      await client.logOpenSmartSnippetInlineLink(fakeDocInfo, meta);
+      expectMatchDocumentPayload(SearchPageEvents.openSmartSnippetInlineLink, fakeDocInfo, meta);
+    });
+
+    it('should send proper payload for #openSmartSnippetSuggestionSource', async () => {
+      const meta = {
+        question: 'Abc',
+        answerSnippet: 'Def',
+        documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
+      };
+
+      const expectedMetadata = {
+        ...meta,
+        contentIDKey: meta.documentId.contentIdKey,
+        contentIDValue: meta.documentId.contentIdValue,
+      };
+
+      await client.logOpenSmartSnippetSuggestionSource(fakeDocInfo, meta);
+      expectMatchDocumentPayload(
+        SearchPageEvents.openSmartSnippetSuggestionSource,
+        fakeDocInfo,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #openSmartSnippetSuggestionInlineLink', async () => {
+      const meta = {
+        question: 'Abc',
+        answerSnippet: 'Def',
+        documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
+        linkText: 'Some text',
+        linkURL: 'https://invalid.com',
+      };
+      const expectedMetadata = {
+        ...meta,
+        contentIDKey: meta.documentId.contentIdKey,
+        contentIDValue: meta.documentId.contentIdValue,
+      };
+
+      await client.logOpenSmartSnippetSuggestionInlineLink(fakeDocInfo, meta);
+      expectMatchDocumentPayload(
+        SearchPageEvents.openSmartSnippetSuggestionInlineLink,
+        fakeDocInfo,
+        expectedMetadata
+      );
+    });
+    it('should send proper payload for #showMoreFoldedResults', async () => {
+      await client.logShowMoreFoldedResults(fakeDocInfo, fakeDocID);
+      expectMatchDocumentPayload(SearchPageEvents.showMoreFoldedResults, fakeDocInfo, fakeDocID);
+    });
+
+    it('should send proper payload for #showLessFoldedResults', async () => {
+      await client.logShowLessFoldedResults();
+      expectMatchCustomEventPayload(SearchPageEvents.showLessFoldedResults);
+    });
+
+    it('should send proper payload for #likeGeneratedAnswer', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+
+      await client.logLikeGeneratedAnswer(exampleGeneratedAnswerMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.likeGeneratedAnswer,
+        exampleGeneratedAnswerMetadata
+      );
+    });
+
+    it('should send proper payload for #dislikeGeneratedAnswer', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+
+      await client.logDislikeGeneratedAnswer(exampleGeneratedAnswerMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.dislikeGeneratedAnswer,
+        exampleGeneratedAnswerMetadata
+      );
+    });
+
+    it('should send proper payload for #openGeneratedAnswerSource', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+        permanentId: 'foo',
+        citationId: 'bar',
+      };
+
+      await client.logOpenGeneratedAnswerSource(exampleGeneratedAnswerMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.openGeneratedAnswerSource,
+        exampleGeneratedAnswerMetadata
+      );
+    });
+
+    it('should send proper payload for #generatedAnswerCitationClick', async () => {
+      const meta = {
+        generativeQuestionAnsweringId: '123',
+        citationId: 'bar',
+        documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
+      };
+
+      const expectedMetadata = {
+        ...meta,
+        contentIDKey: meta.documentId.contentIdKey,
+        contentIDValue: meta.documentId.contentIdValue,
+      };
+
+      await client.logGeneratedAnswerCitationClick(fakeDocInfo, meta);
+      expectMatchDocumentPayload(
+        SearchPageEvents.generatedAnswerCitationClick,
+        fakeDocInfo,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #generatedAnswerSourceHover', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+        permanentId: 'foo',
+        citationId: 'bar',
+        citationHoverTimeMs: 100,
+      };
+
+      await client.logGeneratedAnswerSourceHover(exampleGeneratedAnswerMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.generatedAnswerSourceHover,
+        exampleGeneratedAnswerMetadata
+      );
+    });
+
+    it('should send proper payload for #generatedAnswerCopyToClipboard', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+
+      await client.logGeneratedAnswerCopyToClipboard(exampleGeneratedAnswerMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.generatedAnswerCopyToClipboard,
+        exampleGeneratedAnswerMetadata
+      );
+    });
+
+    it('should send proper payload for #generatedAnswerHideAnswers', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+
+      await client.logGeneratedAnswerHideAnswers(exampleGeneratedAnswerMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.generatedAnswerHideAnswers,
+        exampleGeneratedAnswerMetadata
+      );
+    });
+
+    it('should send proper payload for #generatedAnswerShowAnswers', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+
+      await client.logGeneratedAnswerShowAnswers(exampleGeneratedAnswerMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.generatedAnswerShowAnswers,
+        exampleGeneratedAnswerMetadata
+      );
+    });
+
+    it('should send proper payload for #generatedAnswerExpand', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+
+      await client.logGeneratedAnswerExpand(exampleGeneratedAnswerMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.generatedAnswerExpand,
+        exampleGeneratedAnswerMetadata
+      );
+    });
+
+    it('should send proper payload for #generatedAnswerCollapse', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+
+      await client.logGeneratedAnswerCollapse(exampleGeneratedAnswerMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.generatedAnswerCollapse,
+        exampleGeneratedAnswerMetadata
+      );
+    });
+
+    it('should send proper payload for #generatedAnswerFeedbackSubmit', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+        reason: <GeneratedAnswerFeedbackReason>'other',
+        details: 'foo',
+      };
+
+      await client.logGeneratedAnswerFeedbackSubmit(exampleGeneratedAnswerMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.generatedAnswerFeedbackSubmit,
+        exampleGeneratedAnswerMetadata
+      );
+    });
+
+    it('should send proper payload for #rephraseGeneratedAnswer', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+        rephraseFormat: <GeneratedAnswerRephraseFormat>'step',
+      };
+
+      await client.logRephraseGeneratedAnswer(exampleGeneratedAnswerMetadata);
+      expectMatchPayload(SearchPageEvents.rephraseGeneratedAnswer, exampleGeneratedAnswerMetadata);
+    });
+
+    it('should send proper payload for #retryGeneratedAnswer', async () => {
+      await client.logRetryGeneratedAnswer();
+      expectMatchPayload(SearchPageEvents.retryGeneratedAnswer);
+    });
+
+    it('should send proper payload for #generatedAnswerStreamEnd', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+        answerGenerated: true,
+        answerTextIsEmpty: false,
+      };
+
+      await client.logGeneratedAnswerStreamEnd(exampleGeneratedAnswerMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.generatedAnswerStreamEnd,
+        exampleGeneratedAnswerMetadata
+      );
+    });
+
+    it('should send proper payload for #generatedAnswerCitationDocumentAttach', async () => {
+      const meta = {
+        generativeQuestionAnsweringId: '123',
+        citationId: 'bar',
+        documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
+      };
+
+      const expectedMetadata = {
+        ...meta,
+        contentIDKey: meta.documentId.contentIdKey,
+        contentIDValue: meta.documentId.contentIdValue,
+      };
+
+      await client.logGeneratedAnswerCitationDocumentAttach(fakeDocInfo, meta);
+      expectMatchDocumentPayload(
+        SearchPageEvents.generatedAnswerCitationDocumentAttach,
+        fakeDocInfo,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #createArticle', async () => {
+      const exampleCreateArticleMetadata = {
+        articleType: 'Knowledge__kav',
+        triggeredBy: 'CreateArticleButton',
+      };
+      await client.logCreateArticle(exampleCreateArticleMetadata);
+      expectMatchCustomEventPayload(InsightEvents.createArticle, exampleCreateArticleMetadata);
+    });
+
+    it('should send proper payload for #logTriggerNotify', async () => {
+      const exampleTriggerNotifyMetadata = {
+        notifications: ['foo', 'bar'],
+      };
+      await client.logTriggerNotify(exampleTriggerNotifyMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.triggerNotify, exampleTriggerNotifyMetadata);
+    });
+
+    it('should send proper payload for #generatedAnswerFeedbackSubmitV2', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+        helpful: true,
+        readable: <GeneratedAnswerFeedbackReasonOption>'yes',
+        documented: <GeneratedAnswerFeedbackReasonOption>'no',
+        correctTopic: <GeneratedAnswerFeedbackReasonOption>'unknown',
+        hallucinationFree: <GeneratedAnswerFeedbackReasonOption>'yes',
+        details: 'foo',
+        documentUrl: 'https://document.com',
+      };
+
+      await client.logGeneratedAnswerFeedbackSubmitV2(exampleGeneratedAnswerMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.generatedAnswerFeedbackSubmitV2,
+        exampleGeneratedAnswerMetadata
+      );
+    });
+  });
+
+  describe('when the case metadata is included', () => {
+    it('should send proper payload for #interfaceLoad', async () => {
+      const metadata = baseCaseMetadata;
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+      };
+      await client.logInterfaceLoad(metadata);
+      expectMatchPayload(SearchPageEvents.interfaceLoad, expectedMetadata);
+    });
+
+    it('should send proper payload for #recentQueryClick', async () => {
+      const metadata = baseCaseMetadata;
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+      };
+      await client.logRecentQueryClick(metadata);
+      expectMatchPayload(SearchPageEvents.recentQueryClick, expectedMetadata);
+    });
+
+    it('should send proper payload for #clearRecentQueries', async () => {
+      const metadata = baseCaseMetadata;
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+      };
+      await client.logClearRecentQueries(metadata);
+      expectMatchCustomEventPayload(SearchPageEvents.clearRecentQueries, expectedMetadata);
+    });
+
+    it('should send proper payload for #interfaceChange', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        interfaceChangeTo: 'bob',
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+        interfaceChangeTo: 'bob',
+      };
+      await client.logInterfaceChange(metadata);
+      expectMatchPayload(SearchPageEvents.interfaceChange, expectedMetadata);
+    });
+
+    it('should send proper payload for #fetchMoreResults', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+        type: 'getMoreResults',
+      };
+      await client.logFetchMoreResults(metadata);
+      expectMatchCustomEventPayload(SearchPageEvents.pagerScrolling, expectedMetadata);
+    });
+
+    it('should send proper payload for #staticFilterDeselect', async () => {
+      const metadata: InsightStaticFilterToggleValueMetadata = {
+        ...baseCaseMetadata,
+        staticFilterId: 'filetypes',
+        staticFilterValue: {
+          caption: 'Youtube',
+          expression: '@filetype="youtubevideo"',
+        },
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+        staticFilterId: 'filetypes',
+        staticFilterValue: {
+          caption: 'Youtube',
+          expression: '@filetype="youtubevideo"',
+        },
+      };
+      await client.logStaticFilterDeselect(metadata);
+
+      expectMatchPayload(SearchPageEvents.staticFilterDeselect, expectedMetadata);
+    });
+
+    it('should send proper payload for #breadcrumbResetAll', async () => {
+      const metadata = baseCaseMetadata;
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+      };
+      await client.logBreadcrumbResetAll(metadata);
+      expectMatchPayload(SearchPageEvents.breadcrumbResetAll, expectedMetadata);
+    });
+
+    it('should send proper payload for #breadcrumbFacet', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        facetValue: 'qwerty',
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        facetValue: 'qwerty',
+      };
+      await client.logBreadcrumbFacet(metadata);
+      expectMatchPayload(SearchPageEvents.breadcrumbFacet, expectedMetadata);
+    });
+
+    it('should send proper payload for #logFacetSelect', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        facetValue: 'qwerty',
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        facetValue: 'qwerty',
+      };
+
+      await client.logFacetSelect(metadata);
+      expectMatchPayload(SearchPageEvents.facetSelect, expectedMetadata);
+    });
+
+    it('should send proper payload for #logFacetExclude', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        facetValue: 'qwerty',
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        facetValue: 'qwerty',
+      };
+
+      await client.logFacetExclude(metadata);
+      expectMatchPayload(SearchPageEvents.facetExclude, expectedMetadata);
+    });
+
+    it('should send proper payload for #logFacetDeselect', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        facetValue: 'qwerty',
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        facetValue: 'qwerty',
+      };
+
+      await client.logFacetDeselect(metadata);
+      expectMatchPayload(SearchPageEvents.facetDeselect, expectedMetadata);
+    });
+
+    it('should send proper payload for #logFacetUpdateSort', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        criteria: 'bazz',
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+        criteria: 'bazz',
+      };
+      await client.logFacetUpdateSort(metadata);
+      expectMatchPayload(SearchPageEvents.facetUpdateSort, expectedMetadata);
+    });
+
+    it('should send proper payload for #logFacetClearAll', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+      };
+      await client.logFacetClearAll(metadata);
+      expectMatchPayload(SearchPageEvents.facetClearAll, expectedMetadata);
+    });
+
+    it('should send proper payload for #logFacetShowMore', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+      };
+      await client.logFacetShowMore(metadata);
+      expectMatchCustomEventPayload(SearchPageEvents.facetShowMore, expectedMetadata);
+    });
+
+    it('should send proper payload for #logFacetShowLess', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        facetField: '@foo',
+        facetId: 'bar',
+        facetTitle: 'title',
+      };
+      await client.logFacetShowLess(metadata);
+      expectMatchCustomEventPayload(SearchPageEvents.facetShowLess, expectedMetadata);
+    });
+
+    it('should send proper payload for #logQueryError', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        query: 'q',
+        aq: 'aq',
+        cq: 'cq',
+        dq: 'dq',
+        errorMessage: 'boom',
+        errorType: 'a bad one',
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        query: 'q',
+        aq: 'aq',
+        cq: 'cq',
+        dq: 'dq',
+        errorMessage: 'boom',
+        errorType: 'a bad one',
+      };
+      await client.logQueryError(metadata);
+      expectMatchCustomEventPayload(SearchPageEvents.queryError, expectedMetadata);
+    });
+
+    it('should send proper payload for #logPagerNumber', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        pagerNumber: 123,
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        pagerNumber: 123,
+      };
+      await client.logPagerNumber(metadata);
+      expectMatchCustomEventPayload(SearchPageEvents.pagerNumber, expectedMetadata);
+    });
+
+    it('should send proper payload for #logPagerNext', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        pagerNumber: 123,
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        pagerNumber: 123,
+      };
+      await client.logPagerNext(metadata);
+      expectMatchCustomEventPayload(SearchPageEvents.pagerNext, expectedMetadata);
+    });
+
+    it('should send proper payload for #logPagerPrevious', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        pagerNumber: 123,
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        pagerNumber: 123,
+      };
+      await client.logPagerPrevious(metadata);
+      expectMatchCustomEventPayload(SearchPageEvents.pagerPrevious, expectedMetadata);
+    });
+
+    it('should send proper payload for #didyoumeanAutomatic', async () => {
+      const metadata = baseCaseMetadata;
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+      };
+      await client.logDidYouMeanAutomatic(metadata);
+      expectMatchPayload(SearchPageEvents.didyoumeanAutomatic, expectedMetadata);
+    });
+
+    it('should send proper payload for #didyoumeanClick', async () => {
+      const metadata = baseCaseMetadata;
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+      };
+      await client.logDidYouMeanClick(metadata);
+      expectMatchPayload(SearchPageEvents.didyoumeanClick, expectedMetadata);
+    });
+
+    it('should send proper payload for #resultsSort', async () => {
+      const metadata = {
+        ...baseCaseMetadata,
+        resultsSortBy: 'date ascending',
+      };
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+        resultsSortBy: 'date ascending',
+      };
+      await client.logResultsSort(metadata);
+      expectMatchPayload(SearchPageEvents.resultsSort, expectedMetadata);
+    });
+
+    it('should send proper payload for #searchboxSubmit', async () => {
+      const metadata = baseCaseMetadata;
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        context_Case_Subject: 'test subject',
+        context_Case_Description: 'test description',
+      };
+      await client.logSearchboxSubmit(metadata);
+      expectMatchPayload(SearchPageEvents.searchboxSubmit, expectedMetadata);
+    });
+
+    it('should send proper payload for #documentOpen', async () => {
+      const metadata = baseCaseMetadata;
+
+      const expectedMetadata = {
+        ...fakeDocID,
+        ...expectedBaseCaseMetadata,
+      };
+      await client.logDocumentOpen(fakeDocInfo, fakeDocID, metadata);
+      expectMatchDocumentPayload(SearchPageEvents.documentOpen, fakeDocInfo, expectedMetadata);
+    });
+
+    it('should send proper payload for #copyToClipboard', async () => {
+      const metadata = baseCaseMetadata;
+
+      const expectedMetadata = {
+        ...fakeDocID,
+        ...expectedBaseCaseMetadata,
+      };
+      await client.logCopyToClipboard(fakeDocInfo, fakeDocID, metadata);
+      expectMatchDocumentPayload(SearchPageEvents.copyToClipboard, fakeDocInfo, expectedMetadata);
+    });
+
+    it('should send proper payload for #caseSendEmail', async () => {
+      const metadata = baseCaseMetadata;
+
+      const expectedMetadata = {
+        ...fakeDocID,
+        ...expectedBaseCaseMetadata,
+      };
+      await client.logCaseSendEmail(fakeDocInfo, fakeDocID, metadata);
+      expectMatchDocumentPayload(SearchPageEvents.caseSendEmail, fakeDocInfo, expectedMetadata);
+    });
+
+    it('should send proper payload for #feedItemTextPost', async () => {
+      const metadata = baseCaseMetadata;
+
+      const expectedMetadata = {
+        ...fakeDocID,
+        ...expectedBaseCaseMetadata,
+      };
+      await client.logFeedItemTextPost(fakeDocInfo, fakeDocID, metadata);
+      expectMatchDocumentPayload(SearchPageEvents.feedItemTextPost, fakeDocInfo, expectedMetadata);
+    });
+
+    it('should send proper payload for #documentQuickview', async () => {
+      const metadata = baseCaseMetadata;
+
+      const expectedMetadata = {
+        ...fakeDocID,
+        ...expectedBaseCaseMetadata,
+        documentTitle: fakeDocInfo.documentTitle,
+        documentURL: fakeDocInfo.documentUrl,
+      };
+      await client.logDocumentQuickview(fakeDocInfo, fakeDocID, metadata);
+      expectMatchDocumentPayload(SearchPageEvents.documentQuickview, fakeDocInfo, expectedMetadata);
+    });
+
+    it('should send proper payload for #caseAttach', async () => {
+      const metadata = baseCaseMetadata;
+
+      const expectedMetadata = {
+        ...fakeDocID,
+        ...expectedBaseCaseMetadata,
+        documentTitle: fakeDocInfo.documentTitle,
+        documentURL: fakeDocInfo.documentUrl,
+        resultUriHash: fakeDocInfo.documentUriHash,
+      };
+      await client.logCaseAttach(fakeDocInfo, fakeDocID, metadata);
+      expectMatchDocumentPayload(SearchPageEvents.caseAttach, fakeDocInfo, expectedMetadata);
+    });
+
+    it('should send proper payload for #caseDetach', async () => {
+      const metadata = baseCaseMetadata;
+      const mockResultUriHash = fakeDocInfo.documentUriHash;
+      const mockPermanentId = fakeDocID.contentIDValue;
+
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+        resultUriHash: mockResultUriHash,
+        permanentId: mockPermanentId,
+      };
+      await client.logCaseDetach(mockResultUriHash, metadata, mockPermanentId);
+      expectMatchCustomEventPayload(SearchPageEvents.caseDetach, expectedMetadata);
+    });
+
+    it('should send proper payload for #likeSmartSnippet', async () => {
+      await client.logLikeSmartSnippet(baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.likeSmartSnippet, expectedBaseCaseMetadata);
+    });
+
+    it('should send proper payload for #dislikeSmartSnippet', async () => {
+      await client.logDislikeSmartSnippet(baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.dislikeSmartSnippet, expectedBaseCaseMetadata);
+    });
+
+    it('should send proper payload for #expandSmartSnippet', async () => {
+      await client.logExpandSmartSnippet(baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.expandSmartSnippet, expectedBaseCaseMetadata);
+    });
+
+    it('should send proper payload for #collapseSmartSnippet', async () => {
+      await client.logCollapseSmartSnippet(baseCaseMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.collapseSmartSnippet,
+        expectedBaseCaseMetadata
+      );
+    });
+
+    it('should send proper payload for #openSmartSnippetFeedbackModal', async () => {
+      await client.logOpenSmartSnippetFeedbackModal(baseCaseMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.openSmartSnippetFeedbackModal,
+        expectedBaseCaseMetadata
+      );
+    });
+
+    it('should send proper payload for #closeSmartSnippetFeedbackModal', async () => {
+      await client.logCloseSmartSnippetFeedbackModal(baseCaseMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.closeSmartSnippetFeedbackModal,
+        expectedBaseCaseMetadata
+      );
+    });
+
+    it('should send proper payload for #sendSmartSnippetReason', async () => {
+      const reason = 'other';
+      const details = 'example details';
+      const expectedMetadata = {
+        reason,
+        details,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logSmartSnippetFeedbackReason(reason, details, baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.sendSmartSnippetReason, expectedMetadata);
+    });
+
+    it('should send proper payload for #expandSmartSnippetSuggestion', async () => {
+      const exampleSmartSnippetSuggestion = {
+        question: 'Abc',
+        answerSnippet: 'Def',
+        documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
+      };
+      const expectedMetadata = {
+        ...exampleSmartSnippetSuggestion,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logExpandSmartSnippetSuggestion(exampleSmartSnippetSuggestion, baseCaseMetadata);
+      expectMatchCustomEventPayload(
+        SearchPageEvents.expandSmartSnippetSuggestion,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #collapseSmartSnippetSuggestion', async () => {
+      const exampleSmartSnippetSuggestion = {
+        question: 'Abc',
+        answerSnippet: 'Def',
+        documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
+      };
+      const expectedMetadata = {
+        ...exampleSmartSnippetSuggestion,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logCollapseSmartSnippetSuggestion(
+        exampleSmartSnippetSuggestion,
+        baseCaseMetadata
+      );
+      expectMatchCustomEventPayload(
+        SearchPageEvents.collapseSmartSnippetSuggestion,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #openSmartSnippetSource', async () => {
+      const expectedMetadata = {
+        ...fakeDocID,
+        ...expectedBaseCaseMetadata,
+      };
+      await client.logOpenSmartSnippetSource(fakeDocInfo, fakeDocID, baseCaseMetadata);
+      expectMatchDocumentPayload(
+        SearchPageEvents.openSmartSnippetSource,
+        fakeDocInfo,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #openSmartSnippetInlineLink', async () => {
+      const meta = {
+        ...fakeDocID,
+        linkText: 'Some text',
+        linkURL: 'https://invalid.com',
+      };
+      const expectedMetadata = {
+        ...meta,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logOpenSmartSnippetInlineLink(fakeDocInfo, meta, baseCaseMetadata);
+      expectMatchDocumentPayload(
+        SearchPageEvents.openSmartSnippetInlineLink,
+        fakeDocInfo,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #openSmartSnippetSuggestionSource', async () => {
+      const meta = {
+        question: 'Abc',
+        answerSnippet: 'Def',
+        documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
+      };
+
+      const expectedMetadata = {
+        ...meta,
+        ...expectedBaseCaseMetadata,
+        contentIDKey: meta.documentId.contentIdKey,
+        contentIDValue: meta.documentId.contentIdValue,
+      };
+
+      await client.logOpenSmartSnippetSuggestionSource(fakeDocInfo, meta, baseCaseMetadata);
+      expectMatchDocumentPayload(
+        SearchPageEvents.openSmartSnippetSuggestionSource,
+        fakeDocInfo,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #openSmartSnippetSuggestionInlineLink', async () => {
+      const meta = {
+        question: 'Abc',
+        answerSnippet: 'Def',
+        documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
+        linkText: 'Some text',
+        linkURL: 'https://invalid.com',
+      };
+      const expectedMetadata = {
+        ...meta,
+        ...expectedBaseCaseMetadata,
+        contentIDKey: meta.documentId.contentIdKey,
+        contentIDValue: meta.documentId.contentIdValue,
+      };
+
+      await client.logOpenSmartSnippetSuggestionInlineLink(fakeDocInfo, meta, baseCaseMetadata);
+      expectMatchDocumentPayload(
+        SearchPageEvents.openSmartSnippetSuggestionInlineLink,
+        fakeDocInfo,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #showMoreFoldedResults', async () => {
+      const expectedMetadata = {
+        ...fakeDocID,
+        ...expectedBaseCaseMetadata,
+      };
+      await client.logShowMoreFoldedResults(fakeDocInfo, fakeDocID, baseCaseMetadata);
+      expectMatchDocumentPayload(
+        SearchPageEvents.showMoreFoldedResults,
+        fakeDocInfo,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #showLessFoldedResults', async () => {
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+      };
+      await client.logShowLessFoldedResults(baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.showLessFoldedResults, expectedMetadata);
+    });
+
+    it('should send proper payload for #likeGeneratedAnswer', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+      const expectedMetadata = {
+        ...exampleGeneratedAnswerMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logLikeGeneratedAnswer(exampleGeneratedAnswerMetadata, baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.likeGeneratedAnswer, expectedMetadata);
+    });
+
+    it('should send proper payload for #dislikeGeneratedAnswer', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+      const expectedMetadata = {
+        ...exampleGeneratedAnswerMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logDislikeGeneratedAnswer(exampleGeneratedAnswerMetadata, baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.dislikeGeneratedAnswer, expectedMetadata);
+    });
+
+    it('should send proper payload for #openGeneratedAnswerSource', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+        permanentId: 'foo',
+        citationId: 'bar',
+      };
+      const expectedMetadata = {
+        ...exampleGeneratedAnswerMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logOpenGeneratedAnswerSource(exampleGeneratedAnswerMetadata, baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.openGeneratedAnswerSource, expectedMetadata);
+    });
+
+    it('should send proper payload for #generatedAnswerCitationClick', async () => {
+      const meta = {
+        generativeQuestionAnsweringId: '123',
+        citationId: 'bar',
+        documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
+      };
+
+      const expectedMetadata = {
+        ...meta,
+        contentIDKey: meta.documentId.contentIdKey,
+        contentIDValue: meta.documentId.contentIdValue,
+      };
+
+      await client.logGeneratedAnswerCitationClick(fakeDocInfo, meta, baseCaseMetadata);
+      expectMatchDocumentPayload(
+        SearchPageEvents.generatedAnswerCitationClick,
+        fakeDocInfo,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #generatedAnswerSourceHover', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+        permanentId: 'foo',
+        citationId: 'bar',
+        citationHoverTimeMs: 100,
+      };
+      const expectedMetadata = {
+        ...exampleGeneratedAnswerMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logGeneratedAnswerSourceHover(exampleGeneratedAnswerMetadata, baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerSourceHover, expectedMetadata);
+    });
+
+    it('should send proper payload for #generatedAnswerCopyToClipboard', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+      const expectedMetadata = {
+        ...exampleGeneratedAnswerMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logGeneratedAnswerCopyToClipboard(
+        exampleGeneratedAnswerMetadata,
+        baseCaseMetadata
+      );
+      expectMatchCustomEventPayload(
+        SearchPageEvents.generatedAnswerCopyToClipboard,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #generatedAnswerHideAnswers', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+      const expectedMetadata = {
+        ...exampleGeneratedAnswerMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logGeneratedAnswerHideAnswers(exampleGeneratedAnswerMetadata, baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerHideAnswers, expectedMetadata);
+    });
+
+    it('should send proper payload for #generatedAnswerShowAnswers', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+      const expectedMetadata = {
+        ...exampleGeneratedAnswerMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logGeneratedAnswerShowAnswers(exampleGeneratedAnswerMetadata, baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerShowAnswers, expectedMetadata);
+    });
+
+    it('should send proper payload for #generatedAnswerExpand', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+      const expectedMetadata = {
+        ...exampleGeneratedAnswerMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logGeneratedAnswerExpand(exampleGeneratedAnswerMetadata, baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerExpand, expectedMetadata);
+    });
+
+    it('should send proper payload for #generatedAnswerCollapse', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+      };
+      const expectedMetadata = {
+        ...exampleGeneratedAnswerMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logGeneratedAnswerCollapse(exampleGeneratedAnswerMetadata, baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerCollapse, expectedMetadata);
+    });
+
+    it('should send proper payload for #generatedAnswerFeedbackSubmit', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+        reason: <GeneratedAnswerFeedbackReason>'other',
+        details: 'foo',
+      };
+      const expectedMetadata = {
+        ...exampleGeneratedAnswerMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logGeneratedAnswerFeedbackSubmit(
+        exampleGeneratedAnswerMetadata,
+        baseCaseMetadata
+      );
+      expectMatchCustomEventPayload(
+        SearchPageEvents.generatedAnswerFeedbackSubmit,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #generatedAnswerFeedbackSubmitV2', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+        helpful: true,
+        readable: <GeneratedAnswerFeedbackReasonOption>'yes',
+        documented: <GeneratedAnswerFeedbackReasonOption>'no',
+        correctTopic: <GeneratedAnswerFeedbackReasonOption>'unknown',
+        hallucinationFree: <GeneratedAnswerFeedbackReasonOption>'yes',
+        details: 'foo',
+        documentUrl: 'https://document.com',
+      };
+      const expectedMetadata = {
+        ...exampleGeneratedAnswerMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logGeneratedAnswerFeedbackSubmitV2(
+        exampleGeneratedAnswerMetadata,
+        baseCaseMetadata
+      );
+      expectMatchCustomEventPayload(
+        SearchPageEvents.generatedAnswerFeedbackSubmitV2,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #rephraseGeneratedAnswer', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+        rephraseFormat: <GeneratedAnswerRephraseFormat>'step',
+      };
+      const expectedMetadata = {
+        ...exampleGeneratedAnswerMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logRephraseGeneratedAnswer(exampleGeneratedAnswerMetadata, baseCaseMetadata);
+      expectMatchPayload(SearchPageEvents.rephraseGeneratedAnswer, expectedMetadata);
+    });
+
+    it('should send proper payload for #retryGeneratedAnswer', async () => {
+      const expectedMetadata = {
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logRetryGeneratedAnswer(baseCaseMetadata);
+      expectMatchPayload(SearchPageEvents.retryGeneratedAnswer, expectedMetadata);
+    });
+
+    it('should send proper payload for #generatedAnswerStreamEnd', async () => {
+      const exampleGeneratedAnswerMetadata = {
+        generativeQuestionAnsweringId: '123',
+        answerGenerated: true,
+        answerTextIsEmpty: false,
+      };
+      const expectedMetadata = {
+        ...exampleGeneratedAnswerMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+
+      await client.logGeneratedAnswerStreamEnd(exampleGeneratedAnswerMetadata, baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerStreamEnd, expectedMetadata);
+    });
+
+    it('should send proper payload for #generatedAnswerCitationDocumentAttach', async () => {
+      const meta = {
+        generativeQuestionAnsweringId: '123',
+        citationId: 'bar',
+        documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
+      };
+
+      const expectedMetadata = {
+        ...meta,
+        ...expectedBaseCaseMetadata,
+        contentIDKey: meta.documentId.contentIdKey,
+        contentIDValue: meta.documentId.contentIdValue,
+      };
+
+      await client.logGeneratedAnswerCitationDocumentAttach(fakeDocInfo, meta, baseCaseMetadata);
+      expectMatchDocumentPayload(
+        SearchPageEvents.generatedAnswerCitationDocumentAttach,
+        fakeDocInfo,
+        expectedMetadata
+      );
+    });
+
+    it('should send proper payload for #createArticle', async () => {
+      const exampleCreateArticleMetadata = {
+        articleType: 'Knowledge__kav',
+      };
+      const expectedMetadata = {
+        ...exampleCreateArticleMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+      await client.logCreateArticle(exampleCreateArticleMetadata, baseCaseMetadata);
+      expectMatchCustomEventPayload(InsightEvents.createArticle, expectedMetadata);
+    });
+
+    it('should send proper payload for #logTriggerNotify', async () => {
+      const exampleTriggerNotifyMetadata = {
+        notifications: ['foo', 'bar'],
+      };
+      const expectedMetadata = {
+        ...exampleTriggerNotifyMetadata,
+        ...expectedBaseCaseMetadata,
+      };
+      await client.logTriggerNotify(exampleTriggerNotifyMetadata, baseCaseMetadata);
+      expectMatchCustomEventPayload(SearchPageEvents.triggerNotify, expectedMetadata);
+    });
+  });
+
+  it('should enable analytics tracking by default', () => {
+    const c = new CoveoInsightClient({}, provider);
+    expect(c.coveoAnalyticsClient instanceof CoveoAnalyticsClient).toBe(true);
+  });
+
+  it('should allow disabling analytics on initialization', () => {
+    const c = new CoveoInsightClient({enableAnalytics: false}, provider);
+    expect(c.coveoAnalyticsClient instanceof NoopAnalytics).toBe(true);
+  });
+
+  it('should allow disabling analytics after initialization', () => {
+    const c = new CoveoInsightClient({enableAnalytics: true}, provider);
+    expect(c.coveoAnalyticsClient instanceof CoveoAnalyticsClient).toBe(true);
+    c.disable();
+    expect(c.coveoAnalyticsClient instanceof NoopAnalytics).toBe(true);
+  });
+
+  it('disabling analytics does not delete the visitorId', () => {
+    const visitorId = 'uuid';
+    Cookie.set('coveo_visitorId', visitorId);
+    const c = new CoveoInsightClient({enableAnalytics: true}, provider);
+
+    expect(Cookie.get('coveo_visitorId')).toBe(visitorId);
+    c.disable();
+    expect(Cookie.get('coveo_visitorId')).toBe(visitorId);
+  });
+
+  it('should disable analytics when doNotTrack is enabled', async () => {
+    (doNotTrack as Mock).mockImplementationOnce(() => true);
+
+    const c = new CoveoInsightClient({}, provider);
+    expect(c.coveoAnalyticsClient instanceof NoopAnalytics).toBe(true);
+  });
+
+  it('keeps a real analytics client under doNotTrack when disableBrowserPrivacySignals is true', () => {
+    (doNotTrack as Mock).mockImplementation(() => true);
+
+    const c = new CoveoInsightClient({disableBrowserPrivacySignals: true}, provider);
+    expect(c.coveoAnalyticsClient instanceof CoveoAnalyticsClient).toBe(true);
+
+    (doNotTrack as Mock).mockReset();
+  });
+
+  it('still disables analytics when enableAnalytics is false even if disableBrowserPrivacySignals is true', () => {
+    const c = new CoveoInsightClient(
+      {enableAnalytics: false, disableBrowserPrivacySignals: true},
+      provider
+    );
+    expect(c.coveoAnalyticsClient instanceof NoopAnalytics).toBe(true);
+  });
+
+  it('should allow enabling analytics after initialization', () => {
+    const c = new CoveoInsightClient({enableAnalytics: false}, provider);
+    expect(c.coveoAnalyticsClient instanceof NoopAnalytics).toBe(true);
+    c.enable();
+    expect(c.coveoAnalyticsClient instanceof CoveoAnalyticsClient).toBe(true);
+  });
+
+  it('should send proper payload for #contextChanged', async () => {
+    const meta = {
+      caseId: '1234',
+      caseNumber: '5678',
+      caseContext: {
+        Case_Subject: 'test subject',
+        Case_Description: 'test description',
+      },
     };
 
-    const fakeDocID = {
-        contentIDKey: 'permanentID',
-        contentIDValue: 'the-permanent-id',
+    const expectedMeta = {
+      CaseId: '1234',
+      CaseNumber: '5678',
+      CaseSubject: 'test subject',
+      context_Case_Subject: 'test subject',
+      context_Case_Description: 'test description',
     };
 
-    beforeEach(() => {
-        fetchMockBeforeEach();
-
-        client = initClient();
-        client.coveoAnalyticsClient.runtime.storage.setItem('visitorId', 'visitor-id');
-        fetchMock.mock(/.*/, {
-            visitId: 'visit-id',
-        });
-    });
-
-    afterEach(() => {
-        fetchMock.reset();
-    });
-
-    describe('when the case metadata is not included', () => {
-        it('should send proper payload for #interfaceLoad', async () => {
-            await client.logInterfaceLoad();
-            expectMatchPayload(SearchPageEvents.interfaceLoad);
-        });
-
-        it('should send proper payload for #recentQueryClick', async () => {
-            await client.logRecentQueryClick();
-            expectMatchPayload(SearchPageEvents.recentQueryClick);
-        });
-
-        it('should send proper payload for #clearRecentQueries', async () => {
-            await client.logClearRecentQueries();
-            expectMatchCustomEventPayload(SearchPageEvents.clearRecentQueries);
-        });
-
-        it('should send proper payload for #interfaceChange', async () => {
-            await client.logInterfaceChange({
-                interfaceChangeTo: 'bob',
-            });
-            expectMatchPayload(SearchPageEvents.interfaceChange, {interfaceChangeTo: 'bob'});
-        });
-
-        it('should send proper payload for #fetchMoreResults', async () => {
-            await client.logFetchMoreResults();
-            expectMatchCustomEventPayload(SearchPageEvents.pagerScrolling, {type: 'getMoreResults'});
-        });
-
-        it('should send proper payload for #staticFilterDeselect', async () => {
-            const meta: StaticFilterToggleValueMetadata = {
-                staticFilterId: 'filetypes',
-                staticFilterValue: {
-                    caption: 'Youtube',
-                    expression: '@filetype="youtubevideo"',
-                },
-            };
-            await client.logStaticFilterDeselect(meta);
-
-            expectMatchPayload(SearchPageEvents.staticFilterDeselect, meta);
-        });
-
-        it('should send proper payload for #breadcrumbResetAll', async () => {
-            await client.logBreadcrumbResetAll();
-            expectMatchPayload(SearchPageEvents.breadcrumbResetAll);
-        });
-
-        it('should send proper payload for #breadcrumbFacet', async () => {
-            const meta = {
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                facetValue: 'qwerty',
-            };
-            await client.logBreadcrumbFacet(meta);
-            expectMatchPayload(SearchPageEvents.breadcrumbFacet, meta);
-        });
-
-        it('should send proper payload for #logFacetSelect', async () => {
-            const meta = {
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                facetValue: 'qwerty',
-            };
-
-            await client.logFacetSelect(meta);
-            expectMatchPayload(SearchPageEvents.facetSelect, meta);
-        });
-
-        it('should send proper payload for #logFacetExclude', async () => {
-            const meta = {
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                facetValue: 'qwerty',
-            };
-
-            await client.logFacetExclude(meta);
-            expectMatchPayload(SearchPageEvents.facetExclude, meta);
-        });
-
-        it('should send proper payload for #logFacetDeselect', async () => {
-            const meta = {
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                facetValue: 'qwerty',
-            };
-
-            await client.logFacetDeselect(meta);
-            expectMatchPayload(SearchPageEvents.facetDeselect, meta);
-        });
-
-        it('should send proper payload for #logFacetUpdateSort', async () => {
-            const meta = {
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                criteria: 'bazz',
-            };
-            await client.logFacetUpdateSort(meta);
-            expectMatchPayload(SearchPageEvents.facetUpdateSort, meta);
-        });
-
-        it('should send proper payload for #logFacetClearAll', async () => {
-            const meta = {
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-            };
-            await client.logFacetClearAll(meta);
-            expectMatchPayload(SearchPageEvents.facetClearAll, meta);
-        });
-
-        it('should send proper payload for #logFacetShowMore', async () => {
-            const meta = {
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-            };
-            await client.logFacetShowMore(meta);
-            expectMatchCustomEventPayload(SearchPageEvents.facetShowMore, meta);
-        });
-
-        it('should send proper payload for #logFacetShowLess', async () => {
-            const meta = {
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-            };
-            await client.logFacetShowLess(meta);
-            expectMatchCustomEventPayload(SearchPageEvents.facetShowLess, meta);
-        });
-
-        it('should send proper payload for #logQueryError', async () => {
-            const meta = {
-                query: 'q',
-                aq: 'aq',
-                cq: 'cq',
-                dq: 'dq',
-                errorMessage: 'boom',
-                errorType: 'a bad one',
-            };
-            await client.logQueryError(meta);
-            expectMatchCustomEventPayload(SearchPageEvents.queryError, meta);
-        });
-
-        it('should send proper payload for #logPagerNumber', async () => {
-            const meta = {pagerNumber: 123};
-            await client.logPagerNumber(meta);
-            expectMatchCustomEventPayload(SearchPageEvents.pagerNumber, meta);
-        });
-
-        it('should send proper payload for #logPagerNext', async () => {
-            const meta = {pagerNumber: 123};
-            await client.logPagerNext(meta);
-            expectMatchCustomEventPayload(SearchPageEvents.pagerNext, meta);
-        });
-
-        it('should send proper payload for #logPagerPrevious', async () => {
-            const meta = {pagerNumber: 123};
-            await client.logPagerPrevious(meta);
-            expectMatchCustomEventPayload(SearchPageEvents.pagerPrevious, meta);
-        });
-
-        it('should send proper payload for #didyoumeanAutomatic', async () => {
-            await client.logDidYouMeanAutomatic();
-            expectMatchPayload(SearchPageEvents.didyoumeanAutomatic);
-        });
-
-        it('should send proper payload for #didyoumeanClick', async () => {
-            await client.logDidYouMeanClick();
-            expectMatchPayload(SearchPageEvents.didyoumeanClick);
-        });
-
-        it('should send proper payload for #resultsSort', async () => {
-            await client.logResultsSort({resultsSortBy: 'date ascending'});
-            expectMatchPayload(SearchPageEvents.resultsSort, {resultsSortBy: 'date ascending'});
-        });
-
-        it('should send proper payload for #searchboxSubmit', async () => {
-            await client.logSearchboxSubmit();
-            expectMatchPayload(SearchPageEvents.searchboxSubmit);
-        });
-
-        it('should send proper payload for #documentOpen', async () => {
-            await client.logDocumentOpen(fakeDocInfo, fakeDocID);
-            expectMatchDocumentPayload(SearchPageEvents.documentOpen, fakeDocInfo, fakeDocID);
-        });
-
-        it('should send proper payload for #copyToClipboard', async () => {
-            await client.logCopyToClipboard(fakeDocInfo, fakeDocID);
-            expectMatchDocumentPayload(SearchPageEvents.copyToClipboard, fakeDocInfo, fakeDocID);
-        });
-
-        it('should send proper payload for #caseSendEmail', async () => {
-            await client.logCaseSendEmail(fakeDocInfo, fakeDocID);
-            expectMatchDocumentPayload(SearchPageEvents.caseSendEmail, fakeDocInfo, fakeDocID);
-        });
-
-        it('should send proper payload for #feedItemTextPost', async () => {
-            await client.logFeedItemTextPost(fakeDocInfo, fakeDocID);
-            expectMatchDocumentPayload(SearchPageEvents.feedItemTextPost, fakeDocInfo, fakeDocID);
-        });
-
-        it('should send proper payload for #documentQuickview', async () => {
-            const expectedMetadata = {
-                ...fakeDocID,
-                documentTitle: fakeDocInfo.documentTitle,
-                documentURL: fakeDocInfo.documentUrl,
-            };
-            await client.logDocumentQuickview(fakeDocInfo, fakeDocID);
-            expectMatchDocumentPayload(SearchPageEvents.documentQuickview, fakeDocInfo, expectedMetadata);
-        });
-
-        it('should send proper payload for #caseAttach', async () => {
-            const expectedMetadata = {
-                ...fakeDocID,
-                documentTitle: fakeDocInfo.documentTitle,
-                documentURL: fakeDocInfo.documentUrl,
-                resultUriHash: fakeDocInfo.documentUriHash,
-            };
-            await client.logCaseAttach(fakeDocInfo, fakeDocID);
-            expectMatchDocumentPayload(SearchPageEvents.caseAttach, fakeDocInfo, expectedMetadata);
-        });
-
-        it('should send proper payload for #caseDetach', async () => {
-            const mockResultUriHash = fakeDocInfo.documentUriHash;
-            const mockPermanentId = fakeDocID.contentIDValue;
-            const expectedMetadata = {
-                resultUriHash: mockResultUriHash,
-                permanentId: mockPermanentId,
-            };
-            await client.logCaseDetach(mockResultUriHash, undefined, mockPermanentId);
-            expectMatchCustomEventPayload(SearchPageEvents.caseDetach, expectedMetadata);
-        });
-
-        it('should send proper payload for #likeSmartSnippet', async () => {
-            await client.logLikeSmartSnippet();
-            expectMatchCustomEventPayload(SearchPageEvents.likeSmartSnippet);
-        });
-
-        it('should send proper payload for #dislikeSmartSnippet', async () => {
-            await client.logDislikeSmartSnippet();
-            expectMatchCustomEventPayload(SearchPageEvents.dislikeSmartSnippet);
-        });
-
-        it('should send proper payload for #expandSmartSnippet', async () => {
-            await client.logExpandSmartSnippet();
-            expectMatchCustomEventPayload(SearchPageEvents.expandSmartSnippet);
-        });
-
-        it('should send proper payload for #collapseSmartSnippet', async () => {
-            await client.logCollapseSmartSnippet();
-            expectMatchCustomEventPayload(SearchPageEvents.collapseSmartSnippet);
-        });
-
-        it('should send proper payload for #openSmartSnippetFeedbackModal', async () => {
-            await client.logOpenSmartSnippetFeedbackModal();
-            expectMatchCustomEventPayload(SearchPageEvents.openSmartSnippetFeedbackModal);
-        });
-
-        it('should send proper payload for #closeSmartSnippetFeedbackModal', async () => {
-            await client.logCloseSmartSnippetFeedbackModal();
-            expectMatchCustomEventPayload(SearchPageEvents.closeSmartSnippetFeedbackModal);
-        });
-
-        it('should send proper payload for #sendSmartSnippetReason', async () => {
-            const reason = 'other';
-            const details = 'example details';
-            const expectedMetadata = {
-                reason,
-                details,
-            };
-
-            await client.logSmartSnippetFeedbackReason(reason, details);
-            expectMatchCustomEventPayload(SearchPageEvents.sendSmartSnippetReason, expectedMetadata);
-        });
-
-        it('should send proper payload for #expandSmartSnippetSuggestion', async () => {
-            const exampleSmartSnippetSuggestion = {
-                question: 'Abc',
-                answerSnippet: 'Def',
-                documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
-            };
-
-            await client.logExpandSmartSnippetSuggestion(exampleSmartSnippetSuggestion);
-            expectMatchCustomEventPayload(SearchPageEvents.expandSmartSnippetSuggestion, exampleSmartSnippetSuggestion);
-        });
-
-        it('should send proper payload for #collapseSmartSnippetSuggestion', async () => {
-            const exampleSmartSnippetSuggestion = {
-                question: 'Abc',
-                answerSnippet: 'Def',
-                documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
-            };
-
-            await client.logCollapseSmartSnippetSuggestion(exampleSmartSnippetSuggestion);
-            expectMatchCustomEventPayload(
-                SearchPageEvents.collapseSmartSnippetSuggestion,
-                exampleSmartSnippetSuggestion,
-            );
-        });
-
-        it('should send proper payload for #openSmartSnippetSource', async () => {
-            await client.logOpenSmartSnippetSource(fakeDocInfo, fakeDocID);
-            expectMatchDocumentPayload(SearchPageEvents.openSmartSnippetSource, fakeDocInfo, fakeDocID);
-        });
-
-        it('should send proper payload for #openSmartSnippetInlineLink', async () => {
-            const meta = {
-                ...fakeDocID,
-                linkText: 'Some text',
-                linkURL: 'https://invalid.com',
-            };
-
-            await client.logOpenSmartSnippetInlineLink(fakeDocInfo, meta);
-            expectMatchDocumentPayload(SearchPageEvents.openSmartSnippetInlineLink, fakeDocInfo, meta);
-        });
-
-        it('should send proper payload for #openSmartSnippetSuggestionSource', async () => {
-            const meta = {
-                question: 'Abc',
-                answerSnippet: 'Def',
-                documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
-            };
-
-            const expectedMetadata = {
-                ...meta,
-                contentIDKey: meta.documentId.contentIdKey,
-                contentIDValue: meta.documentId.contentIdValue,
-            };
-
-            await client.logOpenSmartSnippetSuggestionSource(fakeDocInfo, meta);
-            expectMatchDocumentPayload(
-                SearchPageEvents.openSmartSnippetSuggestionSource,
-                fakeDocInfo,
-                expectedMetadata,
-            );
-        });
-
-        it('should send proper payload for #openSmartSnippetSuggestionInlineLink', async () => {
-            const meta = {
-                question: 'Abc',
-                answerSnippet: 'Def',
-                documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
-                linkText: 'Some text',
-                linkURL: 'https://invalid.com',
-            };
-            const expectedMetadata = {
-                ...meta,
-                contentIDKey: meta.documentId.contentIdKey,
-                contentIDValue: meta.documentId.contentIdValue,
-            };
-
-            await client.logOpenSmartSnippetSuggestionInlineLink(fakeDocInfo, meta);
-            expectMatchDocumentPayload(
-                SearchPageEvents.openSmartSnippetSuggestionInlineLink,
-                fakeDocInfo,
-                expectedMetadata,
-            );
-        });
-        it('should send proper payload for #showMoreFoldedResults', async () => {
-            await client.logShowMoreFoldedResults(fakeDocInfo, fakeDocID);
-            expectMatchDocumentPayload(SearchPageEvents.showMoreFoldedResults, fakeDocInfo, fakeDocID);
-        });
-
-        it('should send proper payload for #showLessFoldedResults', async () => {
-            await client.logShowLessFoldedResults();
-            expectMatchCustomEventPayload(SearchPageEvents.showLessFoldedResults);
-        });
-
-        it('should send proper payload for #likeGeneratedAnswer', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-
-            await client.logLikeGeneratedAnswer(exampleGeneratedAnswerMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.likeGeneratedAnswer, exampleGeneratedAnswerMetadata);
-        });
-
-        it('should send proper payload for #dislikeGeneratedAnswer', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-
-            await client.logDislikeGeneratedAnswer(exampleGeneratedAnswerMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.dislikeGeneratedAnswer, exampleGeneratedAnswerMetadata);
-        });
-
-        it('should send proper payload for #openGeneratedAnswerSource', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-                permanentId: 'foo',
-                citationId: 'bar',
-            };
-
-            await client.logOpenGeneratedAnswerSource(exampleGeneratedAnswerMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.openGeneratedAnswerSource, exampleGeneratedAnswerMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerCitationClick', async () => {
-            const meta = {
-                generativeQuestionAnsweringId: '123',
-                citationId: 'bar',
-                documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
-            };
-
-            const expectedMetadata = {
-                ...meta,
-                contentIDKey: meta.documentId.contentIdKey,
-                contentIDValue: meta.documentId.contentIdValue,
-            };
-
-            await client.logGeneratedAnswerCitationClick(fakeDocInfo, meta);
-            expectMatchDocumentPayload(SearchPageEvents.generatedAnswerCitationClick, fakeDocInfo, expectedMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerSourceHover', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-                permanentId: 'foo',
-                citationId: 'bar',
-                citationHoverTimeMs: 100,
-            };
-
-            await client.logGeneratedAnswerSourceHover(exampleGeneratedAnswerMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerSourceHover, exampleGeneratedAnswerMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerCopyToClipboard', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-
-            await client.logGeneratedAnswerCopyToClipboard(exampleGeneratedAnswerMetadata);
-            expectMatchCustomEventPayload(
-                SearchPageEvents.generatedAnswerCopyToClipboard,
-                exampleGeneratedAnswerMetadata,
-            );
-        });
-
-        it('should send proper payload for #generatedAnswerHideAnswers', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-
-            await client.logGeneratedAnswerHideAnswers(exampleGeneratedAnswerMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerHideAnswers, exampleGeneratedAnswerMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerShowAnswers', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-
-            await client.logGeneratedAnswerShowAnswers(exampleGeneratedAnswerMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerShowAnswers, exampleGeneratedAnswerMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerExpand', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-
-            await client.logGeneratedAnswerExpand(exampleGeneratedAnswerMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerExpand, exampleGeneratedAnswerMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerCollapse', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-
-            await client.logGeneratedAnswerCollapse(exampleGeneratedAnswerMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerCollapse, exampleGeneratedAnswerMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerFeedbackSubmit', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-                reason: <GeneratedAnswerFeedbackReason>'other',
-                details: 'foo',
-            };
-
-            await client.logGeneratedAnswerFeedbackSubmit(exampleGeneratedAnswerMetadata);
-            expectMatchCustomEventPayload(
-                SearchPageEvents.generatedAnswerFeedbackSubmit,
-                exampleGeneratedAnswerMetadata,
-            );
-        });
-
-        it('should send proper payload for #rephraseGeneratedAnswer', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-                rephraseFormat: <GeneratedAnswerRephraseFormat>'step',
-            };
-
-            await client.logRephraseGeneratedAnswer(exampleGeneratedAnswerMetadata);
-            expectMatchPayload(SearchPageEvents.rephraseGeneratedAnswer, exampleGeneratedAnswerMetadata);
-        });
-
-        it('should send proper payload for #retryGeneratedAnswer', async () => {
-            await client.logRetryGeneratedAnswer();
-            expectMatchPayload(SearchPageEvents.retryGeneratedAnswer);
-        });
-
-        it('should send proper payload for #generatedAnswerStreamEnd', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-                answerGenerated: true,
-                answerTextIsEmpty: false,
-            };
-
-            await client.logGeneratedAnswerStreamEnd(exampleGeneratedAnswerMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerStreamEnd, exampleGeneratedAnswerMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerCitationDocumentAttach', async () => {
-            const meta = {
-                generativeQuestionAnsweringId: '123',
-                citationId: 'bar',
-                documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
-            };
-
-            const expectedMetadata = {
-                ...meta,
-                contentIDKey: meta.documentId.contentIdKey,
-                contentIDValue: meta.documentId.contentIdValue,
-            };
-
-            await client.logGeneratedAnswerCitationDocumentAttach(fakeDocInfo, meta);
-            expectMatchDocumentPayload(
-                SearchPageEvents.generatedAnswerCitationDocumentAttach,
-                fakeDocInfo,
-                expectedMetadata,
-            );
-        });
-
-        it('should send proper payload for #createArticle', async () => {
-            const exampleCreateArticleMetadata = {
-                articleType: 'Knowledge__kav',
-                triggeredBy: 'CreateArticleButton',
-            };
-            await client.logCreateArticle(exampleCreateArticleMetadata);
-            expectMatchCustomEventPayload(InsightEvents.createArticle, exampleCreateArticleMetadata);
-        });
-
-        it('should send proper payload for #logTriggerNotify', async () => {
-            const exampleTriggerNotifyMetadata = {
-                notifications: ['foo', 'bar'],
-            };
-            await client.logTriggerNotify(exampleTriggerNotifyMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.triggerNotify, exampleTriggerNotifyMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerFeedbackSubmitV2', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-                helpful: true,
-                readable: <GeneratedAnswerFeedbackReasonOption>'yes',
-                documented: <GeneratedAnswerFeedbackReasonOption>'no',
-                correctTopic: <GeneratedAnswerFeedbackReasonOption>'unknown',
-                hallucinationFree: <GeneratedAnswerFeedbackReasonOption>'yes',
-                details: 'foo',
-                documentUrl: 'https://document.com',
-            };
-
-            await client.logGeneratedAnswerFeedbackSubmitV2(exampleGeneratedAnswerMetadata);
-            expectMatchCustomEventPayload(
-                SearchPageEvents.generatedAnswerFeedbackSubmitV2,
-                exampleGeneratedAnswerMetadata,
-            );
-        });
-    });
-
-    describe('when the case metadata is included', () => {
-        it('should send proper payload for #interfaceLoad', async () => {
-            const metadata = baseCaseMetadata;
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-            };
-            await client.logInterfaceLoad(metadata);
-            expectMatchPayload(SearchPageEvents.interfaceLoad, expectedMetadata);
-        });
-
-        it('should send proper payload for #recentQueryClick', async () => {
-            const metadata = baseCaseMetadata;
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-            };
-            await client.logRecentQueryClick(metadata);
-            expectMatchPayload(SearchPageEvents.recentQueryClick, expectedMetadata);
-        });
-
-        it('should send proper payload for #clearRecentQueries', async () => {
-            const metadata = baseCaseMetadata;
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-            };
-            await client.logClearRecentQueries(metadata);
-            expectMatchCustomEventPayload(SearchPageEvents.clearRecentQueries, expectedMetadata);
-        });
-
-        it('should send proper payload for #interfaceChange', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                interfaceChangeTo: 'bob',
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-                interfaceChangeTo: 'bob',
-            };
-            await client.logInterfaceChange(metadata);
-            expectMatchPayload(SearchPageEvents.interfaceChange, expectedMetadata);
-        });
-
-        it('should send proper payload for #fetchMoreResults', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-                type: 'getMoreResults',
-            };
-            await client.logFetchMoreResults(metadata);
-            expectMatchCustomEventPayload(SearchPageEvents.pagerScrolling, expectedMetadata);
-        });
-
-        it('should send proper payload for #staticFilterDeselect', async () => {
-            const metadata: InsightStaticFilterToggleValueMetadata = {
-                ...baseCaseMetadata,
-                staticFilterId: 'filetypes',
-                staticFilterValue: {
-                    caption: 'Youtube',
-                    expression: '@filetype="youtubevideo"',
-                },
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-                staticFilterId: 'filetypes',
-                staticFilterValue: {
-                    caption: 'Youtube',
-                    expression: '@filetype="youtubevideo"',
-                },
-            };
-            await client.logStaticFilterDeselect(metadata);
-
-            expectMatchPayload(SearchPageEvents.staticFilterDeselect, expectedMetadata);
-        });
-
-        it('should send proper payload for #breadcrumbResetAll', async () => {
-            const metadata = baseCaseMetadata;
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-            };
-            await client.logBreadcrumbResetAll(metadata);
-            expectMatchPayload(SearchPageEvents.breadcrumbResetAll, expectedMetadata);
-        });
-
-        it('should send proper payload for #breadcrumbFacet', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                facetValue: 'qwerty',
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                facetValue: 'qwerty',
-            };
-            await client.logBreadcrumbFacet(metadata);
-            expectMatchPayload(SearchPageEvents.breadcrumbFacet, expectedMetadata);
-        });
-
-        it('should send proper payload for #logFacetSelect', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                facetValue: 'qwerty',
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                facetValue: 'qwerty',
-            };
-
-            await client.logFacetSelect(metadata);
-            expectMatchPayload(SearchPageEvents.facetSelect, expectedMetadata);
-        });
-
-        it('should send proper payload for #logFacetExclude', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                facetValue: 'qwerty',
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                facetValue: 'qwerty',
-            };
-
-            await client.logFacetExclude(metadata);
-            expectMatchPayload(SearchPageEvents.facetExclude, expectedMetadata);
-        });
-
-        it('should send proper payload for #logFacetDeselect', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                facetValue: 'qwerty',
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                facetValue: 'qwerty',
-            };
-
-            await client.logFacetDeselect(metadata);
-            expectMatchPayload(SearchPageEvents.facetDeselect, expectedMetadata);
-        });
-
-        it('should send proper payload for #logFacetUpdateSort', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                criteria: 'bazz',
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-                criteria: 'bazz',
-            };
-            await client.logFacetUpdateSort(metadata);
-            expectMatchPayload(SearchPageEvents.facetUpdateSort, expectedMetadata);
-        });
-
-        it('should send proper payload for #logFacetClearAll', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-            };
-            await client.logFacetClearAll(metadata);
-            expectMatchPayload(SearchPageEvents.facetClearAll, expectedMetadata);
-        });
-
-        it('should send proper payload for #logFacetShowMore', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-            };
-            await client.logFacetShowMore(metadata);
-            expectMatchCustomEventPayload(SearchPageEvents.facetShowMore, expectedMetadata);
-        });
-
-        it('should send proper payload for #logFacetShowLess', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                facetField: '@foo',
-                facetId: 'bar',
-                facetTitle: 'title',
-            };
-            await client.logFacetShowLess(metadata);
-            expectMatchCustomEventPayload(SearchPageEvents.facetShowLess, expectedMetadata);
-        });
-
-        it('should send proper payload for #logQueryError', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                query: 'q',
-                aq: 'aq',
-                cq: 'cq',
-                dq: 'dq',
-                errorMessage: 'boom',
-                errorType: 'a bad one',
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                query: 'q',
-                aq: 'aq',
-                cq: 'cq',
-                dq: 'dq',
-                errorMessage: 'boom',
-                errorType: 'a bad one',
-            };
-            await client.logQueryError(metadata);
-            expectMatchCustomEventPayload(SearchPageEvents.queryError, expectedMetadata);
-        });
-
-        it('should send proper payload for #logPagerNumber', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                pagerNumber: 123,
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                pagerNumber: 123,
-            };
-            await client.logPagerNumber(metadata);
-            expectMatchCustomEventPayload(SearchPageEvents.pagerNumber, expectedMetadata);
-        });
-
-        it('should send proper payload for #logPagerNext', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                pagerNumber: 123,
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                pagerNumber: 123,
-            };
-            await client.logPagerNext(metadata);
-            expectMatchCustomEventPayload(SearchPageEvents.pagerNext, expectedMetadata);
-        });
-
-        it('should send proper payload for #logPagerPrevious', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                pagerNumber: 123,
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                pagerNumber: 123,
-            };
-            await client.logPagerPrevious(metadata);
-            expectMatchCustomEventPayload(SearchPageEvents.pagerPrevious, expectedMetadata);
-        });
-
-        it('should send proper payload for #didyoumeanAutomatic', async () => {
-            const metadata = baseCaseMetadata;
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-            };
-            await client.logDidYouMeanAutomatic(metadata);
-            expectMatchPayload(SearchPageEvents.didyoumeanAutomatic, expectedMetadata);
-        });
-
-        it('should send proper payload for #didyoumeanClick', async () => {
-            const metadata = baseCaseMetadata;
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-            };
-            await client.logDidYouMeanClick(metadata);
-            expectMatchPayload(SearchPageEvents.didyoumeanClick, expectedMetadata);
-        });
-
-        it('should send proper payload for #resultsSort', async () => {
-            const metadata = {
-                ...baseCaseMetadata,
-                resultsSortBy: 'date ascending',
-            };
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-                resultsSortBy: 'date ascending',
-            };
-            await client.logResultsSort(metadata);
-            expectMatchPayload(SearchPageEvents.resultsSort, expectedMetadata);
-        });
-
-        it('should send proper payload for #searchboxSubmit', async () => {
-            const metadata = baseCaseMetadata;
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                context_Case_Subject: 'test subject',
-                context_Case_Description: 'test description',
-            };
-            await client.logSearchboxSubmit(metadata);
-            expectMatchPayload(SearchPageEvents.searchboxSubmit, expectedMetadata);
-        });
-
-        it('should send proper payload for #documentOpen', async () => {
-            const metadata = baseCaseMetadata;
-
-            const expectedMetadata = {
-                ...fakeDocID,
-                ...expectedBaseCaseMetadata,
-            };
-            await client.logDocumentOpen(fakeDocInfo, fakeDocID, metadata);
-            expectMatchDocumentPayload(SearchPageEvents.documentOpen, fakeDocInfo, expectedMetadata);
-        });
-
-        it('should send proper payload for #copyToClipboard', async () => {
-            const metadata = baseCaseMetadata;
-
-            const expectedMetadata = {
-                ...fakeDocID,
-                ...expectedBaseCaseMetadata,
-            };
-            await client.logCopyToClipboard(fakeDocInfo, fakeDocID, metadata);
-            expectMatchDocumentPayload(SearchPageEvents.copyToClipboard, fakeDocInfo, expectedMetadata);
-        });
-
-        it('should send proper payload for #caseSendEmail', async () => {
-            const metadata = baseCaseMetadata;
-
-            const expectedMetadata = {
-                ...fakeDocID,
-                ...expectedBaseCaseMetadata,
-            };
-            await client.logCaseSendEmail(fakeDocInfo, fakeDocID, metadata);
-            expectMatchDocumentPayload(SearchPageEvents.caseSendEmail, fakeDocInfo, expectedMetadata);
-        });
-
-        it('should send proper payload for #feedItemTextPost', async () => {
-            const metadata = baseCaseMetadata;
-
-            const expectedMetadata = {
-                ...fakeDocID,
-                ...expectedBaseCaseMetadata,
-            };
-            await client.logFeedItemTextPost(fakeDocInfo, fakeDocID, metadata);
-            expectMatchDocumentPayload(SearchPageEvents.feedItemTextPost, fakeDocInfo, expectedMetadata);
-        });
-
-        it('should send proper payload for #documentQuickview', async () => {
-            const metadata = baseCaseMetadata;
-
-            const expectedMetadata = {
-                ...fakeDocID,
-                ...expectedBaseCaseMetadata,
-                documentTitle: fakeDocInfo.documentTitle,
-                documentURL: fakeDocInfo.documentUrl,
-            };
-            await client.logDocumentQuickview(fakeDocInfo, fakeDocID, metadata);
-            expectMatchDocumentPayload(SearchPageEvents.documentQuickview, fakeDocInfo, expectedMetadata);
-        });
-
-        it('should send proper payload for #caseAttach', async () => {
-            const metadata = baseCaseMetadata;
-
-            const expectedMetadata = {
-                ...fakeDocID,
-                ...expectedBaseCaseMetadata,
-                documentTitle: fakeDocInfo.documentTitle,
-                documentURL: fakeDocInfo.documentUrl,
-                resultUriHash: fakeDocInfo.documentUriHash,
-            };
-            await client.logCaseAttach(fakeDocInfo, fakeDocID, metadata);
-            expectMatchDocumentPayload(SearchPageEvents.caseAttach, fakeDocInfo, expectedMetadata);
-        });
-
-        it('should send proper payload for #caseDetach', async () => {
-            const metadata = baseCaseMetadata;
-            const mockResultUriHash = fakeDocInfo.documentUriHash;
-            const mockPermanentId = fakeDocID.contentIDValue;
-
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-                resultUriHash: mockResultUriHash,
-                permanentId: mockPermanentId,
-            };
-            await client.logCaseDetach(mockResultUriHash, metadata, mockPermanentId);
-            expectMatchCustomEventPayload(SearchPageEvents.caseDetach, expectedMetadata);
-        });
-
-        it('should send proper payload for #likeSmartSnippet', async () => {
-            await client.logLikeSmartSnippet(baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.likeSmartSnippet, expectedBaseCaseMetadata);
-        });
-
-        it('should send proper payload for #dislikeSmartSnippet', async () => {
-            await client.logDislikeSmartSnippet(baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.dislikeSmartSnippet, expectedBaseCaseMetadata);
-        });
-
-        it('should send proper payload for #expandSmartSnippet', async () => {
-            await client.logExpandSmartSnippet(baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.expandSmartSnippet, expectedBaseCaseMetadata);
-        });
-
-        it('should send proper payload for #collapseSmartSnippet', async () => {
-            await client.logCollapseSmartSnippet(baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.collapseSmartSnippet, expectedBaseCaseMetadata);
-        });
-
-        it('should send proper payload for #openSmartSnippetFeedbackModal', async () => {
-            await client.logOpenSmartSnippetFeedbackModal(baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.openSmartSnippetFeedbackModal, expectedBaseCaseMetadata);
-        });
-
-        it('should send proper payload for #closeSmartSnippetFeedbackModal', async () => {
-            await client.logCloseSmartSnippetFeedbackModal(baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.closeSmartSnippetFeedbackModal, expectedBaseCaseMetadata);
-        });
-
-        it('should send proper payload for #sendSmartSnippetReason', async () => {
-            const reason = 'other';
-            const details = 'example details';
-            const expectedMetadata = {
-                reason,
-                details,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logSmartSnippetFeedbackReason(reason, details, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.sendSmartSnippetReason, expectedMetadata);
-        });
-
-        it('should send proper payload for #expandSmartSnippetSuggestion', async () => {
-            const exampleSmartSnippetSuggestion = {
-                question: 'Abc',
-                answerSnippet: 'Def',
-                documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
-            };
-            const expectedMetadata = {
-                ...exampleSmartSnippetSuggestion,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logExpandSmartSnippetSuggestion(exampleSmartSnippetSuggestion, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.expandSmartSnippetSuggestion, expectedMetadata);
-        });
-
-        it('should send proper payload for #collapseSmartSnippetSuggestion', async () => {
-            const exampleSmartSnippetSuggestion = {
-                question: 'Abc',
-                answerSnippet: 'Def',
-                documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
-            };
-            const expectedMetadata = {
-                ...exampleSmartSnippetSuggestion,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logCollapseSmartSnippetSuggestion(exampleSmartSnippetSuggestion, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.collapseSmartSnippetSuggestion, expectedMetadata);
-        });
-
-        it('should send proper payload for #openSmartSnippetSource', async () => {
-            const expectedMetadata = {
-                ...fakeDocID,
-                ...expectedBaseCaseMetadata,
-            };
-            await client.logOpenSmartSnippetSource(fakeDocInfo, fakeDocID, baseCaseMetadata);
-            expectMatchDocumentPayload(SearchPageEvents.openSmartSnippetSource, fakeDocInfo, expectedMetadata);
-        });
-
-        it('should send proper payload for #openSmartSnippetInlineLink', async () => {
-            const meta = {
-                ...fakeDocID,
-                linkText: 'Some text',
-                linkURL: 'https://invalid.com',
-            };
-            const expectedMetadata = {
-                ...meta,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logOpenSmartSnippetInlineLink(fakeDocInfo, meta, baseCaseMetadata);
-            expectMatchDocumentPayload(SearchPageEvents.openSmartSnippetInlineLink, fakeDocInfo, expectedMetadata);
-        });
-
-        it('should send proper payload for #openSmartSnippetSuggestionSource', async () => {
-            const meta = {
-                question: 'Abc',
-                answerSnippet: 'Def',
-                documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
-            };
-
-            const expectedMetadata = {
-                ...meta,
-                ...expectedBaseCaseMetadata,
-                contentIDKey: meta.documentId.contentIdKey,
-                contentIDValue: meta.documentId.contentIdValue,
-            };
-
-            await client.logOpenSmartSnippetSuggestionSource(fakeDocInfo, meta, baseCaseMetadata);
-            expectMatchDocumentPayload(
-                SearchPageEvents.openSmartSnippetSuggestionSource,
-                fakeDocInfo,
-                expectedMetadata,
-            );
-        });
-
-        it('should send proper payload for #openSmartSnippetSuggestionInlineLink', async () => {
-            const meta = {
-                question: 'Abc',
-                answerSnippet: 'Def',
-                documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
-                linkText: 'Some text',
-                linkURL: 'https://invalid.com',
-            };
-            const expectedMetadata = {
-                ...meta,
-                ...expectedBaseCaseMetadata,
-                contentIDKey: meta.documentId.contentIdKey,
-                contentIDValue: meta.documentId.contentIdValue,
-            };
-
-            await client.logOpenSmartSnippetSuggestionInlineLink(fakeDocInfo, meta, baseCaseMetadata);
-            expectMatchDocumentPayload(
-                SearchPageEvents.openSmartSnippetSuggestionInlineLink,
-                fakeDocInfo,
-                expectedMetadata,
-            );
-        });
-
-        it('should send proper payload for #showMoreFoldedResults', async () => {
-            const expectedMetadata = {
-                ...fakeDocID,
-                ...expectedBaseCaseMetadata,
-            };
-            await client.logShowMoreFoldedResults(fakeDocInfo, fakeDocID, baseCaseMetadata);
-            expectMatchDocumentPayload(SearchPageEvents.showMoreFoldedResults, fakeDocInfo, expectedMetadata);
-        });
-
-        it('should send proper payload for #showLessFoldedResults', async () => {
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-            };
-            await client.logShowLessFoldedResults(baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.showLessFoldedResults, expectedMetadata);
-        });
-
-        it('should send proper payload for #likeGeneratedAnswer', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-            const expectedMetadata = {
-                ...exampleGeneratedAnswerMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logLikeGeneratedAnswer(exampleGeneratedAnswerMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.likeGeneratedAnswer, expectedMetadata);
-        });
-
-        it('should send proper payload for #dislikeGeneratedAnswer', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-            const expectedMetadata = {
-                ...exampleGeneratedAnswerMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logDislikeGeneratedAnswer(exampleGeneratedAnswerMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.dislikeGeneratedAnswer, expectedMetadata);
-        });
-
-        it('should send proper payload for #openGeneratedAnswerSource', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-                permanentId: 'foo',
-                citationId: 'bar',
-            };
-            const expectedMetadata = {
-                ...exampleGeneratedAnswerMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logOpenGeneratedAnswerSource(exampleGeneratedAnswerMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.openGeneratedAnswerSource, expectedMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerCitationClick', async () => {
-            const meta = {
-                generativeQuestionAnsweringId: '123',
-                citationId: 'bar',
-                documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
-            };
-
-            const expectedMetadata = {
-                ...meta,
-                contentIDKey: meta.documentId.contentIdKey,
-                contentIDValue: meta.documentId.contentIdValue,
-            };
-
-            await client.logGeneratedAnswerCitationClick(fakeDocInfo, meta, baseCaseMetadata);
-            expectMatchDocumentPayload(SearchPageEvents.generatedAnswerCitationClick, fakeDocInfo, expectedMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerSourceHover', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-                permanentId: 'foo',
-                citationId: 'bar',
-                citationHoverTimeMs: 100,
-            };
-            const expectedMetadata = {
-                ...exampleGeneratedAnswerMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logGeneratedAnswerSourceHover(exampleGeneratedAnswerMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerSourceHover, expectedMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerCopyToClipboard', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-            const expectedMetadata = {
-                ...exampleGeneratedAnswerMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logGeneratedAnswerCopyToClipboard(exampleGeneratedAnswerMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerCopyToClipboard, expectedMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerHideAnswers', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-            const expectedMetadata = {
-                ...exampleGeneratedAnswerMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logGeneratedAnswerHideAnswers(exampleGeneratedAnswerMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerHideAnswers, expectedMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerShowAnswers', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-            const expectedMetadata = {
-                ...exampleGeneratedAnswerMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logGeneratedAnswerShowAnswers(exampleGeneratedAnswerMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerShowAnswers, expectedMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerExpand', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-            const expectedMetadata = {
-                ...exampleGeneratedAnswerMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logGeneratedAnswerExpand(exampleGeneratedAnswerMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerExpand, expectedMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerCollapse', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-            };
-            const expectedMetadata = {
-                ...exampleGeneratedAnswerMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logGeneratedAnswerCollapse(exampleGeneratedAnswerMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerCollapse, expectedMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerFeedbackSubmit', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-                reason: <GeneratedAnswerFeedbackReason>'other',
-                details: 'foo',
-            };
-            const expectedMetadata = {
-                ...exampleGeneratedAnswerMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logGeneratedAnswerFeedbackSubmit(exampleGeneratedAnswerMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerFeedbackSubmit, expectedMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerFeedbackSubmitV2', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-                helpful: true,
-                readable: <GeneratedAnswerFeedbackReasonOption>'yes',
-                documented: <GeneratedAnswerFeedbackReasonOption>'no',
-                correctTopic: <GeneratedAnswerFeedbackReasonOption>'unknown',
-                hallucinationFree: <GeneratedAnswerFeedbackReasonOption>'yes',
-                details: 'foo',
-                documentUrl: 'https://document.com',
-            };
-            const expectedMetadata = {
-                ...exampleGeneratedAnswerMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logGeneratedAnswerFeedbackSubmitV2(exampleGeneratedAnswerMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerFeedbackSubmitV2, expectedMetadata);
-        });
-
-        it('should send proper payload for #rephraseGeneratedAnswer', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-                rephraseFormat: <GeneratedAnswerRephraseFormat>'step',
-            };
-            const expectedMetadata = {
-                ...exampleGeneratedAnswerMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logRephraseGeneratedAnswer(exampleGeneratedAnswerMetadata, baseCaseMetadata);
-            expectMatchPayload(SearchPageEvents.rephraseGeneratedAnswer, expectedMetadata);
-        });
-
-        it('should send proper payload for #retryGeneratedAnswer', async () => {
-            const expectedMetadata = {
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logRetryGeneratedAnswer(baseCaseMetadata);
-            expectMatchPayload(SearchPageEvents.retryGeneratedAnswer, expectedMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerStreamEnd', async () => {
-            const exampleGeneratedAnswerMetadata = {
-                generativeQuestionAnsweringId: '123',
-                answerGenerated: true,
-                answerTextIsEmpty: false,
-            };
-            const expectedMetadata = {
-                ...exampleGeneratedAnswerMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-
-            await client.logGeneratedAnswerStreamEnd(exampleGeneratedAnswerMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.generatedAnswerStreamEnd, expectedMetadata);
-        });
-
-        it('should send proper payload for #generatedAnswerCitationDocumentAttach', async () => {
-            const meta = {
-                generativeQuestionAnsweringId: '123',
-                citationId: 'bar',
-                documentId: {contentIdKey: 'permanentid', contentIdValue: 'foo'},
-            };
-
-            const expectedMetadata = {
-                ...meta,
-                ...expectedBaseCaseMetadata,
-                contentIDKey: meta.documentId.contentIdKey,
-                contentIDValue: meta.documentId.contentIdValue,
-            };
-
-            await client.logGeneratedAnswerCitationDocumentAttach(fakeDocInfo, meta, baseCaseMetadata);
-            expectMatchDocumentPayload(
-                SearchPageEvents.generatedAnswerCitationDocumentAttach,
-                fakeDocInfo,
-                expectedMetadata,
-            );
-        });
-
-        it('should send proper payload for #createArticle', async () => {
-            const exampleCreateArticleMetadata = {
-                articleType: 'Knowledge__kav',
-            };
-            const expectedMetadata = {
-                ...exampleCreateArticleMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-            await client.logCreateArticle(exampleCreateArticleMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(InsightEvents.createArticle, expectedMetadata);
-        });
-
-        it('should send proper payload for #logTriggerNotify', async () => {
-            const exampleTriggerNotifyMetadata = {
-                notifications: ['foo', 'bar'],
-            };
-            const expectedMetadata = {
-                ...exampleTriggerNotifyMetadata,
-                ...expectedBaseCaseMetadata,
-            };
-            await client.logTriggerNotify(exampleTriggerNotifyMetadata, baseCaseMetadata);
-            expectMatchCustomEventPayload(SearchPageEvents.triggerNotify, expectedMetadata);
-        });
-    });
-
-    it('should enable analytics tracking by default', () => {
-        const c = new CoveoInsightClient({}, provider);
-        expect(c.coveoAnalyticsClient instanceof CoveoAnalyticsClient).toBe(true);
-    });
-
-    it('should allow disabling analytics on initialization', () => {
-        const c = new CoveoInsightClient({enableAnalytics: false}, provider);
-        expect(c.coveoAnalyticsClient instanceof NoopAnalytics).toBe(true);
-    });
-
-    it('should allow disabling analytics after initialization', () => {
-        const c = new CoveoInsightClient({enableAnalytics: true}, provider);
-        expect(c.coveoAnalyticsClient instanceof CoveoAnalyticsClient).toBe(true);
-        c.disable();
-        expect(c.coveoAnalyticsClient instanceof NoopAnalytics).toBe(true);
-    });
-
-    it('disabling analytics does not delete the visitorId', () => {
-        const visitorId = 'uuid';
-        Cookie.set('coveo_visitorId', visitorId);
-        const c = new CoveoInsightClient({enableAnalytics: true}, provider);
-
-        expect(Cookie.get('coveo_visitorId')).toBe(visitorId);
-        c.disable();
-        expect(Cookie.get('coveo_visitorId')).toBe(visitorId);
-    });
-
-    it('should disable analytics when doNotTrack is enabled', async () => {
-        (doNotTrack as jest.Mock).mockImplementationOnce(() => true);
-
-        const c = new CoveoInsightClient({}, provider);
-        expect(c.coveoAnalyticsClient instanceof NoopAnalytics).toBe(true);
-    });
-
-    it('should allow enabling analytics after initialization', () => {
-        const c = new CoveoInsightClient({enableAnalytics: false}, provider);
-        expect(c.coveoAnalyticsClient instanceof NoopAnalytics).toBe(true);
-        c.enable();
-        expect(c.coveoAnalyticsClient instanceof CoveoAnalyticsClient).toBe(true);
-    });
-
-    it('should send proper payload for #contextChanged', async () => {
-        const meta = {
-            caseId: '1234',
-            caseNumber: '5678',
-            caseContext: {Case_Subject: 'test subject', Case_Description: 'test description'},
-        };
-
-        const expectedMeta = {
-            CaseId: '1234',
-            CaseNumber: '5678',
-            CaseSubject: 'test subject',
-            context_Case_Subject: 'test subject',
-            context_Case_Description: 'test description',
-        };
-
-        await client.logContextChanged(meta);
-        expectMatchPayload(InsightEvents.contextChanged, expectedMeta);
-    });
-
-    it('should send proper payload for #expandToFullUI', async () => {
-        const meta = {
-            caseId: '1234',
-            caseNumber: '5678',
-            caseContext: {Case_Subject: 'test subject', Case_Description: 'test description'},
-            fullSearchComponentName: 'c__FullSearch',
-            triggeredBy: 'openFullSearchButton',
-        };
-
-        const expectedMeta = {
-            CaseId: '1234',
-            CaseNumber: '5678',
-            CaseSubject: 'test subject',
-            fullSearchComponentName: 'c__FullSearch',
-            triggeredBy: 'openFullSearchButton',
-        };
-        await client.logExpandToFullUI(meta);
-        expectMatchCustomEventPayload(InsightEvents.expandToFullUI, expectedMeta);
-    });
-
-    it('should send proper payload for #logOpenUserActions', async () => {
-        await client.logOpenUserActions(baseCaseMetadata);
-        expectMatchCustomEventPayload(InsightEvents.openUserActions, expectedBaseCaseMetadata);
-    });
-
-    it('should send proper payload for #logShowPrecedingSession', async () => {
-        await client.logShowPrecedingSessions(baseCaseMetadata);
-        expectMatchCustomEventPayload(InsightEvents.showPrecedingSessions, expectedBaseCaseMetadata);
-    });
-
-    it('should send proper payload for #logShowFollowingSession', async () => {
-        await client.logShowFollowingSessions(baseCaseMetadata);
-        expectMatchCustomEventPayload(InsightEvents.showFollowingSessions, expectedBaseCaseMetadata);
-    });
+    await client.logContextChanged(meta);
+    expectMatchPayload(InsightEvents.contextChanged, expectedMeta);
+  });
+
+  it('should send proper payload for #expandToFullUI', async () => {
+    const meta = {
+      caseId: '1234',
+      caseNumber: '5678',
+      caseContext: {
+        Case_Subject: 'test subject',
+        Case_Description: 'test description',
+      },
+      fullSearchComponentName: 'c__FullSearch',
+      triggeredBy: 'openFullSearchButton',
+    };
 
-    it('should send proper payload for #logViewedDocumentClick', async () => {
-        const document = {
-            title: 'Some Title',
-            uri: 'https://www.some-uri.com',
-            uriHash: 'Acp8NfEWi0DeðeZU',
-            permanentId: '8c88cd894t2767a96fa4f109041bb62bb54ca21ff31c1d760814b60cbcf2',
-        };
-        await client.logViewedDocumentClick(document, baseCaseMetadata);
-        expectMatchCustomEventPayload(InsightEvents.clickViewedDocument, {
-            ...expectedBaseCaseMetadata,
-            document,
-        });
+    const expectedMeta = {
+      CaseId: '1234',
+      CaseNumber: '5678',
+      CaseSubject: 'test subject',
+      fullSearchComponentName: 'c__FullSearch',
+      triggeredBy: 'openFullSearchButton',
+    };
+    await client.logExpandToFullUI(meta);
+    expectMatchCustomEventPayload(InsightEvents.expandToFullUI, expectedMeta);
+  });
+
+  it('should send proper payload for #logOpenUserActions', async () => {
+    await client.logOpenUserActions(baseCaseMetadata);
+    expectMatchCustomEventPayload(InsightEvents.openUserActions, expectedBaseCaseMetadata);
+  });
+
+  it('should send proper payload for #logShowPrecedingSession', async () => {
+    await client.logShowPrecedingSessions(baseCaseMetadata);
+    expectMatchCustomEventPayload(InsightEvents.showPrecedingSessions, expectedBaseCaseMetadata);
+  });
+
+  it('should send proper payload for #logShowFollowingSession', async () => {
+    await client.logShowFollowingSessions(baseCaseMetadata);
+    expectMatchCustomEventPayload(InsightEvents.showFollowingSessions, expectedBaseCaseMetadata);
+  });
+
+  it('should send proper payload for #logViewedDocumentClick', async () => {
+    const document = {
+      title: 'Some Title',
+      uri: 'https://www.some-uri.com',
+      uriHash: 'testUriHash',
+      permanentId: '8c88cd894t2767a96fa4f109041bb62bb54ca21ff31c1d760814b60cbcf2',
+    };
+    await client.logViewedDocumentClick(document, baseCaseMetadata);
+    expectMatchCustomEventPayload(InsightEvents.clickViewedDocument, {
+      ...expectedBaseCaseMetadata,
+      document,
     });
+  });
 
-    it('should send proper payload for #logPageViewClick', async () => {
-        const pageView = {
-            title: 'Some Title',
-            contentIdKey: 'someKey',
-            contentIdValue: 'some-content-id-value',
-        };
-        await client.logPageViewClick(pageView, baseCaseMetadata);
-        expectMatchCustomEventPayload(InsightEvents.clickPageView, {
-            ...expectedBaseCaseMetadata,
-            pageView,
-        });
+  it('should send proper payload for #logPageViewClick', async () => {
+    const pageView = {
+      title: 'Some Title',
+      contentIdKey: 'someKey',
+      contentIdValue: 'some-content-id-value',
+    };
+    await client.logPageViewClick(pageView, baseCaseMetadata);
+    expectMatchCustomEventPayload(InsightEvents.clickPageView, {
+      ...expectedBaseCaseMetadata,
+      pageView,
     });
+  });
 });