public void GetAll_should_return_all_from_OrderService_Subspec()
{
var orders = default(Order[]);
var mockOrderService = default(Mock<IOrderService>);
var orderController = default(OrderController);
var result = default(IEnumerable<Order>);
"Given order service contains no orders"
.Context(() =>
{
orders = new Order[0];
mockOrderService = new Mock<IOrderService>();
orderController = new OrderController(mockOrderService.Object);
mockOrderService.Setup(x => x.GetAll())
.Returns(orders);
});
"When I ask for all orders from orderController"
.Do(() =>
{
result = orderController.Get();
});
"Then it must not be null"
.Observation(() =>
{
Assert.NotNull(result);
});
"And it should contain no order"
.Observation(() =>
{
Assert.Empty(result);
});
}
public void Get_should_return_OK_if_order_exists()
{
// arrange
const int OrderId = 123;
var order = new Order()
{
Id = OrderId
};
var mockOrderService = new Mock<IOrderService>();
mockOrderService.Setup(x => x.Exists(It.IsAny<int>()))
.Returns(true);
mockOrderService.Setup(x => x.Get(It.IsAny<int>()))
.Returns(order);
var orderController = new OrderController(mockOrderService.Object);
var request = new HttpRequestMessage();
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = new HttpConfiguration();
// act
var result = orderController.Get(request, OrderId);
// assert
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
}
public HttpResponseMessage Put(HttpRequestMessage request, Order order)
{
if (!_orderService.Exists(order.Id))
return request.CreateErrorResponse(HttpStatusCode.NotFound, "Order does not exist");
_orderService.Update(order);
return request.CreateResponse(HttpStatusCode.OK);
}
public void Save(Order order)
{
if (order.Id == 0)
order.Id = _random.Next(); // assign random Id if a new order
order.TotalPrice = _pricingService.GetPrice(order);
_orders.Add(order.Id, order);
}
public HttpResponseMessage Post(HttpRequestMessage request, Order order)
{
if (!order.Items.Any())
return request.CreateErrorResponse(HttpStatusCode.BadRequest, "Order has no items");
if(_orderService.Exists(order.Id))
return request.CreateErrorResponse(HttpStatusCode.BadRequest, "Order already exists");
_orderService.Save(order);
var response = request.CreateResponse(HttpStatusCode.Created);
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = order.Id }));
return response;
}
public decimal GetPrice(Order order)
{
const decimal BasePriceForAnyPizza = 7.5m;
const decimal ValueAddedTax = 0.20m;
// price of the pizza is calculated by the base price plus
// 0.5 for every character in the name of the pizza!
var priceBeforeTax = order.Items.Sum(x => x.Quantity *
(BasePriceForAnyPizza + 0.5m*x.Name.Length));
return priceBeforeTax + (priceBeforeTax * ValueAddedTax);
}
public void GetAll_should_return_all_from_OrderService()
{
// arrange
var orders = new Order[0];
var mockOrderService = new Mock<IOrderService>();
mockOrderService.Setup(x => x.GetAll())
.Returns(orders);
var orderController = new OrderController(mockOrderService.Object);
// act
var result = orderController.Get();
// assert
Assert.Equal(orders, result);
}
public void GivenIHaveAnOrderForAMixtureOfPizzas()
{
var order = new Order();
order.Items = new[]
{
new OrderItem()
{
Name = "Hawaiian",
Quantity = 2
},
new OrderItem()
{
Name = "Meat Feast",
Quantity = 1
}
};
ScenarioContext.Current[TestContextKeys.NewOrder] = order;
}
public async Task<IHttpActionResult> RegiterNew(OrderDTO orderDTO)
{
var order = new Order(orderDTO.CustomerName, orderDTO.CustomerPhone, orderDTO.PizzaID);
_dbSet.Add(order);
await _context.SaveChangesAsync();
orderDTO = (OrderDTO)new OrderDTO().InjectFrom(order);
orderDTO.StatusDescription = ((OrderStatus)order.Status).ToString();
return Created(new Uri(_baseUri + orderDTO.OrderID), orderDTO);
}
public void Update(Order order)
{
order.TotalPrice = _pricingService.GetPrice(order);
_orders[order.Id] = order;
}
public void Post_should_return_Created_if_order_good_fluentApi()
{
// arrange
const string url = "http://localhost:2345/api/Order/";
const int OrderId = 123;
var order = new Order(new OrderItem[]
{
new OrderItem()
{
Name = "Name",
Quantity = 1
}
})
{
Id = OrderId
};
var mockOrderService = new Mock<IOrderService>();
mockOrderService.Setup(x => x.Exists(It.IsAny<int>()))
.Returns(false);
var orderController = ControllerContextSetup
.Of(() => new OrderController(mockOrderService.Object))
.WithDefaultConfig()
.WithDefaultRoute()
.Requesting(url)
.WithRouteData(new {controller="Order"})
.Build<OrderController>();
// act
var result = orderController.Post(orderController.Request, order);
// assert
Assert.Equal(HttpStatusCode.Created, result.StatusCode);
Assert.NotNull(result.Headers.Location);
Assert.Equal(result.Headers.Location, new Uri(new Uri(url), order.Id.ToString()));
}
public void Post_should_return_Created_if_order_good()
{
// arrange
const int OrderId = 123;
var order = new Order(new OrderItem[]
{
new OrderItem()
{
Name = "Name",
Quantity = 1
}
})
{
Id = OrderId
};
var mockOrderService = new Mock<IOrderService>();
mockOrderService.Setup(x => x.Exists(It.IsAny<int>()))
.Returns(false);
var orderController = new OrderController(mockOrderService.Object);
var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost:2345/api/Order");
var config = new HttpConfiguration();
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
orderController.Request = request;
orderController.Configuration = config;
config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new {id = RouteParameter.Optional});
var route = config.Routes["DefaultApi"];
var httpRouteData = new HttpRouteData(route, new HttpRouteValueDictionary(new { controller = "Order" }));
orderController.Request.Properties[HttpPropertyKeys.HttpRouteDataKey] = httpRouteData;
// act
var result = orderController.Post(request, order);
// assert
Assert.Equal(HttpStatusCode.Created, result.StatusCode);
}
public void Post_should_return_BadRequest_if_order_hasNoOrderItems()
{
// arrange
const int OrderId = 123;
var order = new Order()
{
Id = OrderId,
};
var mockOrderService = new Mock<IOrderService>();
mockOrderService.Setup(x => x.Exists(It.IsAny<int>()))
.Returns(false);
var orderController = new OrderController(mockOrderService.Object);
var request = new HttpRequestMessage();
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = new HttpConfiguration();
// act
var result = orderController.Post(request, order);
// assert
Assert.Equal(HttpStatusCode.BadRequest, result.StatusCode);
}
