public async Task CreateProductForSupplier()
{
await using var context = DatabaseHelper.CreateInMemoryDatabaseContext(nameof(CreateProductForSupplier));
var res = await context.AddAsync(ValidModelCreator.Supplier());
var supplierId = res.Entity.Id;
var createProductForSupplierCommand = new CreateProductForSupplierCommand
{
Label = "Product 123",
Price = 12.5m,
SupplierId = supplierId
};
var createProductForSupplierHandler = new CreateProductForSupplierCommandHandler(context);
var response1 =
await createProductForSupplierHandler.Handle(createProductForSupplierCommand, CancellationToken.None);
Assert.True(response1.Success);
var productId = response1.Data;
var queryOne = new GetProductForSupplierByIdQuery
{
SupplierId = supplierId, ProductId = productId
};
var queryOneHandler = new GetProductForSupplierByIdQueryHandler(context);
var queryOneResponse = await queryOneHandler.Handle(queryOne, CancellationToken.None);
Assert.True(queryOneResponse.Success);
Assert.Equal(productId, queryOneResponse.Data.Id);
Assert.Equal(createProductForSupplierCommand.Label, queryOneResponse.Data.Label);
Assert.Equal(createProductForSupplierCommand.Price, queryOneResponse.Data.Price);
Assert.Equal(createProductForSupplierCommand.SupplierId, queryOneResponse.Data.SupplierId);
var queryAll = new GetAllProductsForSupplierQuery {
SupplierId = supplierId
};
var queryAllHandler = new GetAllProductsForSupplierQueryHandler(context);
var queryAllResponse = await queryAllHandler.Handle(queryAll, CancellationToken.None);
Assert.True(queryAllResponse.Success);
var relevantProduct = queryAllResponse.Data.SingleOrDefault(p => p.Id == productId);
Assert.NotNull(relevantProduct);
Assert.Equal(productId, relevantProduct.Id);
Assert.Equal(createProductForSupplierCommand.Label, relevantProduct.Label);
Assert.Equal(createProductForSupplierCommand.Price, relevantProduct.Price);
Assert.Equal(createProductForSupplierCommand.SupplierId, relevantProduct.SupplierId);
}
public async Task DeleteProductForSupplier()
{
var context = DatabaseHelper.CreateInMemoryDatabaseContext(nameof(DeleteProductForSupplier));
var supplierResp = await context.AddAsync(ValidModelCreator.Supplier());
var supplierId = supplierResp.Entity.Id;
var productId1 = (await context.AddAsync(ValidModelCreator.Product(supplierId))).Entity.Id;
var productId2 = (await context.AddAsync(ValidModelCreator.Product(supplierId))).Entity.Id;
var productId3 = (await context.AddAsync(ValidModelCreator.Product(supplierId))).Entity.Id;
var deleteProduct2Cmd = new DeleteProductForSupplierCommand
{
ProductId = productId2, SupplierId = supplierId
};
var deleteProductHandler = new DeleteProductForSupplierCommandHandler(context);
var result = await deleteProductHandler.Handle(deleteProduct2Cmd, CancellationToken.None);
Assert.True(result.Success);
var queryProduct2 = new GetProductForSupplierByIdQuery {
ProductId = productId2, SupplierId = supplierId
};
var queryOneHandler = new GetProductForSupplierByIdQueryHandler(context);
var queryProduct2Result = await queryOneHandler.Handle(queryProduct2, CancellationToken.None);
Assert.False(queryProduct2Result.Success);
var queryProduct1 = new GetProductForSupplierByIdQuery {
ProductId = productId1, SupplierId = supplierId
};
var queryProduct3 = new GetProductForSupplierByIdQuery {
ProductId = productId3, SupplierId = supplierId
};
var queryProduct1Result = await queryOneHandler.Handle(queryProduct1, CancellationToken.None);
Assert.True(queryProduct1Result.Success);
var queryProduct3Result = await queryOneHandler.Handle(queryProduct3, CancellationToken.None);
Assert.True(queryProduct3Result.Success);
var result2 = await deleteProductHandler.Handle(deleteProduct2Cmd, CancellationToken.None);
Assert.False(result2.Success);
}
public async Task DeleteSupplier()
{
await using var context = DatabaseHelper.CreateInMemoryDatabaseContext(nameof(DeleteSupplier));
var supplierId1Task = context.AddAsync(ValidModelCreator.Supplier());
var supplierId2Task = context.AddAsync(ValidModelCreator.Supplier());
var supplierId3Task = context.AddAsync(ValidModelCreator.Supplier());
var supplier1Id = (await supplierId1Task).Entity.Id;
var supplier2Id = (await supplierId2Task).Entity.Id;
var supplier3Id = (await supplierId3Task).Entity.Id;
var deleteSupplier2Cmd = new DeleteSupplierCommand
{
Id = supplier2Id,
};
var deleteHandler = new DeleteSupplierCommandHandler(context);
var deleteResult1 = await deleteHandler.Handle(deleteSupplier2Cmd, CancellationToken.None);
Assert.True(deleteResult1.Success);
var querySupplier2 = new GetSupplierByIdQuery {
Id = supplier2Id
};
var queryOneHandler = new GetSupplierByIdQueryHandler(context);
var querySupplier2Res = await queryOneHandler.Handle(querySupplier2, CancellationToken.None);
Assert.False(querySupplier2Res.Success);
var deleteResult2 = await deleteHandler.Handle(deleteSupplier2Cmd, CancellationToken.None);
Assert.False(deleteResult2.Success);
var querySupplier1 = new GetSupplierByIdQuery {
Id = supplier1Id
};
var query1Result = await queryOneHandler.Handle(querySupplier1, CancellationToken.None);
Assert.True(query1Result.Success);
var querySupplier3 = new GetSupplierByIdQuery {
Id = supplier3Id
};
var query3Result = await queryOneHandler.Handle(querySupplier3, CancellationToken.None);
Assert.True(query3Result.Success);
}
public async Task TestUpdateSupplierSuccess()
{
await using var context = DatabaseHelper.CreateInMemoryDatabaseContext(nameof(TestUpdateSupplierSuccess));
var addedSupplier = await context.Suppliers.AddAsync(ValidModelCreator.Supplier());
var supplier1Id = addedSupplier.Entity.Id;
var updateCmd1 = new UpdateSupplierCommand
{
Id = supplier1Id,
Name = "something",
Email = "*****@*****.**",
Phone = null,
};
var updateHandler = new UpdateSupplierCommandHandler(context);
var queryOneHandler = new GetSupplierByIdQueryHandler(context);
var response1 = await updateHandler.Handle(updateCmd1, CancellationToken.None);
Assert.True(response1.Success);
var updatedSupplier =
(await queryOneHandler.Handle(new GetSupplierByIdQuery {
Id = updateCmd1.Id
}, CancellationToken.None))
.Data;
Assert.Equal(updateCmd1.Name, updatedSupplier.Name);
Assert.Equal(updateCmd1.Email, updatedSupplier.Email);
Assert.Equal(updateCmd1.Phone, updatedSupplier.Phone);
var updateCmd2 = new UpdateSupplierCommand
{
Id = supplier1Id,
Name = "something new",
Email = "*****@*****.**",
Phone = "+41 79 456 45 45",
};
var response2 = await updateHandler.Handle(updateCmd2, CancellationToken.None);
Assert.True(response2.Success);
var updatedAgain =
(await queryOneHandler.Handle(new GetSupplierByIdQuery {
Id = updateCmd1.Id
}, CancellationToken.None))
.Data;
Assert.Equal(updateCmd2.Name, updatedAgain.Name);
Assert.Equal(updateCmd2.Email, updatedAgain.Email);
Assert.Equal(updateCmd2.Phone, updatedAgain.Phone);
var updateNonExistingSupplierCommand = new UpdateSupplierCommand
{
Id = supplier1Id + 1,
Name = "something",
Email = "*****@*****.**",
Phone = "+41 79 456 45 45",
};
var response3 = await updateHandler.Handle(updateNonExistingSupplierCommand, CancellationToken.None);
Assert.False(response3.Success);
}
public async Task UpdateProductForSupplier()
{
await using var context = DatabaseHelper.CreateInMemoryDatabaseContext(nameof(UpdateProductForSupplier));
var supplierRes = await context.AddAsync(ValidModelCreator.Supplier());
var supplierId = supplierRes.Entity.Id;
var productRes = await context.AddAsync(ValidModelCreator.Product(supplierId));
var productId = productRes.Entity.Id;
//test update
var updateProductCmd1 = new UpdateProductForSupplierCommand
{
SupplierId = supplierId,
ProductId = productId,
Label = "Something new",
Price = 55.5m,
};
var updateProductForSupplierCommandHandler = new UpdateProductForSupplierCommandHandler(context);
var response1 =
await updateProductForSupplierCommandHandler.Handle(updateProductCmd1, CancellationToken.None);
Assert.True(response1.Success);
var getUpdatedProductQuery1 = new GetProductForSupplierByIdQuery
{
SupplierId = supplierId,
ProductId = productId,
};
var queryOneHandler = new GetProductForSupplierByIdQueryHandler(context);
var queryResp1 =
await queryOneHandler.Handle(getUpdatedProductQuery1,
CancellationToken.None);
Assert.True(queryResp1.Success);
Assert.Equal(supplierId, queryResp1.Data.SupplierId);
Assert.Equal(productId, queryResp1.Data.Id);
Assert.Equal("Something new", queryResp1.Data.Label);
Assert.Equal(55.5m, queryResp1.Data.Price);
// test another update
var updateProductCmd2 = new UpdateProductForSupplierCommand
{
SupplierId = supplierId,
ProductId = productId,
Label = "another thing",
Price = 66.45798m,
};
var response2 =
await updateProductForSupplierCommandHandler.Handle(updateProductCmd2, CancellationToken.None);
Assert.True(response2.Success);
var queryResp2 =
await queryOneHandler.Handle(
new GetProductForSupplierByIdQuery { SupplierId = supplierId, ProductId = productId },
CancellationToken.None);
Assert.Equal(supplierId, queryResp2.Data.SupplierId);
Assert.Equal(productId, queryResp2.Data.Id);
Assert.Equal("another thing", queryResp2.Data.Label);
Assert.Equal(66.45798m, queryResp2.Data.Price);
// test no update if invalid data provided
var reqInvalidSupplier = new UpdateProductForSupplierCommand
{
SupplierId = supplierId + 1,
ProductId = productId,
Price = 50.0m,
Label = "should not be changed",
};
var response3 =
await updateProductForSupplierCommandHandler.Handle(reqInvalidSupplier, CancellationToken.None);
Assert.False(response3.Success);
var queryResponse3 = await queryOneHandler.Handle(
new GetProductForSupplierByIdQuery { SupplierId = supplierId, ProductId = productId, },
CancellationToken.None);
Assert.True(queryResponse3.Success);
Assert.Equal(supplierId, queryResponse3.Data.SupplierId);
Assert.Equal(productId, queryResponse3.Data.Id);
Assert.Equal("another thing", queryResponse3.Data.Label);
Assert.Equal(66.45798m, queryResponse3.Data.Price);
}
