dotnet-testing-filesystem-testing-abstractions

name	dotnet-testing-filesystem-testing-abstractions
category	testing
subcategory	specialized
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
targets	["*"]
license	MIT
metadata	{"author":"Kevin Tseng","version":"1.0.0","tags":".NET, testing, IFileSystem, MockFileSystem, file testing","related_skills":"nsubstitute-mocking, unit-test-fundamentals, datetime-testing-timeprovider"}
claudecode	{}
opencode	{}
codexcli	{"short-description":".NET skill guidance for dotnet-testing-filesystem-testing-abstractions"}
copilot	{}
geminicli	{}
antigravity	{}

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



**Step **: Change code directly   classes to depend  `IFileSystem`

```csharp

  
{
    
    {
         File.ReadAllText(path);
    }
}


  
{
      IFileSystem _fileSystem;

    
    {
        _fileSystem = fileSystem;
    }

    
    {
         _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