FileDiffServiceとFolderDiffServiceのテスト容易性を改善

Author: Widthdom

CHANGELOG.md

@@ -11,6 +11,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 #### Changed
 
+- Added `IFileSystemService` and `IFileComparisonService` as low-level seams for folder discovery/output I/O and per-file comparison I/O, making permission and disk-failure paths unit-testable without changing production behavior.
+- Split folder/file diff coverage more clearly into lightweight unit tests and temp-directory-backed integration tests, and expanded automated coverage for hash failures, IL-output failures, and large-text comparison paths.
+- Updated the README, developer guide, and testing guide in both English and Japanese to document the new service seams, test boundaries, and the latest passing test count (`218`).
 - Moved aggregated `MD5Mismatch` console warnings into `ProgramRunner`, kept `ReportGenerateService` report-only, and updated related docs and automated tests.
 - Replaced one-off `string.Format(...)` usage with interpolated strings, removed broad `#region` usage, and deleted now-unused format/message constants.
 - Updated the developer and testing guides to reflect the current source-style expectations and latest passing test count.
@@ -208,6 +211,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 #### 変更
 
+- `IFileSystemService` と `IFileComparisonService` を追加し、フォルダ列挙/出力系 I/O とファイル単位比較 I/O の差し替え口を明確にしました。これにより、本番挙動を変えずに権限エラーやディスク系失敗をユニットテストできるようにしました。
+- `FolderDiffService` / `FileDiffService` まわりのテストを、軽量ユニットテストと temp ディレクトリ前提の統合テストにより明確に分離し、ハッシュ失敗、IL 出力失敗、大きいテキスト比較経路の自動テストを拡充しました。
+- README、開発者ガイド、テストガイドの日英両記述を更新し、新しいサービス境界、テスト境界、最新の通過テスト件数（`218` 件）を反映しました。
 - 集約後の `MD5Mismatch` コンソール警告を `ProgramRunner` に移し、`ReportGenerateService` はレポート専用の責務に整理しました。あわせて関連ドキュメントと自動テストを更新しました。
 - 単発利用の `string.Format(...)` を補間文字列へ置き換え、広範な `#region` 利用をやめ、不要になった書式・メッセージ定数を削除しました。
 - 開発ガイドとテストガイドを更新し、現在のソースコード方針と最新の通過テスト件数を反映しました。

FolderDiffIL4DotNet.Tests/Services/FileDiffServiceTests.cs

