public static void Equals_DifferentOrderId_AreNotEqual()
{
var orderItem1 = OrderItemBuilder.Create().Build();
var orderItem2 = OrderItemBuilder.Create().WithOrderId(2).Build();
orderItem1.Equals(orderItem2).Should().BeFalse();
}
public static void DeleteOrderItemAndUpdateProgress_AllCataloguesSolutionsDeleted_SetsAdditionalServicesViewedToFalse(
CatalogueItemId catalogueItemId,
Order order)
{
var parentOrderItem = OrderItemBuilder.Create()
.WithCatalogueItem(new CatalogueItem
{
Id = catalogueItemId,
CatalogueItemType = CatalogueItemType.Solution,
}).Build();
var childOrderItem = OrderItemBuilder.Create()
.WithCatalogueItem(
new CatalogueItem
{
CatalogueItemType = CatalogueItemType.AdditionalService,
ParentCatalogueItemId = catalogueItemId,
}).Build();
order.Progress.AdditionalServicesViewed = true;
order.AddOrUpdateOrderItem(parentOrderItem);
order.AddOrUpdateOrderItem(childOrderItem);
order.DeleteOrderItemAndUpdateProgress(catalogueItemId);
order.Progress.AdditionalServicesViewed.Should().BeFalse();
}
public static MerchantOrder MakeCompleteOrder()
{
var shippingDetail = AddressBuilder.MakeFullAddress();
var billingDetail = new Address
{
FirstName = "Piet",
MiddleName = "van der",
LastName = "Stoel",
Street = "Dorpsstraat",
PostalCode = "4321YZ",
City = "Bennebroek",
CountryCode = "NL",
HouseNumber = "9",
HouseNumberAddition = "rood"
};
var customerInformation = CustomerInformationBuilder.MakeCompleteCustomerInformation();
return(new MerchantOrder
{
MerchantOrderId = "100",
Description = "Order ID: " + "100",
OrderItems = new[] { OrderItemBuilder.MakeCompleteOrderItem() },
Amount = Money.FromDecimal("EUR", 99.99),
ShippingDetail = shippingDetail,
BillingDetail = billingDetail,
CustomerInformation = customerInformation,
Language = "NL",
MerchantReturnUrl = "http://localhost/",
PaymentBrand = PaymentBrand.Ideal,
PaymentBrandForce = PaymentBrandForce.ForceOnce
});
}
public static void CalculateTotalOwnershipCost_RecurringAndOneOff_ReturnsTotalOwnershipCost()
{
var order = new Order();
var orderItem1 = OrderItemBuilder
.Create()
.WithCatalogueItem(new CatalogueItem {
Id = new CatalogueItemId(1, "1"), CatalogueItemType = CatalogueItemType.AssociatedService
})
.WithProvisioningType(ProvisioningType.OnDemand)
.WithPrice(5)
.WithRecipient(new OrderItemRecipient {
Quantity = 10
})
.Build();
var orderItem2 = OrderItemBuilder
.Create()
.WithCatalogueItem(new CatalogueItem {
CatalogueItemType = CatalogueItemType.AdditionalService
})
.WithProvisioningType(ProvisioningType.Patient)
.WithPrice(240)
.WithRecipient(new OrderItemRecipient {
Quantity = 2
})
.Build();
order.AddOrUpdateOrderItem(orderItem1);
order.AddOrUpdateOrderItem(orderItem2);
order.CalculateTotalOwnershipCost().Should().Be(19080);
}
public static void CalculateCostPerYear_Recurring_OrderItemCostTypeRecurring_ReturnsTotalOrderItemCost()
{
var order = new Order();
var orderItem1 = OrderItemBuilder
.Create()
.WithCatalogueItem(new CatalogueItem {
Id = new CatalogueItemId(1, "1"), CatalogueItemType = CatalogueItemType.Solution
})
.WithProvisioningType(ProvisioningType.Declarative)
.WithPrice(120)
.WithRecipient(new OrderItemRecipient {
Quantity = 2
})
.Build();
var orderItem2 = OrderItemBuilder
.Create()
.WithCatalogueItem(new CatalogueItem {
CatalogueItemType = CatalogueItemType.AdditionalService
})
.WithProvisioningType(ProvisioningType.Patient)
.WithPrice(240)
.WithRecipient(new OrderItemRecipient {
Quantity = 2
})
.Build();
order.AddOrUpdateOrderItem(orderItem1);
order.AddOrUpdateOrderItem(orderItem2);
order.CalculateCostPerYear(CostType.Recurring).Should().Be(8640);
}
public static void CalculateTotalOwnershipCost_SingleOneOffOrRecurringOrderItem_ReturnsTotalOwnershipCost(
CatalogueItemType catalogueItemType,
ProvisioningType provisioningType,
decimal price,
int quantity,
decimal totalOwnershipCost)
{
var orderItem = OrderItemBuilder
.Create()
.WithCatalogueItem(new CatalogueItem {
CatalogueItemType = catalogueItemType
})
.WithProvisioningType(provisioningType)
.WithPrice(price)
.WithRecipient(new OrderItemRecipient {
Quantity = quantity
})
.Build();
var order = OrderBuilder
.Create()
.WithOrderItem(orderItem)
.Build();
order.CalculateTotalOwnershipCost().Should().Be(totalOwnershipCost);
}
static void Test()
{
OrderItemBuilder
.Create()
.WithCatalogueItemType(null)
.Build();
}
public async Task GetAllAsync_WithSolution_ReturnsOkayResult()
{
const string expectedDescription = "A description";
var context = CatalogueSolutionsControllerTestContext.Setup();
context.Order.SetDescription(OrderDescription.Create(expectedDescription).Value);
var serviceRecipients = new List <(string Ods, string Name)>
{
("eu", "EU test")
};
context.Order.SetServiceRecipient(serviceRecipients, Guid.Empty, string.Empty);
var orderItem = OrderItemBuilder.Create().WithOdsCode(serviceRecipients[0].Ods).Build();
context.Order.AddOrderItem(orderItem, Guid.Empty, string.Empty);
var result = await context.Controller.GetAllAsync("myOrder");
result.Value.Should().BeOfType <CatalogueSolutionsModel>();
var model = result.Value;
model.CatalogueSolutions.Count().Should().Be(1);
var expectedCatalogueSolutionList = new List <CatalogueSolutionModel>
{
CreateCatalogueSolutionModel(orderItem, serviceRecipients[0])
};
model.OrderDescription.Should().Be(expectedDescription);
model.CatalogueSolutions.Should().BeEquivalentTo(expectedCatalogueSolutionList);
}
public static void DeleteOrderItemAndUpdateProgress_CataloguesSolutionsNotDeleted_AdditionalServicesViewedNotChanged(
CatalogueItemId catalogueItemId,
Order order)
{
var orderItem1 = OrderItemBuilder.Create()
.WithCatalogueItem(new CatalogueItem
{
Id = catalogueItemId,
CatalogueItemType = CatalogueItemType.Solution,
}).Build();
var orderItem2 = OrderItemBuilder.Create()
.WithCatalogueItem(new CatalogueItem
{
CatalogueItemType = CatalogueItemType.Solution,
}).Build();
var childOrderItem = OrderItemBuilder.Create()
.WithCatalogueItem(
new CatalogueItem
{
CatalogueItemType = CatalogueItemType.AdditionalService,
ParentCatalogueItemId = catalogueItemId,
}).Build();
order.AddOrUpdateOrderItem(orderItem1);
order.AddOrUpdateOrderItem(orderItem2);
order.AddOrUpdateOrderItem(childOrderItem);
order.Progress.AdditionalServicesViewed = true;
order.DeleteOrderItemAndUpdateProgress(orderItem1.CatalogueItem.Id);
order.Progress.AdditionalServicesViewed.Should().BeTrue();
}
public async Task <OrderItem> AddItem(AddToCartRequest request)
{
var currentUser = await accountManager.GetCurrentUser();
if (currentUser.Id == request.OfferOwnerId)
{
throw new NoPermissionsException(ErrorMessages.NotAllowedMessage);
}
if (currentUser.Cart == null)
{
currentUser.SetCart(await CreateCart(currentUser));
}
var item = new OrderItemBuilder()
.SetAmount(request.Amount)
.SetType(request.Type)
.SetProductName(request.ProductName)
.SetUserName(request.UserName)
.SetEmail(request.Email)
.SetCartId(currentUser.Cart.Id)
.SetOptionalData(request.OfferOwnerId)
.Build();
currentUser.Cart.Items.Add(item);
currentUser.Cart.CalculateTotalAmount();
return(await unitOfWork.Complete() ? item : throw new ServerException("Adding item to cart failed"));
}
public async Task GivenACatalogueSolutionHasBeenAddedToTheOrder()
{
var order = (Order)Context[ContextKeys.CreatedOrder];
var solutions = await SupplierInfo.GetPublishedCatalogueItemsNoTieredAsync(Test.BapiConnectionString, order.Supplier.Id, CatalogueItemType.Solution);
var selectedItem = solutions.First();
var catalogueItem = await DbContext.FindAsync <CatalogueItem>(CatalogueItemId.ParseExact(selectedItem.CatalogueItemId))
?? selectedItem.ToDomain();
var pricingUnitName = "per banana";
var pricingUnit = await DbContext.FindAsync <PricingUnit>(pricingUnitName) ?? new PricingUnit
{
Name = pricingUnitName,
};
var orderItem = new OrderItemBuilder(order.Id)
.WithCatalogueItem(catalogueItem)
.WithCataloguePriceType(CataloguePriceType.Flat)
.WithCurrencyCode()
.WithDefaultDeliveryDate(DateTime.Today)
.WithPrice(0.01M)
.WithPricingTimeUnit(TimeUnit.PerMonth)
.WithProvisioningType(ProvisioningType.Declarative)
.WithPricingUnit(pricingUnit)
.Build();
order.AddOrUpdateOrderItem(orderItem);
await DbContext.SaveChangesAsync();
}
public static async Task <OrderItem> GetOrderItemWithId(Order order, string solutionId, string connectionString, OrderingDbContext context)
{
var newPricingUnit = await GetPricingUnitAsync(ProvisioningType.Declarative, connectionString);
var pricingUnit = await context.FindAsync <PricingUnit>(newPricingUnit.Name) ?? newPricingUnit;
var selectedItem = (await SupplierInfo.GetPublishedCatalogueItemsNoTieredAsync(connectionString, order.Supplier.Id, CatalogueItemType.Solution))
.Single(s => s.CatalogueItemId.ToString().Equals(solutionId));
var catalogueItem = await context.FindAsync <CatalogueItem>(CatalogueItemId.ParseExact(solutionId))
?? selectedItem.ToDomain();
var orderItem = new OrderItemBuilder(order.Id)
.WithCatalogueItem(catalogueItem)
.WithCataloguePriceType(CataloguePriceType.Flat)
.WithCurrencyCode()
.WithDefaultDeliveryDate(DateTime.Today)
.WithPrice(0.01M)
.WithPricingTimeUnit(TimeUnit.PerYear)
.WithProvisioningType(ProvisioningType.Declarative)
.WithPricingUnit(pricingUnit)
.WithEstimationPeriod(TimeUnit.PerMonth);
return(orderItem.Build());
}
public static void Equals_SameOrderItemReference_AreEqual()
{
var orderItem = OrderItemBuilder
.Create()
.Build();
orderItem.Equals(orderItem).Should().BeTrue();
}
public OrderItem(OrderItemBuilder orderItemBuilder)
: base(orderItemBuilder.Id)
{
ItemId = orderItemBuilder.ItemId;
ItemPrice = orderItemBuilder.ItemPrice.Amount;
OrderedAmount = orderItemBuilder.OrderedAmount;
ShippingDate = CalculateShippingDate(orderItemBuilder.AvailableItemStock);
}
public static void Equals_NullOrderItem_AreNotEqual()
{
var orderItem = OrderItemBuilder
.Create()
.Build();
orderItem.Equals(null).Should().BeFalse();
}
protected override OrderItem BuildEntity()
{
var orderItem = new OrderItemBuilder().Build();
// there are no cascade's configured for the following assocations, so we have to make these
// transient instances persistent manually
Session.Save(orderItem.Product);
return(orderItem);
}
public void Should_Not_Create_An_OrderItem_With_Discount_Greater_Than_Product_Price()
{
var product = ProductBuilder.New().Build();
var invalidDiscount = (product.Price * 2) + 1;
Assert.Throws <DomainException>(() =>
OrderItemBuilder.New().WithQuantity(2).WithProduct(product).WithDiscount(invalidDiscount).Build()
).WithMessage("Discount cannot be greater than the subtotal of products");
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
FoodBuilder.Build(modelBuilder);
OrderBuilder.Build(modelBuilder);
OrderItemBuilder.Build(modelBuilder);
PaymentMethodBuilder.Build(modelBuilder);
RestaurantBuilder.Build(modelBuilder);
TableBuilder.Build(modelBuilder);
}
public static MerchantOrder MakeWithOrderItemsWithoutOptionalFields()
{
return(new MerchantOrder
{
MerchantOrderId = "100",
OrderItems = new[] { OrderItemBuilder.MakeOrderItemWithoutOptionals() },
Amount = Money.FromDecimal("EUR", 99.99),
MerchantReturnUrl = "http://localhost/"
});
}
private static OrderItem CreateOrderItem(CatalogueItemType catalogueItemType, ProvisioningType provisioningType)
{
return(OrderItemBuilder
.Create()
.WithCatalogueItem(new CatalogueItem {
CatalogueItemType = catalogueItemType
})
.WithProvisioningType(provisioningType)
.Build());
}
protected override void Given()
{
_product = Build.Product().WithCanUseBulkDiscount(CanUseBulkDiscount).WithPrice(Price);
_orderItem = Build.OrderItem().WithProduct(_product).WithQuantity(Quantity);
_order = Build.Order().WithCoupon(WithCoupon).WithOrderItem(new List <OrderItem> {
_orderItem
});
_expectedAdjustment = -1 * Price * Quantity;
Mock <IFinalPrice>().Order.Returns(_order);
}
public static void MarkOrderSectionAsViewed_NullOrder_ThrowsArgumentNullException()
{
var orderItem = OrderItemBuilder
.Create()
.WithCatalogueItem(new CatalogueItem {
CatalogueItemType = CatalogueItemType.Solution
})
.Build();
Assert.Throws <ArgumentNullException>(() => orderItem.MarkOrderSectionAsViewed(null));
}
public OrderTest()
{
faker = new Faker();
var product = ProductBuilder.New().WithPrice(125).Build();
var orderItem = OrderItemBuilder.New().WithQuantity(1).WithProduct(product).WithDiscount(25).Build();
listOfOrderItems = new List <OrderItem>()
{
orderItem,
};
}
public static void IsFundingSourceComplete_OrderFundingViewed_WithAssociatedService_ReturnsTrue()
{
var order = OrderBuilder.Create()
.WithOrderItem(OrderItemBuilder.Create().WithCatalogueItem(new CatalogueItem
{
CatalogueItemType = CatalogueItemType.AssociatedService,
}).Build()).WithFundingSourceOnlyGms(true).Build();
var actual = order.IsFundingSourceComplete();
actual.Should().BeTrue();
}
public void Constructor_NullOrEmptyCurrencyCode_ThrowsArgumentException(string currencyCodeInput)
{
void Test()
{
OrderItemBuilder
.Create()
.WithCurrencyCode(currencyCodeInput)
.Build();
}
Assert.Throws <ArgumentException>(Test);
}
public void Constructor_NullOrEmptyCatalogueItemName_ThrowsArgumentException(string catalogueItemNameInput)
{
void Test()
{
OrderItemBuilder
.Create()
.WithCatalogueItemName(catalogueItemNameInput)
.Build();
}
Assert.Throws <ArgumentException>(Test);
}
public static void AddOrUpdateOrderItem_OrderItem_ItemAdded()
{
var order = OrderBuilder.Create().Build();
var orderItem = OrderItemBuilder.Create().Build();
order.AddOrUpdateOrderItem(orderItem);
var expected = new List <OrderItem> {
orderItem
};
order.OrderItems.Should().BeEquivalentTo(expected);
}
protected override void Given()
{
_product = Build.Product().WithCanUseBulkDiscount(CanUseBulkDiscount).WithPrice(Price);
_orderItem = Build.OrderItem().WithProduct(_product).WithQuantity(Quantity);
_order = Build.Order().WithCoupon(WithCoupon).WithOrderItem(new List <OrderItem> {
_orderItem
});
_expectedAdjustment = Price * FreeQty * (Quantity - Quantity % BulkAndFree) / BulkAndFree;
Mock <IFinalPrice>().Order.Returns(_order);
Mock <IDiscountVariablesRepository>().FreeQty.Returns(FreeQty);
Mock <IDiscountVariablesRepository>().BulkQty.Returns(BulkQty);
}
public static void CalculateTotalCostPerYear_WithPriceTypePerYear_CalculatesCostCorrectly()
{
var orderItem = OrderItemBuilder
.Create()
.WithPrice(1m)
.WithRecipient(new OrderItemRecipient {
Quantity = 10
})
.WithPriceTimeUnit(TimeUnit.PerYear)
.Build();
orderItem.CalculateTotalCostPerYear().Should().Be(10);
}
public static void Equals_DifferentType_ReturnsFalse()
{
var item = OrderItemBuilder.Create().Build();
var anonItem = new
{
Order = item.OrderId,
item.CatalogueItem,
};
var isEqual = item.Equals(anonItem);
isEqual.Should().BeFalse();
}
