private void When_setting_path_to_invalid_drive_it_must_fail()
{
// Arrange
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher())
{
// Act
// ReSharper disable once AccessToDisposedClosure
Action action = () => watcher.Path = "_:";
// Assert
action.Should().ThrowExactly <ArgumentException>().WithMessage("The directory name _: is invalid.");
}
}
private void When_filtering_directory_with_null_pattern_it_must_raise_events()
{
// Arrange
const string directoryToWatch = @"c:\some";
string pathToFileToUpdate1 = Path.Combine(directoryToWatch, "MatchingFile.txt");
string pathToFileToUpdate2 = Path.Combine(directoryToWatch, "MatchingFile");
string pathToDirectoryToUpdate1 = Path.Combine(directoryToWatch, "MatchingFolder.txt");
string pathToDirectoryToUpdate2 = Path.Combine(directoryToWatch, "MatchingFolder");
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingEmptyFile(pathToFileToUpdate1)
.IncludingEmptyFile(pathToFileToUpdate2)
.IncludingDirectory(pathToDirectoryToUpdate1)
.IncludingDirectory(pathToDirectoryToUpdate2)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = TestNotifyFilters.All;
watcher.IncludeSubdirectories = true;
// ReSharper disable once AssignNullToNotNullAttribute
watcher.Filter = null;
using (var listener = new FileSystemWatcherEventListener(watcher))
{
// Act
fileSystem.File.SetAttributes(pathToFileToUpdate1, FileAttributes.Hidden);
fileSystem.File.SetAttributes(pathToFileToUpdate2, FileAttributes.Hidden);
fileSystem.File.SetAttributes(pathToDirectoryToUpdate1, FileAttributes.Hidden);
fileSystem.File.SetAttributes(pathToDirectoryToUpdate2, FileAttributes.Hidden);
watcher.FinishAndWaitForFlushed(MaxTestDurationInMilliseconds);
// Assert
watcher.Filter.Should().Be("*.*");
string text = string.Join(Environment.NewLine, listener.GetEventsCollectedAsText());
text.Should().Be(@"
* MatchingFile.txt
* MatchingFile
* MatchingFolder.txt
* MatchingFolder
".TrimLines());
}
}
}
private void When_moving_readonly_directory_tree_to_parent_directory_it_must_raise_events(NotifyFilters filters,
[NotNull] string expectedText)
{
// Arrange
const string directoryToWatch = @"c:\some";
const string containerDirectoryName = "Container";
const string sourceDirectoryName = @"MoveSource\SubFolderA";
const string destinationDirectoryName = "MovedSubFolderA";
string pathToContainerDirectory = Path.Combine(directoryToWatch, containerDirectoryName);
string pathToSourceDirectory = Path.Combine(pathToContainerDirectory, sourceDirectoryName);
string pathToDestinationDirectory = Path.Combine(pathToContainerDirectory, destinationDirectoryName);
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingDirectory(pathToContainerDirectory, FileAttributes.ReadOnly)
.IncludingDirectory(pathToSourceDirectory, FileAttributes.ReadOnly)
.IncludingDirectory(Path.Combine(pathToSourceDirectory, @"FolderA"), FileAttributes.ReadOnly)
.IncludingDirectory(Path.Combine(pathToSourceDirectory, @"FolderA\SubFolderA"), FileAttributes.ReadOnly)
.IncludingEmptyFile(Path.Combine(pathToSourceDirectory, @"FolderA\FileInA.txt"), FileAttributes.ReadOnly)
.IncludingDirectory(Path.Combine(pathToSourceDirectory, @"FolderB"), FileAttributes.ReadOnly)
.IncludingEmptyFile(Path.Combine(pathToSourceDirectory, @"FolderB\FileInB.txt"), FileAttributes.ReadOnly)
.IncludingDirectory(Path.Combine(pathToSourceDirectory, @"FolderC"), FileAttributes.ReadOnly)
.IncludingDirectory(Path.Combine(pathToSourceDirectory, @"FolderC\SubFolderC"), FileAttributes.ReadOnly)
.IncludingEmptyFile(Path.Combine(pathToSourceDirectory, @"FolderC\SubFolderC\FileInSubFolderC.txt"),
FileAttributes.ReadOnly)
.IncludingEmptyFile(Path.Combine(pathToSourceDirectory, @"FileInRoot2.txt"), FileAttributes.ReadOnly)
.IncludingEmptyFile(Path.Combine(pathToSourceDirectory, @"FileInRoot1.txt"), FileAttributes.ReadOnly)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = filters;
watcher.IncludeSubdirectories = true;
using (var listener = new FileSystemWatcherEventListener(watcher))
{
// Act
fileSystem.Directory.Move(pathToSourceDirectory, pathToDestinationDirectory);
watcher.FinishAndWaitForFlushed(MaxTestDurationInMilliseconds);
// Assert
string text = string.Join(Environment.NewLine, listener.GetEventsCollectedAsText());
text.Should().Be(expectedText);
}
}
}
private void When_setting_InternalBufferSize_to_high_value_it_must_store_value()
{
// Arrange
const int oneMegabyte = 1024 * 1024;
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher())
{
// Act
watcher.InternalBufferSize = oneMegabyte;
// Assert
watcher.InternalBufferSize.Should().Be(oneMegabyte);
}
}
private void When_filtering_directory_with_name_pattern_in_rename_it_must_raise_events()
{
// Arrange
const string directoryToWatch = @"c:\some";
string sourcePathToFile1 = Path.Combine(directoryToWatch, "SourceHit1.txt");
string targetPathToFile1 = Path.Combine(directoryToWatch, "TargetHit1.txt");
string sourcePathToFile2 = Path.Combine(directoryToWatch, "SourceHit2.txt");
string targetPathToFile2 = Path.Combine(directoryToWatch, "TargetMiss2.txt");
string sourcePathToFile3 = Path.Combine(directoryToWatch, "SourceMiss3.txt");
string targetPathToFile3 = Path.Combine(directoryToWatch, "TargetHit3.txt");
string sourcePathToFile4 = Path.Combine(directoryToWatch, "SourceMiss4.txt");
string targetPathToFile4 = Path.Combine(directoryToWatch, "TargetMiss4.txt");
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingEmptyFile(sourcePathToFile1)
.IncludingEmptyFile(sourcePathToFile2)
.IncludingEmptyFile(sourcePathToFile3)
.IncludingEmptyFile(sourcePathToFile4)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = TestNotifyFilters.All;
watcher.IncludeSubdirectories = true;
watcher.Filter = "*Hit*.*";
using (var listener = new FileSystemWatcherEventListener(watcher))
{
// Act
fileSystem.File.Move(sourcePathToFile1, targetPathToFile1);
fileSystem.File.Move(sourcePathToFile2, targetPathToFile2);
fileSystem.File.Move(sourcePathToFile3, targetPathToFile3);
fileSystem.File.Move(sourcePathToFile4, targetPathToFile4);
watcher.FinishAndWaitForFlushed(MaxTestDurationInMilliseconds);
// Assert
string text = string.Join(Environment.NewLine, listener.GetEventsCollectedAsText());
text.Should().Be(@"
> SourceHit1.txt => TargetHit1.txt
> SourceHit2.txt => TargetMiss2.txt
> SourceMiss3.txt => TargetHit3.txt
".TrimLines());
}
}
}
private void When_parent_of_watcher_directory_is_deleted_it_must_raise_error_event_and_terminate()
{
// Arrange
const string directoryToWatch = @"c:\parent\watchFolder";
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingDirectory(directoryToWatch)
.Build();
var lockObject = new object();
Exception lastError = null;
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.Error += (sender, args) =>
{
lock (lockObject)
{
lastError = args.GetException();
}
};
using (var listener = new FileSystemWatcherEventListener(watcher))
{
// Act
fileSystem.Directory.Delete(@"c:\parent", true);
Thread.Sleep(SleepTimeToEnsureOperationHasArrivedAtWatcherConsumerLoop);
// Assert
watcher.EnableRaisingEvents.Should().BeFalse();
string text = string.Join(Environment.NewLine, listener.GetEventsCollectedAsText());
text.Should().Be(@"
! Access is denied
".TrimLines());
lock (lockObject)
{
lastError.Should().NotBeNull();
lastError.Should().BeOfType <Win32Exception>().Subject.NativeErrorCode.Should().Be(5);
lastError.Message.Should().Be("Access is denied");
}
}
}
}
private void When_waiting_for_disposed_watcher_it_must_fail()
{
// Arrange
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.Build();
FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher();
watcher.Dispose();
// Act
Action action = () => watcher.WaitForChanged(WatcherChangeTypes.All, MaxTestDurationInMilliseconds);
// Assert
action.Should().ThrowExactly <ObjectDisposedException>().WithMessage("Cannot access a disposed object.*")
.And.ObjectName.Should().Be("FileSystemWatcher");
}
private void When_starting_disposed_watcher_it_must_fail()
{
// Arrange
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.Build();
FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher();
watcher.Dispose();
// Act
Action action = () => watcher.EnableRaisingEvents = true;
// Assert
action.Should().ThrowExactly <ObjectDisposedException>().WithMessage("Cannot access a disposed object.*")
.And.ObjectName.Should().Be("FileSystemWatcher");
}
protected static void BlockUntilChangeProcessed([NotNull] FakeFileSystemWatcher watcher, [NotNull] Action diskOperation)
{
using (var operationWaitHandle = new ManualResetEventSlim(false))
{
// ReSharper disable AccessToDisposedClosure
watcher.Deleted += (sender, args) => operationWaitHandle.Set();
watcher.Created += (sender, args) => operationWaitHandle.Set();
watcher.Changed += (sender, args) => operationWaitHandle.Set();
watcher.Renamed += (sender, args) => operationWaitHandle.Set();
// ReSharper restore AccessToDisposedClosure
diskOperation();
bool waitSucceeded = operationWaitHandle.Wait(MaxTestDurationInMilliseconds);
waitSucceeded.Should().BeTrue();
}
}
private static void BlockUntilStarted([NotNull] FakeFileSystemWatcher watcher)
{
DateTime startTime = DateTime.UtcNow;
DateTime expirationTime = startTime.AddMilliseconds(MaxTestDurationInMilliseconds);
while (DateTime.UtcNow < expirationTime)
{
if (watcher.EnableRaisingEvents)
{
return;
}
Thread.Sleep(50);
}
throw new TimeoutException("Test timed out.");
}
private void When_setting_path_to_missing_network_share_it_must_fail()
{
// Arrange
const string path = @"\\server\share";
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher())
{
// Act
// ReSharper disable once AccessToDisposedClosure
Action action = () => watcher.Path = path;
// Assert
action.Should().ThrowExactly <ArgumentException>().WithMessage(@"The directory name \\server\share is invalid.");
}
}
private void When_waiting_for_file_change_multiple_times_it_must_succeed()
{
// Arrange
const string directoryToWatch = @"c:\some";
const string fileNameToUpdate = "file.txt";
string pathToFileToUpdate = Path.Combine(directoryToWatch, fileNameToUpdate);
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingEmptyFile(pathToFileToUpdate)
.Build();
// ReSharper disable once ConvertToLocalFunction
Action <DateTime> updateCreationTimeAction = creationTimeUtc =>
{
Thread.Sleep(SleepTimeToEnsureWaiterInitializationHasCompleted);
fileSystem.File.SetCreationTimeUtc(pathToFileToUpdate, creationTimeUtc);
};
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = NotifyFilters.CreationTime;
Task.Run(() => updateCreationTimeAction(1.January(2000)));
// Act
WaitForChangedResult result1 = watcher.WaitForChanged(WatcherChangeTypes.Changed, MaxTestDurationInMilliseconds);
Task.Run(() => updateCreationTimeAction(2.January(2000)));
WaitForChangedResult result2 = watcher.WaitForChanged(WatcherChangeTypes.Changed, MaxTestDurationInMilliseconds);
// Assert
result1.TimedOut.Should().BeFalse();
result1.ChangeType.Should().Be(WatcherChangeTypes.Changed);
result1.Name.Should().Be(fileNameToUpdate);
result1.OldName.Should().BeNull();
result2.TimedOut.Should().BeFalse();
result2.ChangeType.Should().Be(WatcherChangeTypes.Changed);
result2.Name.Should().Be(fileNameToUpdate);
result2.OldName.Should().BeNull();
}
}
private void When_setting_path_to_existing_local_file_it_must_fail()
{
// Arrange
const string path = @"c:\some\file.txt";
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingEmptyFile(path)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher())
{
// Act
// ReSharper disable once AccessToDisposedClosure
Action action = () => watcher.Path = path;
// Assert
action.Should().ThrowExactly <ArgumentException>().WithMessage(@"The directory name c:\some\file.txt is invalid.");
}
}
private void When_setting_path_to_empty_string_it_must_fail()
{
// Arrange
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher())
{
watcher.Path = string.Empty;
// Act
// ReSharper disable once AccessToDisposedClosure
Action action = () => watcher.EnableRaisingEvents = true;
// Assert
watcher.Path.Should().Be(string.Empty);
action.Should().ThrowExactly <FileNotFoundException>().WithMessage("Error reading the directory.");
}
}
private void When_setting_path_on_disposed_watcher_it_must_succeed()
{
// Arrange
const string directoryToWatch = @"c:\some";
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingDirectory(directoryToWatch)
.Build();
FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher();
watcher.Dispose();
// Act
watcher.Path = directoryToWatch;
// Assert
watcher.Path.Should().Be(directoryToWatch);
}
private void When_waiting_for_file_rename_while_files_are_renamed_it_must_succeed()
{
// Arrange
const string directoryToWatch = @"c:\some";
const string sourceFileName1 = "source1.txt";
const string targetFileName1 = "target1.txt";
const string sourceFileName2 = "source2.txt";
const string targetFileName2 = "target2.txt";
string pathToSourceFile1 = Path.Combine(directoryToWatch, sourceFileName1);
string pathToTargetFile1 = Path.Combine(directoryToWatch, targetFileName1);
string pathToSourceFile2 = Path.Combine(directoryToWatch, sourceFileName2);
string pathToTargetFile2 = Path.Combine(directoryToWatch, targetFileName2);
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingEmptyFile(pathToSourceFile1)
.IncludingEmptyFile(pathToSourceFile2)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = NotifyFilters.FileName;
Task.Run(() =>
{
// ReSharper disable once AccessToDisposedClosure
BlockUntilStarted(watcher);
fileSystem.File.Move(pathToSourceFile1, pathToTargetFile1);
fileSystem.File.Move(pathToSourceFile2, pathToTargetFile2);
});
// Act
WaitForChangedResult result = watcher.WaitForChanged(WatcherChangeTypes.Renamed, MaxTestDurationInMilliseconds);
// Assert
result.TimedOut.Should().BeFalse();
result.ChangeType.Should().Be(WatcherChangeTypes.Renamed);
result.Name.Should().Be(targetFileName1);
result.OldName.Should().Be(sourceFileName1);
}
}
private void When_waiting_for_changes_with_negative_timeout_it_must_fail()
{
// Arrange
const string directoryToWatch = @"c:\some";
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingDirectory(directoryToWatch)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
// Act
// ReSharper disable once AccessToDisposedClosure
Action action = () => watcher.WaitForChanged(WatcherChangeTypes.All, -5);
// Assert
action.Should().ThrowExactly <ArgumentOutOfRangeException>().WithMessage(
"Specified argument was out of the range of valid values.*");
}
}
private void When_waiting_for_change_it_must_apply_filters()
{
// Arrange
const string directoryToWatch = @"c:\some";
string pathToMismatchingFile = Path.Combine(directoryToWatch, "OtherName.txt");
string pathToMismatchingDirectory = Path.Combine(directoryToWatch, "SomeFolderIgnored");
string pathToMatchingFile = Path.Combine(directoryToWatch, "Subfolder", "SomeFile.txt");
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingEmptyFile(pathToMismatchingFile)
.IncludingDirectory(Path.Combine(directoryToWatch, "Subfolder"))
.IncludingEmptyFile(pathToMatchingFile)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size;
watcher.IncludeSubdirectories = true;
watcher.Filter = "Some*";
Task.Run(() =>
{
// ReSharper disable once AccessToDisposedClosure
BlockUntilStarted(watcher);
fileSystem.Directory.CreateDirectory(pathToMismatchingDirectory);
fileSystem.File.AppendAllText(pathToMismatchingFile, "IgnoreMe");
fileSystem.File.AppendAllText(pathToMatchingFile, "NotifyForMe");
});
// Act
WaitForChangedResult result = watcher.WaitForChanged(WatcherChangeTypes.All, MaxTestDurationInMilliseconds);
// Assert
result.TimedOut.Should().BeFalse();
result.ChangeType.Should().Be(WatcherChangeTypes.Changed);
result.Name.Should().Be(@"Subfolder\SomeFile.txt");
result.OldName.Should().BeNull();
}
}
private void When_filtering_directory_tree_with_asterisk_dot_pattern_it_must_not_raise_events()
{
// Arrange
const string directoryToWatch = @"c:\some";
string pathToFileToUpdate1 = Path.Combine(directoryToWatch, "RootFile");
string pathToFileToUpdate2 = Path.Combine(directoryToWatch, "SubFolder", "SubFile");
string pathToDirectoryToUpdate1 = Path.Combine(directoryToWatch, "RootFolder");
string pathToDirectoryToUpdate2 = Path.Combine(directoryToWatch, "SubFolder", "Nested");
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingEmptyFile(pathToFileToUpdate1)
.IncludingEmptyFile(pathToFileToUpdate2)
.IncludingDirectory(pathToDirectoryToUpdate1)
.IncludingDirectory(pathToDirectoryToUpdate2)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = TestNotifyFilters.All;
watcher.IncludeSubdirectories = true;
watcher.Filter = "*.";
using (var listener = new FileSystemWatcherEventListener(watcher))
{
// Act
fileSystem.File.SetAttributes(pathToFileToUpdate1, FileAttributes.Hidden);
fileSystem.File.SetAttributes(pathToFileToUpdate2, FileAttributes.Hidden);
fileSystem.File.SetAttributes(pathToDirectoryToUpdate1, FileAttributes.Hidden);
fileSystem.File.SetAttributes(pathToDirectoryToUpdate2, FileAttributes.Hidden);
watcher.FinishAndWaitForFlushed(MaxTestDurationInMilliseconds);
// Assert
watcher.Filter.Should().Be("*.");
string text = string.Join(Environment.NewLine, listener.GetEventsCollectedAsText());
text.Should().BeEmpty();
}
}
}
private void When_starting_watcher_for_removed_directory_it_must_fail()
{
// Arrange
const string directoryToWatch = @"c:\some";
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingDirectory(directoryToWatch)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
fileSystem.Directory.Delete(directoryToWatch);
// Act
// ReSharper disable once AccessToDisposedClosure
Action action = () => watcher.EnableRaisingEvents = true;
// Assert
action.Should().ThrowExactly <FileNotFoundException>().WithMessage(@"Error reading the c:\some directory.");
}
}
private void When_waiting_for_changes_while_timeout_expires_it_must_succeed()
{
// Arrange
const string directoryToWatch = @"c:\some";
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingDirectory(directoryToWatch)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
// Act
WaitForChangedResult result = watcher.WaitForChanged(WatcherChangeTypes.All, 1000);
// Assert
result.TimedOut.Should().BeTrue();
result.ChangeType.Should().Be(0);
result.Name.Should().BeNull();
result.OldName.Should().BeNull();
}
}
private void When_changing_filter_on_running_watcher_it_must_not_restart()
{
// Arrange
const string directoryToWatch = @"c:\some";
string pathToFileToUpdate1 = Path.Combine(directoryToWatch, "file1.txt");
string pathToFileToUpdate2 = Path.Combine(directoryToWatch, "file2.txt");
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingEmptyFile(pathToFileToUpdate1)
.IncludingEmptyFile(pathToFileToUpdate2)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = TestNotifyFilters.All;
using (var listener = new FileSystemWatcherEventListener(watcher))
{
BlockUntilChangeProcessed(watcher, () =>
{
fileSystem.File.SetAttributes(pathToFileToUpdate1, FileAttributes.Hidden);
});
// Act
watcher.Filter = "*.txt";
fileSystem.File.SetAttributes(pathToFileToUpdate2, FileAttributes.Hidden);
watcher.FinishAndWaitForFlushed(MaxTestDurationInMilliseconds);
// Assert
string text = string.Join(Environment.NewLine, listener.GetEventsCollectedAsText());
text.Should().Be(@"
* file1.txt
* file2.txt
".TrimLines());
}
}
}
private void When_disposing_unstarted_watcher_multiple_times_it_must_succeed()
{
// Arrange
const string directoryToWatch = @"c:\some";
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingDirectory(directoryToWatch)
.Build();
// Act
FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch);
// Act
Action action = () =>
{
watcher.Dispose();
watcher.Dispose();
};
// Assert
action.Should().NotThrow();
}
private void When_async_appending_to_stream_it_must_raise_events(NotifyFilters filters, [NotNull] string expectedText)
{
// Arrange
const string directoryToWatch = @"c:\some";
const string containerDirectoryName = "Container";
const string fileNameToWrite = "file.txt";
string pathToFileToWrite = Path.Combine(directoryToWatch, containerDirectoryName, fileNameToWrite);
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingBinaryFile(pathToFileToWrite, BufferFactory.Create(1024))
.Build();
var buffer = new byte[512];
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = filters;
watcher.IncludeSubdirectories = true;
using (var listener = new FileSystemWatcherEventListener(watcher))
{
using (IFileStream stream = fileSystem.File.Open(pathToFileToWrite, FileMode.Open, FileAccess.ReadWrite))
{
stream.Seek(0, SeekOrigin.End);
// Act
Task task = stream.WriteAsync(buffer, 0, buffer.Length);
task.Wait();
}
watcher.FinishAndWaitForFlushed(MaxTestDurationInMilliseconds);
// Assert
string text = string.Join(Environment.NewLine, listener.GetEventsCollectedAsText());
text.Should().Be(expectedText);
}
}
}
private void When_setting_path_to_relative_local_directory_it_must_raise_events()
{
// Arrange
const string directoryToWatch = @"c:\some";
const string fileNameToUpdate = "file.txt";
string pathToFileToUpdate = Path.Combine(directoryToWatch, fileNameToUpdate);
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingEmptyFile(pathToFileToUpdate)
.Build();
fileSystem.Directory.SetCurrentDirectory(@"c:\");
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher())
{
watcher.NotifyFilter = TestNotifyFilters.All;
// Act
watcher.Path = "some";
using (var listener = new FileSystemWatcherEventListener(watcher))
{
fileSystem.File.SetAttributes(pathToFileToUpdate, FileAttributes.ReadOnly);
watcher.FinishAndWaitForFlushed(MaxTestDurationInMilliseconds);
// Assert
listener.EventsCollected.Should().HaveCount(1);
listener.ChangeEventArgsCollected.Should().HaveSameCount(listener.EventsCollected);
FileSystemEventArgs args = listener.ChangeEventArgsCollected.Single();
args.ChangeType.Should().Be(WatcherChangeTypes.Changed);
args.FullPath.Should().Be(pathToFileToUpdate);
args.Name.Should().Be(fileNameToUpdate);
}
}
}
private void When_waiting_for_file_change_while_file_attributes_are_changed_it_must_succeed()
{
// Arrange
const string directoryToWatch = @"c:\some";
const string fileNameToUpdate1 = "file1.txt";
const string fileNameToUpdate2 = "file2.txt";
string pathToFileToUpdate1 = Path.Combine(directoryToWatch, fileNameToUpdate1);
string pathToFileToUpdate2 = Path.Combine(directoryToWatch, fileNameToUpdate2);
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingEmptyFile(pathToFileToUpdate1)
.IncludingEmptyFile(pathToFileToUpdate2)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = NotifyFilters.Attributes;
Task.Run(() =>
{
// ReSharper disable once AccessToDisposedClosure
BlockUntilStarted(watcher);
fileSystem.File.SetAttributes(pathToFileToUpdate1, FileAttributes.System);
fileSystem.File.SetAttributes(pathToFileToUpdate2, FileAttributes.System);
});
// Act
WaitForChangedResult result = watcher.WaitForChanged(WatcherChangeTypes.Changed, MaxTestDurationInMilliseconds);
// Assert
result.TimedOut.Should().BeFalse();
result.ChangeType.Should().Be(WatcherChangeTypes.Changed);
result.Name.Should().Be(fileNameToUpdate1);
result.OldName.Should().BeNull();
}
}
private void When_waiting_for_directory_deletion_while_directories_are_deleted_it_must_succeed()
{
// Arrange
const string directoryToWatch = @"c:\some";
const string directoryNameToDelete1 = "subfolder1";
const string directoryNameToDelete2 = "subfolder2";
string pathToDirectoryToDelete1 = Path.Combine(directoryToWatch, directoryNameToDelete1);
string pathToDirectoryToDelete2 = Path.Combine(directoryToWatch, directoryNameToDelete2);
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingDirectory(pathToDirectoryToDelete1)
.IncludingDirectory(pathToDirectoryToDelete2)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = NotifyFilters.DirectoryName;
Task.Run(() =>
{
// ReSharper disable once AccessToDisposedClosure
BlockUntilStarted(watcher);
fileSystem.Directory.Delete(pathToDirectoryToDelete1);
fileSystem.Directory.Delete(pathToDirectoryToDelete2);
});
// Act
WaitForChangedResult result = watcher.WaitForChanged(WatcherChangeTypes.Deleted, MaxTestDurationInMilliseconds);
// Assert
result.TimedOut.Should().BeFalse();
result.ChangeType.Should().Be(WatcherChangeTypes.Deleted);
result.Name.Should().Be(directoryNameToDelete1);
result.OldName.Should().BeNull();
}
}
private void When_copying_file_to_subdirectory_it_must_raise_events(NotifyFilters filters, [NotNull] string expectedText)
{
// Arrange
const string directoryToWatch = @"c:\some";
const string containerDirectoryName = "Container";
const string sourceFileName = "source.txt";
const string destinationDirectoryName = "Subfolder";
const string destinationFileName = "target.txt";
string pathToContainerDirectory = Path.Combine(directoryToWatch, containerDirectoryName);
string pathToSourceFile = Path.Combine(pathToContainerDirectory, sourceFileName);
string pathToDestinationDirectory = Path.Combine(pathToContainerDirectory, destinationDirectoryName);
string pathToDestinationFile = Path.Combine(pathToDestinationDirectory, destinationFileName);
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingTextFile(pathToSourceFile, "Example")
.IncludingDirectory(pathToDestinationDirectory)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = filters;
watcher.IncludeSubdirectories = true;
using (var listener = new FileSystemWatcherEventListener(watcher))
{
// Act
fileSystem.File.Copy(pathToSourceFile, pathToDestinationFile);
watcher.FinishAndWaitForFlushed(MaxTestDurationInMilliseconds);
// Assert
string text = string.Join(Environment.NewLine, listener.GetEventsCollectedAsText());
text.Should().Be(expectedText);
}
}
}
private void When_replacing_file_in_different_directory_with_backup_and_custom_attributes_it_must_raise_events(
NotifyFilters filters, [NotNull] string expectedText)
{
// Arrange
const string directoryToWatch = @"c:\some";
const string containerName = "Container";
string pathToSourceFile = Path.Combine(directoryToWatch, containerName, "sourceDir", "source.txt");
string pathToDestinationFile = Path.Combine(directoryToWatch, containerName, "targetDir", "target.txt");
string pathToBackupDirectory = Path.Combine(directoryToWatch, containerName, "backupDir");
string pathToBackupFile = Path.Combine(pathToBackupDirectory, "backup.txt");
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingTextFile(pathToSourceFile, "SourceText", attributes: FileAttributes.Hidden)
.IncludingTextFile(pathToDestinationFile, "DestinationText",
attributes: FileAttributes.Hidden | FileAttributes.System)
.IncludingDirectory(pathToBackupDirectory)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = filters;
watcher.IncludeSubdirectories = true;
using (var listener = new FileSystemWatcherEventListener(watcher))
{
// Act
fileSystem.File.Replace(pathToSourceFile, pathToDestinationFile, pathToBackupFile);
watcher.FinishAndWaitForFlushed(MaxTestDurationInMilliseconds);
// Assert
string text = string.Join(Environment.NewLine, listener.GetEventsCollectedAsText());
text.Should().Be(expectedText);
}
}
}
private void When_moving_readonly_hidden_system_archive_file_to_sibling_directory_it_must_raise_events(
NotifyFilters filters, [NotNull] string expectedText)
{
// Arrange
const string directoryToWatch = @"c:\some";
const string sourceFileName = "source.txt";
const string destinationFileName = "target.txt";
string pathToSourceFile = Path.Combine(directoryToWatch, "srcFolder", sourceFileName);
string pathToDestinationDirectory = Path.Combine(directoryToWatch, "dstFolder");
string pathToDestinationFile = Path.Combine(pathToDestinationDirectory, destinationFileName);
FakeFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingTextFile(pathToSourceFile, "CONTENT",
attributes: FileAttributes.ReadOnly | FileAttributes.Hidden | FileAttributes.System | FileAttributes.Archive)
.IncludingDirectory(pathToDestinationDirectory)
.Build();
using (FakeFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
watcher.NotifyFilter = filters;
watcher.IncludeSubdirectories = true;
using (var listener = new FileSystemWatcherEventListener(watcher))
{
// Act
fileSystem.File.Move(pathToSourceFile, pathToDestinationFile);
watcher.FinishAndWaitForFlushed(MaxTestDurationInMilliseconds);
// Assert
string text = string.Join(Environment.NewLine, listener.GetEventsCollectedAsText());
text.Should().Be(expectedText);
}
}
}
