fix: initialize drives with root directory (#847)

This PR fixes a bug where drives in the mock file system were not properly initialized with their root directory containers, causing issues when trying to enumerate files on newly created drives. The fix ensures that when a drive is created, its corresponding root directory container is also created in the storage system.

### Key changes:
- Initializes the main drive with a root directory container during storage construction
- Updates the `GetOrAddDrive` method to create root directory containers for new drives
- Add tests to verify that drives can be enumerated without errors

Author: vbreuss

Source/Testably.Abstractions.Testing/MockFileSystem.cs

@@ -223,7 +223,7 @@ public MockFileSystem WithDrive(string? drive,
 		Action<IStorageDrive>? driveCallback = null)
 	{
 		IStorageDrive driveInfoMock =
-			drive == null
+			drive == null || string.Equals(drive, Execute.Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal)
 				? Storage.MainDrive
 				: Storage.GetOrAddDrive(drive);
 		driveCallback?.Invoke(driveInfoMock);

Source/Testably.Abstractions.Testing/Storage/InMemoryStorage.cs

@@ -36,6 +36,10 @@ public InMemoryStorage(MockFileSystem fileSystem)
 		CurrentDirectory = string.Empty.PrefixRoot(_fileSystem);
 		DriveInfoMock mainDrive = DriveInfoMock.New(CurrentDirectory, _fileSystem);
 		_drives.TryAdd(mainDrive.GetName(), mainDrive);
+		IStorageLocation rootLocation =
+			InMemoryLocation.New(_fileSystem, mainDrive, mainDrive.GetName());
+		_containers.TryAdd(rootLocation, InMemoryContainer.NewDirectory(rootLocation, _fileSystem));
+
 		MainDrive = mainDrive;
 	}
 
@@ -189,7 +193,7 @@ public IEnumerable<IStorageLocation> EnumerateLocations(
 		EnumerationOptions? enumerationOptions = null)
 	{
 		ValidateExpression(searchPattern);
-		if (!_containers.TryGetValue(location, out var parentContainer))
+		if (!_containers.TryGetValue(location, out IStorageContainer? parentContainer))
 		{
 			throw ExceptionFactory.DirectoryNotFound(location.FullPath);
 		}
@@ -227,11 +231,11 @@ public IEnumerable<IStorageLocation> EnumerateLocations(
 			}
 
 			if (enumerationOptions.ReturnSpecialDirectories &&
-				type == FileSystemTypes.Directory)
+			    type == FileSystemTypes.Directory)
 			{
 				IStorageDrive? drive = _fileSystem.Storage.GetDrive(fullPath);
 				if (drive == null &&
-					!fullPath.IsUncPath(_fileSystem))
+				    !fullPath.IsUncPath(_fileSystem))
 				{
 					drive = _fileSystem.Storage.MainDrive;
 				}
@@ -255,11 +259,12 @@ public IEnumerable<IStorageLocation> EnumerateLocations(
 
 			foreach (KeyValuePair<IStorageLocation, IStorageContainer> item in _containers
 				.Where(x => x.Key.FullPath.StartsWith(fullPath,
-								_fileSystem.Execute.StringComparisonMode) &&
-							!x.Key.Equals(location)))
+					            _fileSystem.Execute.StringComparisonMode) &&
+				            !x.Key.Equals(location)))
 			{
 				if (type.HasFlag(item.Value.Type) &&
-					IncludeItemInEnumeration(item, fullPathWithoutTrailingSlash, enumerationOptions))
+				    IncludeItemInEnumeration(item, fullPathWithoutTrailingSlash,
+					    enumerationOptions))
 				{
 					string? itemPath = item.Key.FullPath;
 					if (itemPath.EndsWith(_fileSystem.Path.DirectorySeparatorChar))
@@ -269,14 +274,14 @@ public IEnumerable<IStorageLocation> EnumerateLocations(
 
 					string name = _fileSystem.Execute.Path.GetFileName(itemPath);
 					if (EnumerationOptionsHelper.MatchesPattern(
-							_fileSystem.Execute,
-							enumerationOptions,
-							name,
-							searchPattern) ||
-						(_fileSystem.Execute.IsNetFramework &&
-						 SearchPatternMatchesFileExtensionOnNetFramework(
-							 searchPattern,
-							 _fileSystem.Execute.Path.GetExtension(name))))
+						    _fileSystem.Execute,
+						    enumerationOptions,
+						    name,
+						    searchPattern) ||
+					    (_fileSystem.Execute.IsNetFramework &&
+					     SearchPatternMatchesFileExtensionOnNetFramework(
+						     searchPattern,
+						     _fileSystem.Execute.Path.GetExtension(name))))
 					{
 						yield return item.Key;
 					}
@@ -346,8 +351,19 @@ public IEnumerable<IStorageDrive> GetDrives()
 			drive = _fileSystem.Storage.MainDrive;
 		}
 
