@aws/lsp-codewhisperer 0.0.15 → 0.0.17

package/out/language-server/telemetryService.test.js

@@ -0,0 +1,761 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const telemetryService_1 = require("./telemetryService");
+const ts_sinon_1 = require("ts-sinon");
+const constants_1 = require("./constants");
+const types_1 = require("./telemetry/types");
+class MockCredentialsProvider {
+    mockIamCredentials;
+    mockBearerCredentials;
+    mockConnectionMetadata;
+    hasCredentials(type) {
+        if (type === 'iam') {
+            return this.mockIamCredentials !== undefined;
+        }
+        else if (type === 'bearer') {
+            return this.mockBearerCredentials !== undefined;
+        }
+        return false;
+    }
+    getCredentials(type) {
+        if (type === 'iam') {
+            return this.mockIamCredentials;
+        }
+        else if (type === 'bearer') {
+            return this.mockBearerCredentials;
+        }
+        return undefined;
+    }
+    getConnectionMetadata() {
+        return this.mockConnectionMetadata;
+    }
+    setConnectionMetadata(metadata) {
+        this.mockConnectionMetadata = metadata;
+    }
+}
+describe('TelemetryService', () => {
+    let telemetry;
+    let clock;
+    let telemetryService;
+    let mockCredentialsProvider;
+    const logging = {
+        log: (message) => {
+            console.log(message);
+        },
+    };
+    const mockSession = {
+        codewhispererSessionId: 'test-session-id',
+        responseContext: {
+            requestId: 'test-request-id',
+            codewhispererSessionId: 'test-session-id',
+        },
+        customizationArn: 'test-arn',
+        language: 'tsx',
+        suggestions: [
+            {
+                itemId: 'item-id-1',
+                content: 'line1\nline2\nline3',
+                references: [],
+            },
+        ],
+        completionSessionResult: {
+            'item-id-1': {
+                accepted: true,
+                seen: true,
+                discarded: false,
+            },
+        },
+        acceptedSuggestionId: 'item-id-1',
+        firstCompletionDisplayLatency: 100,
+        timeToFirstRecommendation: 200,
+        getAggregatedUserTriggerDecision: () => 'Accept',
+        startPosition: {
+            line: 12,
+            character: 23,
+        },
+    };
+    beforeEach(() => {
+        clock = ts_sinon_1.default.useFakeTimers({
+            now: 1483228800000,
+        });
+        mockCredentialsProvider = new MockCredentialsProvider();
+        telemetry = {
+            emitMetric: ts_sinon_1.default.stub(),
+            onClientTelemetry: ts_sinon_1.default.stub(),
+        };
+    });
+    afterEach(() => {
+        clock.restore();
+        ts_sinon_1.default.restore();
+    });
+    it('updateUserContext updates the userContext property', () => {
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', {}, logging);
+        const mockUserContext = {
+            clientId: 'aaaabbbbccccdddd',
+            ideCategory: 'ECLIPSE',
+            ideVersion: '1.1.1',
+            operatingSystem: 'MAC',
+            product: 'INLINE',
+        };
+        telemetryService.updateUserContext(mockUserContext);
+        ts_sinon_1.default.assert.match(telemetryService.userContext, mockUserContext);
+    });
+    it('updateOptOutPreference updates the optOutPreference property', () => {
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', {}, logging);
+        const mockOptOutPreference = 'OPTIN';
+        telemetryService.updateOptOutPreference(mockOptOutPreference);
+        ts_sinon_1.default.assert.match(telemetryService.optOutPreference, mockOptOutPreference);
+    });
+    it('updateEnableTelemetryEventsToDestination updates the enableTelemetryEventsToDestination property', () => {
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', {}, logging);
+        telemetryService.updateEnableTelemetryEventsToDestination(true);
+        ts_sinon_1.default.assert.match(telemetryService.enableTelemetryEventsToDestination, true);
+    });
+    it('getSuggestionState fetches the suggestion state from CodeWhispererSession', () => {
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', {}, logging);
+        const getSuggestionState = telemetryService.getSuggestionState.bind(telemetryService);
+        let session = {
+            getAggregatedUserTriggerDecision: () => {
+                return 'Accept';
+            },
+        };
+        ts_sinon_1.default.assert.match(getSuggestionState(session), 'ACCEPT');
+        session = {
+            getAggregatedUserTriggerDecision: () => {
+                return 'Reject';
+            },
+        };
+        ts_sinon_1.default.assert.match(getSuggestionState(session), 'REJECT');
+        session = {
+            getAggregatedUserTriggerDecision: () => {
+                return 'Discard';
+            },
+        };
+        ts_sinon_1.default.assert.match(getSuggestionState(session), 'DISCARD');
+        session = {
+            getAggregatedUserTriggerDecision: () => {
+                return 'Empty';
+            },
+        };
+        ts_sinon_1.default.assert.match(getSuggestionState(session), 'EMPTY');
+        session = {
+            getAggregatedUserTriggerDecision: () => {
+                return undefined;
+            },
+        };
+        ts_sinon_1.default.assert.match(getSuggestionState(session), 'EMPTY');
+    });
+    it('should not emit user trigger decision if login is invalid (IAM)', () => {
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'iam', telemetry, logging);
+        const invokeSendTelemetryEventStub = ts_sinon_1.default.stub(telemetryService, 'sendTelemetryEvent');
+        telemetryService.emitUserTriggerDecision(mockSession);
+        ts_sinon_1.default.assert.notCalled(invokeSendTelemetryEventStub);
+    });
+    it('should not emit user trigger decision if login is BuilderID, but user chose OPTOUT option', () => {
+        mockCredentialsProvider.setConnectionMetadata({
+            sso: {
+                startUrl: constants_1.BUILDER_ID_START_URL,
+            },
+        });
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', telemetry, logging);
+        const invokeSendTelemetryEventStub = ts_sinon_1.default.stub(telemetryService, 'sendTelemetryEvent');
+        telemetryService.updateOptOutPreference('OPTOUT');
+        telemetryService.emitUserTriggerDecision(mockSession);
+        ts_sinon_1.default.assert.notCalled(invokeSendTelemetryEventStub);
+    });
+    it('should handle SSO connection type change at runtime', () => {
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', telemetry, logging);
+        const sendTelemetryEventStub = ts_sinon_1.default
+            .stub(telemetryService, 'sendTelemetryEvent')
+            .returns(Promise.resolve());
+        telemetryService.updateOptOutPreference('OPTOUT'); // Disables telemetry for builderId startUrl
+        mockCredentialsProvider.setConnectionMetadata({
+            sso: {
+                startUrl: 'https://some-random-test-idc-directory.awsapps.com',
+            },
+        });
+        // Emitting event with IdC connection
+        telemetryService.emitUserTriggerDecision(mockSession);
+        ts_sinon_1.default.assert.calledOnce(sendTelemetryEventStub);
+        // Switch to BuilderId connection
+        mockCredentialsProvider.setConnectionMetadata({
+            sso: {
+                startUrl: constants_1.BUILDER_ID_START_URL,
+            },
+        });
+        sendTelemetryEventStub.resetHistory();
+        // Should not emit event anymore with BuilderId
+        telemetryService.emitUserTriggerDecision(mockSession);
+        ts_sinon_1.default.assert.notCalled(sendTelemetryEventStub);
+    });
+    it('should emit userTriggerDecision event to STE and to the destination', () => {
+        const expectedUserTriggerDecisionEvent = {
+            telemetryEvent: {
+                userTriggerDecisionEvent: {
+                    sessionId: 'test-session-id',
+                    requestId: 'test-request-id',
+                    customizationArn: 'test-arn',
+                    programmingLanguage: { languageName: 'typescript' },
+                    completionType: 'BLOCK',
+                    suggestionState: 'ACCEPT',
+                    recommendationLatencyMilliseconds: 100,
+                    timestamp: new Date(Date.now()),
+                    triggerToResponseLatencyMilliseconds: 200,
+                    suggestionReferenceCount: 0,
+                    generatedLine: 3,
+                    numberOfRecommendations: 1,
+                    perceivedLatencyMilliseconds: undefined,
+                    acceptedCharacterCount: 17,
+                },
+            },
+            optOutPreference: 'OPTIN',
+        };
+        mockCredentialsProvider.setConnectionMetadata({
+            sso: {
+                startUrl: 'idc-start-url',
+            },
+        });
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', telemetry, logging);
+        telemetryService.updateEnableTelemetryEventsToDestination(true);
+        const invokeSendTelemetryEventStub = ts_sinon_1.default
+            .stub(telemetryService, 'sendTelemetryEvent')
+            .returns(Promise.resolve());
+        telemetryService.updateOptOutPreference('OPTIN');
+        telemetryService.emitUserTriggerDecision(mockSession);
+        ts_sinon_1.default.assert.calledOnceWithExactly(invokeSendTelemetryEventStub, expectedUserTriggerDecisionEvent);
+        ts_sinon_1.default.assert.calledOnceWithExactly(telemetry.emitMetric, {
+            name: 'codewhisperer_userTriggerDecision',
+            data: {
+                codewhispererSessionId: 'test-session-id',
+                codewhispererFirstRequestId: 'test-request-id',
+                credentialStartUrl: undefined,
+                codewhispererSuggestionState: 'Accept',
+                codewhispererCompletionType: 'Block',
+                codewhispererLanguage: 'tsx',
+                codewhispererTriggerType: undefined,
+                codewhispererAutomatedTriggerType: undefined,
+                codewhispererTriggerCharacter: undefined,
+                codewhispererLineNumber: 12,
+                codewhispererCursorOffset: 23,
+                codewhispererSuggestionCount: 1,
+                codewhispererClassifierResult: undefined,
+                codewhispererClassifierThreshold: undefined,
+                codewhispererTotalShownTime: 0,
+                codewhispererTypeaheadLength: 0,
+                codewhispererTimeSinceLastDocumentChange: undefined,
+                codewhispererTimeSinceLastUserDecision: undefined,
+                codewhispererTimeToFirstRecommendation: 200,
+                codewhispererPreviousSuggestionState: undefined,
+                codewhispererSupplementalContextTimeout: undefined,
+                codewhispererSupplementalContextIsUtg: undefined,
+                codewhispererSupplementalContextLength: undefined,
+                codewhispererCustomizationArn: 'test-arn',
+            },
+        });
+    });
+    it('should not emit userTriggerDecision event to destination when enableTelemetryEventsToDestination is disabled', () => {
+        mockCredentialsProvider.setConnectionMetadata({
+            sso: {
+                startUrl: constants_1.BUILDER_ID_START_URL,
+            },
+        });
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', telemetry, logging);
+        telemetryService.updateEnableTelemetryEventsToDestination(false);
+        telemetryService.updateOptOutPreference('OPTOUT');
+        telemetryService.emitUserTriggerDecision(mockSession);
+        ts_sinon_1.default.assert.neverCalledWithMatch(telemetry.emitMetric, {
+            name: 'codewhisperer_userTriggerDecision',
+        });
+    });
+    describe('Chat interact with message', () => {
+        let telemetryService;
+        let mockCredentialsProvider;
+        let invokeSendTelemetryEventStub;
+        beforeEach(() => {
+            mockCredentialsProvider = new MockCredentialsProvider();
+            mockCredentialsProvider.setConnectionMetadata({
+                sso: {
+                    startUrl: 'idc-start-url',
+                },
+            });
+            telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', telemetry, logging);
+            invokeSendTelemetryEventStub = ts_sinon_1.default
+                .stub(telemetryService, 'sendTelemetryEvent')
+                .returns(Promise.resolve());
+        });
+        afterEach(() => {
+            ts_sinon_1.default.restore();
+        });
+        it('should send InteractWithMessage event with correct parameters and emit metric to destination', () => {
+            const metric = {
+                cwsprChatMessageId: 'message123',
+                codewhispererCustomizationArn: 'arn:123',
+                cwsprChatInteractionType: types_1.ChatInteractionType.InsertAtCursor,
+                cwsprChatInteractionTarget: 'CODE',
+                cwsprChatAcceptedCharactersLength: 100,
+            };
+            const conversationId = 'conv123';
+            const acceptedLineCount = 5;
+            telemetryService.updateEnableTelemetryEventsToDestination(true);
+            telemetryService.emitChatInteractWithMessage(metric, {
+                conversationId,
+                acceptedLineCount,
+            });
+            const expectedEvent = {
+                telemetryEvent: {
+                    chatInteractWithMessageEvent: {
+                        conversationId: conversationId,
+                        messageId: metric.cwsprChatMessageId,
+                        customizationArn: 'arn:123',
+                        interactionType: 'INSERT_AT_CURSOR',
+                        interactionTarget: metric.cwsprChatInteractionTarget,
+                        acceptedCharacterCount: metric.cwsprChatAcceptedCharactersLength,
+                        acceptedLineCount: acceptedLineCount,
+                        acceptedSnippetHasReference: false,
+                        hasProjectLevelContext: false,
+                    },
+                },
+            };
+            ts_sinon_1.default.assert.calledOnceWithExactly(invokeSendTelemetryEventStub, expectedEvent);
+            ts_sinon_1.default.assert.calledOnceWithExactly(telemetry.emitMetric, {
+                name: 'amazonq_interactWithMessage',
+                data: {
+                    cwsprChatMessageId: 'message123',
+                    codewhispererCustomizationArn: 'arn:123',
+                    cwsprChatInteractionType: 'insertAtCursor',
+                    cwsprChatInteractionTarget: 'CODE',
+                    cwsprChatAcceptedCharactersLength: 100,
+                    cwsprChatConversationId: 'conv123',
+                    credentialStartUrl: 'idc-start-url',
+                },
+            });
+        });
+        it('should not send InteractWithMessage event to destination when enableTelemetryEventsToDestination flag is disabled', () => {
+            const metric = {
+                cwsprChatMessageId: 'message123',
+                codewhispererCustomizationArn: 'arn:123',
+                cwsprChatInteractionType: types_1.ChatInteractionType.InsertAtCursor,
+                cwsprChatInteractionTarget: 'CODE',
+                cwsprChatAcceptedCharactersLength: 100,
+            };
+            const conversationId = 'conv123';
+            const acceptedLineCount = 5;
+            mockCredentialsProvider.setConnectionMetadata({
+                sso: {
+                    startUrl: constants_1.BUILDER_ID_START_URL,
+                },
+            });
+            telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', {}, logging);
+            telemetryService.updateEnableTelemetryEventsToDestination(false);
+            telemetryService.updateOptOutPreference('OPTOUT');
+            telemetryService.emitChatInteractWithMessage(metric, {
+                conversationId,
+                acceptedLineCount,
+            });
+            ts_sinon_1.default.assert.neverCalledWithMatch(telemetry.emitMetric, {
+                name: 'amazonq_interactWithMessage',
+            });
+        });
+        it('should not send InteractWithMessage when conversationId is undefined', () => {
+            const metric = {
+                cwsprChatMessageId: 'message123',
+                codewhispererCustomizationArn: 'arn:123',
+                cwsprChatInteractionType: types_1.ChatInteractionType.InsertAtCursor,
+                cwsprChatInteractionTarget: 'CODE',
+                cwsprChatAcceptedCharactersLength: 100,
+            };
+            telemetryService.emitChatInteractWithMessage(metric, {
+                acceptedLineCount: 5,
+            });
+            ts_sinon_1.default.assert.notCalled(invokeSendTelemetryEventStub);
+        });
+        it('should not send InteractWithMessage when credentialsType is IAM', () => {
+            telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'iam', telemetry, logging);
+            invokeSendTelemetryEventStub = ts_sinon_1.default.stub(telemetryService, 'sendTelemetryEvent');
+            const metric = {
+                cwsprChatMessageId: 'message123',
+                codewhispererCustomizationArn: 'arn:123',
+                cwsprChatInteractionType: types_1.ChatInteractionType.InsertAtCursor,
+                cwsprChatInteractionTarget: 'CODE',
+                cwsprChatAcceptedCharactersLength: 100,
+            };
+            telemetryService.emitChatInteractWithMessage(metric, {
+                conversationId: 'conv123',
+                acceptedLineCount: 5,
+            });
+            ts_sinon_1.default.assert.notCalled(invokeSendTelemetryEventStub);
+        });
+        it('should not send InteractWithMessage when login is BuilderID, but user chose OPTOUT option', () => {
+            mockCredentialsProvider.setConnectionMetadata({
+                sso: {
+                    startUrl: constants_1.BUILDER_ID_START_URL,
+                },
+            });
+            telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', telemetry, logging);
+            invokeSendTelemetryEventStub = ts_sinon_1.default.stub(telemetryService, 'sendTelemetryEvent');
+            telemetryService.updateOptOutPreference('OPTOUT');
+            const metric = {
+                cwsprChatMessageId: 'message123',
+                codewhispererCustomizationArn: 'arn:123',
+                cwsprChatInteractionType: types_1.ChatInteractionType.InsertAtCursor,
+                cwsprChatInteractionTarget: 'CODE',
+                cwsprChatAcceptedCharactersLength: 100,
+            };
+            telemetryService.emitChatInteractWithMessage(metric, {
+                conversationId: 'conv123',
+                acceptedLineCount: 5,
+            });
+            ts_sinon_1.default.assert.notCalled(invokeSendTelemetryEventStub);
+        });
+        it('should send InteractWithMessage but with optional acceptedLineCount parameter', () => {
+            const metric = {
+                cwsprChatMessageId: 'message123',
+                codewhispererCustomizationArn: 'arn:123',
+                cwsprChatInteractionType: types_1.ChatInteractionType.InsertAtCursor,
+                cwsprChatInteractionTarget: 'CODE',
+                cwsprChatAcceptedCharactersLength: 100,
+            };
+            const conversationId = 'conv123';
+            telemetryService.emitChatInteractWithMessage(metric, {
+                conversationId,
+                acceptedLineCount: undefined,
+            });
+            ts_sinon_1.default.assert.calledWithExactly(invokeSendTelemetryEventStub, {
+                telemetryEvent: {
+                    chatInteractWithMessageEvent: {
+                        conversationId: 'conv123',
+                        messageId: 'message123',
+                        customizationArn: 'arn:123',
+                        interactionType: 'INSERT_AT_CURSOR',
+                        interactionTarget: 'CODE',
+                        acceptedCharacterCount: 100,
+                        acceptedLineCount: undefined, // Should be undefined
+                        acceptedSnippetHasReference: false,
+                        hasProjectLevelContext: false,
+                    },
+                },
+            });
+        });
+    });
+    it('should emit CodeCoverageEvent event to STE and to the destination', () => {
+        const expectedEvent = {
+            telemetryEvent: {
+                codeCoverageEvent: {
+                    customizationArn: 'test-arn',
+                    programmingLanguage: { languageName: 'typescript' },
+                    acceptedCharacterCount: 123,
+                    totalCharacterCount: 456,
+                    timestamp: new Date(Date.now()),
+                },
+            },
+            optOutPreference: 'OPTIN',
+        };
+        mockCredentialsProvider.setConnectionMetadata({
+            sso: {
+                startUrl: 'idc-start-url',
+            },
+        });
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', telemetry, logging);
+        const invokeSendTelemetryEventStub = ts_sinon_1.default
+            .stub(telemetryService, 'sendTelemetryEvent')
+            .returns(Promise.resolve());
+        telemetryService.updateOptOutPreference('OPTIN');
+        telemetryService.updateEnableTelemetryEventsToDestination(true);
+        telemetryService.emitCodeCoverageEvent({
+            languageId: 'typescript',
+            customizationArn: 'test-arn',
+            acceptedCharacterCount: 123,
+            totalCharacterCount: 456,
+        }, {
+            percentage: 50,
+            successCount: 1,
+        });
+        ts_sinon_1.default.assert.calledOnceWithExactly(invokeSendTelemetryEventStub, expectedEvent);
+        ts_sinon_1.default.assert.calledOnceWithExactly(telemetry.emitMetric, {
+            name: 'codewhisperer_codePercentage',
+            data: {
+                codewhispererTotalTokens: 456,
+                codewhispererLanguage: 'typescript',
+                codewhispererSuggestedTokens: 123,
+                codewhispererPercentage: 50,
+                successCount: 1,
+            },
+        });
+    });
+    it('should not emit CodeCoverageEvent event to destination when enableTelemetryEventsToDestination flag is disabled', () => {
+        mockCredentialsProvider.setConnectionMetadata({
+            sso: {
+                startUrl: constants_1.BUILDER_ID_START_URL,
+            },
+        });
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', telemetry, logging);
+        telemetryService.updateOptOutPreference('OPTOUT');
+        telemetryService.updateEnableTelemetryEventsToDestination(false);
+        telemetryService.emitCodeCoverageEvent({
+            languageId: 'typescript',
+            customizationArn: 'test-arn',
+            acceptedCharacterCount: 123,
+            totalCharacterCount: 456,
+        }, {
+            percentage: 50,
+            successCount: 1,
+        });
+        ts_sinon_1.default.assert.neverCalledWithMatch(telemetry.emitMetric, {
+            name: 'codewhisperer_codePercentage',
+        });
+    });
+    it('should emit userModificationEvent event', () => {
+        mockCredentialsProvider.setConnectionMetadata({
+            sso: {
+                startUrl: 'idc-start-url',
+            },
+        });
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', {}, logging);
+        const invokeSendTelemetryEventStub = ts_sinon_1.default
+            .stub(telemetryService, 'sendTelemetryEvent')
+            .returns(Promise.resolve());
+        telemetryService.updateOptOutPreference('OPTIN');
+        telemetryService.emitUserModificationEvent({
+            sessionId: 'test-session-id',
+            requestId: 'test-request-id',
+            languageId: 'typescript',
+            customizationArn: 'test-arn',
+            timestamp: new Date(),
+            modificationPercentage: 0.2,
+            acceptedCharacterCount: 100,
+            unmodifiedAcceptedCharacterCount: 80,
+        });
+        const expectedEvent = {
+            telemetryEvent: {
+                userModificationEvent: {
+                    sessionId: 'test-session-id',
+                    requestId: 'test-request-id',
+                    programmingLanguage: {
+                        languageName: 'typescript',
+                    },
+                    modificationPercentage: 0.2,
+                    customizationArn: 'test-arn',
+                    timestamp: new Date(),
+                    acceptedCharacterCount: 100,
+                    unmodifiedAcceptedCharacterCount: 80,
+                },
+            },
+            optOutPreference: 'OPTIN',
+        };
+        ts_sinon_1.default.assert.calledOnceWithExactly(invokeSendTelemetryEventStub, expectedEvent);
+    });
+    it('should emit chatUserModificationEvent event including emitting event to destination', () => {
+        mockCredentialsProvider.setConnectionMetadata({
+            sso: {
+                startUrl: 'idc-start-url',
+            },
+        });
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', telemetry, logging);
+        telemetryService.updateEnableTelemetryEventsToDestination(true);
+        const invokeSendTelemetryEventStub = ts_sinon_1.default
+            .stub(telemetryService, 'sendTelemetryEvent')
+            .returns(Promise.resolve());
+        telemetryService.updateOptOutPreference('OPTIN');
+        telemetryService.emitChatUserModificationEvent({
+            conversationId: 'test-conversation-id',
+            messageId: 'test-message-id',
+            customizationArn: 'test-arn',
+            modificationPercentage: 0.2,
+        });
+        const expectedEvent = {
+            telemetryEvent: {
+                chatUserModificationEvent: {
+                    conversationId: 'test-conversation-id',
+                    messageId: 'test-message-id',
+                    customizationArn: 'test-arn',
+                    modificationPercentage: 0.2,
+                },
+            },
+            optOutPreference: 'OPTIN',
+        };
+        ts_sinon_1.default.assert.calledOnceWithExactly(invokeSendTelemetryEventStub, expectedEvent);
+        ts_sinon_1.default.assert.calledOnceWithExactly(telemetry.emitMetric, {
+            name: 'amazonq_modifyCode',
+            data: {
+                cwsprChatConversationId: 'test-conversation-id',
+                cwsprChatMessageId: 'test-message-id',
+                cwsprChatModificationPercentage: 0.2,
+                codewhispererCustomizationArn: 'test-arn',
+                credentialStartUrl: 'idc-start-url',
+            },
+        });
+    });
+    it('should not emit chatUserModificationEvent event to destination when enableTelemetryEventsToDestination flag is disabled', () => {
+        mockCredentialsProvider.setConnectionMetadata({
+            sso: {
+                startUrl: constants_1.BUILDER_ID_START_URL,
+            },
+        });
+        telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', telemetry, logging);
+        telemetryService.updateEnableTelemetryEventsToDestination(false);
+        telemetryService.updateOptOutPreference('OPTOUT');
+        telemetryService.emitChatUserModificationEvent({
+            conversationId: 'test-conversation-id',
+            messageId: 'test-message-id',
+            customizationArn: 'test-arn',
+            modificationPercentage: 0.2,
+        });
+        ts_sinon_1.default.assert.neverCalledWithMatch(telemetry.emitMetric, {
+            name: 'amazonq_modifyCode',
+        });
+    });
+    describe('Chat add message', () => {
+        let telemetryService;
+        let mockCredentialsProvider;
+        let invokeSendTelemetryEventStub;
+        beforeEach(() => {
+            mockCredentialsProvider = new MockCredentialsProvider();
+            mockCredentialsProvider.setConnectionMetadata({
+                sso: {
+                    startUrl: 'idc-start-url',
+                },
+            });
+            telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', telemetry, logging);
+            invokeSendTelemetryEventStub = ts_sinon_1.default
+                .stub(telemetryService, 'sendTelemetryEvent')
+                .returns(Promise.resolve());
+        });
+        afterEach(() => {
+            ts_sinon_1.default.restore();
+        });
+        it('should send ChatAddMessage event with correct parameters and emit metric to destination', () => {
+            telemetryService.updateEnableTelemetryEventsToDestination(true);
+            telemetryService.emitChatAddMessage({
+                conversationId: 'conv123',
+                messageId: 'message123',
+                customizationArn: 'cust-123',
+                programmingLanguage: 'jsx',
+                userIntent: 'SUGGEST_ALTERNATE_IMPLEMENTATION',
+                hasCodeSnippet: false,
+                timeToFirstChunkMilliseconds: 100,
+                activeEditorTotalCharacters: 250,
+                fullResponselatency: 400,
+                requestLength: 100,
+                responseLength: 3000,
+                numberOfCodeBlocks: 0,
+            }, {});
+            const expectedEvent = {
+                telemetryEvent: {
+                    chatAddMessageEvent: {
+                        conversationId: 'conv123',
+                        messageId: 'message123',
+                        customizationArn: 'cust-123',
+                        userIntent: 'SUGGEST_ALTERNATE_IMPLEMENTATION',
+                        hasCodeSnippet: false,
+                        programmingLanguage: {
+                            languageName: 'javascript',
+                        },
+                        activeEditorTotalCharacters: 250,
+                        timeToFirstChunkMilliseconds: 100,
+                        timeBetweenChunks: undefined,
+                        fullResponselatency: 400,
+                        requestLength: 100,
+                        responseLength: 3000,
+                        numberOfCodeBlocks: 0,
+                        hasProjectLevelContext: false,
+                    },
+                },
+            };
+            ts_sinon_1.default.assert.calledOnceWithExactly(invokeSendTelemetryEventStub, expectedEvent);
+            ts_sinon_1.default.assert.calledOnceWithExactly(telemetry.emitMetric, {
+                name: 'amazonq_addMessage',
+                data: {
+                    credentialStartUrl: 'idc-start-url',
+                    cwsprChatConversationId: 'conv123',
+                    cwsprChatHasCodeSnippet: false,
+                    cwsprChatTriggerInteraction: undefined,
+                    cwsprChatMessageId: 'message123',
+                    cwsprChatUserIntent: 'SUGGEST_ALTERNATE_IMPLEMENTATION',
+                    cwsprChatProgrammingLanguage: 'jsx',
+                    cwsprChatResponseCodeSnippetCount: 0,
+                    cwsprChatResponseCode: undefined,
+                    cwsprChatSourceLinkCount: undefined,
+                    cwsprChatReferencesCount: undefined,
+                    cwsprChatFollowUpCount: undefined,
+                    cwsprTimeToFirstChunk: 100,
+                    cwsprChatFullResponseLatency: 400,
+                    cwsprChatTimeBetweenChunks: undefined,
+                    cwsprChatRequestLength: 100,
+                    cwsprChatResponseLength: 3000,
+                    cwsprChatConversationType: undefined,
+                    cwsprChatActiveEditorTotalCharacters: 250,
+                    cwsprChatActiveEditorImportCount: undefined,
+                    codewhispererCustomizationArn: 'cust-123',
+                },
+            });
+        });
+        it('should not send ChatAddMessage event to destination when enableTelemetryEventsToDestination flag is disabled', () => {
+            mockCredentialsProvider.setConnectionMetadata({
+                sso: {
+                    startUrl: constants_1.BUILDER_ID_START_URL,
+                },
+            });
+            telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', {}, logging);
+            telemetryService.updateOptOutPreference('OPTOUT');
+            telemetryService.updateEnableTelemetryEventsToDestination(false);
+            telemetryService.emitChatAddMessage({
+                conversationId: 'conv123',
+                messageId: 'message123',
+                customizationArn: 'cust-123',
+                programmingLanguage: 'jsx',
+                userIntent: 'SUGGEST_ALTERNATE_IMPLEMENTATION',
+                hasCodeSnippet: false,
+                timeToFirstChunkMilliseconds: 100,
+                activeEditorTotalCharacters: 250,
+                fullResponselatency: 400,
+                requestLength: 100,
+                responseLength: 3000,
+                numberOfCodeBlocks: 0,
+            }, {});
+            ts_sinon_1.default.assert.neverCalledWithMatch(telemetry.emitMetric, {
+                name: 'amazonq_addMessage',
+            });
+        });
+        it('should not send ChatAddMessage when conversationId is undefined', () => {
+            telemetryService.emitChatAddMessage({
+                messageId: 'message123',
+                customizationArn: 'cust-123',
+            }, {});
+            ts_sinon_1.default.assert.notCalled(invokeSendTelemetryEventStub);
+        });
+        it('should not send ChatAddMessage when messageId is undefined', () => {
+            telemetryService.emitChatAddMessage({
+                conversationId: 'conv123',
+                customizationArn: 'cust-123',
+            }, {});
+            ts_sinon_1.default.assert.notCalled(invokeSendTelemetryEventStub);
+        });
+        it('should not send ChatAddMessage when credentialsType is IAM', () => {
+            telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'iam', telemetry, logging);
+            invokeSendTelemetryEventStub = ts_sinon_1.default.stub(telemetryService, 'sendTelemetryEvent');
+            telemetryService.emitChatAddMessage({
+                conversationId: 'conv123',
+                messageId: 'message123',
+                customizationArn: 'cust-123',
+            }, {});
+            ts_sinon_1.default.assert.notCalled(invokeSendTelemetryEventStub);
+        });
+        it('should not send ChatAddMessage when login is BuilderID, but user chose OPTOUT option', () => {
+            mockCredentialsProvider.setConnectionMetadata({
+                sso: {
+                    startUrl: constants_1.BUILDER_ID_START_URL,
+                },
+            });
+            telemetryService = new telemetryService_1.TelemetryService(mockCredentialsProvider, 'bearer', telemetry, logging);
+            invokeSendTelemetryEventStub = ts_sinon_1.default.stub(telemetryService, 'sendTelemetryEvent');
+            telemetryService.updateOptOutPreference('OPTOUT');
+            telemetryService.emitChatAddMessage({
+                conversationId: 'conv123',
+                messageId: 'message123',
+                customizationArn: 'cust-123',
+            }, {});
+            ts_sinon_1.default.assert.notCalled(invokeSendTelemetryEventStub);
+        });
+    });
+});
+//# sourceMappingURL=telemetryService.test.js.map