PR comments

Author: GarrettBeatty

Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Components/Pages/Home.razor.cs

@@ -10,6 +10,7 @@
 using BlazorMonaco.Editor;
 using Microsoft.JSInterop;
 using Microsoft.AspNetCore.WebUtilities;
+using Microsoft.Extensions.Options;
 
 namespace Amazon.Lambda.TestTool.Components.Pages;
 
@@ -22,8 +23,8 @@ public partial class Home : ComponentBase, IDisposable
     [Inject] public required IDirectoryManager DirectoryManager { get; set; }
     [Inject] public required IThemeService ThemeService { get; set; }
     [Inject] public required IJSRuntime JsRuntime { get; set; }
-
     [Inject] public required ILambdaClient LambdaClient { get; set; }
+    [Inject] public IOptions<LambdaOptions> LambdaOptions { get; set; }
 
     private StandaloneCodeEditor? _editor;
     private StandaloneCodeEditor? _activeEditor;
@@ -345,16 +346,17 @@ private async Task<bool> InvokeLambdaFunction(string payload)
 
         try
         {
-            await LambdaClient.InvokeAsync(invokeRequest);
+            await LambdaClient.InvokeAsync(invokeRequest, LambdaOptions.Value.Endpoint);
             _errorMessage = string.Empty;
             return true;
         }
         catch (AmazonLambdaException e)
         {
             // lambda client automatically adds some extra verbiage: "The service returned an error with Error Code xxxx and HTTP Body: <bodyhere>".
             // removing the extra verbiage to make the error message smaller and look better on the ui.
-            _errorMessage = e.Message.Split("HTTP Body: ")[1];
-        }
+            _errorMessage = e.Message.Contains("HTTP Body: ")
+                ? e.Message.Split("HTTP Body: ")[1]
+                : e.Message;        }
         return false;
     }
 }

Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Models/LambdaOptions.cs

@@ -0,0 +1,9 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+namespace Amazon.Lambda.TestTool.Models;
+
+public class LambdaOptions
+{
+    public string Endpoint { get; set; } = string.Empty;
+}

Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Processes/ApiGatewayEmulatorProcess.cs

