public async Task GetOrderSummaryAsync_ServiceRecipientCount_ReturnsCountOfTwo()
{
var order = OrderBuilder.Create().Build();
var context = OrdersControllerTestContext.Setup(order.OrganisationId);
context.Order = order;
context.ServiceRecipientListCount = 2;
var controller = context.OrdersController;
string expectedOrderId = context.Order.OrderId;
var response = (await controller.GetOrderSummaryAsync(expectedOrderId)).Result as OkObjectResult;
Assert.IsNotNull(response);
var actual = response.Value.As <OrderSummaryModel>();
var expected = OrderSummaryModelBuilder
.Create()
.WithOrderId(expectedOrderId)
.WithOrganisationId(order.OrganisationId)
.WithSections(SectionModelListBuilder
.Create()
.WithServiceRecipients(
SectionModel
.ServiceRecipients
.WithStatus("incomplete")
.WithCount(context.ServiceRecipientListCount))
.Build())
.Build();
actual.Should().BeEquivalentTo(expected);
}
public async Task CreateOrderAsync_CreateOrderFailureResult_ReturnsBadRequest()
{
var context = OrdersControllerTestContext.Setup();
var controller = context.OrdersController;
var errors = new List <ErrorDetails> {
new ErrorDetails("TestErrorId", "TestField")
};
var createOrderRequest = new CreateOrderModel
{
Description = "Test Order 1",
OrganisationId = context.PrimaryOrganisationId
};
context.CreateOrderResult = Result.Failure <string>(errors);
var response = await controller.CreateOrderAsync(createOrderRequest);
response.Should().BeOfType <ActionResult <CreateOrderResponseModel> >();
var actual = response.Result;
var expectedErrors =
new List <ErrorModel> {
new ErrorModel("TestErrorId", "TestField")
};
var expected = new BadRequestObjectResult(new CreateOrderResponseModel {
Errors = expectedErrors
});
actual.Should().BeEquivalentTo(expected);
}
public async Task CreateOrderAsync_CreateOrderSuccessfulResult_ReturnsOrderId()
{
const string newOrderId = "New Test Order Id";
var context = OrdersControllerTestContext.Setup();
context.CreateOrderResult = Result.Success(newOrderId);
var createOrderRequest = new CreateOrderModel
{
Description = "Test Order 1",
OrganisationId = context.PrimaryOrganisationId
};
var controller = context.OrdersController;
var response = await controller.CreateOrderAsync(createOrderRequest);
var actual = response.Result;
var expectation = new CreatedAtActionResult(nameof(controller.CreateOrderAsync).TrimAsync(), null,
new { orderId = newOrderId }, new CreateOrderResponseModel {
OrderId = newOrderId
});
actual.Should().BeEquivalentTo(expectation);
}
public async Task GetOrderSummaryAsync_OrderIdDoesNotExist_ReturnsNotFound()
{
var context = OrdersControllerTestContext.Setup();
var controller = context.OrdersController;
var response = await controller.GetOrderSummaryAsync("INVALID");
response.Should().BeEquivalentTo(new ActionResult <OrderSummaryModel>(new NotFoundResult()));
}
public async Task GetAll_OrdersByOrganisationId_CalledOnce()
{
var context = OrdersControllerTestContext.Setup();
var controller = context.OrdersController;
await controller.GetAllAsync(context.PrimaryOrganisationId);
context.OrderRepositoryMock.Verify(x => x.ListOrdersByOrganisationIdAsync(context.PrimaryOrganisationId),
Times.Once);
}
public async Task GetAllAsync_NoOrdersExist_ReturnsEmptyResult()
{
var context = OrdersControllerTestContext.Setup();
var controller = context.OrdersController;
var result = await controller.GetAllAsync(context.PrimaryOrganisationId) as OkObjectResult;
var orders = result.Value as List <OrderListItemModel>;
orders.Should().BeEmpty();
}
public void CreateOrderAsync_NullApplicationUser_ThrowsException()
{
var context = OrdersControllerTestContext.Setup();
async Task <ActionResult <CreateOrderResponseModel> > CreateOrder()
{
var controller = context.OrdersController;
return(await controller.CreateOrderAsync(null));
}
Assert.ThrowsAsync <ArgumentNullException>(CreateOrder);
}
public async Task CreateOrderAsync_CreateOrderService_CreateAsync_CalledOnce()
{
var context = OrdersControllerTestContext.Setup();
var controller = context.OrdersController;
var createOrderModel = new CreateOrderModel
{
Description = "Description1",
OrganisationId = context.PrimaryOrganisationId
};
await controller.CreateOrderAsync(createOrderModel);
context.CreateOrderServiceMock.Verify(x => x.CreateAsync(It.IsAny <CreateOrderRequest>()), Times.Once);
}
public async Task GetOrderSummaryAsync_OtherOrganisationId_ReturnResult()
{
var organisationId = Guid.NewGuid();
const string orderId = "C0000014-01";
var context = OrdersControllerTestContext.Setup();
(Order order, _) = CreateOrderSummaryTestData(orderId, "Some Description", organisationId);
context.Order = order;
var controller = context.OrdersController;
var response = await controller.GetOrderSummaryAsync(orderId);
response.Should().BeEquivalentTo(new ActionResult <OrderSummaryModel>(new ForbidResult()));
}
public async Task GetOrderSummaryAsync_IsSummaryComplete_ReturnResult()
{
const string orderId = "C0000014-01";
var context = OrdersControllerTestContext.Setup();
(Order order, OrderSummaryModel expected) =
CreateOrderSummaryTestData(orderId, "Some Description", context.PrimaryOrganisationId);
context.Order = order;
var controller = context.OrdersController;
var response = await controller.GetOrderSummaryAsync(orderId);
response.Should().BeEquivalentTo(new ActionResult <OrderSummaryModel>(new OkObjectResult(expected)));
}
public async Task GetAllAsync_SingleOrderWithOtherOrganisationIdExists_ReturnsForbidden()
{
var otherOrganisationId = Guid.NewGuid();
var context = OrdersControllerTestContext.Setup();
var orders = new List <(Order order, OrderListItemModel expected)>
{
CreateOrderTestData("C0000014-01", otherOrganisationId, "A description")
};
context.Orders = orders.Select(x => x.order);
var controller = context.OrdersController;
var result = await controller.GetAllAsync(otherOrganisationId);
result.Should().BeOfType <ForbidResult>();
}
public async Task GetOrderSummaryAsync_ServiceRecipientRepository_CalledOnce()
{
var order = OrderBuilder.Create().Build();
var context = OrdersControllerTestContext.Setup(order.OrganisationId);
context.Order = order;
context.ServiceRecipientListCount = 2;
var controller = context.OrdersController;
string expectedOrderId = context.Order.OrderId;
await controller.GetOrderSummaryAsync(expectedOrderId);
context.ServiceRecipientRepositoryMock.Verify(x => x.GetCountByOrderIdAsync(expectedOrderId), Times.Once);
}
public async Task GetOrderSummaryAsync_ChangeOrderData_ReturnsExpectedSummary(Order order,
OrderSummaryModel expected)
{
var context = OrdersControllerTestContext.Setup(order.OrganisationId);
context.Order = order;
var controller = context.OrdersController;
var response = (await controller.GetOrderSummaryAsync(context.Order.OrderId)).Result as OkObjectResult;
Assert.IsNotNull(response);
var actual = response.Value.As <OrderSummaryModel>();
actual.Should().BeEquivalentTo(expected);
}
public async Task GetAllAsync_SingleOrderWithOrganisationIdExists_ReturnsTheOrder(string orderId,
string orderDescription)
{
var context = OrdersControllerTestContext.Setup();
var orders = new List <(Order order, OrderListItemModel expected)>
{
CreateOrderTestData(orderId, context.PrimaryOrganisationId, orderDescription)
};
context.Orders = orders.Select(x => x.order);
var controller = context.OrdersController;
var result = await controller.GetAllAsync(context.PrimaryOrganisationId) as OkObjectResult;
var ordersResult = result.Value as List <OrderListItemModel>;
ordersResult.Should().ContainSingle();
ordersResult.Should().BeEquivalentTo(orders.Select(x => x.expected));
}
public async Task GetAllAsync_MultipleOrdersWithOrganisationIdExist_ReturnsAllOrders()
{
var context = OrdersControllerTestContext.Setup();
var orders = new List <(Order order, OrderListItemModel expected)>
{
CreateOrderTestData("C0000014-01", context.PrimaryOrganisationId, "Some Description"),
CreateOrderTestData("C000012-01", context.PrimaryOrganisationId, "Another Description")
};
context.Orders = orders.Select(x => x.order);
var controller = context.OrdersController;
var result = await controller.GetAllAsync(context.PrimaryOrganisationId) as OkObjectResult;
var ordersResult = result.Value as List <OrderListItemModel>;
ordersResult.Count.Should().Be(2);
ordersResult.Should().BeEquivalentTo(orders.Select(x => x.expected));
}
