test: Program統合テスト追加と低カバレッジ領域のテスト強化

Author: Widthdom

FolderDiffIL4DotNet.Tests/ProgramTests.cs

@@ -0,0 +1,124 @@
+using System;
+using System.IO;
+using System.Reflection;
+using System.Threading.Tasks;
+using FolderDiffIL4DotNet.Services;
+using Xunit;
+
+namespace FolderDiffIL4DotNet.Tests
+{
+    public sealed class ProgramTests
+    {
+        private static readonly string ConfigFilePath = Path.Combine(AppContext.BaseDirectory, "config.json");
+
+        [Fact]
+        public async Task Main_WithInsufficientArguments_ReturnsErrorCode()
+        {
+            var exitCode = await InvokeProgramMainAsync(new[] { "--no-pause" });
+            Assert.Equal(1, exitCode);
+        }
+
+        [Fact]
+        public async Task Main_WithValidArguments_ReturnsSuccessAndGeneratesReport()
+        {
+            var tempRoot = Path.Combine(Path.GetTempPath(), "fd-program-tests-" + Guid.NewGuid().ToString("N"));
+            var oldDir = Path.Combine(tempRoot, "old");
+            var newDir = Path.Combine(tempRoot, "new");
+            Directory.CreateDirectory(oldDir);
+            Directory.CreateDirectory(newDir);
+            await File.WriteAllTextAsync(Path.Combine(oldDir, "sample.txt"), "same");
+            await File.WriteAllTextAsync(Path.Combine(newDir, "sample.txt"), "same");
+
+            var reportLabel = "report_" + Guid.NewGuid().ToString("N");
+            var reportDir = Path.Combine(AppContext.BaseDirectory, "Reports", reportLabel);
+            var configJson = """
+            {
+              "IgnoredExtensions": [],
+              "TextFileExtensions": [".txt"],
+              "MaxLogGenerations": 3,
+              "ShouldIncludeUnchangedFiles": true,
+              "ShouldIncludeIgnoredFiles": false,
+              "ShouldOutputILText": false,
+              "ShouldIgnoreILLinesContainingConfiguredStrings": false,
+              "ILIgnoreLineContainingStrings": [],
+              "ShouldOutputFileTimestamps": false,
+              "MaxParallelism": 1,
+              "EnableILCache": false,
+              "OptimizeForNetworkShares": false,
+              "AutoDetectNetworkShares": false
+            }
+            """;
+
+            try
+            {
+                await WithConfigFileAsync(configJson, async () =>
+                {
+                    var exitCode = await InvokeProgramMainAsync(new[] { oldDir, newDir, reportLabel, "--no-pause" });
+                    Assert.Equal(0, exitCode);
+                    Assert.True(File.Exists(Path.Combine(reportDir, "diff_report.md")));
+                });
+            }
+            finally
+            {
+                try
+                {
+                    if (Directory.Exists(tempRoot))
+                    {
+                        Directory.Delete(tempRoot, recursive: true);
+                    }
+                }
+                catch
+                {
+                    // ignore cleanup errors in tests
+                }
+                try
+                {
+                    if (Directory.Exists(reportDir))
+                    {
+                        Directory.Delete(reportDir, recursive: true);
+                    }
+                }
+                catch
+                {
+                    // ignore cleanup errors in tests
+                }
+            }
+        }
+
+        private static async Task<int> InvokeProgramMainAsync(string[] args)
+        {
+            var programType = typeof(ConfigService).Assembly.GetType("FolderDiffIL4DotNet.Program");
+            Assert.NotNull(programType);
+
+            var mainMethod = programType.GetMethod("Main", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+            Assert.NotNull(mainMethod);
+
+            var taskObject = mainMethod.Invoke(null, new object[] { args });
+            var task = Assert.IsAssignableFrom<Task<int>>(taskObject);
+            return await task;
+        }
+
+        private static async Task WithConfigFileAsync(string content, Func<Task> assertion)
+        {
+            var backupExists = File.Exists(ConfigFilePath);
+            var backupContent = backupExists ? await File.ReadAllTextAsync(ConfigFilePath) : null;
+
+            try
+            {
+                await File.WriteAllTextAsync(ConfigFilePath, content);
+                await assertion();
+            }
+            finally
+            {
+                if (backupExists)
+                {
+                    await File.WriteAllTextAsync(ConfigFilePath, backupContent ?? string.Empty);
+                }
+                else if (File.Exists(ConfigFilePath))
+                {
+                    File.Delete(ConfigFilePath);
+                }
+            }
+        }
+    }
+}

FolderDiffIL4DotNet.Tests/Services/DotNetDisassembleServiceTests.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using System.Reflection;
 using System.Threading.Tasks;
+using FolderDiffIL4DotNet.Common;
 using FolderDiffIL4DotNet.Models;
 using FolderDiffIL4DotNet.Services;
 using FolderDiffIL4DotNet.Services.Caching;
@@ -359,6 +360,44 @@ exit 1
             }
         }
 
