public async Task WhenDtoIsValid_ShouldCreatePartner()
{
var command = new CreatePartnerCommand()
{
Address = new AddressDto()
{
City = "Toronto",
Country = "Canada",
Street = "Street 123",
ZipCode = "1234XX"
},
Name = "Test Name"
};
// Act.
var partnerId = await TestFramework.SendAsync(command);
var partner = await TestFramework.Data.FindAsync <Partner>(partnerId, x => x.Transactions);
partner.Should().NotBeNull();
partner.Id.Should().Be(partnerId);
partner.CreatedAt.Should().BeCloseTo(DateTime.Now, 10000);
partner.CreatedBy.Should().NotBeNullOrWhiteSpace();
partner.LastModifiedAt.Should().BeNull();
partner.DeletedAt.Should().BeNull();
partner.Transactions.Should().BeEmpty();
partner.Name.Should().Be(command.Name);
partner.Address.Should().NotBeNull();
partner.Address.Should().BeEquivalentTo(command.Address,
o => o.ComparingByMembers <AddressDto>());
}
public async Task WhenSalesRequested_ShouldReturnOnlySales()
{
var partner = (await TestFramework.DataFactory.AddPartners(1)).First();
for (int i = 0; i < 6; i++)
{
await TestFramework.DataFactory.CreateProcurementTransaction(1, partner,
createNewProducts : true);
}
var numberOfSales = 3;
var products = await TestFramework.Data.GetAllAsync <Product>();
for (int i = 0; i < numberOfSales; i++)
{
await TestFramework.DataFactory.CreateSalesTransaction(partner, products.Skip(i).Take(1));
}
var list = await TestFramework.SendAsync(new GetTransactionListQuery()
{
Type = TransactionType.Sales
});
list.Should().NotBeNull();
list.RowCount.Should().Be(numberOfSales);
list.Results.Should().HaveCount(numberOfSales)
.And.OnlyHaveUniqueItems()
.And.OnlyContain(x => x.TransactionType == (int)TransactionType.Sales);
}
public async Task WhenIdValid_ShouldReturnTransactionDetails()
{
var existing = await TestFramework.DataFactory.CreateProcurementTransaction(4);
var result = await TestFramework.SendAsync(new GetTransactionDetailsQuery()
{
Id = existing.Id
});
result.Should().NotBeNull();
result.CreatedAt.Should().BeCloseTo(DateTime.Now, 10000);
result.PartnerId.Should().Be(existing.PartnerId);
result.PartnerName.Should().Be(existing.Partner.Name);
result.PartnerAddress.Should().Be(existing.Partner.Address.ToString());
result.TotalAmount.Should().Be(existing.Total.Amount);
result.TotalCurrencyCode.Should().Be(existing.Total.Currency.Code);
result.TransactionType.Should().Be((int)existing.TransactionType);
result.TransactionLines
.Should().BeEquivalentTo(existing.TransactionLines
.Select(ent => new {
ent.ProductId,
ent.Quantity,
ProductName = ent.Product.Name,
UnitPrice = ent.UnitPrice.ToString(),
UnitPriceAmount = ent.UnitPrice.Amount,
UnitPriceCurrencyCode = ent.UnitPrice.Currency.Code
}),
o => o.ExcludingMissingMembers());
}
public void WhenDtoIsBlank_ShouldThrow_InputValidationException()
{
var command = new CreatePartnerCommand();
FluentActions.Invoking(() => TestFramework.SendAsync(command))
.Should().Throw <InputValidationException>();
}
public async Task WhenDtoIsValid_ShouldCreateProduct()
{
var command = new CreateProductCommand()
{
Name = "Product",
Description = "Description",
MassUnitSymbol = "kg",
MassValue = 10.1f,
PriceAmount = 99.99m,
PriceCurrencyCode = "USD"
};
var productId = await TestFramework.SendAsync(command);
var createdProduct = await TestFramework.Data.FindAsync <Product>(productId);
createdProduct.Should().NotBeNull();
createdProduct.Id.Should().Be(productId);
createdProduct.NumberInStock.Should().Be(0);
createdProduct.Name.Should().Be(command.Name);
createdProduct.Description.Should().Be(command.Description);
createdProduct.Mass.Value.Should().Be(command.MassValue);
createdProduct.Mass.Unit.Symbol.Should().Be(command.MassUnitSymbol);
createdProduct.Price.Amount.Should().Be(command.PriceAmount);
createdProduct.Price.Currency.Code.Should().Be(command.PriceCurrencyCode);
}
public async Task WhenDtoIsValid_ShouldUpdatePartner()
{
var partner = (await TestFramework.DataFactory.AddPartners(1)).First();
var command = new UpdatePartnerCommand()
{
Id = partner.Id,
Name = "New PartnerName",
Address = new AddressDto()
{
City = "Berlin",
Country = "Germany",
Street = "Varnhagenstraße 18-44",
ZipCode = "10439"
}
};
await TestFramework.SendAsync(command);
var updatedPartner = await TestFramework.Data.FindAsync <Partner>(command.Id);
updatedPartner.Should().NotBeNull();
updatedPartner.Id.Should().Be(command.Id);
updatedPartner.Name.Should().Be(command.Name);
updatedPartner.Address.Should().NotBeNull()
.And.Subject.Should().BeEquivalentTo(command.Address, o => o.ComparingByMembers <AddressDto>());
}
public async Task ProcurementRequest_ShouldCreateTransaction()
{
var partner = (await TestFramework.DataFactory.AddPartners(1)).First();
var products = await TestFramework.DataFactory.AddProducts(3);
var command = new CreateTransactionCommand()
{
PartnerId = partner.Id,
TransactionType = Domain.TransactionType.Procurement,
TransactionLines = products.Select(p => new CreateTransactionCommand.TransactionLine()
{
ProductId = p.Id,
ProductQuantity = 5
}).ToArray()
};
// Act.
var result = await TestFramework.SendAsync(command);
var transaction = await TestFramework.Data.FindAsync <Transaction>(result, x => x.TransactionLines, x => x.Partner);
transaction.Should().NotBeNull();
transaction.Partner.Id.Should().Be(partner.Id);
transaction.Total.Amount.Should().Be(transaction.TransactionLines.Sum(x => x.UnitPrice.Amount * x.Quantity));
transaction.TransactionLines.Should().HaveSameCount(products)
.And.Subject.Select(x => new { x.ProductId, ProductQuantity = x.Quantity })
.Should().BeEquivalentTo(command.TransactionLines,
o => o.ComparingByMembers <CreateTransactionCommand.TransactionLine>());
var newProducts = await TestFramework.Data.GetAllAsync <Product>();
newProducts.Select(x => new { id = x.Id, qty = x.NumberInStock })
.Should().BeEquivalentTo(command.TransactionLines
.Select(x => new { id = x.ProductId, qty = x.ProductQuantity }));
}
public async Task WhenEmpty_ShouldReturnEmptyList()
{
var list = await TestFramework.SendAsync(new GetTransactionListQuery());
list.Should().NotBeNull();
list.RowCount.Should().Be(0);
list.Results.Should().BeEmpty();
}
public async Task WhenEmpty_ShouldReturnEmptyList()
{
var list = await TestFramework.SendAsync(new ListQueryModel <PartnerDto>());
list.Should().NotBeNull();
list.RowCount.Should().Be(0);
list.Results.Should().BeEmpty();
}
public void WhenIdIsInvalid_ShouldThrow_EntityNotFoundException()
{
var command = new DeleteProductCommand()
{
Id = 1234567
};
FluentActions.Invoking(() => TestFramework.SendAsync(command))
.Should().Throw <EntityNotFoundException>();
}
public async Task ShouldReturnStockCount()
{
var products = await TestFramework.DataFactory.AddProducts(21);
var result = await TestFramework.SendAsync(new ProductStockCountQuery());
result.Should().NotBeNull();
result.ProductCount.Should().Be(products.Count);
result.TotalStock.Should().Be(products.Sum(x => x.NumberInStock));
}
public void WhenIdIsInvalid_ShouldThrow_EntityNotFoundException()
{
var command = new GetTransactionDetailsQuery()
{
Id = 1234567
};
FluentActions.Invoking(() => TestFramework.SendAsync(command))
.Should().ThrowExactly <EntityNotFoundException>();
}
public void WhenPartnerDoesntExist_ShouldThrow_EntityNotFoundException()
{
var query = new GetPartnerDetailsQuery()
{
Id = 45938
};
FluentActions.Invoking(() => TestFramework.SendAsync(query))
.Should().Throw <EntityNotFoundException>();
}
public void WhenIdIsInvalid_ShouldThrow_EntityNotFoundException()
{
var request = new GetProductDetailsQuery()
{
Id = 12345
};
FluentActions.Invoking(() => TestFramework.SendAsync(request))
.Should().ThrowExactly <EntityNotFoundException>();
}
public async Task ShouldReturnStockCount()
{
var products = await TestFramework.DataFactory.AddProducts(25);
var result = await TestFramework.SendAsync(new ProductStockValueQuery());
result.Should().NotBeNull();
result.Amount.Should().Be(products
.Sum(x => x.Price.Amount * x.NumberInStock));
result.CurrencyCode.Should().Be(products.GroupBy(x =>
x.Price.Currency.Code).Single().Key);
}
public async Task WhenPartnersExist_ShouldReturnPagedResults()
{
await TestFramework.DataFactory.AddPartners(31);
// Act.
var list = await TestFramework.SendAsync(new ListQueryModel <PartnerDto>());
list.RowCount.Should().Be(31);
list.PageIndex.Should().Be(1);
list.Results.Should().NotBeNull()
.And.HaveCount(list.PageSize)
.And.NotContainNulls()
.And.OnlyHaveUniqueItems();
}
public async Task ShouldReturnStockCount()
{
var products = await TestFramework.DataFactory.AddProducts(23);
var result = await TestFramework.SendAsync(new ProductStockMassQuery());
result.Should().NotBeNull();
result.Unit.Should().NotBeNull();
result.Value.Should().Be(
new Mass(
value: products.Sum(x => x.Mass.Value * x.NumberInStock),
unit: MassUnit.FromSymbol(products.GroupBy(x => x.Mass.Unit.Symbol).Single().Key)
).ConvertTo(
MassUnit.FromSymbol(result.Unit))
.Value
);
}
public async Task WhenAllProductsRequested_ShouldReturnPagedProducts()
{
await TestFramework.DataFactory.AddProducts(31);
// Act.
var list = await TestFramework.SendAsync(new GetProductsListQuery()
{
Status = GetProductsListQuery.ProductStatus.Default
});
list.RowCount.Should().Be(31);
list.PageIndex.Should().Be(1);
list.Results.Should().NotBeNull()
.And.HaveCount(list.PageSize)
.And.NotContainNulls()
.And.OnlyHaveUniqueItems();
}
public async Task WhenAllTransactionsRequested_ShouldReturnPagedTransactions()
{
var numberOfTransactions = 25;
var partner = (await TestFramework.DataFactory.AddPartners(1)).First();
for (int i = 0; i < numberOfTransactions; i++)
{
await TestFramework.DataFactory.CreateProcurementTransaction(1, partner);
}
var list = await TestFramework.SendAsync(new GetTransactionListQuery());
list.Should().NotBeNull();
list.RowCount.Should().Be(numberOfTransactions);
list.PageIndex.Should().Be(1);
list.Results.Should().HaveCount(list.PageSize)
.And.OnlyHaveUniqueItems();
}
public async Task WhenPartnerExist_ShouldReturnDetails()
{
var partner = (await TestFramework.DataFactory.AddPartners(1)).First();
// Act.
var result = await TestFramework.SendAsync(new GetPartnerDetailsQuery()
{
Id = partner.Id
});
result.Should().NotBeNull();
result.Id.Should().Be(partner.Id);
result.Name.Should().Be(partner.Name);
result.Address.Should().NotBeNull();
result.Address.Should().BeEquivalentTo(partner.Address,
o => o.ComparingByMembers <Address>());
}
public async Task WhenStockedProductsRequested_ShouldReturnOnlyStocked()
{
await TestFramework.DataFactory.AddProducts(31);
await TestFramework.DataFactory.CreateProcurementTransaction(6,
createNewProducts : false);
// Act.
var list = await TestFramework.SendAsync(new GetProductsListQuery()
{
Status = GetProductsListQuery.ProductStatus.Stocked
});
list.RowCount.Should().Be(6);
list.Results.Should().NotBeNull()
.And.HaveCount(6)
.And.OnlyHaveUniqueItems()
.And.OnlyContain(x => x.NumberInStock > 0);
}
public async Task WhenIdIsValid_ShouldReturnProductDetails()
{
var existingProduct = (await TestFramework.DataFactory.AddProducts(1)).First();
var request = new GetProductDetailsQuery()
{
Id = existingProduct.Id
};
var result = await TestFramework.SendAsync(request);
result.Should().NotBeNull();
result.Id.Should().Be(existingProduct.Id);
result.Name.Should().Be(existingProduct.Name);
result.NumberInStock.Should().Be(existingProduct.NumberInStock);
result.Description.Should().Be(existingProduct.Description);
result.MassValue.Should().Be(existingProduct.Mass.Value);
result.MassUnitSymbol.Should().Be(existingProduct.Mass.Unit.Symbol);
result.PriceAmount.Should().Be(existingProduct.Price.Amount);
result.PriceCurrencyCode.Should().Be(existingProduct.Price.Currency.Code);
}
public async Task SalesRequest_WithoutStock_ShouldThrowException()
{
var partner = (await TestFramework.DataFactory.AddPartners(1)).First();
var products = await TestFramework.DataFactory.AddProducts(2);
var command = new CreateTransactionCommand()
{
TransactionType = Domain.TransactionType.Sales,
PartnerId = partner.Id,
TransactionLines = products.Select(p => new CreateTransactionCommand.TransactionLine()
{
ProductId = p.Id,
ProductQuantity = 5
}).ToArray()
};
FluentActions.Invoking(() => TestFramework.SendAsync(command))
.Should().ThrowExactly <InputValidationException>()
.And.Errors.SelectMany(e => e.Value).Should().ContainMatch("*stock*");
}
public async Task WhenIdIsValid_ShouldDeleteProduct()
{
var createdProducts = await TestFramework.DataFactory.AddProducts(2);
// Act.
await TestFramework.SendAsync(new DeleteProductCommand()
{
Id = createdProducts[0].Id
});
var deletedProduct = await TestFramework.Data.FindAsync <Product>(createdProducts[0].Id);
var anotherProduct = await TestFramework.Data.FindAsync <Product>(createdProducts[1].Id);
var allProducts = await TestFramework.Data.GetAllAsync <Product>();
deletedProduct.Should().BeNull();
anotherProduct.Should().NotBeNull();
allProducts.Should().ContainSingle()
.And.HaveElementAt(0, anotherProduct);
}
public async Task SalesRequest_ShouldCreateTransaction()
{
CreateTransactionCommand.TransactionLine[] lines;
Partner partner;
{ // Create procurement transaction to prepare product stock for sales.
var t = await TestFramework.DataFactory.CreateProcurementTransaction(3);
lines = t.TransactionLines.Select(x => new CreateTransactionCommand.TransactionLine()
{
ProductId = x.Product.Id,
ProductQuantity = x.Quantity
}).ToArray();
partner = t.Partner;
}
var command = new CreateTransactionCommand()
{
TransactionType = Domain.TransactionType.Sales,
PartnerId = partner.Id,
TransactionLines = lines
};
// Act.
var result = await TestFramework.SendAsync(command);
var transaction = await TestFramework.Data.FindAsync <Transaction>(result, x => x.TransactionLines, x => x.Partner);
transaction.Should().NotBeNull();
transaction.Partner.Id.Should().Be(partner.Id);
transaction.Total.Amount.Should().Be(transaction.TransactionLines.Sum(x => x.UnitPrice.Amount * x.Quantity));
transaction.TransactionLines.Should().HaveSameCount(lines)
.And.Subject.Select(x => new { x.ProductId, ProductQuantity = x.Quantity })
.Should().BeEquivalentTo(command.TransactionLines,
o => o.ComparingByMembers <CreateTransactionCommand.TransactionLine>());
var products = await TestFramework.Data.GetAllAsync <Product>();
products.Should().Match(x => x.All(p => p.NumberInStock == 0)); // Because we sold the exact amount we procured.
}
public async Task WhenDtoIsValid_ShouldUpdateProduct()
{
var product = (await TestFramework.DataFactory.AddProducts(1)).First();
var command = new UpdateProductCommand()
{
Id = product.Id,
Name = "NewProductName",
Description = "NewProductDescription",
MassValue = 1111.1f,
PriceAmount = 9999.99m,
};
await TestFramework.SendAsync(command);
var updatedProduct = await TestFramework.Data.FindAsync <Product>(command.Id);
updatedProduct.Should().NotBeNull();
updatedProduct.Id.Should().Be(command.Id);
updatedProduct.Name.Should().Be(command.Name);
updatedProduct.Description.Should().Be(command.Description);
updatedProduct.Mass.Value.Should().Be(command.MassValue);
updatedProduct.Price.Amount.Should().Be(command.PriceAmount);
}
public void WhenDtoIsBlank_ShouldThrow_InputValidationException()
{
FluentActions.Invoking(() => TestFramework.SendAsync(new UpdateProductCommand()))
.Should().ThrowExactly <InputValidationException>();
}
