public void Parse_WhenNonMemberExpression_ThrowsSisoDbException()
        {
            var parser = new SortingParser();
            var nonMemberExpression = Reflect<MyClass>.BoolExpressionFrom(m => m.Int1 == 32);

            var ex = Assert.Throws<NCoreException>(() => parser.Parse(new []{nonMemberExpression}));

            Assert.AreEqual("No MemberExpression found in expression: '(m.Int1 == 32)'.", ex.Message);
        }
        public void Parse_WhenNonMemberExpression_ThrowsSisoDbException()
        {
            var parser = new SortingParser();
            var nonMemberExpression = Reflect <MyClass> .BoolExpressionFrom(m => m.Int1 == 32);

            var ex = Assert.Throws <NCoreException>(() => parser.Parse(new [] { nonMemberExpression }));

            Assert.AreEqual("No MemberExpression found in expression: '(m.Int1 == 32)'.", ex.Message);
        }
        public void Parse_WhenOnePropertyLambdaIsPassed_ExactlyOneSortingNodeIsReturned()
        {
            var lambda = Reflect <MyClass> .LambdaFrom(m => m.String1);

            var parsedLambda = new SortingParser()
                               .Parse(new[] { lambda });

            Assert.AreEqual(1, parsedLambda.Nodes.Count);
            Assert.IsInstanceOf(typeof(SortingNode), parsedLambda.Nodes[0]);
        }
        public void Parse_WhenOnePropertyLambdaIsPassed_ExactlyOneSortingNodeIsReturned()
        {
            var lambda = Reflect<MyClass>.LambdaFrom(m => m.String1);

            var parsedLambda = new SortingParser()
                .Parse(new[] { lambda });

            Assert.AreEqual(1, parsedLambda.Nodes.Count);
            Assert.IsInstanceOf(typeof(SortingNode), parsedLambda.Nodes[0]);
        }
        public void Parse_WhenFirstLevelLambda_MemberPathIsPropertyName()
        {
            var lambda = Reflect <MyClass> .LambdaFrom(m => m.String1);

            var parsedLambda = new SortingParser()
                               .Parse(new[] { lambda });

            var node = (SortingNode)parsedLambda.Nodes[0];

            Assert.AreEqual("String1", node.MemberPath);
        }
        public void Parse_WhenAscAndDescExtensionOnSameMember_SortingDirectionBecomesDesc()
        {
            var lambda = Reflect <MyClass> .LambdaFrom(m => m.String1.Asc().Desc());

            var parsedLambda = new SortingParser()
                               .Parse(new[] { lambda });

            var node = (SortingNode)parsedLambda.Nodes[0];

            Assert.AreEqual(SortDirections.Desc, node.Direction);
        }
        public void Parse_WhenNeitherAscNorDescExtension_SortingDirectionBecomesAsc()
        {
            var lambda = Reflect <MyClass> .LambdaFrom(m => m.String1);

            var parsedLambda = new SortingParser()
                               .Parse(new[] { lambda });

            var node = (SortingNode)parsedLambda.Nodes[0];

            Assert.AreEqual(SortDirections.Asc, node.Direction);
        }
        public void Parse_WhenAscExtensionOnNested_MemberPathReflectsHierarchy()
        {
            var lambda = Reflect <MyClass> .LambdaFrom(m => m.Child.String1.Asc());

            var parsedLambda = new SortingParser()
                               .Parse(new[] { lambda });

            var node = (SortingNode)parsedLambda.Nodes[0];

            Assert.AreEqual("Child.String1", node.MemberPath);
        }
        public void Parse_WhenTwoPropertyLambdasArePassed_ExactlyTwoSortingNodeIsReturned()
        {
            var lambda1 = Reflect<MyClass>.LambdaFrom(m => m.String1);
            var lambda2 = Reflect<MyClass>.LambdaFrom(m => m.Int1);

            var parsedLambda = new SortingParser()
                .Parse(new[] { lambda1, lambda2 });

            Assert.AreEqual(2, parsedLambda.Nodes.Count);
            Assert.IsInstanceOf(typeof(SortingNode), parsedLambda.Nodes[0]);
            Assert.IsInstanceOf(typeof(SortingNode), parsedLambda.Nodes[1]);
        }
        public void Parse_WhenTwoPropertyLambdasArePassed_ExactlyTwoSortingNodeIsReturned()
        {
            var lambda1 = Reflect <MyClass> .LambdaFrom(m => m.String1);

            var lambda2 = Reflect <MyClass> .LambdaFrom(m => m.Int1);

            var parsedLambda = new SortingParser()
                               .Parse(new[] { lambda1, lambda2 });

            Assert.AreEqual(2, parsedLambda.Nodes.Count);
            Assert.IsInstanceOf(typeof(SortingNode), parsedLambda.Nodes[0]);
            Assert.IsInstanceOf(typeof(SortingNode), parsedLambda.Nodes[1]);
        }
        public void Parse_WhenNestedLambda_MemberPathReflectsHierarchy()
        {
            var lambda = Reflect<MyClass>.LambdaFrom(m => m.Child.String1);

            var parsedLambda = new SortingParser()
                .Parse(new[] { lambda });

            var node = (SortingNode)parsedLambda.Nodes[0];
            Assert.AreEqual("Child.String1", node.MemberPath);
        }
        public void Parse_WhenFirstLevelLambda_MemberPathIsPropertyName()
        {
            var lambda = Reflect<MyClass>.LambdaFrom(m => m.String1);

            var parsedLambda = new SortingParser()
                .Parse(new[] { lambda });

            var node = (SortingNode)parsedLambda.Nodes[0];
            Assert.AreEqual("String1", node.MemberPath);
        }
        public void Parse_WhenAscAndDescExtensionOnSameMember_SortingDirectionBecomesDesc()
        {
            var lambda = Reflect<MyClass>.LambdaFrom(m => m.String1.Asc().Desc());

            var parsedLambda = new SortingParser()
                .Parse(new[] { lambda });

            var node = (SortingNode)parsedLambda.Nodes[0];
            Assert.AreEqual(SortDirections.Desc, node.Direction);
        }
        public void Parse_WhenNeitherAscNorDescExtension_SortingDirectionBecomesAsc()
        {
            var lambda = Reflect<MyClass>.LambdaFrom(m => m.String1);

            var parsedLambda = new SortingParser()
                .Parse(new[] { lambda });

            var node = (SortingNode)parsedLambda.Nodes[0];
            Assert.AreEqual(SortDirections.Asc, node.Direction);
        }