coveo.analytics 2.20.1 → 2.20.4

package/dist/definitions/coveoua/headless.d.ts

@@ -1,5 +1,6 @@
 export { CoveoSearchPageClient, SearchPageClientProvider } from '../searchPage/searchPageClient';
 export { CaseAssistClient, CaseAssistClientProvider } from '../caseAssist/caseAssistClient';
+export { CoveoInsightClient, InsightClientProvider } from '../insight/insightClient';
 export { CoveoAnalyticsClient, AnalyticsClientSendEventHook } from '../client/analytics';
 export { PreprocessAnalyticsRequest } from '../client/analyticsRequestClient';
 export * as history from '../history';

package/dist/definitions/coveoua/library.d.ts

@@ -9,4 +9,5 @@ export { IRuntimeEnvironment } from '../client/runtimeEnvironment';
 export { CoveoUA, getCurrentClient, handleOneAnalyticsEvent } from './simpleanalytics';
 export { CoveoSearchPageClient, SearchPageClientProvider } from '../searchPage/searchPageClient';
 export { CaseAssistClient, CaseAssistClientProvider } from '../caseAssist/caseAssistClient';
+export { CoveoInsightClient, InsightClientProvider } from '../insight/insightClient';
 export { analytics, donottrack, history, SimpleAnalytics, storage };

package/dist/definitions/insight/insightClient.d.ts

@@ -0,0 +1,43 @@
+import { AnalyticsClient, ClientOptions } from '../client/analytics';
+import { SearchEventRequest } from '../events';
+import { FacetBaseMeta, FacetMetadata, FacetSortMeta, FacetStateMetadata, QueryErrorMeta, SearchPageEvents } from '../searchPage/searchPageEvents';
+export interface InsightClientProvider {
+    getSearchEventRequestPayload: () => Omit<SearchEventRequest, 'actionCause' | 'searchQueryUid'>;
+    getSearchUID: () => string;
+    getBaseMetadata: () => Record<string, any>;
+    getPipeline: () => string;
+    getOriginContext?: () => string;
+    getOriginLevel1: () => string;
+    getOriginLevel2: () => string;
+    getOriginLevel3: () => string;
+    getLanguage: () => string;
+    getIsAnonymous: () => boolean;
+    getFacetState?: () => FacetStateMetadata[];
+}
+export interface InsightClientOptions extends ClientOptions {
+    enableAnalytics: boolean;
+}
+export declare class CoveoInsightClient {
+    private opts;
+    private provider;
+    coveoAnalyticsClient: AnalyticsClient;
+    constructor(opts: Partial<InsightClientOptions>, provider: InsightClientProvider);
+    disable(): void;
+    enable(): void;
+    logInterfaceLoad(): Promise<void | import("../events").SearchEventResponse>;
+    logFetchMoreResults(): Promise<void | import("../events").CustomEventResponse>;
+    logFacetSelect(meta: FacetMetadata): Promise<void | import("../events").SearchEventResponse>;
+    logFacetDeselect(meta: FacetMetadata): Promise<void | import("../events").SearchEventResponse>;
+    logFacetUpdateSort(meta: FacetSortMeta): Promise<void | import("../events").SearchEventResponse>;
+    logFacetClearAll(meta: FacetBaseMeta): Promise<void | import("../events").SearchEventResponse>;
+    logFacetShowMore(meta: FacetBaseMeta): Promise<void | import("../events").CustomEventResponse>;
+    logFacetShowLess(meta: FacetBaseMeta): Promise<void | import("../events").CustomEventResponse>;
+    logQueryError(meta: QueryErrorMeta): Promise<void | import("../events").CustomEventResponse>;
+    logCustomEvent(event: SearchPageEvents, metadata?: Record<string, any>): Promise<void | import("../events").CustomEventResponse>;
+    logSearchEvent(event: SearchPageEvents, metadata?: Record<string, any>): Promise<void | import("../events").SearchEventResponse>;
+    private getBaseCustomEventRequest;
+    private getBaseSearchEventRequest;
+    private getBaseEventRequest;
+    private getOrigins;
+    private getClientId;
+}

