public async Task TokenFiredForGlobbingPatternsPointingToSubDirectory()
{
using (var root = new DisposableFileSystem())
{
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
{
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
using (var provider = new PhysicalFileProvider(root.RootPath, physicalFilesWatcher))
{
var subDirectoryName = Guid.NewGuid().ToString();
var subSubDirectoryName = Guid.NewGuid().ToString();
var fileName = Guid.NewGuid().ToString() + ".cshtml";
root.CreateFolder(subDirectoryName)
.CreateFolder(Path.Combine(subDirectoryName, subSubDirectoryName))
.CreateFile(Path.Combine(subDirectoryName, subSubDirectoryName, fileName));
var pattern = string.Format(Path.Combine(subDirectoryName, "**", "*.cshtml"));
var token = provider.Watch(pattern);
fileSystemWatcher.CallOnChanged(new FileSystemEventArgs(WatcherChangeTypes.Changed, Path.Combine(root.RootPath, subDirectoryName, subSubDirectoryName), fileName));
await Task.Delay(WaitTimeForTokenToFire);
Assert.True(token.HasChanged);
}
}
}
}
}
public async Task TokensFiredForOldAndNewNamesOnRename()
{
using (var root = new DisposableFileSystem())
{
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
{
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
using (var provider = new PhysicalFileProvider(root.RootPath, physicalFilesWatcher))
{
var oldFileName = Guid.NewGuid().ToString();
var oldToken = provider.Watch(oldFileName);
var newFileName = Guid.NewGuid().ToString();
var newToken = provider.Watch(newFileName);
fileSystemWatcher.CallOnRenamed(new RenamedEventArgs(WatcherChangeTypes.Renamed, root.RootPath, newFileName, oldFileName));
await Task.Delay(WaitTimeForTokenToFire);
Assert.True(oldToken.HasChanged);
Assert.True(newToken.HasChanged);
}
}
}
}
}
public async Task CorrectTokensFiredForMultipleFiles()
{
using (var root = new DisposableFileSystem())
{
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
{
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
using (var provider = new PhysicalFileProvider(root.RootPath, physicalFilesWatcher))
{
var fileName1 = Guid.NewGuid().ToString();
var token1 = provider.Watch(fileName1);
var fileName2 = Guid.NewGuid().ToString();
var token2 = provider.Watch(fileName2);
fileSystemWatcher.CallOnChanged(new FileSystemEventArgs(WatcherChangeTypes.Changed, root.RootPath, fileName1));
await Task.Delay(WaitTimeForTokenToFire);
Assert.True(token1.HasChanged);
Assert.False(token2.HasChanged);
fileSystemWatcher.CallOnChanged(new FileSystemEventArgs(WatcherChangeTypes.Changed, root.RootPath, fileName2));
await Task.Delay(WaitTimeForTokenToFire);
Assert.True(token2.HasChanged);
}
}
}
}
}
public async Task TokenFiredForFilesUnderPathEndingWithSlash()
{
using (var root = new DisposableFileSystem())
{
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
{
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
using (var provider = new PhysicalFileProvider(root.RootPath, physicalFilesWatcher))
{
var directoryName = Guid.NewGuid().ToString();
root.CreateFolder(directoryName)
.CreateFile(Path.Combine(directoryName, "some-file"));
var newDirectory = Path.GetRandomFileName();
var token = provider.Watch(directoryName + Path.DirectorySeparatorChar);
Directory.Move(
Path.Combine(root.RootPath, directoryName),
Path.Combine(root.RootPath, newDirectory));
fileSystemWatcher.CallOnRenamed(new RenamedEventArgs(
WatcherChangeTypes.Renamed,
root.RootPath,
newDirectory,
directoryName));
await Task.Delay(WaitTimeForTokenToFire);
Assert.True(token.HasChanged);
}
}
}
}
}
public async Task TokenNotAffectedByExceptions()
{
using (var root = new DisposableFileSystem())
{
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
{
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
using (var provider = new PhysicalFileProvider(root.RootPath, physicalFilesWatcher))
{
var fileName = Guid.NewGuid().ToString();
var token = provider.Watch(fileName);
token.RegisterChangeCallback(_ =>
{
throw new Exception();
}, null);
fileSystemWatcher.CallOnChanged(new FileSystemEventArgs(WatcherChangeTypes.Changed, root.RootPath, fileName));
await Task.Delay(WaitTimeForTokenToFire);
Assert.True(token.HasChanged);
}
}
}
}
}
public async Task FileChangeTokenNotNotifiedAfterExpiry()
{
using (var root = new DisposableFileSystem())
{
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
{
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
using (var provider = new PhysicalFileProvider(root.RootPath, physicalFilesWatcher))
{
var fileName = Guid.NewGuid().ToString();
var changeToken = provider.Watch(fileName);
var invocationCount = 0;
changeToken.RegisterChangeCallback(_ => { invocationCount++; }, null);
// Callback expected.
fileSystemWatcher.CallOnChanged(new FileSystemEventArgs(WatcherChangeTypes.Changed, root.RootPath, fileName));
await Task.Delay(WaitTimeForTokenToFire);
// Callback not expected.
fileSystemWatcher.CallOnChanged(new FileSystemEventArgs(WatcherChangeTypes.Changed, root.RootPath, fileName));
await Task.Delay(WaitTimeForTokenToFire);
Assert.Equal(1, invocationCount);
}
}
}
}
}
public async Task TokensFiredOnFileDeleted()
{
using (var root = new DisposableFileSystem())
{
var fileName = Guid.NewGuid().ToString();
var fileLocation = Path.Combine(root.RootPath, fileName);
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
{
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
using (var provider = new PhysicalFileProvider(root.RootPath, physicalFilesWatcher))
{
var token = provider.Watch(fileName);
Assert.NotNull(token);
Assert.False(token.HasChanged);
Assert.True(token.ActiveChangeCallbacks);
fileSystemWatcher.CallOnDeleted(new FileSystemEventArgs(WatcherChangeTypes.Deleted, root.RootPath, fileName));
await Task.Delay(WaitTimeForTokenToFire);
Assert.True(token.HasChanged);
}
}
}
}
}
public async Task WatcherWithPolling_ReturnsTrueForChangedFileWhenQueriedMultipleTimes()
{
using (var root = new DisposableFileSystem())
{
var fileName = Path.GetRandomFileName();
var fileLocation = Path.Combine(root.RootPath, fileName);
PollingFileChangeToken.PollingInterval = TimeSpan.FromMilliseconds(10);
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
{
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: true))
{
using (var provider = new PhysicalFileProvider(root.RootPath, physicalFilesWatcher))
{
root.CreateFile(fileName);
var token = provider.Watch(fileName);
File.Delete(fileLocation);
await Task.Delay(WaitTimeForTokenToFire);
Assert.True(token.HasChanged);
}
}
}
}
}
public async Task TokensFiredForAllEntriesOnError()
{
using (var root = new DisposableFileSystem())
{
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
{
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
using (var provider = new PhysicalFileProvider(root.RootPath, physicalFilesWatcher))
{
var token1 = provider.Watch(Guid.NewGuid().ToString());
var token2 = provider.Watch(Guid.NewGuid().ToString());
var token3 = provider.Watch(Guid.NewGuid().ToString());
fileSystemWatcher.CallOnError(new ErrorEventArgs(new Exception()));
await Task.Delay(WaitTimeForTokenToFire);
Assert.True(token1.HasChanged);
Assert.True(token2.HasChanged);
Assert.True(token3.HasChanged);
}
}
}
}
}
public async Task TokensNotFiredForHiddenAndSystemFiles()
{
using (var root = new DisposableFileSystem())
{
var hiddenFileName = Guid.NewGuid().ToString();
var hiddenFilePath = Path.Combine(root.RootPath, hiddenFileName);
File.Create(hiddenFilePath);
var fileInfo = new FileInfo(hiddenFilePath);
File.SetAttributes(hiddenFilePath, fileInfo.Attributes | FileAttributes.Hidden);
var systemFileName = Guid.NewGuid().ToString();
var systemFilePath = Path.Combine(root.RootPath, systemFileName);
File.Create(systemFilePath);
fileInfo = new FileInfo(systemFilePath);
File.SetAttributes(systemFilePath, fileInfo.Attributes | FileAttributes.System);
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
{
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
using (var provider = new PhysicalFileProvider(root.RootPath, physicalFilesWatcher))
{
var hiddenFiletoken = provider.Watch(Path.GetFileName(hiddenFileName));
var systemFiletoken = provider.Watch(Path.GetFileName(systemFileName));
fileSystemWatcher.CallOnChanged(new FileSystemEventArgs(WatcherChangeTypes.Changed, root.RootPath, hiddenFileName));
await Task.Delay(WaitTimeForTokenToFire);
Assert.False(hiddenFiletoken.HasChanged);
fileSystemWatcher.CallOnChanged(new FileSystemEventArgs(WatcherChangeTypes.Changed, root.RootPath, systemFileName));
await Task.Delay(WaitTimeForTokenToFire);
Assert.False(systemFiletoken.HasChanged);
}
}
}
}
}
public async Task TokenNotFiredForFileNameStartingWithPeriod()
{
using (var root = new DisposableFileSystem())
{
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
{
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
using (var provider = new PhysicalFileProvider(root.RootPath, physicalFilesWatcher))
{
var fileName = "." + Guid.NewGuid().ToString();
var token = provider.Watch(Path.GetFileName(fileName));
fileSystemWatcher.CallOnChanged(new FileSystemEventArgs(WatcherChangeTypes.Changed, root.RootPath, fileName));
await Task.Delay(WaitTimeForTokenToFire);
Assert.False(token.HasChanged);
}
}
}
}
}
public async Task TokenFiredOnCreation()
{
using (var root = new DisposableFileSystem())
{
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
{
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
using (var provider = new PhysicalFileProvider(root.RootPath, physicalFilesWatcher))
{
var name = Guid.NewGuid().ToString();
var token = provider.Watch(name);
fileSystemWatcher.CallOnChanged(new FileSystemEventArgs(WatcherChangeTypes.Created, root.RootPath, name));
await Task.Delay(WaitTimeForTokenToFire);
Assert.True(token.HasChanged);
}
}
}
}
}
public async Task WatcherWithPolling_ReturnsTrueForFileChangedWhenFileSystemWatcherDoesNotRaiseEvents()
{
using (var root = new DisposableFileSystem())
{
var fileName = Path.GetRandomFileName();
var fileLocation = Path.Combine(root.RootPath, fileName);
PollingFileChangeToken.PollingInterval = TimeSpan.FromMilliseconds(10);
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
{
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: true))
{
using (var provider = new PhysicalFileProvider(root.RootPath, physicalFilesWatcher))
{
var token = provider.Watch(fileName);
File.WriteAllText(fileLocation, "some-content");
await Task.Delay(WaitTimeForTokenToFire);
Assert.True(token.HasChanged);
}
}
}
}
}
