public void Sort_ObjectMultiple_ShouldSortByStringAscThenByStringAsc()
        {
            // arrange
            var value = new ObjectValueNode(new ObjectFieldNode("foo",
                                                                new ObjectValueNode(
                                                                    new ObjectFieldNode("baz",
                                                                                        new EnumValueNode(SortOperationKind.Asc)
                                                                                        ),
                                                                    new ObjectFieldNode("bar",
                                                                                        new EnumValueNode(SortOperationKind.Asc)
                                                                                        ))));

            FooNestedSortType sortType = CreateType(new FooNestedSortType());

            IQueryable <FooNested> a = new[]
            {
                new FooNested {
                    Foo = new Foo {
                        Bar = "b", Baz = "b"
                    }
                },
                new FooNested {
                    Foo = new Foo {
                        Bar = "a", Baz = "b"
                    }
                },
                new FooNested {
                    Foo = new Foo {
                        Bar = "c", Baz = "a"
                    }
                }
            }.AsQueryable();

            // act
            var filter = new QueryableSortVisitor(
                sortType, typeof(FooNested));

            value.Accept(filter);
            ICollection <FooNested> aFiltered = filter.Sort(a).ToList();

            // assert
            Assert.Collection(aFiltered,
                              foo => Assert.Equal("c", foo.Foo.Bar),
                              foo => Assert.Equal("a", foo.Foo.Bar),
                              foo => Assert.Equal("b", foo.Foo.Bar)
                              );
        }
        public void Sort_ObjectMultiple_ShouldSortByStringAscThenByStringAsc()
        {
            // arrange
            var value = new ObjectValueNode(new ObjectFieldNode("foo",
                                                                new ObjectValueNode(
                                                                    new ObjectFieldNode("baz",
                                                                                        new EnumValueNode(SortOperationKind.Asc)),
                                                                    new ObjectFieldNode("bar",
                                                                                        new EnumValueNode(SortOperationKind.Asc)))));

            FooNestedSortType sortType = CreateType(new FooNestedSortType());

            IQueryable <FooNested> a = new[]
            {
                new FooNested {
                    Foo = new Foo {
                        Bar = "b", Baz = "b"
                    }
                },
                new FooNested {
                    Foo = new Foo {
                        Bar = "a", Baz = "b"
                    }
                },
                new FooNested {
                    Foo = new Foo {
                        Bar = "c", Baz = "a"
                    }
                }
            }.AsQueryable();

            // act
            var context = new QueryableSortVisitorContext(
                new(new DefaultTypeConverter()), sortType, typeof(FooNested), false);

            QueryableSortVisitor.Default.Visit(value, context);
            ICollection <FooNested> aFiltered = context.Sort(a).ToList();

            // assert
            Assert.Collection(aFiltered,
                              foo => Assert.Equal("c", foo.Foo.Bar),
                              foo => Assert.Equal("a", foo.Foo.Bar),
                              foo => Assert.Equal("b", foo.Foo.Bar)
                              );
        }