More and better tests

Curupira.Tests/AppClient/Services/AutofacHelperTests.cs

@@ -0,0 +1,46 @@
+using Autofac;
+using Curupira.AppClient.Services;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Curupira.Tests.AppClient.Services
+{
+    [TestClass]
+    public class AutofacHelperTests
+    {
+        private IContainer _container;
+        private AutofacHelper _autofacHelper;
+
+        [TestInitialize]
+        public void SetUp()
+        {
+            var builder = new ContainerBuilder();
+            // Register types here
+            builder.RegisterType<SomeImplementation>().As<ISomeInterface>().Named<ISomeInterface>("SomeName");
+            _container = builder.Build();
+
+            _autofacHelper = new AutofacHelper(_container);
+        }
+
+        [TestCleanup]
+        public void Cleanup()
+        {
+            _container.Dispose();
+        }
+
+        [TestMethod]
+        public void GetNamedImplementationsOfInterface_ShouldReturnCorrectImplementations()
+        {
+            // Act
+            var implementations = _autofacHelper.GetNamedImplementationsOfInterface<ISomeInterface>();
+
+            // Assert
+            Assert.AreEqual(1, implementations.Count);
+            Assert.AreEqual("SomeName", implementations[0].Name);
+            Assert.AreEqual(typeof(SomeImplementation), implementations[0].ImplementationType);
+        }
+
+        public interface ISomeInterface { }
+
+        public class SomeImplementation : ISomeInterface { }
+    }
+}

Curupira.Tests/Curupira.Tests.csproj

@@ -165,6 +165,7 @@
   <ItemGroup>
     <Compile Include="AppClient\AppRunnerTests.cs" />
     <Compile Include="AppClient\OptionsTests.cs" />
+    <Compile Include="AppClient\Services\AutofacHelperTests.cs" />
     <Compile Include="AppClient\Services\PluginExecutorTests.cs" />
     <Compile Include="Plugins\Backup\BackupPluginConfigParserTests.cs" />
     <Compile Include="Plugins\Backup\BackupPluginTests.cs" />
@@ -178,9 +179,11 @@
     <Compile Include="Plugins\FoldersCreator\FoldersCreatorPluginWithDelay.cs" />
     <Compile Include="Plugins\Installer\InstallerPluginConfigParserTests.cs" />
     <Compile Include="Plugins\Installer\InstallerPluginTests.cs" />
+    <Compile Include="Plugins\Installer\ProcessExecutorTests.cs" />
     <Compile Include="Plugins\ServiceManager\ServiceManagerPluginConfigParserTests.cs" />
     <Compile Include="Plugins\ServiceManager\ServiceManagerPluginTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="WindowsService\ApiKeyValidationTests.cs" />
     <Compile Include="WindowsService\AppRunnerTests.cs" />
     <Compile Include="WindowsService\Controllers\BackupControllerTests.cs" />
     <Compile Include="WindowsService\Controllers\EventLogsControllerTests.cs" />

Curupira.Tests/Plugins/Installer/InstallerPluginTests.cs

@@ -40,6 +40,12 @@ public void Setup()
             _plugin.Init();
         }
 
+        [TestCleanup]
+        public void Cleanup()
+        {
+            _plugin?.Dispose();
+        }
+
         [TestMethod]
         public async Task ExecuteAsync_ShouldExtractZipComponentSuccessfully_RealFileSystem()
         {

Curupira.Tests/Plugins/Installer/ProcessExecutorTests.cs

@@ -0,0 +1,48 @@
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Curupira.Plugins.Installer;
+
+namespace Curupira.Tests.Plugins.Installer
+{
+    [TestClass]
+    public class ProcessExecutorTests
+    {
+        private IProcessExecutor _processExecutor;
+
+        [TestInitialize]
+        public void SetUp()
+        {
+            _processExecutor = new ProcessExecutor();
+        }
+
+        [TestMethod]
+        public async Task ExecuteAsync_ShouldReturnZeroExitCode_WhenCommandSucceeds()
+        {
+            // Arrange
+            string fileName = "cmd.exe";
+            string arguments = "/c echo Hello, World!";
+            string workingDirectory = ".";
+
+            // Act
+            int exitCode = await _processExecutor.ExecuteAsync(fileName, arguments, workingDirectory);
+
+            // Assert
+            Assert.AreEqual(0, exitCode);
+        }
+
+        [TestMethod]
+        public async Task ExecuteAsync_ShouldReturnNonZeroExitCode_WhenCommandFails()
+        {
+            // Arrange
+            string fileName = "cmd.exe";
+            string arguments = "/c invalidcommand";
+            string workingDirectory = ".";
+
+            // Act
+            int exitCode = await _processExecutor.ExecuteAsync(fileName, arguments, workingDirectory);
+
+            // Assert
+            Assert.AreNotEqual(0, exitCode);
+        }
+    }
+}

Curupira.Tests/Plugins/ServiceManager/ServiceManagerPluginTests.cs

@@ -46,6 +46,12 @@ public void Setup()
             _serviceManagerPluginMock.Object.Init();
         }
 
