**Add comprehensive unit tests for services, models, and utilities**

- Added tests for UpdateService, StatsService, BugReportService, AppConfig, PbpExtractionResult, and GitHubRelease
- Expanded PathUtilsTests, FileExtensionsTests, and GameFileParserTests with new edge cases and validations
- Added InternalsVisibleTo for test access and introduced AppHttpClient
- Updated project file and test coverage

Author: drpetersonfernandes

BatchConvertToCHD.Tests/AppConfigTests.cs

@@ -0,0 +1,75 @@
+using System.Runtime.InteropServices;
+
+namespace BatchConvertToCHD.Tests;
+
+public class AppConfigTests
+{
+    [Fact]
+    public void IsArm64ReturnsBool()
+    {
+        var result = AppConfig.IsArm64;
+        var expected = RuntimeInformation.ProcessArchitecture == Architecture.Arm64;
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void ChdmanExeNameMatchesArchitecture()
+    {
+        if (AppConfig.IsArm64)
+        {
+            Assert.Equal("chdman_arm64.exe", AppConfig.ChdmanExeName);
+        }
+        else
+        {
+            Assert.Equal("chdman.exe", AppConfig.ChdmanExeName);
+        }
+    }
+
+    [Fact]
+    public void BugReportApiUrlIsNotEmpty()
+    {
+        Assert.False(string.IsNullOrEmpty(AppConfig.BugReportApiUrl));
+    }
+
+    [Fact]
+    public void BugReportApiKeyIsNotEmpty()
+    {
+        Assert.False(string.IsNullOrEmpty(AppConfig.BugReportApiKey));
+    }
+
+    [Fact]
+    public void ApplicationStatsApiUrlIsNotEmpty()
+    {
+        Assert.False(string.IsNullOrEmpty(AppConfig.ApplicationStatsApiUrl));
+    }
+
+    [Fact]
+    public void ApplicationStatsApiKeyIsNotEmpty()
+    {
+        Assert.False(string.IsNullOrEmpty(AppConfig.ApplicationStatsApiKey));
+    }
+
+    [Fact]
+    public void ApplicationNameIsCorrect()
+    {
+        Assert.Equal("BatchConvertToCHD", AppConfig.ApplicationName);
+    }
+
+    [Fact]
+    public void WriteSpeedUpdateIntervalMsIsPositive()
+    {
+        Assert.True(AppConfig.WriteSpeedUpdateIntervalMs > 0);
+    }
+
+    [Fact]
+    public void MaxConversionTimeoutHoursIsPositive()
+    {
+        Assert.True(AppConfig.MaxConversionTimeoutHours > 0);
+    }
+
+    [Fact]
+    public void PsxPackagerExeNameIsNotEmpty()
+    {
+        Assert.False(string.IsNullOrEmpty(AppConfig.PsxPackagerExeName));
+    }
+}

BatchConvertToCHD.Tests/ArchiveServiceTests.cs

@@ -1,6 +1,6 @@
 using System.IO.Compression;
-using System.Reflection;
 using BatchConvertToCHD.Services;
+using SharpCompressZipArchive = SharpCompress.Archives.Zip.ZipArchive;
 
 namespace BatchConvertToCHD.Tests;
 
@@ -115,7 +115,7 @@ public async Task ExtractCsoAsyncMaxCsoNotAvailableReturnsFailure()
         var service = new ArchiveService("maxcso.exe", false);
         var tempIso = Path.Combine(_tempDir, "out.iso");
 
-        var result = await service.ExtractCsoAsync("input.cso", tempIso, _tempDir, static _ => { }, static _ => { }, CancellationToken.None);
+        var result = await service.ExtractCsoAsync("input.cso", tempIso, _tempDir, static _ => { }, CancellationToken.None);
 
         Assert.False(result.Success);
         Assert.Contains("maxcso.exe is not available", result.ErrorMessage);
@@ -132,34 +132,50 @@ public void DisposeDoesNotThrow()
     [Fact]
     public void ExtractArchiveWithFallbackMissingFileThrowsFileNotFoundWithoutFallback()
     {
-        var method = typeof(ArchiveService).GetMethod("ExtractArchiveWithFallback", BindingFlags.NonPublic | BindingFlags.Static);
-        Assert.NotNull(method);
-
-        // Construct the generic method with a concrete archive type that satisfies the constraints
-        var genericMethod = method.MakeGenericMethod(typeof(SharpCompress.Archives.Zip.ZipArchive));
-
         var missingPath = Path.Combine(_tempDir, $"missing_{Guid.NewGuid():N}.7z");
         var outputDir = Path.Combine(_tempDir, "out");
         Directory.CreateDirectory(outputDir);
         var logs = new List<string>();
 
         var ex = Record.Exception(() =>
         {
-            genericMethod.Invoke(
-                null,
-                [
-                    missingPath,
-                    outputDir,
-                    (Action<string>)(logs.Add),
-                    ".7z",
-                    (Func<Stream, SharpCompress.Archives.Zip.ZipArchive>)(static _ => throw new InvalidOperationException("Should not reach here")),
-                    CancellationToken.None
-                ]);
+            ArchiveService.ExtractArchiveWithFallback<SharpCompressZipArchive>(
+                missingPath,
+                outputDir,
+                logs.Add,
+                ".7z",
+                static _ => throw new InvalidOperationException("Should not reach here"),
+                CancellationToken.None);
         });
 
         Assert.NotNull(ex);
-        var inner = ex is TargetInvocationException tie ? tie.InnerException : ex;
-        Assert.IsType<FileNotFoundException>(inner);
+        Assert.IsType<FileNotFoundException>(ex);
         Assert.Contains(logs, static msg => msg.Contains("Skipping fallback", StringComparison.OrdinalIgnoreCase));
     }
+
+    [Fact]
+    public async Task ExtractArchiveAsyncInvalidSevenZipReturnsFailure()
+    {
+        var service = new ArchiveService("maxcso.exe", false);
+        var sevenZPath = Path.Combine(_tempDir, "invalid.7z");
+        File.WriteAllText(sevenZPath, "not a valid 7z archive");
+        var tempDir = Path.Combine(_tempDir, "extract");
+
+        var result = await service.ExtractArchiveAsync(sevenZPath, tempDir, static _ => { }, CancellationToken.None);
+
+        Assert.False(result.Success);
+    }
+
+    [Fact]
+    public async Task ExtractArchiveAsyncInvalidRarReturnsFailure()
+    {
+        var service = new ArchiveService("maxcso.exe", false);
+        var rarPath = Path.Combine(_tempDir, "invalid.rar");
+        File.WriteAllText(rarPath, "not a valid rar archive");
+        var tempDir = Path.Combine(_tempDir, "extract");
+
+        var result = await service.ExtractArchiveAsync(rarPath, tempDir, static _ => { }, CancellationToken.None);
+
+        Assert.False(result.Success);
+    }
 }

