public void WhenOneBookIsAdded_ThenReturnsATotalOf8()
{
var priceCalculator = new PriceCalculator();
priceCalculator.AddBook("A");
Assert.That(priceCalculator.Total, Is.EqualTo(8));
}
public void WhenTwoOfTheSameBooksAreAdded_ThenReturnsATotalOf16()
{
var priceCalculator = new PriceCalculator();
priceCalculator.AddBook("A");
priceCalculator.AddBook("A");
Assert.That(priceCalculator.Total, Is.EqualTo(16));
}
public void WhenTwoDifferentBooksAreAdded_ThenReturnsATotalOf16Minus5Percent()
{
var priceCalculator = new PriceCalculator();
decimal expectedTotal = ((2m * 8m) * 0.95m);
priceCalculator.AddBook("A");
priceCalculator.AddBook("B");
Assert.That(priceCalculator.Total, Is.EqualTo(expectedTotal));
}
public void Should_AddItems()
{
var skus = "ABCD";
var itemCounter = Mock.Create<IItemCounter>();
itemCounter.Arrange(i => i.AddItems(skus)).MustBeCalled();
var checkout = new PriceCalculator(itemCounter);
checkout.Calculate(skus);
itemCounter.Assert();
}
public void WhenFourDifferentBooksAreAdded_ThenReturnsATotalOf32Minus20Percent()
{
var priceCalculator = new PriceCalculator();
decimal expectedTotal = ((4m * 8m) * 0.80m);
priceCalculator.AddBook("A");
priceCalculator.AddBook("B");
priceCalculator.AddBook("C");
priceCalculator.AddBook("D");
Assert.That(priceCalculator.Total, Is.EqualTo(expectedTotal));
}
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 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 SetUp()
{
var timeSpan = new TimeSpan(0, 5, 30, 0);
var priceCalculator = new PriceCalculator(new List<IParkingPriceRule>
{
new OneHourPriceRule(),
new TwoHourPriceRule(),
new ThreeOrMoreHoursPriceRule()
});
_amount = priceCalculator.Calculate(timeSpan);
}
public void SetUp()
{
var parkingDate = new DateTime(2013, 10, 06, 12, 0, 0);
var parkingReceipt = ParkingReceipt.Create(parkingDate);
DateTime checkoutTime = parkingDate.AddHours(5).AddMinutes(30);
var priceCalculator = new PriceCalculator(new List<IParkingPriceRule>
{
new OneHourPriceRule(),
new TwoHourPriceRule(),
new ThreeOrMoreHoursPriceRule()
});
var checkoutService = new CheckoutService(new TestableTimeService(checkoutTime), priceCalculator);
_invoice = checkoutService.Checkout(parkingReceipt);
}
string FormatHtml(ClientService clientService)
{
var calculator = new PriceCalculator(Configuration.Read(), clientService);
var res = "";
res += @"<html><body>";
res += FormatField("Фамилия", info.PersonalDetails.LastName);
res += FormatField("Имя", info.PersonalDetails.FirstName);
res += FormatField("Отчество", info.PersonalDetails.MiddleName);
res += FormatField("Модель", info.CarDetails.ModelName);
res += FormatField("Гос. знак", info.CarDetails.StateId);
res += FormatField("VIN", info.CarDetails.VIN);
res += FormatField("ПТС", info.CarDetails.Passport);
res += FormatField("Стоимость", calculator.Calculate(info).ToString());
res += @"</body></html>";
return(res);
}
public void ShouldReturnProperPricingPlanWhenProductsInSecondBundle()
{
//Arrange
var env =
TestEnvironment.Create(
c =>
{
c.Products.AddOrUpdate("A1", p => p.WithPrice(10));
c.Products.AddOrUpdate("A2", p => p.WithPrice(5));
c.Products.AddOrUpdate("A3", p => p.WithPrice(2));
c.Products.AddOrUpdate("A4", p => p.WithPrice(1));
c.DiscountStructure.Add(d => d.AddProduct("A1", 0.1m).AddProduct("A2", 0.1m));
c.DiscountStructure.Add(d => d.AddProduct("A1", 0.1m).AddProduct("A3", 0.5m).AddProduct("A4", 0.5m));
});
var priceCalculator = new PriceCalculator(env.Mocks.PriceService, env.Mocks.DiscountsService);
var elements =
new List <ElementInfo>()
{
env.ElementInfos.Get("A1"),
env.ElementInfos.Get("A4"),
env.ElementInfos.Get("A3")
};
var expectedPrices =
new List <ElementPrice>()
{
TestElementPrices.Get(env.ElementInfos.Get("A1"), 9m),
TestElementPrices.Get(env.ElementInfos.Get("A3"), 1m),
TestElementPrices.Get(env.ElementInfos.Get("A4"), 0.5m),
};
//Act
var pricingPlan = priceCalculator.Calculate(elements);
//Assert
Assert.Equal(3, pricingPlan.Prices.Count);
Assert.Equal(expectedPrices, pricingPlan.Prices, new PricesComparer());
}
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());
}
static void Main(string[] args)
{
var input = Console.ReadLine().Split();
if (input.Length == 4)
{
var pricePerD = decimal.Parse(input[0]);
var allDays = int.Parse(input[1]);
var season = input[2];
var disc = input[3];
PriceCalculator price = new PriceCalculator(pricePerD, allDays, season, disc);
}
else
{
var pricePerD = decimal.Parse(input[0]);
var allDays = int.Parse(input[1]);
var season = input[2];
PriceCalculator price = new PriceCalculator(pricePerD, allDays, season);
}
}
public static void Main()
{
var inputHolidayInfo = Console.ReadLine()
.Split(' ')
.ToArray();
var pricePerDay = decimal.Parse(inputHolidayInfo[0]);
var numbersOfDays = int.Parse(inputHolidayInfo[1]);
var season = inputHolidayInfo[2];
string discount = null;
if (inputHolidayInfo.Length == 4)
{
discount = inputHolidayInfo[3];
}
var price = new PriceCalculator(pricePerDay, numbersOfDays, season, discount);
Console.WriteLine($"{price.CalcPriceForAllHolyday():f2}");
}
public void TestPriceIncludingVatCumulativeTaxes()
{
var calculator = new PriceCalculator(true, false);
var priceExcludingTax = 100m;
var taxes = new List <PublicOrderTax>
{
new PublicOrderTax()
{
Name = "Tax1", Percent = 25, ApplyToAmountOnly = false
},
new PublicOrderTax()
{
Name = "Tax2", Percent = 25, ApplyToAmountOnly = false
}
};
var result = calculator.CalculatePrice(priceExcludingTax, taxes);
Assert.AreEqual(156.25m, result);
}
public string GenerateReceipt(Order order)
{
var totalAmount = 0d;
var result = new StringBuilder($"<html><body><h1>Order receipt for '{order.Company}'</h1>");
if (order.OrderLines.Any())
{
result.Append("<ul>");
totalAmount = PriceCalculator.CalculateTotal(order.OrderLines,
(line, amount) => result.Append(
$"<li>{line.Quantity} x {line.Product.ProductType} {line.Product.ProductName} = {amount:C}</li>"));
result.Append("</ul>");
}
result.Append($"<h3>Subtotal: {totalAmount:C}</h3>");
var totalTax = totalAmount * Rates.Tax;
result.Append($"<h3>MVA: {totalTax:C}</h3>");
result.Append($"<h2>Total: {(totalAmount + totalTax):C}</h2>");
result.Append("</body></html>");
return(result.ToString());
}
public void TestAllInvalidItem()
{
string msg = string.Empty;
msg = string.Format("Start of Unit Test : {0} ", MethodBase.GetCurrentMethod());
logHelper.LogInfo(msg);
PriceCalculator price = new PriceCalculator();
OrderDetails orderDetails = new OrderDetails();
orderDetails.orderItems.Add(new Item("AA", 5));
orderDetails.orderItems.Add(new Item("BB", 8));
orderDetails.orderItems.Add(new Item("Z", 2.5f));
price.CalTotalPriceOfOrder(orderDetails);
var abc = price.CalTotalPriceOfOrder(orderDetails);
Assert.AreEqual(orderDetails.inValidItems.Count, 3);
Assert.AreEqual(orderDetails.validItems.Count, 0);
msg = string.Format("End of Unit Test : {0} \n--------------------", MethodBase.GetCurrentMethod());
logHelper.LogInfo(msg);
}
public static void Main()
{
string[] holidayParams = Console.ReadLine().Split();
decimal pricePerDay = decimal.Parse(holidayParams[0]);
int numberOfDays = int.Parse(holidayParams[1]);
PriceCalculator.SeasonMultiplier seasonMultiplier = Enum.Parse <PriceCalculator.SeasonMultiplier>(holidayParams[2]);
PriceCalculator.Discounts discount = PriceCalculator.Discounts.None;
if (holidayParams.Length == 4)
{
discount = Enum.Parse <PriceCalculator.Discounts>(holidayParams[3]);
}
PriceCalculator priceCalculator = new PriceCalculator(pricePerDay, numberOfDays, seasonMultiplier, discount);
decimal holidayPrice = priceCalculator.CalculateHolidayPrice();
Console.WriteLine(holidayPrice.ToString("f2"));
}
public void GivenBooking_WithProducts_WhenPriceCalculated_ShouldReturnCorrectPrice()
{
var cabins = new List <BookingSource.Cabin>
{
new BookingSource.Cabin {
TypeId = TypeA
}
};
var products = new List <BookingSource.Product>
{
new BookingSource.Product {
TypeId = TypeA, Quantity = 5
}
};
var priceCalculator = new PriceCalculator();
var result = priceCalculator.CalculatePrice(cabins, products, 0, CruiseCabinsForTesting, CruiseProductsForTesting);
var correctResult = PriceA + 5 * ProductPriceA;
Assert.AreEqual(correctResult, result);
}
public void Should_Call_CorrectPricer_With_Count()
{
var skus = "A";
var itemCounter = Mock.Create<IItemCounter>();
var aPricer = Mock.Create<IPricer>();
aPricer.Arrange(ap => ap.TotalPrice(1)).MustBeCalled();
var pricers = new List<IPricer> {aPricer};
var aItemCount = new ItemCount('a', 1);
var counts = new List<ItemCount>
{
aItemCount
};
itemCounter.Arrange(i => i.AddItems(skus)).Returns(counts);
var checkout = new PriceCalculator(itemCounter, pricers);
checkout.Calculate(skus);
aPricer.Assert();
}
static void Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
IConfiguration config = builder.Build();
var discountConfig = new Discount();
config.GetSection("Discount").Bind(discountConfig);
var discountRules = DiscountHelper.GetDiscountRuleFromConfig(discountConfig);
var calculator = new PriceCalculator(discountRules);
//due to important part is Price calculator model, so skip input args and validation here
//assume all data is correct and invalid data will be reject before this
Console.WriteLine("-- Start Calculate input");
Console.WriteLine("Test with 1 person, code DIS10, price 500");
var bestRule = calculator.GetBestRule(1, "DIS10", 500);
if (!string.IsNullOrEmpty(bestRule.Name))
{
Console.WriteLine("-Match with promotion : " + bestRule.Name.ToString());
Console.WriteLine("-Amount : " + bestRule.Price.ToString());
}
Console.WriteLine("Test with 1 person, code STARCARD, price 2000");
bestRule = calculator.GetBestRule(1, "STARCARD", 2000);
if (!string.IsNullOrEmpty(bestRule.Name))
{
Console.WriteLine("-Match with promotion : " + bestRule.Name.ToString());
Console.WriteLine("-Amount : " + bestRule.Price.ToString());
}
Console.WriteLine("Test with 2 person, code DIS10, price 1500");
bestRule = calculator.GetBestRule(2, "DIS10", 1500);
if (!string.IsNullOrEmpty(bestRule.Name))
{
Console.WriteLine("-Match with promotion : " + bestRule.Name.ToString());
Console.WriteLine("-Amount : " + bestRule.Price.ToString());
}
Console.WriteLine("-- End Calculation");
}
public void WrongTypeOfAvailabilityShouldReturnNull()
{
// Arrange
var loggerMock = new Mock <ILogger <ProductService> >();
var priceCalculator = new PriceCalculator(loggerMock.Object);
var dbProduct = new DbProduct
{
Availability = new List <Store>
{
new Store
{
Type = StoreType.ClosedShop,
Price = 1000,
Quantity = 1,
},
new Store
{
Type = StoreType.Inactive,
Price = 1000,
Quantity = 1,
},
new Store
{
Type = StoreType.RepairShop,
Price = 1000,
Quantity = 1,
}
}
};
// Act
(var price, var salePrice) = priceCalculator.GetPrice(dbProduct);
// Assert
Assert.IsNull(price);
Assert.IsNull(salePrice);
}
public void Initialize()
{
logFactory = new DefaultLogFactory("Root").AddSerializer(new ConsoleSerializer());
errorLog = logFactory.Scope("Error");
readModelContextFactory = Factory.Getter(() => new ReadModelContext(connectionStrings.ReadModel));
eventSourcingContextFactory = Factory.Getter(() => new EventSourcingContext(connectionStrings.EventSourcing));
CreateReadModelContext();
CreateEventSourcingContext();
exceptionHandlerBuilder = new ExceptionHandlerBuilder();
services
.AddSingleton(readModelContextFactory)
.AddSingleton(eventSourcingContextFactory)
.AddSingleton(exceptionHandlerBuilder)
.AddSingleton <IExceptionHandler>(exceptionHandlerBuilder);
Domain();
priceCalculator = new PriceCalculator(eventDispatcher.Handlers, queryDispatcher);
services
.AddSingleton(priceCalculator)
.AddSingleton(new FormatterContainer(commandFormatter, eventFormatter, queryFormatter, exceptionFormatter));
ReadModels();
services
.AddSingleton <IEventHandlerCollection>(eventDispatcher.Handlers)
.AddScoped <ICommandDispatcher>(provider => new UserCommandDispatcher(commandDispatcher, provider.GetService <IHttpContextAccessor>().HttpContext, provider.GetService <ApiHub>()))
.AddScoped <IQueryDispatcher>(provider => new UserQueryDispatcher(queryDispatcher, provider.GetService <IHttpContextAccessor>().HttpContext));
CurrencyCache currencyCache = new CurrencyCache(eventDispatcher.Handlers, queryDispatcher, queryDispatcher);
services
.AddSingleton(currencyCache);
}
public void Start12hEnd22h_ShouldBeCorrect()
{
Limousine limousine = new Limousine("Tesla", "Model X", "White", 600, 1500, 2500, 2700);
DateTime startTime = new DateTime(2020, 09, 22, 12, 0, 0);
DateTime endTime = new DateTime(2020, 09, 23, 22, 0, 0);
TimeSpan totalHours = endTime - startTime;
double discountPercentage = 5;
Price price = PriceCalculator.WelnessPriceCalculator(limousine, totalHours, startTime, endTime, discountPercentage);
Assert.AreEqual(price.FirstHourPrice, 0);
Assert.AreEqual(price.NightHourCount, 0);
Assert.AreEqual(price.NightHourPrice, 0);
Assert.AreEqual(price.SecondHourCount, 0);
Assert.AreEqual(price.SecondHourPrice, 0);
Assert.AreEqual(price.OvertimeCount, 0);
Assert.AreEqual(price.OvertimePrice, 0);
Assert.AreEqual(price.FixedPrice, 2700);
Assert.AreEqual(price.SubTotal, 2700);
Assert.AreEqual(price.ExclusiveBtw, 2565);
Assert.AreEqual(price.BtwPrice, 153.9);
Assert.AreEqual(price.Total, 2718.9);
}
public void With15ProcentStaffelDiscount_ShouldBeCorrect()
{
Limousine limousine = new Limousine("Tesla", "Model X", "White", 600, 1500, 2500, 2700);
DateTime startTime = new DateTime(2020, 09, 22, 20, 0, 0);
DateTime endTime = new DateTime(2020, 09, 23, 3, 0, 0);
TimeSpan totalHours = endTime - startTime;
double discountPercentage = 15;
Price price = PriceCalculator.NightlifePriceCalculator(limousine, totalHours, startTime, endTime, discountPercentage);
Assert.AreEqual(price.FixedPrice, 1500);
Assert.AreEqual(price.FirstHourPrice, 0);
Assert.AreEqual(price.NightHourCount, 0);
Assert.AreEqual(price.NightHourPrice, 0);
Assert.AreEqual(price.SecondHourCount, 0);
Assert.AreEqual(price.SecondHourPrice, 0);
Assert.AreEqual(price.OvertimeCount, 0);
Assert.AreEqual(price.OvertimePrice, 0);
Assert.AreEqual(price.SubTotal, 1500);
Assert.AreEqual(price.ExclusiveBtw, 1275);
Assert.AreEqual(price.BtwPrice, 76.5);
Assert.AreEqual(price.Total, 1351.5);
}
public void ElevenTotalHours_ShouldBeCorrect()
{
Limousine limousine = new Limousine("Tesla", "Model X", "White", 600, 1500, 2500, 2700);
DateTime startTime = new DateTime(2020, 09, 22, 22, 0, 0);
DateTime endTime = new DateTime(2020, 09, 23, 9, 0, 0);
TimeSpan totalHours = endTime - startTime;
double discountPercentage = 5;
Price price = PriceCalculator.NightlifePriceCalculator(limousine, totalHours, startTime, endTime, discountPercentage);
Assert.AreEqual(price.FixedPrice, 1500);
Assert.AreEqual(price.FirstHourPrice, 0);
Assert.AreEqual(price.NightHourCount, 4);
Assert.AreEqual(price.NightHourPrice, 3360);
Assert.AreEqual(price.SecondHourCount, 0);
Assert.AreEqual(price.SecondHourPrice, 0);
Assert.AreEqual(price.OvertimeCount, 0);
Assert.AreEqual(price.OvertimePrice, 0);
Assert.AreEqual(price.SubTotal, 4860);
Assert.AreEqual(price.ExclusiveBtw, 4617);
Assert.AreEqual(price.BtwPrice, 277.02);
Assert.AreEqual(price.Total, 4894.02);
}
public void Start20hEnd6h_ShouldBeCorrect()
{
Limousine limousine = new Limousine("Tesla", "Model X", "White", 600, 1500, 2500, 2700);
DateTime startTime = new DateTime(2020, 09, 22, 20, 0, 0);
DateTime endTime = new DateTime(2020, 09, 23, 6, 0, 0);
TimeSpan totalHours = endTime - startTime;
double discountPercentage = 5;
Price price = PriceCalculator.NightlifePriceCalculator(limousine, totalHours, startTime, endTime, discountPercentage);
Assert.AreEqual(price.FixedPrice, 1500);
Assert.AreEqual(price.FirstHourPrice, 0);
Assert.AreEqual(price.NightHourCount, 3);
Assert.AreEqual(price.NightHourPrice, 2520);
Assert.AreEqual(price.SecondHourCount, 0);
Assert.AreEqual(price.SecondHourPrice, 0);
Assert.AreEqual(price.OvertimeCount, 0);
Assert.AreEqual(price.OvertimePrice, 0);
Assert.AreEqual(price.SubTotal, 4020);
Assert.AreEqual(price.ExclusiveBtw, 3819);
Assert.AreEqual(price.BtwPrice, 229.14);
Assert.AreEqual(price.Total, 4048.14);
}
public void Initialize()
{
Logging();
exceptionHandlerBuilder = new ExceptionHandlerBuilder();
exceptionHandlerBuilder.Handler(Handle);
services
.AddDbContextWithSchema <ReadModelContext>(connectionStrings.GetSection("ReadModel"), pathResolver)
.AddDbContextWithSchema <EventSourcingContext>(connectionStrings.GetSection("EventSourcing"), pathResolver)
.AddSingleton(exceptionHandlerBuilder)
.AddSingleton <IExceptionHandler>(exceptionHandlerBuilder);
var provider = services.BuildServiceProvider();
Domain(provider);
priceCalculator = new PriceCalculator(eventDispatcher.Handlers, queryDispatcher);
services
.AddSingleton(priceCalculator)
.AddSingleton(new FormatterContainer(commandFormatter, eventFormatter, queryFormatter, exceptionFormatter));
CreateReadModelContext(provider);
CreateEventSourcingContext(provider);
ReadModels(provider);
services
.AddSingleton <IEventHandlerCollection>(eventDispatcher.Handlers)
.AddScoped <ICommandDispatcher>(provider => new UserCommandDispatcher(commandDispatcher, provider.GetService <IHttpContextAccessor>().HttpContext, provider.GetService <ApiHub>()))
.AddScoped <IQueryDispatcher>(provider => new UserQueryDispatcher(queryDispatcher, provider.GetService <IHttpContextAccessor>().HttpContext));
CurrencyCache currencyCache = new CurrencyCache(eventDispatcher.Handlers, queryDispatcher, queryDispatcher);
services
.AddSingleton(currencyCache);
}
public void Start5hEnd12h_ShouldBeCorrect()
{
Limousine limousine = new Limousine("Tesla", "Model X", "White", 600, 1500, 2500, 2700);
DateTime startTime = new DateTime(2020, 09, 22, 5, 0, 0);
DateTime endTime = new DateTime(2020, 09, 22, 12, 0, 0);
TimeSpan totalHours = endTime - startTime;
double discountPercentage = 5;
Price price = PriceCalculator.PerHourPriceCalculator
(limousine, totalHours, startTime, endTime, discountPercentage);
Assert.AreEqual(price.FixedPrice, 0);
Assert.AreEqual(price.FirstHourPrice, 600);
Assert.AreEqual(price.NightHourCount, 1);
Assert.AreEqual(price.NightHourPrice, 840);
Assert.AreEqual(price.SecondHourCount, 5);
Assert.AreEqual(price.SecondHourPrice, 1950);
Assert.AreEqual(price.OvertimeCount, 0);
Assert.AreEqual(price.OvertimePrice, 0);
Assert.AreEqual(price.SubTotal, 3390);
Assert.AreEqual(price.ExclusiveBtw, 3220.5);
Assert.AreEqual(price.BtwPrice, 193.23);
Assert.AreEqual(price.Total, 3413.73);
}
public void Start20hEnd4h_ShouldBeCorrect()
{
Limousine limousine = new Limousine("Tesla", "Model X", "White", 600, 1500, 2500, 2700);
DateTime startTime = new DateTime(2020, 09, 22, 20, 0, 0);
DateTime endTime = new DateTime(2020, 09, 23, 4, 0, 0);
TimeSpan totalHours = endTime - startTime;
double discountPercentage = 5;
Price price = PriceCalculator.PerHourPriceCalculator
(limousine, totalHours, startTime, endTime, discountPercentage);
Assert.AreEqual(price.FixedPrice, 0);
Assert.AreEqual(price.FirstHourPrice, 600);
Assert.AreEqual(price.NightHourCount, 6);
Assert.AreEqual(price.NightHourPrice, 5040);
Assert.AreEqual(price.SecondHourCount, 1);
Assert.AreEqual(price.SecondHourPrice, 390);
Assert.AreEqual(price.OvertimeCount, 0);
Assert.AreEqual(price.OvertimePrice, 0);
Assert.AreEqual(price.SubTotal, 6030);
Assert.AreEqual(price.ExclusiveBtw, 5728.5);
Assert.AreEqual(price.BtwPrice, 343.71);
Assert.AreEqual(price.Total, 6072.21);
}
public void Start7hEnd17h_ShouldBeCorrect()
{
Limousine limousine = new Limousine("Tesla", "Model X", "White", 600, 1500, 2500, 2700);
DateTime startTime = new DateTime(2020, 09, 22, 7, 0, 0);
DateTime endTime = new DateTime(2020, 09, 22, 17, 0, 0);
TimeSpan totalHours = endTime - startTime;
double discountPercentage = 5;
Price price = PriceCalculator.PerHourPriceCalculator
(limousine, totalHours, startTime, endTime, discountPercentage);
Assert.AreEqual(price.FixedPrice, 0);
Assert.AreEqual(price.FirstHourPrice, 600);
Assert.AreEqual(price.NightHourCount, 0);
Assert.AreEqual(price.NightHourPrice, 0);
Assert.AreEqual(price.SecondHourCount, 9);
Assert.AreEqual(price.SecondHourPrice, 3510);
Assert.AreEqual(price.OvertimeCount, 0);
Assert.AreEqual(price.OvertimePrice, 0);
Assert.AreEqual(price.SubTotal, 4110);
Assert.AreEqual(price.ExclusiveBtw, 3904.5);
Assert.AreEqual(price.BtwPrice, 234.26999999999998);
Assert.AreEqual(price.Total, 4138.77);
}
public void PricingCalculator_WhenNewCustomerOrder_ReturnsAppropriatePrice()
{
var pricingCalc = new PriceCalculator(new List <IOrderRule>
{
new DistanceRule(),
new FloorRule(),
new WeekendRule(),
new NewCustomerRule(_orderRepo.Object),
new GoldenCustomerRule(_orderRepo.Object, _customerRepo.Object),
new CouponRule(_customerRepo.Object)
});
var order = new Models.Order
{
CustomerId = new Guid(),
DeliveryDate = DateTime.Today,
Distance = 5,
FloorNumber = 5
};
pricingCalc.Calculate(order);
Assert.AreEqual(849.15, order.Price);
}
public void Start7hEnd18h_ShouldBeCorrect()
{
Limousine limousine = new Limousine("Tesla", "Model X", "White", 600, 1500, 2500, 2700);
DateTime startTime = new DateTime(2020, 09, 22, 7, 0, 0);
DateTime endTime = new DateTime(2020, 09, 22, 18, 0, 0);
TimeSpan totalHours = endTime - startTime;
double discountPercentage = 5;
Price price = PriceCalculator.WeddingPriceCalculator
(limousine, totalHours, startTime, endTime, discountPercentage);
Assert.AreEqual(price.FixedPrice, 2500);
Assert.AreEqual(price.FirstHourPrice, 600);
Assert.AreEqual(price.SecondHourCount, 0);
Assert.AreEqual(price.SecondHourPrice, 0);
Assert.AreEqual(price.NightHourCount, 0);
Assert.AreEqual(price.NightHourPrice, 0);
Assert.AreEqual(price.OvertimeCount, 3);
Assert.AreEqual(price.OvertimePrice, 1170);
Assert.AreEqual(price.SubTotal, 4270);
Assert.AreEqual(price.ExclusiveBtw, 4056.5);
Assert.AreEqual(price.BtwPrice, 243.39);
Assert.AreEqual(price.Total, 4299.89);
}
public void Given_The_Fx_Rates_All_Product_Prices_Are_Increased_According_To_The_Source_And_Target_Currency()
{
var fxRates = new List <ForeignExchangeRateResponse>
{
new ForeignExchangeRateResponse {
Rate = 0.5m, SourceCurrency = "AUD", TargetCurrency = "GBP"
},
new ForeignExchangeRateResponse {
Rate = 2m, SourceCurrency = "AUD", TargetCurrency = "USD"
}
};
var products = new List <ProductResponse> {
new ProductResponse {
UnitPrice = 1
}, new ProductResponse {
UnitPrice = 2
}
};
var priceCalculator = new PriceCalculator(new ForeignExchangeRateCalculator(fxRates, Currency.AUD, Currency.USD));
var fxRatedProducts = priceCalculator.Calculate(products).ToArray();
Assert.Equal(2m, fxRatedProducts[0].UnitPrice);
Assert.Equal(4m, fxRatedProducts[1].UnitPrice);
}
public void CalculateProductPrice_ProductWithValidProps_ReturnsProductWithCalculatedPrice()
{
var calc = new PriceCalculator();
var kgAmount = new AmountUnit()
{
Id = 2, Name = "kg"
};
var prodInParam = new Product()
{
Id = 2,
Name = "Sugar",
CategoryId = 1,
MarketId = 1,
OriginId = 1,
PricePerUnit = 7.30,
Amount = 2,
AmountUnit = kgAmount,
AmountUnitId = 2,
};
var expectedProduct = new Product()
{
Id = 2,
Name = "Sugar",
CategoryId = 1,
MarketId = 1,
OriginId = 1,
PricePerUnit = 7.30,
Amount = 2,
AmountUnit = kgAmount,
AmountUnitId = 2,
Price = 14.60, // calculated price
};
var result = calc.CalculatePrice(prodInParam);
result.Price.Should().Be(expectedProduct.Price);
}
public void ElevenTotalHours_ShouldBeCorrect()
{
Limousine limousine = new Limousine("Tesla", "Model X", "White", 600, 1500, 2500, 2700);
DateTime startTime = new DateTime(2020, 09, 22, 12, 0, 0);
DateTime endTime = new DateTime(2020, 09, 22, 23, 0, 0);
TimeSpan totalHours = endTime - startTime;
double discountPercentage = 5;
Price price = PriceCalculator.WeddingPriceCalculator
(limousine, totalHours, startTime, endTime, discountPercentage);
Assert.AreEqual(price.FixedPrice, 2500);
Assert.AreEqual(price.FirstHourPrice, 600);
Assert.AreEqual(price.SecondHourCount, 0);
Assert.AreEqual(price.SecondHourPrice, 0);
Assert.AreEqual(price.NightHourCount, 1);
Assert.AreEqual(price.NightHourPrice, 840);
Assert.AreEqual(price.OvertimeCount, 2);
Assert.AreEqual(price.OvertimePrice, 780);
Assert.AreEqual(price.SubTotal, 4720);
Assert.AreEqual(price.ExclusiveBtw, 4484);
Assert.AreEqual(price.BtwPrice, 269.03999999999996);
Assert.AreEqual(price.Total, 4753.04);
}
public void GivenListOfCabins_WhenDiscountIsApplied_ShouldReturnCorrectPrice()
{
var cabins = new List <BookingSource.Cabin>
{
new BookingSource.Cabin {
TypeId = TypeB
},
new BookingSource.Cabin {
TypeId = TypeB
},
new BookingSource.Cabin {
TypeId = TypeB
},
new BookingSource.Cabin {
TypeId = TypeB
},
};
var priceCalculator = new PriceCalculator();
var result = priceCalculator.CalculatePrice(cabins, NoProducts, 16, CruiseCabinsForTesting, CruiseProductsForTesting);
var correctResult = 0.84m * 4 * CapacityB * PriceB;
Assert.AreEqual(correctResult, result);
}
public void GivenListOfCabins_WhenPriceCalculated_ShouldReturnCorrectPrice()
{
var cabins = new List <BookingSource.Cabin>
{
new BookingSource.Cabin {
TypeId = TypeA
},
new BookingSource.Cabin {
TypeId = TypeA
},
new BookingSource.Cabin {
TypeId = TypeB
},
new BookingSource.Cabin {
TypeId = TypeC
}
};
var priceCalculator = new PriceCalculator();
var result = priceCalculator.CalculatePrice(cabins, NoProducts, 0, CruiseCabinsForTesting, CruiseProductsForTesting);
var correctResult = 2 * CapacityA * PriceA + CapacityB * PriceB + CapacityC * PriceC;
Assert.AreEqual(correctResult, result);
}
public PizzasController(IUnitOfWork unitOfWork)
{
this.unitOfWork = unitOfWork;
priceCalculator = new PriceCalculator(unitOfWork);
}
public Order(IEnumerable<OrderLine> orderLines, PriceCalculator priceCalculator, Customer customer)
{
this.OrderLines = ImmutableList<OrderLine>.Empty.AddRange(orderLines);
this.priceCalculator = priceCalculator;
this.IsB2C = customer.IsConsumer;
}
public void SetUp()
{
_book1 = new Book { Id = 1, Price = 7.0 };
_book2 = new Book { Id = 2, Price = 7.0 };
_book3 = new Book { Id = 3, Price = 7.0 };
_book4 = new Book { Id = 4, Price = 8.0 };
_book5 = new Book { Id = 5, Price = 10.0 };
_priceCalculator = new PriceCalculator();
}
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);
}
public void SetUp()
{
_book1 = new Book { Id = 5 };
_book2 = new Book { Id = 6 };
_book3 = new Book { Id = 7 };
_book4 = new Book { Id = 8 };
_book5 = new Book { Id = 9 };
_priceCalculator = new PriceCalculator();
}
private Order CreateOrder(PriceCalculator priceCalculator, decimal itemPrice, bool isConsumer, int numItems)
{
return new Order(Enumerable.Repeat<OrderLine>(new OrderLine(new Sku(), 1, new Amount(Currency.DKK, itemPrice)), numItems),
priceCalculator,
new Customer { IsConsumer = isConsumer});
}
/// <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;
}
public void SetUp()
{
cart = A.Fake<ICart>();
calculator = new PriceCalculator(cart);
}
public Product(int factor)
{
Calculator=new PriceCalculator(factor);
}
public void SetUp()
{
var priceCalculator = new PriceCalculator(new List<IParkingPriceRule>());
_garage = new Garage(new CheckoutService(new DefaultTimeService(), priceCalculator));
}