Beispiel #1
0
        public void SetRequestAdvancedString_Introspection_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(EchoStateSchema));

            var query = @"{
                __type(name:""Input_SetRequestAdvancedString""){
                        name
                        inputFields{
                            name
                            type{
                                kind
                                ofType{
                                    kind
                                }
                            }
                        }
                    }
                }
            ";

            var expected =
                @"{""__type"":{""name"":""Input_SetRequestAdvancedString"",""inputFields"":[{""name"":""nonRequiredBool"",""type"":{""kind"":""SCALAR"",""ofType"":null}},{""name"":""nonRequiredObject"",""type"":{""kind"":""INPUT_OBJECT"",""ofType"":null}},{""name"":""notRequiredString"",""type"":{""kind"":""SCALAR"",""ofType"":null}},{""name"":""nullRequiredDateTime"",""type"":{""kind"":""SCALAR"",""ofType"":null}},{""name"":""requiredObject"",""type"":{""kind"":""INPUT_OBJECT"",""ofType"":null}},{""name"":""requiredObjects"",""type"":{""kind"":""LIST"",""ofType"":{""kind"":""INPUT_OBJECT""}}},{""name"":""requiredString"",""type"":{""kind"":""SCALAR"",""ofType"":null}}]}}";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #2
0
        public void BasicClassInputExample_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(GenericsSchema));

            var query = @"
                {
                    echoClassGenerics{
                        list{innerInt}
                    }
                    echoClassGenerics2{
                        list{inner2Int}
                    }
                }
            ";

            var expected = @"{
              echoClassGenerics: {
                list: [{innerInt:1}]
              },
             echoClassGenerics2: {
                list: [{inner2Int:2}]
              }
            }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #3
0
        public void BasicExample_WithEnums_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(StarWarsAttributeSchema));

            var query = @"
                query HeroNameQuery {
                  hero {
                    appearsIn
                    friends
                  }
                }
            ";

            var expected = @"{
              hero: {
                appearsIn: [
                  ""NEWHOPE"",
                  ""EMPIRE"",
                  ""JEDI""
                ],
                friends: [""1"",""4""]
                }
            }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #4
0
        public void BasicExample_WithQueryAndMutation_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(EchoStateSchema));

            var query = @"
                mutation SetState{
                    setState (request:Open){
                        state
                    }
                }
                query GetState{
                    getState{
                        state
                    }
                }
            ";

            var expected = @"{
              SetState:{setState: {
                state: ""Open""
              }},
             GetState:{getState: {
                state: ""Open""
              }
            }}";

            GraphAssert.QueryOperationsSuccess(schema, query, expected);
        }
Beispiel #5
0
        public void SetAdvanced_WithNullableParam_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(EchoStateSchema));

            var query = @"
                mutation SetState($dec:Decimal!, $int:Int!, $int2:Int!, $date1:Date!, $str:String){
                    set:setAdvanced(request:{decimal:$dec, data:$int, nonRequiredInt:$int2, nullRequiredDateTime:$date1, notRequiredString:$str}){
                        decimal
                        data
                        state
                    }
                }
            ";

            var expected = @"{
              set: {
                decimal:24.15,
                data: 3,
                state: ""Open""
              }
            }";

            GraphAssert.QuerySuccess(schema, query, expected, "{dec:24.15, int:2, int2:1, date1:\"1-1-2011\"}");
        }
Beispiel #6
0
        public void GetTimeSpanAsVariable_IsSafe()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(DateSchema));

            var query = @"
                query($ts:TimeSpan!)
                {
                    dates(dates:{timeSpan:$ts}) {
                        timeSpan
                    }
                }                
            ";

            var variables = @"{
                ts:""1.23:59:59""
            }";

            var expected = @"{
              dates: {
                timeSpan:""1.23:59:59""
              }
            }";

            GraphAssert.QuerySuccess(schema, query, expected, variables);
        }