package/dist/definitions/src/coveoua/headless.d.ts

@@ -1,5 +1,6 @@
 export { CoveoSearchPageClient, SearchPageClientProvider } from '../searchPage/searchPageClient';
 export { CaseAssistClient, CaseAssistClientProvider } from '../caseAssist/caseAssistClient';
+export { CoveoInsightClient, InsightClientProvider } from '../insight/insightClient';
 export { CoveoAnalyticsClient, AnalyticsClientSendEventHook } from '../client/analytics';
 export { PreprocessAnalyticsRequest } from '../client/analyticsRequestClient';
 export * as history from '../history';

package/dist/definitions/src/coveoua/library.d.ts

@@ -9,4 +9,5 @@ export { IRuntimeEnvironment } from '../client/runtimeEnvironment';
 export { CoveoUA, getCurrentClient, handleOneAnalyticsEvent } from './simpleanalytics';
 export { CoveoSearchPageClient, SearchPageClientProvider } from '../searchPage/searchPageClient';
 export { CaseAssistClient, CaseAssistClientProvider } from '../caseAssist/caseAssistClient';
+export { CoveoInsightClient, InsightClientProvider } from '../insight/insightClient';
 export { analytics, donottrack, history, SimpleAnalytics, storage };

package/dist/library.es.js

@@ -1765,4 +1765,91 @@ class CaseAssistClient {
     }
 }
 
-export { CaseAssistClient, CoveoAnalyticsClient, CoveoSearchPageClient, history };
+class CoveoInsightClient {
+    constructor(opts, provider) {
+        this.opts = opts;
+        this.provider = provider;
+        const shouldDisableAnalytics = opts.enableAnalytics === false || doNotTrack();
+        this.coveoAnalyticsClient = shouldDisableAnalytics ? new NoopAnalytics() : new CoveoAnalyticsClient(opts);
+    }
+    disable() {
+        if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+            this.coveoAnalyticsClient.clear();
+        }
+        this.coveoAnalyticsClient = new NoopAnalytics();
+    }
+    enable() {
+        this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.opts);
+    }
+    logInterfaceLoad() {
+        return this.logSearchEvent(SearchPageEvents.interfaceLoad);
+    }
+    logFetchMoreResults() {
+        return this.logCustomEvent(SearchPageEvents.pagerScrolling, { type: 'getMoreResults' });
+    }
+    logFacetSelect(meta) {
+        return this.logSearchEvent(SearchPageEvents.facetSelect, meta);
+    }
+    logFacetDeselect(meta) {
+        return this.logSearchEvent(SearchPageEvents.facetDeselect, meta);
+    }
+    logFacetUpdateSort(meta) {
+        return this.logSearchEvent(SearchPageEvents.facetUpdateSort, meta);
+    }
+    logFacetClearAll(meta) {
+        return this.logSearchEvent(SearchPageEvents.facetClearAll, meta);
+    }
+    logFacetShowMore(meta) {
+        return this.logCustomEvent(SearchPageEvents.facetShowMore, meta);
+    }
+    logFacetShowLess(meta) {
+        return this.logCustomEvent(SearchPageEvents.facetShowLess, meta);
+    }
+    logQueryError(meta) {
+        return this.logCustomEvent(SearchPageEvents.queryError, meta);
+    }
+    logCustomEvent(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customData = Object.assign(Object.assign({}, this.provider.getBaseMetadata()), metadata);
+            const payload = Object.assign(Object.assign({}, (yield this.getBaseCustomEventRequest(customData))), { eventType: CustomEventsTypes[event], eventValue: event });
+            return this.coveoAnalyticsClient.sendCustomEvent(payload);
+        });
+    }
+    logSearchEvent(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.coveoAnalyticsClient.sendSearchEvent(yield this.getBaseSearchEventRequest(event, metadata));
+        });
+    }
+    getBaseCustomEventRequest(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign(Object.assign({}, (yield this.getBaseEventRequest(metadata))), { lastSearchQueryUid: this.provider.getSearchUID() });
+        });
+    }
+    getBaseSearchEventRequest(event, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign(Object.assign(Object.assign({}, (yield this.getBaseEventRequest(metadata))), this.provider.getSearchEventRequestPayload()), { searchQueryUid: this.provider.getSearchUID(), queryPipeline: this.provider.getPipeline(), actionCause: event });
+        });
+    }
+    getBaseEventRequest(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customData = Object.assign(Object.assign({}, this.provider.getBaseMetadata()), metadata);
+            return Object.assign(Object.assign({}, this.getOrigins()), { customData, language: this.provider.getLanguage(), facetState: this.provider.getFacetState ? this.provider.getFacetState() : [], anonymous: this.provider.getIsAnonymous(), clientId: yield this.getClientId() });
+        });
+    }
+    getOrigins() {
+        var _a, _b;
+        return {
+            originContext: (_b = (_a = this.provider).getOriginContext) === null || _b === void 0 ? void 0 : _b.call(_a),
+            originLevel1: this.provider.getOriginLevel1(),
+            originLevel2: this.provider.getOriginLevel2(),
+            originLevel3: this.provider.getOriginLevel3(),
+        };
+    }
+    getClientId() {
+        return this.coveoAnalyticsClient instanceof CoveoAnalyticsClient
+            ? this.coveoAnalyticsClient.getCurrentVisitorId()
+            : undefined;
+    }
+}
+
+export { CaseAssistClient, CoveoAnalyticsClient, CoveoInsightClient, CoveoSearchPageClient, history };

