fix: userConsent req to return specific http sts codes

kithwa · kithwa · commit d4fcfc9ea9db · 2025-11-28T18:06:17.000+08:00
Signed-off-by: Cheah, Kit Hwa &lt;kit.hwa.cheah@intel.com&gt;
diff --git a/src/routes/amt/userConsent/cancel.test.ts b/src/routes/amt/userConsent/cancel.test.ts
@@ -46,7 +46,7 @@ describe('cancel user consent code', () => {
     expect(resSpy.status).toHaveBeenCalledWith(200)
     expect(resSpy.json).toHaveBeenCalledWith(result)
   })
-  it('Should give an error when return value is not 0', async () => {
+  it('should return 409 when return value is NOT_READY', async () => {
     const result = {
       Header: {
         To: 'http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous',
@@ -62,11 +62,54 @@ describe('cancel user consent code', () => {
         }
       }
     }
-    const response = { Header: result.Header, Body: result.Body.CancelOptIn_OUTPUT }
+    cancelUserConsetCodeSpy.mockResolvedValueOnce(result)
+    await cancel(req, resSpy)
+    expect(resSpy.status).toHaveBeenCalledWith(409)
+    expect(resSpy.json).toHaveBeenCalledWith(expect.objectContaining({
+      error: 'Conflict',
+      message: expect.any(String),
+      details: expect.any(Object),
+      amtResponse: expect.objectContaining({
+        Header: result.Header,
+        Body: expect.objectContaining({
+          ReturnValue: '2',
+          ReturnValueStr: 'NOT_READY'
+        })
+      })
+    }))
+  })
+  
+  it('should return 400 for other non-zero return values', async () => {
+    const result = {
+      Header: {
+        To: 'http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous',
+        RelatesTo: '0',
+        Action: 'http://intel.com/wbem/wscim/1/ips-schema/1/IPS_OptInService/CancelOptInResponse',
+        MessageID: 'uuid:00000000-8086-8086-8086-000000000786',
+        ResourceURI: 'http://intel.com/wbem/wscim/1/ips-schema/1/IPS_OptInService'
+      },
+      Body: {
+        CancelOptIn_OUTPUT: {
+          ReturnValue: '1',
+          ReturnValueStr: 'INTERNAL_ERROR'
+        }
+      }
+    }
     cancelUserConsetCodeSpy.mockResolvedValueOnce(result)
     await cancel(req, resSpy)
     expect(resSpy.status).toHaveBeenCalledWith(400)
-    expect(resSpy.json).toHaveBeenCalledWith(response)
+    expect(resSpy.json).toHaveBeenCalledWith(expect.objectContaining({
+      error: 'Bad Request',
+      message: expect.stringContaining('INTERNAL_ERROR'),
+      details: expect.any(Object),
+      amtResponse: expect.objectContaining({
+        Header: result.Header,
+        Body: expect.objectContaining({
+          ReturnValue: '1',
+          ReturnValueStr: 'INTERNAL_ERROR'
+        })
+      })
+    }))
   })
   it('should get an error with status code 400, when failed to cancel user consent code', async () => {
     cancelUserConsetCodeSpy.mockResolvedValueOnce(null)
diff --git a/src/routes/amt/userConsent/cancel.ts b/src/routes/amt/userConsent/cancel.ts
@@ -8,6 +8,7 @@ import { logger, messages } from '../../../logging/index.js'
 import { ErrorResponse } from '../../../utils/amtHelper.js'
 import { MqttProvider } from '../../../utils/MqttProvider.js'
 import { AMTStatusCodes } from '../../../utils/constants.js'
+import { mapAMTReturnValueToHttpStatus, getDetailedErrorMessage } from './statusMapper.js'
 
 export async function cancel(req: Request, res: Response): Promise<void> {
   try {
@@ -20,13 +21,23 @@ export async function cancel(req: Request, res: Response): Promise<void> {
         Body: response.Body.CancelOptIn_OUTPUT
       }
       result.Body.ReturnValueStr = AMTStatusCodes[result.Body.ReturnValue]
+      
       if (result.Body?.ReturnValue.toString() === '0') {
         MqttProvider.publishEvent('success', ['Cancel_User_Consent_Code'], messages.USER_CONSENT_CANCEL_SUCCESS, guid)
         res.status(200).json(result)
-      } else if (result.Body?.ReturnValue.toString() !== '0') {
-        logger.error(`${messages.USER_CONSENT_CANCEL_FAILED} : ${guid}.`)
+      } else {
+        // Map AMT return value to appropriate HTTP status code
+        const httpStatus = mapAMTReturnValueToHttpStatus(result.Body.ReturnValueStr)
+        const errorDetail = getDetailedErrorMessage(result.Body.ReturnValue, result.Body.ReturnValueStr, 'cancel')
+        
+        logger.error(`${messages.USER_CONSENT_CANCEL_FAILED} : ${guid}. ReturnValue: ${result.Body.ReturnValue} (${result.Body.ReturnValueStr})`)
         MqttProvider.publishEvent('fail', ['Cancel_User_Consent_Code'], messages.USER_CONSENT_CANCEL_FAILED, guid)
-        res.status(400).json(result)
+        
+        // Return detailed error response with original AMT data
+        res.status(httpStatus).json({
+          ...errorDetail,
+          amtResponse: result
+        })
       }
     } else {
       logger.error(`${messages.USER_CONSENT_CANCEL_FAILED} for guid : ${guid}.`)
diff --git a/src/routes/amt/userConsent/request.test.ts b/src/routes/amt/userConsent/request.test.ts
@@ -46,7 +46,7 @@ describe('request user consent code', () => {
     expect(resSpy.status).toHaveBeenCalledWith(200)
     expect(resSpy.json).toHaveBeenCalledWith(result)
   })
-  it('Should give an error when return value is not 0', async () => {
+  it('should return 409 when return value is NOT_READY', async () => {
     const result = {
       Header: {
         To: 'http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous',
@@ -62,11 +62,54 @@ describe('request user consent code', () => {
         }
       }
     }
-    const response = { Header: result.Header, Body: result.Body.StartOptIn_OUTPUT }
+    requestUserConsetCodeSpy.mockResolvedValueOnce(result)
+    await request(req, resSpy)
+    expect(resSpy.status).toHaveBeenCalledWith(409)
+    expect(resSpy.json).toHaveBeenCalledWith(expect.objectContaining({
+      error: 'Conflict',
+      message: expect.any(String),
+      details: expect.any(Object),
+      amtResponse: expect.objectContaining({
+        Header: result.Header,
+        Body: expect.objectContaining({
+          ReturnValue: '2',
+          ReturnValueStr: 'NOT_READY'
+        })
+      })
+    }))
+  })
+  
+  it('should return 400 for other non-zero return values', async () => {
+    const result = {
+      Header: {
+        To: 'http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous',
+        RelatesTo: '0',
+        Action: 'http://intel.com/wbem/wscim/1/ips-schema/1/IPS_OptInService/StartOptInResponse',
+        MessageID: 'uuid:00000000-8086-8086-8086-00000000008D',
+        ResourceURI: 'http://intel.com/wbem/wscim/1/ips-schema/1/IPS_OptInService'
+      },
+      Body: {
+        StartOptIn_OUTPUT: {
+          ReturnValue: '1',
+          ReturnValueStr: 'INTERNAL_ERROR'
+        }
+      }
+    }
     requestUserConsetCodeSpy.mockResolvedValueOnce(result)
     await request(req, resSpy)
     expect(resSpy.status).toHaveBeenCalledWith(400)
-    expect(resSpy.json).toHaveBeenCalledWith(response)
+    expect(resSpy.json).toHaveBeenCalledWith(expect.objectContaining({
+      error: 'Bad Request',
+      message: expect.stringContaining('INTERNAL_ERROR'),
+      details: expect.any(Object),
+      amtResponse: expect.objectContaining({
+        Header: result.Header,
+        Body: expect.objectContaining({
+          ReturnValue: '1',
+          ReturnValueStr: 'INTERNAL_ERROR'
+        })
+      })
+    }))
   })
   it('should get an error with status code 400, when failed to request user consent code', async () => {
     requestUserConsetCodeSpy.mockResolvedValueOnce(null)
diff --git a/src/routes/amt/userConsent/request.ts b/src/routes/amt/userConsent/request.ts
@@ -8,6 +8,7 @@ import { logger, messages } from '../../../logging/index.js'
 import { ErrorResponse } from '../../../utils/amtHelper.js'
 import { MqttProvider } from '../../../utils/MqttProvider.js'
 import { AMTStatusCodes } from '../../../utils/constants.js'
+import { mapAMTReturnValueToHttpStatus, getDetailedErrorMessage } from './statusMapper.js'
 
 export async function request(req: Request, res: Response): Promise<void> {
   try {
@@ -20,13 +21,23 @@ export async function request(req: Request, res: Response): Promise<void> {
         Body: response.Body.StartOptIn_OUTPUT
       }
       result.Body.ReturnValueStr = AMTStatusCodes[result.Body.ReturnValue]
+      
       if (result.Body.ReturnValue.toString() === '0') {
         MqttProvider.publishEvent('success', ['Request_User_Consent_Code'], messages.USER_CONSENT_REQUEST_SUCCESS, guid)
         res.status(200).json(result)
       } else {
-        logger.error(`${messages.USER_CONSENT_REQUEST_FAILED} for guid : ${guid}.`)
+        // Map AMT return value to appropriate HTTP status code
+        const httpStatus = mapAMTReturnValueToHttpStatus(result.Body.ReturnValueStr)
+        const errorDetail = getDetailedErrorMessage(result.Body.ReturnValue, result.Body.ReturnValueStr, 'request')
+        
+        logger.error(`${messages.USER_CONSENT_REQUEST_FAILED} for guid : ${guid}. ReturnValue: ${result.Body.ReturnValue} (${result.Body.ReturnValueStr})`)
         MqttProvider.publishEvent('fail', ['Request_User_Consent_Code'], messages.USER_CONSENT_REQUEST_FAILED, guid)
-        res.status(400).json(result)
+        
+        // Return detailed error response with original AMT data
+        res.status(httpStatus).json({
+          ...errorDetail,
+          amtResponse: result
+        })
       }
     } else {
       logger.error(`${messages.USER_CONSENT_REQUEST_FAILED} for guid : ${guid}.`)
diff --git a/src/routes/amt/userConsent/send.test.ts b/src/routes/amt/userConsent/send.test.ts
@@ -47,7 +47,7 @@ describe('send user consent code', () => {
     expect(resSpy.status).toHaveBeenCalledWith(200)
     expect(resSpy.json).toHaveBeenCalledWith(result)
   })
-  it('Should give an error when return value is not 0', async () => {
+  it('should return 409 when return value is NOT_READY', async () => {
     const result = {
       Header: {
         To: 'http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous',
@@ -63,11 +63,87 @@ describe('send user consent code', () => {
         }
       }
     }
-    const response = { Header: result.Header, Body: result.Body.SendOptInCode_OUTPUT }
+    sendUserConsetCodeSpy.mockResolvedValueOnce(result)
+    await send(req, resSpy)
+    expect(resSpy.status).toHaveBeenCalledWith(409)
+    expect(resSpy.json).toHaveBeenCalledWith(expect.objectContaining({
+      error: 'Conflict',
+      message: expect.any(String),
+      details: expect.any(Object),
+      amtResponse: expect.objectContaining({
+        Header: result.Header,
+        Body: expect.objectContaining({
+          ReturnValue: '2',
+          ReturnValueStr: 'NOT_READY'
+        })
+      })
+    }))
+  })
+  
+  it('should return 422 when return value is UNSUPPORTED (wrong consent code)', async () => {
+    const result = {
+      Header: {
+        To: 'http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous',
+        RelatesTo: '3',
+        Action: 'http://intel.com/wbem/wscim/1/ips-schema/1/IPS_OptInService/SendOptInCodeResponse',
+        MessageID: 'uuid:00000000-8086-8086-8086-000000000093',
+        ResourceURI: 'http://intel.com/wbem/wscim/1/ips-schema/1/IPS_OptInService'
+      },
+      Body: {
+        SendOptInCode_OUTPUT: {
+          ReturnValue: '2066',
+          ReturnValueStr: 'UNSUPPORTED'
+        }
+      }
+    }
+    sendUserConsetCodeSpy.mockResolvedValueOnce(result)
+    await send(req, resSpy)
+    expect(resSpy.status).toHaveBeenCalledWith(422)
+    expect(resSpy.json).toHaveBeenCalledWith(expect.objectContaining({
+      error: 'Unprocessable Entity',
+      message: 'Invalid consent code provided',
+      details: expect.any(Object),
+      amtResponse: expect.objectContaining({
+        Header: result.Header,
+        Body: expect.objectContaining({
+          ReturnValue: '2066',
+          ReturnValueStr: 'UNSUPPORTED'
+        })
+      })
+    }))
+  })
+  
+  it('should return 400 for other non-zero return values', async () => {
+    const result = {
+      Header: {
+        To: 'http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous',
+        RelatesTo: '3',
+        Action: 'http://intel.com/wbem/wscim/1/ips-schema/1/IPS_OptInService/SendOptInCodeResponse',
+        MessageID: 'uuid:00000000-8086-8086-8086-000000000093',
+        ResourceURI: 'http://intel.com/wbem/wscim/1/ips-schema/1/IPS_OptInService'
+      },
+      Body: {
+        SendOptInCode_OUTPUT: {
+          ReturnValue: '1',
+          ReturnValueStr: 'INTERNAL_ERROR'
+        }
+      }
+    }
     sendUserConsetCodeSpy.mockResolvedValueOnce(result)
     await send(req, resSpy)
     expect(resSpy.status).toHaveBeenCalledWith(400)
-    expect(resSpy.json).toHaveBeenCalledWith(response)
+    expect(resSpy.json).toHaveBeenCalledWith(expect.objectContaining({
+      error: 'Bad Request',
+      message: expect.stringContaining('INTERNAL_ERROR'),
+      details: expect.any(Object),
+      amtResponse: expect.objectContaining({
+        Header: result.Header,
+        Body: expect.objectContaining({
+          ReturnValue: '1',
+          ReturnValueStr: 'INTERNAL_ERROR'
+        })
+      })
+    }))
   })
   it('should get an error with status code 400, when failed to request user consent code', async () => {
     sendUserConsetCodeSpy.mockResolvedValueOnce(null)
diff --git a/src/routes/amt/userConsent/send.ts b/src/routes/amt/userConsent/send.ts
@@ -8,27 +8,37 @@ import { logger, messages } from '../../../logging/index.js'
 import { ErrorResponse } from '../../../utils/amtHelper.js'
 import { MqttProvider } from '../../../utils/MqttProvider.js'
 import { AMTStatusCodes } from '../../../utils/constants.js'
+import { mapAMTReturnValueToHttpStatus, getDetailedErrorMessage } from './statusMapper.js'
 
 export async function send(req: Request, res: Response): Promise<void> {
   const userConsentCode: number = req.body.consentCode
   const guid: string = req.params.guid
   try {
-    // Cancel a previous opt-in code request.
+    // Send in the consent code obtained from Client as verification
     const response = await req.deviceAction.sendUserConsentCode(userConsentCode)
     if (response != null) {
       const result = {
         Header: response.Header,
         Body: response.Body.SendOptInCode_OUTPUT
       }
       result.Body.ReturnValueStr = AMTStatusCodes[result.Body.ReturnValue]
+      
       if (result.Body?.ReturnValue.toString() === '0') {
         MqttProvider.publishEvent('success', ['Send_User_Consent_Code'], messages.USER_CONSENT_SENT_SUCCESS, guid)
-        result.Body.ReturnValueStr = AMTStatusCodes[result.Body.ReturnValue]
         res.status(200).json(result)
       } else {
-        logger.error(`${messages.USER_CONSENT_SENT_FAILED} for guid : ${guid}.`)
+        // Map AMT return value to appropriate HTTP status code
+        const httpStatus = mapAMTReturnValueToHttpStatus(result.Body.ReturnValueStr)
+        const errorDetail = getDetailedErrorMessage(result.Body.ReturnValue, result.Body.ReturnValueStr, 'send')
+        
+        logger.error(`${messages.USER_CONSENT_SENT_FAILED} for guid : ${guid}. ReturnValue: ${result.Body.ReturnValue} (${result.Body.ReturnValueStr})`)
         MqttProvider.publishEvent('fail', ['Send_User_Consent_Code'], messages.USER_CONSENT_SENT_FAILED, guid)
-        res.status(400).json(result)
+        
+        // Return detailed error response with original AMT data
+        res.status(httpStatus).json({
+          ...errorDetail,
+          amtResponse: result
+        })
       }
     } else {
       logger.error(`${messages.USER_CONSENT_SENT_FAILED} for guid : ${guid}.`)
diff --git a/src/routes/amt/userConsent/statusMapper.ts b/src/routes/amt/userConsent/statusMapper.ts