Beispiel #7
0
        public void Schema_HasUniqueTypes()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(GenericsSchema));

            var query = @"
                {
                    __schema{
                        queryType {
                          name,
                          fields{
                            name
                            type{
                              name
                              kind
                            }
                          }
                        }
                      }
                }
            ";

            var expected = @"{
              __schema: {
                queryType: {
                            name: ""RootQueries"",
                  fields: [
                    {
                      name: ""echoGenerics"",
                      type: {
                        name: ""EchoGeneric__String"",
                        kind: ""OBJECT""
                      }
            },
                    {
                      name: ""echoClassGenerics"",
                      type: {
                        name: ""EchoGenericList__Inner"",
                        kind: ""OBJECT""
                      }
                    },
                    {
                      name: ""echoClassGenerics2"",
                      type: {
                        name: ""EchoGenericList__Inner2"",
                        kind: ""OBJECT""
                      }
                    }
                  ]
                }
              }
            }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #8
0
        public void AdvancedExample_Introspection_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(EchoStateSchema));

            var query = @"{
                __type(name:""Input_SetRequest""){
                        name
                        inputFields{
                            name
                            type{
                                kind
                                ofType{
                                    kind
                                }
                            }
                        }
                    }
                }
            ";

            var expected = @"{
              __type: {
                name: ""Input_SetRequest"",
                inputFields: [
                  {
                    name: ""data"",
                    type: {
                    kind: ""NON_NULL"",
                    ofType: {
                        kind: ""SCALAR""
                      }
                    }
                  },
                    {
                        name: ""decimal"",
                        type: {
                                kind: ""SCALAR"",
                          ofType: null
                        }
                    },
                  {
                    name: ""state"",
                    type: {
                      kind: ""ENUM"",
                      ofType: null
                    }
                  }
                ]
              }
            }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #9
0
        //todo:
        //[Fact]
        public void BasicInterfaceExample_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(EchoSchema));

            var query = @"{
                  testInterface{value}
                }";

            var expected = @"{
              testInterface: {value:8}
                }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #10
0
        public void PrimitiveString_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(PrimitiveSchema));

            var query = @"
               {
                    testString (){}
                }
            ";

            var expected = @"{testString:""Hi""}";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #11
0
        public void WithDateTimeOffset_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(EchoSchema));

            var query = @"{
                  testRequest {date{{year}}
                }";

            var expected = @"{
              testRequest: {date:{year:1999}}
                }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
        public void WithDictionaryParameterExample_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(DictionarySchema));

            var query = @"{
                  dictionaryRequest(request:{dictionary:[{key:""name"", value:""bob""}]}) {key,value}
                }";

            var expected = @"{
              dictionaryRequest: [{""key"":""name"",""value"":""bob""}]
                }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
        public void WithEnumerableExample_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(AsyncSchema));

            var query = @"{
                  testEnumerable{value}
                }";

            var expected = @"{
                  testEnumerable: [{value: 1},{value: 5}]
                }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
        public void WithStringParameterExample_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(AsyncSchema));

            var query = @"{
                  testRequest(request:{data:""yes""}) {stringValue}
                }";

            var expected = @"{
              testRequest: {stringValue:""yes""}
                }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #15
0
        public void PrimitiveExample_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(PrimitiveSchema));

            var query = @"
                mutation Test{
                    testRequest (clear:true)
                }
            ";

            var expected = @"{testRequest:null}";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
        public void BasicParameterExample_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(AsyncSchema));

            var query = @"{
                  testRequest {value}
                }";

            var expected = @"{
              testRequest: {value:5}
                }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
        public void WithEnumerableParameterExample_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(AsyncSchema));

            var query = @"{
                  testEnumerableRequest(request:[{echo:1}]) {value}
                }";

            var expected = @"{
              testEnumerableRequest: {value:1}
                }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
        public void WithNull_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(AsyncSchema));

            var query = @"{
                  testRequest {nullValue}
                }";

            var expected = @"{
              testRequest: {nullValue:null}
                }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
        public void WithDateTimeOffset_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(AsyncSchema));

            var query = @"{
                  testRequest {date}
                }";

            var expected = @"{
              testRequest: {date:""1999-01-01T00:00:00-07:00""}
                }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
        public void WithEnum_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(AsyncSchema));

            var query = @"{
                  testRequest {enum}
                }";

            var expected = @"{
              testRequest: {enum:""NEWHOPE""}
                }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #21
