dotnet-testing-filesystem-testing-abstractions

name	dotnet-testing-filesystem-testing-abstractions
description	Specialized skill for testing file system operations using System.IO.Abstractions. Use when you need to test File, Directory, Path operations, or simulate file system. Covers IFileSystem, MockFileSystem, file read/write testing, directory operation testing, etc. Keywords: file testing, filesystem, file testing, file system testing, IFileSystem, MockFileSystem, System.IO.Abstractions, File.ReadAllText, File.WriteAllText, Directory.CreateDirectory, Path.Combine, mock file system, file abstraction
metadata	{"short-description":".NET skill guidance for dotnet-testing-filesystem-testing-abstractions"}

Source: kevintsengtw/dotnet-testing-agent-skills (MIT). Ported into dotnet-agent-harness.

File System Testing: Using System.IO.Abstractions to Simulate File Operations

Applicable Scenarios

Use this skill when asked to perform the following tasks:

• Refactor code directly using System.IO.File, System.IO.Directory and other static classes
• Write unit tests for code involving file read/write, directory operations
• Use MockFileSystem to simulate various file system states
• Test exception scenarios like insufficient file permissions, file not found
• Design testable file processing service architecture

Core Principles

1. Fundamental Problem of File System Dependencies

Traditional code directly using System.IO static classes is difficult to test, reasons include:

• Speed Issues: Actual disk IO is 10-100x slower than memory operations
• Environment Dependency: Test results affected by file system state, permissions, paths
• Side Effects: Tests leave traces on disk, affecting other tests
• Concurrency Issues: Multiple tests operating on same file create race conditions
• Error Simulation Difficulty: Difficult to simulate insufficient permissions, insufficient disk space, etc.

2. System.IO.Abstractions Solution

This is a package that wraps System.IO static classes into interfaces, supporting dependency injection and test doubles.

Core Interface Architecture:

public interface IFileSystem
{
    IFile File { get; }
    IDirectory Directory { get; }
    IFileInfo FileInfo { get; }
    IDirectoryInfo DirectoryInfo { get; }
    IPath Path { get; }
    IDriveInfo DriveInfo { get; }
}
```text

**Required NuGet Packages**:

```xml
<!-- Production environment -->
<PackageReference Include="System.IO.Abstractions" Version="21.*" />

<!-- Test project -->
<PackageReference Include="System.IO.Abstractions.TestingHelpers" Version="21.*" />
```text

### 3. Refactoring Steps

**Step 1**: Change code directly using static classes to depend on `IFileSystem`

```csharp
// ❌ Before refactoring (not testable)
public class ConfigService
{
    public string LoadConfig(string path)
    {
        return File.ReadAllText(path);
    }
}

// ✅ After refactoring (testable)
public class ConfigService
{
    private readonly IFileSystem _fileSystem;

    public ConfigService(IFileSystem fileSystem)
    {
        _fileSystem = fileSystem;
    }

    public string LoadConfig(string path)
    {
        return _fileSystem.File.ReadAllText(path);
    }
}
```text

**Step **: Register real implementation  DI container

```csharp

services.AddSingleton<IFileSystem, FileSystem>();
services.AddScoped<ConfigService>();
```text

**Step **: Use MockFileSystem  tests

```csharp
 mockFs =  MockFileSystem( Dictionary<, MockFileData>
{
    [] =  MockFileData()
});
 service =  ConfigService(mockFs);
```text





```csharp
[]

{
    
     mockFileSystem =  MockFileSystem( Dictionary<, MockFileData>
    {
        [] =  MockFileData(),
        [] =  MockFileData(),
        [] =  MockDirectoryData()  
    });

     service =  ConfigService(mockFileSystem);

    
     result =  service.LoadConfigAsync();

    
    result.Should().Contain();
}
```text



```csharp
[]

{
    
     mockFileSystem =  MockFileSystem();
     service =  ConfigService(mockFileSystem);

    
     service.SaveConfigAsync(, );

    
    mockFileSystem.File.Exists().Should().BeTrue();
     content =  mockFileSystem.File.ReadAllTextAsync();
    content.Should().Contain();
}
```text



```csharp
[]

{
    
     mockFileSystem =  MockFileSystem( Dictionary<, MockFileData>
    {
        [] =  MockFileData()
    });
     service =  FileManagerService(mockFileSystem);

    
    service.CopyFileToDirectory(, );

    
    mockFileSystem.Directory.Exists().Should().BeTrue();
    mockFileSystem.File.Exists().Should().BeTrue();
}
```text



When needing to simulate specific exceptions, MockFileSystem has limited support, can use NSubstitute:

```csharp
[]

