コード例 #1
0
        public IActionResult GetCategories(CategoriesParametersModel parameters)
        {
            if (parameters.Page < Configurations.DefaultPageValue)
            {
                return(Error(HttpStatusCode.BadRequest, "page", "Invalid page parameter"));
            }

            var allCategories = _categoryApiService.GetCategories(parameters.Ids, parameters.CreatedAtMin, parameters.CreatedAtMax,
                                                                  parameters.UpdatedAtMin, parameters.UpdatedAtMax,
                                                                  50000, parameters.Page, parameters.SinceId,
                                                                  parameters.ProductId, parameters.PublishedStatus)
                                .Where(c => StoreMappingService.Authorize(c));

            IList <CategoryDto> categoriesAsDtos = allCategories.Select(category =>
            {
                return(_dtoHelper.PrepareCategoryDTO(category));
            }).ToList();

            var categoriesRootObject = new CategoriesRootObject()
            {
                Categories = categoriesAsDtos
            };

            var json = JsonFieldsSerializer.Serialize(categoriesRootObject, parameters.Fields);

            return(new RawJsonActionResult(json));
        }
コード例 #2
0
        public void WhenCalledWithLimitParameter_GivenCategoriesAboveTheLimit_ShouldReturnCollectionWithCountEqualToTheLimit()
        {
            //Arange
            var expectedLimit = 5;

            //Act
            var categories = _categoryApiService.GetCategories(limit: expectedLimit);

            // Assert
            // Not Empty assert is a good practice when you assert something about collection. Because you can get a false positive if the collection is empty.
            CollectionAssert.IsNotEmpty(categories);
            Assert.AreEqual(expectedLimit, categories.Count);
        }
コード例 #3
0
        public void WhenAskForOnlyThePublishedCategories_ShouldReturnOnlyThePublishedOnesSortedById()
        {
            // Arange
            var expectedCollection = _existigCategories.Where(x => x.Published && !x.Deleted).OrderBy(x => x.Id);

            // Act
            var categories = _categoryApiService.GetCategories(publishedStatus: true);

            // Assert
            // Not Empty assert is a good practice when you assert something about collection. Because you can get a false positive if the collection is empty.
            CollectionAssert.IsNotEmpty(categories);
            Assert.IsTrue(categories.Select(x => x.Id).SequenceEqual(expectedCollection.Select(x => x.Id)));
        }
        public void WhenCalledWithValidSinceId_ShouldReturnOnlyTheCategoriesAfterThisIdSortedById()
        {
            // Arange
            int sinceId            = 3;
            var expectedCollection = _existigCategories.Where(x => x.Id > sinceId && !x.Deleted).OrderBy(x => x.Id);

            // Act
            var categories = _categoryApiService.GetCategories(sinceId: sinceId);

            // Assert
            // Not Empty assert is a good practice when you assert something about collection. Because you can get a false positive if the collection is empty.
            CollectionAssert.IsNotEmpty(categories);
            Assert.IsTrue(categories.Select(x => x.Id).SequenceEqual(expectedCollection.Select(x => x.Id)));
        }
コード例 #5
0
        public void WhenCalledWithIdsParameter_GivenCategoriesWithTheSpecifiedIds_ShouldReturnThemSortedById()
        {
            var idsCollection = new List <int>()
            {
                1, 5
            };

            var categories = _categoryApiService.GetCategories(ids: idsCollection);

            // Assert
            // Not Empty assert is a good practice when you assert something about collection. Because you can get a false positive if the collection is empty.
            CollectionAssert.IsNotEmpty(categories);
            Assert.AreEqual(idsCollection[0], categories[0].Id);
            Assert.AreEqual(idsCollection[1], categories[1].Id);
        }
コード例 #6
0
        public void Can_GetCategories()
        {
            var categories = _categoryApiService.GetCategories();

            // Assert
            Assert.AreEqual(3, categories.ToList().Count);
        }
        public void WhenCalledWithPageParameter_GivenLimitedCategoriesCollection_ShouldReturnThePartOfTheCollectionThatCorrespondsToThePage()
        {
            //Arange
            var limit = 5;
            var page  = 6;
            var expectedCollection = new ApiList <Category>(_existigCategories.Where(x => !x.Deleted).AsQueryable(), page - 1, limit);

            //Act
            var categories = _categoryApiService.GetCategories(limit: limit, page: page);

            // Assert
            // Not Empty assert is a good practice when you assert something about collection. Because you can get a false positive if the collection is empty.
            CollectionAssert.IsNotEmpty(categories);
            Assert.AreEqual(expectedCollection.Count(), categories.Count);
            Assert.IsTrue(categories.Select(x => x.Id).SequenceEqual(expectedCollection.Select(x => x.Id)));
        }
