public async Task TestCopyOperation(bool throws, OperationState state)
{
var copySetup = _autoMocker
.Setup <IFileService, Task <bool> >(m => m.CopyAsync(SourceName, DestinationName, false))
.ReturnsAsync(!throws);
copySetup.Verifiable();
var operationsFactory = _autoMocker.CreateInstance <OperationsFactory>();
var settings = new BinaryFileSystemOperationSettings(
new string[] { },
new[] { SourceName },
new string[] { },
new[] { SourceName },
new Dictionary <string, string> {
[SourceName] = DestinationName
},
new string[] { }
);
var copyOperation = operationsFactory.CreateCopyOperation(settings);
Assert.Equal(OperationState.NotStarted, copyOperation.State);
var isCallbackCalled = false;
copyOperation.StateChanged += (sender, args) => isCallbackCalled = true;
await copyOperation.RunAsync();
Assert.Equal(state, copyOperation.State);
Assert.True(isCallbackCalled);
_autoMocker.Verify <IFileService>(m => m.CopyAsync(SourceName, DestinationName, false), Times.Once);
}
public async Task TestCopyEmptyDirectoryOperation(bool success, OperationState state)
{
_autoMocker
.Setup <IDirectoryService, IReadOnlyList <string> >(m => m.GetEmptyDirectoriesRecursively(SourceName))
.Returns(new[] { SourceName });
_autoMocker
.Setup <IDirectoryService, bool>(m => m.Create(DestinationName))
.Returns(success)
.Verifiable();
var operationsFactory = _autoMocker.CreateInstance <OperationsFactory>();
var settings = new BinaryFileSystemOperationSettings(
new[] { SourceName },
new string[] { },
new[] { DestinationName },
new string[] { },
new Dictionary <string, string>(),
new[] { DestinationName }
);
var copyOperation = operationsFactory.CreateCopyOperation(settings);
Assert.Equal(OperationState.NotStarted, copyOperation.State);
var callbackCalled = false;
copyOperation.StateChanged += (sender, args) => callbackCalled = true;
await copyOperation.RunAsync();
Assert.Equal(state, copyOperation.State);
Assert.True(callbackCalled);
_autoMocker.Verify <IDirectoryService, bool>(m => m.Create(DestinationName), Times.Once);
}
public async Task TestMoveOperation(bool copyThrows, bool deleteThrows, OperationState state)
{
var directoryServiceMock = new Mock <IDirectoryService>();
var filesServiceMock = new Mock <IFileService>();
var copySetup = filesServiceMock
.Setup(m => m.CopyAsync(SourceName, DestinationName, false));
if (copyThrows)
{
copySetup.ThrowsAsync(new AccessViolationException()).Verifiable();
}
else
{
copySetup.Verifiable();
}
var deleteSetup = filesServiceMock
.Setup(m => m.Remove(SourceName));
if (deleteThrows)
{
deleteSetup.Throws(new AccessViolationException()).Verifiable();
}
else
{
deleteSetup.Verifiable();
}
var operationsFactory = new OperationsFactory(
_taskPool,
directoryServiceMock.Object,
filesServiceMock.Object,
_pathService,
_fileNameGenerationService);
var settings = new BinaryFileSystemOperationSettings(
new string[] { },
new[] { SourceName },
new string[] { },
new[] { SourceName },
new Dictionary <string, string> {
[SourceName] = DestinationName
},
new string[] { }
);
var moveOperation = operationsFactory.CreateMoveOperation(settings);
Assert.Equal(OperationState.NotStarted, moveOperation.State);
var callbackCalled = false;
moveOperation.StateChanged += (sender, args) => callbackCalled = true;
await moveOperation.RunAsync();
Assert.Equal(state, moveOperation.State);
Assert.True(callbackCalled);
filesServiceMock.Verify(m => m.CopyAsync(SourceName, DestinationName, false), Times.Once());
filesServiceMock.Verify(m => m.Remove(SourceName), copyThrows ? Times.Never() : Times.Once());
}
public async Task TestBlockedCopyOperation()
{
var directoryServiceMock = new Mock <IDirectoryService>();
var filesServiceMock = new Mock <IFileService>();
filesServiceMock
.Setup(m => m.CopyAsync(SourceName, DestinationName, false))
.Verifiable();
filesServiceMock
.Setup(m => m.CopyAsync(SourceName, DestinationName, true))
.Verifiable();
filesServiceMock
.Setup(m => m.CheckIfExists(DestinationName))
.Returns(true);
var operationsFactory = new OperationsFactory(
_taskPool,
directoryServiceMock.Object,
filesServiceMock.Object,
_pathService,
_fileNameGenerationService);
var settings = new BinaryFileSystemOperationSettings(
new string[] { },
new[] { SourceName },
new string[] { },
new[] { SourceName },
new Dictionary <string, string> {
[SourceName] = DestinationName
}
);
var copyOperation = operationsFactory.CreateCopyOperation(settings);
var callbackCalled = false;
copyOperation.StateChanged += async(sender, args) =>
{
if (args.OperationState != OperationState.Blocked)
{
return;
}
callbackCalled = true;
filesServiceMock.Verify(m => m.CopyAsync(SourceName, DestinationName, false), Times.Never);
var operation = (IOperation)sender;
Assert.NotNull(operation);
var(sourceFilePath, _) = operation.CurrentBlockedFile;
var options = OperationContinuationOptions.CreateContinuationOptions(sourceFilePath, false, OperationContinuationMode.Overwrite);
await copyOperation.ContinueAsync(options);
};
await copyOperation.RunAsync();
Assert.True(callbackCalled);
Assert.Equal(OperationState.Finished, copyOperation.State);
filesServiceMock.Verify(m => m.CopyAsync(SourceName, DestinationName, true), Times.Once);
}
public OperationInfo(OperationType operationType, BinaryFileSystemOperationSettings settings)
{
OperationType = operationType;
Files = settings.InputTopLevelFiles;
Directories = settings.InputTopLevelDirectories;
TotalFilesCount = settings.FilesDictionary.Count;
SourceDirectory = settings.SourceDirectory;
TargetDirectory = settings.TargetDirectory;
}
public IOperation CreateCopyOperation(BinaryFileSystemOperationSettings settings)
{
var copyOperations = CreateCopyOperations(settings.FilesDictionary, settings.EmptyDirectories);
var operationGroup = CreateOperationGroup(copyOperations);
var operations = CreateOperationsGroupsList(operationGroup);
var operationInfo = CreateOperationInfo(OperationType.Copy, settings);
var compositeOperation = CreateCompositeOperation(operations, operationInfo);
return(CreateOperation(compositeOperation));
}
public IOperation CreateCopyOperation(BinaryFileSystemOperationSettings settings)
{
var copyOperations = CreateCopyOperations(settings.FilesDictionary);
var deleteNewFilesOperations = CreateDeleteOperations(settings.OutputTopLevelDirectories, settings.OutputTopLevelFiles);
var operationGroup = CreateOperationGroup(copyOperations, deleteNewFilesOperations);
var operations = CreateOperationsGroupsList(operationGroup);
var operationInfo = Create(OperationType.Copy, settings.InputTopLevelDirectories,
settings.InputTopLevelFiles, settings.SourceDirectory, settings.TargetDirectory);
return(CreateCompositeOperation(operations, operationInfo));
}
public IOperation CreateMoveOperation(BinaryFileSystemOperationSettings settings)
{
var copyOperations = CreateCopyOperations(settings.FilesDictionary, settings.EmptyDirectories);
var copyOperationGroup = CreateOperationGroup(copyOperations);
var deleteOldFilesOperations = CreateDeleteOperations(settings.InputTopLevelDirectories, settings.InputTopLevelFiles);
var deleteOperationGroup = CreateOperationGroup(deleteOldFilesOperations);
var operations = CreateOperationsGroupsList(copyOperationGroup, deleteOperationGroup);
var operationInfo = CreateOperationInfo(OperationType.Move, settings);
var compositeOperation = CreateCompositeOperation(operations, operationInfo);
return(CreateOperation(compositeOperation));
}
public async Task TestMoveOperation(bool copyThrows, bool deleteThrows, OperationState state,
int removeCallsCount)
{
var copySetup = _autoMocker
.Setup <IFileService, Task <bool> >(m => m.CopyAsync(SourceName, DestinationName, It.IsAny <CancellationToken>(), false))
.ReturnsAsync(!copyThrows);
copySetup.Verifiable();
var deleteSetup = _autoMocker
.Setup <IFileService, bool>(m => m.Remove(SourceName))
.Returns(!deleteThrows);
deleteSetup.Verifiable();
var operationsFactory = _autoMocker.CreateInstance <OperationsFactory>();
var settings = new BinaryFileSystemOperationSettings(
new string[] { },
new[] { SourceName },
new string[] { },
new[] { SourceName },
new Dictionary <string, string> {
[SourceName] = DestinationName
},
new string[] { }
);
var moveOperation = operationsFactory.CreateMoveOperation(settings);
Assert.Equal(OperationState.NotStarted, moveOperation.State);
var callbackCalled = false;
moveOperation.StateChanged += (sender, args) => callbackCalled = true;
await moveOperation.RunAsync();
Assert.Equal(state, moveOperation.State);
Assert.True(callbackCalled);
_autoMocker
.Verify <IFileService>(m => m.CopyAsync(SourceName, DestinationName, It.IsAny <CancellationToken>(), false),
Times.Once);
_autoMocker
.Verify <IFileService, bool>(m => m.Remove(SourceName),
Times.Exactly(removeCallsCount));
}
public async Task TestMoveOperation()
{
var directoryServiceMock = new Mock <IDirectoryService>();
var filesServiceMock = new Mock <IFileService>();
filesServiceMock
.Setup(m => m.CopyAsync(SourceName, DestinationName, false))
.Verifiable();
filesServiceMock
.Setup(m => m.Remove(SourceName))
.Verifiable();
var operationsFactory = new OperationsFactory(
_taskPool,
directoryServiceMock.Object,
filesServiceMock.Object,
_pathService,
_fileNameGenerationService);
var settings = new BinaryFileSystemOperationSettings(
new string[] { },
new[] { SourceName },
new string[] { },
new[] { SourceName },
new Dictionary <string, string> {
[SourceName] = DestinationName
}
);
var moveOperation = operationsFactory.CreateMoveOperation(settings);
Assert.Equal(OperationState.NotStarted, moveOperation.State);
var callbackCalled = false;
moveOperation.StateChanged += (sender, args) => callbackCalled = true;
await moveOperation.RunAsync();
Assert.Equal(OperationState.Finished, moveOperation.State);
Assert.True(callbackCalled);
filesServiceMock.Verify(m => m.CopyAsync(SourceName, DestinationName, false), Times.Once());
filesServiceMock.Verify(m => m.Remove(SourceName), Times.Once());
}
public async Task TestCopeEmptyDirectoryOperation(bool success, OperationState state)
{
var directoryServiceMock = new Mock <IDirectoryService>();
directoryServiceMock
.Setup(m => m.GetEmptyDirectoriesRecursively(SourceName))
.Returns(new[] { SourceName });
directoryServiceMock
.Setup(m => m.Create(DestinationName))
.Returns(success)
.Verifiable();
var filesServiceMock = new Mock <IFileService>();
var pathServiceMock = new Mock <IPathService>();
var operationsFactory = new OperationsFactory(
_taskPool,
directoryServiceMock.Object,
filesServiceMock.Object,
pathServiceMock.Object,
_fileNameGenerationService);
var settings = new BinaryFileSystemOperationSettings(
new[] { SourceName },
new string[] { },
new[] { DestinationName },
new string[] { },
new Dictionary <string, string>(),
new[] { DestinationName }
);
var copyOperation = operationsFactory.CreateCopyOperation(settings);
Assert.Equal(OperationState.NotStarted, copyOperation.State);
var callbackCalled = false;
copyOperation.StateChanged += (sender, args) => callbackCalled = true;
await copyOperation.RunAsync();
Assert.Equal(state, copyOperation.State);
Assert.True(callbackCalled);
directoryServiceMock.Verify(m => m.Create(DestinationName), Times.Once());
}
public void TestProperties()
{
var settings = new BinaryFileSystemOperationSettings(
new string[] { },
new[] { SourceName },
new string[] { },
new[] { DestinationName },
new Dictionary <string, string>
{
[SourceName] = DestinationName
},
new string[] { }
);
var operationInfo = new OperationInfo(OperationType.Copy, settings);
_autoMocker.Use(operationInfo);
var operation = _autoMocker.CreateInstance <CompositeOperation>();
Assert.Equal(operationInfo, operation.Info);
Assert.Equal(default, operation.CurrentBlockedFile);
public async Task TestCopyOperation(bool throws, OperationState state, string sourceName,
string destinationName, int copyCallsCount, bool destinationExists)
{
var copySetup = _autoMocker
.Setup <IFileService, Task <bool> >(m => m.CopyAsync(sourceName, destinationName, It.IsAny <CancellationToken>(), false))
.ReturnsAsync(!throws);
copySetup.Verifiable();
_autoMocker
.Setup <IFileService, bool>(m => m.CheckIfExists(destinationName))
.Returns(destinationExists);
var operationsFactory = _autoMocker.CreateInstance <OperationsFactory>();
var settings = new BinaryFileSystemOperationSettings(
new string[] { },
new[] { SourceName },
new string[] { },
new[] { SourceName },
new Dictionary <string, string> {
[sourceName] = destinationName
},
new string[] { }
);
var copyOperation = operationsFactory.CreateCopyOperation(settings);
Assert.Equal(OperationState.NotStarted, copyOperation.State);
var isCallbackCalled = false;
copyOperation.StateChanged += (sender, args) => isCallbackCalled = true;
await copyOperation.RunAsync();
Assert.Equal(state, copyOperation.State);
Assert.True(isCallbackCalled);
_autoMocker
.Verify <IFileService>(m => m.CopyAsync(sourceName, destinationName, It.IsAny <CancellationToken>(), false),
Times.Exactly(copyCallsCount));
}
public void TestProperties(OperationType operationType, int filesCount,
int dirsCount, bool isProcessingSingleFile, OperationState operationState,
string sourceFile)
{
var files = Enumerable
.Repeat(File, filesCount)
.ToArray();
var dirs = Enumerable
.Repeat(Directory, dirsCount)
.ToArray();
var settings = new BinaryFileSystemOperationSettings(dirs, files,
dirs, files, new Dictionary <string, string>(0),
new string[0], SourceDirectory, TargetDirectory);
var operationInfo = new OperationInfo(operationType, settings);
_autoMocker
.Setup <IOperation, OperationInfo>(m => m.Info)
.Returns(operationInfo);
_autoMocker
.Setup <IOperation, OperationState>(m => m.State)
.Returns(operationState);
_autoMocker
.Setup <IPathService, string>(m => m.GetFileName(It.IsAny <string>()))
.Returns <string>(s => s);
var viewModel = _autoMocker.CreateInstance <OperationStateViewModel>();
Assert.Equal(0, viewModel.Progress);
Assert.Equal(operationState, viewModel.State);
Assert.Equal(filesCount, viewModel.SourceFilesCount);
Assert.Equal(dirsCount, viewModel.SourceDirectoriesCount);
Assert.Equal(isProcessingSingleFile, viewModel.IsProcessingSingleFile);
Assert.Equal(operationType, viewModel.OperationType);
Assert.Equal(sourceFile, viewModel.SourceFile);
Assert.Equal(SourceDirectory, viewModel.SourceDirectory);
Assert.Equal(TargetDirectory, viewModel.TargetDirectory);
}
public async Task TestBlockedOperationCancel(bool areMultipleFilesAvailable, int filesCount)
{
var taskCompletionSource = new TaskCompletionSource <bool>();
var options = OperationContinuationOptions.CreateContinuationOptions(FilePath,
true, OperationContinuationMode.Skip);
var operationsStateServiceMock = new Mock <IOperationsStateService>();
var operationStateViewModelFactoryMock = new Mock <IOperationStateViewModelFactory>();
var applicationDispatcherMock = new Mock <IApplicationDispatcher>();
applicationDispatcherMock
.Setup(m => m.Dispatch(It.IsAny <Action>()))
.Callback <Action>(action => action());
applicationDispatcherMock
.Setup(m => m.DispatchAsync(It.IsAny <Func <Task> >()))
.Callback <Func <Task> >(async func =>
{
await func();
taskCompletionSource.SetResult(true);
});
var dialogServiceMock = new Mock <IDialogService>();
dialogServiceMock
.Setup(m => m.ShowDialogAsync <OverwriteOptionsDialogResult, OverwriteOptionsNavigationParameter>(
nameof(OverwriteOptionsDialogViewModel),
It.IsAny <OverwriteOptionsNavigationParameter>()))
.Callback <string, OverwriteOptionsNavigationParameter>((_, p) =>
{
Assert.Equal(areMultipleFilesAvailable, p.AreMultipleFilesAvailable);
Assert.Equal(Source, p.SourceFilePath);
Assert.Equal(Destination, p.DestinationFilePath);
})
.Returns(Task.FromResult(new OverwriteOptionsDialogResult(options)));
var viewModel = new OperationsStatesListViewModel(
operationsStateServiceMock.Object,
operationStateViewModelFactoryMock.Object,
applicationDispatcherMock.Object,
dialogServiceMock.Object);
var state = OperationState.InProgress;
var operationMock = new Mock <IOperation>();
operationMock
.Setup(m => m.ContinueAsync(options))
.Verifiable();
operationMock
.SetupGet(m => m.State)
.Returns(() => state);
operationMock
.SetupGet(m => m.CurrentBlockedFile)
.Returns((Source, Destination));
var array = new string[0];
var dictionary = new Dictionary <string, string>();
for (var i = 0; i < filesCount; i++)
{
dictionary[i.ToString()] = i.ToString();
}
var settings = new BinaryFileSystemOperationSettings(
array, array,
array, array, dictionary, array);
var operationInfo = new OperationInfo(OperationType.Copy, settings);
operationMock
.SetupGet(m => m.Info)
.Returns(operationInfo);
var operationStartedEventArgs = new OperationStartedEventArgs(operationMock.Object);
operationsStateServiceMock.Raise(m => m.OperationStarted += null, operationStartedEventArgs);
Assert.True(viewModel.AreAnyOperationsAvailable);
state = OperationState.Blocked;
var operationStateChangedEventArgs = new OperationStateChangedEventArgs(state);
operationMock.Raise(m => m.StateChanged += null, operationStateChangedEventArgs);
Assert.True(viewModel.AreAnyOperationsAvailable);
var task = await Task.WhenAny(Task.Delay(1000), taskCompletionSource.Task);
if (task != taskCompletionSource.Task)
{
taskCompletionSource.SetResult(false);
}
var result = await taskCompletionSource.Task;
Assert.True(result);
await Task.Delay(500);
operationMock.Verify(m => m.ContinueAsync(options), Times.Once());
}
public async Task TestBlockedCopyOperation(bool applyToAll, int expectedCallbackCallsCount,
OperationContinuationMode mode, int expectedWriteCallsCountFirstFile, int expectedWriteCallsCountSecondFile)
{
var now = DateTime.UtcNow;
var hourBeforeNow = now.AddHours(-1);
var directoryServiceMock = new Mock <IDirectoryService>();
var filesServiceMock = new Mock <IFileService>();
filesServiceMock
.Setup(m => m.GetFile(SourceName))
.Returns(new FileModel {
LastModifiedDateTime = now
});
filesServiceMock
.Setup(m => m.GetFile(DestinationName))
.Returns(new FileModel {
LastModifiedDateTime = hourBeforeNow
});
filesServiceMock
.Setup(m => m.GetFile(SecondSourceName))
.Returns(new FileModel {
LastModifiedDateTime = hourBeforeNow
});
filesServiceMock
.Setup(m => m.GetFile(SecondDestinationName))
.Returns(new FileModel {
LastModifiedDateTime = now
});
filesServiceMock
.Setup(m => m.CopyAsync(SourceName, DestinationName, false))
.Verifiable();
filesServiceMock
.Setup(m => m.CopyAsync(SourceName, DestinationName, true))
.Returns(Task.CompletedTask)
.Verifiable();
filesServiceMock
.Setup(m => m.CopyAsync(SecondSourceName, SecondDestinationName, false))
.Verifiable();
filesServiceMock
.Setup(m => m.CopyAsync(SecondSourceName, SecondDestinationName, true))
.Returns(Task.CompletedTask)
.Verifiable();
filesServiceMock
.Setup(m => m.CheckIfExists(It.IsAny <string>()))
.Returns(true);
var operationsFactory = new OperationsFactory(
_taskPool,
directoryServiceMock.Object,
filesServiceMock.Object,
_pathService,
_fileNameGenerationService);
var settings = new BinaryFileSystemOperationSettings(
new string[] { },
new[] { SourceName, SecondSourceName },
new string[] { },
new[] { DestinationName, SecondDestinationName },
new Dictionary <string, string>
{
[SourceName] = DestinationName,
[SecondSourceName] = SecondDestinationName
},
new string[] { }
);
var copyOperation = operationsFactory.CreateCopyOperation(settings);
var callbackCallsCount = 0;
copyOperation.StateChanged += async(sender, args) =>
{
if (args.OperationState != OperationState.Blocked)
{
return;
}
var operation = (IOperation)sender;
if (operation is null)
{
return;
}
callbackCallsCount++;
var(sourceFilePath, _) = operation.CurrentBlockedFile;
var options = OperationContinuationOptions.CreateContinuationOptions(sourceFilePath, applyToAll, mode);
await copyOperation.ContinueAsync(options);
};
await copyOperation.RunAsync();
Assert.Equal(expectedCallbackCallsCount, callbackCallsCount);
Assert.Equal(OperationState.Finished, copyOperation.State);
filesServiceMock.Verify(m => m.CopyAsync(SourceName, DestinationName, true), Times.Exactly(expectedWriteCallsCountFirstFile));
filesServiceMock.Verify(m => m.CopyAsync(SecondSourceName, SecondDestinationName, true), Times.Exactly(expectedWriteCallsCountSecondFile));
filesServiceMock.Verify(m => m.CopyAsync(SourceName, DestinationName, false), Times.Never);
filesServiceMock.Verify(m => m.CopyAsync(SecondSourceName, SecondDestinationName, false), Times.Never);
}
public async Task TestBlockedCopyOperationSingle(bool applyToAll, OperationContinuationMode mode,
int expectedWriteCalls, int expectedWriteCallsSecondFile, int offsetHours = -1)
{
var now = DateTime.UtcNow;
var nowWithOffset = now.AddHours(offsetHours);
_autoMocker
.Setup <IFileService, FileModel>(m => m.GetFile(SourceName))
.Returns(new FileModel {
LastModifiedDateTime = now
});
_autoMocker
.Setup <IFileService, FileModel>(m => m.GetFile(DestinationName))
.Returns(new FileModel {
LastModifiedDateTime = nowWithOffset
});
_autoMocker
.Setup <IFileService>(
m => m.CopyAsync(SourceName, DestinationName, It.IsAny <CancellationToken>(), false))
.Verifiable();
_autoMocker
.Setup <IFileService, Task <bool> >(m =>
m.CopyAsync(SourceName, DestinationName, It.IsAny <CancellationToken>(), true))
.ReturnsAsync(true)
.Verifiable();
_autoMocker
.Setup <IFileService, Task <bool> >(m =>
m.CopyAsync(SourceName, SecondDestinationName, It.IsAny <CancellationToken>(), false))
.ReturnsAsync(true)
.Verifiable();
_autoMocker
.Setup <IFileService, bool>(m => m.CheckIfExists(DestinationName))
.Returns(true);
var operationsFactory = _autoMocker.CreateInstance <OperationsFactory>();
var settings = new BinaryFileSystemOperationSettings(
new string[] { },
new[] { SourceName },
new string[] { },
new[] { DestinationName },
new Dictionary <string, string>
{
[SourceName] = DestinationName
},
new string[] { }
);
var copyOperation = operationsFactory.CreateCopyOperation(settings);
var callbackCallsCount = 0;
copyOperation.StateChanged += async(sender, args) =>
{
if (args.OperationState != OperationState.Blocked)
{
return;
}
var operation = (IOperation)sender;
if (operation is null)
{
return;
}
callbackCallsCount++;
var(sourceFilePath, _) = operation.CurrentBlockedFile;
var options = mode is OperationContinuationMode.Rename
? OperationContinuationOptions.CreateRenamingContinuationOptions(sourceFilePath, applyToAll,
SecondDestinationName)
: OperationContinuationOptions.CreateContinuationOptions(sourceFilePath, applyToAll, mode);
await copyOperation.ContinueAsync(options);
};
await copyOperation.RunAsync();
Assert.Equal(1, callbackCallsCount);
Assert.Equal(OperationState.Finished, copyOperation.State);
_autoMocker
.Verify <IFileService>(
m => m.CopyAsync(SourceName, DestinationName, It.IsAny <CancellationToken>(), true),
Times.Exactly(expectedWriteCalls));
_autoMocker
.Verify <IFileService>(
m => m.CopyAsync(SourceName, SecondDestinationName, It.IsAny <CancellationToken>(), true),
Times.Exactly(expectedWriteCallsSecondFile));
}
public async Task TestBlockedCopyOperationMultiple(bool applyToAll, int expectedCallbackCallsCount,
OperationContinuationMode mode, int expectedWriteCallsCountFirstFile, int expectedWriteCallsCountSecondFile,
int expectedWriteCallsCountThirdFile, int expectedWriteCallsCountFourthFile)
{
_autoMocker
.Setup <IFileNameGenerationService, string>(m => m.GenerateFullName(It.IsAny <string>()))
.Returns <string>(GetNewFileName);
var taskCompletionSource = new TaskCompletionSource <bool>();
var secondTaskCompletionSource = new TaskCompletionSource <bool>();
var copyOperation = new Mock <IInternalOperation>();
copyOperation
.SetupGet(m => m.State)
.Returns(OperationState.Blocked);
var blockedOperation = copyOperation.As <ISelfBlockingOperation>();
blockedOperation
.Setup(m => m.CurrentBlockedFile)
.Returns((SourceName, DestinationName));
blockedOperation
.Setup(m => m.ContinueAsync(It.Is <OperationContinuationOptions>(
o => o.ApplyToAll == applyToAll &&
o.Mode == mode)))
.Returns(() =>
{
copyOperation
.SetupGet(m => m.State)
.Returns(OperationState.Finished);
copyOperation.Raise(m => m.StateChanged += null,
new OperationStateChangedEventArgs(OperationState.Finished));
taskCompletionSource.SetResult(true);
return(Task.CompletedTask);
})
.Verifiable();
copyOperation
.Setup(m => m.RunAsync(It.IsAny <CancellationToken>()))
.Returns(async() =>
{
copyOperation.Raise(m => m.StateChanged += null,
new OperationStateChangedEventArgs(OperationState.Blocked));
await taskCompletionSource.Task;
});
var secondCopyOperation = new Mock <IInternalOperation>();
secondCopyOperation
.SetupGet(m => m.State)
.Returns(OperationState.Blocked);
var secondBlockedOperation = secondCopyOperation.As <ISelfBlockingOperation>();
secondBlockedOperation
.Setup(m => m.CurrentBlockedFile)
.Returns((SecondSourceName, SecondDestinationName));
secondBlockedOperation
.Setup(m => m.ContinueAsync(It.Is <OperationContinuationOptions>(
o => o.ApplyToAll == applyToAll &&
o.Mode == mode)))
.Returns(() =>
{
secondCopyOperation
.SetupGet(m => m.State)
.Returns(OperationState.Finished);
secondCopyOperation.Raise(m => m.StateChanged += null,
new OperationStateChangedEventArgs(OperationState.Finished));
secondTaskCompletionSource.SetResult(true);
return(Task.CompletedTask);
})
.Verifiable();
secondCopyOperation
.Setup(m => m.RunAsync(It.IsAny <CancellationToken>()))
.Returns(async() =>
{
secondCopyOperation.Raise(m => m.StateChanged += null,
new OperationStateChangedEventArgs(OperationState.Blocked));
await secondTaskCompletionSource.Task;
});
IReadOnlyList <OperationGroup> operationGroups = new List <OperationGroup>
{
new OperationGroup(
new[] { copyOperation.Object }),
new OperationGroup(
new[] { secondCopyOperation.Object })
};
_autoMocker.Use(operationGroups);
var settings = new BinaryFileSystemOperationSettings(
new string[] { },
new[] { SourceName, SecondSourceName },
new string[] { },
new[] { DestinationName, SecondDestinationName },
new Dictionary <string, string>
{
[SourceName] = DestinationName,
[SecondSourceName] = SecondDestinationName
},
new string[] { }
);
_autoMocker.Use(new OperationInfo(OperationType.Copy, settings));
var operation = _autoMocker.CreateInstance <CompositeOperation>();
var callbackCallsCount = 0;
operation.Blocked += async(sender, args) =>
{
callbackCallsCount++;
var(sourceFilePath, _) = operation.CurrentBlockedFile;
var options = mode is OperationContinuationMode.Rename
? OperationContinuationOptions.CreateRenamingContinuationOptions(sourceFilePath, applyToAll,
GetNewFileName(sourceFilePath))
: OperationContinuationOptions.CreateContinuationOptions(sourceFilePath, applyToAll, mode);
await operation.ContinueAsync(options);
};
var task = operation.RunAsync();
var firstTask = await Task.WhenAny(task, Task.Delay(1000));
Assert.Equal(task, firstTask);
Assert.Equal(expectedCallbackCallsCount, callbackCallsCount);
blockedOperation
.Verify(m => m.ContinueAsync(It.Is <OperationContinuationOptions>(
o => o.ApplyToAll == applyToAll &&
o.Mode == mode &&
o.FilePath == SourceName &&
o.NewFilePath == null)),
Times.Exactly(expectedWriteCallsCountFirstFile));
blockedOperation
.Verify(m => m.ContinueAsync(It.Is <OperationContinuationOptions>(
o => o.ApplyToAll == applyToAll &&
o.Mode == mode &&
o.FilePath == SourceName &&
o.NewFilePath == ThirdDestinationName)),
Times.Exactly(expectedWriteCallsCountThirdFile));
secondBlockedOperation
.Verify(m => m.ContinueAsync(It.Is <OperationContinuationOptions>(
o => o.ApplyToAll == applyToAll &&
o.Mode == mode &&
o.FilePath == SecondSourceName &&
o.NewFilePath == null)),
Times.Exactly(expectedWriteCallsCountSecondFile));
secondBlockedOperation
.Verify(m => m.ContinueAsync(It.Is <OperationContinuationOptions>(
o => o.ApplyToAll == applyToAll &&
o.Mode == mode &&
o.FilePath == SecondSourceName &&
o.NewFilePath == FourthDestinationName)),
Times.Exactly(expectedWriteCallsCountFourthFile));
}
private static OperationInfo CreateOperationInfo(OperationType operationType, BinaryFileSystemOperationSettings settings) => new OperationInfo(operationType, settings);
public async Task TestBlockedOperationCancel()
{
var taskCompletionSource = new TaskCompletionSource <bool>();
_autoMocker
.Setup <IApplicationDispatcher>(m => m.Dispatch(It.IsAny <Action>()))
.Callback <Action>(action => action());
_autoMocker
.Setup <IApplicationDispatcher>(m => m.DispatchAsync(It.IsAny <Func <Task> >()))
.Callback <Func <Task> >(async func =>
{
await func();
taskCompletionSource.SetResult(true);
});
var viewModel = _autoMocker.CreateInstance <OperationsStatesListViewModel>();
var state = OperationState.InProgress;
var operationMock = new Mock <IOperation>();
operationMock
.Setup(m => m.CancelAsync())
.Verifiable();
operationMock
.SetupGet(m => m.State)
.Returns(() => state);
operationMock
.SetupGet(m => m.CurrentBlockedFile)
.Returns((Source, Destination));
var array = new string[0];
var dictionary = new Dictionary <string, string>();
for (var i = 0; i < 5; i++)
{
dictionary[i.ToString()] = i.ToString();
}
var settings = new BinaryFileSystemOperationSettings(
array, array,
array, array, dictionary, array);
var operationInfo = new OperationInfo(OperationType.Copy, settings);
operationMock
.SetupGet(m => m.Info)
.Returns(operationInfo);
var operationStartedEventArgs = new OperationStartedEventArgs(operationMock.Object);
_autoMocker
.GetMock <IOperationsStateService>()
.Raise(m => m.OperationStarted += null, operationStartedEventArgs);
Assert.True(viewModel.AreAnyOperationsAvailable);
state = OperationState.Blocked;
var operationStateChangedEventArgs = new OperationStateChangedEventArgs(state);
operationMock.Raise(m => m.StateChanged += null, operationStateChangedEventArgs);
Assert.True(viewModel.AreAnyOperationsAvailable);
var task = await Task.WhenAny(Task.Delay(1000), taskCompletionSource.Task);
if (task != taskCompletionSource.Task)
{
taskCompletionSource.SetResult(false);
}
var result = await taskCompletionSource.Task;
Assert.True(result);
await Task.Delay(500);
operationMock.Verify(m => m.CancelAsync(), Times.Once);
}
public async Task TestInProgressOperation(OperationState operationState, bool isLastSuccessful)
{
var stateViewModelMock = new Mock <IOperationStateViewModel>();
stateViewModelMock
.Setup(m => m.State)
.Returns(operationState);
_autoMocker
.Setup <IApplicationDispatcher>(m => m.Dispatch(It.IsAny <Action>()))
.Callback <Action>(action => action());
_autoMocker
.Setup <IOperationStateViewModelFactory, IOperationStateViewModel>(m => m.Create(It.IsAny <IOperation>()))
.Returns(stateViewModelMock.Object);
var configuration = new OperationsStatesConfiguration
{
MaximumFinishedOperationsCount = 1
};
_autoMocker.Use(configuration);
var viewModel = _autoMocker.CreateInstance <OperationsStatesListViewModel>();
var state = OperationState.InProgress;
var operationMock = new Mock <IOperation>();
operationMock
.SetupGet(m => m.State)
.Returns(() => state);
var array = new string[0];
var dictionary = new Dictionary <string, string>();
for (var i = 0; i < 5; i++)
{
dictionary[i.ToString()] = i.ToString();
}
var settings = new BinaryFileSystemOperationSettings(
array, array,
array, array, dictionary, array);
var operationInfo = new OperationInfo(OperationType.Copy, settings);
operationMock
.SetupGet(m => m.Info)
.Returns(operationInfo);
Assert.False(viewModel.IsInProgress);
Assert.Equal(0, viewModel.TotalProgress);
var operationStartedEventArgs = new OperationStartedEventArgs(operationMock.Object);
_autoMocker
.GetMock <IOperationsStateService>()
.Raise(m => m.OperationStarted += null, operationStartedEventArgs);
Assert.NotEmpty(viewModel.ActiveOperations);
Assert.Single(viewModel.ActiveOperations);
Assert.Empty(viewModel.InactiveOperations);
_autoMocker
.Setup <IOperationsStateService, IReadOnlyList <IOperation> >(m => m.ActiveOperations)
.Returns(new[] { operationMock.Object });
const double progress = 0.5;
var args = new OperationProgressChangedEventArgs(progress);
operationMock
.Setup(m => m.CurrentProgress)
.Returns(progress);
operationMock
.Raise(m => m.ProgressChanged += null, args);
Assert.NotEmpty(viewModel.ActiveOperations);
Assert.Single(viewModel.ActiveOperations);
Assert.Empty(viewModel.InactiveOperations);
Assert.True(viewModel.IsInProgress);
Assert.Equal(50, viewModel.TotalProgress);
var taskCompletionSource = new TaskCompletionSource <bool>();
_autoMocker
.Setup <IApplicationDispatcher>(m => m.Dispatch(It.IsAny <Action>()))
.Callback <Action>(action =>
{
action();
taskCompletionSource.SetResult(true);
});
state = operationState;
var finishedArgs = new OperationStateChangedEventArgs(state);
operationMock
.Raise(m => m.StateChanged += null, finishedArgs);
var task = await Task.WhenAny(Task.Delay(1000), taskCompletionSource.Task);
if (task != taskCompletionSource.Task)
{
taskCompletionSource.SetResult(false);
}
var result = await taskCompletionSource.Task;
Assert.True(result);
Assert.NotEmpty(viewModel.InactiveOperations);
Assert.Single(viewModel.InactiveOperations);
Assert.Empty(viewModel.ActiveOperations);
Assert.Equal(viewModel.IsLastOperationSuccessful, isLastSuccessful);
}
public async Task TestBlockedOperationCancel()
{
var copyOperation = new Mock <IInternalOperation>();
copyOperation
.SetupGet(m => m.State)
.Returns(OperationState.Blocked);
var blockedOperation = copyOperation.As <ISelfBlockingOperation>();
blockedOperation
.Setup(m => m.CurrentBlockedFile)
.Returns((SourceName, DestinationName));
copyOperation
.Setup(m => m.RunAsync(It.IsAny <CancellationToken>()))
.Callback(() =>
{
copyOperation.Raise(m => m.StateChanged += null,
new OperationStateChangedEventArgs(OperationState.Blocked));
});
IReadOnlyList <OperationGroup> operationGroups = new List <OperationGroup>
{
new OperationGroup(
new[] { copyOperation.Object })
};
_autoMocker.Use(operationGroups);
var settings = new BinaryFileSystemOperationSettings(
new string[] { },
new[] { SourceName },
new string[] { },
new[] { DestinationName },
new Dictionary <string, string> {
[SourceName] = DestinationName
},
new string[] { }
);
_autoMocker.Use(new OperationInfo(OperationType.Copy, settings));
var operation = _autoMocker.CreateInstance <CompositeOperation>();
var taskCompletionSource = new TaskCompletionSource <bool>();
operation.Blocked += async(sender, args) =>
{
if (operation.CurrentBlockedFile == (SourceName, DestinationName))
{
await operation.CancelAsync();
taskCompletionSource.SetResult(true);
}
};
await operation.RunAsync();
var task = await Task.WhenAny(Task.Delay(500), taskCompletionSource.Task);
if (task != taskCompletionSource.Task)
{
taskCompletionSource.SetResult(false);
}
var result = await taskCompletionSource.Task;
Assert.True(result);
}
}
public async Task TestBlockedCopyOperation(bool applyToAll, int expectedCallbackCallsCount,
OperationContinuationMode mode, int expectedWriteCallsCountFirstFile, int expectedWriteCallsCountSecondFile)
{
var now = DateTime.UtcNow;
var hourBeforeNow = now.AddHours(-1);
_autoMocker
.Setup <IFileService, FileModel>(m => m.GetFile(SourceName))
.Returns(new FileModel {
LastModifiedDateTime = now
});
_autoMocker
.Setup <IFileService, FileModel>(m => m.GetFile(DestinationName))
.Returns(new FileModel {
LastModifiedDateTime = hourBeforeNow
});
_autoMocker
.Setup <IFileService, FileModel>(m => m.GetFile(SecondSourceName))
.Returns(new FileModel {
LastModifiedDateTime = hourBeforeNow
});
_autoMocker
.Setup <IFileService, FileModel>(m => m.GetFile(SecondDestinationName))
.Returns(new FileModel {
LastModifiedDateTime = now
});
_autoMocker
.Setup <IFileService>(m => m.CopyAsync(SourceName, DestinationName, false))
.Verifiable();
_autoMocker
.Setup <IFileService, Task <bool> >(m => m.CopyAsync(SourceName, DestinationName, true))
.ReturnsAsync(true)
.Verifiable();
_autoMocker
.Setup <IFileService>(m => m.CopyAsync(SecondSourceName, SecondDestinationName, false))
.Verifiable();
_autoMocker
.Setup <IFileService, Task <bool> >(m => m.CopyAsync(SecondSourceName, SecondDestinationName, true))
.ReturnsAsync(true)
.Verifiable();
_autoMocker
.Setup <IFileService, bool>(m => m.CheckIfExists(It.IsAny <string>()))
.Returns(true);
var operationsFactory = _autoMocker.CreateInstance <OperationsFactory>();
var settings = new BinaryFileSystemOperationSettings(
new string[] { },
new[] { SourceName, SecondSourceName },
new string[] { },
new[] { DestinationName, SecondDestinationName },
new Dictionary <string, string>
{
[SourceName] = DestinationName,
[SecondSourceName] = SecondDestinationName
},
new string[] { }
);
var copyOperation = operationsFactory.CreateCopyOperation(settings);
var callbackCallsCount = 0;
copyOperation.StateChanged += async(sender, args) =>
{
if (args.OperationState != OperationState.Blocked)
{
return;
}
var operation = (IOperation)sender;
if (operation is null)
{
return;
}
Interlocked.Increment(ref callbackCallsCount);
var(sourceFilePath, _) = operation.CurrentBlockedFile;
var options = OperationContinuationOptions.CreateContinuationOptions(sourceFilePath, applyToAll, mode);
await copyOperation.ContinueAsync(options);
};
await copyOperation.RunAsync();
Assert.Equal(expectedCallbackCallsCount, callbackCallsCount);
Assert.Equal(OperationState.Finished, copyOperation.State);
_autoMocker
.Verify <IFileService>(m => m.CopyAsync(SourceName, DestinationName, true), Times.Exactly(expectedWriteCallsCountFirstFile));
_autoMocker
.Verify <IFileService>(m => m.CopyAsync(SecondSourceName, SecondDestinationName, true), Times.Exactly(expectedWriteCallsCountSecondFile));
_autoMocker
.Verify <IFileService>(m => m.CopyAsync(SourceName, DestinationName, false), Times.Never);
_autoMocker
.Verify <IFileService>(m => m.CopyAsync(SecondSourceName, SecondDestinationName, false), Times.Never);
}
