public void CreateRowViewModel() { const string file1Name = "File1"; const string file2Name = "File2"; using (var leftDirectory = new Infrastructure.TestDirectory()) using (var rightDirectory = new Infrastructure.TestDirectory()) { leftDirectory.CreateFiles(new Dictionary <string, DateTime> { { file1Name, DateTime.Now }, { file2Name, DateTime.Now } }); rightDirectory.CreateFiles(new Dictionary <string, DateTime> { { file1Name, DateTime.Now }, { file2Name, DateTime.Now } }); bool useAddRowEvent = false; var synchronizedDirectories = GetSynchronizedDirectories(leftDirectory.FullPath, rightDirectory.FullPath); var factory = new RowViewModelFactory(); factory.AddRowEvent += (IRowViewModel parent, IRowViewModel child) => { useAddRowEvent = true; }; var rowViewModel = factory.CreateRowViewModel(synchronizedDirectories); // Пока не выполнялась загрузка, события добавления записи происходить не должны. Assert.False(useAddRowEvent); Assert.Empty(rowViewModel.ChildRows); } }
public async Task DeleteDirectoryRowEvent() { IRowViewModel deleteRowEventParent = null, deleteRowEventChild = null; using (var testDirectory = new Infrastructure.TestDirectory()) { Infrastructure.TestDirectory.CreateFiles(testDirectory.CreateDirectory("Dir"), new Dictionary <string, DateTime> { { "File", DateTime.Now } }); var synchronizedDirectories = new TestSynchronizedItems(new Directory(testDirectory.FullPath, null, new ItemFactory())); var factory = new RowViewModelFactory(); factory.DeleteRowEvent += (IRowViewModel parent, IRowViewModel child) => { deleteRowEventParent = parent; deleteRowEventChild = child; }; var rowViewModel = factory.CreateRowViewModel(synchronizedDirectories); await synchronizedDirectories.Load(); var level1Child = synchronizedDirectories.ChildItems[0]; var level2Child = level1Child.ChildItems[0]; ((TestSynchronizedItems)level1Child).IsDeleted(); Assert.NotNull(deleteRowEventParent); Assert.NotNull(deleteRowEventChild); Assert.Equal(synchronizedDirectories.LeftItem.Name, deleteRowEventParent.LeftItem.Name); Assert.Equal(level1Child.LeftItem.Name, deleteRowEventChild.LeftItem.Name); } }
public async void LoadChildItems_RefreshStatusAndCommandsFromChilds() { const string dir1Name = "Dir1"; const string dir2Name = "Dir2"; const string file1Name = "File1"; const string file2Name = "File2"; const string file3Name = "File3"; var updateDate = DateTime.Now; using (var leftDirectory = new Infrastructure.TestDirectory()) using (var rightDirectory = new Infrastructure.TestDirectory()) { Infrastructure.TestDirectory.CreateFiles(leftDirectory.CreateDirectory(dir1Name), new Dictionary <string, DateTime> { { file1Name, updateDate } }); Infrastructure.TestDirectory.CreateFiles(leftDirectory.CreateDirectory(dir2Name), new Dictionary <string, DateTime> { { file2Name, updateDate }, { file3Name, updateDate } }); Infrastructure.TestDirectory.CreateFiles(rightDirectory.CreateDirectory(dir1Name), new Dictionary <string, DateTime> { { file1Name, updateDate } }); Infrastructure.TestDirectory.CreateFiles(rightDirectory.CreateDirectory(dir2Name), new Dictionary <string, DateTime> { { file2Name, updateDate }, { file3Name, updateDate } }); var settingsRow = new TestSettingsRow { LeftDirectory = new SettingsDirectory(leftDirectory.FullPath), RightDirectory = new SettingsDirectory(rightDirectory.FullPath) }; var testSynchronizedItemsStatusAndCommandsUpdater = new TestSynchronizedItemsStatusAndCommandsUpdater(); var synchronizedItems = new SynchronizedItems(settingsRow, new SynchronizedItemFactory(new ItemFactory()), testSynchronizedItemsStatusAndCommandsUpdater); await Task.WhenAll(synchronizedItems.LeftDirectory.Load(), synchronizedItems.RightDirectory.Load()); synchronizedItems.LoadChildItems(); var refreshedLeftItemSynchronizedItemsList = testSynchronizedItemsStatusAndCommandsUpdater.RefreshedLeftItemSynchronizedItemsList; var refreshedRightItemSynchronizedItemsList = testSynchronizedItemsStatusAndCommandsUpdater.RefreshedRightItemSynchronizedItemsList; // Каждая директория должна была обновить свои статусы и команды. Assert.Equal(3, refreshedLeftItemSynchronizedItemsList.Count); Assert.Equal(3, refreshedRightItemSynchronizedItemsList.Count); // В таком порядке должны были обновляться статусы элементов. Assert.Equal(refreshedLeftItemSynchronizedItemsList[0], synchronizedItems.ChildItems[0]); Assert.Equal(refreshedLeftItemSynchronizedItemsList[1], synchronizedItems.ChildItems[1]); Assert.Equal(refreshedLeftItemSynchronizedItemsList[2], synchronizedItems); Assert.Equal(refreshedRightItemSynchronizedItemsList[0], synchronizedItems.ChildItems[0]); Assert.Equal(refreshedRightItemSynchronizedItemsList[1], synchronizedItems.ChildItems[1]); Assert.Equal(refreshedRightItemSynchronizedItemsList[2], synchronizedItems); } }
public void CopyTo() { using (var testDirectory = new Infrastructure.TestDirectory()) { var sourceFile = Path.Combine(testDirectory.FullPath, Guid.NewGuid().ToString()); var destinationFile = Path.Combine(testDirectory.FullPath, Guid.NewGuid().ToString()); var fileText = Guid.NewGuid().ToString(); File.WriteAllText(sourceFile, fileText); IItem destinationCopyFile = null; string destinationCopyPath = null; var file = new DirectorySync.Models.File(sourceFile); file.CopiedFromToEvent += (IItem destinationItem, string destinationPath) => { destinationCopyFile = destinationItem; destinationCopyPath = destinationPath; }; file.CopyTo(destinationFile).Wait(); Assert.True(File.Exists(sourceFile)); Assert.True(File.Exists(destinationFile)); Assert.Equal(fileText, File.ReadAllText(destinationFile)); Assert.NotNull(destinationCopyFile); Assert.Equal(destinationFile, destinationCopyFile.FullPath); Assert.Equal(destinationFile, destinationCopyPath); } }
public async Task RemoveEmptySynchronizedDirectoriesAfterDeleteItem() { const string directoryName = "Dir1"; using (var leftDirectory = new Infrastructure.TestDirectory()) using (var rightDirectory = new Infrastructure.TestDirectory()) { Infrastructure.TestDirectory.CreateDirectory(leftDirectory.CreateDirectory(directoryName), directoryName); Infrastructure.TestDirectory.CreateFiles( Infrastructure.TestDirectory.CreateDirectory(rightDirectory.CreateDirectory(directoryName), directoryName), new Dictionary <string, DateTime> { { "File1", DateTime.Now } }); var synchronizedDirectories = GetSynchronizedDirectories(leftDirectory.FullPath, rightDirectory.FullPath); await synchronizedDirectories.Load(); await synchronizedDirectories.LeftItem.SyncCommand.Process(); // Эта команда должна выполнить удаление файла справа. // Корневые элементы должны по прежнему остваться директориями. Assert.NotNull(synchronizedDirectories.LeftDirectory); Assert.NotNull(synchronizedDirectories.RightDirectory); await Task.Delay(20); // Подождём, чтобы успела обновиться коллекция дочерних элементов. // Но синхронизируемых элементов в них быть не должно, так как никаких файлов не осталось. Assert.Empty(synchronizedDirectories.ChildItems); } }
public async Task SynchronizedDirectoriesAfterDeleteItem_ThroughRightChild(string childItemName) { const string directoryName = "Dir1"; const string fileName = "File1"; var fileUpdateDate = DateTime.Now; using (var leftDirectory = new Infrastructure.TestDirectory()) using (var rightDirectory = new Infrastructure.TestDirectory()) { Infrastructure.TestDirectory.CreateFiles(leftDirectory.CreateDirectory(directoryName), new Dictionary <string, DateTime> { { fileName, fileUpdateDate }, { "File2", fileUpdateDate } }); Infrastructure.TestDirectory.CreateFiles(rightDirectory.CreateDirectory(directoryName), new Dictionary <string, DateTime> { { fileName, fileUpdateDate } }); var synchronizedDirectories = GetSynchronizedDirectories(leftDirectory.FullPath, rightDirectory.FullPath); await synchronizedDirectories.Load(); // Эта команда должна выполнить удаление файла "File2" слева. await GetChildItemByName(synchronizedDirectories, false, childItemName).SyncCommand.Process(); // По прежнему должна остваться одна дочерняя запись на директории. Assert.Single(synchronizedDirectories.ChildItems); await Task.Delay(20); // Чтобы успели обновиться статусы и команды. // Дочерние элементы теперь должны быть идентичные и команды синхронизации им не нужны. var childItem = synchronizedDirectories.ChildItems[0]; Assert.Equal(ItemStatusEnum.Equally, childItem.LeftItem.Status.StatusEnum); Assert.Equal(ItemStatusEnum.Equally, childItem.RightItem.Status.StatusEnum); Assert.Null(childItem.LeftItem.SyncCommand.CommandAction); Assert.Null(childItem.RightItem.SyncCommand.CommandAction); // И в ней одна запись на оставшуюся пару файлов. Assert.Single(childItem.ChildItems); // Эти тоже теперь должны быть идентичные и команды синхронизации им не нужны. childItem = childItem.ChildItems[0]; Assert.Equal(ItemStatusEnum.Equally, childItem.LeftItem.Status.StatusEnum); Assert.Equal(ItemStatusEnum.Equally, childItem.RightItem.Status.StatusEnum); Assert.Null(childItem.LeftItem.SyncCommand.CommandAction); Assert.Null(childItem.RightItem.SyncCommand.CommandAction); // И корневые элементы теперь должны быть идентичные и команды синхронизации им тоже не нужны. Assert.Equal(ItemStatusEnum.Equally, synchronizedDirectories.LeftItem.Status.StatusEnum); Assert.Equal(ItemStatusEnum.Equally, synchronizedDirectories.RightItem.Status.StatusEnum); Assert.Null(synchronizedDirectories.LeftItem.SyncCommand.CommandAction); Assert.Null(synchronizedDirectories.RightItem.SyncCommand.CommandAction); } }
public async Task LoadDirectoryAndFile() { const string directoryAndFileName = "Item"; using (var leftDirectory = new Infrastructure.TestDirectory()) using (var rightDirectory = new Infrastructure.TestDirectory()) { var updateDate = DateTime.Now; leftDirectory.CreateFiles(new Dictionary <string, DateTime> { { directoryAndFileName, updateDate } }); // В директорию надо поместить хотя бы один файл, чтобы она была видна. Infrastructure.TestDirectory.CreateFiles(rightDirectory.CreateDirectory(directoryAndFileName), new Dictionary <string, DateTime> { { "1", updateDate } }); var settingsRow = new TestSettingsRow { LeftDirectory = new SettingsDirectory(leftDirectory.FullPath), RightDirectory = new SettingsDirectory(rightDirectory.FullPath) }; var testSynchronizedItemsStatusAndCommandsUpdater = new TestSynchronizedItemsStatusAndCommandsUpdater(); var synchronizedDirectories = new SynchronizedItems(settingsRow, new SynchronizedItemFactory(new ItemFactory()), testSynchronizedItemsStatusAndCommandsUpdater); await synchronizedDirectories.Load(); Assert.Equal(2, synchronizedDirectories.ChildItemsCount); // Одна модель на директории, одна модель на файлы. // Сначала директория, потом файл. var childDirectories1 = synchronizedDirectories.ChildItems[0]; Assert.Equal(directoryAndFileName, childDirectories1.LeftItem.Name); Assert.Equal(directoryAndFileName, childDirectories1.RightItem.Name); Assert.NotNull(childDirectories1.RightItem.Directory); Assert.True(childDirectories1.RightItem.IsDirectory); // Даже если элемент отсутствует, а присутствующий является директорией, то и этот должен быть директорией. Assert.Null(childDirectories1.LeftItem.Directory); Assert.True(childDirectories1.LeftItem.IsDirectory); var childDirectories2 = synchronizedDirectories.ChildItems[1]; Assert.Equal(directoryAndFileName, childDirectories2.LeftItem.Name); Assert.Equal(directoryAndFileName, childDirectories2.RightItem.Name); Assert.Null(childDirectories2.LeftItem.Directory); Assert.False(childDirectories2.LeftItem.IsDirectory); Assert.Null(childDirectories2.RightItem.Directory); Assert.False(childDirectories2.RightItem.IsDirectory); } }
public void DeleteWithError() { using (var testDirectory = new Infrastructure.TestDirectory()) { var sourceFile = Path.Combine(testDirectory.FullPath, Guid.NewGuid().ToString()); File.WriteAllBytes(sourceFile, new byte[0]); var file = new DirectorySync.Models.File(sourceFile); string error = null; file.SyncErrorEvent += (string message) => { error = message; }; using (var stream = File.Open(sourceFile, FileMode.Open)) file.Delete().Wait(); Assert.NotNull(error); } }
public async Task DirectoriesIsLoadedEvent() { List <ISynchronizedItems> loadedSynchronizedDirectoriesList = new List <ISynchronizedItems>(); using (var leftDirectory = new Infrastructure.TestDirectory()) using (var rightDirectory = new Infrastructure.TestDirectory()) { var synchronizedDirectories = GetSynchronizedDirectories(leftDirectory.FullPath, rightDirectory.FullPath); synchronizedDirectories.DirectoriesIsLoadedEvent += (ISynchronizedItems loadedSynchronizedItems) => { loadedSynchronizedDirectoriesList.Add(loadedSynchronizedItems); }; await synchronizedDirectories.Load(); Assert.Single(loadedSynchronizedDirectoriesList); Assert.Equal(synchronizedDirectories, loadedSynchronizedDirectoriesList[0]); } }
public async Task LoadDirectories_OneEmptyDirectory() { const string directoryName = "Directory"; const string fileName = "File"; var newerDate = new DateTime(2019, 1, 1); var olderDate = new DateTime(2018, 1, 1); using (var leftDirectory = new Infrastructure.TestDirectory()) using (var rightDirectory = new Infrastructure.TestDirectory()) { var childLeftDirectoryPath = leftDirectory.CreateDirectory(directoryName, newerDate); Infrastructure.TestDirectory.CreateFiles(childLeftDirectoryPath, new Dictionary <string, DateTime> { { fileName, DateTime.Now } }); rightDirectory.CreateDirectory(directoryName, olderDate); var settingsRow = new TestSettingsRow { LeftDirectory = new SettingsDirectory(leftDirectory.FullPath), RightDirectory = new SettingsDirectory(rightDirectory.FullPath) }; var testSynchronizedItemsStatusAndCommandsUpdater = new TestSynchronizedItemsStatusAndCommandsUpdater(); var synchronizedDirectories = new SynchronizedItems(settingsRow, new SynchronizedItemFactory(new ItemFactory()), testSynchronizedItemsStatusAndCommandsUpdater); await synchronizedDirectories.Load(); Assert.Single(synchronizedDirectories.ChildItems); var childDirectories = synchronizedDirectories.ChildItems[0]; Assert.Equal(directoryName, childDirectories.LeftItem.Name); Assert.Equal(directoryName, childDirectories.RightItem.Name); Assert.NotNull(childDirectories.LeftItem.Directory); // Справа реально директории нет, потому что пустые директории не учитываются, но элемент помечен как директория. Assert.Null(childDirectories.RightItem.Directory); Assert.True(childDirectories.RightItem.IsDirectory); Assert.Empty(childDirectories.ChildItems); } }
public async Task Load_RefreshStatusAndCommandsFromChilds() { const string directoryName = "Directory"; const string fileName = "File"; var updateDate = DateTime.Now; using (var leftDirectory = new Infrastructure.TestDirectory()) using (var rightDirectory = new Infrastructure.TestDirectory()) { var childLeftDirectoryPath = leftDirectory.CreateDirectory(directoryName, updateDate); var childRightDirectoryPath = rightDirectory.CreateDirectory(directoryName, updateDate); Infrastructure.TestDirectory.CreateFiles(childLeftDirectoryPath, new Dictionary <string, DateTime> { { fileName, updateDate } }); Infrastructure.TestDirectory.CreateFiles(childRightDirectoryPath, new Dictionary <string, DateTime> { { fileName, updateDate } }); var settingsRow = new TestSettingsRow { LeftDirectory = new SettingsDirectory(leftDirectory.FullPath), RightDirectory = new SettingsDirectory(rightDirectory.FullPath) }; var testSynchronizedItemsStatusAndCommandsUpdater = new TestSynchronizedItemsStatusAndCommandsUpdater(); var synchronizedDirectories = new SynchronizedItems(settingsRow, new SynchronizedItemFactory(new ItemFactory()), testSynchronizedItemsStatusAndCommandsUpdater); await synchronizedDirectories.Load(); Assert.Single(synchronizedDirectories.ChildItems); var childDirectories = synchronizedDirectories.ChildItems[0]; var refreshedLeftItemSynchronizedItemsList = testSynchronizedItemsStatusAndCommandsUpdater.RefreshedLeftItemSynchronizedItemsList; var refreshedRightItemSynchronizedItemsList = testSynchronizedItemsStatusAndCommandsUpdater.RefreshedRightItemSynchronizedItemsList; Assert.Equal(2, refreshedLeftItemSynchronizedItemsList.Count); Assert.Equal(2, refreshedRightItemSynchronizedItemsList.Count); Assert.Equal(childDirectories, refreshedLeftItemSynchronizedItemsList[0]); Assert.Equal(childDirectories, refreshedRightItemSynchronizedItemsList[0]); Assert.Equal(synchronizedDirectories, refreshedLeftItemSynchronizedItemsList[1]); Assert.Equal(synchronizedDirectories, refreshedRightItemSynchronizedItemsList[1]); } }
public void Delete(bool isReadOnly) { IItem deletedFile = null; using (var testDirectory = new Infrastructure.TestDirectory()) { var sourceFile = Path.Combine(testDirectory.FullPath, Guid.NewGuid().ToString()); File.WriteAllBytes(sourceFile, new byte[0]); new FileInfo(sourceFile).IsReadOnly = isReadOnly; var file = new DirectorySync.Models.File(sourceFile); file.DeletedEvent += (IItem item) => { deletedFile = item; }; file.Delete().Wait(); Assert.Equal(file, deletedFile); Assert.False(File.Exists(sourceFile)); } }
public void CopyToWithError() { using (var testDirectory = new Infrastructure.TestDirectory()) { var sourceFile = Path.Combine(testDirectory.FullPath, Guid.NewGuid().ToString()); var destinationFile = Path.Combine(testDirectory.FullPath, Guid.NewGuid().ToString()); var fileText = Guid.NewGuid().ToString(); File.WriteAllText(sourceFile, fileText); var file = new DirectorySync.Models.File(sourceFile); string error = null; file.SyncErrorEvent += (string message) => { error = message; }; using (var stream = File.Create(destinationFile)) file.CopyTo(destinationFile).Wait(); Assert.NotNull(error); } }
public async Task CreateRowViewModel_Tree() { const string name1 = "1"; const string name2 = "2"; byte useAddRowsCount = 0; using (var leftDirectory = new Infrastructure.TestDirectory()) using (var rightDirectory = new Infrastructure.TestDirectory()) { Infrastructure.TestDirectory.CreateFiles(leftDirectory.CreateDirectory(name1), new Dictionary <string, DateTime> { { name1, DateTime.Now } }); Infrastructure.TestDirectory.CreateFiles(rightDirectory.CreateDirectory(name1), new Dictionary <string, DateTime> { { name1, DateTime.Now } }); Infrastructure.TestDirectory.CreateFiles(leftDirectory.CreateDirectory(name2), new Dictionary <string, DateTime> { { name1, DateTime.Now } }); Infrastructure.TestDirectory.CreateFiles(rightDirectory.CreateDirectory(name2), new Dictionary <string, DateTime> { { name1, DateTime.Now } }); var synchronizedDirectories = GetSynchronizedDirectories(leftDirectory.FullPath, rightDirectory.FullPath); var factory = new RowViewModelFactory(); factory.AddRowEvent += (IRowViewModel parent, IRowViewModel child) => { useAddRowsCount++; }; var rowViewModel = factory.CreateRowViewModel(synchronizedDirectories); await synchronizedDirectories.Load(); Assert.Equal(4, useAddRowsCount); // Две директории, в каждой директории по одному файлу. Assert.Empty(rowViewModel.ChildRows); // А записей не прибавилось, потому что фабрика их не прибавляет. } }
public async Task AddCommandsAfterSyncProcess() { const string directory1Name = "Dir1"; const string directory2Name = "Dir2"; const string file1Name = "File1"; var updateDate = DateTime.Now; using (var leftDirectory = new Infrastructure.TestDirectory()) using (var rightDirectory = new Infrastructure.TestDirectory()) { leftDirectory.CreateDirectory(directory1Name); Infrastructure.TestDirectory.CreateFiles(rightDirectory.CreateDirectory(directory1Name), new Dictionary <string, DateTime> { { file1Name, updateDate } }); Infrastructure.TestDirectory.CreateFiles(leftDirectory.CreateDirectory(directory2Name), new Dictionary <string, DateTime> { { file1Name, updateDate }, { "File2", updateDate } }); Infrastructure.TestDirectory.CreateFiles(rightDirectory.CreateDirectory(directory2Name), new Dictionary <string, DateTime> { { file1Name, updateDate } }); var synchronizedDirectories = GetSynchronizedDirectories(leftDirectory.FullPath, rightDirectory.FullPath); await synchronizedDirectories.Load(); // После того, как Dir2 слева начнёт соответствовать Dir2 справа, // у корневой строки должны появиться команды для синхронизации Dir1. await synchronizedDirectories.ChildItems[1].LeftItem.SyncCommand.Process(); await Task.Delay(20); // Чтобы успели обновиться статусы и команды. Assert.NotNull(synchronizedDirectories.LeftItem.SyncCommand.CommandAction); Assert.NotNull(synchronizedDirectories.RightItem.SyncCommand.CommandAction); } }
public async Task LoadFiles() { const string file1Name = "File1"; const string file2Name = "File2"; const string file3Name = "File3"; var updateFileDate = DateTime.Now; var filesDirectoinaries = new Dictionary <string, DateTime> { { file1Name, updateFileDate }, { file2Name, updateFileDate }, { file3Name, updateFileDate } }; using (var leftDirectory = new Infrastructure.TestDirectory()) using (var rightDirectory = new Infrastructure.TestDirectory()) { leftDirectory.CreateFiles(filesDirectoinaries); rightDirectory.CreateFiles(filesDirectoinaries); var settingsRow = new TestSettingsRow { LeftDirectory = new SettingsDirectory(leftDirectory.FullPath), RightDirectory = new SettingsDirectory(rightDirectory.FullPath) }; var testSynchronizedItemsStatusAndCommandsUpdater = new TestSynchronizedItemsStatusAndCommandsUpdater(); var synchronizedDirectories = new SynchronizedItems(settingsRow, new SynchronizedItemFactory(new ItemFactory()), testSynchronizedItemsStatusAndCommandsUpdater); await synchronizedDirectories.Load(); Assert.Equal(3, synchronizedDirectories.ChildItemsCount); var directories = synchronizedDirectories.ChildItems[0]; Assert.Equal(file1Name, directories.LeftItem.Name); Assert.Equal(file1Name, directories.RightItem.Name); // Это файлы. Assert.False(directories.LeftItem.IsDirectory); Assert.Null(directories.LeftItem.Directory); Assert.False(directories.RightItem.IsDirectory); Assert.Null(directories.RightItem.Directory); directories = synchronizedDirectories.ChildItems[1]; Assert.Equal(file2Name, directories.LeftItem.Name); Assert.Equal(file2Name, directories.RightItem.Name); // Это файлы. Assert.False(directories.LeftItem.IsDirectory); Assert.Null(directories.LeftItem.Directory); Assert.False(directories.RightItem.IsDirectory); Assert.Null(directories.RightItem.Directory); directories = synchronizedDirectories.ChildItems[2]; Assert.Equal(file3Name, directories.LeftItem.Name); Assert.Equal(file3Name, directories.RightItem.Name); // Это файлы. Assert.False(directories.LeftItem.IsDirectory); Assert.Null(directories.LeftItem.Directory); Assert.False(directories.RightItem.IsDirectory); Assert.Null(directories.RightItem.Directory); } }
public async Task InProcess_SyncCommand(bool left) { using (var leftDirectory = new Infrastructure.TestDirectory()) using (var rightDirectory = new Infrastructure.TestDirectory()) { Infrastructure.TestDirectory.CreateDirectory(leftDirectory.CreateDirectory("Dir1"), "Dir2"); Infrastructure.TestDirectory.CreateDirectory(rightDirectory.CreateDirectory("Dir1"), "Dir2"); leftDirectory.CreateDirectory("Dir3"); rightDirectory.CreateDirectory("Dir3"); var containerBuilder = new ContainerBuilder(); containerBuilder.RegisterModule <TestAutofacRegisterModule>(); containerBuilder.RegisterType <SettingsRow>().As <ISettingsRow>(); containerBuilder.RegisterType <SynchronizedItems>().As <ISynchronizedItems>(); using (var fake = new AutoFake(builder: containerBuilder)) { var fakeItemFactory = A.Fake <IItemFactory>(); A.CallTo(() => fakeItemFactory.CreateDirectory(A <string> .Ignored, A <string[]> .Ignored)) .ReturnsLazily((string directoryPath, string[] excludedExtensions) => { return(new TestDirectory(directoryPath, fakeItemFactory, 1)); }); var fakeSettingsRow = A.Fake <ISettingsRow>(); A.CallTo(() => fakeSettingsRow.LeftDirectory).Returns(new SettingsDirectory(leftDirectory.FullPath)); A.CallTo(() => fakeSettingsRow.RightDirectory).Returns(new SettingsDirectory(rightDirectory.FullPath)); var fakeSynchronizedItemsStatusAndCommandsUpdater = A.Fake <ISynchronizedItemsStatusAndCommandsUpdater>(); A.CallTo(() => fakeSynchronizedItemsStatusAndCommandsUpdater .UpdateStatusesAndCommands(A <ISynchronizedItem> .Ignored, A <ISynchronizedItem> .Ignored)) .Invokes((ISynchronizedItem item1, ISynchronizedItem item2) => { item1.UpdateStatus(ItemStatusEnum.Equally); item2.UpdateStatus(ItemStatusEnum.Equally); }); fake.Provide(fakeSettingsRow); fake.Provide(fakeItemFactory); fake.Provide(fakeSynchronizedItemsStatusAndCommandsUpdater); var synchronizedItems = fake.Resolve <ISynchronizedItems>(); await synchronizedItems.Load(); // Загрузим, чтобы построилось дерево элементов. // А теперь запустим синхронизацию одного из элементов и проверим изменение признака InProcess. var childLevel1SynchronizedItems1 = synchronizedItems.ChildItems[0]; var processItem = left ? childLevel1SynchronizedItems1.LeftItem : childLevel1SynchronizedItems1.RightItem; processItem.SyncCommand.SetCommandAction(() => Task.Delay(4)); var syncTask = Task.Run(() => processItem.SyncCommand.Process()); await Task.Delay(2); // Чтобы признаки успели поменять значения. Assert.True(childLevel1SynchronizedItems1.InProcess); Assert.True(synchronizedItems.InProcess); // И процесс родителя должен обозначиться. Assert.True(childLevel1SynchronizedItems1.ChildItems[0].InProcess); // И процесс дочерних элементом. Assert.False(synchronizedItems.ChildItems[1].InProcess); // А эти элементы не при чём. syncTask.Wait(); // Ждём, пока завершится синхронизация. // А теперь всё обратно в false. Assert.False(childLevel1SynchronizedItems1.InProcess); Assert.False(synchronizedItems.InProcess); Assert.False(childLevel1SynchronizedItems1.ChildItems[0].InProcess); } } }