add async handler detection tests

Author: Fabiana Severin

src/Errors.js

@@ -38,9 +38,9 @@ function toRapidResponse(error) {
   try {
     if (util.types.isNativeError(error) || _isError(error)) {
       return {
-        errorType: error.name?.replace(/\x7F/g, '%7F'),
-        errorMessage: error.message?.replace(/\x7F/g, '%7F'),
-        trace: error.stack.replace(/\x7F/g, '%7F').split('\n'),
+        errorType: error.name?.replaceAll('\x7F', '%7F'),
+        errorMessage: error.message?.replaceAll('\x7F', '%7F'),
+        trace: error.stack.replaceAll('\x7F', '%7F').split('\n'),
       };
     } else {
       return {
@@ -106,6 +106,13 @@ const errorClasses = [
   class UserCodeSyntaxError extends Error {},
   class MalformedStreamingHandler extends Error {},
   class InvalidStreamingOperation extends Error {},
+  class NodeJsExit extends Error {
+    constructor() {
+      super(
+        'The Lambda runtime client detected an unexpected Node.js exit code. This is most commonly caused by a Promise that was never settled. For more information, see https://nodejs.org/docs/latest/api/process.html#exit-codes',
+      );
+    }
+  },
   class UnhandledPromiseRejection extends Error {
     constructor(reason, promise) {
       super(reason);

src/Runtime.js

@@ -12,7 +12,9 @@ const CallbackContext = require('./CallbackContext.js');
 const StreamingContext = require('./StreamingContext.js');
 const BeforeExitListener = require('./BeforeExitListener.js');
 const { STREAM_RESPONSE } = require('./UserFunction.js');
+const { NodeJsExit } = require('./Errors.js');
 const { verbose, vverbose } = require('./VerboseLog.js').logger('RAPID');
+const { structuredConsole } = require('./LogPatch');
 
 module.exports = class Runtime {
   constructor(client, handler, handlerMetadata, errorCallbacks) {
@@ -69,7 +71,7 @@ module.exports = class Runtime {
 
     try {
       this._setErrorCallbacks(invokeContext.invokeId);
-      this._setDefaultExitListener(invokeContext.invokeId, markCompleted);
+      this._setDefaultExitListener(invokeContext.invokeId, markCompleted, this.handlerMetadata.isAsync);
 
       let result = this.handler(
         JSON.parse(bodyJson),
@@ -178,12 +180,22 @@ module.exports = class Runtime {
    * called and the handler is not async.
    * CallbackContext replaces the listener if a callback is invoked.
    */
-  _setDefaultExitListener(invokeId, markCompleted) {
+  _setDefaultExitListener(invokeId, markCompleted, isAsync) {
     BeforeExitListener.set(() => {
       markCompleted();
-      this.client.postInvocationResponse(null, invokeId, () =>
-        this.scheduleIteration(),
-      );
+      // if the handle signature is async, we do want to fail the invocation
+      if (isAsync) {
+        const nodeJsExitError = new NodeJsExit();
+        structuredConsole.logError('Invoke Error', nodeJsExitError);
+        this.client.postInvocationError(nodeJsExitError, invokeId, () =>
+          this.scheduleIteration(),
+        );
+        // if the handler signature is sync, or use callback, we do want to send a successful invocation with a null payload if the customer forgot to call the callback
+      } else {
+        this.client.postInvocationResponse(null, invokeId, () =>
+          this.scheduleIteration(),
+        );
+      }
     });
   }
 

src/UserFunction.js

@@ -311,8 +311,17 @@ module.exports.isHandlerFunction = function (value) {
   return typeof value === 'function';
 };
 
-function _isAsync(handlerFunc) {
-  return handlerFunc.constructor.name === 'AsyncFunction';
+function _isAsync(handler) {
+  try {
+    return (
+      handler &&
+      typeof handler === 'function' &&
+      handler.constructor &&
+      handler.constructor.name === 'AsyncFunction'
+    );
+  } catch (error) {
+    return false;
+  }
 }
 
 module.exports.getHandlerMetadata = function (handlerFunc) {

test/handlers/isAsync.mjs

@@ -0,0 +1,17 @@
+/** Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
+
+export const handlerAsync = async () => {
+  const response = {
+    statusCode: 200,
+    body: JSON.stringify('Hello from Lambda!'),
+  };
+  return response;
+};
+
+export const handlerNotAsync = () => {
+  const response = {
+    statusCode: 200,
+    body: JSON.stringify('Hello from Lambda!'),
+  };
+  return response;
+};

test/handlers/isAsyncCallback.js

@@ -0,0 +1,12 @@
+/** Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
+
+'use strict';
+
+exports.handler = (_event, _context, callback) => {
+  callback(null, {
+    statusCode: 200,
+    body: JSON.stringify({
+      message: 'hello world',
+    }),
+  });
+};

test/unit/ErrorsTest.js

@@ -1,6 +1,4 @@
-/**
- * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
- */
+/** Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
 
 'use strict';
 
@@ -22,11 +20,22 @@ describe('Formatted Error Logging', () => {
 
 describe('Invalid chars in HTTP header', () => {
   it('should be replaced', () => {
-    let errorWithInvalidChar = new Error('\x7F \x7F');
+    let errorWithInvalidChar = new Error('\x7F');
     errorWithInvalidChar.name = 'ErrorWithInvalidChar';
 
     let loggedError = Errors.toRapidResponse(errorWithInvalidChar);
     loggedError.should.have.property('errorType', 'ErrorWithInvalidChar');
-    loggedError.should.have.property('errorMessage', '%7F %7F');
+    loggedError.should.have.property('errorMessage', '%7F');
+  });
+});
+
+describe('NodeJsExit error ctor', () => {
+  it('should be have a fixed reason', () => {
+    let nodeJsExit = new Errors.NodeJsExit();
+    let loggedError = Errors.toRapidResponse(nodeJsExit);
+    loggedError.should.have.property('errorType', 'Runtime.NodeJsExit');
+    loggedError.errorMessage.should.containEql(
+      'runtime client detected an unexpected Node.js',
+    );
   });
 });

test/unit/IsAsyncTest.js

@@ -0,0 +1,37 @@
+/** Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
+
+'use strict';
+
+require('should');
+const path = require('path');
+const UserFunction = require('lambda-runtime/UserFunction.js');
+
+const TEST_ROOT = path.join(__dirname, '../');
+const HANDLERS_ROOT = path.join(TEST_ROOT, 'handlers');
+
+describe('isAsync tests', () => {
+  it('is async should be true', async () => {
+    const handlerFunc = await UserFunction.load(
+      HANDLERS_ROOT,
+      'isAsync.handlerAsync',
+    );
+    const metadata = UserFunction.getHandlerMetadata(handlerFunc);
+    metadata.isAsync.should.be.true();
+  });
+  it('is async should be false', async () => {
+    const handlerFunc = await UserFunction.load(
+      HANDLERS_ROOT,
+      'isAsync.handlerNotAsync',
+    );
+    const metadata = UserFunction.getHandlerMetadata(handlerFunc);
+    metadata.isAsync.should.be.false();
+  });
+  it('is async should be false since it is a callback', async () => {
+    const handlerFunc = await UserFunction.load(
+      HANDLERS_ROOT,
+      'isAsyncCallback.handler',
+    );
+    const metadata = UserFunction.getHandlerMetadata(handlerFunc);
+    metadata.isAsync.should.be.false();
+  });
+});