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); }