public override void Arrange()
{
_customer = new Customer {
Birthdate = DateTime.UtcNow
};
_discountCalculator = new DiscountCalculatorFactory().Create();
}
public OrderService(INumberGenerator numberGenerator, IConfiguration configuration, IDiscountCalculator discountCalculator, IProductRepository productRepository)
{
_numberGenerator = numberGenerator;
_configuration = configuration;
_discountCalculator = discountCalculator;
_productRepository = productRepository;
}
public Domain.Offer.Offer CalculateOffer(IDiscountCalculator discountCalculator, IProductRepository productRepository)
{
if (_status != OrderStatus.New)
{
throw new NotFoundException();
}
List <OfferItem> availabeItems = new List <OfferItem>();
List <OfferItem> unavailableItems = new List <OfferItem>();
decimal totalCost = 0;
foreach (var orderItem in _products)
{
Product.Product product = productRepository.Get(orderItem.ProductId);
if (product.Aviable)
{
OfferItem offerItem = new OfferItem(product.Id, product.Name, product.Price, product.ProductType);
availabeItems.Add(offerItem);
totalCost += offerItem.Price;
}
else
{
OfferItem offerItem = new OfferItem(product.Id, product.Name, product.Price, product.ProductType);
unavailableItems.Add(offerItem);
}
}
decimal discount = discountCalculator.Calculate(availabeItems);
return(new Domain.Offer.Offer(_clientId, totalCost - discount, discount, availabeItems, unavailableItems));
}
/// <summary>
/// Adds a new discount calculator.
/// The calculators are stored in the order they were added, and their order should not matter.
/// </summary>
/// <param name="calculator">The calculator to add.</param>
public void AddCalculator(IDiscountCalculator <TType> calculator)
{
if (calculator == this)
{
throw new ArgumentException("Cannot add the calculator as itself, as it creates an infinite loop.");
}
_discountStrategies.Add(calculator);
}
public void CheckMax()
{
IDiscountCalculator discountCalculator1 = new DiscountCalculator(new Func <ShoppingBasket, DiscountOfProducts>((ShoppingBasket shoppingBasket) => d1));
IDiscountCalculator discountCalculator2 = new DiscountCalculator(new Func <ShoppingBasket, DiscountOfProducts>((ShoppingBasket shoppingBasket) => d2));
IDiscountCalculator discountCalculator3 = discountCalculator1.Max(discountCalculator2);
Assert.AreEqual(20, discountCalculator3.CalcDiscount(shoppingBasket).Discount);
}
public void ThrowsException_When_Price_Less_Than_Zero()
{
//Arrange
IDiscountCalculator calc = GetDiscounter();
//Act
decimal finalPrice = calc.GetDiscountedValue(-10);
}
public CashRegister(IDiscountCalculator discountCalculator = null)
{
if (discountCalculator == null)
{
discountCalculator = new DiscountCalculator();
}
_discountCalculator = discountCalculator;
}
public ConfirmOrderHandler(IOrderRepository repository, IProductRepository productRepository, IDiscountCalculator discountCalculator, IClientRepository clientRepository, IPurchaseFactory purchaseFactory, IPurchaseRepository purchaseRepository)
{
_repository = repository;
_productRepository = productRepository;
_discountCalculator = discountCalculator;
_clientRepository = clientRepository;
_purchaseFactory = purchaseFactory;
_purchaseRepository = purchaseRepository;
}
public void ApplyDiscount(IDiscountCalculator discountCalculator, int existingPoints)
{
if (discountCalculator == null)
{
return;
}
Discount = discountCalculator.GetDiscount(this, existingPoints);
}
public DiscountCalculatorTests()
{
var transactions = new List <Transaction>
{
new Transaction
{
Size = Constants.Sizes.Medium,
Date = new DateTime(2017, 05, 10),
ShippingProvider = Constants.Providers.LaPoste,
Discount = new decimal(0.5)
},
new Transaction
{
Size = Constants.Sizes.Small,
Date = DateTime.UtcNow,
ShippingProvider = Constants.Providers.MondialRelay
},
new Transaction
{
Size = Constants.Sizes.Large,
Date = DateTime.UtcNow,
ShippingProvider = Constants.Providers.LaPoste,
CorruptedData = "CorruptedDataTest"
},
new Transaction
{
Size = Constants.Sizes.Large,
Date = new DateTime(2017, 05, 20),
ShippingProvider = Constants.Providers.MondialRelay
},
new Transaction
{
Size = Constants.Sizes.Small,
Date = new DateTime(2017, 04, 20),
ShippingProvider = Constants.Providers.LaPoste
},
new Transaction
{
Size = Constants.Sizes.Large,
Date = new DateTime(2017, 05, 20),
ShippingProvider = Constants.Providers.MondialRelay
},
new Transaction
{
Size = Constants.Sizes.Large,
Date = new DateTime(2017, 05, 20),
ShippingProvider = Constants.Providers.MondialRelay
}
};
_discounts = new Discounts
{
Transactions = transactions
};
_discountCalculator = new DiscountCalculator();
}
public ParcelPriceCalculator(IParcelMetadataProvider parcelMetadataProvider,
IDiscountCalculator discountCalculator,
IWeightCostCalculator weightCostCalculator)
{
_parcelMetadataProvider =
parcelMetadataProvider ?? throw new ArgumentNullException(nameof(parcelMetadataProvider));
_discountCalculator = discountCalculator ?? throw new ArgumentNullException(nameof(discountCalculator));
_weightCostCalculator =
weightCostCalculator ?? throw new ArgumentNullException(nameof(weightCostCalculator));
}
public OrderService(IOrderFactory orderFactory,
ICustomerOrdersRepository customerOrdersRepository, IUnitOfWork unitOfWork,
IPointsCalculator pointsCalculator, IDiscountCalculator discountCalculator)
{
this.orderFactory = orderFactory;
this.customerOrdersRepository = customerOrdersRepository;
this.unitOfWork = unitOfWork;
this.pointsCalculator = pointsCalculator;
this.discountCalculator = discountCalculator;
}
public void Apply_Default_Discount_For_Amount_Of_100()
{
//Arrange
IDiscountCalculator calc = GetDiscounter();
//Act
decimal finalPrice = calc.GetDiscountedValue(100);
//Assert
Assert.AreEqual(80, finalPrice);
}
public void Confirm(Domain.Offer.Offer seenOffer, IDiscountCalculator discountCalculator,
IProductRepository productRepository)
{
Domain.Offer.Offer current = CalculateOffer(discountCalculator, productRepository);
if (current.SameAs(seenOffer))
{
throw new InvalidOperationException();
}
_status = OrderStatus.Confirmed;
}
public void CalculatorExceptionTest()
{
// Arrange
IDiscountCalculator discountCalculator = CreateDiscountCalculator();
// Act
Action act = () => discountCalculator.CalculateDiscount(null);
// Asserts
act.Should().Throw <ArgumentNullException>();
}
public void Setup()
{
_fixture = (Fixture) new Fixture().Customize(new AutoNSubstituteCustomization());
_carRepositoryCache = NSubstitute.Substitute.For <ICarRepositoryCache>();
_discountCalculator1 = NSubstitute.Substitute.For <IDiscountCalculator>();
_discountCalculator2 = NSubstitute.Substitute.For <IDiscountCalculator>();
_sut = new DiscountCalculatorService(_carRepositoryCache, new List <IDiscountCalculator> {
_discountCalculator1, _discountCalculator2
});
}
public void IsSumThe_Same_With_Dummy_Discounter_Return_Value_For_10_Percentage_Discount()
{
//Arrange
IDiscountCalculator calc = GetDiscounter(10);
LinqValueCalculator linqCalc = new LinqValueCalculator(calc);
//Act
decimal finalPrice = linqCalc.GetTotalValueOfProducts(_products);
//Assert
Assert.AreEqual(72, finalPrice);
}
public decimal GetTotalPrice(IList <ProductPrice> productPrices, DiscountPolicy discountPolicy)
{
if (productPrices.IsEmpty())
{
throw new ArgumentNullException("productPrices");
}
IDiscountCalculator discountCalculator = _discountCalculatorFactory.Get(discountPolicy);
decimal totalPrice = productPrices.Sum(x => x.Price);
decimal discount = discountCalculator.Compute();
return(totalPrice - discount);
}
public OrderViewModel(IDiscountCalculator <OrderViewModel> orderDiscountCalculator, IDiscountCalculator <LineViewModel> lineDiscountCalculator, Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
_orderDiscountCalculator = orderDiscountCalculator;
_lineDiscountCalculator = lineDiscountCalculator;
_order = order;
_lines = new List <LineViewModel>(_order.Lines.Select(line => new LineViewModel(line, _lineDiscountCalculator)));
UpdatePrices();
}
public void IsSumThe_Same_With_Dummy_Discounter()
{
//Arrange
IDiscountCalculator calc = GetDiscounter(0);
LinqValueCalculator linqCalc = new LinqValueCalculator(calc);
//Act
decimal finalPrice = linqCalc.GetTotalValueOfProducts(_products);
//Assert
Assert.AreEqual(80, finalPrice);
}
public void PlaceOrder(Order order, IPointsCalculator pointsCalculator, IDiscountCalculator discountCalculator = null)
{
NewOrder = order;
if (order == null)
{
return;
}
order.SetCustomerId(CustomerId);
order.ApplyDiscount(discountCalculator, ExistingPoints);
NewPoints = order.GetPoints(pointsCalculator);
}
public static double CalculateTotal(IEnumerable <OrderItem> orderItems)
{
double totalPrice = 0.0;
foreach (var item in orderItems)
{
IDiscountCalculator discountCalculator
= DiscountFactory.CreateDiscountCalculator(item.DiscountType);
double itemPrice = discountCalculator.GetDiscountedPrice(item);
totalPrice += itemPrice;
}
return(totalPrice);
}
private static void StrategyPatternProblem()
{
var(grossTotal, selection) = ReadInput();
IDiscountCalculator discountStrategy = selection switch
{
1 => new SeniorCitizenDiscount(),
2 => new VeteranDiscount(),
3 => new MinorDiscount(),
_ => new NoDiscount()
};
var context = new DiscountContext(discountStrategy);
var net = context.Calculate(grossTotal);
PrintResult(grossTotal, net);
}
public bool TryGetCalculator(Type stackType, out IDiscountCalculator calculator)
{
if (typeof(IPotterCollection).IsAssignableFrom(stackType))
{
// If we already have a calculator for this type, return that
if (usedCalculators.TryGetValue(typeof(HarryPotterDiscountCalculator), out IDiscountCalculator value))
{
calculator = value;
}
else
{
calculator = new HarryPotterDiscountCalculator();
usedCalculators.Add(typeof(HarryPotterDiscountCalculator), calculator);
}
return(true);
}
calculator = null;
return(false);
}
public LineViewModel(Line line, IDiscountCalculator <LineViewModel> lineDiscountCalculator)
{
if (line == null)
{
throw new ArgumentNullException("line");
}
if (line.Quantity <= 0)
{
throw new ArgumentException("Invalid quantity");
}
if (line.Bike.Price <= 0)
{
throw new ArgumentException("Invalid price");
}
_line = line;
_lineDiscountCalculator = lineDiscountCalculator;
}
public IDiscountCalculator Max(IDiscountCalculator otherDiscountCalc)
{
return(discountCalculator.Max(otherDiscountCalc));
}
public IDiscountCalculator Add(IDiscountCalculator otherDiscountCalc)
{
return(discountCalculator.Add(otherDiscountCalc));
}
public ProductDiscountCalculator(Guid productId, double percent)
{
Func <ShoppingBasket, DiscountOfProducts> f = new Func <ShoppingBasket, DiscountOfProducts>((ShoppingBasket basket) => Calc(basket, productId, percent));
discountCalculator = new DiscountCalculator(f);
}
public OrdersController(IGenericRepository <Product> productRepo, IGenericRepository <Customer> customerRepo, IDiscountCalculator calculator)
{
_customerRepository = customerRepo;
_productRepository = productRepo;
_discountCalculator = calculator;
}
public PurchaseController(IDiscountCalculator discountCalculator)
{
_discountCalculator = discountCalculator;
}
public ShoppingCart(IDiscountCalculator discountCalculator)
{
_discountCalculator = discountCalculator;
_cartItems = new List<CartItem>();
}
