public void ThrowsException_When_TotalPriceIsNegativeNumber()
{
// Arrange
var mockedDiscountHelper = new Mock <IDiscountHelper>();
mockedDiscountHelper.Setup(m => m.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total);
var defaultPriceCalculator = new DefaultPriceCalculator(mockedDiscountHelper.Object);
// Act
defaultPriceCalculator.ApplyDiscount(-1);
}
public void Calculating_price_for_null_customer_should_calculate_the_full_price()
{
var repository = new Mock <IDiscountRepository>();
var orderItem = new OrderItem {
Identifier = "item-1", ItemCost = 10m, Quantity = 2
};
var subject = new DefaultPriceCalculator(repository.Object);
Assert.That(subject.CalculatePrice(null, orderItem),
Is.EqualTo(orderItem.ItemCost * orderItem.Quantity));
}
public void Items_having_multiple_discounts_should_return_with_the_lowest_price()
{
var order = new OrderItem {
Identifier = "item-1", ItemCost = 50m, Quantity = 2
};
var basicCustomer = new Customer()
{
Level = MembershipLevel.Basic
};
var higherPriceStrategy = new Mock <IOrderItemDiscount>();
higherPriceStrategy.Setup(s => s.CalculateItemPrice(order)).Returns(1000m);
var higherDiscount = new Mock <IMembershipDiscount>()
{
Name = "higher discount"
};
higherDiscount.SetupGet(d => d.Discount).Returns(higherPriceStrategy.Object);
higherDiscount.Setup(d => d.MatchesTo(basicCustomer, order)).Returns(true);
var lowestPriceStrategy = new Mock <IOrderItemDiscount>();
lowestPriceStrategy.Setup(s => s.CalculateItemPrice(order)).Returns(1m);
var lowestDiscount = new Mock <IMembershipDiscount>();
lowestDiscount.SetupGet(d => d.Discount).Returns(lowestPriceStrategy.Object);
lowestDiscount.Setup(d => d.MatchesTo(basicCustomer, order)).Returns(true);
var highestPriceStrategy = new Mock <IOrderItemDiscount>();
highestPriceStrategy.Setup(s => s.CalculateItemPrice(order)).Returns(2000m);
var highestDiscount = new Mock <IMembershipDiscount>();
highestDiscount.SetupGet(d => d.Discount).Returns(highestPriceStrategy.Object);
highestDiscount.Setup(d => d.MatchesTo(basicCustomer, order)).Returns(true);
var repository = new Mock <IDiscountRepository>();
repository
.Setup(r => r.GetDiscountsFor(It.IsAny <string>()))
.Returns(new List <IMembershipDiscount>
{
higherDiscount.Object,
lowestDiscount.Object,
highestDiscount.Object
});
var subject = new DefaultPriceCalculator(repository.Object);
Assert.That(subject.CalculatePrice(basicCustomer, order), Is.EqualTo(1m));
}
public void Items_not_discounted_should_have_full_price()
{
var repository = new Mock <IDiscountRepository>();
var basicCustomer = new Customer()
{
Level = MembershipLevel.Basic
};
var orderItem = new OrderItem {
Identifier = "item-1", ItemCost = 10m, Quantity = 2
};
var subject = new DefaultPriceCalculator(repository.Object);
Assert.That(subject.CalculatePrice(basicCustomer, orderItem), Is.EqualTo(orderItem.Quantity * orderItem.ItemCost));
}
public void Should_check_customers_orderitem_for_discounts()
{
var repository = new Mock <IDiscountRepository>();
var basicCustomer = new Customer()
{
Level = MembershipLevel.Basic
};
var subject = new DefaultPriceCalculator(repository.Object);
var orderItem = new OrderItem {
Identifier = "item-1", ItemCost = 10m, Quantity = 2
};
subject.CalculatePrice(basicCustomer, orderItem);
repository.Verify(r => r.GetDiscountsFor(orderItem.Identifier), Times.Once);
}
public void Return0ForNoItems()
{
var configuredPrices = new Dictionary <string, Prices>();
configuredPrices["A"] = new Prices()
{
UnitPrice = 50
};
var defaultPriceCalculator = new DefaultPriceCalculator(configuredPrices);
var checkout = new DefaultCheckout(defaultPriceCalculator);
var total = checkout.GetTotalPrice();
Assert.Equal(0, total);
}
public void ReturnCorrectPriceForAConfiguredPrice()
{
var configuredPrices = new Dictionary <string, Prices>();
configuredPrices["C"] = new Prices()
{
UnitPrice = 20
};
var defaultPriceCalculator = new DefaultPriceCalculator(configuredPrices);
var checkout = new DefaultCheckout(defaultPriceCalculator);
checkout.Scan("C");
var total = checkout.GetTotalPrice();
Assert.Equal(20, total);
}
public void Return30ForOneB()
{
var configuredPrices = new Dictionary <string, Prices>();
configuredPrices["B"] = new Prices()
{
UnitPrice = 30
};
var defaultPriceCalculator = new DefaultPriceCalculator(configuredPrices);
var checkout = new DefaultCheckout(defaultPriceCalculator);
checkout.Scan("B");
var total = checkout.GetTotalPrice();
Assert.Equal(30, total);
}
public void Returns_CalculatedTotalPrice()
{
// Arrange
var mockedDiscountHelper = new Mock <IDiscountHelper>();
mockedDiscountHelper.Setup(m => m.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total);
var defaultPriceCalculator = new DefaultPriceCalculator(mockedDiscountHelper.Object);
var products = this.GetProducts().ToArray();
// Act
var totalPrice = defaultPriceCalculator.CalculateTotalPrice(products);
// Assert
var totalPriceOfProducts = products.Sum(p => p.Price);
Assert.AreEqual(totalPriceOfProducts, totalPrice);
}
public void ThrowsException_When_ProductsCollectionIsNull()
{
// Arrange
var mockedDiscountHelper = new Mock <IDiscountHelper>();
mockedDiscountHelper.Setup(m => m.ApplyDiscount(It.IsAny <decimal>())).Returns <decimal>(total => total);
var defaultPriceCalculator = new DefaultPriceCalculator(mockedDiscountHelper.Object);
Product[] products = null;
// Act
var totalPrice = defaultPriceCalculator.CalculateTotalPrice(products);
// Assert
var totalPriceOfProducts = products.Sum(p => p.Price);
Assert.AreEqual(totalPriceOfProducts, totalPrice);
}
public void ReturnCorrectPriceForComplexCombination()
{
var configuredPrices = new Dictionary <string, Prices>();
configuredPrices["A"] = new Prices()
{
UnitPrice = 50, SpecialPrice = new SpecialPrice()
{
Quantity = 3, Price = 130
}
};
configuredPrices["B"] = new Prices()
{
UnitPrice = 30, SpecialPrice = new SpecialPrice()
{
Quantity = 2, Price = 45
}
};
configuredPrices["C"] = new Prices()
{
UnitPrice = 20
};
configuredPrices["D"] = new Prices()
{
UnitPrice = 15
}; var defaultPriceCalculator = new DefaultPriceCalculator(configuredPrices);
var checkout = new DefaultCheckout(defaultPriceCalculator);
checkout.Scan("A");
checkout.Scan("B");
checkout.Scan("A");
checkout.Scan("C");
checkout.Scan("A");
checkout.Scan("D");
checkout.Scan("A");
checkout.Scan("B");
checkout.Scan("C");
var total = checkout.GetTotalPrice();
Assert.Equal(280, total);
}
public void ReturnSpecialPriceOf130ForThreeAs()
{
var configuredPrices = new Dictionary <string, Prices>();
configuredPrices["A"] = new Prices()
{
UnitPrice = 50, SpecialPrice = new SpecialPrice()
{
Quantity = 3, Price = 130
}
};
var defaultPriceCalculator = new DefaultPriceCalculator(configuredPrices);
var checkout = new DefaultCheckout(defaultPriceCalculator);
checkout.Scan("A");
checkout.Scan("A");
checkout.Scan("A");
var total = checkout.GetTotalPrice();
Assert.Equal(130, total);
}
public void Should_verify_whether_discount_is_appliable_to_customer()
{
var repository = new Mock <IDiscountRepository>();
var basicCustomer = new Customer()
{
Level = MembershipLevel.Basic
};
var orderItem = new OrderItem {
Identifier = "item-1", ItemCost = 10m, Quantity = 2
};
var notAppliableDiscount = new Mock <IMembershipDiscount>();
notAppliableDiscount.Setup(d => d.MatchesTo(basicCustomer, It.IsAny <OrderItem>())).Returns(false);
notAppliableDiscount.SetupGet(d => d.Discount).Returns(new Mock <IOrderItemDiscount>().Object);
repository.Setup(r => r.GetDiscountsFor(It.IsAny <string>())).Returns(new List <IMembershipDiscount>()
{
notAppliableDiscount.Object
});
var subject = new DefaultPriceCalculator(repository.Object);
Assert.That(subject.CalculatePrice(basicCustomer, orderItem), Is.EqualTo(20m));
}
public void Calculator_with_no_custom_default_strategy_supplied_should_use_the_fullprice_strategy()
{
var subject = new DefaultPriceCalculator(new Mock <IDiscountRepository>().Object);
Assert.IsInstanceOf <FullPrice>(subject.Default);
}
