Fix unit test

Author: normj

Libraries/src/Amazon.Lambda.RuntimeSupport/Bootstrap/UserCodeLoader.cs

@@ -35,6 +35,8 @@ internal class UserCodeLoader
     {
         private const string UserInvokeException = "An exception occurred while invoking customer handler.";
         private const string LambdaLoggingActionFieldName = "_loggingAction";
+        private const string LambdaLoggingWithLevelActionFieldName = "_loggingWithLevelAction";
+        private const string LambdaLoggingWithLevelAndExceptionActionFieldName = "_loggingWithLevelAndExceptionAction";
 
         internal const string LambdaCoreAssemblyName = "Amazon.Lambda.Core";
 
@@ -186,6 +188,82 @@ internal static void SetCustomerLoggerLogAction(Assembly coreAssembly, Action<st
             }
         }
 
+        internal static void SetCustomerLoggerLogAction(Assembly coreAssembly, Action<string, string, object[]> loggingWithLevelAction, InternalLogger internalLogger)
+        {
+            if (coreAssembly == null)
+            {
+                throw new ArgumentNullException(nameof(coreAssembly));
+            }
+
+            if (loggingWithLevelAction == null)
+            {
+                throw new ArgumentNullException(nameof(loggingWithLevelAction));
+            }
+
+            internalLogger.LogDebug($"UCL : Retrieving type '{Types.LambdaLoggerTypeName}'");
+            var lambdaILoggerType = coreAssembly.GetType(Types.LambdaLoggerTypeName);
+            if (lambdaILoggerType == null)
+            {
+                throw LambdaExceptions.ValidationException(Errors.UserCodeLoader.Internal.UnableToLocateType, Types.LambdaLoggerTypeName);
+            }
+
+            internalLogger.LogDebug($"UCL : Retrieving field '{LambdaLoggingWithLevelActionFieldName}'");
+            var loggingActionField = lambdaILoggerType.GetTypeInfo().GetField(LambdaLoggingWithLevelActionFieldName, BindingFlags.NonPublic | BindingFlags.Static);
+            if (loggingActionField == null)
+            {
+                throw LambdaExceptions.ValidationException(Errors.UserCodeLoader.Internal.UnableToRetrieveField, LambdaLoggingWithLevelActionFieldName, Types.LambdaLoggerTypeName);
+            }
+
+            internalLogger.LogDebug($"UCL : Setting field '{LambdaLoggingWithLevelActionFieldName}'");
+            try
+            {
+                loggingActionField.SetValue(null, loggingWithLevelAction);
+            }
+            catch (Exception e)
+            {
+                throw LambdaExceptions.ValidationException(e, Errors.UserCodeLoader.Internal.UnableToSetField,
+                    Types.LambdaLoggerTypeName, LambdaLoggingWithLevelActionFieldName);
+            }
+        }
+
+        internal static void SetCustomerLoggerLogAction(Assembly coreAssembly, Action<string, Exception, string, object[]> loggingWithAndExceptionLevelAction, InternalLogger internalLogger)
+        {
+            if (coreAssembly == null)
+            {
+                throw new ArgumentNullException(nameof(coreAssembly));
+            }
+
+            if (loggingWithAndExceptionLevelAction == null)
+            {
+                throw new ArgumentNullException(nameof(loggingWithAndExceptionLevelAction));
+            }
+
+            internalLogger.LogDebug($"UCL : Retrieving type '{Types.LambdaLoggerTypeName}'");
+            var lambdaILoggerType = coreAssembly.GetType(Types.LambdaLoggerTypeName);
+            if (lambdaILoggerType == null)
+            {
+                throw LambdaExceptions.ValidationException(Errors.UserCodeLoader.Internal.UnableToLocateType, Types.LambdaLoggerTypeName);
+            }
+
+            internalLogger.LogDebug($"UCL : Retrieving field '{LambdaLoggingWithLevelAndExceptionActionFieldName}'");
+            var loggingActionField = lambdaILoggerType.GetTypeInfo().GetField(LambdaLoggingWithLevelAndExceptionActionFieldName, BindingFlags.NonPublic | BindingFlags.Static);
+            if (loggingActionField == null)
+            {
+                throw LambdaExceptions.ValidationException(Errors.UserCodeLoader.Internal.UnableToRetrieveField, LambdaLoggingWithLevelAndExceptionActionFieldName, Types.LambdaLoggerTypeName);
+            }
+
+            internalLogger.LogDebug($"UCL : Setting field '{LambdaLoggingWithLevelAndExceptionActionFieldName}'");
+            try
+            {
+                loggingActionField.SetValue(null, loggingWithAndExceptionLevelAction);
+            }
+            catch (Exception e)
+            {
+                throw LambdaExceptions.ValidationException(e, Errors.UserCodeLoader.Internal.UnableToSetField,
+                    Types.LambdaLoggerTypeName, LambdaLoggingWithLevelAndExceptionActionFieldName);
+            }
+        }
+
         /// <summary>
         /// Constructs customer-specified serializer, specified either on the method,
         /// the assembly, or not specified at all.