+        [Fact]
+        public async Task PrefetchIlCacheAsync_NullInput_ReturnsWithoutThrowing()
+        {
+            var service = CreateService(CreateConfig(enableIlCache: true), new ILCache(Path.Combine(_rootDir, "prefetch-null"), _logger));
+            await service.PrefetchIlCacheAsync(null, maxParallel: 1);
+            Assert.Equal(0, service.IlCacheHits);
+        }
+
+        [Fact]
+        public async Task PrefetchIlCacheAsync_InvalidMaxParallel_Throws()
+        {
+            var service = CreateService(CreateConfig(enableIlCache: true), new ILCache(Path.Combine(_rootDir, "prefetch-invalid"), _logger));
+            await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => service.PrefetchIlCacheAsync(new[] { "dummy.dll" }, maxParallel: 0));
+        }
+
+        [Fact]
+        public async Task PrefetchIlCacheAsync_WhenSeededCacheExists_IncrementsHitCounter()
+        {
+            var cacheDir = Path.Combine(_rootDir, "prefetch-hit-cache");
+            var ilCache = new ILCache(cacheDir, _logger);
+            var service = CreateService(CreateConfig(enableIlCache: true), ilCache);
+
+            var assemblyPath = Path.Combine(_rootDir, "prefetch-target.dll");
+            await File.WriteAllTextAsync(assemblyPath, "dummy");
+
+            const string version = "1.2.3";
+            SeedDisassemblerVersionCache(Constants.DOTNET_ILDASM, version);
+            SeedDisassemblerVersionCache($"{Constants.DOTNET_MUXER} {Constants.ILDASM_LABEL}", version);
+            SeedDisassemblerVersionCache(Constants.ILSPY_CMD, version);
+
+            var label = $"{Constants.DOTNET_ILDASM} {Path.GetFileName(assemblyPath)} (version: {version})";
+            await ilCache.SetILAsync(assemblyPath, label, "CACHED_IL");
+
+            await service.PrefetchIlCacheAsync(new[] { assemblyPath }, maxParallel: 1);
+
+            Assert.True(service.IlCacheHits >= 1);
+        }
+
         private static ConfigSettings CreateConfig(bool enableIlCache) => new()
         {
             EnableILCache = enableIlCache,
@@ -416,6 +455,15 @@ private void ResetDisassemblerVersionCacheState()
             dictionary.Clear();
         }
 
+        private void SeedDisassemblerVersionCache(string key, string version)
+        {
+            var field = typeof(DotNetDisassemblerCache).GetField("_disassemblerVersionCache", BindingFlags.Instance | BindingFlags.NonPublic);
+            Assert.NotNull(field);
+            var dictionary = field.GetValue(_dotNetDisassemblerCache) as ConcurrentDictionary<string, string>;
+            Assert.NotNull(dictionary);
+            dictionary[key] = version;
+        }
+
         private DotNetDisassembleService CreateService(ConfigSettings config, ILCache ilCache)
             => new(config, ilCache, _resultLists, _logger, _dotNetDisassemblerCache);
     }

FolderDiffIL4DotNet.Tests/Services/ILOutputServiceTests.cs

@@ -1,7 +1,12 @@
+using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Reflection;
+using System.Threading.Tasks;
 using FolderDiffIL4DotNet.Models;
 using FolderDiffIL4DotNet.Services;
+using FolderDiffIL4DotNet.Services.Caching;
+using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 
 namespace FolderDiffIL4DotNet.Tests.Services
@@ -38,6 +43,103 @@ public void GetNormalizedIlIgnoreContainingStrings_RemovesEmptyTrimAndDuplicates
             Assert.Equal(new[] { "buildserver", "buildpath" }, result);
         }
 
