public void Execute_withADeleteCommand_shouldMakeTheCorrectCallToTheMegaNzClient()
{
// Arrange
var deleteCommand = new DeleteFileCommand
{
PathToDelete = "\\folder1\\file1.jpeg",
LastModifiedDate = new DateTime(2016, 1, 1, 0, 0, 0)
};
var commandList = new[] { deleteCommand };
// Remote items
// Root in the remote file structure
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
mockMegaNzNodeForRemoteRoot.SetupGet(m => m.Id).Returns("0");
mockMegaNzNodeForRemoteRoot.SetupGet(m => m.Name).Returns("\\");
mockMegaNzNodeForRemoteRoot.SetupGet(m => m.Type).Returns(NodeType.Root);
var megaNzItemRemoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, "\\", ItemType.Folder, "\\", 0);
// Folder1 in the remote file structure
var mockMegaNzNodeForRemoteFolder1 = new Mock <INode>(MockBehavior.Strict);
mockMegaNzNodeForRemoteFolder1.SetupGet(m => m.Id).Returns("1");
mockMegaNzNodeForRemoteFolder1.SetupGet(m => m.Name).Returns("folder1");
mockMegaNzNodeForRemoteFolder1.SetupGet(m => m.ParentId).Returns("0");
mockMegaNzNodeForRemoteFolder1.SetupGet(m => m.Type).Returns(NodeType.Directory);
var megaNzItemForRemoteFolder1 = new MegaNzItem(mockMegaNzNodeForRemoteFolder1.Object, "\\folder1", ItemType.Folder, "\\folder1", 0);
// File1.jpeg in the remote file structure
var mockMegaNzNodeForRemoteFile1 = new Mock <INode>(MockBehavior.Strict);
mockMegaNzNodeForRemoteFile1.SetupGet(m => m.Id).Returns("2");
mockMegaNzNodeForRemoteFile1.SetupGet(m => m.Name).Returns("file1.jpeg");
mockMegaNzNodeForRemoteFile1.SetupGet(m => m.ParentId).Returns("1");
mockMegaNzNodeForRemoteFile1.SetupGet(m => m.Type).Returns(NodeType.File);
var megaNzItemForRemoteFile1 = new MegaNzItem(mockMegaNzNodeForRemoteFile1.Object, "\\folder1\\file1.jpeg", ItemType.File, "\\folder1\\file1.jpeg", 0);
var remoteItems = new[] {
megaNzItemRemoteRoot,
megaNzItemForRemoteFolder1,
megaNzItemForRemoteFile1
};
var megaNzItemCollection = new MegaNzItemCollection(remoteItems);
var mockMegaApiClient = new Mock <IMegaApiClient>(MockBehavior.Strict);
mockMegaApiClient.Setup(m => m.Delete(mockMegaNzNodeForRemoteFile1.Object, true)).Verifiable();
var mockFileManager = new Mock <IFileManager>(MockBehavior.Strict);
var mockProgressNotifier = new Mock <IProgress <double> >(MockBehavior.Strict);
// Act
var commandExecutor = new CommandExecutor(mockMegaApiClient.Object, _mockLogger.Object);
commandExecutor.Execute(commandList, megaNzItemCollection, mockFileManager.Object, mockProgressNotifier.Object);
mockMegaApiClient.VerifyAll();
}
public MegaNzItem Add(INode node)
{
var newItem = new MegaNzItem(node, _nodeByMegaNzNodeId);
_collection.Add(newItem);
_nodeByPath[newItem.Path] = node;
_nodeByMegaNzNodeId[newItem.MegaNzNode.Id] = node;
return(newItem);
}
public void Constructor_usingINodeOfTypeFile_shouldParseTheCorrectLastModificationDatetime()
{
// We need a structure like this:
// root
// +--> folder1
// +--> folder2
// +--> file1
var folder1 = new MegaNzNodeMock
{
Id = "2",
Name = "folder1",
Owner = "User",
ParentId = "1",
Size = 0,
Type = NodeType.Directory
};
var folder2 = new MegaNzNodeMock
{
Id = "3",
Name = "folder2",
Owner = "User",
ParentId = "2",
Size = 0,
Type = NodeType.Directory
};
var file1 = new MegaNzNodeMock
{
Id = "4",
Name = "file1_[[2016-1-2-3-4-5]].jpeg",
Owner = "User",
ParentId = "3",
Size = 1024,
Type = NodeType.File
};
var nodeDictionary = new Dictionary <string, INode> {
{ _root.Id, _root },
{ folder1.Id, folder1 },
{ folder2.Id, folder2 },
{ file1.Id, file1 }
};
// Act
var file1Item = new MegaNzItem(file1, nodeDictionary);
// Assert
file1Item.LastModified.Should().HaveValue();
file1Item.LastModified.Value.Year.Should().Be(2016);
file1Item.LastModified.Value.Month.Should().Be(1);
file1Item.LastModified.Value.Day.Should().Be(2);
file1Item.LastModified.Value.Hour.Should().Be(3);
file1Item.LastModified.Value.Minute.Should().Be(4);
file1Item.LastModified.Value.Second.Should().Be(5);
}
public void Constructor_usingINodeOfTypeRoot_shouldHaveTheCorrectType()
{
// Arrange
var nodeDictionary = new Dictionary <string, INode> {
{ _root.Id, _root }
};
// Act
var rootItem = new MegaNzItem(_root, nodeDictionary);
// Assert
rootItem.Type.Should().Be(ItemType.Folder);
}
public void Constructor_usingINodeOfTypeRoot_shouldHaveSizeZero()
{
// Arrange
var nodeDictionary = new Dictionary <string, INode> {
{ _root.Id, _root }
};
// Act
var rootItem = new MegaNzItem(_root, nodeDictionary);
// Assert
rootItem.Size.Should().Be(0);
}
public void Constructor_usingINodeOfTypeRoot_shouldBuildTheCorrectPath()
{
// Arrange
var nodeDictionary = new Dictionary <string, INode> {
{ _root.Id, _root }
};
// Act
var rootItem = new MegaNzItem(_root, nodeDictionary);
// Assert
rootItem.Path.Should().Be(@"\");
}
public void GenerateCommandList_withAFolderInTheRemoteRootThatIsNotInTheLocalRoot_shouldGenerateADeleteFolderCommand()
{
// Given the following local file structure:
// root
// |
// +--> (no folder)
//
// And given the following remote file structure:
// root
// |
// +--> Folder1
//
// Then the generated command list should be:
// DeleteFolder \Folder1
// Local file structure
var localRoot = new FileItem(ItemType.Folder, @"\", 0);
var localItems = new List <FileItem> {
localRoot
};
// Remote file structure
// Root
const string folderName = "Folder1";
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
var remoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, @"\", ItemType.Folder, @"\", 0);
// File1
var mockMegaNzNodeForFile1 = new Mock <INode>(MockBehavior.Strict);
var remoteFolder1 = new MegaNzItem(mockMegaNzNodeForFile1.Object, folderName, ItemType.Folder, @"\" + folderName, 0);
var remoteItems = new List <MegaNzItem> {
remoteRoot,
remoteFolder1
};
// Act
const string localBasePath = "c:\\testing\\";
var synchronizer = new CommandGenerator(localBasePath);
var commandList = synchronizer.GenerateCommandList(localItems, remoteItems);
// Assert
commandList.Count.Should().Be(1);
commandList[0].Should().BeOfType <DeleteFolderCommand>();
var deleteFolderCommand = (DeleteFolderCommand)commandList[0];
deleteFolderCommand.PathToDelete.Should().Be(remoteFolder1.Path);
mockMegaNzNodeForRemoteRoot.VerifyAll();
mockMegaNzNodeForFile1.VerifyAll();
}
public void Constructor_usingINodeOfTypeDirectory_shouldBuildTheCorrectPath()
{
// We need a structure like this:
// root
// +--> folder1
// +--> folder2
// +--> folder3
var folder1 = new MegaNzNodeMock
{
Id = "2",
Name = "folder1",
Owner = "User",
ParentId = "1",
Size = 0,
Type = NodeType.Directory
};
var folder2 = new MegaNzNodeMock
{
Id = "3",
Name = "folder2",
Owner = "User",
ParentId = "2",
Size = 0,
Type = NodeType.Directory
};
var folder3 = new MegaNzNodeMock
{
Id = "4",
Name = "folder3",
Owner = "User",
ParentId = "3",
Size = 0,
Type = NodeType.Directory
};
var nodeDictionary = new Dictionary <string, INode> {
{ _root.Id, _root },
{ folder1.Id, folder1 },
{ folder2.Id, folder2 },
{ folder3.Id, folder3 }
};
// Act
var folder3Item = new MegaNzItem(folder3, nodeDictionary);
// Assert
folder3Item.Path.Should().Be(@"\folder1\folder2\folder3\"); // We want to have the backslash at the end of the path for the directory item
}
public void GenerateCommandList_withAFileInTheRemoteRootThatIsNotInTheLocalRoot_shouldGenerateADeleteCommand()
{
// Given the following local file structure:
// root
// |
// (no file in the root)
//
// And given the following remote file structure:
// root
// |
// +--> File1.jpeg - Last Modif 2016-1-1-0-0-0
//
// Then the generated command list should be:
// - Delete \File1.jpeg
// Local file structure
var localRoot = new FileItem(ItemType.Folder, @"\", 0);
var localItems = new List <FileItem> {
localRoot
};
// Remote file structure
// Root
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
var remoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, @"\", ItemType.Folder, @"\", 0);
// File1
var lastModifiedDate = new DateTime(2017, 1, 1, 0, 0, 0);
var mockMegaNzNodeForFile1 = new Mock <INode>(MockBehavior.Strict);
var remoteFile1 = new MegaNzItem(mockMegaNzNodeForFile1.Object, "File1.jpeg", ItemType.File, @"\\File1.jpeg", 1024, lastModifiedDate);
var remoteItems = new List <MegaNzItem> {
remoteRoot,
remoteFile1
};
// Act
var localBasePath = "c:\\testing\\";
var synchronizer = new CommandGenerator(localBasePath);
var commandList = synchronizer.GenerateCommandList(localItems, remoteItems);
// Assert
commandList.Count.Should().Be(1);
commandList[0].Should().BeOfType <DeleteFileCommand>();
var deleteCommand = (DeleteFileCommand)commandList[0];
deleteCommand.PathToDelete.Should().Be(remoteFile1.Path);
deleteCommand.LastModifiedDate.Should().Be(lastModifiedDate);
mockMegaNzNodeForRemoteRoot.VerifyAll();
mockMegaNzNodeForFile1.VerifyAll();
}
public void Constructor_usingINodeOfTypeFile_shouldBuildTheCorrectPath()
{
// We need a structure like this:
// root
// +--> folder1
// +--> folder2
// +--> file1
var folder1 = new MegaNzNodeMock
{
Id = "2",
Name = "folder1",
Owner = "User",
ParentId = "1",
Size = 0,
Type = NodeType.Directory
};
var folder2 = new MegaNzNodeMock
{
Id = "3",
Name = "folder2",
Owner = "User",
ParentId = "2",
Size = 0,
Type = NodeType.Directory
};
var file1 = new MegaNzNodeMock
{
Id = "4",
Name = "file1_[[2016-1-1-0-0-1]].jpeg",
Owner = "User",
ParentId = "3",
Size = 1024,
Type = NodeType.File
};
var nodeDictionary = new Dictionary <string, INode> {
{ _root.Id, _root },
{ folder1.Id, folder1 },
{ folder2.Id, folder2 },
{ file1.Id, file1 }
};
// Act
var file1Item = new MegaNzItem(file1, nodeDictionary);
// Assert
file1Item.Path.Should().Be(@"\folder1\folder2\file1.jpeg");
}
public void GenerateCommandList_withAFileInTheLocalRootThatIsTheSameInTheRemoteRoot_shouldNotGenerateAnyCommand()
{
// Given the following local file structure:
// root
// |
// +--> File1.jpeg - Last Modif = 2016-1-1-0-0-0 - Size = 1024
//
// And given the following remote file structure:
// root
// |
// +--> File1.jpeg - Last Modif = 2016-1-1-0-0-0 - Size = 1024
//
// Then the generated an empty command list
const string fileName = "File1.jpeg";
const long size = 1024;
var lastModifiedDate = new DateTime(2016, 1, 1, 0, 0, 0);
// Local file structure
var localRoot = new FileItem(ItemType.Folder, @"\", 0);
var localFile1 = new FileItem(ItemType.File, @"\" + fileName, size, lastModifiedDate);
var localItems = new List <FileItem> {
localRoot,
localFile1
};
// Remote file structure
// Root
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
var remoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, @"\", ItemType.Folder, @"\", 0);
// File1
var mockMegaNzNodeForFile1 = new Mock <INode>(MockBehavior.Strict);
var remoteFile1 = new MegaNzItem(mockMegaNzNodeForFile1.Object, fileName, ItemType.File, @"\" + fileName, size, lastModifiedDate);
var remoteItems = new List <MegaNzItem> {
remoteRoot,
remoteFile1
};
// Act
const string localBasePath = "c:\\testing\\";
var synchronizer = new CommandGenerator(localBasePath);
var commandList = synchronizer.GenerateCommandList(localItems, remoteItems);
// Assert
commandList.Should().BeEmpty();
mockMegaNzNodeForRemoteRoot.VerifyAll();
mockMegaNzNodeForFile1.VerifyAll();
}
public void GenerateCommandList_withAFolderInTheLocalRootThatIsInTheRemoteRoot_shouldNotGenerateAnyCommand()
{
// Given the following local file structure:
// root
// |
// +--> Folder1
//
// And given the following remote file structure:
// root
// |
// +--> Folder1
//
// Then the generated command list should be empty
// Local file structure
const string folderName = "Folder1";
var localRoot = new FileItem(ItemType.Folder, @"\", 0);
var localFolder1 = new FileItem(ItemType.Folder, @"\" + folderName, 0);
var localItems = new List <FileItem> {
localRoot,
localFolder1
};
// Remote file structure
// Root
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
var remoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, @"\", ItemType.Folder, @"\", 0);
// Folder1
var mockMegaNzNodeForFile1 = new Mock <INode>(MockBehavior.Strict);
var remoteFolder1 = new MegaNzItem(mockMegaNzNodeForFile1.Object, folderName, ItemType.Folder, @"\" + folderName, 0);
var remoteItems = new List <MegaNzItem> {
remoteRoot,
remoteFolder1
};
// Act
const string localBasePath = "c:\\testing\\";
var generator = new CommandGenerator(localBasePath);
var commandList = generator.GenerateCommandList(localItems, remoteItems);
// Assert
commandList.Should().BeEmpty();
mockMegaNzNodeForRemoteRoot.VerifyAll();
mockMegaNzNodeForFile1.VerifyAll();
}
public void GenerateCommandList_withAFileInFolderInTheLocalRootThatIsNotInTheRemoteFolder_shouldGenerateAnUploadCommand()
{
// Given the following local file structure:
// root
// |
// +--> Folder1
// |
// +--> File1.jpeg - Last Modif 2016-1-1-0-0-0
//
// And given the following remote file structure:
// root
// |
// +--> Folder1
// |
// +--> (no file in the root)
//
// Then the generated command list should be:
// - Upload \root\Folder1\File1.jpeg
// Local file structure
const string folderName = "Folder1";
var lastModifiedDate = new DateTime(2016, 1, 1, 0, 0, 0);
var localRoot = new FileItem(ItemType.Folder, @"\", 0);
var localFolder1 = new FileItem(ItemType.Folder, @"\" + folderName, 0);
var localFile1 = new FileItem(ItemType.File, @"\" + folderName + @"\File1.jpeg", 1024, lastModifiedDate);
var localItems = new List <FileItem> {
localRoot,
localFolder1,
localFile1
};
// Remote file structure
// Root
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
var remoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, @"\", ItemType.Folder, @"\", 0);
// Folder1
var mockMegaNzNodeForFolder1 = new Mock <INode>(MockBehavior.Strict);
var remoteFolder1 = new MegaNzItem(mockMegaNzNodeForFolder1.Object, folderName, ItemType.Folder, @"\" + folderName, 0);
var remoteItems = new List <MegaNzItem> {
remoteRoot,
remoteFolder1
};
// Act
const string localBasePath = "c:\\testing\\";
var generator = new CommandGenerator(localBasePath);
var commandList = generator.GenerateCommandList(localItems, remoteItems);
// Assert
commandList.Count.Should().Be(1);
commandList[0].Should().BeOfType <UploadFileCommand>();
var uploadCommand = (UploadFileCommand)commandList[0];
uploadCommand.SourcePath.Should().Be(@"c:\testing\Folder1\File1.jpeg");
uploadCommand.DestinationPath.Should().Be(@"\Folder1\"); // We must have the backslash at the end of the path for a folder
uploadCommand.LastModifiedDate.Should().Be(lastModifiedDate);
mockMegaNzNodeForRemoteRoot.VerifyAll();
mockMegaNzNodeForFolder1.VerifyAll();
}
public void GenerateCommandList_withAFileInTheLocalRootThatHasDifferentSizeThanTheSameInTheRemoteRoot_shouldGenerateADeleteCommandAndAnUpdateCommand()
{
// Given the following local file structure:
// root
// |
// +--> File1.jpeg - Last Modif = 2016-1-1-0-0-0 - Size = 2048
//
// And given the following remote file structure:
// root
// |
// +--> File1.jpeg - Last Modif = 2016-1-1-0-0-0 - Size = 1024
//
// Then the generated command list should be:
// Delete \File1.jpeg
// Upload \File1.jpeg
const string fileName = "File1.jpeg";
const long size = 1024;
var lastModifiedDate = new DateTime(2016, 1, 1, 0, 0, 0);
// Local file structure
var localRoot = new FileItem(ItemType.Folder, @"\", 0);
var localFile1 = new FileItem(ItemType.File, @"\" + fileName, size, lastModifiedDate);
var localItems = new List <FileItem> {
localRoot,
localFile1
};
// Remote file structure
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
var remoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, @"\", ItemType.Folder, @"\", 0);
// File1
var mockMegaNzNodeForFile1 = new Mock <INode>(MockBehavior.Strict);
var remoteFile1 = new MegaNzItem(mockMegaNzNodeForFile1.Object, fileName, ItemType.File, @"\" + fileName, size * 2, lastModifiedDate);
var remoteItems = new List <MegaNzItem> {
remoteRoot,
remoteFile1
};
// Act
const string localBasePath = "c:\\testing\\";
var synchronizer = new CommandGenerator(localBasePath);
var commandList = synchronizer.GenerateCommandList(localItems, remoteItems);
// Assert
commandList.Count.Should().Be(2);
commandList[0].Should().BeOfType <DeleteFileCommand>();
var deleteCommand = (DeleteFileCommand)commandList[0];
deleteCommand.PathToDelete.Should().Be(remoteFile1.Path);
deleteCommand.LastModifiedDate.Should().Be(lastModifiedDate);
commandList[1].Should().BeOfType <UploadFileCommand>();
var uploadCommand = (UploadFileCommand)commandList[1];
uploadCommand.DestinationPath.Should().Be(remoteRoot.Path);
uploadCommand.SourcePath.Should().Be(localBasePath.TrimEnd('\\') + localFile1.Path);
uploadCommand.LastModifiedDate.Should().Be(lastModifiedDate);
mockMegaNzNodeForRemoteRoot.VerifyAll();
mockMegaNzNodeForFile1.VerifyAll();
}
public void Execute_withADeleteFolderCommand_shouldRemoteTheDeletedItemFromTheMegaNzItemCollection()
{
// Scenario
// Local file structure
// root
// |
// +--> folder1
//
// Remote file structure
// root
// |
// +--> folder1
// |
// +--> folder2
// Arrange
var deleteFolderCommand = new DeleteFolderCommand
{
PathToDelete = "\\folder1\\folder2"
};
var commandList = new[] { deleteFolderCommand };
// Remote items
// Root in the remote file structure
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
mockMegaNzNodeForRemoteRoot.SetupGet(m => m.Id).Returns("0");
mockMegaNzNodeForRemoteRoot.SetupGet(m => m.Type).Returns(NodeType.Root);
mockMegaNzNodeForRemoteRoot.SetupGet(m => m.Name).Returns("\\");
var megaNzItemRemoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, "\\", ItemType.Folder, "\\", 0);
// Folder1 in the remote file structure
var mockMegaNzNodeForRemoteFolder1 = new Mock <INode>(MockBehavior.Strict);
mockMegaNzNodeForRemoteFolder1.SetupGet(m => m.Id).Returns("1");
mockMegaNzNodeForRemoteFolder1.SetupGet(m => m.ParentId).Returns("0");
mockMegaNzNodeForRemoteFolder1.SetupGet(m => m.Type).Returns(NodeType.Directory);
mockMegaNzNodeForRemoteFolder1.SetupGet(m => m.Name).Returns("folder1");
var megaNzItemForRemoteFolder1 = new MegaNzItem(mockMegaNzNodeForRemoteFolder1.Object, "\\folder1", ItemType.Folder, "\\folder1", 0);
// Folder2 in the remote file structure
var mockMegaNzNodeForRemoteFolder2 = new Mock <INode>(MockBehavior.Strict);
mockMegaNzNodeForRemoteFolder2.SetupGet(m => m.Id).Returns("2");
mockMegaNzNodeForRemoteFolder2.SetupGet(m => m.ParentId).Returns("1");
mockMegaNzNodeForRemoteFolder2.SetupGet(m => m.Type).Returns(NodeType.Directory);
mockMegaNzNodeForRemoteFolder2.SetupGet(m => m.Name).Returns("folder2");
var megaNzItemForRemoteFolder2 = new MegaNzItem(mockMegaNzNodeForRemoteFolder2.Object, "folder2", ItemType.Folder, "\\folder1\\folder2", 0);
var remoteItems = new[] {
megaNzItemRemoteRoot,
megaNzItemForRemoteFolder1,
megaNzItemForRemoteFolder2
};
var megaNzItemCollection = new MegaNzItemCollection(remoteItems);
var mockMegaApiClient = new Mock <IMegaApiClient>(MockBehavior.Strict);
mockMegaApiClient
.Setup(m => m.Delete(mockMegaNzNodeForRemoteFolder2.Object, true))
.Verifiable();
var mockFileManager = new Mock <IFileManager>(MockBehavior.Strict);
var mockProgressNotifier = new Mock <IProgress <double> >(MockBehavior.Strict);
// Act
var commandExecutor = new CommandExecutor(mockMegaApiClient.Object, _mockLogger.Object);
commandExecutor.Execute(commandList, megaNzItemCollection, mockFileManager.Object, mockProgressNotifier.Object);
// Assert
megaNzItemCollection.GetList().Should().NotContain(item => item.MegaNzNode.Id == "2");
}
public void GenerateCommandList_withAFileInFolderInTheLocalRootThatIsOlderThanTheSameInTheRemoteFolder_shouldGenerateADeleteCommandAndAnUpdateCommand()
{
// Given the following local file structure:
// root
// |
// +--> Folder1
// |
// +--> File1.jpeg - Last Modif = 2015-1-1-0-0-0 - Size = 1024
//
// And given the following remote file structure:
// root
// |
// +--> Folder1
// |
// +--> File1.jpeg - Last Modif = 2016-1-1-0-0-0 - Size = 1024
//
// Then the generated command list should be:
// Delete \Folder1\File1.jpeg
// Upload \Folder1\File1.jpeg
const string fileName = "File1.jpeg";
const long size = 1024;
const string folderName = "Folder1";
var localLastModifiedDate = new DateTime(2015, 1, 1, 0, 0, 0);
// Local file structure
var localRoot = new FileItem(ItemType.Folder, @"\", 0);
var localFolder1 = new FileItem(ItemType.Folder, @"\" + folderName, 0);
var localFile1 = new FileItem(ItemType.File, @"\" + folderName + @"\" + fileName, size, localLastModifiedDate);
var localItems = new List <FileItem> {
localRoot,
localFolder1,
localFile1
};
// Remote file structure
// Root
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
var remoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, @"\", ItemType.Folder, @"\", 0);
// Folder1
var mockMegaNzNodeForRemoteFolder1 = new Mock <INode>(MockBehavior.Strict);
var remoteFolder1 = new MegaNzItem(mockMegaNzNodeForRemoteFolder1.Object, folderName, ItemType.Folder, @"\" + folderName, 0);
// File1
var mockMegaNzNodeForRemoteFile1 = new Mock <INode>(MockBehavior.Strict);
var remoteLastModifiedDate = localLastModifiedDate.AddYears(1);
var remoteFile1 = new MegaNzItem(mockMegaNzNodeForRemoteFile1.Object, fileName, ItemType.File, @"\" + folderName + @"\" + fileName, size, remoteLastModifiedDate);
var remoteItems = new List <MegaNzItem> {
remoteRoot,
remoteFolder1,
remoteFile1
};
// Act
const string localBasePath = "c:\\testing\\";
var synchronizer = new CommandGenerator(localBasePath);
var commandList = synchronizer.GenerateCommandList(localItems, remoteItems);
// Assert
commandList.Count.Should().Be(2);
commandList[0].Should().BeOfType <DeleteFileCommand>();
var deleteFileCommand = (DeleteFileCommand)commandList[0];
deleteFileCommand.PathToDelete.Should().Be(@"\Folder1\File1.jpeg");
deleteFileCommand.LastModifiedDate.Should().Be(remoteLastModifiedDate);
commandList[1].Should().BeOfType <UploadFileCommand>();
var uploadFileCommand = (UploadFileCommand)commandList[1];
uploadFileCommand.SourcePath.Should().Be(localBasePath + folderName + @"\" + fileName);
uploadFileCommand.DestinationPath.Should().Be(@"\" + folderName + @"\"); // Because we need the backslash at the end of the path for a folder
uploadFileCommand.LastModifiedDate.Should().Be(localLastModifiedDate);
mockMegaNzNodeForRemoteRoot.VerifyAll();
mockMegaNzNodeForRemoteFolder1.VerifyAll();
mockMegaNzNodeForRemoteFile1.VerifyAll();
}
public void Execute_withACreateFolderCommand_shouldUploadTheMegaNzItemCollection()
{
// Scenario
// Local file structure
// root
// |
// +--> folder1
// |
// +--> folder2
//
// Remote file structure
// root
// |
// +--> folder1
// Arrange
var createFolderCommand = new CreateFolderCommand
{
ParentPath = "\\folder1",
Name = "folder2"
};
var commandList = new[] { createFolderCommand };
// Remote items
// Root in the remote file structure
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
mockMegaNzNodeForRemoteRoot.SetupGet(m => m.Id).Returns("0");
mockMegaNzNodeForRemoteRoot.SetupGet(m => m.Type).Returns(NodeType.Root);
mockMegaNzNodeForRemoteRoot.SetupGet(m => m.Name).Returns("\\");
var megaNzItemRemoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, "\\", ItemType.Folder, "\\", 0);
// Folder1 in the remote file structure
var mockMegaNzNodeForRemoteFolder1 = new Mock <INode>(MockBehavior.Strict);
mockMegaNzNodeForRemoteFolder1.SetupGet(m => m.Id).Returns("1");
mockMegaNzNodeForRemoteFolder1.SetupGet(m => m.ParentId).Returns("0");
mockMegaNzNodeForRemoteFolder1.SetupGet(m => m.Type).Returns(NodeType.Directory);
mockMegaNzNodeForRemoteFolder1.SetupGet(m => m.Name).Returns("folder1");
var megaNzItemForRemoteFolder1 = new MegaNzItem(mockMegaNzNodeForRemoteFolder1.Object, "\\folder1", ItemType.Folder, "\\folder1", 0);
var remoteItems = new[] {
megaNzItemRemoteRoot,
megaNzItemForRemoteFolder1
};
var megaNzItemCollection = new MegaNzItemCollection(remoteItems);
// The MegaNzNode for the folder created
var mockMegaNzNodeForRemoteFolder2 = new MegaNzNodeMock {
Id = "2",
Name = "folder2",
Type = NodeType.Directory,
Size = 0,
ParentId = "1"
};
var mockMegaApiClient = new Mock <IMegaApiClient>(MockBehavior.Strict);
mockMegaApiClient
.Setup(m => m.CreateFolder(createFolderCommand.Name, mockMegaNzNodeForRemoteFolder1.Object))
.Returns(mockMegaNzNodeForRemoteFolder2);
var mockFileManager = new Mock <IFileManager>(MockBehavior.Strict);
var mockProgressNotifier = new Mock <IProgress <double> >(MockBehavior.Strict);
// Act
var commandExecutor = new CommandExecutor(mockMegaApiClient.Object, _mockLogger.Object);
commandExecutor.Execute(commandList, megaNzItemCollection, mockFileManager.Object, mockProgressNotifier.Object);
// Assert
megaNzItemCollection.GetList().Should().Contain(item => item.MegaNzNode.Id == mockMegaNzNodeForRemoteFolder2.Id);
}
