public void AppDisabled()
{
// ARRANGE
var uow = Container.Resolve <IUnitOfWork>();
var cmdDispatcher = Container.Resolve <ICommandHandlerDispatcher>();
var queryDispatcher = Container.Resolve <IQueryHandlerDispatcher>();
var cmd = new CreateAppCommand("AppDisabled", "AppDisabled", "AppDisabled", "x", "x", "x", 1);
cmdDispatcher.Handle(cmd);
var query = new GetAppByIdQuery("AppDisabled", cmd.AppId);
var dto = queryDispatcher.Handle <GetAppByIdQuery, AppDto>(query);
// ACT
Thread.Sleep(2000);
var cmd2 = new DisableAppCommand("AppDisabled", cmd.AppId);
cmdDispatcher.Handle(cmd2);
var query2 = new GetAppByIdQuery("AppDisabled", cmd2.AppId);
var dto2 = queryDispatcher.Handle <GetAppByIdQuery, AppDto>(query2);
// ASSERT
Assert.IsTrue(dto.IsEnabled);
Assert.IsFalse(dto2.IsEnabled);
uow.Commit();
}
public async Task <IActionResult> Post([FromBody] CreateAppCommand command)
{
var result = await _mediator.Send(command);
var resource = await _mediator.Send(new GetAppQuery { Id = result.Id });
return(CreatedAtAction("Get", _appControllerName, new { id = resource.Id }, resource));
}
public async Task Create_app_without_id_returns_validationerror()
{
// Arrange
var command = new CreateAppCommand();
var handler = new CreateAppCommandHandler(Substitute.For <IApplicationStore>(), new AppValidator());
// Act
var result = await handler.Handle(command);
// Assert
Assert.Contains(result.ValidationErrors, err => err.Name == "Id");
}
public async Task Create_app_with_invalid_characters_returns_validationerror(string appId)
{
// Arrange
var command = new CreateAppCommand
{
Id = appId,
DisplayName = "Test"
};
var handler = new CreateAppCommandHandler(Substitute.For <IApplicationStore>(), new AppValidator());
// Act
var result = await handler.Handle(command);
// Assert
Assert.Contains(result.ValidationErrors, err => err.Name == "Id");
}
public void ModuleCreated()
{
// ARRANGE
var uow = Container.Resolve <IUnitOfWork>();
var cmdDispatcher = Container.Resolve <ICommandHandlerDispatcher>();
var cmd = new CreateAppCommand("CreateModule", "CreateModule", "x", "x", "x", "x", 1);
var cmd2 = new CreateModuleCommand("CreateModule", cmd.AppId, "CreateModule", "CreateModule", "CreateModule", "CreateModule", "CreateModule", 1);
// ACT
cmdDispatcher.Handle(cmd);
cmdDispatcher.Handle(cmd2);
// ASSERT
uow.Commit();
}
public async Task Create_app_with_nonexisting_defaultlanguage_returns_validationerror()
{
// Arrange
var command = new CreateAppCommand
{
Id = "test",
DisplayName = "Test",
Languages = new [] { "en", "fr" },
DefaultLanguage = "nl"
};
var handler = new CreateAppCommandHandler(Substitute.For <IApplicationStore>(), new AppValidator());
// Act
var result = await handler.Handle(command);
// Assert
Assert.Contains(result.ValidationErrors, err => err.ErrorMessage == "DefaultLanguageNotInLanguages");
}
public async Task Create_valid_app_returns_no_errors()
{
// Arrange
var command = new CreateAppCommand
{
Id = "test",
DisplayName = "Test",
Languages = new [] { "en" },
DefaultLanguage = "en"
};
var handler = new CreateAppCommandHandler(Substitute.For <IApplicationStore>(), new AppValidator());
// Act
var result = await handler.Handle(command);
// Assert
Assert.Equal(ResultStatus.Success, result.Status);
}
public void AppCreated()
{
// ARRANGE
var uow = Container.Resolve <IUnitOfWork>();
var cmdDispatcher = Container.Resolve <ICommandHandlerDispatcher>();
for (var i = 0; i < 10; i++)
{
var cmd = new CreateAppCommand("x" + i.ToString(), "x" + i.ToString(), "x" + i.ToString(), "x", "x", "x", 1);
// ACT
cmdDispatcher.Handle(cmd);
}
// ASSERT
uow.Commit();
}
public async Task Create_app_with_existing_id_returns_validationerror()
{
// Arrange
var command = new CreateAppCommand
{
Id = "test",
DisplayName = "A new app with existing id",
Languages = new[] { "en" },
DefaultLanguage = "en"
};
var applicationStore = Substitute.For <IApplicationStore>();
applicationStore.AppExists("test").Returns(true);
var handler = new CreateAppCommandHandler(applicationStore, new AppValidator());
// Act
var result = await handler.Handle(command);
// Assert
Assert.Equal(ResultStatus.ValidationError, result.Status);
Assert.Contains(result.ValidationErrors, err => err.ErrorMessage == "AppIdAlreadyExists");
}
public void ShouldNotSetupApplicationIfAlreadyConfigured([Frozen] Mock <IApplicationConfiguration> applicationConfiguration, [Frozen] Mock <TextWriter> writer, CreateAppCommand command, string[] arguments, string applicationName)
{
applicationConfiguration.Setup(x => x.GetApplicationId()).Returns(applicationName);
command.Execute(arguments);
writer.Verify(x => x.WriteLine("This directory is already configured to track application \"{0}\".", applicationName), Times.Once());
}
public void ShouldSetupApplicationLocallyAfterCreationIfNotConfigured([Frozen] Mock <IApplicationConfiguration> applicationConfiguration, [Frozen] Mock <IAppHarborClient> client, CreateAppCommand command, CreateResult result, User user, string[] arguments)
{
client.Setup(x => x.CreateApplication(It.IsAny <string>(), It.IsAny <string>())).Returns(result);
client.Setup(x => x.GetUser()).Returns(user);
applicationConfiguration.Setup(x => x.GetApplicationId()).Throws <ApplicationConfigurationException>();
command.Execute(arguments);
applicationConfiguration.Verify(x => x.SetupApplication(result.Id, user), Times.Once());
}
public void ShouldCreateApplicationWithOnlyName([Frozen] Mock <IAppHarborClient> client, CreateAppCommand command)
{
var arguments = new string[] { "foo" };
command.Execute(arguments);
client.Verify(x => x.CreateApplication(arguments.First(), arguments.Skip(1).FirstOrDefault()), Times.Once());
}
public void ShouldThrowWhenNoArguments(CreateAppCommand command)
{
var exception = Assert.Throws <CommandException>(() => command.Execute(new string[0]));
Assert.Equal("An application name must be provided to create an application", exception.Message);
}
