public void EmptyKvpList()
        {
            //arrange
            var list = new KeyValuePair <string, string> [0];

            //act
            var fop = new FilterOptionsParser().Parse(list);

            //assert
            fop.Should().HaveCount(0);
        }
Example #2
0
        public void BuildExpression_double(string filterstring, string expr)
        {
            //arrange
            var items     = filterstring.Split('&').Select(_ => { var t = _.Split('='); return(new KeyValuePair <string, string>(t[0], t[1])); });
            var filterOps = new FilterOptionsParser().Parse(items);

            //act
            var exp = new FilterExpressionBuilder().Build <TestObj>(filterOps);

            //assert
            exp.Item1.Should().Be(expr);
            exp.Item2.Count().Should().Be(2);
        }
        public void Parser_parts(string filterstring, string field, string op, string filterValue)
        {
            //arrange
            var parts     = filterstring.Split('=');
            var filterkvp = new KeyValuePair <string, string>(parts[0], parts[1]);
            var list      = new KeyValuePair <string, string>[] { filterkvp };

            //act
            var fop = new FilterOptionsParser().Parse(list).FirstOrDefault();

            //assert
            fop.Field.Should().Be(field);
            fop.Operator.ToString().Should().Be(op);
            fop.FilterValue.Should().Be(filterValue);
        }
Example #4
0
        public void BuildExpression_single(string filterstring, string expr)
        {
            //arrange
            var parts     = filterstring.Split('=');
            var filterkvp = new KeyValuePair <string, string>(parts[0], parts[1]);
            var filterOps = new FilterOptionsParser().Parse(new List <KeyValuePair <string, string> >()
            {
                filterkvp
            });

            //act
            var exp = new FilterExpressionBuilder().Build <TestObj>(filterOps);

            //assert
            exp.Item1.Should().Be(expr);
            exp.Item2.Count().Should().Be(1);
        }
Example #5
0
        public void DynamicExpressions_TypeConversions(string filterstring, bool shouldContain1111, bool shouldContain9911, string expectedIds)
        {
            //arrange
            var items     = filterstring.Split('&').Select(_ => { var t = _.Split('='); return(new KeyValuePair <string, string>(t[0], t[1])); });
            var filterOps = new FilterOptionsParser().Parse(items);

            var testObjList = CreateTestData();
            var byKeys      = testObjList.ToDictionary(_ => _.IdStr);

            //act
            var actual = QueryableExtensions.AddFilters(testObjList.AsQueryable(), filterOps)
                         .ToList();       //run the query

            //assert
            var expectedIdsList = expectedIds.Split(',');

            actual.Should().HaveCount(expectedIdsList.Count());

            if (shouldContain1111)
            {
                actual.Should().Contain(byKeys["1111"]);
            }
            else
            {
                actual.Should().NotContain(byKeys["1111"]);
            }

            if (shouldContain9911)
            {
                actual.Should().Contain(byKeys["9911"]);
            }
            else
            {
                actual.Should().NotContain(byKeys["9911"]);
            }

            //actual.Should().ContainInOrder(expectedIdsList.ToArray());
        }