public void ProperlyCompute_CompoundOrders(bool isSpeedy, decimal expectedTotal)
{
// arrange
var smallParcelType = new MockSomethingSmallSizeParcel();
var weightBasedParcel = new MockWeightBasedParcel();
_mockParcelClassifier.Setup(p => p.ClassifyParcelBySize(It.IsAny <double>()))
.Returns(smallParcelType);
_mockParcelClassifier.Setup(p => p.ClassifyHeavyParcelByWeight(It.IsAny <double>()))
.Returns(weightBasedParcel);
var parcelOrder = new ParcelOrder
{
Speedy = isSpeedy,
ParcelOrderItems = new List <ParcelOrderItem>
{
new ParcelOrderItem(1, 2, CalculationType.BySize),
new ParcelOrderItem(1, 1, CalculationType.BySize),
new ParcelOrderItem(1, 50, CalculationType.ByWeight),
new ParcelOrderItem(1, 51, CalculationType.ByWeight)
}
};
// act
var order = _parcelBuilder.BuildOrder(parcelOrder);
// assert
order.TotalCost.Should().Be(expectedTotal);
}
public void ProperlyGenerateOrderLines()
{
// arrange
var smallParcelType = new MockSomethingSmallSizeParcel();
_mockParcelClassifier.Setup(p => p.ClassifyParcelBySize(It.IsAny <double>()))
.Returns(smallParcelType);
var parcelOrder = new ParcelOrder
{
ParcelOrderItems = new List <ParcelOrderItem>
{
new ParcelOrderItem(5, 1, CalculationType.BySize)
},
};
// act
var order = _parcelBuilder.BuildOrder(parcelOrder);
// assert
order.LineItems.Count.Should().Be(1);
order.LineItems.Single().Cost.Should().Be(smallParcelType.Cost);
order.LineItems.Single().ParcelType.Should().Be(smallParcelType.ParcelType.ToString());
}
public ParcelOrderOutput BuildOrder(ParcelOrder parcelOrder)
{
if (!parcelOrder.ParcelOrderItems.HaveValidParcelItems())
{
throw new Exception("Invalid Process.");
}
var parcelOrderOutput = new ParcelOrderOutput
{
IsSpeedy = parcelOrder.Speedy
};
var parcelBySize = parcelOrder.ParcelOrderItems.Where(p => p.CalculationType.Equals(CalculationType.BySize));
var parcelByWeight = parcelOrder.ParcelOrderItems.Where(p => p.CalculationType.Equals(CalculationType.ByWeight));
if (parcelBySize.Any())
{
var(lineItems, totalCost) = ComposeLineItems(parcelBySize, ParcelBySizeSelector());
parcelOrderOutput.LineItems.AddRange(lineItems);
parcelOrderOutput.TotalCost += totalCost;
}
if (parcelByWeight.Any())
{
var(lineItems, totalCost) = ComposeLineItems(parcelByWeight, ParcelByWeightSelector());
parcelOrderOutput.LineItems.AddRange(lineItems);
parcelOrderOutput.TotalCost += totalCost;
}
// apply discounts
if (parcelOrder.DiscountToApply.Any())
{
AppliedDiscount discount;
if (parcelOrder.DiscountToApply.Contains(DiscountTypes.Mixed))
{
discount = _discountCalculator.CalculateMixedDiscount(parcelOrderOutput.LineItems);
}
else
{
discount = _discountCalculator.CalculateDiscount(parcelOrderOutput.LineItems);
}
parcelOrderOutput.TotalCost = discount.TotalCost;
parcelOrderOutput.TotalSaved = discount.SavedCost;
}
if (parcelOrder.Speedy)
{
parcelOrderOutput.TotalCost *= 2;
}
return(parcelOrderOutput);
}
public IParcelOrder GeneratePacels(IParcelFactory parcelFactory, List<IParcelSettings> parcelSettings, IParcelOrderSettings parcelOrderSettings)
{
var parcelOrder = new ParcelOrder(parcelOrderSettings);
foreach (var setting in parcelSettings)
{
parcelOrder.Add(parcelFactory.CreateParcel(setting));
}
return parcelOrder;
}
public void ExecuteOrder(ParcelOrder order)
{
try
{
_logger.LogInformation("Processing Order.");
var output = _parcelOrderBuilder.BuildOrder(order);
PrintOutput(output);
}
catch (Exception e)
{
_logger.LogError("Failed to Process Order.", e);
}
}
public void ShouldApplyOneMediumDiscount()
{
var testParcels = new List <Parcel>
{
new Parcel(45, 45, 45, 3),
new Parcel(45, 45, 45, 3),
new Parcel(45, 45, 45, 4),
};
var newParcelOrder = new ParcelOrder(testParcels);
Assert.Equal(testParcels.Count(), newParcelOrder.Parcels.Count());
Assert.Single(newParcelOrder.Discounts);
Assert.Equal(8, newParcelOrder.TotalDiscount);
}
public void ShouldApplyOneSmallDiscount()
{
var testParcels = new List <Parcel>
{
new Parcel(1, 1, 1, 0),
new Parcel(1, 1, 1, 0),
new Parcel(1, 1, 1, 0),
new Parcel(1, 1, 1, 2)
};
var newParcelOrder = new ParcelOrder(testParcels);
Assert.Equal(testParcels.Count(), newParcelOrder.Parcels.Count());
Assert.Single(newParcelOrder.Discounts);
Assert.Equal(3, newParcelOrder.TotalDiscount);
}
public void ShouldCreateAParcelOrderAndSetTheTotalCost(ParcelSize result, int length, int width, int heigth, double weigth)
{
//Arrange
//The test values are defined on the attribute "InlineDate"
var testParcel = new Parcel(length, width, heigth, weigth);
//Act
var testParcelOrder = new ParcelOrder(testParcel);
//Assert
Assert.Single(testParcelOrder.Parcels);
Assert.Equal(SizeCost.GetCost(result), testParcelOrder.TotalCost);
Assert.All(testParcelOrder.Parcels, x =>
{
Assert.Equal(SizeCost.GetCost(result), x.Cost);
});
Assert.Null(testParcelOrder.SpeedyShippingCost);
}
public void CalculateCost_WhenAnOrderIsApplicableForMediumParcelMania_Every3rdMediumParcelIsFreeAndCostIsReturned()
{
//Arrange
var parcels = new List <Parcel>()
{
new Parcel(25, 3), //$8
new Parcel(25, 4), //$10
new Parcel(25, 3) //$8
};
var parcelOrder = new ParcelOrder(parcels);
//Act
var parcelCost = parcelOrder.CalculateCost();
//Assert
Assert.Equal(26, parcelCost.Cost);
Assert.Equal(-8, parcelCost.Discount);
}
public void ShouldCreateAParcelOrderAndSetTheTotalCostWithExtraWeight()
{
var length = 1;
var width = 1;
var heigth = 1;
var weight = 6;
var testParcel = new Parcel(length, width, heigth, weight);
var testParcelOrder = new ParcelOrder(testParcel);
var expectedTotalCost = SizeCost.GetCost(ParcelSize.Small) + WeightLimit.GetCost(ParcelSize.Small, weight);
Assert.Single(testParcelOrder.Parcels);
Assert.Equal(expectedTotalCost, testParcelOrder.TotalCost);
Assert.All(testParcelOrder.Parcels, x =>
{
Assert.Equal(expectedTotalCost, x.Cost);
});
Assert.Null(testParcelOrder.SpeedyShippingCost);
}
public void ShouldAddOneDiscountTypeEach()
{
var testParcels = new List <Parcel>
{
new Parcel(1, 1, 1, 0),
new Parcel(1, 1, 1, 0),
new Parcel(1, 1, 1, 0),
new Parcel(1, 1, 1, 2),
new Parcel(45, 45, 45, 3),
new Parcel(45, 45, 45, 3),
new Parcel(45, 45, 45, 4),
new Parcel(75, 75, 75, 0),
};
var newParcelOrder = new ParcelOrder(testParcels);
Assert.Equal(testParcels.Count(), newParcelOrder.Parcels.Count());
Assert.Equal(3, newParcelOrder.Discounts.Count());
Assert.Equal(14, newParcelOrder.TotalDiscount);
}
public void ShouldCreateAParcelOrderAndSetTheTotalForAHeavyParcel()
{
var length = 1;
var width = 1;
var heigth = 1;
var weight = 100d;
var testParcel = new Parcel(length, width, heigth, weight);
var testParcelOrder = new ParcelOrder(testParcel);
var expectedTotalCost = WeightLimit.GetHeavyParcelCost(weight);
Assert.Single(testParcelOrder.Parcels);
Assert.Equal(expectedTotalCost, testParcelOrder.TotalCost);
Assert.All(testParcelOrder.Parcels, x =>
{
Assert.Equal(expectedTotalCost, x.Cost);
});
Assert.Null(testParcelOrder.SpeedyShippingCost);
}
public void CalculateCost_WhenAnOrderIsApplicableForSmallParcelMania_Every4thSmallParcelIsFreeAndCostIsReturned()
{
//Arrange
var parcels = new List <Parcel>()
{
new Parcel(5, 1), //$3
new Parcel(5, 2), //$5
new Parcel(5, 1), //$3
new Parcel(5, 2), //$3
};
var parcelOrder = new ParcelOrder(parcels);
//Act
var parcelCost = parcelOrder.CalculateCost();
//Assert
Assert.Equal(14, parcelCost.Cost);
Assert.Equal(-3, parcelCost.Discount);
}
public override void OnCreate()
{
base.OnCreate();
m_Radios = GetComponentsInChildren <Toggle>(true);
var index = 0;
foreach (var radio in m_Radios)
{
var id = index;
index++;
radio.onValueChanged.AddListener((bool enabled) =>
OnRadioValueChanged(id, enabled));
radio.isOn = id == DEFAULT_ORDER;
}
Data = new ParcelOrder();
IsExpanded = true;
}
public void CalculateCost_WhenAnOrderIsApplicableForMixedParcelMania_Every5thParcelIsFreeAndCostIsReturned()
{
//Arrange
var parcels = new List <Parcel>()
{
new Parcel(5, 1), //$3
new Parcel(25, 3), //$8
new Parcel(75, 6), //$15
new Parcel(5, 1), //$3
new Parcel(25, 3) //$8
};
var parcelOrder = new ParcelOrder(parcels);
//Act
var parcelCost = parcelOrder.CalculateCost();
//Assert
Assert.Equal(37, parcelCost.Cost);
Assert.Equal(-3, parcelCost.Discount);
}
public void ShouldCreateAParcelOrderWithSeveralParcelsAndSetTheTotalCost()
{
var testParcels = new List <Parcel>
{
new Parcel(1, 1, 1, 0),
new Parcel(75, 75, 75, 0),
new Parcel(150, 150, 150, 0)
};
var testParcelOrder = new ParcelOrder(testParcels);
var expectedTotalCost = SizeCost.GetCost(ParcelSize.Small) + SizeCost.GetCost(ParcelSize.Large) + SizeCost.GetCost(ParcelSize.ExtraLarge);
Assert.Equal(testParcels.Count(), testParcelOrder.Parcels.Count());
Assert.Equal(expectedTotalCost, testParcelOrder.TotalCost);
Assert.All(testParcelOrder.Parcels, x =>
{
Assert.Equal(SizeCost.GetCost(x.Size), x.Cost);
});
Assert.Null(testParcelOrder.SpeedyShippingCost);
}
public void ProperlyComputeWeightAddOn()
{
// arrange
var smallParcelType = new MockSomethingSmallSizeParcel();
_mockParcelClassifier.Setup(p => p.ClassifyParcelBySize(It.IsAny <double>()))
.Returns(smallParcelType);
var parcelOrder = new ParcelOrder
{
ParcelOrderItems = new List <ParcelOrderItem>
{
new ParcelOrderItem(5, 2, CalculationType.BySize),
new ParcelOrderItem(5, 1, CalculationType.BySize)
}
};
// act
var order = _parcelBuilder.BuildOrder(parcelOrder);
// assert
order.TotalCost.Should().Be(24);
}
public void ShouldCreateAParcelOrderWithSpeedyShippingValueSet()
{
var length = 1;
var width = 1;
var heigth = 1;
var weight = 0;
var testParcel = new Parcel(length, width, heigth, weight);
var speedyShipping = true;
var testParcelOrder = new ParcelOrder(testParcel, speedyShipping);
var expectedTotalCost = SizeCost.GetCost(ParcelSize.Small) * 2;
var speedyShippingCost = expectedTotalCost / 2;
Assert.Single(testParcelOrder.Parcels);
Assert.Equal(expectedTotalCost, testParcelOrder.TotalCost);
Assert.All(testParcelOrder.Parcels, x =>
{
Assert.Equal(SizeCost.GetCost(x.Size), x.Cost);
});
Assert.NotNull(testParcelOrder.SpeedyShippingCost);
Assert.Equal(speedyShippingCost, testParcelOrder.SpeedyShippingCost);
}
public void CalculateCost_WhenAnOrderIsApplicableForMultipleDiscounts_BestPriceDiscountsAreSelectedAndCostIsReturned()
{
//Arrange
var parcels = new List <Parcel>()
{
new Parcel(5, 1), //$3
new Parcel(5, 1), //$3
new Parcel(5, 1), //$3
new Parcel(5, 1), //$3
new Parcel(25, 3), //$8
new Parcel(25, 3), //$8
new Parcel(25, 3) //$8
};
var parcelOrder = new ParcelOrder(parcels);
//Act
var parcelCost = parcelOrder.CalculateCost();
//Assert
Assert.Equal(36, parcelCost.Cost);
Assert.Equal(-11, parcelCost.Discount);
}
[InlineData(5, 50, false, CalculationType.ByWeight, 100)] // cost would double coz discount is not supported
public void ProperlyComputeCost(double size, double weight, bool isSpeedy, CalculationType calculationType, decimal expectedTotalCost)
{
// arrange
var smallParcelType = new MockSomethingSmallSizeParcel();
var weightBasedParcel = new MockWeightBasedParcel();
_mockParcelClassifier.Setup(p => p.ClassifyParcelBySize(It.IsAny <double>()))
.Returns(smallParcelType);
_mockParcelClassifier.Setup(p => p.ClassifyHeavyParcelByWeight(It.IsAny <double>()))
.Returns(weightBasedParcel);
var parcelBuilderWithDiscount = new ParcelOrderBuilder(_mockParcelClassifier.Object, new DiscountCalculator(new List <IDiscount>
{
new MockDiscountConfiguration()
}));
var parcelOrder = new ParcelOrder
{
Speedy = isSpeedy,
DiscountToApply = new List <DiscountTypes>
{
DiscountTypes.Small
},
ParcelOrderItems = new List <ParcelOrderItem>
{
new ParcelOrderItem(size, weight, calculationType),
new ParcelOrderItem(size, weight, calculationType)
}
};
// act
var order = parcelBuilderWithDiscount.BuildOrder(parcelOrder);
// assert
order.TotalCost.Should().Be(expectedTotalCost);
}
static void Main(string[] args)
{
var serviceCollection = new ServiceCollection();
ConfigureServices(serviceCollection);
var serviceProvider = serviceCollection.BuildServiceProvider();
var worker = serviceProvider.GetService <IParcelWorker>();
var order = new ParcelOrder
{
Speedy = true,
DiscountToApply = new List <DiscountTypes>
{
DiscountTypes.Small,
DiscountTypes.Medium
},
ParcelOrderItems = new List <ParcelOrderItem>
{
new ParcelOrderItem(9, 1, CalculationType.BySize),
new ParcelOrderItem(9, 5, CalculationType.BySize),
new ParcelOrderItem(9, 1, CalculationType.BySize),
new ParcelOrderItem(9, 1, CalculationType.BySize),
new ParcelOrderItem(49, 50, CalculationType.BySize),
new ParcelOrderItem(49, 4, CalculationType.BySize),
new ParcelOrderItem(51, 100, CalculationType.BySize),
new ParcelOrderItem(101, 1000, CalculationType.BySize),
new ParcelOrderItem(101, 50, CalculationType.ByWeight),
new ParcelOrderItem(101, 51, CalculationType.ByWeight),
}
};
worker.ExecuteOrder(order);
serviceProvider.Dispose();
}
