public async Task CreateProductAsync_UniqueCode_ProductWithSpecifiedCodeCreated()
{
const string newCode = "cc";
var newProduct = new UpdateProductRequest()
{
Code = newCode
};
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <CatalogueProduct> productList = new List <CatalogueProduct>()
{
new CatalogueProduct()
{
Id = 1, Code = "aa"
},
new CatalogueProduct()
{
Id = 2, Code = "bb"
}
};
mockUserContext.Setup(c => c.UserId).Returns(1);
mockProductContext.Setup(c => c.Products).ReturnsEntitySet(productList);
var service = new ProductCatalogueService(mockProductContext.Object, mockUserContext.Object);
var product = await service.CreateProductAsync(newProduct);
Assert.Equal(newCode, product.Code);
}
public async Task GetProductAsync_IdPresent_RequestedProductReturned()
{
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <CatalogueProduct> productList = new List <CatalogueProduct>()
{
new CatalogueProduct()
{
Id = 1, CategoryId = 1
},
new CatalogueProduct()
{
Id = 2, CategoryId = 2
}
};
List <DbCategory> categoryList = new List <DbCategory>()
{
new DbCategory()
{
Id = 1
},
new DbCategory()
{
Id = 2
}
};
mockProductContext.Setup(c => c.Products).ReturnsEntitySet(productList);
mockProductContext.Setup(c => c.Categories).ReturnsEntitySet(categoryList);
var service = new ProductCatalogueService(mockProductContext.Object, mockUserContext.Object);
var product = await service.GetProductAsync(1);
Assert.Equal(1, product.Id);
}
public async Task GetCategoryProductsAsync_ProductCategoryId_ListProductCategoryProductListItems(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
// arrange
var dbCategorys = fixture.CreateMany <DbProductCategory>(1).ToList();
var productCategoryId = dbCategorys[0].Id;
var dbProducts = fixture.CreateMany <DbProduct>(5).OrderBy(s => s.Id).ToList();
dbProducts[1].CategoryId = productCategoryId;
dbProducts[3].CategoryId = productCategoryId;
dbProducts[4].CategoryId = productCategoryId;
context.Setup(s => s.Categories).ReturnsEntitySet(dbCategorys);
context.Setup(s => s.Products).ReturnsEntitySet(dbProducts);
// act
var productCategoryProductListItems = await service.GetCategoryProductsAsync(productCategoryId);
// assert
Assert.Equal(3, productCategoryProductListItems.Count);
}
public async Task UpdateProductAsync_IdNotPresent_RequestedResourceNotFoundExceptionThrown()
{
var newProduct = new UpdateProductRequest()
{
Code = "bb"
};
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <CatalogueProduct> productList = new List <CatalogueProduct>()
{
new CatalogueProduct()
{
Id = 1, Code = "aa"
},
new CatalogueProduct()
{
Id = 2, Code = "bb"
}
};
mockProductContext.Setup(c => c.Products).ReturnsEntitySet(productList);
var service = new ProductCatalogueService(mockProductContext.Object, mockUserContext.Object);
Assert.ThrowsAsync <RequestedResourceNotFoundException>(() => service.UpdateProductAsync(3, newProduct));
}
public async Task UpdateProductAsync_ValidRequest_ProductUpdated()
{
var newProduct = new UpdateProductRequest()
{
Code = "cc"
};
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <CatalogueProduct> productList = new List <CatalogueProduct>()
{
new CatalogueProduct()
{
Id = 1, Code = "aa"
},
new CatalogueProduct()
{
Id = 2, Code = "bb"
}
};
mockUserContext.Setup(c => c.UserId).Returns(1);
mockProductContext.Setup(c => c.Products).ReturnsEntitySet(productList);
var service = new ProductCatalogueService(mockProductContext.Object, mockUserContext.Object);
var updatedProduct = await service.UpdateProductAsync(1, newProduct);
Assert.Equal(newProduct.Code, updatedProduct.Code);
}
public async Task SetStatusAsync_SetProductStatus(int productId, bool productStatusBefor, bool productStatusAfter)
{
// arrange
var dbProduct = new DbProduct();
dbProduct.Id = productId;
dbProduct.IsDeleted = productStatusBefor;
Assert.Equal(productStatusBefor, dbProduct.IsDeleted);
var dbProducts = new[] { dbProduct };
var context = new Mock <IProductCatalogueContext>();
context.Setup(s => s.Products).ReturnsEntitySet(dbProducts);
var userContext = new Mock <IUserContext>();
userContext.Setup(s => s.UserId).Returns(1);
var service = new ProductCatalogueService(context.Object, userContext.Object);
// act
await service.SetStatusAsync(productId, productStatusAfter);
// assert
Assert.Equal(productStatusAfter, dbProduct.IsDeleted);
}
public async Task DeleteProductAsync_IdPresent_RequestedProductDeleted()
{
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <CatalogueProduct> productList = new List <CatalogueProduct>()
{
new CatalogueProduct()
{
Id = 1, IsDeleted = true
},
new CatalogueProduct()
{
Id = 2
}
};
mockProductContext.Setup(c => c.Products).ReturnsEntitySet(productList);
var service = new ProductCatalogueService(mockProductContext.Object, mockUserContext.Object);
await service.DeleteProductAsync(1);
var products = await service.GetProductsAsync(0, productList.Count);
Assert.DoesNotContain(products, h => h.Id == 1);
}
public async Task SetStatusAsync_IdPresent_RequestedProductStatusChanged()
{
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <CatalogueProduct> productList = new List <CatalogueProduct>()
{
new CatalogueProduct()
{
Id = 1, IsDeleted = true
},
new CatalogueProduct()
{
Id = 2
}
};
mockUserContext.Setup(c => c.UserId).Returns(1);
mockProductContext.Setup(c => c.Products).ReturnsEntitySet(productList);
var service = new ProductCatalogueService(mockProductContext.Object, mockUserContext.Object);
await service.SetStatusAsync(1, false);
var product = await service.GetProductAsync(1);
Assert.False(product.IsDeleted);
}
public async Task UpdateProductAsync_UpdateProductRequest_Product(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
// arrange
var updateRequest = fixture.Create <UpdateProductRequest>();
var dbProducts = fixture.CreateMany <DbProduct>(2).ToList();
var productId = 1;
dbProducts[0].Id = productId + 1;
dbProducts[0].Code = $"{updateRequest.Code}1";
dbProducts[1].Id = productId;
dbProducts[1].Code = updateRequest.Code;
context.Setup(s => s.Products).ReturnsEntitySet(dbProducts);
// act
var updateProduct = await service.UpdateProductAsync(productId, updateRequest);
// assert
Assert.Equal(updateRequest.Code, updateProduct.Code);
Assert.Equal(updateRequest.Name, updateProduct.Name);
}
public async Task GetCategoryProductsAsync_IdPresent_ReturnsAppropriateProducts()
{
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <CatalogueProduct> productList = new List <CatalogueProduct>()
{
new CatalogueProduct()
{
Id = 1, CategoryId = 1
},
new CatalogueProduct()
{
Id = 2, CategoryId = 2
}
};
List <DbCategory> categoryList = new List <DbCategory>()
{
new DbCategory()
{
Id = 1
},
new DbCategory()
{
Id = 2
}
};
mockProductContext.Setup(c => c.Products).ReturnsEntitySet(productList);
mockProductContext.Setup(c => c.Categories).ReturnsEntitySet(categoryList);
var service = new ProductCatalogueService(mockProductContext.Object, mockUserContext.Object);
var list = await service.GetCategoryProductsAsync(1);
Assert.Single(list);
}
public async Task GetCategoryProductsAsync_IdNotPresent_RequestedResourceNotFoundExceptionThrown()
{
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <CatalogueProduct> productList = new List <CatalogueProduct>()
{
new CatalogueProduct()
{
Id = 1, CategoryId = 1
},
new CatalogueProduct()
{
Id = 2, CategoryId = 2
}
};
List <DbCategory> categoryList = new List <DbCategory>()
{
new DbCategory()
{
Id = 1
},
new DbCategory()
{
Id = 2
}
};
mockProductContext.Setup(c => c.Products).ReturnsEntitySet(productList);
mockProductContext.Setup(c => c.Categories).ReturnsEntitySet(categoryList);
var service = new ProductCatalogueService(mockProductContext.Object, mockUserContext.Object);
Assert.ThrowsAsync <RequestedResourceNotFoundException>(() => service.GetCategoryProductsAsync(0));
}
public async Task GetProductAsync_ById_ReturnOneElement(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
var products = fixture.CreateMany <CatalogueProduct>(5).ToList();
context.Setup(x => x.Products).ReturnsEntitySet(products);
var result = await service.GetProductAsync(products[0].Id);
result.Id.Should().Be(products[0].Id);
}
public async Task GetProductAsync_ById_RequestedResourceNotFoundException(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
var products = fixture.CreateMany <CatalogueProduct>(5).ToList();
context.Setup(x => x.Products).ReturnsEntitySet(products);
Func <Task> act = async() => await service.GetProductAsync(0);
act.Should().Throw <RequestedResourceNotFoundException>();
}
public async Task GetProductsAsync_EmptyCollectionRequested_ReturnsEmptyCollection()
{
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
mockProductContext.Setup(c => c.Products).ReturnsEntitySet(new List <CatalogueProduct>());
var service = new ProductCatalogueService(mockProductContext.Object, mockUserContext.Object);
var list = await service.GetProductsAsync(0, 0);
Assert.Empty(list);
}
public async Task ProductUpdateAsync_UpdateOneItem_ReturnOneItem(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
var products = fixture.CreateMany <CatalogueProduct>(5).ToList();
var updateProduct = fixture.Create <UpdateProductRequest>();
context.Setup(x => x.Products).ReturnsEntitySet(products);
var result = await service.UpdateProductAsync(products[0].Id, updateProduct);
result.Code.Should().Be(service.GetProductAsync(products[0].Id).Result.Code);
}
public async Task SetStatusProductAsync_SetDeleteStatus(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
var products = fixture.CreateMany <CatalogueProduct>(5).ToList();
context.Setup(x => x.Products).ReturnsEntitySet(products);
await service.SetStatusAsync(products[0].Id, true);
Func <Task> act = async() => await service.DeleteProductAsync(products[0].Id);
act.Should().NotThrow();
}
public async Task GetProductsAsync_ReturnTwoElement(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
var start = 1;
var amount = 2;
var products = fixture.CreateMany <CatalogueProduct>(5).ToList();
context.Setup(x => x.Products).ReturnsEntitySet(products);
var result = await service.GetProductsAsync(1, 2);
result.Count.Should().Be(2);
}
public async Task ProductUpdateAsync_RequestedResourceHasConflictException(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
var products = fixture.CreateMany <CatalogueProduct>(5).ToList();
var updateProduct = fixture.Create <UpdateProductRequest>();
updateProduct.Code = products[1].Code;
context.Setup(x => x.Products).ReturnsEntitySet(products);
Func <Task> act = async() => await service.UpdateProductAsync(products[0].Id, updateProduct);
act.Should().Throw <RequestedResourceHasConflictException>();
}
public async Task DeleteProductAsync_RequestedResourceHasConflictException(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
var products = fixture.CreateMany <CatalogueProduct>(5).ToList();
products[0].IsDeleted = false;
context.Setup(x => x.Products).ReturnsEntitySet(products);
Func <Task> act = async() => await service.DeleteProductAsync(products[0].Id);
act.Should().Throw <RequestedResourceHasConflictException>();
}
public async Task GetCategoryProductsAsync_ProductCategoryId_RequestedResourceNotFoundException(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
// arrange
var dbCategorys = fixture.CreateMany <DbProductCategory>(1).ToList();
var productCategoryId = dbCategorys[0].Id + 1;
context.Setup(s => s.Categories).ReturnsEntitySet(dbCategorys);
// assert
await Assert.ThrowsAsync <RequestedResourceNotFoundException>(() => service.GetCategoryProductsAsync(productCategoryId));
}
public async Task ProductCreateAsync_AddOneElement_ColectionCountSix(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
var products = fixture.CreateMany <CatalogueProduct>(5).ToList();
var product = fixture.Create <UpdateProductRequest>();
context.Setup(x => x.Products).ReturnsEntitySet(products);
await service.CreateProductAsync(product);
var result = await service.GetProductsAsync(0, 8);
result.Count.Should().Be(6);
}
public async Task CreateProductAsync_UpdateProductRequest_RequestedResourceHasConflictException(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
// arrange
var dbProducts = fixture.CreateMany <DbProduct>(3).ToList();
var updateRequest = fixture.Create <UpdateProductRequest>();
updateRequest.Code = dbProducts[1].Code;
context.Setup(s => s.Products).ReturnsEntitySet(dbProducts);
// assert
await Assert.ThrowsAsync <RequestedResourceHasConflictException>(() => service.CreateProductAsync(updateRequest));
}
public async Task GetProductAsync_ProductId_Product(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
// arrange
var dbProducts = fixture.CreateMany <DbProduct>(5).ToList();
var productId = dbProducts[2].Id;
context.Setup(s => s.Products).ReturnsEntitySet(dbProducts);
// act
var product = await service.GetProductAsync(productId);
// assert
Assert.Equal(dbProducts[2].Code, product.Code);
}
public async Task GetProductsAsync_IntStartAndAmount_ListProductListItems(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
// arrange
var dbProducts = fixture.CreateMany <DbProduct>(6).OrderBy(s => s.Id).ToList();
int start = 0, amount = 6;
context.Setup(s => s.Products).ReturnsEntitySet(dbProducts);
// act
var productListItems = await service.GetProductsAsync(start, amount);
// assert
Assert.Equal(6, productListItems.Count);
}
public async Task DeleteProductAsync_DeleteOneElement(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
var products = fixture.CreateMany <CatalogueProduct>(5).ToList();
products[0].IsDeleted = true;
var id = products[0].Id;
context.Setup(x => x.Products).ReturnsEntitySet(products);
await service.DeleteProductAsync(id);
Func <Task> act = async() => await service.GetProductAsync(id);
act.Should().Throw <RequestedResourceNotFoundException>();
}
public async Task DeleteProductAsync_ProductId_RequestedResourceHasConflictException(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
// arrange
var productId = 1;
var dbProducts = fixture.CreateMany <DbProduct>(3).ToList();
dbProducts[0].Id = productId + 1;
dbProducts[1].Id = productId;
dbProducts[1].IsDeleted = false;
dbProducts[2].Id = productId + 1;
context.Setup(s => s.Products).ReturnsEntitySet(dbProducts);
// assert
await Assert.ThrowsAsync <RequestedResourceHasConflictException>(() => service.DeleteProductAsync(productId));
}
public async Task SetStatusAsync_IdNotPresent_RequestedResourceNotFoundExceptionThrown()
{
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <CatalogueProduct> productList = new List <CatalogueProduct>()
{
new CatalogueProduct()
{
Id = 1
},
new CatalogueProduct()
{
Id = 2
}
};
mockProductContext.Setup(c => c.Products).ReturnsEntitySet(productList);
var service = new ProductCatalogueService(mockProductContext.Object, mockUserContext.Object);
Assert.ThrowsAsync <RequestedResourceNotFoundException>(() => service.SetStatusAsync(3, false));
}
public async Task DeleteProductAsync_StatusIsNotDeleted_RequestedResourceHasConflictThrown()
{
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <CatalogueProduct> productList = new List <CatalogueProduct>()
{
new CatalogueProduct()
{
Id = 1, IsDeleted = false
},
new CatalogueProduct()
{
Id = 2
}
};
mockProductContext.Setup(c => c.Products).ReturnsEntitySet(productList);
var service = new ProductCatalogueService(mockProductContext.Object, mockUserContext.Object);
Assert.ThrowsAsync <RequestedResourceHasConflictException>(() => service.DeleteProductAsync(1));
}
public async Task UpdateProductAsync_UpdateProductRequest_RequestedResourceNotFoundException(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCatalogueService service,
IFixture fixture)
{
// arrange
var updateRequest = fixture.Create <UpdateProductRequest>();
var dbProducts = fixture.CreateMany <DbProduct>(2).ToList();
var productId = 1;
dbProducts[0].Id = productId + 1;
dbProducts[0].Code = $"{updateRequest.Code}1";
dbProducts[1].Id = productId + 1;
dbProducts[1].Code = $"{updateRequest.Code}1";
context.Setup(s => s.Products).ReturnsEntitySet(dbProducts);
// assert
await Assert.ThrowsAsync <RequestedResourceNotFoundException>(() => service.UpdateProductAsync(productId, updateRequest));
}
public async Task GetProductsAsync_TwoElementsRequested_ReturnsCollectionWithTwoElements()
{
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <CatalogueProduct> productList = new List <CatalogueProduct>()
{
new CatalogueProduct()
{
Id = 1
},
new CatalogueProduct()
{
Id = 2
}
};
mockProductContext.Setup(c => c.Products).ReturnsEntitySet(productList);
var service = new ProductCatalogueService(mockProductContext.Object, mockUserContext.Object);
var list = await service.GetProductsAsync(0, 2);
Assert.Equal(2, list.Count);
}
