Ejemplo n.º 1
0
        public async Task Test_Combine_With_Arguments()
        {
            // Arrange
            var expected =
                @"{""query"":""query{batch0_Part1Field1:part1_field1(argumentName:\""1\"") batch0_Part1Field2:part1Field2 batch1_Part2Field3:part2_field3(argumentName:\""2\"") batch1_Part2Field4:part2Field4}""}";
            var httpClientMock = new GraphQLHttpExecutorMock(
                JsonConvert.SerializeObject(new
            {
                Data = new
                {
                    batch0_Part1Field1 = "Value1",
                    batch0_Part1Field2 = "Value2",
                    batch1_Part2Field3 = "Value3",
                    batch1_Part2Field4 = "Value4"
                }
            }), expected);
            var client = new GraphQLHttpClient(httpClientMock, new GraphQLFieldBuilder(),
                                               new GraphQLQueryGeneratorFromFields(), new GraphQLDeserilization());

            // Act
            var batch  = client.CreateBatch("");
            var query1 =
                batch.Query <QueryBatchWithArgumentsPart1>(new GraphQLQueryArgument("argumentVariable", 1.ToString()));
            var query2 =
                batch.Query <QueryBatchWithArgumentsPart2>(new GraphQLQueryArgument("argumentVariable2", 2.ToString()));

            var result1 = await query1.Execute();

            var result2 = await query2.Execute();

            // Assert
            Assert.Equal(result1.Part1Field1, "Value1");
            Assert.Equal(result1.Part1Field2, "Value2");

            Assert.Equal(result2.Part2Field3, "Value3");
            Assert.Equal(result2.Part2Field4, "Value4");
        }
        public async Task Test_GraphQL_Builder_Get_Result()
        {
            var expected       = "{\"query\":\"query{alias1:field1 alias2:field2}\"}";
            var httpClientMock = new GraphQLHttpExecutorMock(
                JsonConvert.SerializeObject(new
            {
                Data = new
                {
                    alias1 = "Value1",
                    alias2 = "Value2"
                }
            }), expected);
            var client = new GraphQLHttpClient(httpClientMock, new GraphQLFieldBuilder(), new GraphQLQueryGeneratorFromFields(), new GraphQLDeserilization());

            // Act
            var query = client.CreateQuery(builder =>
                                           builder.Field("field1", field1 => field1.Alias("alias1"))
                                           .Field("field2", field2 => field2.Alias("alias2")), "randomurl");
            var result = await query.Execute();

            // Assert
            Assert.Equal("Value1", result["alias1"].Value);
            Assert.Equal("Value2", result["alias2"].Value);
        }
Ejemplo n.º 3
0
        public async Task Test_Client_Should_Deserialize_Errors()
        {
            // Arrange
            var expected =
                "{\"query\":\"query{field}\"}";
            var httpClientMock = new GraphQLHttpExecutorMock(
                JsonConvert.SerializeObject(new
            {
                Data = new
                {
                    Field = "FieldValue"
                },
                Errors = new[]
                {
                    new
                    {
                        message   = "This is not a valid query!",
                        locations = new []
                        {
                            new
                            {
                                line   = 1,
                                column = 0
                            },
                            new
                            {
                                line   = 1,
                                column = 1
                            }
                        }
                    },
                    new
                    {
                        message   = "And this is a second error message",
                        locations = new []
                        {
                            new
                            {
                                line   = 1,
                                column = 10
                            }
                        }
                    }
                }
            }), expected);
            var client = new GraphQLHttpClient(httpClientMock, new GraphQLFieldBuilder(),
                                               new GraphQLQueryGeneratorFromFields(), new GraphQLDeserilization());

            // Act
            var query = client.CreateQuery <Query>("url");

            // Assert
            var exception = await Assert.ThrowsAsync <GraphQLErrorException>(() => query.Execute());

            Assert.Equal(expected, exception.Query);
            Assert.Equal(2, exception.Errors.Count());

            // Validate error 1
            Assert.Equal("This is not a valid query!", exception.Errors.First().Message);
            Assert.Equal(true, exception.Errors.First().ContainLocations);
            Assert.Equal(2, exception.Errors.First().Locations.Count());
            Assert.Equal(1, exception.Errors.First().Locations.First().Line);
            Assert.Equal(0, exception.Errors.First().Locations.First().Column);
        }