{
    
     mockFileSystem = Substitute.For<IFileSystem>();
     mockFile = Substitute.For<IFile>();

    mockFileSystem.File.Returns(mockFile);
    mockFile.Exists().Returns();
    mockFile.ReadAllText()
            .Throws( UnauthorizedAccessException());

     service =  FilePermissionService(mockFileSystem);

    
     result = service.TryReadFile(,   content);

    
    result.Should().BeFalse();
    content.Should().BeNull();
}
```text





```csharp
[]

{
    
     content = ;
     mockFileSystem =  MockFileSystem( Dictionary<, MockFileData>
    {
        [] =  MockFileData(content)
    });

     processor =  StreamProcessorService(mockFileSystem);

    
     result =  processor.CountLinesAsync();

    
    result.Should().Be();
}
```text



```csharp
[]

{
    
     content = ;
     mockFileSystem =  MockFileSystem( Dictionary<, MockFileData>
    {
        [] =  MockFileData(content)
    });

     service =  FileManagerService(mockFileSystem);

    
     info = service.GetFileInfo();

    
    info.Should().NotBeNull();
    info!.Name.Should().Be();
    info.Size.Should().Be(content.Length);
}
```text



```csharp
[]

{
    
     mockFileSystem =  MockFileSystem( Dictionary<, MockFileData>
    {
        [] =  MockFileData()
    });

     service =  FileManagerService(mockFileSystem);

    
     backupPath = service.BackupFile();

    
    backupPath.Should().StartWith();
    backupPath.Should().EndWith();
    mockFileSystem.File.Exists(backupPath).Should().BeTrue();
}
```text





 **Use Path.Combine to handle paths**:

   ```csharp
    path = _fileSystem.Path.Combine(, );
```text

 **Defensively check  existence**:

   ```
   {
        defaultValue;
   }
```text

 **Auto-create necessary directories**:

   ```csharp
    dir = _fileSystem.Path.GetDirectoryName(filePath);
    (!.IsNullOrEmpty(dir) && !_fileSystem.Directory.Exists(dir))
   {
       _fileSystem.Directory.CreateDirectory(dir);
   }
```text

 **Properly handle various IO exceptions**:

   ```csharp
   
   {
         _fileSystem.File.ReadAllTextAsync(path);
   }
    (UnauthorizedAccessException) {  }
    (IOException) {  }
    (DirectoryNotFoundException) {  }
```text

 **Use independent MockFileSystem  each test**:

   ```csharp
     
   {
       []
       
       {
            mockFs =  MockFileSystem(); 
       }

       []
       
       {
            mockFs =  MockFileSystem(); 
       }
   }
```text



 **Hardcode path separators**:

   ```csharp
   
    path = ;  
    path = ;   

   
    path = _fileSystem.Path.Combine(, );
```text

 **Use real  system  unit tests**:

   ```csharp
   
    realFs =  FileSystem();

   
    mockFs =  MockFileSystem();
```text

 **Ignore exception handling**:

   ```csharp
   
    content = _fileSystem.File.ReadAllText(path);

   
    (_fileSystem.File.Exists(path))
   {
        {  _fileSystem.File.ReadAllText(path); }
        (IOException) {  defaultValue; }
   }
```text





- **Speed**: x faster than real  operations
- **Reliability**: Not affected  disk state
- **Isolation**: Complete isolation between tests
- **Error Simulation**: Can precisely simulate various exception scenarios



- Only create files necessary  testing
- Avoid simulating oversized files  tests
- For large  processing logic, use moderately sized test data:

```csharp

 testContent = .Join(,
    Enumerable.Range(, ).Select(i => ));
mockFileSystem.AddFile(,  MockFileData(testContent));
```text





See `templates/configmanager-service.cs`  complete implementation, including:

- Configuration  load  save
- JSON serialization  deserialization
- Auto-create directories
- Configuration  backup functionality



See `templates/filemanager-service.cs`  implementation, including:

- File copy  backup
- Directory operations
- File information query
- Error handling patterns





This skill content  distilled  the  article series:

- **Day  - File  IO Testing: Using System.IO.Abstractions to Simulate File System**
  - Article: https:
  - Sample Code: https:



- [System.IO.Abstractions GitHub](https:
- [System.IO.Abstractions NuGet](https:
- [TestingHelpers NuGet](https:



- `nsubstitute-mocking` - Test doubles  mocking
- `unit-test-fundamentals` - Unit testing basics