@@ -52,15 +52,8 @@ public static ApiGatewayEmulatorProcess Startup(RunCommandSettings settings, Can
         Utils.ConfigureWebApplicationBuilder(builder);
 
         builder.Services.AddApiGatewayEmulatorServices();
-        builder.Services.Configure<RunCommandSettings>(options =>
-        {
-            options.LambdaEmulatorHost = settings.LambdaEmulatorHost;
-            options.LambdaEmulatorPort = settings.LambdaEmulatorPort;
-        });
-
         builder.Services.AddSingleton<ILambdaClient, LambdaClient>();
 
-
         var serviceUrl = $"http://{settings.LambdaEmulatorHost}:{settings.ApiGatewayEmulatorPort}";
         builder.WebHost.UseUrls(serviceUrl);
         builder.WebHost.SuppressStatusMessages(true);
@@ -112,9 +105,7 @@ public static ApiGatewayEmulatorProcess Startup(RunCommandSettings settings, Can
             try
             {
                 var endpoint = routeConfig.Endpoint ?? $"http://{settings.LambdaEmulatorHost}:{settings.LambdaEmulatorPort}";
-                lambdaClient.SetEndpoint(endpoint);
-
-                var response = await lambdaClient.InvokeAsync(invokeRequest);
+                var response = await lambdaClient.InvokeAsync(invokeRequest, endpoint);
 
                 if (response.FunctionError == null) // response is successful
                 {

Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Processes/TestToolProcess.cs

@@ -5,6 +5,7 @@
 using Amazon.Lambda.TestTool.Commands.Settings;
 using Amazon.Lambda.TestTool.Components;
 using Amazon.Lambda.TestTool.Configuration;
+using Amazon.Lambda.TestTool.Models;
 using Amazon.Lambda.TestTool.Services;
 using Amazon.Lambda.TestTool.Services.IO;
 using Amazon.Lambda.TestTool.Utilities;
@@ -44,13 +45,13 @@ public static TestToolProcess Startup(RunCommandSettings settings, CancellationT
 
         builder.Services.AddSingleton<IRuntimeApiDataStoreManager, RuntimeApiDataStoreManager>();
         builder.Services.AddSingleton<IThemeService, ThemeService>();
-        builder.Services.Configure<RunCommandSettings>(options =>
+        builder.Services.AddSingleton<ILambdaClient, LambdaClient>();
+
+        builder.Services.Configure<LambdaOptions>(options =>
         {
-            options.LambdaEmulatorHost = settings.LambdaEmulatorHost;
-            options.LambdaEmulatorPort = settings.LambdaEmulatorPort;
+            options.Endpoint = $"http://{settings.LambdaEmulatorHost}:{settings.LambdaEmulatorPort}";
         });
 
-        builder.Services.AddSingleton<ILambdaClient, LambdaClient>();
 
         // Add services to the container.
         builder.Services.AddRazorComponents()

Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Services/ILambdaClient.cs

@@ -14,12 +14,7 @@ public interface ILambdaClient
     /// Invokes a Lambda function asynchronously.
     /// </summary>
     /// <param name="request">The request object containing details for the Lambda function invocation.</param>
+    /// <param name="endpoint">The endpoint for the lambda to connect invoke.</param>
     /// <returns>A task that represents the asynchronous operation. The task result contains the response from the Lambda function invocation.</returns>
-    Task<InvokeResponse> InvokeAsync(InvokeRequest request);
-
-    /// <summary>
-    /// Sets the endpoint for the Lambda client.
-    /// </summary>
-    /// <param name="endpoint">The URL of the endpoint to be used for Lambda operations.</param>
-    void SetEndpoint(string endpoint);
+    Task<InvokeResponse> InvokeAsync(InvokeRequest request, string endpoint);
 }

Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Services/LambdaClient.cs

@@ -1,6 +1,5 @@
+using System.Collections.Concurrent;
 using Amazon.Lambda.Model;
-using Amazon.Lambda.TestTool.Commands.Settings;
-using Microsoft.Extensions.Options;
 
 namespace Amazon.Lambda.TestTool.Services;
 
@@ -9,35 +8,21 @@ namespace Amazon.Lambda.TestTool.Services;
 /// </summary>
 public class LambdaClient : ILambdaClient, IDisposable
 {
-    internal Dictionary<string, IAmazonLambda> Clients => _clients; // used for unit tests only
-    private readonly Dictionary<string, IAmazonLambda> _clients;
-    private string _currentEndpoint;
+    internal ConcurrentDictionary<string, IAmazonLambda> Clients => _clients; // used for unit tests only
+    private readonly ConcurrentDictionary<string, IAmazonLambda> _clients;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="LambdaClient"/> class.
     /// </summary>
-    /// <param name="settings">The run command settings containing Lambda emulator configuration.</param>
-    public LambdaClient(IOptions<RunCommandSettings> settings)
+    public LambdaClient()
     {
-        _clients = new Dictionary<string, IAmazonLambda>();
-        _currentEndpoint = $"http://{settings.Value.LambdaEmulatorHost}:{settings.Value.LambdaEmulatorPort}";
-        _clients[_currentEndpoint] = CreateClient(_currentEndpoint);
+        _clients = new ConcurrentDictionary<string, IAmazonLambda>();
     }
 
     /// <inheritdoc />
-    public Task<InvokeResponse> InvokeAsync(InvokeRequest request)
+    public Task<InvokeResponse> InvokeAsync(InvokeRequest request, string endpoint)
     {
-        return _clients[_currentEndpoint].InvokeAsync(request);
-    }
-
-    /// <inheritdoc />
-    public void SetEndpoint(string endpoint)
-    {
-        if (!_clients.ContainsKey(endpoint))
-        {
-            _clients[endpoint] = CreateClient(endpoint);
-        }
-        _currentEndpoint = endpoint;
+        return _clients.GetOrAdd(endpoint, CreateClient(endpoint)).InvokeAsync(request);
     }
 
     /// <summary>

Tools/LambdaTestTool-v2/tests/Amazon.Lambda.TestTool.UnitTests/Services/LambdaClientTests.cs

@@ -1,107 +1,118 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+
 using Amazon.Lambda.Model;
-using Amazon.Lambda.TestTool.Commands.Settings;
 using Amazon.Lambda.TestTool.Services;
-using Microsoft.Extensions.Options;
 using Moq;
 using Xunit;
 
 namespace Amazon.Lambda.TestTool.UnitTests.Services
 {
-    public class LambdaClientTests : IDisposable
+     public class LambdaClientTests : IDisposable
     {
-        private readonly Mock<IOptions<RunCommandSettings>> _mockSettings;
-        private readonly RunCommandSettings _settings;
-        private readonly LambdaClient _client;
+        private readonly LambdaClient _lambdaClient;
+        private readonly InvokeRequest _validRequest;
 
         public LambdaClientTests()
         {
-            _settings = new RunCommandSettings
+            _lambdaClient = new LambdaClient();
+            _validRequest = new InvokeRequest
             {
-                LambdaEmulatorHost = "localhost",
-                LambdaEmulatorPort = 5050
+                FunctionName = "TestFunction",
+                Payload = "{}"
             };
-            _mockSettings = new Mock<IOptions<RunCommandSettings>>();
-            _mockSettings.Setup(s => s.Value).Returns(_settings);
-            _client = new LambdaClient(_mockSettings.Object);
         }
 
         [Fact]
-        public void Constructor_InitializesCorrectly()
-        {
-            // Assert
-            var expectedEndpoint = $"http://{_settings.LambdaEmulatorHost}:{_settings.LambdaEmulatorPort}";
-            Assert.Single(_client.Clients);
-            Assert.True(_client.Clients.ContainsKey(expectedEndpoint));
-        }
-
-        [Fact]
-        public async Task InvokeAsync_UsesCurrentEndpoint()
+        public void InvokeAsync_CreatesNewClientForNewEndpoint()
         {
             // Arrange
-            var request = new InvokeRequest();
+            var endpoint = "invalid://example.com";
+
+            // Act
+            _lambdaClient.InvokeAsync(_validRequest, endpoint);
 
-            // Act & Assert
-            await Assert.ThrowsAsync<AmazonLambdaException>(
-                async () => await _client.InvokeAsync(request));
+            // Assert
+            Assert.Single(_lambdaClient.Clients);
+            Assert.True(_lambdaClient.Clients.ContainsKey(endpoint));
         }
 
         [Fact]
-        public void SetEndpoint_CreatesNewClientForNewEndpoint()
+        public void InvokeAsync_ReuseExistingClientForSameEndpoint()
         {
             // Arrange
-            var newEndpoint = "http://newhost:1234";
-            var initialCount = _client.Clients.Count;
+            var endpoint = "invalid://example.com";
 
             // Act
-            _client.SetEndpoint(newEndpoint);
+            _lambdaClient.InvokeAsync(_validRequest, endpoint);
+            _lambdaClient.InvokeAsync(_validRequest, endpoint);
 
             // Assert
-            Assert.True(_client.Clients.ContainsKey(newEndpoint));
-            Assert.Equal(initialCount + 1, _client.Clients.Count);
+            Assert.Single(_lambdaClient.Clients);
+            Assert.True(_lambdaClient.Clients.ContainsKey(endpoint));
         }
 
         [Fact]
-        public void SetEndpoint_ReuseExistingClientForSameEndpoint()
+        public void InvokeAsync_CreatesSeparateClientsForDifferentEndpoints()
         {
             // Arrange
-            var initialEndpoint = $"http://{_settings.LambdaEmulatorHost}:{_settings.LambdaEmulatorPort}";
-            var initialCount = _client.Clients.Count;
+            var endpoint1 = "invalid://example1.com";
+            var endpoint2 = "invalid://example2.com";
 
             // Act
-            _client.SetEndpoint(initialEndpoint);
+            _lambdaClient.InvokeAsync(_validRequest, endpoint1);
+            _lambdaClient.InvokeAsync(_validRequest, endpoint2);
 
             // Assert
-            Assert.Equal(initialCount, _client.Clients.Count);
-            Assert.True(_client.Clients.ContainsKey(initialEndpoint));
+            Assert.Equal(2, _lambdaClient.Clients.Count);
+            Assert.True(_lambdaClient.Clients.ContainsKey(endpoint1));
+            Assert.True(_lambdaClient.Clients.ContainsKey(endpoint2));
         }
 
         [Fact]
-        public void Dispose_ClearsAllClients()
+        public void Dispose_ClearsClientDictionary()
         {
+            // Arrange
+            var endpoint = "invalid://example.com";
+            _lambdaClient.InvokeAsync(_validRequest, endpoint);
+            Assert.Single(_lambdaClient.Clients);
+
             // Act
-            _client.Dispose();
+            _lambdaClient.Dispose();
 
             // Assert
-            Assert.Empty(_client.Clients);
+            Assert.Empty(_lambdaClient.Clients);
         }
 
         [Fact]
-        public async Task Dispose_PreventsSubsequentOperations()
+        public void MultipleEndpoints_CreateCorrectNumberOfClients()
         {
             // Arrange
-            _client.Dispose();
+            var endpoints = new[]
+            {
+                "invalid://example1.com",
+                "invalid://example2.com",
+                "invalid://example3.com",
+                "invalid://example1.com" // Duplicate to test reuse
+            };
 
-            // Act & Assert
-            await Assert.ThrowsAnyAsync<Exception>(
-                async () => await _client.InvokeAsync(new InvokeRequest()));
+            // Act
+            foreach (var endpoint in endpoints)
+            {
+                _lambdaClient.InvokeAsync(_validRequest, endpoint);
+            }
+
+            // Assert
+            Assert.Equal(3, _lambdaClient.Clients.Count);
+            Assert.True(_lambdaClient.Clients.ContainsKey("invalid://example1.com"));
+            Assert.True(_lambdaClient.Clients.ContainsKey("invalid://example2.com"));
+            Assert.True(_lambdaClient.Clients.ContainsKey("invalid://example3.com"));
         }
 
         public void Dispose()
         {
-            _client?.Dispose();
+            _lambdaClient.Dispose();
         }
     }
 }