@@ -12,6 +12,7 @@
 
 namespace FolderDiffIL4DotNet.Tests.Services
 {
+    [Trait("Category", "Integration")]
     public sealed class FileDiffServiceTests : IDisposable
     {
         private readonly string _rootDir;

FolderDiffIL4DotNet.Tests/Services/FileDiffServiceUnitTests.cs

@@ -0,0 +1,327 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using FolderDiffIL4DotNet.Models;
+using FolderDiffIL4DotNet.Services;
+using FolderDiffIL4DotNet.Utils;
+using Xunit;
+
+namespace FolderDiffIL4DotNet.Tests.Services
+{
+    [Trait("Category", "Unit")]
+    public sealed class FileDiffServiceUnitTests
+    {
+        [Fact]
+        public async Task FilesAreEqualAsync_WhenHashMatches_ReturnsTrueAndShortCircuitsFurtherWork()
+        {
+            var fileComparisonService = new FakeFileComparisonService
+            {
+                HashResult = true
+            };
+            var ilOutputService = new FakeILOutputService();
+            var resultLists = new FileDiffResultLists();
+            var logger = new TestLogger();
+            var service = CreateService(fileComparisonService, ilOutputService, resultLists, logger);
+
+            var areEqual = await service.FilesAreEqualAsync("sample.txt", maxParallel: 4);
+
+            Assert.True(areEqual);
+            Assert.Equal(FileDiffResultLists.DiffDetailResult.MD5Match, resultLists.FileRelativePathToDiffDetailDictionary["sample.txt"]);
+            Assert.Single(fileComparisonService.HashCalls);
+            Assert.Empty(fileComparisonService.DotNetDetectionCalls);
+            Assert.Empty(fileComparisonService.TextDiffCalls);
+            Assert.Empty(fileComparisonService.ReadChunkCalls);
+            Assert.Empty(ilOutputService.DiffCalls);
+        }
+
+        [Fact]
+        public async Task FilesAreEqualAsync_WhenHashDiffThrowsUnauthorizedAccessException_LogsErrorAndRethrows()
+        {
+            var fileComparisonService = new FakeFileComparisonService
+            {
+                HashException = new UnauthorizedAccessException("permission denied")
+            };
+            var ilOutputService = new FakeILOutputService();
+            var resultLists = new FileDiffResultLists();
+            var logger = new TestLogger();
+            var service = CreateService(fileComparisonService, ilOutputService, resultLists, logger);
+
+            var exception = await Assert.ThrowsAsync<UnauthorizedAccessException>(() => service.FilesAreEqualAsync("secret.bin"));
+
+            Assert.Equal("permission denied", exception.Message);
+            Assert.Contains(
+                logger.Entries,
+                entry => entry.LogLevel == AppLogLevel.Error
+                    && entry.Message.Contains("An error occurred while diffing", StringComparison.Ordinal));
+            Assert.Empty(resultLists.FileRelativePathToDiffDetailDictionary);
+        }
+
+        [Fact]
+        public async Task FilesAreEqualAsync_WhenIlOutputThrowsIOException_LogsErrorAndRethrows()
+        {
+            var fileComparisonService = new FakeFileComparisonService
+            {
+                HashResult = false,
+                DotNetDetectionResult = new DotNetExecutableDetectionResult(DotNetExecutableDetectionStatus.DotNetExecutable)
+            };
+            var ilOutputService = new FakeILOutputService
+            {
+                DiffException = new IOException("disk full")
+            };
+            var resultLists = new FileDiffResultLists();
+            var logger = new TestLogger();
+            var service = CreateService(fileComparisonService, ilOutputService, resultLists, logger);
+
+            var exception = await Assert.ThrowsAsync<IOException>(() => service.FilesAreEqualAsync("assembly.dll"));
+
+            Assert.Equal("disk full", exception.Message);
+            Assert.Single(ilOutputService.DiffCalls);
+            Assert.Contains(
+                logger.Entries,
+                entry => entry.LogLevel == AppLogLevel.Error
+                    && entry.Message.Contains("An error occurred while diffing", StringComparison.Ordinal));
+            Assert.Empty(resultLists.FileRelativePathToDiffDetailDictionary);
+        }
+
+        [Fact]
+        public async Task FilesAreEqualAsync_WhenLargeTextFilesMatch_UsesParallelChunkComparison()
+        {
+            const string relativePath = "large.txt";
+            var fileComparisonService = new FakeFileComparisonService
+            {
+                HashResult = false,
+                DotNetDetectionResult = new DotNetExecutableDetectionResult(DotNetExecutableDetectionStatus.NotDotNetExecutable)
+            };
+            var oldFileAbsolutePath = Path.Combine("/virtual/old", relativePath);
+            var newFileAbsolutePath = Path.Combine("/virtual/new", relativePath);
+            fileComparisonService.SetFileContent(oldFileAbsolutePath, new string('A', 2048));
+            fileComparisonService.SetFileContent(newFileAbsolutePath, new string('A', 2048));
+
+            var ilOutputService = new FakeILOutputService();
+            var resultLists = new FileDiffResultLists();
+            var logger = new TestLogger();
+            var service = CreateService(
+                fileComparisonService,
+                ilOutputService,
+                resultLists,
+                logger,
+                optimizeForNetworkShares: false,
+                configure: config =>
+                {
+                    config.TextDiffParallelThresholdKilobytes = 1;
+                    config.TextDiffChunkSizeKilobytes = 1;
+                });
+
+            var areEqual = await service.FilesAreEqualAsync(relativePath, maxParallel: 2);
+
+            Assert.True(areEqual);
+            Assert.Equal(FileDiffResultLists.DiffDetailResult.TextMatch, resultLists.FileRelativePathToDiffDetailDictionary[relativePath]);
+            Assert.NotEmpty(fileComparisonService.ReadChunkCalls);
+            Assert.Empty(fileComparisonService.TextDiffCalls);
+        }
+
+        [Fact]
+        public async Task FilesAreEqualAsync_WhenSequentialTextCompareThrowsUnauthorizedAccessException_LogsWarningThenErrorAndRethrows()
+        {
+            const string relativePath = "locked.txt";
+            var fileComparisonService = new FakeFileComparisonService
+            {
+                HashResult = false,
+                DotNetDetectionResult = new DotNetExecutableDetectionResult(DotNetExecutableDetectionStatus.NotDotNetExecutable),
+                TextDiffException = new UnauthorizedAccessException("text access denied")
+            };
+            var ilOutputService = new FakeILOutputService();
+            var resultLists = new FileDiffResultLists();
+            var logger = new TestLogger();
+            var service = CreateService(
+                fileComparisonService,
+                ilOutputService,
+                resultLists,
+                logger,
+                optimizeForNetworkShares: true);
+
+            var exception = await Assert.ThrowsAsync<UnauthorizedAccessException>(() => service.FilesAreEqualAsync(relativePath, maxParallel: 1));
+
+            Assert.Equal("text access denied", exception.Message);
+            var warning = Assert.Single(logger.Entries, entry => entry.LogLevel == AppLogLevel.Warning);
+            Assert.Contains("Falling back to sequential text diff", warning.Message);
+            Assert.IsType<UnauthorizedAccessException>(warning.Exception);
+            Assert.Contains(
+                logger.Entries,
+                entry => entry.LogLevel == AppLogLevel.Error
+                    && entry.Message.Contains("An error occurred while diffing", StringComparison.Ordinal));
+            Assert.Empty(resultLists.FileRelativePathToDiffDetailDictionary);
+        }
+
+        private static FileDiffService CreateService(
+            FakeFileComparisonService fileComparisonService,
+            FakeILOutputService ilOutputService,
+            FileDiffResultLists resultLists,
+            TestLogger logger,
+            bool optimizeForNetworkShares = false,
+            Action<ConfigSettings> configure = null)
+        {
+            var config = new ConfigSettings
+            {
+                TextFileExtensions = new List<string> { ".txt" },
+                IgnoredExtensions = new List<string>(),
+                ShouldOutputILText = false,
+                EnableILCache = false,
+                OptimizeForNetworkShares = optimizeForNetworkShares,
+                TextDiffParallelThresholdKilobytes = 512,
+                TextDiffChunkSizeKilobytes = 64
+            };
+            configure?.Invoke(config);
+
+            var executionContext = new DiffExecutionContext(
+                "/virtual/old",
+                "/virtual/new",
+                "/virtual/report",
+                optimizeForNetworkShares: optimizeForNetworkShares,
+                detectedNetworkOld: false,
+                detectedNetworkNew: false);
+            return new FileDiffService(config, ilOutputService, executionContext, resultLists, logger, fileComparisonService);
+        }
+
+        private sealed class FakeFileComparisonService : IFileComparisonService
+        {
+            private readonly Dictionary<string, byte[]> _fileContentsByPath = new(StringComparer.OrdinalIgnoreCase);
+
+            public bool HashResult { get; set; }
+
+            public Exception HashException { get; set; }
+
+            public bool TextDiffResult { get; set; }
+
+            public Exception TextDiffException { get; set; }
+
+            public Exception ReadChunkException { get; set; }
+
+            public DotNetExecutableDetectionResult DotNetDetectionResult { get; set; } =
+                new(DotNetExecutableDetectionStatus.NotDotNetExecutable);
+
+            public List<(string File1, string File2)> HashCalls { get; } = new();
+
+            public List<string> DotNetDetectionCalls { get; } = new();
+
+            public List<(string File1, string File2)> TextDiffCalls { get; } = new();
+
+            public List<(string Path, long Offset, int Length)> ReadChunkCalls { get; } = new();
+
+            public void SetFileContent(string path, string content)
+                => _fileContentsByPath[path] = System.Text.Encoding.UTF8.GetBytes(content);
+
+            public Task<bool> DiffFilesByHashAsync(string file1AbsolutePath, string file2AbsolutePath)
+            {
+                HashCalls.Add((file1AbsolutePath, file2AbsolutePath));
+                if (HashException != null)
+                {
+                    throw HashException;
+                }
+                return Task.FromResult(HashResult);
+            }
+
+            public Task<bool> DiffTextFilesAsync(string file1AbsolutePath, string file2AbsolutePath)
+            {
+                TextDiffCalls.Add((file1AbsolutePath, file2AbsolutePath));
+                if (TextDiffException != null)
+                {
+                    throw TextDiffException;
+                }
+                return Task.FromResult(TextDiffResult);
+            }
+
+            public DotNetExecutableDetectionResult DetectDotNetExecutable(string fileAbsolutePath)
+            {
+                DotNetDetectionCalls.Add(fileAbsolutePath);
+                return DotNetDetectionResult;
+            }
+
+            public bool FileExists(string fileAbsolutePath)
+                => _fileContentsByPath.ContainsKey(fileAbsolutePath);
+
+            public long GetFileLength(string fileAbsolutePath)
+            {
+                if (_fileContentsByPath.TryGetValue(fileAbsolutePath, out var content))
+                {
+                    return content.LongLength;
+                }
+
+                throw new FileNotFoundException($"File not found: {fileAbsolutePath}", fileAbsolutePath);
+            }
+
+            public Task<int> ReadChunkAsync(string fileAbsolutePath, long offset, Memory<byte> buffer, CancellationToken cancellationToken)
+            {
+                ReadChunkCalls.Add((fileAbsolutePath, offset, buffer.Length));
+                if (ReadChunkException != null)
+                {
+                    throw ReadChunkException;
+                }
+                if (!_fileContentsByPath.TryGetValue(fileAbsolutePath, out var content))
+                {
+                    throw new FileNotFoundException($"File not found: {fileAbsolutePath}", fileAbsolutePath);
+                }
+
+                int start = checked((int)offset);
+                if (start >= content.Length)
+                {
+                    return Task.FromResult(0);
+                }
+
+                int count = Math.Min(buffer.Length, content.Length - start);
+                content.AsMemory(start, count).CopyTo(buffer);
+                return Task.FromResult(count);
+            }
+        }
+
+        private sealed class FakeILOutputService : IILOutputService
+        {
+            public (bool AreEqual, string DisassemblerLabel) DiffResult { get; set; }
+
+            public Exception DiffException { get; set; }
+
+            public List<DiffCall> DiffCalls { get; } = new();
+
+            public Task PrecomputeAsync(IEnumerable<string> filesAbsolutePaths, int maxParallel)
+                => Task.CompletedTask;
+
+            public Task<(bool AreEqual, string DisassemblerLabel)> DiffDotNetAssembliesAsync(string fileRelativePath, string oldFolderAbsolutePath, string newFolderAbsolutePath, bool shouldOutputIlText)
+            {
+                DiffCalls.Add(new DiffCall(fileRelativePath, oldFolderAbsolutePath, newFolderAbsolutePath, shouldOutputIlText));
+                if (DiffException != null)
+                {
+                    throw DiffException;
+                }
+                return Task.FromResult(DiffResult);
+            }
+        }
+
+        private sealed class TestLogger : ILoggerService
+        {
+            public string LogFileAbsolutePath => null;
+
+            public List<LogEntry> Entries { get; } = new();
+
+            public void Initialize()
+            {
+            }
+
+            public void CleanupOldLogFiles(int maxLogGenerations)
+            {
+            }
+
+            public void LogMessage(AppLogLevel logLevel, string message, bool shouldOutputMessageToConsole, Exception exception = null)
+                => LogMessage(logLevel, message, shouldOutputMessageToConsole, consoleForegroundColor: null, exception);
+
+            public void LogMessage(AppLogLevel logLevel, string message, bool shouldOutputMessageToConsole, ConsoleColor? consoleForegroundColor, Exception exception = null)
+                => Entries.Add(new LogEntry(logLevel, message, exception));
+        }
+
+        private sealed record DiffCall(string FileRelativePath, string OldFolderAbsolutePath, string NewFolderAbsolutePath, bool ShouldOutputIlText);
+
+        private sealed record LogEntry(AppLogLevel LogLevel, string Message, Exception Exception);
+    }
+}

FolderDiffIL4DotNet.Tests/Services/FolderDiffServiceTests.cs

@@ -10,6 +10,7 @@
 
 namespace FolderDiffIL4DotNet.Tests.Services
 {
+    [Trait("Category", "Integration")]
     public sealed class FolderDiffServiceTests : IDisposable
     {
         private readonly string _rootDir;