-		return InMemoryLocation.New(_fileSystem, drive, path.GetFullPathOrWhiteSpace(_fileSystem),
-			path);
+		string fullPath;
+		if (path.IsUncPath(_fileSystem) &&
+			_fileSystem.Execute is { IsNetFramework: true } or {IsWindows: false } &&
+			path.LastIndexOf(_fileSystem.Path.DirectorySeparatorChar) <= 2)
+		{
+			fullPath = path;
+		}
+		else
+		{
+			fullPath = path.GetFullPathOrWhiteSpace(_fileSystem);
+		}
+
+		return InMemoryLocation.New(_fileSystem, drive, fullPath, path);
 	}
 
 	/// <inheritdoc cref="IStorage.GetOrAddDrive(string)" />
@@ -360,7 +376,14 @@ public IEnumerable<IStorageDrive> GetDrives()
 		}
 
 		DriveInfoMock drive = DriveInfoMock.New(driveName, _fileSystem);
-		return _drives.GetOrAdd(drive.GetName(), _ => drive);
+		return _drives.GetOrAdd(drive.GetName(), _ =>
+		{
+			IStorageLocation rootLocation =
+				InMemoryLocation.New(_fileSystem, drive, drive.GetName());
+			_containers.TryAdd(rootLocation,
+				InMemoryContainer.NewDirectory(rootLocation, _fileSystem));
+			return drive;
+		});
 	}
 
 	/// <inheritdoc cref="IStorage.GetOrCreateContainer" />

Tests/Testably.Abstractions.Testing.Tests/MockFileSystemTests.cs

@@ -1,4 +1,5 @@
-using System.IO;
+using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using Testably.Abstractions.Helpers;
 using Testably.Abstractions.Testing.FileSystem;
@@ -115,13 +116,14 @@ public async Task ToString_ShouldContainStorageInformation()
 
 		string result = sut.ToString();
 
-		await That(result).Contains("directories: 0, files: 1");
+		await That(result).Contains("directories: 1, files: 1");
 	}
 
 	[Theory]
 	[AutoData]
-	public async Task WithAccessControl_Denied_CreateDirectoryShouldThrowUnauthorizedAccessException(
-		string path)
+	public async Task
+		WithAccessControl_Denied_CreateDirectoryShouldThrowUnauthorizedAccessException(
+			string path)
 	{
 		Skip.If(!Test.RunsOnWindows);
 
@@ -241,6 +243,20 @@ await That(drives).HasSingle().Matching(d
 			=> string.Equals(d.Name, expectedDriveName, StringComparison.Ordinal));
 	}
 
+	[Fact]
+	public async Task WithDrive_ShouldInitializeDrivesWithRootDirectory()
+	{
+		Skip.IfNot(Test.RunsOnWindows, "Linux does not support different drives.");
+
+		MockFileSystem sut = new MockFileSystem().WithDrive("V");
+		List<IFileSystemInfo> fileSystemInfos = sut.DriveInfo.GetDrives()
+			.SelectMany(drive => drive.RootDirectory
+				.EnumerateFileSystemInfos("*", SearchOption.AllDirectories))
+			.ToList();
+
+		await That(fileSystemInfos).HasCount(0);
+	}
+
 	[Theory]
 	[AutoData]
 	public async Task WithDrive_WithCallback_ShouldUpdateDrive(long totalSize)
@@ -305,6 +321,22 @@ public async Task WithUncDrive_ShouldCreateUncDrive(
 		await That(result).IsEqualTo(contents);
 	}
 
+	[Fact]
+	public async Task WithUncDrive_ShouldInitializeDrivesWithRootDirectory()
+	{
+		MockFileSystem sut = new();
+		string uncPrefix = new(sut.Path.DirectorySeparatorChar, 2);
+		string uncDrive = $"{uncPrefix}UNC-Path";
+		sut.WithUncDrive("UNC-Path");
+		IDriveInfo drive = sut.DriveInfo.New(uncDrive);
+
+		List<IFileSystemInfo> fileSystemInfos = drive.RootDirectory
+			.EnumerateFileSystemInfos("*", SearchOption.AllDirectories)
+			.ToList();
+
+		await That(fileSystemInfos).HasCount(0);
+	}
+
 	[Theory]
 	[AutoData]
 	public async Task WithUncDrive_ShouldNotBeIncludedInGetDrives(

Tests/Testably.Abstractions.Testing.Tests/Storage/InMemoryContainerTests.cs

@@ -303,7 +303,8 @@ public async Task ToString_File_ShouldIncludePathAndFileSize(byte[] bytes)
 		MockFileSystem fileSystem = new();
 		string expectedPath = fileSystem.Path.GetFullPath("foo.txt");
 		fileSystem.File.WriteAllBytes(expectedPath, bytes);
-		IStorageContainer sut = fileSystem.StorageContainers.Single();
+		IStorageContainer sut = fileSystem.StorageContainers
+			.Single(x => x.Type == FileSystemTypes.File);
 
 		string? result = sut.ToString();