public void CheckAllFilesWithoutFilter()
{
#region Arrange
List <string> expectedList = new List <string>
{
"File1.txt",
"SubDirectory1",
"SubDirectory2",
"File2.cs",
"File3.jpg",
"File4.txt",
"File5.dll",
"SubDirectory2_1"
};
FileSystemVisitor visitor = new FileSystemVisitor($"{_currentDirectory}\\RootFolder");
#endregion
#region Act
var actualList = visitor.Find().ToList();
#endregion
#region Assert
CollectionAssert.AreEqual(expectedList, actualList, $"Actual value is '{string.Join(", ",actualList)}'");
#endregion
}
public void StartProcess_NeitherOfItemsPassFilter_ExpectedDataReturns()
{
var actualList = new List <string>();
var expectedList = new List <string>();
var item1 = new Mock <IFileInfoWrapper>();
var item2 = new Mock <IDirectoryInfoWrapper>();
item1.Setup(_ => _.Name).Returns("Puppy");
item2.Setup(_ => _.Name).Returns("Hello");
var excpectedList = new List <IFileSystemInfoWrapper>()
{
item1.Object,
item2.Object
};
directoryInfoMock.Setup(_ => _.GetFileSystemInfos()).Returns(excpectedList.ToArray());
Func <IFileSystemInfoWrapper, bool> filter = (item) => false;
var fileSystemVisitor = new FileSystemVisitor(filter);
foreach (var item in fileSystemVisitor.StartProcess(directoryInfoMock.Object))
{
actualList.Add(item.Name);
}
CollectionAssert.AreEqual(expectedList, actualList);
directoryInfoMock.Verify(_ => _.GetFileSystemInfos(), Times.Once);
}
public void CheckBreakSearchAfterFileFindedEvent()
{
#region Arrange
EventHandler <FileEventArgs> fileFindedHandler = (sender, e) =>
{
if (e.File.Name == "File2.cs")
{
e.Break = true;
}
};
List <string> expectedList = new List <string>
{
"File1.txt",
"SubDirectory1",
"SubDirectory2",
"File2.cs"
};
FileSystemVisitor visitor = new FileSystemVisitor($"{_currentDirectory}\\RootFolder");
#endregion
#region Act
visitor.FileFinded += fileFindedHandler;
var actualList = visitor.Find().ToList();
#endregion
#region Assert
CollectionAssert.AreEqual(expectedList, actualList, $"Actual value is '{string.Join(", ", actualList)}'");
#endregion
}
public void CheckExcludeDirectoryAfterFilteredDirectoryFindedEvent()
{
#region Arrange
Predicate <string> filter = x => x.StartsWith("SubDirectory");
EventHandler <DirectoryEventArgs> filteredDirectoryFindedHandler = (sender, e) =>
{
if (e.Directory.Name.EndsWith("2"))
{
e.Exclude = true;
}
};
List <string> expectedList = new List <string>
{
"SubDirectory1",
"SubDirectory2_1"
};
FileSystemVisitor visitor = new FileSystemVisitor($"{_currentDirectory}\\RootFolder", filter);
#endregion
#region Act
visitor.FilteredDirectoryFinded += filteredDirectoryFindedHandler;
var actualList = visitor.Find().ToList();
#endregion
#region Assert
CollectionAssert.AreEqual(expectedList, actualList, $"Actual value is '{string.Join(", ", actualList)}'");
#endregion
}
public void CheckBreakSearchAfterFilteredFileFindedEvent()
{
#region Arrange
Predicate <string> filter = x => x.EndsWith(".txt");
EventHandler <FileEventArgs> filteredFileFindedHandler = (sender, e) =>
{
if (e.File.Name.StartsWith("File1"))
{
e.Break = true;
}
};
List <string> expectedList = new List <string>
{
"File1.txt"
};
FileSystemVisitor visitor = new FileSystemVisitor($"{_currentDirectory}\\RootFolder", filter);
#endregion
#region Act
visitor.FilteredFileFinded += filteredFileFindedHandler;
var actualList = visitor.Find().ToList();
#endregion
#region Assert
CollectionAssert.AreEqual(expectedList, actualList, $"Actual value is '{string.Join(", ", actualList)}'");
#endregion
}
public void CheckExcludeDirectoryAfterDirectoryFindedEvent()
{
#region Arrange
EventHandler <DirectoryEventArgs> directoryFindedHandler = (sender, e) =>
{
if (e.Directory.Name == "SubDirectory2")
{
e.Exclude = true;
}
};
List <string> expectedList = new List <string>
{
"File1.txt",
"SubDirectory1",
"File2.cs",
"File3.jpg",
"File4.txt",
"File5.dll",
"SubDirectory2_1"
};
FileSystemVisitor visitor = new FileSystemVisitor($"{_currentDirectory}\\RootFolder");
#endregion
#region Act
visitor.DirectoryFinded += directoryFindedHandler;
var actualList = visitor.Find().ToList();
#endregion
#region Assert
CollectionAssert.AreEqual(expectedList, actualList, $"Actual value is '{string.Join(", ", actualList)}'");
#endregion
}
public void GetAllElenments()
{
// Arrange
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ @"c:\myfile.txt", new MockFileData("Testing is meh.") },
{ @"c:\Folder\New File.txt", new MockFileData("some new file") },
{ @"c:\Folder 2\setting.json", new MockFileData("\"field\":\"value\"") }
});
FileSystemVisitor fsv = new FileSystemVisitor("c:/", fileSystem: fileSystem);
var expected = new string[] {
@"c:\Folder",
@"c:\Folder\New File.txt",
@"c:\Folder 2",
@"c:\Folder 2\setting.json",
@"c:\myfile.txt"
};
// Act
var actual = fsv.GetAllElements();
// Assert
Assert.Equal(expected, actual);
}
private static void Main()
{
var stringForSkip = "level2";
var stringForStop = "file2";
var fileSystemProvider = new FileSystemInfoProvider();
var visitor = new FileSystemVisitor(fileSystemProvider, "d:/Test", entity => entity.Name.Contains("l2"));
visitor.Start += (o, eventArgs) => Console.WriteLine("Start !!!");
visitor.Finish += (o, eventArgs) => Console.WriteLine("Finish !!!");
visitor.FileFound += (o, eventArgs) => Console.WriteLine($"File {eventArgs.FoundItem.Name} found!!!");
visitor.DirectoryFound += (o, eventArgs) => Console.WriteLine($"Directory {eventArgs.FoundItem.Name} found!!!");
visitor.FilteredFileFound += (o, eventArgs) =>
{
Console.WriteLine($"Filtered File {eventArgs.FoundItem.Name} found!!!");
eventArgs.IsSkip = eventArgs.FoundItem.Name.Contains(stringForSkip);
eventArgs.IsStop = eventArgs.FoundItem.Name.Contains(stringForStop);
};
visitor.FilteredDirectoryFound += (o, eventArgs) =>
{
Console.WriteLine($"Filtered Directory {eventArgs.FoundItem.Name} found!!!");
eventArgs.IsSkip = eventArgs.FoundItem.Name.Contains(stringForSkip);
eventArgs.IsStop = eventArgs.FoundItem.Name.Contains(stringForStop);
};
foreach (var item in visitor)
{
Console.WriteLine($"{item.Name} - {item.Type} - {item.Date}");
}
Console.ReadKey();
}
static void Main(string[] args)
{
var path = Console.ReadLine();
Predicate <string> predicate = (info) => info.Contains("txt");
FileSystemVisitor fsVisitor;
try
{
fsVisitor = new FileSystemVisitor(path, predicate);
}
catch (DirectoryNotFoundException e)
{
throw new DirectoryNotFoundException("Invalid directory path.", e);
}
catch (ArgumentNullException e)
{
throw new ArgumentNullException("Invalid argument.", e);
}
catch (Exception)
{
throw;
}
fsVisitor.VisitStarted += (sender, e) => { Console.WriteLine("EVENT VisitStarted"); };
fsVisitor.VisitFinished += (sender, e) => { Console.WriteLine("EVENT VisitFinished"); };
fsVisitor.DirectoryFound += (sender, e) => { Console.WriteLine($"EVENT -Dir: {e.Path}"); };
fsVisitor.FileFound += (sender, e) => { Console.WriteLine($"EVENT File: {e.Path}"); };
fsVisitor.FilteredDirectoryFound += (sender, e) => { Console.WriteLine($"EVENT -Filtered Dir: {e.Path}"); };
fsVisitor.FilteredFileFound += (sender, e) => { Console.WriteLine($"EVENT Filtered File: {e.Path}"); };
var result = new List <string>();
try
{
foreach (var item in fsVisitor)
{
result.Add(item);
}
}
catch (DirectoryNotFoundException e)
{
throw new DirectoryNotFoundException("Invalid directory path.", e);
}
catch (Exception)
{
throw;
}
foreach (var item in result)
{
Console.WriteLine(item);
}
Console.ReadLine();
}
public void Initialize()
{
fsv = new FileSystemVisitor();
conditions = new Predicate <string> [2];
conditions[0] = null;
conditions[1] = x => x.Length > 8;
}
public void ItemIsExcludedFromResult()
{
var fileToExclude = new FileSystemVisitor().Search(Directory).Last();
var fileVisitor = new FileSystemVisitor(x => x.Equals(fileToExclude));
fileVisitor.FilteredItemFound += RemoveItemFromResult;
Assert.False(fileVisitor.Search(Directory).Contains(fileToExclude));
}
public void SearchDirectoryInnerEntities_ReturnAllEntities()
{
var fileSystemVisitor = new FileSystemVisitor(_fileSystem);
var entitiesCount = fileSystemVisitor.SearchDirectoryInnerEntities(_entryPath).Count();
Assert.Equal(4, entitiesCount);
}
public void SearchDirectoryInnerEntities_WithNameLengthMoreThat5Character_Return2Entity()
{
var fileSystemVisitor = new FileSystemVisitor(_fileSystem, (FileSystemInfoBase entityInfo) => entityInfo.Name.Length > 5);
var entitiesCount = fileSystemVisitor.SearchDirectoryInnerEntities(_entryPath).Count();
Assert.Equal(2, entitiesCount);
}
public void TestFakeDependency()
{
var x = new Mock <IFakeClass>();
x.Setup(l => l.ThrowException).Returns(true);
var fileSystemVisitor = new FileSystemVisitor(x.Object);
var result = fileSystemVisitor.GetFilesRecursive(new DirectoryInfo("")).ToList();
}
public void DirectoryNotFoundException_Exception_Expected()
{
//Arrange
var fileSystemVisitor = new FileSystemVisitor(_fileSystemMock.Object);
//act
fileSystemVisitor.StartSearch(RootPath).Wait();
}
private static void Subscribe(FileSystemVisitor visitor)
{
visitor.Start += Visitor_Start;
visitor.Stop += Visitor_Stop;
visitor.FileFinded += Visitor_FileFinded;
visitor.DirectoryFinded += Visitor_DirectoryFinded;
visitor.FilterDirectoryFinded += Visitor_FilterDirectoryFinded;
visitor.FilterFileFinded += Visitor_FilterFileFinded;
}
public void Search_UseNullINLambdaFilters_ShouldReturnAllFilesAndFolders()
{
// Arrange
var model = new FileSystemVisitor(TestFolderPath, null, null);
var outputNames = new List <string>
{
"3000x2000_990611_[www.ArtFile.ru].jpg",
"Animals___Cats_Red_Cat_on_an_orange_background_044688_.jpg",
"app.config",
"bbin",
"csrd_log - Copy (2).txt",
"csrd_log - Copy (3).txt",
"csrd_log - Copy (4).txt",
"csrd_log - Copy.txt",
"csrd_log.txt",
"FirstLayerFolder1",
"FirstLayerFolder2",
"FirstLayerFolder3",
"godnota.jpg",
"kot-kote-ryzhij-morda-usy.svg",
"log.txt",
"Microsoft.Practices.Unity.Configuration.dll",
"R2D2.bmp",
"SecondLayerFolder",
"SecondLayerFolder1",
"SecondLayerFolder2",
"Secret.xlsx",
"Test.docx",
"TextWorksheet.xlsx",
"ThirdLayerFolder",
"times.png",
"vocabulary_careers.doc",
};
var outputEvents = new List <string>
{
"The process has begun.",
"The files had found.",
"The directories had found.",
"The process is over",
};
var receivedEvents = new List <string>();
Subscribe(model, receivedEvents);
// Act
var result = model.Search();
// Assert
result.Should()
.BeEquivalentTo(outputNames);
receivedEvents.Should()
.BeEquivalentTo(outputEvents);
}
private static void Subscribe(FileSystemVisitor visitor)
{
visitor.Start += OutputVisitorMessages;
visitor.Finish += OutputVisitorMessages;
visitor.DirectorysFiltered += OutputVisitorMessages;
visitor.FilesFiltered += OutputVisitorMessages;
visitor.DirectorysFinded += OutputVisitorMessages;
visitor.FilesFinded += OutputVisitorMessages;
}
private void AddSubscribers(FileSystemVisitor fileSystemVisitor)
{
fileSystemVisitor.Start += FileVisitorHandler;
fileSystemVisitor.FileFinded += FileVisitorHandler;
fileSystemVisitor.DirectoryFinded += FileVisitorHandler;
fileSystemVisitor.Finish += FileVisitorHandler;
}
public void FSV_SearchByDefaultFilterRecursively_MustNotReturnsNullOnTrashInput()
{
FileSystemVisitor fsv = new FileSystemVisitor();
IEnumerable <FileSystemInfo> result = fsv.SearchByFilter(Guid.NewGuid().ToString(), isRecursive: true);
string stringResult = result.RepresentAsString();
Assert.NotNull(result);
Assert.NotNull(stringResult);
}
/// <summary>
/// Initialize a new instance of the <see cref="Listener"/> class.
/// </summary>
/// <param name="visitor">The <see cref="FileSystemVisitor"/> instance.</param>
/// <param name="countForCancel">The count filtered items for Cancel operation.</param>
/// <param name="countForExclude">The count filtered items for exclude directories and files from saving.</param>
public Listener(FileSystemVisitor visitor, int countForCancel, int countForExclude)
{
visitor.Start += StartHandler;
visitor.Finish += FinishHandler;
visitor.FoundItem += FoundHandler;
visitor.FilteredItem += FilteredHandler;
_countForCancel = countForCancel;
_countForExclude = countForExclude;
}
public void GetResultOfBypassingDirectories_NoFilter_ReturnsVisitedEntityIEnumerable()
{
var fileSystemVisitor = new FileSystemVisitor(_fileSystemEntitiesProvider);
var monitored = fileSystemVisitor.Monitor();
var actualResult = fileSystemVisitor.GetResultOfBypassingDirectories(_rootDirectoryPath).ToList();
Assert.NotEmpty(actualResult);
Assert.Equal(actualResult.Count, _filesAndDirectories.Count);
ShouldRaiseAllEventsExcept(monitored);
}
public void FinishEventTest()
{
var fileSystemVisitor = new FileSystemVisitor(_mockFileSystem);
var eventHandled = false;
fileSystemVisitor.Finish += (sender, args) => eventHandled = true;
var result = fileSystemVisitor.GetDirectoryContent(@"c:\").Count();
Assert.AreEqual(7, result);
Assert.AreEqual(true, eventHandled);
}
public void Search_NullDirectory_Exception()
{
// Arrange
var fsv = new FileSystemVisitor();
// Act
fsv.Search(null);
// Assert
// throw ArgumentNullException
}
public void SearchIsStopped()
{
var files = new FileSystemVisitor().Search(Directory);
var expectedLastItem = files.ToArray()[files.Count() / 2];
var fileVisitor = new FileSystemVisitor(x => x.Equals(expectedLastItem));
fileVisitor.FilteredItemFound += StopSearching;
var actualItems = fileVisitor.Search(Directory);
Assert.Less(actualItems.Count(), files.Count());
}
public void Search_InvalidDirectory_Exception(string rootDirectory)
{
// Arrange
var fsv = new FileSystemVisitor();
// Act
fsv.Search(rootDirectory);
// Assert
// throw DirectoryNotFoundException
}
public void Search_FilterOnlyFiles_ShouldReturnOnlyFiles()
{
// Arrange
var model = new FileSystemVisitor
{
SourcePath = TestFolderPath,
FilterPattern = FileSystemVisitor.ExcludeDirectoryFilter,
};
var outputNames = new List <string>
{
"3000x2000_990611_[www.ArtFile.ru].jpg",
"Animals___Cats_Red_Cat_on_an_orange_background_044688_.jpg",
"app.config",
"csrd_log - Copy (2).txt",
"csrd_log - Copy (3).txt",
"csrd_log - Copy (4).txt",
"csrd_log - Copy.txt",
"csrd_log.txt",
"godnota.jpg",
"kot-kote-ryzhij-morda-usy.svg",
"log.txt",
"Microsoft.Practices.Unity.Configuration.dll",
"R2D2.bmp",
"Secret.xlsx",
"Test.docx",
"TextWorksheet.xlsx",
"times.png",
"vocabulary_careers.doc",
};
var outputEvents = new List <string>
{
"The process has begun.",
"The files had found.",
"The directories had found.",
"Directories were excluded from the search.",
"The process is over",
};
var receivedEvents = new List <string>();
Subscribe(model, receivedEvents);
// Act
var result = model.Search();
// Assert
result.Should()
.BeEquivalentTo(outputNames);
receivedEvents.Should()
.BeEquivalentTo(outputEvents);
}
public void VisitDirectory_WhenNullFileSystemPassed_ThrowNullReferenceException()
{
// Arrange.
var nullVisitor = new FileSystemVisitor(null, null);
// Act.
void FsvPerform() => nullVisitor.PerformProcess(_baseDirectory).ToList();
// Assert.
Assert.Throws <NullReferenceException>(FsvPerform);
}
private static void Subscribe(FileSystemVisitor visitor, List <string> receivedEvents)
{
void AddToList(string message) => receivedEvents.Add(message);
visitor.Start += AddToList;
visitor.Finish += AddToList;
visitor.DirectorysFiltered += AddToList;
visitor.FilesFiltered += AddToList;
visitor.DirectorysFinded += AddToList;
visitor.FilesFinded += AddToList;
}
static void Main(string[] args)
{
Console.WriteLine($"ENTER PATH");
var enteredPath = Console.ReadLine();
var visitor = new FileSystemVisitor(new FileManager.Services.FileManager(path => path.ToLower().Contains("eng")));
var fileService = new ManagerSubscriber(visitor, path => path.Contains("12"), path => true, path => false);
visitor.Search($@"{enteredPath}");
Console.ReadKey();
}