BatchConvertToCHD.Tests/BugReportServiceTests.cs

@@ -0,0 +1,170 @@
+using System.Reflection;
+using System.Text;
+using BatchConvertToCHD.Services;
+
+namespace BatchConvertToCHD.Tests;
+
+public class BugReportServiceTests
+{
+    private const string TestApiUrl = "https://example.com/api/bugreport";
+    private const string TestApiKey = "test-api-key";
+    private const string TestAppName = "TestApp";
+
+    [Fact]
+    public void ConstructorStoresParametersCorrectly()
+    {
+        var service = new BugReportService(TestApiUrl, TestApiKey, TestAppName);
+
+        var apiUrlField = typeof(BugReportService).GetField("_apiUrl", BindingFlags.NonPublic | BindingFlags.Instance);
+        var apiKeyField = typeof(BugReportService).GetField("_apiKey", BindingFlags.NonPublic | BindingFlags.Instance);
+        var appNameField = typeof(BugReportService).GetField("_applicationName", BindingFlags.NonPublic | BindingFlags.Instance);
+
+        Assert.NotNull(apiUrlField);
+        Assert.NotNull(apiKeyField);
+        Assert.NotNull(appNameField);
+        Assert.Equal(TestApiUrl, apiUrlField.GetValue(service));
+        Assert.Equal(TestApiKey, apiKeyField.GetValue(service));
+        Assert.Equal(TestAppName, appNameField.GetValue(service));
+    }
+
+    [Fact]
+    public void BuildFormattedReportIncludesMessageAndAppName()
+    {
+        var service = new BugReportService(TestApiUrl, TestApiKey, TestAppName);
+        var method = typeof(BugReportService).GetMethod("BuildFormattedReport", BindingFlags.NonPublic | BindingFlags.Instance);
+        Assert.NotNull(method);
+
+        var result = method.Invoke(service, ["Test error message", null]) as string;
+        Assert.NotNull(result);
+        Assert.Contains("Test error message", result, StringComparison.Ordinal);
+        Assert.Contains(TestAppName, result, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void BuildFormattedReportIncludesExceptionDetails()
+    {
+        var service = new BugReportService(TestApiUrl, TestApiKey, TestAppName);
+        var method = typeof(BugReportService).GetMethod("BuildFormattedReport", BindingFlags.NonPublic | BindingFlags.Instance);
+        Assert.NotNull(method);
+
+        var ex = new InvalidOperationException("Something went wrong");
+        var result = method.Invoke(service, ["Error summary", ex]) as string;
+        Assert.NotNull(result);
+        Assert.Contains("Error summary", result, StringComparison.Ordinal);
+        Assert.Contains("InvalidOperationException", result, StringComparison.Ordinal);
+        Assert.Contains("Something went wrong", result, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void BuildFormattedReportIncludesInnerException()
+    {
+        var service = new BugReportService(TestApiUrl, TestApiKey, TestAppName);
+        var method = typeof(BugReportService).GetMethod("BuildFormattedReport", BindingFlags.NonPublic | BindingFlags.Instance);
+        Assert.NotNull(method);
+
+        var inner = new ArgumentException("Inner error");
+        var outer = new InvalidOperationException("Outer error", inner);
+        var result = method.Invoke(service, ["Error summary", outer]) as string;
+        Assert.NotNull(result);
+        Assert.Contains("Inner Exception", result, StringComparison.Ordinal);
+        Assert.Contains("Inner error", result, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void GetExceptionStackTraceNullReturnsNa()
+    {
+        var method = typeof(BugReportService).GetMethod("GetExceptionStackTrace", BindingFlags.NonPublic | BindingFlags.Static);
+        Assert.NotNull(method);
+
+        var result = method.Invoke(null, [null]) as string;
+        Assert.Equal("N/A", result);
+    }
+
+    [Fact]
+    public void GetExceptionStackTraceIncludesExceptionDetails()
+    {
+        var method = typeof(BugReportService).GetMethod("GetExceptionStackTrace", BindingFlags.NonPublic | BindingFlags.Static);
+        Assert.NotNull(method);
+
+        var ex = new InvalidOperationException("Test error");
+        var result = method.Invoke(null, [ex]) as string;
+        Assert.NotNull(result);
+        Assert.Contains("InvalidOperationException", result, StringComparison.Ordinal);
+        Assert.Contains("Test error", result, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void GetExceptionStackTraceHandlesNestedExceptions()
+    {
+        var method = typeof(BugReportService).GetMethod("GetExceptionStackTrace", BindingFlags.NonPublic | BindingFlags.Static);
+        Assert.NotNull(method);
+
+        var deep = new FormatException("Deep");
+        var mid = new ArgumentException("Mid", deep);
+        var top = new InvalidOperationException("Top", mid);
+        var result = method.Invoke(null, [top]) as string;
+        Assert.NotNull(result);
+        Assert.Contains("Top", result, StringComparison.Ordinal);
+        Assert.Contains("Mid", result, StringComparison.Ordinal);
+        Assert.Contains("Deep", result, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void GetExceptionStackTraceLimitsDepth()
+    {
+        var method = typeof(BugReportService).GetMethod("GetExceptionStackTrace", BindingFlags.NonPublic | BindingFlags.Static);
+        Assert.NotNull(method);
+
+        var inner = new Exception("deepest");
+        var current = inner;
+        for (var i = 0; i < 10; i++)
+        {
+            current = new Exception($"level {i}", current);
+        }
+
+        var result = method.Invoke(null, [current]) as string;
+        Assert.NotNull(result);
+    }
+
+    [Fact]
+    public void GetEnvironmentDetailsReturnsValidValues()
+    {
+        var method = typeof(BugReportService).GetMethod("GetEnvironmentDetails", BindingFlags.NonPublic | BindingFlags.Static);
+        Assert.NotNull(method);
+
+        var result = method.Invoke(null, null);
+        Assert.NotNull(result);
+
+        var type = result.GetType();
+        var osVersion = type.GetField("Item1")?.GetValue(result) as string;
+        var architecture = type.GetField("Item2")?.GetValue(result) as string;
+        var processorCount = type.GetField("Item5")?.GetValue(result);
+
+        Assert.NotNull(osVersion);
+        Assert.NotEmpty(osVersion);
+        Assert.NotNull(architecture);
+        Assert.NotEmpty(architecture);
+        Assert.IsType<int>(processorCount);
+    }
+
+    [Fact]
+    public void AppendExceptionDetailsWithNullStackTraceDoesNotCrash()
+    {
+        var method = typeof(BugReportService).GetMethod("AppendExceptionDetails", BindingFlags.NonPublic | BindingFlags.Static);
+        Assert.NotNull(method);
+
+        var sb = new StringBuilder();
+        var ex = new Exception("No stack") { };
+        var record = Record.Exception(() => method.Invoke(null, [sb, ex, 0]));
+        Assert.Null(record);
+        Assert.Contains("No stack", sb.ToString(), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task SendBugReportAsyncReturnsFalseOnNetworkError()
+    {
+        var service = new BugReportService("https://invalid.example.invalid/api", TestApiKey, TestAppName);
+        var result = await service.SendBugReportAsync("Test message");
+        Assert.False(result);
+    }
+}