public async Task<IHttpActionResult> Post(string boardSlug, BoardTask boardTask)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
try
{
var result = await commandDispatcher.HandleAsync<CreateBoardTaskCommand, BoardTask>(new CreateBoardTaskCommand
{
BoardSlug = boardSlug,
BoardTask = boardTask
});
hyperMediaFactory.Apply(result);
return Created(hyperMediaFactory.GetLink(result, Link.SELF), result);
}
catch (BoardColumnNotFoundException)
{
return BadRequest("Board Column Not Found");
}
catch (BoardNotFoundException)
{
return NotFound();
}
}
public void GiveAObjWhenIsABoardThenReturnsTrue()
{
// Arrange
SetupState();
var boardTask = new BoardTask();
// Act
var isAppliable = state.IsAppliable(boardTask);
// Assert
Assert.True(isAppliable);
}
public void GivenAObjWhenIsABoardThenSelfLinkAdded()
{
// Arrange
SetupState();
mockLinkFactory.Setup(x => x.Build("BoardTaskGet", It.IsAny<object>())).Returns("http://fake-url/");
var boardTask = new BoardTask();
// Act
state.Apply(boardTask);
// Assert
Assert.NotNull(boardTask.Links);
Assert.NotNull(boardTask.Links.FirstOrDefault(x => x.Rel == Link.SELF));
}
public async void GivenABoardSlugSlugAndTaskWhenBoardExistsThenHyperMediaSet()
{
// Arrange
SetupController();
const string boardSlug = "board-name";
var boardTask = new BoardTask();
mockCommandDispatcher.Setup(
x => x.HandleAsync<CreateBoardTaskCommand, BoardTask>(It.IsAny<CreateBoardTaskCommand>()))
.ReturnsAsync(new BoardTask());
mockHyperMediaFactory.Setup(x => x.GetLink(It.IsAny<IHyperMediaItem>(), It.IsAny<string>()))
.Returns("http://fake-url/");
// Act
await controller.Post(boardSlug, boardTask);
// Assert
mockHyperMediaFactory.Verify(x => x.Apply(It.IsAny<BoardTask>()), Times.Once);
}
public async void GivenABoardSlugAndTaskWhenBoardAndColumnExistsThenReturnOkResult()
{
// Arrange
SetupController();
const string boardSlug = "board-name";
var boardTask = new BoardTask();
mockCommandDispatcher.Setup(
x => x.HandleAsync<CreateBoardTaskCommand, BoardTask>(It.IsAny<CreateBoardTaskCommand>()))
.ReturnsAsync(new BoardTask());
mockHyperMediaFactory.Setup(x => x.GetLink(It.IsAny<IHyperMediaItem>(), It.IsAny<string>()))
.Returns("http://fake-url/");
// Act
var createdNegotiatedContentResult =
await controller.Post(boardSlug, boardTask) as CreatedNegotiatedContentResult<BoardTask>;
// Assert
Assert.NotNull(createdNegotiatedContentResult);
}
public async Task<IHttpActionResult> Put(string boardSlug, int taskId, BoardTask boardTask)
{
try
{
var result = await commandDispatcher.HandleAsync<UpdateBoardTaskCommand, BoardTask>(new UpdateBoardTaskCommand
{
BoardSlug = boardSlug,
BoardTask = boardTask
});
hyperMediaFactory.Apply(result);
return Ok(result);
}
catch (BoardTaskNotFoundException)
{
return NotFound();
}
catch (BoardColumnNotFoundException)
{
return BadRequest("Board Column Not Found");
}
}
public async void GivenABoardSlugAndTaskWhenBoardColumnIsInvalidThenReturnInvalidModelState()
{
// Arrange
SetupController();
const string boardSlug = "board-name";
var boardTask = new BoardTask();
controller.ModelState.AddModelError("error", "error");
// Act
var invalidModelStateResult = await controller.Post(boardSlug, boardTask) as InvalidModelStateResult;
// Assert
Assert.NotNull(invalidModelStateResult);
}
public async void GivenABoardSlugTaskIdAndTaskWhenBoardColumnDoesNotExistThenBadRequestReturned()
{
// Arrange
SetupController();
const string boardSlug = "board-name";
const int taskId = 1;
var boardTask = new BoardTask
{
Id = taskId,
Name = "Updated Name"
};
mockCommandDispatcher.Setup(
x => x.HandleAsync<UpdateBoardTaskCommand, BoardTask>(It.IsAny<UpdateBoardTaskCommand>()))
.Throws<BoardColumnNotFoundException>();
// Act
var badRequestErrorMessageResult =
await controller.Put(boardSlug, taskId, boardTask) as BadRequestErrorMessageResult;
// Assert
Assert.NotNull(badRequestErrorMessageResult);
Assert.Equal("Board Column Not Found", badRequestErrorMessageResult.Message);
}
public async void GivenABoardSlugTaskIdAndTaskWhenAllAreValidThenHypermediaSet()
{
// Arrange
SetupController();
const string boardSlug = "board-name";
const int taskId = 1;
var boardTask = new BoardTask
{
Id = taskId,
Name = "Updated Name"
};
// Act
await controller.Put(boardSlug, taskId, boardTask);
// Assert
mockHyperMediaFactory.Verify(x => x.Apply(It.IsAny<object>()), Times.Once);
}
public async void GivenABoardSlugTaskIdAndTaskWhenAllAreValidThenUpdateBoardTaskCommandCalled()
{
// Arrange
SetupController();
const string boardSlug = "board-name";
const int taskId = 1;
var boardTask = new BoardTask
{
Id = taskId,
Name = "Updated Name"
};
// Act
await controller.Put(boardSlug, taskId, boardTask);
// Assert
mockCommandDispatcher.Verify(
x => x.HandleAsync<UpdateBoardTaskCommand, BoardTask>(It.Is<UpdateBoardTaskCommand>(
y => y.BoardSlug == boardSlug && y.BoardTask == boardTask
)), Times.Once);
}
public async void GivenABoardSlugTaskIdAndTaskWhenAllAreValidThenOkResultReturned()
{
// Arrange
SetupController();
const string boardSlug = "board-name";
const int taskId = 1;
var boardTask = new BoardTask
{
Id = taskId,
Name = "Updated Name"
};
// Act
var okNegotiatedContentResult =
await controller.Put(boardSlug, taskId, boardTask) as OkNegotiatedContentResult<BoardTask>;
// Assert
Assert.NotNull(okNegotiatedContentResult);
}
public async void GivenABoardSlugAndTaskWhenBoardDoesNotExistThenNotFound()
{
// Arrange
SetupController();
const string boardSlug = "board-name";
var boardTask = new BoardTask();
mockCommandDispatcher.Setup(
x => x.HandleAsync<CreateBoardTaskCommand, BoardTask>(It.IsAny<CreateBoardTaskCommand>()))
.Throws<BoardNotFoundException>();
// Act
var notFoundResult = await controller.Post(boardSlug, boardTask) as NotFoundResult;
// Assert
Assert.NotNull(notFoundResult);
}
