refactor(dev): remove errorName from Amazon Q feature development error classes

Author: chengoramazon

packages/core/src/amazonqFeatureDev/controllers/chat/controller.ts

@@ -214,14 +214,15 @@ export class FeatureDevController {
         )
 
         let defaultMessage
-        const isDenyListedError = denyListedErrors.some((err) => errorMessage.includes(err))
+        const isDenyListedError = denyListedErrors.some((denyListedError) => err.message.includes(denyListedError))
 
         switch (err.constructor.name) {
             case ContentLengthError.name:
                 this.messenger.sendAnswer({
                     type: 'answer',
                     tabID: message.tabID,
                     message: err.message + messageWithConversationId(session?.conversationIdUnsafe),
+                    canBeVoted: true,
                 })
                 this.messenger.sendAnswer({
                     type: 'system-prompt',
@@ -268,6 +269,7 @@ export class FeatureDevController {
                     type: 'answer',
                     tabID: message.tabID,
                     message: err.message + messageWithConversationId(session?.conversationIdUnsafe),
+                    canBeVoted: true,
                 })
                 this.messenger.sendAnswer({
                     type: 'system-prompt',

packages/core/src/amazonqFeatureDev/controllers/chat/messenger/messenger.ts

@@ -85,6 +85,7 @@ export class Messenger {
                 type: 'answer',
                 tabID: tabID,
                 message: showDefaultMessage ? errorMessage : i18n('AWS.amazonq.featureDev.error.technicalDifficulties'),
+                canBeVoted: true,
             })
             this.sendFeedback(tabID)
             return

packages/core/src/test/amazonqFeatureDev/controllers/chat/controller.test.ts

@@ -14,14 +14,27 @@ import { Session } from '../../../../amazonqFeatureDev/session/session'
 import { Prompter } from '../../../../shared/ui/prompter'
 import { assertTelemetry, toFile } from '../../../testUtil'
 import {
+    CodeIterationLimitError,
+    ContentLengthError,
+    createUserFacingErrorMessage,
+    FeatureDevServiceError,
+    MonthlyConversationLimitError,
     NoChangeRequiredException,
+    PrepareRepoFailedError,
+    PromptRefusalException,
     SelectedFolderNotInWorkspaceFolderError,
+    TabIdNotFoundError,
+    UploadCodeError,
     UploadURLExpired,
+    UserMessageNotFoundError,
+    ZipFileError,
 } from '../../../../amazonqFeatureDev/errors'
 import { CodeGenState, PrepareCodeGenState } from '../../../../amazonqFeatureDev/session/sessionState'
 import { FeatureDevClient } from '../../../../amazonqFeatureDev/client/featureDev'
 import { createAmazonQUri } from '../../../../amazonq/commons/diff'
 import { AuthUtil } from '../../../../codewhisperer'
+import { featureName, messageWithConversationId } from '../../../../amazonqFeatureDev'
+import { i18n } from '../../../../shared/i18n-helper'
 
 let mockGetCodeGeneration: sinon.SinonStub
 describe('Controller', () => {
@@ -210,7 +223,6 @@ describe('Controller', () => {
         })
 
         it('accepts valid source folders under a workspace root', async () => {
-            const controllerSetup = await createController()
             sinon.stub(controllerSetup.sessionStorage, 'getSession').resolves(session)
             sinon.stub(vscode.workspace, 'getWorkspaceFolder').returns(controllerSetup.workspaceFolder)
             const expectedSourceRoot = path.join(controllerSetup.workspaceFolder.uri.fsPath, 'src')
@@ -386,33 +398,113 @@ describe('Controller', () => {
         }
 
         describe('processErrorChatMessage', function () {
-            async function verifyException(error: Error, message?: string) {
+            const runs = [
+                { name: 'ContentLengthError', error: new ContentLengthError() },
+                {
+                    name: 'MonthlyConversationLimitError',
+                    error: new MonthlyConversationLimitError('Service Quota Exceeded'),
+                },
+                {
+                    name: 'FeatureDevServiceError',
+                    error: new FeatureDevServiceError(
+                        i18n('AWS.amazonq.featureDev.error.codeGen.default'),
+                        'GuardrailsException'
+                    ),
+                },
+                { name: 'UploadCodeError', error: new UploadCodeError('403: Forbiden') },
+                { name: 'UserMessageNotFoundError', error: new UserMessageNotFoundError() },
+                { name: 'TabIdNotFoundError', error: new TabIdNotFoundError() },
+                { name: 'PrepareRepoFailedError', error: new PrepareRepoFailedError() },
+                { name: 'PromptRefusalException', error: new PromptRefusalException() },
+                { name: 'ZipFileError', error: new ZipFileError() },
+                { name: 'CodeIterationLimitError', error: new CodeIterationLimitError() },
+                { name: 'UploadURLExpired', error: new UploadURLExpired() },
+                { name: 'NoChangeRequiredException', error: new NoChangeRequiredException() },
+                { name: 'default', error: new Error() },
+            ]
+
+            function createTestErrorMessage(message: string) {
+                return createUserFacingErrorMessage(`${featureName} request failed: ${message}`)
+            }
+
+            async function verifyException(error: Error) {
                 sinon.stub(session, 'preloader').throws(error)
                 const sendAnswerSpy = sinon.stub(controllerSetup.messenger, 'sendAnswer')
+                const sendErrorMessageSpy = sinon.stub(controllerSetup.messenger, 'sendErrorMessage')
+                const sendMonthlyLimitErrorSpy = sinon.stub(controllerSetup.messenger, 'sendMonthlyLimitError')
 
                 await fireChatMessage()
 
-                assert.strictEqual(
-                    sendAnswerSpy.calledWith({
-                        type: 'answer',
-                        tabID,
-                        message: message ?? error.message,
-                        canBeVoted: true,
-                    }),
-                    true
-                )
+                switch (error.constructor.name) {
+                    case ContentLengthError.name:
+                        assert.ok(
+                            sendAnswerSpy.calledWith({
+                                type: 'answer',
+                                tabID,
+                                message: error.message + messageWithConversationId(session?.conversationIdUnsafe),
+                                canBeVoted: true,
+                            })
+                        )
+                        break
+                    case MonthlyConversationLimitError.name:
+                        assert.ok(sendMonthlyLimitErrorSpy.calledWith(tabID))
+                        break
+                    case FeatureDevServiceError.name:
+                    case UploadCodeError.name:
+                    case UserMessageNotFoundError.name:
+                    case TabIdNotFoundError.name:
+                    case PrepareRepoFailedError.name:
+                        assert.ok(
+                            sendErrorMessageSpy.calledWith(
+                                createTestErrorMessage(error.message),
+                                tabID,
+                                session?.retries,
+                                session?.conversationIdUnsafe
+                            )
+                        )
+                        break
+                    case PromptRefusalException.name:
+                    case ZipFileError.name:
+                        assert.ok(
+                            sendErrorMessageSpy.calledWith(
+                                createTestErrorMessage(error.message),
+                                tabID,
+                                0,
+                                session?.conversationIdUnsafe,
+                                true
+                            )
+                        )
+                        break
+                    case NoChangeRequiredException.name:
+                    case CodeIterationLimitError.name:
+                    case UploadURLExpired.name:
+                        assert.ok(
+                            sendAnswerSpy.calledWith({
+                                type: 'answer',
+                                tabID,
+                                message: error.message,
+                                canBeVoted: true,
+                            })
+                        )
+                        break
+                    default:
+                        assert.ok(
+                            sendErrorMessageSpy.calledWith(
+                                i18n('AWS.amazonq.featureDev.error.codeGen.default'),
+                                tabID,
+                                session?.retries,
+                                session?.conversationIdUnsafe,
+                                true
+                            )
+                        )
+                        break
+                }
             }
 
-            it('should handle NoChangeRequiredException', async function () {
-                const noChangeRequiredException = new NoChangeRequiredException()
-
-                await verifyException(noChangeRequiredException)
-            })
-
-            it('should handle UploadURLExpired', async function () {
-                const uploadURLExpired = new UploadURLExpired()
-
-                await verifyException(uploadURLExpired)
+            runs.forEach((run) => {
+                it(`should handle ${run.name}`, async function () {
+                    await verifyException(run.error)
+                })
             })
         })
     })