public void Search_User_Name_Via_Edges()
        {
            var query = new Query()
                        .Search("foo", SearchType.User, 30)
                        .Edges.Select(x => x.Node)
                        .Select(x => x.User.Name);

            Expression <Func <JObject, IEnumerable <string> > > expected = data =>
                                                                           (IEnumerable <string>)
                                                                           Rewritten.List.Select(
                Rewritten.List.Select(data["data"]["search"]["edges"], x => x["node"]),
                x => Rewritten.Value.OfType(x, "User")["name"].ToObject <string>()).ToList();

            ExpressionRewriterAssertions.AssertExpressionQueryEqual(expected, query);
        }
        public void Search_User_Name_Via_Edges()
        {
            var query = new Query()
                        .Search("foo", SearchType.User, 30)
                        .Edges.Select(x => x.Node)
                        .Select(x => x.Switch <string>(when =>
                                                       when.User(user => user.Name)));

            Expression <Func <JObject, IEnumerable <string> > > expected = data =>
                                                                           (IEnumerable <string>)Rewritten.List.Select(
                Rewritten.List.Select(data["data"]["search"]["edges"], x => x["node"]),
                x => Rewritten.Value.Switch(x, new Dictionary <string, Func <JToken, string> >
            {
                { "User", user => user["name"].ToObject <string>() },
            })).ToList();

            ExpressionRewriterAssertions.AssertExpressionQueryEqual(expected, query);
        }
        public void Repository_Details_With_Viewer()
        {
            var query = new Query()
                        .Select(x => x.RepositoryOwner("foo")
                                .Repositories(30, null, null, null, null, null, null, null, null, null)
                                .Edges
                                .Select(y => y.Node)
                                .Select(z => new
            {
                z.Name,
                z.IsPrivate,
                Viewer = x.Viewer.Select(a => new
                {
                    a.Login
                }).Single()
            }));

            Expression <Func <JObject, IEnumerable <object> > > expected = data =>
                                                                           (IEnumerable <object>)Rewritten.Value.SelectList(
                data["data"],
                x =>
                Rewritten.List.Select(
                    Rewritten.List.Select(
                        x["repositoryOwner"]["repositories"]["edges"],
                        y => y["node"]),
                    z => new
            {
                Name      = z["name"].ToObject <string>(),
                IsPrivate = z["isPrivate"].ToObject <bool>(),
                Viewer    = Rewritten.Value.Single(
                    Rewritten.Value.Select(
                        x["viewer"],
                        a => new
                {
                    Login = a["login"].ToObject <string>()
                }))
            })).ToList();

            ExpressionRewriterAssertions.AssertExpressionQueryEqual(expected, query);
        }
        public void RepositoryOwner_Repositories_Query()
        {
            var query = new Query()
                        .RepositoryOwner(login: "******")
                        .Repositories(first: 30)
                        .Edges
                        .Select(x => x.Node)
                        .Select(x => new
            {
                Id = x.Id.ToString(),
                x.Name,
                Owner = x.Owner.Select(o => new
                {
                    o.Login
                }).Single(),
                x.IsFork,
                x.IsPrivate,
            });

            Expression <Func <JObject, IEnumerable <object> > > expected = data =>
                                                                           (IEnumerable <object>)Rewritten.List.Select(
                Rewritten.List.Select(
                    data["data"]["repositoryOwner"]["repositories"]["edges"],
                    x => x["node"]),
                x => new
            {
                Id    = x["id"].ToString(),
                Name  = x["name"].ToObject <string>(),
                Owner = Rewritten.Value.Single(
                    Rewritten.Value.Select(
                        x["owner"],
                        o => new { Login = o["login"].ToObject <string>() })),
                IsFork    = x["isFork"].ToObject <bool>(),
                IsPrivate = x["isPrivate"].ToObject <bool>(),
            }).ToList();

            ExpressionRewriterAssertions.AssertExpressionQueryEqual(expected, query);
        }