コード例 #8
0
        public async Task <IActionResult> GetCategories(CategoriesParametersModel parameters)
        {
            if (parameters.Limit < Constants.Configurations.MinLimit || parameters.Limit > Constants.Configurations.MaxLimit)
            {
                return(Error(HttpStatusCode.BadRequest, "limit", "Invalid limit parameter"));
            }

            if (parameters.Page < Constants.Configurations.DefaultPageValue)
            {
                return(Error(HttpStatusCode.BadRequest, "page", "Invalid page parameter"));
            }

            var allCategories = _categoryApiService.GetCategories(parameters.Ids, parameters.CreatedAtMin, parameters.CreatedAtMax,
                                                                  parameters.UpdatedAtMin, parameters.UpdatedAtMax,
                                                                  parameters.Limit, parameters.Page, parameters.SinceId,
                                                                  parameters.ProductId, parameters.PublishedStatus)
                                .WhereAwait(async c => await StoreMappingService.AuthorizeAsync(c));

            IList <CategoryDto> categoriesAsDtos = await allCategories.SelectAwait(async category => await _dtoHelper.PrepareCategoryDTOAsync(category)).ToListAsync();

            var categoriesRootObject = new CategoriesRootObject
            {
                Categories = categoriesAsDtos
            };

            var json = JsonFieldsSerializer.Serialize(categoriesRootObject, parameters.Fields);

            return(new RawJsonActionResult(json));
        }
コード例 #9
0
        public void WhenCalledWithUpdatedAtMinParameter_GivenSomeCategoriesUpdatedAfterThatDate_ShouldReturnThemSortedById()
        {
            // Arange
            DateTime updatedAtMinDate        = _baseDate.AddMonths(5);
            var      expectedCollection      = _existigCategories.Where(x => x.UpdatedOnUtc > updatedAtMinDate && !x.Deleted).OrderBy(x => x.Id);
            var      expectedCategoriesCount = expectedCollection.Count();

            // Act
            var categories = _categoryApiService.GetCategories(updatedAtMin: updatedAtMinDate);

            // Assert
            // Not Empty assert is a good practice when you assert something about collection. Because you can get a false positive if the collection is empty.
            CollectionAssert.IsNotEmpty(categories);
            Assert.AreEqual(expectedCategoriesCount, categories.Count);
            Assert.IsTrue(categories.Select(x => x.Id).SequenceEqual(expectedCollection.Select(x => x.Id)));
        }
コード例 #10
0
        public IHttpActionResult GetCategories(CategoriesParametersModel parameters)
        {
            if (parameters.Limit < Configurations.MinLimit || parameters.Limit > Configurations.MaxLimit)
            {
                return(Error(HttpStatusCode.BadRequest, "limit", "Invalid limit parameter"));
            }

            if (parameters.Page < Configurations.DefaultPageValue)
            {
                return(Error(HttpStatusCode.BadRequest, "page", "Invalid page parameter"));
            }

            IList <Category> allCategories = _categoryApiService.GetCategories(parameters.Ids, parameters.CreatedAtMin, parameters.CreatedAtMax,
                                                                               parameters.UpdatedAtMin, parameters.UpdatedAtMax,
                                                                               parameters.Limit, parameters.Page, parameters.SinceId,
                                                                               parameters.ProductId, parameters.PublishedStatus);

            IList <CategoryDto> categoriesAsDtos = allCategories.Select(category =>
            {
                CategoryDto categoryDto = category.ToDto();

                PrepareDtoAditionalProperties(category, categoryDto);

                return(categoryDto);
            }).ToList();

            var categoriesRootObject = new CategoriesRootObject()
            {
                Categories = categoriesAsDtos
            };

            var json = _jsonFieldsSerializer.Serialize(categoriesRootObject, parameters.Fields);

            return(new RawJsonActionResult(json));
        }
コード例 #11
0
        public void WhenCalledWithValidProductId_ShouldReturnOnlyTheCategoriesMappedToThisProduct()
        {
            // Arange
            int productId          = 3;
            var expectedCollection = (from cat in _existigCategories
                                      join mapping in _existingCategoryMappings on cat.Id equals mapping.CategoryId
                                      where mapping.ProductId == productId
                                      orderby cat.Id
                                      select cat);

            // Act
            var categories = _categoryApiService.GetCategories(productId: productId);

            // Assert
            // Not Empty assert is a good practice when you assert something about collection. Because you can get a false positive if the collection is empty.
            CollectionAssert.IsNotEmpty(categories);
            Assert.IsTrue(categories.Select(x => x.Id).SequenceEqual(expectedCollection.Select(x => x.Id)));
        }
コード例 #12
0
        public async Task <IActionResult> Get()
        {
            if (!await _permissionService.Authorize(PermissionSystemName.Categories))
            {
                return(Forbid());
            }

            return(Ok(_categoryApiService.GetCategories()));
        }