public void ContractAggregate_AddFixedValueProduct_DuplicateProduct_ErrorThrown()
{
ContractAggregate aggregate = ContractAggregate.Create(TestData.ContractId);
aggregate.Create(TestData.EstateId, TestData.OperatorId, TestData.ContractDescription);
aggregate.AddFixedValueProduct(TestData.ProductId, TestData.ProductName, TestData.ProductDisplayText, TestData.ProductFixedValue);
Should.Throw <InvalidOperationException>(() =>
{
aggregate.AddFixedValueProduct(TestData.ProductId, TestData.ProductName, TestData.ProductDisplayText, TestData.ProductFixedValue);
});
}
/// <summary>
/// Adds the product to contract.
/// </summary>
/// <param name="productId">The product identifier.</param>
/// <param name="contractId">The contract identifier.</param>
/// <param name="productName">Name of the product.</param>
/// <param name="displayText">The display text.</param>
/// <param name="value">The value.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <exception cref="System.InvalidOperationException">Contract Id [{contractId}] must be created to add products</exception>
public async Task AddProductToContract(Guid productId,
Guid contractId,
String productName,
String displayText,
Decimal?value,
CancellationToken cancellationToken)
{
// Get the contract aggregate
ContractAggregate contractAggregate = await this.ContractAggregateRepository.GetLatestVersion(contractId, cancellationToken);
// Check for a duplicate
if (contractAggregate.IsCreated == false)
{
throw new InvalidOperationException($"Contract Id [{contractId}] must be created to add products");
}
if (value.HasValue)
{
contractAggregate.AddFixedValueProduct(productId, productName, displayText, value.Value);
}
else
{
contractAggregate.AddVariableValueProduct(productId, productName, displayText);
}
await this.ContractAggregateRepository.SaveChanges(contractAggregate, cancellationToken);
}
public void ContractAggregate_AddFixedValueProduct_InvalidProductValue_ErrorThrown(Decimal value)
{
ContractAggregate aggregate = ContractAggregate.Create(TestData.ContractId);
aggregate.Create(TestData.EstateId, TestData.OperatorId, TestData.ContractDescription);
Should.Throw <ArgumentOutOfRangeException>(() =>
{
aggregate.AddFixedValueProduct(TestData.ProductId, TestData.ProductName, TestData.ProductDisplayText, value);
});
}
public void ContractAggregate_AddFixedValueProduct_InvalidProductDisplayText_ErrorThrown(String displayText)
{
ContractAggregate aggregate = ContractAggregate.Create(TestData.ContractId);
aggregate.Create(TestData.EstateId, TestData.OperatorId, TestData.ContractDescription);
Should.Throw <ArgumentNullException>(() =>
{
aggregate.AddFixedValueProduct(TestData.ProductId, TestData.ProductName, displayText, TestData.ProductFixedValue);
});
}
public void ContractAggregate_AddTransactionFee_ProductNotFound_ErrorThrown(CalculationType calculationType, FeeType feeType)
{
ContractAggregate aggregate = ContractAggregate.Create(TestData.ContractId);
aggregate.Create(TestData.EstateId, TestData.OperatorId, TestData.ContractDescription);
aggregate.AddFixedValueProduct(TestData.ProductId, TestData.ProductName, TestData.ProductDisplayText, TestData.ProductFixedValue);
Should.Throw <InvalidOperationException>(() =>
{
aggregate.AddTransactionFee(new Product(), TestData.TransactionFeeId, TestData.TransactionFeeDescription, calculationType, feeType, TestData.TransactionFeeValue);
});
}
public void ContractAggregate_AddTransactionFee_FixedValueProduct_InvalidFeeDescription_ErrorThrown(CalculationType calculationType, FeeType feeType, String feeDescription)
{
ContractAggregate aggregate = ContractAggregate.Create(TestData.ContractId);
aggregate.Create(TestData.EstateId, TestData.OperatorId, TestData.ContractDescription);
aggregate.AddFixedValueProduct(TestData.ProductId, TestData.ProductName, TestData.ProductDisplayText, TestData.ProductFixedValue);
List <Product> products = aggregate.GetProducts();
Product product = products.Single();
Should.Throw <ArgumentNullException>(() =>
{
aggregate.AddTransactionFee(product, TestData.TransactionFeeId, feeDescription, calculationType, feeType, TestData.TransactionFeeValue);
});
}
public void ContractAggregate_AddFixedValueProduct_ProductAdded()
{
ContractAggregate aggregate = ContractAggregate.Create(TestData.ContractId);
aggregate.Create(TestData.EstateId, TestData.OperatorId, TestData.ContractDescription);
aggregate.AddFixedValueProduct(TestData.ProductId, TestData.ProductName, TestData.ProductDisplayText, TestData.ProductFixedValue);
List <Product> products = aggregate.GetProducts();
products.Count.ShouldBe(1);
products.First().ProductId.ShouldNotBe(Guid.Empty);
products.First().Name.ShouldBe(TestData.ProductName);
products.First().DisplayText.ShouldBe(TestData.ProductDisplayText);
products.First().Value.ShouldBe(TestData.ProductFixedValue);
}
public void ContractAggregate_AddTransactionFee_FixedValueProduct_TransactionFeeAdded(CalculationType calculationType, FeeType feeType)
{
ContractAggregate aggregate = ContractAggregate.Create(TestData.ContractId);
aggregate.Create(TestData.EstateId, TestData.OperatorId, TestData.ContractDescription);
aggregate.AddFixedValueProduct(TestData.ProductId, TestData.ProductName, TestData.ProductDisplayText, TestData.ProductFixedValue);
List <Product> products = aggregate.GetProducts();
Product product = products.Single();
aggregate.AddTransactionFee(product, TestData.TransactionFeeId, TestData.TransactionFeeDescription, calculationType, feeType, TestData.TransactionFeeValue);
List <Product> productsAfterFeeAdded = aggregate.GetProducts();
Product productWithFees = productsAfterFeeAdded.Single();
productWithFees.TransactionFees.ShouldHaveSingleItem();
TransactionFee fee = productWithFees.TransactionFees.Single();
fee.Description.ShouldBe(TestData.TransactionFeeDescription);
fee.TransactionFeeId.ShouldBe(TestData.TransactionFeeId);
fee.CalculationType.ShouldBe(calculationType);
fee.FeeType.ShouldBe(feeType);
fee.Value.ShouldBe(TestData.TransactionFeeValue);
}