+        [TestCleanup]
+        public void Cleanup()
+        {
+            _serviceManagerPluginMock?.Object.Dispose();
+        }
+
         [TestMethod]
         public async Task Execute_ShouldLogError_WhenBundleIsMissing()
         {

Curupira.Tests/WindowsService/ApiKeyValidationTests.cs

@@ -0,0 +1,74 @@
+using Curupira.WindowsService;
+using Microsoft.Owin.Testing;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Net.Http;
+using System.Threading.Tasks;
+
+namespace Curupira.Tests.WindowsService
+{
+    [TestClass]
+    public class ApiKeyValidationTests
+    {
+        private TestServer _server;
+        private HttpClient _client;
+        private string _validApiKey;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            _validApiKey = Guid.NewGuid().ToString();
+            Environment.SetEnvironmentVariable("API_KEY", _validApiKey);
+            _server = TestServer.Create<Startup>();
+            _client = _server.HttpClient;
+        }
+
+        [TestCleanup]
+        public void Cleanup()
+        {
+            _client.Dispose();
+            _server.Dispose();
+        }
+
+        [TestMethod]
+        public async Task GetSystemUsage_WithValidApiKey_ReturnsOk()
+        {
+            // Arrange
+            var request = new HttpRequestMessage(HttpMethod.Get, "/api/v1/system/usage");
+            request.Headers.Add("X-Api-Key", _validApiKey);
+
+            // Act
+            var response = await _client.SendAsync(request).ConfigureAwait(false);
+
+            // Assert
+            Assert.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode);
+        }
+
+        [TestMethod]
+        public async Task GetSystemUsage_WithInvalidApiKey_ReturnsUnauthorized()
+        {
+            // Arrange
+            var request = new HttpRequestMessage(HttpMethod.Get, "/api/v1/system/usage");
+            request.Headers.Add("X-Api-Key", "invalidApiKey");
+
+            // Act
+            var response = await _client.SendAsync(request).ConfigureAwait(false);
+
+            // Assert
+            Assert.AreEqual(System.Net.HttpStatusCode.Unauthorized, response.StatusCode);
+        }
+
+        [TestMethod]
+        public async Task GetSystemUsage_WithNoApiKey_ReturnsUnauthorized()
+        {
+            // Arrange
+            var request = new HttpRequestMessage(HttpMethod.Get, "/api/v1/system/usage");
+
+            // Act
+            var response = await _client.SendAsync(request).ConfigureAwait(false);
+
+            // Assert
+            Assert.AreEqual(System.Net.HttpStatusCode.Unauthorized, response.StatusCode);
+        }
+    }
+}

Curupira.Tests/WindowsService/StartupIntegrationTests.cs

@@ -1,4 +1,5 @@
 using Curupira.WindowsService;
+using Curupira.WindowsService.Controllers;
 using Microsoft.Owin.Testing;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
@@ -60,5 +61,25 @@ public void Startup_ThrowsException_WhenApiKeyNotDefined()
                 Assert.ThrowsException<InvalidOperationException>(() => server.HttpClient.GetAsync("/api/health").RunSynchronously());
             }
         }
+
+        [TestMethod]
+        public async Task Get_ThrowsUnhandledException_GlobalExceptionFilterHandlesIt()
+        {
+            // Arrange
+            HealthController.ShouldThrowException = true;
+            var requestUri = "/api/health"; // Reusing the existing health endpoint
+
+            // Act
+            var response = await _client.GetAsync(requestUri).ConfigureAwait(false);
+
+            // Assert
+            Assert.AreEqual(System.Net.HttpStatusCode.InternalServerError, response.StatusCode);
+
+            var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+            Assert.IsTrue(content.Contains("An error occurred. Please try again later."));
+
+            // Cleanup
+            HealthController.ShouldThrowException = false;
+        }
     }
 }

Curupira.WindowsService/Controllers/HealthController.cs

@@ -5,10 +5,19 @@ namespace Curupira.WindowsService.Controllers
 {
     public class HealthController : ApiController
     {
+        public static bool ShouldThrowException { get; set; } = false;
+
         [HttpGet]
         [Route("api/health")]
         public IHttpActionResult CheckHealth()
         {
+            if (ShouldThrowException)
+            {
+#pragma warning disable S112 // General or reserved exceptions should never be thrown
+                throw new Exception("This is an unhandled exception.");
+#pragma warning restore S112 // General or reserved exceptions should never be thrown
+            }
+
             return Ok(new { status = "Healthy", timestamp = DateTime.UtcNow });
         }
     }