public IHttpActionResult GetShoppingCartItems(ShoppingCartItemsParametersModel 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<ShoppingCartItem> shoppingCartItems = _shoppingCartItemApiService.GetShoppingCartItems(customerId: null,
                                                                                                         createdAtMin: parameters.CreatedAtMin,
                                                                                                         createdAtMax: parameters.CreatedAtMax, 
                                                                                                         updatedAtMin: parameters.UpdatedAtMin,
                                                                                                         updatedAtMax: parameters.UpdatedAtMax, 
                                                                                                         limit: parameters.Limit,
                                                                                                         page: parameters.Page);

            List<ShoppingCartItemDto> shoppingCartItemsDtos = shoppingCartItems.Select(x => x.ToDto()).ToList();

            var shoppingCartsRootObject = new ShoppingCartItemsRootObject()
            {
                ShoppingCartItems = shoppingCartItemsDtos
            };

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

            return new RawJsonActionResult(json);
        }
        public IActionResult GetShoppingCartItems(ShoppingCartItemsParametersModel 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"));
            }

            IList <ShoppingCartItem> shoppingCartItems = _shoppingCartItemApiService.GetShoppingCartItems(null,
                                                                                                          parameters.CreatedAtMin,
                                                                                                          parameters.CreatedAtMax,
                                                                                                          parameters.UpdatedAtMin,
                                                                                                          parameters.UpdatedAtMax,
                                                                                                          parameters.Limit,
                                                                                                          parameters.Page);

            var shoppingCartItemsDtos = shoppingCartItems.Select(shoppingCartItem => { return(_dtoHelper.PrepareShoppingCartItemDTO(shoppingCartItem)); }).ToList();

            var shoppingCartsRootObject = new ShoppingCartItemsRootObject
            {
                ShoppingCartItems = shoppingCartItemsDtos
            };

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

            return(new RawJsonActionResult(json));
        }
        public void WhenSomeValidParametersPassed_ShouldCallTheServiceWithTheSameParameters()
        {
            var parameters = new ShoppingCartItemsParametersModel();

            //Arange
            var autoMocker = new RhinoAutoMocker <ShoppingCartItemsController>();

            autoMocker.Get <IShoppingCartItemApiService>().Expect(x => x.GetShoppingCartItems(null, parameters.CreatedAtMin,
                                                                                              parameters.CreatedAtMax, parameters.UpdatedAtMin,
                                                                                              parameters.UpdatedAtMax, parameters.Limit,
                                                                                              parameters.Page)).Return(new List <ShoppingCartItem>());

            //Act
            autoMocker.ClassUnderTest.GetShoppingCartItems(parameters);

            //Assert
            autoMocker.Get <IShoppingCartItemApiService>().VerifyAllExpectations();
        }
        public void WhenNoShoppingCartItemsExist_ShouldCallTheSerializerWithNoShoppingCartItems()
        {
            var returnedShoppingCartItemsCollection = new List <ShoppingCartItem>();

            var parameters = new ShoppingCartItemsParametersModel();

            //Arange
            var autoMocker = new RhinoAutoMocker <ShoppingCartItemsController>();

            autoMocker.Get <IShoppingCartItemApiService>().Stub(x => x.GetShoppingCartItems()).Return(returnedShoppingCartItemsCollection).IgnoreArguments();

            //Act
            autoMocker.ClassUnderTest.GetShoppingCartItems(parameters);

            //Assert
            autoMocker.Get <IJsonFieldsSerializer>().AssertWasCalled(
                x => x.Serialize(Arg <ShoppingCartItemsRootObject> .Matches(r => r.ShoppingCartItems.Count == returnedShoppingCartItemsCollection.Count),
                                 Arg <string> .Is.Equal(parameters.Fields)));
        }
        public void WhenFieldsParametersPassed_ShouldCallTheSerializerWithTheSameFields()
        {
            var parameters = new ShoppingCartItemsParametersModel()
            {
                Fields = "id,quantity"
            };

            //Arange
            var autoMocker = new RhinoAutoMocker <ShoppingCartItemsController>();

            autoMocker.Get <IShoppingCartItemApiService>().Stub(x => x.GetShoppingCartItems()).Return(new List <ShoppingCartItem>()).IgnoreArguments();

            //Act
            autoMocker.ClassUnderTest.GetShoppingCartItems(parameters);

            //Assert
            autoMocker.Get <IJsonFieldsSerializer>().AssertWasCalled(
                x => x.Serialize(Arg <ShoppingCartItemsRootObject> .Is.Anything, Arg <string> .Is.Equal(parameters.Fields)));
        }
        public void WhenInvalidLimitParameterPassed_ShouldReturnBadRequest(int invalidLimit)
        {
            var parameters = new ShoppingCartItemsParametersModel()
            {
                Limit = invalidLimit
            };

            //Arange
            var autoMocker = new RhinoAutoMocker <ShoppingCartItemsController>();

            autoMocker.Get <IJsonFieldsSerializer>().Stub(x => x.Serialize(Arg <ShoppingCartItemsRootObject> .Is.Anything, Arg <string> .Is.Anything))
            .IgnoreArguments()
            .Return(string.Empty);
            //Act
            IActionResult result = autoMocker.ClassUnderTest.GetShoppingCartItems(parameters);

            //Assert
            var statusCode = ActionResultExecutor.ExecuteResult(result);

            Assert.AreEqual(HttpStatusCode.BadRequest, statusCode);
        }