0
        public void GetJoinedData_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(UserSchema));

            var query = @"{
                getProjects {
                    projectName,
                    users {
                        firstName
                    }
                }
            }";

            var expected = @"{
            getProjects:
            [
                {   
                    projectName: ""Alpha"",
                    users:
                    [
                        { firstName:""Tom""}
                    ]
                },
                {
                    projectName:""Betta"",
                    users:
                    [
                        {
                            firstName:""Alice""
                        }
                    ]
                },
                {
                  projectName:""Gamma"",
                  users:
                  [
                    {
                        firstName:""Sam""
                    }
                  ]
                 }
            ]
            }";


            GraphAssert.QuerySuccess(schema, query, expected);
        }
        public void WithDictionary_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(AsyncSchema));

            var query = @"{
                  testRequest {
                    values{
                        key
                        value{
                            complicatedResponse{
                                echo
                            }
                        }
                    }
                  }
                }";

            var expected = @"{
              testRequest: {
                values: [
                  {
                   key: ""99"",
                    value: {
                      complicatedResponse: {
                        echo: 99
                      }
            }
                  },
                  {
                    key: ""59"",
                    value: {
                      complicatedResponse: {
                        echo: 59
                      }
                    }
                  },
                  {
                    key: ""null"",
                    value: null
                  }
                ]
              }
            }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
        public void WithComplexParameters_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(AsyncSchema));

            var query = @"{
                  testRequest(request:{
                    complexRequests:[{
                            innerData:""345""
                        }]
                    }) {value}
                }";

            var expected = @"{
              testRequest: {value:5}
                }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #24
0
        public void GetOffset_IsSafe()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(DateSchema));

            var query = @"
                {dates(dates:{offset:""5/1/2012""}) {
                  offset
                }}
            ";

            var expected = @"{
              dates: {
                offset:""2012-05-01T06:00:00Z""
              }
            }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #25
0
        public void BasicExample_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(GenericsSchema));

            var query = @"
                {
                    echoGenerics{data}
                }
            ";

            var expected = @"{
              echoGenerics: {
                data: """"
              }
            }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #26
0
        public void GetTimeSpan_IsSafe()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(DateSchema));

            var query = @"
                {dates(dates:{timeSpan:""1.23:59:59""}) {
                    timeSpan
                }}
            ";

            var expected = @"{
              dates: {
                timeSpan:""1.23:59:59""
              }
            }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #27
0
        public void QueryProject_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(UserSchema));

            var query = @"{
                getUser {
                   firstName
                }
            }";

            var expected = @"{
                getUser:{
                                firstName: ""Hakob""
                        }
            }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
        public void WithComplexParameters_HaveCorrectType()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(AsyncSchema));

            var query = @"{
                  __type(name : ""Input_InnerRequest"") {
                    name
                    kind
                }}";

            var expected = @"{
              __type: {
                name: ""Input_InnerRequest"",
                kind: ""INPUT_OBJECT""
              }
            }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #29
0
        public void BasicExample_WithDecimal_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(EchoStateSchema));

            var query = @"
                mutation SetState{
                    set(request:{decimal:24.15, data:2}){
                        decimal
                    }
                }
            ";

            var expected = @"{
              set: {
                decimal: 24.15
              }
            }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }
Beispiel #30
0
        public void BasicExample_Works()
        {
            var schemaGenerator = new SchemaGenerator(new MockServiceProvider());
            var schema          = schemaGenerator.CreateSchema(typeof(EchoStateSchema));

            var query = @"
                mutation SetData{
                    setData (request:4){
                        data
                    }
                }
            ";

            var expected = @"{
              setData: {
                data: 4
              }
            }";

            GraphAssert.QuerySuccess(schema, query, expected);
        }