private IDirectory BuildInMemoryDirectoryWithTestFiles(string filesInformation)
{
var directory = new InMemoryDirectory();
var filesArray = filesInformation.Split('|');
foreach (var file in filesArray)
{
var pathSegments = PathUtils.SplitPathIntoSegments(file);
var fileName = pathSegments[pathSegments.Length - 1];
string dir = string.Empty;
if (pathSegments.Length > 1)
{
for (int i = 0; i < pathSegments.Length - 1; i++)
{
dir = dir + "/" + pathSegments[i];
}
}
var fileContents = Guid.NewGuid();
IFileInfo fileInfo = new StringFileInfo(fileContents.ToString(), fileName);
directory.AddFile(dir, fileInfo);
}
return(directory);
}
public void Can_Watch_Directory_For_New_Items()
{
// Arrange
IDirectory directory = new InMemoryDirectory();
var watcher = new DirectoryWatcher(directory);
var watchPattern = "/some/dir/folder/newfile.*";
watcher.AddFilter(watchPattern);
//
bool notified = false;
watcher.ItemAdded += (sender, e) =>
{
DirectoryItemAddedEventArgs args = e.DirectoryItemEventArgs;
var matchedFilters = e.MatchedFilters;
IDirectoryItem newItem = args.NewItem;
Assert.Equal("newfile.txt", newItem.Name);
notified = true;
};
directory.AddFile("/some/dir/folder/", new StringFileInfo("hi", "newfile.txt"));
Assert.True(notified);
notified = false;
directory.AddFile("/some/dir/folder/", new StringFileInfo("shouldnt trigger", "anotherfile.txt"));
Assert.False(notified);
}
public IResource CreateFile(FilePath path, byte[]?content = null)
{
var comparison = StringComparison.InvariantCultureIgnoreCase;
if (path.IsAbsolute || path.IsDirectory)
{
throw new ArgumentException("File path cannot be an absolute or a directory");
}
InMemoryDirectory curDir = root;
foreach (var nextDirName in path.Parts.SkipLast(1))
{
var nextDir = curDir.Directories.FirstOrDefault(d => d.Name.Equals(nextDirName, comparison)) as InMemoryDirectory;
if (nextDir == null)
{
nextDir = new InMemoryDirectory(this, curDir, curDir.Path.Combine(nextDirName));
curDir.directories.Add(nextDir);
}
curDir = nextDir;
}
var fileName = path.Parts.Last();
if (curDir.Any(r => r.Name.Equals(fileName, comparison)))
{
throw new ArgumentException($"Resource at path {path} already exists");
}
var newFile = new InMemoryFile(curDir, curDir.Path.Combine(fileName), content); // recombine for case preservation
curDir.files.Add(newFile);
return(newFile);
}
public void TokensFiredOnFileDeleted()
{
var rootDir = new InMemoryDirectory("root");
// add a file at root/a.txt
var fileItem = rootDir.AddFile("", new StringFileInfo("some content", "b.txt"));
using (var provider = new InMemoryFileProvider(rootDir))
{
var filePath = "root/b.txt";
// var fileInfo = provider.GetFileInfo("root/b.txt");
var token = provider.Watch(filePath);
Assert.NotNull(token);
Assert.False(token.HasChanged);
Assert.True(token.ActiveChangeCallbacks);
bool callbackInvoked = false;
token.RegisterChangeCallback(state =>
{
callbackInvoked = true;
}, state: null);
// Trigger a change.
fileItem.Delete();
Assert.True(token.HasChanged);
Assert.True(callbackInvoked);
}
}
public void Can_Search_For_Files()
{
// Arrange
var directory = new InMemoryDirectory();
// Add some files
directory.AddFile("/foo", new StringFileInfo("greetings", "bar.txt"));
directory.AddFile("/foo", new StringFileInfo("another", "baz.txt"));
directory.AddFile("/bar", new StringFileInfo("hi", "bar.txt"));
directory.AddFile("/foo", new StringFileInfo("foo", "bar.txt.min"));
var testProvider = new InMemoryFileProvider(directory);
// Act
// Assert
// Assert that we can get the file from the directory using its full path.
var results = testProvider.Search("/foo/*.txt").ToArray();
Assert.NotNull(results);
Assert.Equal(2, results.Length);
Assert.Equal(results[0].Item1, "/foo");
Assert.Equal(results[0].Item2.Name, "bar.txt");
Assert.Equal(results[1].Item1, "/foo");
Assert.Equal(results[1].Item2.Name, "baz.txt");
}
public void Can_Search_For_Files_Using_Multiple_Includes_And_Excludes()
{
// Arrange
var directory = new InMemoryDirectory();
// Add some files
directory.AddFile("/foo", new StringFileInfo("greetings", "bar.txt"));
directory.AddFile("/foo", new StringFileInfo("another", "baz.txt"));
directory.AddFile("/bar", new StringFileInfo("hi", "bar.txt"));
directory.AddFile("/foo", new StringFileInfo("foo", "bar.txt.min"));
var testProvider = new InMemoryFileProvider(directory);
// Act
// Assert
// Assert that we can get the file from the directory using its full path.
var includes = new string[] { "/foo/*.txt", "/bar/bar.txt" };
var results = testProvider.Search(includes, "/foo/baz.txt").ToArray();
Assert.NotNull(results);
Assert.Equal(2, results.Length);
}
public void Can_Watch_Directory_For_Updated_Items()
{
// Arrange
IDirectory directory = new InMemoryDirectory();
directory.AddFile("/some/dir/folder/", new StringFileInfo("hi", "newfile.txt"));
var watcher = new DirectoryWatcher(directory);
var watchPattern = "/some/dir/folder/new*.txt";
watcher.AddFilter(watchPattern);
//
bool notified = false;
watcher.ItemUpdated += (sender, e) =>
{
DirectoryItemUpdatedEventArgs args = e.DirectoryItemEventArgs;
var matchedFilters = e.MatchedFilters;
Assert.Equal("newfile.txt", args.OldItem.Name);
Assert.Equal("newfile.csv", args.NewItem.Name);
notified = true;
};
// now update the file
var existingItem = directory.GetFile("/some/dir/folder/newfile.txt");
existingItem.Update(new StringFileInfo("changed", "newfile.csv"));
Assert.True(notified);
notified = false;
existingItem.Update(new StringFileInfo("changed again", "newfile.csv"));
// second update shouldnt trigger as our watch pattern is only watching newfile*.txt files.
Assert.False(notified);
}
public void Can_Nest_Folders()
{
// Arrange
IDirectory directory = new InMemoryDirectory();
// Act
// Adds a folder to the directory, along with the necessary directory structure
var folder = directory.GetOrAddFolder("/some/dir/folder");
Assert.NotNull(folder);
var parentFolder = directory.GetFolder("/some/dir");
var grandparentFolder = directory.GetFolder("/some");
// "/some/dir/folder" should have parent folder of "/some/dir"
Assert.Equal(parentFolder, folder.ParentFolder);
Assert.Equal("/some/dir/folder", folder.Path);
Assert.Equal("folder", folder.Name);
Assert.NotNull(folder.FileInfo);
Assert.True(folder.IsFolder);
// "/some/dir/" should have parent folder of "/some"
Assert.Equal(grandparentFolder, parentFolder.ParentFolder);
Assert.Equal("/some/dir", parentFolder.Path);
Assert.Equal("dir", parentFolder.Name);
Assert.NotNull(parentFolder.FileInfo);
Assert.True(parentFolder.IsFolder);
// "/some" should have parent folder which is the root folder for this directory.
Assert.Equal(directory.Root, grandparentFolder.ParentFolder);
Assert.Equal("/some", grandparentFolder.Path);
Assert.Equal("some", grandparentFolder.Name);
Assert.NotNull(grandparentFolder.FileInfo);
Assert.True(grandparentFolder.IsFolder);
}
public void Can_Watch_Directory_For_Moved_Items()
{
// Arrange
// Prepare our in memory directory.
IDirectory directory = new InMemoryDirectory();
directory.AddFile("/some/dir/folder/", new StringFileInfo("hi", "newfile.txt"));
directory.AddFile("/some/dir/another/", new StringFileInfo("hi", "newfile.txt"));
directory.AddFile("/some/dir/hello/", new StringFileInfo("hi", "newfile.txt"));
// Watch the directory using a pattern as a filter.
var watcher = new DirectoryWatcher(directory);
var watchPattern = "/some/dir/**/new*.txt";
watcher.AddFilter(watchPattern);
// Register for the watchers ItemUpdated event, this is how it should notify us of updated
// files.
int notifyCount = 0;
watcher.ItemUpdated += (sender, e) =>
{
DirectoryItemUpdatedEventArgs args = e.DirectoryItemEventArgs;
var matchedFilters = e.MatchedFilters; // contains the patterns that were matched (the reason we are being notified)
// we aren't renaming the file so the file should have the same name.
// We are renaming a parent folder, so only the items full path should be different.
Assert.Equal("newfile.txt", args.OldItem.Name);
Assert.Equal("newfile.txt", args.NewItem.Name);
Assert.StartsWith("/some/dir/", args.OldItem.Path); // the old folder path.
Assert.StartsWith("/newfoldername/dir/", args.NewItem.Path); // the new folder path.
//Assert.Equal("/changed/dir/folder/newfile.txt", args.NewItem.Path);
notifyCount = notifyCount + 1;
};
// Act
// Rename the root folder /some too be /newfoldername
// this should cause the watcher to notifiy us of effected items we are interested in.
var folder = directory.GetFolder("/some");
folder.Rename("newfoldername");
// Watcher should have notified us on of 3 items we were watching (matched by the pattern)
Assert.Equal(3, notifyCount);
// now rename the file again - this time the watcher should not notify us, as the items live in a directory
// that no longer match out pattern - i.e the previous rename operation has moved them outside of our filter pattern.
notifyCount = 0;
var existingItem = directory.GetFile("/newfoldername/dir/folder/newfile.txt");
existingItem.Update(new StringFileInfo("changed", "newfile.csv"));
Assert.Equal(0, notifyCount);
}
public void GetFileInfo_ReturnsNotFoundFileInfo_ForRelativePathWithEmptySegmentsThatNavigates()
{
var rootDir = new InMemoryDirectory("root");
// add a file at root/a.txt
rootDir.AddFile("", new StringFileInfo("some content", "b"));
using (var provider = new InMemoryFileProvider(rootDir))
{
var info = provider.GetFileInfo("a///../../" + "root" + "/b");
Assert.IsType(typeof(NotFoundFileInfo), info);
}
}
private InMemoryDirectory GetRoot(string path)
{
InMemoryDirectory directory;
lock (Directories)
{
if (!Directories.TryGetValue(path, out directory))
{
Directories.Add(path, directory = new InMemoryDirectory(this, path));
}
}
return directory;
}
public void GetFileInfo_ReturnsNotFoundFileInfo_ForRelativePathThatNavigatesAboveRoot()
{
var rootDir = new InMemoryDirectory("root");
// add a file at root/a.txt
rootDir.AddFile("", new StringFileInfo("some content", "a.txt"));
using (var provider = new InMemoryFileProvider(rootDir))
{
// Act
var info = provider.GetFileInfo("../root/a.txt");
Assert.IsType(typeof(NotFoundFileInfo), info);
}
}
public void CreateReadStream_Succeeds_OnEmptyFile()
{
var rootDir = new InMemoryDirectory("root");
// add a file at root/a.txt
rootDir.AddFile("", new StringFileInfo(null, "a.txt"));
using (var provider = new InMemoryFileProvider(rootDir))
{
var info = provider.GetFileInfo("root/a.txt");
using (var stream = info.CreateReadStream())
{
Assert.NotNull(stream);
}
}
}
public void Can_Add_Then_Retrieve_A_Folder()
{
// Arrange
IDirectory directory = new InMemoryDirectory();
// Act
// Add the file to the directory, to the folder path: /foo/bar
var folder = directory.GetOrAddFolder("/folder");
Assert.NotNull(folder);
var retrievedFolder = directory.GetFolder("/folder");
Assert.NotNull(retrievedFolder);
Assert.Equal(folder, retrievedFolder);
}
public void Token_IsSame_ForSamePath()
{
var rootDir = new InMemoryDirectory("root");
// add a file at root/a.txt
rootDir.AddFile("", new StringFileInfo("some content", "b.txt"));
using (var provider = new InMemoryFileProvider(rootDir))
{
var filePath = "root/b.txt";
// var fileInfo = provider.GetFileInfo("root/b.txt");
var token1 = provider.Watch(filePath);
var token2 = provider.Watch(filePath);
Assert.NotNull(token1);
Assert.NotNull(token2);
Assert.Equal(token2, token1);
}
}
public void Can_Add_Then_Retrieve_A_File()
{
// Arrange
IDirectory directory = new InMemoryDirectory();
var fileContents = "greetings!";
IFileInfo fileInfo = new StringFileInfo(fileContents, "hello.txt");
// Act
// Add the file to the directory, to the folder path: /foo/bar
directory.AddFile("/foo", fileInfo);
// Assert
// Assert that we can get the file from the directory using its full path.
var retrievedFile = directory.GetFile("/foo/hello.txt");
Assert.NotNull(retrievedFile);
Assert.Equal(fileInfo, retrievedFile.FileInfo);
}
public void CreateDirectory(string directory)
{
InMemoryDirectory dir = Root;
InMemoryDirectory newDir;
// Make sure all the directory and all its ancestors exist
foreach (string directoryName in directory.Split(DirectorySeparators, StringSplitOptions.RemoveEmptyEntries))
{
if (!dir.GetSubdirectory(directoryName).Exists)
{
// Create a new directory
newDir = new InMemoryDirectory(this, Path.Combine(dir.FullName, directoryName));
dir.AddSubDirectory(newDir);
}
else
{
dir = dir.GetSubdirectory(directoryName) as InMemoryDirectory;
}
}
}
public void TokensFiredOnFileChange()
{
var rootDir = new InMemoryDirectory("root");
// add a file at root/a.txt
var fileItem = rootDir.AddFile("", new StringFileInfo("some content", "b.txt"));
using (var provider = new InMemoryFileProvider(rootDir))
{
var filePath = "root/b.txt";
// var fileInfo = provider.GetFileInfo("root/b.txt");
var token = provider.Watch(filePath);
Assert.NotNull(token);
Assert.False(token.HasChanged);
Assert.True(token.ActiveChangeCallbacks);
// Trigger a change.
fileItem.Update(new StringFileInfo("modified content", "b.txt"));
Assert.True(token.HasChanged);
}
}
public void Can_Watch_Directory_For_Deleted_Items()
{
// Arrange
IDirectory directory = new InMemoryDirectory();
directory.AddFile("/some/dir/folder/", new StringFileInfo("hi", "foo.txt"));
directory.AddFile("/some/dir/folder/", new StringFileInfo("hi", "bar.txt"));
var watcher = new DirectoryWatcher(directory);
var watchPattern = "/some/dir/folder/foo.txt";
watcher.AddFilter(watchPattern);
//
bool notified = false;
watcher.ItemDeleted += (sender, e) =>
{
DirectoryItemDeletedEventArgs args = e.DirectoryItemEventArgs;
var matchedFilters = e.MatchedFilters;
IDirectoryItem deletedItem = args.DeletedItem;
Assert.Equal("foo.txt", deletedItem.Name);
notified = true;
};
var fooFile = directory.GetFile("/some/dir/folder/foo.txt");
fooFile.Delete();
Assert.True(notified);
notified = false;
var barFile = directory.GetFile("/some/dir/folder/bar.txt");
barFile.Delete();
Assert.False(notified);
}
InMemoryDirectory GetRoot(string path)
{
InMemoryDirectory directory;
if (!Directories.TryGetValue(path, out directory))
{
Directories.Add(path, directory = new InMemoryDirectory(path)
{
FileSystem = this
});
}
return directory;
}
public InMemoryFileSystem()
{
_directories[""] = new InMemoryDirectory(this, "");
}
public InMemoryFileSystem()
{
// Create a new Root directory
Root = new InMemoryDirectory(this, "");
}
public IDirectory GetDirectory(string path)
{
IDirectory directory = Root;
if (path.Length != 0 && path != @"\")
{
foreach (string directoryName in path.Split(DirectorySeparators))
{
directory = directory.GetSubdirectory(directoryName);
if (!directory.Exists)
{
break; // no point going further the directory doesn't exist
}
}
}
// The directory wasn't found - so return a blank directory for the path
if (!directory.Exists)
{
directory = new InMemoryDirectory(this, path);
}
return directory;
}
public InMemoryResourcePool()
{
root = new InMemoryDirectory(this, null, "");
}
public InMemoryDirectoryFacts()
{
this.fileSystem = new InMemoryFileSystem();
this.testee = new InMemoryDirectory(this.fileSystem, Enumerable.Empty<IDirectoryExtension>());
}
