Beispiel #1
0
        public async void ShouldBeBindModelAsyncWithModelErrorTest()
        {
            var queryCollection = Helper.QueryCollection
                                  (
                "pageSize", "a",
                "pageNumber", "2",
                "sort", "name;desc,birthDate"
                                  );

            var context = new DefaultHttpContext();

            context.Request.Query = queryCollection;
            var actionContext = new ActionContext {
                HttpContext = context
            };
            var mock = new MockModelBindingContext
            {
                ActionContext = actionContext, ModelState = new ModelStateDictionary()
            };
            var pageableModelBinder = new RSqlPageableModelBinder <Customer>(Helper.Settings(), Helper.JsonOptions(), Helper.MockLogger <Customer>().Object);
            await pageableModelBinder.BindModelAsync(mock);

            var expected = mock.Result;

            expected.Model
            .Should().BeNull();

            mock.ModelState
            .IsValid.Should().BeFalse();
        }
Beispiel #2
0
        public void ShouldBeThrowArgumentNullException()
        {
            // constructor: settings is null
            this.Invoking((a) => _ = new RSqlPageableModelBinder <Customer>(null, Helper.JsonOptions(), Helper.MockLogger <Customer>().Object))
            .Should()
            .Throw <ArgumentNullException>();

            // constructor: option is null
            this.Invoking((a) => _ = new RSqlPageableModelBinder <Customer>(Helper.Settings(), null, Helper.MockLogger <Customer>().Object))
            .Should()
            .Throw <ArgumentNullException>();

            // constructor: logger is null
            this.Invoking((a) => _ = new RSqlPageableModelBinder <Customer>(Helper.Settings(), Helper.JsonOptions(), null))
            .Should()
            .Throw <ArgumentNullException>();

            // build
            this.Invoking((a) =>
            {
                var binder = new RSqlPageableModelBinder <Customer>(Helper.Settings(), Helper.JsonOptions(), Helper.MockLogger <Customer>().Object);
                binder.Build(null);
            })
            .Should()
            .Throw <ArgumentNullException>();
        }
        public void ShouldBeUnknownSortException()
        {
            var queryCollection = Helper.QueryCollection("sort", "a;t");
            var expected        = new RSqlPageableModelBinder <Customer>(Helper.Settings(), Helper.JsonOptions(), Helper.MockLogger <Customer>().Object);

            expected
            .Invoking(f => f.Build(queryCollection))
            .Should().Throw <UnknownSortException>();
        }
        public void ShouldBeOutOfRangePageNumberException()
        {
            var queryCollection = Helper.QueryCollection("pageNumber", "-1");
            var expected        = new RSqlPageableModelBinder <object>(Helper.Settings(), Helper.JsonOptions(), Helper.MockLogger <object>().Object);

            expected
            .Invoking(f => f.Build(queryCollection))
            .Should().Throw <OutOfRangePageNumberException>();
        }
        public void ShouldBeInvalidPageSizeValueException()
        {
            var queryCollection = Helper.QueryCollection("pageSize", "a");
            var expected        = new RSqlPageableModelBinder <object>(Helper.Settings(), Helper.JsonOptions(), Helper.MockLogger <object>().Object);

            expected
            .Invoking(f => f.Build(queryCollection))
            .Should().Throw <InvalidPageSizeValueException>();
        }
Beispiel #6
0
        public void ShouldBeInvalidSortDirectionException()
        {
            var queryCollection = Helper.QueryCollection("sort", "name;asc;sd");
            var expected        = new RSqlPageableModelBinder <object>(Helper.Settings(), Helper.JsonOptions(), Helper.MockLogger <object>().Object);

            expected
            .Invoking(i => i.Build(queryCollection))
            .Should().Throw <InvalidSortDirectionException>();
        }
Beispiel #7
0
        public void ShouldBeValidPageSize()
        {
            const int pageSize            = 10;
            var       queryCollection     = Helper.QueryCollection("pageSize", Convert.ToString(pageSize));
            var       pageableModelBinder = new RSqlPageableModelBinder <Customer>(Helper.Settings(), Helper.JsonOptions(), Helper.MockLogger <Customer>().Object);
            var       expected            = pageableModelBinder.Build(queryCollection);

            expected.PageSize()
            .Should().Be(pageSize);
        }
Beispiel #8
0
        public void ShouldBeIsValid()
        {
            var queryCollection = Helper.QueryCollection
                                  (
                "pageSize", "1",
                "pageNumber", "2",
                "sort", "name;desc,birthDate"
                                  );

            var pageableModelBinder = new RSqlPageableModelBinder <Customer>(Helper.Settings(), Helper.JsonOptions(), Helper.MockLogger <Customer>().Object);
            var expected            = pageableModelBinder.Build(queryCollection);

            // exp
            expected
            .PageNumber().Should().Be(2);
            expected
            .PageSize().Should().Be(1);

            // expected on sort order by ( first )
            expected.Sort()
            .Should().NotBeNull();

            // first sort
            expected.Sort().IsDescending
            .Should().BeTrue();

            ((MemberExpression)((UnaryExpression)expected.Sort().Value.Body).Operand).Member.Name
            .Should().Be("Name");

            // expected on sort order by ( second )
            expected.Sort().Next.Should()
            .NotBeNull();

            // second sort
            expected.Sort().Next.IsDescending
            .Should().BeFalse();

            ((MemberExpression)((UnaryExpression)expected.Sort().Next.Value.Body).Operand).Member.Name
            .Should().Be("BirthDate");
        }