Libraries/test/Amazon.Lambda.Core.Tests/TestUtilitiesLoggingTest.cs

@@ -0,0 +1,50 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using Xunit;
+using System.Linq;
+using Amazon.Lambda.TestUtilities;
+using Amazon.Lambda.Core;
+
+namespace Amazon.Lambda.Tests
+{
+    public class TestUtilitiesLoggingTest
+    {
+        [Fact]
+        public void LogWithLevelAndMessage()
+        {
+            ILambdaLogger logger = new TestLambdaLogger();
+            logger.Log(LogLevel.Warning, "This is a warning");
+
+            Assert.Contains("Warning: This is a warning", ((TestLambdaLogger)logger).Buffer.ToString());
+        }
+
+        [Fact]
+        public void LogWithLevelAndMessageAndParameters()
+        {
+            ILambdaLogger logger = new TestLambdaLogger();
+            logger.Log(LogLevel.Warning, "This is {name}", "garp");
+
+            Assert.Contains("Warning: This is {name}", ((TestLambdaLogger)logger).Buffer.ToString());
+            Assert.Contains("\tgarp", ((TestLambdaLogger)logger).Buffer.ToString());
+        }
+
+        [Fact]
+        public void LogWithLevelAndMessageAndParametersAndExecption()
+        {
+            ILambdaLogger logger = new TestLambdaLogger();
+
+            var exception = new ArgumentException("Bad Name");
+            logger.Log(LogLevel.Warning, exception, "This is {name}", "garp");
+
+
+            Assert.Contains("Warning: This is {name}", ((TestLambdaLogger)logger).Buffer.ToString());
+            Assert.Contains("\tgarp", ((TestLambdaLogger)logger).Buffer.ToString());
+            Assert.Contains("ArgumentException", ((TestLambdaLogger)logger).Buffer.ToString());
+        }
+    }
+}

Libraries/test/Amazon.Lambda.RuntimeSupport.Tests/Amazon.Lambda.RuntimeSupport.UnitTests/HandlerTests.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License").
@@ -393,9 +393,10 @@ private async Task<ExecutionInfo> ExecHandlerAsync(string handler, string dataIn
                     Client = testRuntimeApiClient
                 };
 
-                var loggerAction = actionWriter.ToLoggingAction();
                 var assembly = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(UserCodeLoader.LambdaCoreAssemblyName));
-                UserCodeLoader.SetCustomerLoggerLogAction(assembly, loggerAction, _internalLogger);
+                UserCodeLoader.SetCustomerLoggerLogAction(assembly, actionWriter.ToLoggingAction(), _internalLogger);
+                UserCodeLoader.SetCustomerLoggerLogAction(assembly, actionWriter.ToLoggingWithLevelAction(), _internalLogger);
+                UserCodeLoader.SetCustomerLoggerLogAction(assembly, actionWriter.ToLoggingWithLevelAndExceptionAction(), _internalLogger);
 
                 if (assertLoggedByInitialize != null)
                 {

Libraries/test/Amazon.Lambda.RuntimeSupport.Tests/Amazon.Lambda.RuntimeSupport.UnitTests/TestHelpers/StringWriterExtensions.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License").
@@ -67,9 +67,27 @@ public static Action<string> ToLoggingAction(this TextWriter writer)
             return writer.WriteLine;
         }
 
+        public static Action<string, string, object[]> ToLoggingWithLevelAction(this TextWriter writer)
+        {
+            return (l, m, p) =>
+            {
+                var formattedMessage = $"{l}: {m}";
+                writer.WriteLine(formattedMessage);
+            };
+        }
+
+        public static Action<string, Exception, string, object[]> ToLoggingWithLevelAndExceptionAction(this TextWriter writer)
+        {
+            return (l, e, m, p) =>
+            {
+                var formattedMessage = $"{l}: {m}\n{e}";
+                writer.WriteLine(formattedMessage);
+            };
+        }
+
         public static Action<string> ToLoggingAction(this ITestOutputHelper writer)
         {
             return writer.WriteLine;
         }
     }
-}
+}