public async Task InvoiceContainsTotalBonus(
[Frozen] Mock <IStockRepository> stockRepositoryMock,
[Frozen] Mock <IOrderItemPriceCalculator> orderItemPriceCalculatorMock,
[Frozen] Mock <IOrderItemBonusCalculator> orderItemBonusCalculatorMock,
InvoiceGenerator sut, Order order, List <OrderItem> orderItems)
{
orderItems.ForEach(order.AddItem);
stockRepositoryMock.Setup(m => m.GetById(It.IsAny <int>()))
.Returns <int>(id => Task.FromResult(new StockItem()));
// mock price = 0
orderItemPriceCalculatorMock.Setup(m => m.Calculate(It.IsAny <OrderItem>()))
.ReturnsAsync(0);
// mock bonus = {StockItemId} x {DurationDays}
orderItemBonusCalculatorMock.Setup(m => m.Calculate(It.IsAny <OrderItem>()))
.Returns <OrderItem>(i => Task.FromResult((int?)(i.StockItemId * i.DurationDays)));
var invoice = await sut.Generate(order);
var expectedTotalBonus = orderItems.Sum(i => i.StockItemId * i.DurationDays);
Assert.Contains($"\nBONUS\t\t{expectedTotalBonus}pt.", invoice);
}
public void Able_to_create_instance()
{
_ = new InvoiceGenerator(
Substitute.For <IProductRepository>(),
Substitute.For <ISupplierRepository>(),
Substitute.For <ICustomerRepository>());
}
public void GivenTimeAndDistance_calculatePremiumFare(double distance, double time, double output)
{
InvoiceGenerator invoiceGeneratorPremium = new InvoiceGenerator(InvoiceGenerator.ServiceType.PREMIUM_RIDE);
Ride ride = new Ride(distance, time);
Assert.AreEqual(output, invoiceGeneratorPremium.returnTotalFareForSingleRide(ride));
}
public void GivenDistanceAndTime_ShouldReturn_TotalFare()
{
double expected = 25;
double result = InvoiceGenerator.CalculateFare(2, 5, RideType.NORMAL);
Assert.AreEqual(expected, result);
}
public void GivenWrongRideParameters_WhenRead_ShouldReturn_Exception_INVALID_RIDE_TYPE()
{
invoiceGenerator = new InvoiceGenerator(RideType.NORMAL);
var exception = Assert.Throws <CabInvoiceException>(() => invoiceGenerator.CalculateFare(-45, -3));
Assert.AreEqual(CabInvoiceException.ExceptionType.INVALID_DISTANCE, exception.etype);
}
public IActionResult GetInvoice(int id)
{
var order = OrdersRepo.Get(id);
var invoice = InvoiceGenerator.GenerateInvoice(order, FeeRepository.Get());
return(new FileContentResult(Encoding.UTF8.GetBytes(invoice), InvoiceGenerator.MediaType));
}
public void GenerateInvoice_SpecifiedInput_ExpectedResult(string series, string expected)
{
InvoiceGenerator invoiceGenerator = new InvoiceGenerator();
string actual = invoiceGenerator.GenerateInvoice(series);
Assert.AreEqual(expected, actual);
}
public async Task InvoiceContainsItems(
[Frozen] Mock <IStockRepository> stockRepositoryMock,
[Frozen] Mock <IOrderItemPriceCalculator> orderItemPriceCalculatorMock,
[Frozen] Mock <IOrderItemBonusCalculator> orderItemBonusCalculatorMock,
InvoiceGenerator sut, Order order, List <OrderItem> orderItems)
{
orderItems.ForEach(order.AddItem);
// mock name = "stock-item-{Id}"
stockRepositoryMock.Setup(m => m.GetById(It.IsAny <int>()))
.Returns <int>(id => Task.FromResult(new StockItem {
Name = $"stock-item-{id}"
}));
// mock price = {StockItemId} x {DurationDays}
orderItemPriceCalculatorMock.Setup(m => m.Calculate(It.IsAny <OrderItem>()))
.Returns <OrderItem>(i => Task.FromResult((decimal?)(i.StockItemId * i.DurationDays)));
// mock bonus = 0
orderItemBonusCalculatorMock.Setup(m => m.Calculate(It.IsAny <OrderItem>()))
.ReturnsAsync(0);
var invoice = await sut.Generate(order);
orderItems.ForEach(i =>
Assert.Contains($"\nstock-item-{i.StockItemId}\t\t{i.StockItemId * i.DurationDays}€\n", invoice));
}
public void givenUserId_WhenAbsent_ShouldThrowAnException()
{
invoiceGenerator = new InvoiceGenerator(RideType.NORMAL);
var result = Assert.Throws <CabInvoiceException>(() => invoiceGenerator.GetUserInvoice(1));
Assert.AreEqual(CabInvoiceException.ExceptionType.INVALID_USER_ID, result.type);
}
public void totalFairForJourney()
{
InvoiceGenerator generate = new InvoiceGenerator();
int Fair = generate.totalFair(5, 60);
Assert.AreEqual(110, Fair);
}
public void GenereteInvoice_ShouldCalculateTaxesForItems()
{
var invoiceGenerator = new InvoiceGenerator();
var result = invoiceGenerator.GenerateInvoice().Value;
Assert.AreEqual(0.3, result, 0.0001);
}
static void Main(string[] args)
{
var kompanijos = new CompanyRepository();
Console.WriteLine("Kompanijos:");
foreach (var item in kompanijos.Retrieve())
{
Console.WriteLine("{0} {1} {2}", item.ID, item.Name, item.Address);
}
var saskaitos = new InvoiceItemOutsideRepository();
Console.WriteLine("Saskaitos:");
foreach (var item in saskaitos.Retrieve())
{
Console.WriteLine("{0} {1} {2} {3} {4}", item.Number, item.ProviderCompanyId, item.RecipientCompanyId, item.ServiceName, item.Cost);
}
var ataskaitosGeneravimas = new InvoiceGenerator(new InvoiceItemOutsideRepository(), new CompanyRepository());
var report = ataskaitosGeneravimas.GenerateReportInvoice();
Console.WriteLine("Ataskaita:");
foreach (var ataskaita in report)
{
Console.WriteLine("{0}, {1}, {2}, {3}, {4}, {5}", ataskaita.Number,
ataskaita.ProviderCompanyAdress,
ataskaita.ProviderCompanyName,
ataskaita.RecipientCompanyAdress,
ataskaita.RecipientCompanyName,
ataskaita.Total);
}
Console.ReadLine();
}
public async Task Able_to_generate_invoice()
{
var product = ProductMockBuilder.Build();
var productRepo = Substitute.For <IProductRepository>();
productRepo.Get(Arg.Any <Guid>()).Returns(product);
var supplier = SupplierMockBuilder.Build();
var supplierRepo = Substitute.For <ISupplierRepository>();
supplierRepo.Get(Arg.Any <Guid>()).Returns(supplier);
var customer = CustomerMockBuilder.Build();
var customerRepo = Substitute.For <ICustomerRepository>();
customerRepo.Get(Arg.Any <Guid>()).Returns(customer);
var sut = new InvoiceGenerator(productRepo, supplierRepo, customerRepo);
var actual = await sut.Generate(OrderMockBuilder.Build());
actual.Customer.Should().Be(customer);
actual.Supplier.Should().Be(supplier);
actual.Product.Should().Be(product);
actual.Amount.Should().Be(new InvoiceAmount(30, 0.19));
}
static void Main(string[] args)
{
Console.WriteLine("Welcome To Cab Invoice Generator");
InvoiceGenerator invoiceGenerator = new InvoiceGenerator(RideType.PREMIUM);
double fare = invoiceGenerator.CalculateFare(2.0, 5);
Console.WriteLine($"Fare : {fare}");
}
public void EnhancedInvoiceTotalNumberOfRides()
{
Ride[] ride = { new Ride(5, 60), new Ride(4, 50), new Ride(3, 40) };
InvoiceGenerator generate = new InvoiceGenerator();
Tuple <int, int, double> average = generate.aggregateFare(ride);
Assert.AreEqual(average.Item2, 3);
}
public void EnhancedInvoiceAggregateFair()
{
Ride[] ride = { new Ride(5, 60), new Ride(4, 50), new Ride(3, 40) };
InvoiceGenerator generate = new InvoiceGenerator();
Tuple <int, int, double> aggregate = generate.aggregateFare(ride);
Assert.AreEqual(aggregate.Item1, 270);
}
public void TakeDistanceAndTimeReturnTotalFare()
{
double travelDistance = 10.0;
double travelTime = 5;
InvoiceGenerator invoiceGen = new InvoiceGenerator();
Assert.AreEqual(105, invoiceGen.FareCalculate(travelDistance, travelTime));
}
//Test case 4 - Should return total fare on having multiple rides
public void Given_MultipleNoOfRides_Should_Return_TotalFare()
{
invoiceGenerator = new InvoiceGenerator(RideType.NORMAL);
rides = new Ride[] { new Ride(10, 60), new Ride(5, 30), new Ride(3, 20) };
double fare = invoiceGenerator.CalculateFare(rides);
Assert.AreEqual(290, fare);
}
public QrController(InvoiceGenerator invoiceGenerator, PaymentDataGenerator paymentDataGenerator, SmtpEmailFileSender emailSender, IOptions <GeneratorOptions> genOptions, IOptions <GeneratorSensitiveOptions> genSensitiveOptions)
{
this._invoiceGenerator = invoiceGenerator;
this._paymentDataGenerator = paymentDataGenerator;
this._emailSender = emailSender;
this._sensitiveOpts = genSensitiveOptions.Value;
this._genOpts = genOptions.Value;
}
public void GivenUserId_WhenAbsent_Should_Return_CabInvoiceException()
{
invoiceGenerator = new InvoiceGenerator(RideType.NORMAL);
var exception = Assert.Throws <CabInvoiceException>(() => invoiceGenerator.GetUserInvoice(1));
Assert.AreEqual(CabInvoiceException.Type.INVALID_USER_ID, exception.type);
}
public void CalculateFare_IfNullRides_ThrowsException()
{
var invoiceGenerator = new InvoiceGenerator();
var exception = Assert.Throws <CabInvoiceException>(() => invoiceGenerator.CalculateFare(null));
Assert.That(exception.type, Is.EqualTo(CabInvoiceException.ExceptionType.NULL_RIDES));
}
public void CalculateFare_IfInvalidTime_ThrowsException()
{
var invoiceGenerator = new InvoiceGenerator();
var exception = Assert.Throws <CabInvoiceException>(() => invoiceGenerator.CalculateFare(1.0, -1));
Assert.That(exception.type, Is.EqualTo(CabInvoiceException.ExceptionType.INVALID_TIME));
}
public void CalculateFare_IfValidParameters_ReturnsFare(RideType rideType, double expectedFare)
{
var invoiceGenerator = new InvoiceGenerator(rideType);
var result = invoiceGenerator.CalculateFare(2.0, 1);
Assert.That(result, Is.EqualTo(expectedFare));
}
public void GivenNormalMultipleRideShouldReturnInvoiceSummary()
{
invoiceGenerator = new InvoiceGenerator(RideType.NORMAL);
Ride[] rides = { new Ride(2.0, 5), new Ride(2.0, 5) };
InvoiceSummary summary = invoiceGenerator.CalculateFare(rides);
InvoiceSummary expectedSummary = new InvoiceSummary(2, 50.0);
Assert.AreEqual(expectedSummary, summary);
}
public void GivenPremiumRides_ShouldReturnTotalFare()
{
invoiceGenerator = new InvoiceGenerator(RideType.PREMIUM);
Ride[] rides = { new Ride(2, 5), new Ride(2, 1) };
InvoiceSummary result = invoiceGenerator.CalculateFare(rides);
InvoiceSummary expectedInvoiceSummary = new InvoiceSummary(2, 72);
Assert.AreEqual(expectedInvoiceSummary, result);
}
public void GivenMultipleRides_ShouldReturnInvoiceSummary()
{
invoiceGenerator = new InvoiceGenerator(RideType.NORMAL);
Ride[] rides = { new Ride(2, 5), new Ride(2, 1) };
InvoiceSummary result = invoiceGenerator.CalculateFare(rides);
InvoiceSummary expectedInvoiceSummary = new InvoiceSummary(2, 46);
Assert.AreEqual(expectedInvoiceSummary, result);
}
public void GivenMultipleRide_ShouldReturn_TotalNoRides_Fare_AverageFarePerRide()
{
invoiceGenerator = new InvoiceGenerator(RideType.NORMAL);
Ride[] rides = { new Ride(2.0, 5), new Ride(0.1, 3) };
InvoiceSummary enhancedSummary = invoiceGenerator.CalculateFare(rides);
InvoiceSummary expectedEnhancedSummary = new InvoiceSummary(2, 30);
Assert.AreEqual(expectedEnhancedSummary, enhancedSummary);
}
public void GivenMultipleRides_ShouldReturn_InvoiceSummary()
{
double expected = 45.0;
Ride[] ridesTestObj = { new Ride(2.0, 5, RideType.NORMAL), new Ride(0.1, 1, RideType.PREMIUM) };
InvoiceSummary result = InvoiceGenerator.CalculateFare(ridesTestObj);
Assert.AreEqual(expected, result.totalFare);
}
public void GivenMultipleRides_WhenInvoiceGenerator_thenShouldReturnFollowingInvoiceSummary()
{
invoiceGenerator = new InvoiceGenerator(RideType.NORMAL);
Ride[] rides = { new Ride(2.0, 5), new Ride(0.1, 1) };
InvoiceSummary invoiceSummary = invoiceGenerator.CalculateAvrageFare(rides);
InvoiceSummary expectedSummary = new InvoiceSummary(2, 30.0, 15);
Assert.AreEqual(expectedSummary, invoiceSummary);
}
public void GivenMultipleRideShouldReturnInvoiceSummary()
{
invoiceGenerator = new InvoiceGenerator(RideType.NORMAL);
Ride[] rides = { new Ride(2.0, 5), new Ride(0.1, 5) };
InvoiceSummary summary = invoiceGenerator.CalculateFare(rides);
InvoiceSummary expectedSummary = new InvoiceSummary(2, 35.0);
NUnit.Framework.Assert.AreEqual(expectedSummary.GetType(), summary.GetType());
}
