public void CreatesFolder()
{
_engine = new AutomationEngineInstance(null);
_createFolder = new CreateFolderCommand();
string folderName = "newFolder";
VariableMethods.CreateTestVariable(folderName, _engine, "folderName", typeof(string));
string projectDirectory = Directory.GetParent(Environment.CurrentDirectory).Parent.FullName;
string inputPath = Path.Combine(projectDirectory, @"Resources");
VariableMethods.CreateTestVariable(inputPath, _engine, "inputPath", typeof(string));
_createFolder.v_NewFolderName = "{folderName}";
_createFolder.v_DestinationDirectory = "{inputPath}";
_createFolder.v_DeleteExisting = "Yes";
_createFolder.RunCommand(_engine);
string finalPath = Path.Combine(inputPath, folderName);
Assert.True(Directory.Exists(finalPath));
Directory.Delete(finalPath);
}
public async Task Handle_Invalid_Throws()
{
// arrange
var request = new CreateFolderCommand()
{
Name = "Test",
ParentFolderId = new Guid("97b7e004-be8e-424d-90c9-fa070996beb1")
};
var repositoryMock = new Mock <IRepository <Folder> >();
repositoryMock.Setup(x => x.Insert(It.IsAny <Folder>(), CancellationToken.None)).ThrowsAsync(new Exception());
var _mediatorMock = new Mock <IMediator>();
_mediatorMock.Setup(x => x.Send(It.IsAny <GetFolderQuery>(), CancellationToken.None)).ReturnsAsync(new FolderDto()
{
HierarchyId = "/Test/"
});
var handler = new CreateFolderCommandHandler(repositoryMock.Object, AutomapperFactory.Get(), _mediatorMock.Object);
// act
await Assert.ThrowsAsync <CreateException>(() => handler.Handle(request, CancellationToken.None));
// assert
repositoryMock.Verify(x => x.Insert(It.IsAny <Folder>(), CancellationToken.None), Times.Once);
repositoryMock.VerifyNoOtherCalls();
}
public async Task Handle_Valid_Inserts()
{
// arrange
var request = new CreateFolderCommand()
{
Name = "Test",
};
var mockRes = new Guid("a87887ec-df44-4607-9e6f-28f361670f9b");
Folder folderToAssert = null;
var repositoryMock = new Mock <IFolderRepository>();
var insertSetup = repositoryMock.Setup(x => x.Insert(It.IsAny <Folder>(), CancellationToken.None));
insertSetup.ReturnsAsync(mockRes);
insertSetup.Callback((Folder folder, CancellationToken _) => folderToAssert = folder);
var _mediatorMock = new Mock <IMediator>();
_mediatorMock.Setup(x => x.Send(It.IsAny <GetParentHierarchyQuery>(), CancellationToken.None))
.ReturnsAsync("/Test/");
var handler = new CreateFolderCommandHandler(repositoryMock.Object, AutomapperFactory.Get(), _mediatorMock.Object);
// act
var result = await handler.Handle(request, CancellationToken.None);
// assert
repositoryMock.Verify(x => x.Insert(It.IsAny <Folder>(), CancellationToken.None), Times.Once);
repositoryMock.VerifyNoOtherCalls();
Assert.Equal(mockRes, result);
Assert.Equal(folderToAssert.Name, request.Name);
Assert.Equal(folderToAssert.HierarchyId, $"/Test/Test/");
}
public static async Task <BoxFolder> CreateFolder(string parentId = "0", CommandScope commandScope = CommandScope.Test, CommandAccessLevel accessLevel = CommandAccessLevel.User)
{
var createFolderCommand = new CreateFolderCommand(GetUniqueName("folder"), parentId, commandScope, accessLevel);
await ExecuteCommand(createFolderCommand);
return(createFolderCommand.Folder);
}
public void Validate_NameIsNullString_Invalid()
{
var validator = new CreateFolderCommandValidator();
var query = new CreateFolderCommand(null, null);
var result = validator.Validate(query);
Assert.False(result.IsValid);
}
public void Validate_ValidRequest()
{
var validator = new CreateFolderCommandValidator();
var query1 = new CreateFolderCommand("Test", null);
var result1 = validator.Validate(query1);
Assert.True(result1.IsValid);
}
public void CreateFolder_FolderAlreadyExists_ThrowsFolderNameMustBeUniqueInParentRequestException()
{
var command = new CreateFolderCommand("newFolder", 3);
var handlerSetup = CreateFoldersCommandHandlerFactory.CreateSetup(
isUniqueInParent: false);
var handler = handlerSetup.Handler;
Should.Throw <FolderNameMustBeUniqueInParentRequestException>(
async() => await handler.Handle(command, CancellationToken.None));
}
public void Undo_no_folder_created_no_delete_attempted()
{
FakeFolder folder = new FakeFolder(@"C:\testFolder");
ICommand createFolderComand = new CreateFolderCommand(folder);
createFolderComand.Undo();
Assert.IsFalse(folder.DeleteFolderCalled);
}
public void Execute_Creates_Folder()
{
FakeFolder folder = new FakeFolder(@"C:\testFolder");
ICommand createFolderComand = new CreateFolderCommand(folder);
createFolderComand.Execute();
Assert.IsTrue(folder.CreateFolderCalled);
}
public void CreateFolder_ParentFolderDoesNotExists_ThrowsParentFolderDoesNotExistRequestException()
{
var command = new CreateFolderCommand("newFolder", 3);
var handlerSetup = CreateFoldersCommandHandlerFactory.CreateSetup(
exists: false);
var handler = handlerSetup.Handler;
Should.Throw <ParentFolderDoesNotExistRequestException>(
async() => await handler.Handle(command, CancellationToken.None));
}
public void Undo_created_folder_deleted()
{
FakeFolder folder = new FakeFolder(@"C:\testFolder");
ICommand createFolderComand = new CreateFolderCommand(folder);
createFolderComand.Execute();
createFolderComand.Undo();
Assert.IsTrue(folder.DeleteFolderCalled);
}
public async Task CreateFolder_ValidAndUniqueName_FolderIsCreatedWithCorrectValues(int?parentId)
{
var command = new CreateFolderCommand("newFolder", parentId);
var handlerSetup = CreateFoldersCommandHandlerFactory.CreateSetup(
exists: true, isUniqueInParent: true);
var handler = handlerSetup.Handler;
await handler.Handle(command, CancellationToken.None);
handlerSetup.FoldersRepository.Verify(
x => x.AddAsync(It.IsAny <Folder>()), Times.Once);
}
public void Status_return_status_with_current_folder_name_in()
{
String folderName = @"C:\testFolder";
FakeFolder folder = new FakeFolder(folderName);
folder.FolderExistsReturnValue = true;
ICommand createFolderComand = new CreateFolderCommand(folder);
String status = createFolderComand.UserFeedback;
Assert.IsTrue(status.Contains(folderName));
}
public void Execute_folder_exists_no_create_called()
{
FakeFolder folder = new FakeFolder(@"C:\testFolder");
folder.FolderExistsReturnValue = true;
ICommand createFolderComand = new CreateFolderCommand(folder);
createFolderComand.Execute();
Assert.IsFalse(folder.CreateFolderCalled);
}
public void Undo_folder_existed_before_execute_no_delete_attempted()
{
FakeFolder folder = new FakeFolder(@"C:\testFolder");
folder.FolderExistsReturnValue = true;
ICommand createFolderComand = new CreateFolderCommand(folder);
createFolderComand.Execute();
createFolderComand.Undo();
Assert.IsFalse(folder.DeleteFolderCalled);
}
public IActionResult CreateFolder(EditFolderModel model, [FromServices] CreateFolderCommand createFolderCommand)
{
var messages = createFolderCommand.Validate(model);
if (messages.Count > 0)
{
ModelState.AddModelError("_FORM", messages[0]);
return(View(model));
}
createFolderCommand.Execute(model);
return(Redirect(Url.Content("~/")));
}
public async Task <CreateFolderResult> CreateFoldersAsync(IEnumerable <string> names, EwsFolderIdentifier identifier)
{
var parameter = new CreateFolderParameter {
ParentFolderIdentifier = identifier
};
parameter.Names.AddRange(names);
var command = new CreateFolderCommand(parameter, this.settings);
var result = await command.Execute();
return(result.Data);
}
public async Task <ActionResult <FolderResource> > Post([FromBody] FolderResource folder)
{
try
{
var command = new CreateFolderCommand(folder.Name);
var folderId = await mediator.Send(command);
var query = new ReadFolderQuery(folderId);
var response = await mediator.Send(query);
var folderResource = new FolderResource(response);
folderResource.EnrichWithLinks(this);
return(folderResource);
}
catch (FolderNameMustBeUniqueInParentRequestException)
{
return(this.BadRequest(ApiErrors.FolderNameMustBeUniqueInParent));
}
}
public async global::System.Threading.Tasks.Task HandlesInvalidFilepathInput()
{
_engine = new AutomationEngineInstance(null);
_createFolder = new CreateFolderCommand();
string folderName = "newFolder";
VariableMethods.CreateTestVariable(folderName, _engine, "folderName", typeof(string));
string projectDirectory = Directory.GetParent(Environment.CurrentDirectory).Parent.FullName;
string inputPath = "notADirectoryPath";
VariableMethods.CreateTestVariable(inputPath, _engine, "inputPath", typeof(string));
_createFolder.v_NewFolderName = "{folderName}";
_createFolder.v_DestinationDirectory = "{inputPath}";
_createFolder.v_DeleteExisting = "Yes";
await Assert.ThrowsAsync <DirectoryNotFoundException>(() => _createFolder.RunCommand(_engine));
}
public async Task <IActionResult> Create([FromBody] CreateFolderCommand command, CancellationToken cancellationToken = default)
{
return(Ok(await Mediator.Send(command, cancellationToken)));
}
public async Task <ActionResult <int> > Create(CreateFolderCommand command)
{
return(await Mediator.Send(command));
}
public CreateFolderRequest(string folderName, IFolder parentFolder, RequestCompletedCallback callback)
: base(callback)
{
Command = new CreateFolderCommand(folderName, parentFolder, null);
ProcessorType = typeof(CreateFolderProcessor);
}
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);
}
public async Task <HttpResponseMessage> Create(CreateFolderCommand request)
{
var content = Utilities.GetRequestContent(request);
return(await _client.PostAsync($"api/Folder/", content));
}