package/dist/library.js

@@ -84146,8 +84146,139 @@ var CaseAssistClient = (function () {
     return CaseAssistClient;
 }());
 
+var CoveoInsightClient = (function () {
+    function CoveoInsightClient(opts, provider) {
+        this.opts = opts;
+        this.provider = provider;
+        var shouldDisableAnalytics = opts.enableAnalytics === false || doNotTrack();
+        this.coveoAnalyticsClient = shouldDisableAnalytics ? new NoopAnalytics() : new CoveoAnalyticsClient(opts);
+    }
+    CoveoInsightClient.prototype.disable = function () {
+        if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+            this.coveoAnalyticsClient.clear();
+        }
+        this.coveoAnalyticsClient = new NoopAnalytics();
+    };
+    CoveoInsightClient.prototype.enable = function () {
+        this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.opts);
+    };
+    CoveoInsightClient.prototype.logInterfaceLoad = function () {
+        return this.logSearchEvent(SearchPageEvents.interfaceLoad);
+    };
+    CoveoInsightClient.prototype.logFetchMoreResults = function () {
+        return this.logCustomEvent(SearchPageEvents.pagerScrolling, { type: 'getMoreResults' });
+    };
+    CoveoInsightClient.prototype.logFacetSelect = function (meta) {
+        return this.logSearchEvent(SearchPageEvents.facetSelect, meta);
+    };
+    CoveoInsightClient.prototype.logFacetDeselect = function (meta) {
+        return this.logSearchEvent(SearchPageEvents.facetDeselect, meta);
+    };
+    CoveoInsightClient.prototype.logFacetUpdateSort = function (meta) {
+        return this.logSearchEvent(SearchPageEvents.facetUpdateSort, meta);
+    };
+    CoveoInsightClient.prototype.logFacetClearAll = function (meta) {
+        return this.logSearchEvent(SearchPageEvents.facetClearAll, meta);
+    };
+    CoveoInsightClient.prototype.logFacetShowMore = function (meta) {
+        return this.logCustomEvent(SearchPageEvents.facetShowMore, meta);
+    };
+    CoveoInsightClient.prototype.logFacetShowLess = function (meta) {
+        return this.logCustomEvent(SearchPageEvents.facetShowLess, meta);
+    };
+    CoveoInsightClient.prototype.logQueryError = function (meta) {
+        return this.logCustomEvent(SearchPageEvents.queryError, meta);
+    };
+    CoveoInsightClient.prototype.logCustomEvent = function (event, metadata) {
+        return __awaiter(this, void 0, void 0, function () {
+            var customData, payload, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        customData = __assign(__assign({}, this.provider.getBaseMetadata()), metadata);
+                        _a = [{}];
+                        return [4, this.getBaseCustomEventRequest(customData)];
+                    case 1:
+                        payload = __assign.apply(void 0, [__assign.apply(void 0, _a.concat([(_b.sent())])), { eventType: CustomEventsTypes[event], eventValue: event }]);
+                        return [2, this.coveoAnalyticsClient.sendCustomEvent(payload)];
+                }
+            });
+        });
+    };
+    CoveoInsightClient.prototype.logSearchEvent = function (event, metadata) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _b = (_a = this.coveoAnalyticsClient).sendSearchEvent;
+                        return [4, this.getBaseSearchEventRequest(event, metadata)];
+                    case 1: return [2, _b.apply(_a, [_c.sent()])];
+                }
+            });
+        });
+    };
+    CoveoInsightClient.prototype.getBaseCustomEventRequest = function (metadata) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = [{}];
+                        return [4, this.getBaseEventRequest(metadata)];
+                    case 1: return [2, __assign.apply(void 0, [__assign.apply(void 0, _a.concat([(_b.sent())])), { lastSearchQueryUid: this.provider.getSearchUID() }])];
+                }
+            });
+        });
+    };
+    CoveoInsightClient.prototype.getBaseSearchEventRequest = function (event, metadata) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = [{}];
+                        return [4, this.getBaseEventRequest(metadata)];
+                    case 1: return [2, __assign.apply(void 0, [__assign.apply(void 0, [__assign.apply(void 0, _a.concat([(_b.sent())])), this.provider.getSearchEventRequestPayload()]), { searchQueryUid: this.provider.getSearchUID(), queryPipeline: this.provider.getPipeline(), actionCause: event }])];
+                }
+            });
+        });
+    };
+    CoveoInsightClient.prototype.getBaseEventRequest = function (metadata) {
+        return __awaiter(this, void 0, void 0, function () {
+            var customData, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        customData = __assign(__assign({}, this.provider.getBaseMetadata()), metadata);
+                        _a = [__assign({}, this.getOrigins())];
+                        _b = { customData: customData, language: this.provider.getLanguage(), facetState: this.provider.getFacetState ? this.provider.getFacetState() : [], anonymous: this.provider.getIsAnonymous() };
+                        return [4, this.getClientId()];
+                    case 1: return [2, __assign.apply(void 0, _a.concat([(_b.clientId = _c.sent(), _b)]))];
+                }
+            });
+        });
+    };
+    CoveoInsightClient.prototype.getOrigins = function () {
+        var _a, _b;
+        return {
+            originContext: (_b = (_a = this.provider).getOriginContext) === null || _b === void 0 ? void 0 : _b.call(_a),
+            originLevel1: this.provider.getOriginLevel1(),
+            originLevel2: this.provider.getOriginLevel2(),
+            originLevel3: this.provider.getOriginLevel3(),
+        };
+    };
+    CoveoInsightClient.prototype.getClientId = function () {
+        return this.coveoAnalyticsClient instanceof CoveoAnalyticsClient
+            ? this.coveoAnalyticsClient.getCurrentVisitorId()
+            : undefined;
+    };
+    return CoveoInsightClient;
+}());
+
 exports.CaseAssistClient = CaseAssistClient;
 exports.CoveoAnalyticsClient = CoveoAnalyticsClient;
