public async Task ThenTheTotalOne_OffCostIsTheResultOfTheTotalOne_OffCostCalculationAsync()
{
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var actual = Test.Pages.PreviewOrderSummary.GetTotalOneOffCost();
actual.Should().Be(FormatDecimal(order.CalculateCostPerYear(CostType.OneOff)));
}
public void GetAvailableExtrasForCategory_WhenCalledWithNonExistingCategory_ReturnsEmptyList()
{
var helper = new OrderHelpers(_apiClient);
var availableExtras = helper.GetAvailableExtrasForCategory("dessert");
Assert.IsEmpty(availableExtras);
}
public void CalculateOrderValue_WhenCalledWithEmptyList_ReturnsZero()
{
var helper = new OrderHelpers(_apiClient);
var result = helper.CalculateOrderValue(new List <DishOrder>());
Assert.AreEqual(0, result);
}
public async Task ThenTheUserIsAskedToConfirmTheChoiceToDeleteTheCatalogueSolutionAsync()
{
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var orderitem = order.OrderItems[0].CatalogueItem.Name;
Test.Pages.OrderForm.EditNamedSectionPageDisplayed($"Delete {orderitem}").Should().BeTrue();
}
public async Task ThenTheTotalCostOfContractIsTheResultOfTheTotalCostOfContractCalculationTotalOne_OffCostTotalCostForOneYearCalculationAsync()
{
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var actualTotalCostOfContract = Test.Pages.PreviewOrderSummary.GetTotalOwnershipCost();
actualTotalCostOfContract.Should().Be(FormatDecimal(order.CalculateTotalOwnershipCost()));
}
public async Task ThenTheCall_OffAgreementIDIsDisplayedAsync()
{
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var callOffID = order.CallOffId.ToString();
Test.Pages.OrderForm.EditNamedSectionPageDisplayed(callOffID).Should().BeTrue();
}
public async Task ThenTheOrderDescriptionIsDisplayedAsync()
{
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var orderDescription = order.Description;
Test.Pages.OrderForm.DeleteConfirmationOrderDescription().Should().BeEquivalentTo(orderDescription);
}
public void GetAvailableExtrasForCategory_WhenCalledWithEmptyString_ReturnsEmptyList()
{
var helper = new OrderHelpers(_apiClient);
var availableExtras = helper.GetAvailableExtrasForCategory(string.Empty);
Assert.IsEmpty(availableExtras);
}
public void GetAvailableExtrasForCategory_WhenPizzaExtrasRequested_ReturnsListWith4Elements()
{
var helper = new OrderHelpers(_apiClient);
var availableExtras = helper.GetAvailableExtrasForCategory("Pizza");
Assert.That(availableExtras.Count(), Is.EqualTo(4));
}
public async Task ThenTheItemNameOfEachItemIsTheCatalogueSolutionNameAsync()
{
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var expectedOrderItem = order.OrderItems[0];
var name = Test.Pages.PreviewOrderSummary.GetItemName();
name.Should().Be(expectedOrderItem.CatalogueItem.Name);
}
public async Task ThenThePlannedDeliveryDateOfEachItemIsDisplayedAsync()
{
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var expectedOrderItem = order.OrderItems[0];
var date = Test.Pages.PreviewOrderSummary.GetItemPlannedDate();
date.Should().Be(expectedOrderItem.DefaultDeliveryDate.Value.ToString("d MMMM yyyy"));
}
public async Task ThenTheCallOffOrderingPartySectionIsSavedInTheDb()
{
var contextOrder = Context.Get <Order>(ContextKeys.CreatedOrder);
var order = await OrderHelpers.GetFullOrderAsync(contextOrder.CallOffId, DbContext);
order.OrderingParty.Should().NotBeNull();
order.OrderingPartyContact.Should().NotBeNull();
}
public async Task ThenTheItemYearCostOfEachItemIsTheResultOfTheFlatCalculationPriceQuantityRoundedUpToTwoDecimalPlacesAsync()
{
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var expectedOrderItem = order.OrderItems[0];
var expectedValue = FormatDecimal(Math.Round(expectedOrderItem.CalculateTotalCostPerYear(), 2));
var cost = Test.Pages.PreviewOrderSummary.GetItemCost();
cost.Should().Be(expectedValue.ToString());
}
public Order CreateOrder(int buyerId, List <OrderItem> orderItems)
{
var orderNumber = OrderHelpers.GenerateOrderNumber();
var order = new Order(buyerId, orderNumber, orderItems)
{
Status = OrderStatus.Pending
};
return(_orderRepository.Add(order));
}
public async Task WhenTheUserChoosesToConfirmTheDeleteAsync()
{
var wait = new WebDriverWait(Test.Driver, TimeSpan.FromSeconds(10));
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
Context.Add(ContextKeys.DeletedOrderItem, order.OrderItems[0]);
Test.Pages.DeleteOrder.ClickDeleteButtonYes();
wait.Until(s => Test.Pages.OrderForm.ContinueButtonDisplayed());
}
public async Task ThenOnlyTheCatalogueSolutionWithTheUnitIsDeletedFromTheOrderAsync()
{
var orderItem = Context.Get <OrderItem>(ContextKeys.DeletedOrderItem);
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
if (order.OrderItems.Count > 0)
{
order.OrderItems.Should().NotContain(orderItem);
}
}
public async Task ThenTheCommencementDateIsDisplayedAsync()
{
var date = Test.Pages.PreviewOrderSummary.GetCommencementDateValue();
date.Should().NotBeNullOrEmpty();
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var expectedDate = order.CommencementDate?.ToString("d MMMM yyyy");
date.Should().EndWithEquivalent(expectedDate);
}
public async Task ThenThePricingValuesWillBePopulatedWithTheValuesThatWasSavedByTheUserAsync()
{
var quantityFromPage = Test.Pages.OrderForm.GetQuantity();
var priceFromPage = Test.Pages.OrderForm.GetPriceInputValue();
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var orderItem = order.OrderItems.Single(i => i.CatalogueItem.CatalogueItemType == CatalogueItemType.AdditionalService);
quantityFromPage.Should().Be(orderItem.OrderItemRecipients[0].Quantity.ToString());
priceFromPage.Should().MatchRegex(@"^[0-9]*(\.[0-9]{2,3})?$");
}
public async Task ThenTheQuantityOfEachItemIsTheConcatenationOfQuantityAndPerPeriodAsync(string period)
{
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var expectedOrderItem = order.OrderItems[0];
var expectedQuantityValue = $"{expectedOrderItem.OrderItemRecipients[0].Quantity} {period}";
var actualQuantity = Test.Pages.PreviewOrderSummary.GetItemQuantity();
actualQuantity.Should().ContainEquivalentOf(expectedQuantityValue);
}
public async Task ThenTheQuantityOfEachItemIsQuantityAsync()
{
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var expectedOrderItem = order.OrderItems[0];
var expectedValue = $"{expectedOrderItem.OrderItemRecipients[0].Quantity}";
var quantity = Test.Pages.PreviewOrderSummary.GetItemQuantity();
quantity.Should().ContainEquivalentOf(expectedValue);
}
public async Task ThenTheQuantityOfEachItemIsTheConcatenationI_E_QuantityPerPeriodAsync()
{
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var expectedOrderItem = order.OrderItems[0];
var expectedPeriod = expectedOrderItem.EstimationPeriod;
var expectedValue = $"{FormatInt(expectedOrderItem.OrderItemRecipients[0].Quantity)} {expectedPeriod.Value.Description()}";
var quantity = Test.Pages.PreviewOrderSummary.GetItemQuantity();
quantity.Should().ContainEquivalentOf(expectedValue);
}
public async Task ThenThePreviouslySavedDataIsDisplayedAsync()
{
var priceFromPage = decimal.Parse(Test.Pages.OrderForm.GetPriceInputValue());
var order = Context.Get <Order>(ContextKeys.CreatedOrder);
var orderItemsInDb = (await DbContext.Order.FindAsync(order.Id))
.OrderItems.Single(
s => s.CatalogueItem.CatalogueItemType == CatalogueItemType.AssociatedService);
var unitOrder = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
orderItemsInDb.Price.Value.Should().Be(priceFromPage);
Test.Pages.OrderForm.GetAssociatedServicesPricingUnit(unitOrder).Should().BeTrue();
}
public void CalculateOrderValue_WhenCalledWithNull_ThrowsAnException()
{
var helper = new OrderHelpers(_apiClient);
try
{
helper.CalculateOrderValue(null);
Assert.Fail();
}
catch (Exception)
{
Assert.Pass();
}
}
public void CalculateOrderValue_WhenOrderedDishWithoutExtras_ReturnsCorrectPrice(int quantity, decimal totalPrice)
{
var helper = new OrderHelpers(_apiClient);
var result = helper.CalculateOrderValue(new List <DishOrder>
{
new DishOrder()
{
DishIdentifier = "5f80c7de5508d7198e6e4821",
Quantity = quantity
}
});
Assert.AreEqual(result, totalPrice);
}
public void GetAvailableExtrasForCategory_WhenPizzaExtrasRequested_ReturnedListContainsOnlyPizzaExtras()
{
var helper = new OrderHelpers(_apiClient);
var availableExtras = helper.GetAvailableExtrasForCategory("Pizza");
foreach (var availableExtra in availableExtras)
{
if (availableExtra.DishCategory != "Pizza")
{
Assert.Fail();
}
}
Assert.Pass();
}
public async Task ThenThePriceUnitOfOrderOfEachItemIsTheConcatenationAsync()
{
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var expectedOrderItem = order.OrderItems[0];
var expectedValue = $"{FormatDecimal(expectedOrderItem.Price.Value)} {expectedOrderItem.PricingUnit.Description}".Trim();
if (expectedOrderItem.ProvisioningType != ProvisioningType.OnDemand)
{
expectedValue += $" {expectedOrderItem.PriceTimeUnit.Value.Description()}";
}
var price = Test.Pages.PreviewOrderSummary.GetItemPrice();
price.Should().Be(expectedValue);
}
public async Task ThenTheCallOffOrderingPartyInformationIsDisplayedAsync()
{
var value = Test.Pages.PreviewOrderSummary.GetCallOffOrderingPartyPreviewValue();
value.Should().NotBeNullOrEmpty();
var order = await OrderHelpers.GetFullOrderAsync(Context.Get <Order>(ContextKeys.CreatedOrder).CallOffId, DbContext);
var createdAddress = order.OrderingParty.Address;
var createdContact = order.OrderingPartyContact;
value.Should().ContainEquivalentOf(createdAddress.Line1);
value.Should().ContainEquivalentOf(createdAddress.Town);
value.Should().ContainEquivalentOf(createdAddress.Postcode);
var concattedName = string.Format("{0} {1}", createdContact.FirstName, createdContact.LastName);
value.Should().ContainEquivalentOf(concattedName);
}
public void CalculateOrderValue_WhenOrderedDishWithExtra_ReturnsCorrectPrice(string dishIdentifier, string extrasId, int dishQuantity, decimal totalPrice)
{
var helper = new OrderHelpers(_apiClient);
var result = helper.CalculateOrderValue(new List <DishOrder>
{
new DishOrder()
{
DishIdentifier = dishIdentifier,
Quantity = dishQuantity,
Extras = new List <string> {
extrasId
}
}
});
Assert.AreEqual(totalPrice, result);
}
public async Task GivenAnIncompleteOrderExists()
{
var context = (OrderingDbContext)Context[ContextKeys.DbContext];
var user = (User)Context[ContextKeys.User];
var description = RandomInformation.RandomInformationText();
if (description.Length > 100)
{
description = description.Substring(0, 100);
}
var createModel = new CreateOrderModel {
Description = description, OrganisationId = user.PrimaryOrganisationId
};
var order = await OrderHelpers.CreateOrderAsync(createModel, context, user, Test.IsapiConnectionString);
Context.Add(ContextKeys.CreatedOrder, order);
}
public ActionResult Details(OrderEditView order)
{
if (ModelState.IsValid)
{
if (Request.Form["despatchedbutton"] != null)
{
//Update tables
OrderHelpers.ChangeOrderStatus(db, order.OrderId, OrderStatusEnum.Despatched, User);
return(RedirectToAction("Orders", "ManageListings"));
}
if (Request.Form["delivereddbutton"] != null)
{
//Update tables
OrderHelpers.ChangeOrderStatus(db, order.OrderId, OrderStatusEnum.Delivered, User);
return(RedirectToAction("Orders", "ManageListings"));
}
if (Request.Form["collectedbutton"] != null)
{
//Update tables
OrderHelpers.ChangeOrderStatus(db, order.OrderId, OrderStatusEnum.Collected, User);
return(RedirectToAction("Orders", "ManageListings"));
}
if (Request.Form["receivedbutton"] != null)
{
//Update tables
OrderHelpers.ChangeOrderStatus(db, order.OrderId, OrderStatusEnum.Received, User);
return(RedirectToAction("Orders", "ManageListings"));
}
if (Request.Form["closedbutton"] != null)
{
//Update tables
OrderHelpers.ChangeOrderStatus(db, order.OrderId, OrderStatusEnum.Closed, User);
return(RedirectToAction("Orders", "ManageListings"));
}
}
order = OrderEditHelpers.GetOrderEditView(db, order.OrderId, User);
ViewBag.ShowHistory = false;
return(View(order));
}
