public async Task Load()
{
using (var testDirectory = new TestDirectory())
{
var directory = new Directory(testDirectory.FullPath, null, new TestItemFactory());
const string emptyDirectoryName = "EmptyDirectory";
var emptyDirectoryLastUpdate = new DateTime(2019, 2, 2, 15, 30, 20);
var emptyDirectoryPath = testDirectory.CreateDirectory(emptyDirectoryName, emptyDirectoryLastUpdate);
const string notEmptyDirectoryName = "NotEmptyDirectory";
var notEmptyDirectoryLastUpdate = new DateTime(2019, 4, 4, 16, 35, 25);
var notEmptyDirectoryPath = testDirectory.CreateDirectory(notEmptyDirectoryName);
const string file1Name = "File1";
var file1LastUpdate = new DateTime(2018, 3, 3, 12, 0, 30);
const string file2Name = "File2";
var file2LastUpdate = new DateTime(2019, 2, 3, 11, 5, 10);
TestDirectory.CreateFiles(notEmptyDirectoryPath, new Dictionary <string, DateTime>
{
{ file1Name, file1LastUpdate },
{ file2Name, file2LastUpdate }
});
// Только после добавления файлов в директорию, так как дата перетёрлась бы.
IODirectory.SetLastWriteTime(notEmptyDirectoryPath, notEmptyDirectoryLastUpdate);
const string rootFileName = "RootFile";
var rootFileLastUpdate = new DateTime(2019, 2, 5, 8, 5, 0);
testDirectory.CreateFiles(new Dictionary <string, DateTime> {
{ rootFileName, rootFileLastUpdate }
});
await directory.Load();
Assert.True(directory.IsLoaded);
Assert.Equal(2, directory.Items.Length); // Один файл и одна не пустая директория.
// Сначала идёт директория, а потом файл.
Assert.IsType <Directory>(directory.Items[0]);
Assert.IsType <TestFile>(directory.Items[1]);
Assert.Equal(notEmptyDirectoryName, directory.Items[0].Name);
Assert.Equal(notEmptyDirectoryPath, directory.Items[0].FullPath);
Assert.Equal(notEmptyDirectoryLastUpdate, directory.Items[0].LastUpdate);
Assert.True(((IDirectory)directory.Items[0]).IsLoaded);
Assert.Equal(2, ((IDirectory)directory.Items[0]).Items.Length);
var file1 = ((IDirectory)directory.Items[0]).Items[0];
Assert.Equal(file1Name, file1.Name);
Assert.Equal(file1LastUpdate, file1.LastUpdate);
var file2 = ((IDirectory)directory.Items[0]).Items[1];
Assert.Equal(file2Name, file2.Name);
Assert.Equal(file2LastUpdate, file2.LastUpdate);
Assert.Equal(rootFileName, directory.Items[1].Name);
Assert.Equal(rootFileLastUpdate, directory.Items[1].LastUpdate);
}
}
public async Task CopyTo()
{
using (var testDirectory = new TestDirectory())
{
var sourceDirectory = testDirectory.CreateDirectory("SorceDir");
var destinationDirectory = System.IO.Path.Combine(testDirectory.FullPath, "DestDir");
IItem destinationCopyDirectory = null;
string destinationCopyPath = null;
var directory = new Directory(sourceDirectory, null, new TestItemFactory());
directory.CopiedFromToEvent += (IItem destinationItem, string destinationPath) =>
{
destinationCopyDirectory = destinationItem;
destinationCopyPath = destinationPath;
};
await directory.CopyTo(destinationDirectory);
Assert.True(IODirectory.Exists(sourceDirectory));
Assert.True(IODirectory.Exists(destinationDirectory));
Assert.NotNull(destinationCopyDirectory);
Assert.Equal(destinationDirectory, destinationCopyDirectory.FullPath);
Assert.Equal(destinationDirectory, destinationCopyPath);
}
}
public async Task LoadWithExcludedExtensions(string[] excludedExtensions, byte loadedFilesCount)
{
var testSettingsStorage = new TestSettingsStorage();
using (var testDirectory = new TestDirectory())
{
var fileLastUpdate = DateTime.Now;
var leftDirectory = testDirectory.CreateDirectory("1");
TestDirectory.CreateFiles(leftDirectory, new Dictionary <string, DateTime>
{
{ "1.tiff", fileLastUpdate },
{ "2.tiff", fileLastUpdate },
{ "3.tiff", fileLastUpdate },
{ "4.jpg", fileLastUpdate },
{ "5.jpg", fileLastUpdate },
{ "6.png", fileLastUpdate }
});
var rightDirectory = testDirectory.CreateDirectory("2");
TestDirectory.CreateFiles(rightDirectory, new Dictionary <string, DateTime>
{
{ "1.tiff", fileLastUpdate },
{ "2.tiff", fileLastUpdate },
{ "3.tiff", fileLastUpdate },
{ "4.jpg", fileLastUpdate },
{ "5.jpg", fileLastUpdate },
{ "6.png", fileLastUpdate }
});
var settingsRow1 = new SettingsRow(leftDirectory, rightDirectory, true, excludedExtensions);
testSettingsStorage.SettingsRows = new[] { settingsRow1 };
var synchronizedDirectoriesManager = new SynchronizedDirectoriesManager(testSettingsStorage, new SynchronizedItemFactory(new ItemFactory()),
new SynchronizedItemsStatusAndCommandsUpdater(new SynchronizedItemMatcher()));
await synchronizedDirectoriesManager.Load();
Assert.Single(synchronizedDirectoriesManager.SynchronizedDirectories);
var synchronizedDirectory = synchronizedDirectoriesManager.SynchronizedDirectories.Single();
Assert.Equal(loadedFilesCount, synchronizedDirectory.LeftDirectory.Items.Length);
Assert.Equal(loadedFilesCount, synchronizedDirectory.RightDirectory.Items.Length);
}
}
public async Task Delete()
{
IItem deletedDirectory = null;
using (var testDirectory = new TestDirectory())
{
var sourceDirectory = testDirectory.CreateDirectory("SorceDir");
var directory = new Directory(sourceDirectory, null, new TestItemFactory());
directory.DeletedEvent += (IItem item) => { deletedDirectory = item; };
await directory.Delete();
Assert.Equal(directory, deletedDirectory);
Assert.False(IODirectory.Exists(sourceDirectory));
}
}
public void Constructor(string directoryName, string strLastWriteTime)
{
var lastWriteTime = DateTime.Parse(strLastWriteTime);
using (var testDirectory = new TestDirectory())
{
var directoryPath = testDirectory.CreateDirectory(directoryName, lastWriteTime);
var directory = new Directory(directoryPath, null, new TestItemFactory());
Assert.Equal(directoryName, directory.Name);
Assert.Equal(directoryPath, directory.FullPath);
Assert.Equal(lastWriteTime, directory.LastUpdate);
Assert.False(directory.IsLoaded);
Assert.Empty(directory.Items); // Загрузка не выполнялась, содержимого быть не должно.
}
}
public async Task DeleteWithError()
{
using (var testDirectory = new TestDirectory())
{
var sourceDirectory = testDirectory.CreateDirectory("SorceDir");
var directory = new Directory(sourceDirectory, null, new TestItemFactory());
string error = null;
directory.SyncErrorEvent += (string message) => { error = message; };
using (var stream = IO.File.Create(IO.Path.Combine(sourceDirectory, "1")))
await directory.Delete();
Assert.NotNull(error);
}
}
public async Task DeleteChildItem()
{
using (var testDirectory = new TestDirectory())
{
TestDirectory.CreateFiles(testDirectory.CreateDirectory("Child"), new Dictionary <string, DateTime>
{
{ "1", DateTime.Now }
});
var directory = new Directory(testDirectory.FullPath, null, new TestItemFactory());
await directory.Load();
await directory.Items[0].Delete();
Assert.Empty(directory.Items); // Дочерний элемент должен удаляться из коллекции.
}
}
public async Task Load()
{
var testSettingsStorage = new TestSettingsStorage();
ISynchronizedItems removedSynchronizedDirectories = null;
var loadedDirectories = new List <IDirectory>();
using (var testDirectory = new TestDirectory())
{
var settingsRow1 = new SettingsRow(testDirectory.CreateDirectory("1"), testDirectory.CreateDirectory("2"), true, null);
var settingsRow2 = new SettingsRow(testDirectory.CreateDirectory("3"), testDirectory.CreateDirectory("4"), false, null);
var settingsRow3 = new SettingsRow(testDirectory.CreateDirectory("5"), testDirectory.CreateDirectory("6"), true, new[] { "tiff" });
var settingsRow4 = new SettingsRow(testDirectory.CreateDirectory("7"), testDirectory.CreateDirectory("8"), true, new[] { "tiff" });
var settingsRow5 = new SettingsRow(testDirectory.CreateDirectory("9"), testDirectory.CreateDirectory("10"), true, null);
testSettingsStorage.SettingsRows = new[]
{
settingsRow1,
settingsRow2,
settingsRow3,
settingsRow4,
settingsRow5
};
var synchronizedDirectoriesManager = new SynchronizedDirectoriesManager(testSettingsStorage, new SynchronizedItemFactory(new ItemFactory()),
new SynchronizedItemsStatusAndCommandsUpdater(null));
await synchronizedDirectoriesManager.Load(); // Загрузка до изменения настроек.
var oldSynchronizedDirectory2 = synchronizedDirectoriesManager.SynchronizedDirectories[1];
var oldSynchronizedDirectory3 = synchronizedDirectoriesManager.SynchronizedDirectories[2];
var oldSynchronizedDirectory4 = synchronizedDirectoriesManager.SynchronizedDirectories[3];
foreach (var synchronizedDirectory in synchronizedDirectoriesManager.SynchronizedDirectories)
{
synchronizedDirectory.LeftDirectory.LoadedDirectoryEvent += (IDirectory loadedDirecory) => { loadedDirectories.Add(loadedDirecory); };
synchronizedDirectory.RightDirectory.LoadedDirectoryEvent += (IDirectory loadedDirecory) => { loadedDirectories.Add(loadedDirecory); };
}
synchronizedDirectoriesManager.RemoveSynchronizedDirectoriesEvent += (ISynchronizedItems synchronizedDirectories) =>
{
removedSynchronizedDirectories = synchronizedDirectories;
};
settingsRow1.IsUsed = false; // Эта строка при загрузке должна будет удалиться.
settingsRow2.IsUsed = true; // Эта строка при загрузке должна будет добавиться.
// Эта строка при загрузке должна будет инициализировать новую из-за изменения коллекции ExcludedExtensions.
settingsRow3.ExcludedExtensions = new[] { "jpg" };
await synchronizedDirectoriesManager.Load(); // Загрузка после изменения настроек.
Assert.Equal(4, synchronizedDirectoriesManager.SynchronizedDirectories.Length);
// Проверим удалённую директорию.
Assert.NotNull(removedSynchronizedDirectories);
Assert.Equal(settingsRow1.LeftDirectory.DirectoryPath, removedSynchronizedDirectories.LeftDirectory.FullPath);
Assert.Equal(settingsRow1.RightDirectory.DirectoryPath, removedSynchronizedDirectories.RightDirectory.FullPath);
// Записи на синхронизируемые директории должны оставаться прежними.
Assert.Equal(oldSynchronizedDirectory2, synchronizedDirectoriesManager.SynchronizedDirectories[0]);
Assert.Equal(oldSynchronizedDirectory3, synchronizedDirectoriesManager.SynchronizedDirectories[1]);
Assert.Equal(oldSynchronizedDirectory4, synchronizedDirectoriesManager.SynchronizedDirectories[2]);
// Лишь две директории одной записи должны были обновиться.
Assert.Equal(2, loadedDirectories.Count);
Assert.Contains(oldSynchronizedDirectory2.LeftDirectory, loadedDirectories);
Assert.Contains(oldSynchronizedDirectory2.RightDirectory, loadedDirectories);
// И массивы исключаемых из рассмотрения расширений файлов тоже должны были обновиться.
Assert.Equal(settingsRow3.ExcludedExtensions, oldSynchronizedDirectory2.LeftDirectory.ExcludedExtensions);
Assert.Equal(settingsRow3.ExcludedExtensions, oldSynchronizedDirectory2.RightDirectory.ExcludedExtensions);
// Эта запись на синхронизируемую директорию должна быть добавленной из-за включения строки настройки.
var synchronizedDirectory3 = synchronizedDirectoriesManager.SynchronizedDirectories[3];
Assert.Equal(settingsRow2.LeftDirectory.DirectoryPath, synchronizedDirectory3.LeftDirectory.FullPath);
Assert.Equal(settingsRow2.RightDirectory.DirectoryPath, synchronizedDirectory3.RightDirectory.FullPath);
}
}
