public void CalculatePrice_DistanceIs0_PriceShouldBe2500()
{
//Act
decimal price = calculator.CalculatePrice(0);
//Assert
Assert.Equal(2500, price);
}
public void CalculatePrice_ShouldCallCalcualtionRuleOnce_WhenThereIsOneItemInTheOrderList()
{
int quantity = 1;
decimal priceForSingleItem = 1.25m;
var orderList = new OrderList();
orderList.AddItem(new StockItem("A"), priceForSingleItem);
_sut.CalculatePrice(orderList);
_calculationRuleMock.Verify(i => i.CalculatePrice(quantity, priceForSingleItem), Times.Once);
_calculationRulesProviderMock.Verify();
}
public static void Main()
{
var input = Console.ReadLine()
.Split();
var pricePerDay = decimal.Parse(input[0]);
var daysCount = int.Parse(input[1]);
var seasonType =
Enum.Parse <PriceCalculator.Season>(input[2]);
if (input.Length <= 3)
{
var discountType = PriceCalculator.DiscountType.None;
var calculate = new PriceCalculator();
var result = calculate.CalculatePrice(pricePerDay,
daysCount, seasonType, discountType);
Console.WriteLine($"{result:f2}");
}
else
{
var discountType =
Enum.Parse <PriceCalculator.DiscountType>(input[3]);
var calculate = new PriceCalculator();
var result = calculate.CalculatePrice(pricePerDay,
daysCount, seasonType, discountType);
Console.WriteLine($"{result:f2}");
}
}
public void CalculatePrice_TwoOfSameSingleItemInBasket_WillGive20Discount()
{
PriceCalculator pc = CreatePriceCalculator();
var res = pc.CalculatePrice(CreateBasketSingelItem(2));
Assert.Equal(10.50M * 2 * 0.8M, res);
}
public void CalculatePrice_NullBasket_ReturnsException()
{
PriceCalculator pc = CreatePriceCalculator();
var res = Assert.Throws <ArgumentNullException>(() => pc.CalculatePrice(null));
Assert.Equal("Varukorgen ska inte vara tom (Parameter 'Basket')", res.Message);
}
private void Button_Click_Calculate(object sender, RoutedEventArgs e)
{
var bookList = new List <Books>();
var valueList = new string[] { bookOne.Text, bookTwo.Text, bookThree.Text, bookFour.Text, bookFive.Text };
for (int i = 0; i < 5; i++)
{
if (valueList[i].IsNullOrEmpty())
{
valueList[i] = "0";
}
}
bookList.Add(new Books {
Name = logic.Name.Book1, Amount = Int32.Parse(valueList[0])
});
bookList.Add(new Books {
Name = logic.Name.Book2, Amount = Int32.Parse(valueList[1])
});
bookList.Add(new Books {
Name = logic.Name.Book3, Amount = Int32.Parse(valueList[2])
});
bookList.Add(new Books {
Name = logic.Name.Book4, Amount = Int32.Parse(valueList[3])
});
bookList.Add(new Books {
Name = logic.Name.Book5, Amount = Int32.Parse(valueList[4])
});
result.Content = _priceCalculator.CalculatePrice(bookList).ToString();
}
public void CalculatePrice_EmptyBasket_ReturnsDefault()
{
PriceCalculator pc = CreatePriceCalculator();
decimal price = pc.CalculatePrice(new Basket());
Assert.Equal(0, price);
}
public void CalculatePrice_SingelItemInBasket_ReturnsTheItemprice()
{
PriceCalculator pc = CreatePriceCalculator();
var res = pc.CalculatePrice(CreateBasketSingelItem(1));
Assert.Equal(10.50M, res);
}
public void GivenEmptyList_WhenPriceCalculated_ShouldReturnZero()
{
var priceCalculator = new PriceCalculator();
var result = priceCalculator.CalculatePrice(NoCabins, NoProducts, 0, CruiseCabinsForTesting, CruiseProductsForTesting);
Assert.AreEqual(0m, result);
}
static void Main(string[] args)
{
Reservation reservation = new Reservation(Console.ReadLine());
decimal totalPrice = PriceCalculator.CalculatePrice(reservation);
Console.WriteLine($"{totalPrice:F2}");
}
public void CalculatePrice_MultiItemInBasket_ReturnsTheSumForItemprice()
{
PriceCalculator pc = CreatePriceCalculator();
var res = pc.CalculatePrice(CreateBasketMultiItems(1));
Assert.Equal(40.50M, res);
}
public void GivenBooking_WithProducts_WhenDiscountIsApplied_ShouldReturnCorrectPrice()
{
var cabins = new List <BookingSource.Cabin>
{
new BookingSource.Cabin {
TypeId = TypeB
},
new BookingSource.Cabin {
TypeId = TypeC
}
};
var products = new List <BookingSource.Product>
{
new BookingSource.Product {
TypeId = TypeA, Quantity = 2
}
};
var priceCalculator = new PriceCalculator();
var result = priceCalculator.CalculatePrice(cabins, products, 5, CruiseCabinsForTesting, CruiseProductsForTesting);
var correctResult = 0.95m * (PriceB + PriceC) + 2 * ProductPriceA;
Assert.AreEqual(correctResult, result);
}
static void Main(string[] args)
{
var input = Console.ReadLine();
var priceCalculator = new PriceCalculator(input);
priceCalculator.CalculatePrice();
}
public void CalculatePrice_TwoOfSameMultiItemInBasket_WillGive20Discount()
{
PriceCalculator pc = CreatePriceCalculator();
var res = pc.CalculatePrice(CreateBasketMultiItems(2));
Assert.Equal(40.50M * 2 * 0.8M, res);
}
public void CalculatePrice_ThreeItemsDiscount_Give20Discount()
{
PriceCalculator pc = CreatePriceCalculator();
decimal price = pc.CalculatePrice(CreateBasketMultiItemsWithDiscountflagga());
Assert.Equal((51.0M * 0.8M) + 10.0M, price);
}
public static void Main()
{
var command = Console.ReadLine();
var priceCalculator = new PriceCalculator(command);
var totalPrice = priceCalculator.CalculatePrice();
Console.WriteLine(totalPrice);
}
static void Main(string[] args)
{
var input = Console.ReadLine().Split().ToArray();
var calculator = new PriceCalculator(input);
var price = calculator.CalculatePrice();
Console.WriteLine(price);
}
static void Main()
{
string input = Console.ReadLine();
PriceCalculator priceCalculator = new PriceCalculator(input);
var total = priceCalculator.CalculatePrice();
Console.WriteLine(total);
}
static void Main(string[] args)
{
var command = Console.ReadLine();
var priceCalc = new PriceCalculator(command);
Console.WriteLine($"{priceCalc.CalculatePrice():f2}");
}
public ActionResult Calculate(InsuranceDto ins)
{
decimal price = 0.0M;
var calculator = new PriceCalculator();
price = calculator.CalculatePrice(ins);
return(Json(price));
}
public static void Main()
{
string[] input = Console.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
PriceCalculator calc = new PriceCalculator(input);
calc.CalculatePrice();
Console.WriteLine(calc);
}
public void Accept(Guid orderId)
{
var order = _orderRepository.Get(orderId);
var orderLines = GetOrderLinesWithOrderId(orderId);
order.Price = _priceCalculator.CalculatePrice(order, orderLines);
order.Status = OrderStatus.Accepted;
}
public void TestPriceIncludingVatNullProductTaxes()
{
var calculator = new PriceCalculator(true, false);
var priceExcludingTax = 100;
List <ProductTax> taxes = null;
var result = calculator.CalculatePrice(priceExcludingTax, taxes);
Assert.AreEqual(100, result);
}
static void Main()
{
var reservationInfo = Console.ReadLine().Split();
var priceCalculator = new PriceCalculator(reservationInfo);
var totalPrice = priceCalculator.CalculatePrice();
Console.WriteLine($"{totalPrice:F2}");
}
public double GetTotal()
{
List <Type> priceCaluclatorImplementations = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypes())
.Where(x => typeof(ProductPriceCalculatorDec).IsAssignableFrom(x) && !x.IsInterface && !x.IsAbstract).ToList();
IProductPriceCalculator priceCalculator = new PriceCalculator(Items);
priceCalculator.CalculatePrice();
foreach (var implementation in priceCaluclatorImplementations)
{
priceCalculator = (IProductPriceCalculator)Activator.CreateInstance(implementation, new object[] { priceCalculator });
priceCalculator.CalculatePrice();
}
_logger.Info(new { ItemsInfo = priceCalculator.Items, AppliedDiscounts = priceCalculator.GetAppliedDiscounts() });
return(priceCalculator.GetTotal());
}
public decimal TotalAmount()
{
decimal total = 0m;
foreach (var item in this.items)
{
total += calculator.CalculatePrice(item);
}
return(total);
}
public void TestPriceIncludingVatNoTaxes()
{
var calculator = new PriceCalculator(true, false);
var priceExcludingTax = 100;
var taxes = new List <PublicOrderTax> {
};
var result = calculator.CalculatePrice(priceExcludingTax, taxes);
Assert.AreEqual(100, result);
}
public void Empty_cart_should_cost_nothing()
{
// Given
A.CallTo(() => cart.Items).Returns(Enumerable.Empty <string>());
// When
var price = calculator.CalculatePrice();
// Then
price.Should().Be(0);
}
public void ZeroBookInBasket()
{
var booksList = new List <Books>();
var price = _priceCalculator.CalculatePrice(booksList);
Assert.Equal(0, price);
}
public void TestPriceExcludingVat()
{
var calculator = new PriceCalculator(false, false);
var priceExcludingTax = 100m;
var taxes = new List<PublicOrderTax>
{
new PublicOrderTax(){Name = "Tax1", Percent = 25, ApplyToAmountOnly = true }
};
var result = calculator.CalculatePrice(priceExcludingTax, taxes);
Assert.AreEqual(100, result);
}
public void TestPriceIncludingVatAndResellerHasInclusiveTaxCalculation()
{
var calculator = new PriceCalculator(true, true);
var priceExcludingTax = 100;
var taxes = new List<PublicOrderTax>
{
new PublicOrderTax(){Name = "Tax1", Percent = 25, ApplyToAmountOnly = true }
};
var result = calculator.CalculatePrice(priceExcludingTax, taxes);
Assert.AreEqual(100, result);
}
public async Task CalculatePriceTest()
{
// arrange
var tour = new Tour {
PriceByPerson = 10m
};
// act
var sut = new PriceCalculator();
await sut.CalculatePrice(tour, 2);
// assert
Assert.Equal(20m, tour.TotalPrice);
}
public void TestPriceIncludingVatNullPublicOrderTaxes()
{
var calculator = new PriceCalculator(true, false);
var priceExcludingTax = 100;
List<PublicOrderTax> taxes = null;
var result = calculator.CalculatePrice(priceExcludingTax, taxes);
Assert.AreEqual(100, result);
}
/// <inheritdoc />
public Cart CalculatePricing(Cart cart)
{
var publicOrder = CreateBasicOrder();
var publicOrderItems = new List<PublicOrderItem>();
var itemNo = 0;
foreach(var cartItem in cart.CartItems)
{
var renewalPeriodId = renewalPeriodProvider.GetRenewalPeriodId(cartItem);
publicOrderItems.Add(new PublicOrderItem
{
ItemNumber = cartItem.ArticleNumber,
RenewalPeriodId = renewalPeriodId,
Quantity = cartItem.Quantity,
ItemNo = itemNo++
});
}
publicOrder.OrderItems = publicOrderItems.ToArray();
var publicOrderCustomData = new List<PublicOrderCustomData>();
if (!string.IsNullOrEmpty(cart.CampaignCode))
{
publicOrderCustomData.Add(new PublicOrderCustomData
{
Name = "CampaignCode",
Value = cart.CampaignCode
});
}
if (cart.CustomAttributes != null)
{
foreach (Core.CustomAttribute attr in cart.CustomAttributes)
{
publicOrderCustomData.Add(new PublicOrderCustomData { Name = attr.Name, Value = attr.Value });
}
}
publicOrder.CustomData = publicOrderCustomData.ToArray();
var calculatedPublicOrder = BillingApi.CalculateOrder(publicOrder);
IEnumerable<Tax> taxes = new List<Tax>();
if (calculatedPublicOrder.Taxes != null && calculatedPublicOrder.Taxes.Count() > 0)
{
taxes = calculatedPublicOrder.Taxes.Select(t => new Tax(t.Name, t.Total, t.Percent));
}
var subtotal = this.pricesIncludeVat
? calculatedPublicOrder.Total
: calculatedPublicOrder.Subtotal;
cart.SetPricing(subtotal, calculatedPublicOrder.Total, taxes);
var priceCalculator = new PriceCalculator(this.pricesIncludeVat, this.inclusiveTaxCalculationType);
foreach(var cartItem in cart.CartItems)
{
PublicOrderItem calculatedItem;
var calcOrderItems = calculatedPublicOrder.OrderItems;
if (cartItem.RenewalPeriod == null)
{
calculatedItem = calcOrderItems.First(x =>
x.ItemNumber == cartItem.ArticleNumber
&& x.RenewalPeriod == 0);
}
else
{
calculatedItem = calcOrderItems.First(x =>
x.ItemNumber == cartItem.ArticleNumber
&& x.RenewalPeriod == cartItem.RenewalPeriod.Period
&& x.RenewalPeriodUnit.ToUpper() == cartItem.RenewalPeriod.Unit);
}
IEnumerable<Tax> itemTaxes = new List<Tax>();
if (calculatedItem.Taxes != null && calculatedItem.Taxes.Count() > 0)
{
itemTaxes = calculatedItem.Taxes.Select(t => new Tax(t.Name, calculatedItem.TaxAmount, t.Percent));
}
var price = priceCalculator.CalculatePrice(calculatedItem.Price, calculatedItem.Taxes);
var discount = priceCalculator.CalculatePrice(calculatedItem.Discount, calculatedItem.Taxes);
cartItem.SetPricing(price, discount, itemTaxes);
cartItem.Quantity = calculatedItem.Quantity;
}
return cart;
}