+exports.CoveoInsightClient = CoveoInsightClient;
 exports.CoveoSearchPageClient = CoveoSearchPageClient;
 exports.CoveoUA = CoveoUA;
 exports.SimpleAnalytics = simpleanalytics;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "coveo.analytics",
-    "version": "2.20.1",
+    "version": "2.20.4",
     "description": "📈 Coveo analytics client (node and browser compatible) ",
     "main": "dist/library.js",
     "module": "dist/library.es.js",

package/src/coveoua/headless.ts

@@ -1,5 +1,6 @@
 export {CoveoSearchPageClient, SearchPageClientProvider} from '../searchPage/searchPageClient';
 export {CaseAssistClient, CaseAssistClientProvider} from '../caseAssist/caseAssistClient';
+export {CoveoInsightClient, InsightClientProvider} from '../insight/insightClient';
 export {CoveoAnalyticsClient, AnalyticsClientSendEventHook} from '../client/analytics';
 export {PreprocessAnalyticsRequest} from '../client/analyticsRequestClient';
 export * as history from '../history';

package/src/coveoua/library.ts

@@ -9,5 +9,6 @@ export {IRuntimeEnvironment} from '../client/runtimeEnvironment';
 export {CoveoUA, getCurrentClient, handleOneAnalyticsEvent} from './simpleanalytics';
 export {CoveoSearchPageClient, SearchPageClientProvider} from '../searchPage/searchPageClient';
 export {CaseAssistClient, CaseAssistClientProvider} from '../caseAssist/caseAssistClient';