+        [Theory]
+        [InlineData("dotnet ildasm sample.dll (version: 9.0.0)", "dotnet-ildasm (version: 9.0.0)")]
+        [InlineData("ilspycmd -il sample.dll (version: 8.2.1)", "ilspycmd (version: 8.2.1)")]
+        [InlineData("dotnet-ildasm sample.dll", "dotnet-ildasm")]
+        public void BuildToolAndVersionLabel_ReturnsExpectedLabel(string command, string expected)
+        {
+            var method = typeof(ILOutputService).GetMethod("BuildToolAndVersionLabel", BindingFlags.Static | BindingFlags.NonPublic);
+            Assert.NotNull(method);
+
+            var result = method.Invoke(null, new object[] { command });
+
+            Assert.Equal(expected, Assert.IsType<string>(result));
+        }
+
+        [Fact]
+        public void BuildComparisonDisassemblerLabel_WhenLabelsMismatch_Throws()
+        {
+            var method = typeof(ILOutputService).GetMethod("BuildComparisonDisassemblerLabel", BindingFlags.Static | BindingFlags.NonPublic);
+            Assert.NotNull(method);
+
+            var ex = Assert.Throws<TargetInvocationException>(() =>
+                method.Invoke(null, new object[]
+                {
+                    "dotnet ildasm sample.dll (version: 1.0.0)",
+                    "ilspycmd -il sample.dll (version: 2.0.0)"
+                }));
+            Assert.IsType<InvalidOperationException>(ex.InnerException);
+        }
+
+        [Fact]
+        public void BuildComparisonDisassemblerLabel_WhenOnlyOneSideHasLabel_ReturnsAvailableOne()
+        {
+            var method = typeof(ILOutputService).GetMethod("BuildComparisonDisassemblerLabel", BindingFlags.Static | BindingFlags.NonPublic);
+            Assert.NotNull(method);
+
+            var result = method.Invoke(null, new object[] { null, "ilspycmd -il sample.dll (version: 8.2.1)" });
+            Assert.Equal("ilspycmd (version: 8.2.1)", Assert.IsType<string>(result));
+        }
+
+        [Fact]
+        public void BuildComparisonDisassemblerLabel_WhenBothMatch_IgnoresCaseAndReturnsLabel()
+        {
+            var method = typeof(ILOutputService).GetMethod("BuildComparisonDisassemblerLabel", BindingFlags.Static | BindingFlags.NonPublic);
+            Assert.NotNull(method);
+
+            var result = method.Invoke(null, new object[]
+            {
+                "dotnet ildasm sample.dll (version: 1.0.0)",
+                "DOTNET ILDASM sample.dll (version: 1.0.0)"
+            });
+            Assert.Equal("dotnet-ildasm (version: 1.0.0)", Assert.IsType<string>(result));
+        }
+
+        [Fact]
+        public async Task PrecomputeAsync_WhenOptimizeForNetworkShares_ExitsWithoutThrowing()
+        {
+            var config = new ConfigSettings
+            {
+                OptimizeForNetworkShares = true,
+                EnableILCache = true,
+                IgnoredExtensions = new(),
+                TextFileExtensions = new()
+            };
+
+            var service = CreateILOutputService(config);
+            await service.PrecomputeAsync(new[] { "/tmp/non-existent.dll" }, maxParallel: 0);
+        }
+
+        [Fact]
+        public async Task PrecomputeAsync_WithInvalidMaxParallel_ThrowsWhenNotNetworkOptimized()
+        {
+            var config = new ConfigSettings
+            {
+                OptimizeForNetworkShares = false,
+                EnableILCache = false,
+                IgnoredExtensions = new(),
+                TextFileExtensions = new()
+            };
+
+            var service = CreateILOutputService(config);
+            await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => service.PrecomputeAsync(Array.Empty<string>(), maxParallel: 0));
+        }
+
+        [Fact]
+        public async Task PrecomputeAsync_WithCacheDisabled_ReturnsWithoutThrowing()
+        {
+            var config = new ConfigSettings
+            {
+                OptimizeForNetworkShares = false,
+                EnableILCache = false,
+                IgnoredExtensions = new(),
+                TextFileExtensions = new()
+            };
+            var service = CreateILOutputService(config);
+            await service.PrecomputeAsync(new[] { "/tmp/non-existent.dll" }, maxParallel: 1);
+        }
+
         private static bool InvokeShouldExcludeIlLine(string line, bool shouldIgnoreContainingStrings, IReadOnlyCollection<string> ilIgnoreContainingStrings)
         {
             var method = typeof(ILOutputService).GetMethod("ShouldExcludeIlLine", BindingFlags.Static | BindingFlags.NonPublic);
@@ -53,5 +155,21 @@ private static List<string> InvokeGetNormalizedIlIgnoreContainingStrings(ConfigS
             var result = method.Invoke(null, new object[] { config });
             return Assert.IsType<List<string>>(result);
         }
+
+        private static ILOutputService CreateILOutputService(ConfigSettings config, string ilOldFolder = null, string ilNewFolder = null)
+        {
+            var logger = new LoggerService();
+            var services = new ServiceCollection();
+            services.AddSingleton<ILoggerService>(logger);
+            services.AddSingleton(new FileDiffResultLists());
+            services.AddSingleton(new DotNetDisassemblerCache(logger));
+            var provider = services.BuildServiceProvider();
+
+            var oldDir = ilOldFolder ?? Path.Combine(Path.GetTempPath(), "fd-iloutput-old-" + Guid.NewGuid().ToString("N"));
+            var newDir = ilNewFolder ?? Path.Combine(Path.GetTempPath(), "fd-iloutput-new-" + Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(oldDir);
+            Directory.CreateDirectory(newDir);
+            return new ILOutputService(config, oldDir, newDir, provider, logger);
+        }
     }
 }