Example #1
0
        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);
        }
Example #2
0
        public async void GetProductsAsync_TenEntities_SeccessfulResult([Frozen] Mock <IProductCatalogueContext> context, ProductCatalogueService service, IFixture fixture)
        {
            Configure(context, fixture);

            var result = await service.GetProductsAsync(0, _product.Count);

            result.Should().HaveCount(_product.Count);
        }
Example #3
0
        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 GetProducts_Test([Frozen] Mock <IProductCatalogueContext> context, IFixture fixture, ProductCatalogueService productCatalogueService)
        {
            int start      = 3;
            int amount     = 5;
            var listEntity = fixture.CreateMany <CatalogueProduct>(13).ToList();

            context.Setup(c => c.Products).ReturnsEntitySet(listEntity);

            var products = await productCatalogueService.GetProductsAsync(start, amount);

            Assert.Equal(amount, products.Count);
        }
        public async Task DeleteProduct_Successfuly_Test([Frozen] Mock <IProductCatalogueContext> context, IFixture fixture, ProductCatalogueService productCatalogueService)
        {
            var listEntity = fixture.CreateMany <CatalogueProduct>(13).ToList();

            context.Setup(x => x.Products).ReturnsEntitySet(listEntity);
            ;
            await productCatalogueService.SetStatusAsync(listEntity[0].Id, true);

            await productCatalogueService.DeleteProductAsync(listEntity[0].Id);

            var products = await productCatalogueService.GetProductsAsync(0, 12);

            Assert.Equal(12, products.Count);
        }
Example #6
0
        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);
        }
Example #7
0
        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);
        }
Example #8
0
        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);
        }
Example #9
0
        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);
        }