+export {CoveoInsightClient, InsightClientProvider} from '../insight/insightClient';
 
 export {analytics, donottrack, history, SimpleAnalytics, storage};

package/src/insight/insightClient.spec.ts

@@ -0,0 +1,223 @@
+import {mockFetch} from '../../tests/fetchMock';
+import CoveoAnalyticsClient from '../client/analytics';
+import {NoopAnalytics} from '../client/noopAnalytics';
+import {CustomEventsTypes, SearchPageEvents} from '../searchPage/searchPageEvents';
+import {CoveoInsightClient, InsightClientProvider} from './insightClient';
+import doNotTrack from '../donottrack';
+
+jest.mock('../donottrack', () => {
+    return {
+        default: jest.fn(),
+        doNotTrack: jest.fn(),
+    };
+});
+
+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',
+        },
+    ];
+
+    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,
+    };
+
+    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, meta = {}) => {
+        const [, {body}] = fetchMock.lastCall();
+        const customData = {foo: 'bar', ...meta};
+        expect(JSON.parse(body.toString())).toMatchObject({
+            queryText: 'queryText',
+            responseTime: 123,
+            queryPipeline: 'my-pipeline',
+            actionCause,
+            customData,
+            facetState: fakeFacetState,
+            language: 'en',
+            clientId: 'visitor-id',
+            ...expectOrigins(),
+        });
+    };
+
+    const expectMatchCustomEventPayload = (actionCause: SearchPageEvents, meta = {}) => {
+        const [, {body}] = fetchMock.lastCall();
+        const customData = {foo: 'bar', ...meta};
+        expect(JSON.parse(body.toString())).toMatchObject({
+            eventValue: actionCause,
+            eventType: CustomEventsTypes[actionCause],
+            lastSearchQueryUid: 'my-uid',
+            customData,
+            language: 'en',
+            clientId: 'visitor-id',
+            ...expectOrigins(),
+        });
+    };
+
+    beforeEach(() => {
+        fetchMockBeforeEach();
+
+        client = initClient();
+        client.coveoAnalyticsClient.runtime.storage.setItem('visitorId', 'visitor-id');
+        fetchMock.mock(/.*/, {
+            visitId: 'visit-id',
+        });
+    });
+
+    afterEach(() => {
+        fetchMock.reset();
+    });
+
+    it('should send proper payload for #interfaceLoad', async () => {
+        await client.logInterfaceLoad();
+        expectMatchPayload(SearchPageEvents.interfaceLoad);
+    });
+
+    it('should send proper payload for #fetchMoreResults', async () => {
+        await client.logFetchMoreResults();
+        expectMatchCustomEventPayload(SearchPageEvents.pagerScrolling, {type: 'getMoreResults'});
+    });
+
+    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 #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 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('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);
+    });
+});