@@ -75,7 +75,12 @@ let schemaWithInterface =
7575 [ Define.Field (
7676 " pets" ,
7777 ListOf PetType,
78- fun _ _ -> [ { Name = " Odie" ; Woofs = true } :> IPet; upcast { Name = " Garfield" ; Meows = false } ]
78+ fun _ _ -> [ { Name = " Odie" ; Woofs = true } :> IPet; { Name = " Garfield" ; Meows = false } ]
79+ )
80+ Define.Field (
81+ " nullablePets" ,
82+ ListOf ( Nullable PetType),
83+ fun _ _ -> [ { Name = " Odie" ; Woofs = true } :> IPet |> Some; { Name = " Garfield" ; Meows = false } :> IPet |> Some ]
7984 ) ]
8085 ),
8186 config = { SchemaConfig.Default with Types = [ CatType; DogType ] }
@@ -111,6 +116,79 @@ let ``Execute handles execution of abstract types: isTypeOf is used to resolve r
111116 empty errors
112117 data |> equals ( upcast expected)
113118
119+ [<Fact( Skip = " Not implemented" ) >]
120+ let ``Execute handles execution of abstract types : not specified Interface types produce error`` () =
121+ let query =
122+ """ {
123+ pets {
124+ ... on Dog {
125+ name
126+ woofs
127+ }
128+ }
129+ }"""
130+
131+ let result = sync <| schemaWithInterface.Value.AsyncExecute ( parse query)
132+ ensureRequestError result <| fun [ petsError ] ->
133+ petsError |> ensureValidationError " Field 'pets' does not allow nulls and list values." [ " pets" ; " 0" ]
134+
135+ let query =
136+ """ {
137+ pets {
138+ ... on Cat {
139+ name
140+ meows
141+ }
142+ }
143+ }"""
144+
145+ let result = sync <| schemaWithInterface.Value.AsyncExecute ( parse query)
146+ ensureRequestError result <| fun [ petsError ] ->
147+ petsError |> ensureValidationError " Field 'pets' does not allow nulls and list values." [ " pets" ; " 0" ]
148+
149+ [<Fact>]
150+ let ``Execute handles execution of abstract types : not specified Interface types must be filtered out if they allow null`` () =
151+ let query =
152+ """ {
153+ nullablePets {
154+ ... on Dog {
155+ name
156+ woofs
157+ }
158+ }
159+ }"""
160+
161+ let result = sync <| schemaWithInterface.Value.AsyncExecute ( parse query)
162+
163+ let expected =
164+ NameValueLookup.ofList
165+ [ " nullablePets" , upcast [ NameValueLookup.ofList [ " name" , " Odie" :> obj; " woofs" , upcast true ] :> obj; null ] ]
166+
167+ ensureDirect result <| fun data errors ->
168+ empty errors
169+ data |> equals ( upcast expected)
170+
171+ let query =
172+ """ {
173+ nullablePets {
174+ ... on Cat {
175+ name
176+ meows
177+ }
178+ }
179+ }"""
180+
181+ let result = sync <| schemaWithInterface.Value.AsyncExecute ( parse query)
182+
183+ let expected =
184+ NameValueLookup.ofList
185+ [ " nullablePets" ,
186+ upcast [ null ; NameValueLookup.ofList [ " name" , " Garfield" :> obj; " meows" , upcast false ] :> obj ] ]
187+
188+ ensureDirect result <| fun data errors ->
189+ empty errors
190+ data |> equals ( upcast expected)
191+
114192[<Fact>]
115193let ``Execute handles execution of abstract types : absent field resolution produces errors for Interface`` () =
116194 let query =
@@ -155,6 +233,26 @@ let ``Execute handles execution of abstract types: absent type resolution produc
155233 catError |> ensureValidationError " Field 'unknownField2' is not defined in schema type 'Cat'." [ " pets" ; " unknownField2" ]
156234 dogError |> ensureValidationError " Inline fragment has type condition 'UnknownDog', but that type does not exist in the schema." [ " pets" ]
157235
236+ let query =
237+ """ {
238+ pets {
239+ name
240+ ... on Dog {
241+ woofs
242+ unknownField1
243+ }
244+ ... on UnknownCat {
245+ meows
246+ unknownField2
247+ }
248+ }
249+ }"""
250+
251+ let result = sync <| schemaWithInterface.Value.AsyncExecute ( parse query)
252+ ensureRequestError result <| fun [ catError ; dogError ] ->
253+ catError |> ensureValidationError " Field 'unknownField1' is not defined in schema type 'Dog'." [ " pets" ; " unknownField1" ]
254+ dogError |> ensureValidationError " Inline fragment has type condition 'UnknownCat', but that type does not exist in the schema." [ " pets" ]
255+
158256
159257let schemaWithUnion =
160258 lazy
@@ -184,6 +282,11 @@ let schemaWithUnion =
184282 " pets" ,
185283 ListOf PetType,
186284 fun _ _ -> [ DogCase { Name = " Odie" ; Woofs = true }; CatCase { Name = " Garfield" ; Meows = false } ]
285+ )
286+ Define.Field (
287+ " nullablePets" ,
288+ ListOf ( Nullable PetType),
289+ fun _ _ -> [ DogCase { Name = " Odie" ; Woofs = true } |> Some; CatCase { Name = " Garfield" ; Meows = false } |> Some ]
187290 ) ]
188291 )
189292 )
@@ -219,6 +322,79 @@ let ``Execute handles execution of abstract types: isTypeOf is used to resolve r
219322 empty errors
220323 data |> equals ( upcast expected)
221324
325+ [<Fact( Skip = " Not implemented" ) >]
326+ let ``Execute handles execution of abstract types : not specified Union types produce error`` () =
327+ let query =
328+ """ {
329+ pets {
330+ ... on Dog {
331+ name
332+ woofs
333+ }
334+ }
335+ }"""
336+
337+ let result = sync <| schemaWithUnion.Value.AsyncExecute ( parse query)
338+ ensureRequestError result <| fun [ petsError ] ->
339+ petsError |> ensureValidationError " Field 'pets' does not allow nulls and list values." [ " pets" ; " 0" ]
340+
341+ let query =
342+ """ {
343+ pets {
344+ ... on Cat {
345+ name
346+ meows
347+ }
348+ }
349+ }"""
350+
351+ let result = sync <| schemaWithUnion.Value.AsyncExecute ( parse query)
352+ ensureRequestError result <| fun [ petsError ] ->
353+ petsError |> ensureValidationError " Field 'pets' does not allow nulls and list values." [ " pets" ; " 0" ]
354+
355+ [<Fact>]
356+ let ``Execute handles execution of abstract types : not specified Union types must be filtered out`` () =
357+ let query =
358+ """ {
359+ nullablePets {
360+ ... on Dog {
361+ name
362+ woofs
363+ }
364+ }
365+ }"""
366+
367+ let result = sync <| schemaWithUnion.Value.AsyncExecute ( parse query)
368+
369+ let expected =
370+ NameValueLookup.ofList
371+ [ " nullablePets" , upcast [ NameValueLookup.ofList [ " name" , " Odie" :> obj; " woofs" , upcast true ] :> obj; null ] ]
372+
373+ ensureDirect result <| fun data errors ->
374+ empty errors
375+ data |> equals ( upcast expected)
376+
377+ let query =
378+ """ {
379+ nullablePets {
380+ ... on Cat {
381+ name
382+ meows
383+ }
384+ }
385+ }"""
386+
387+ let result = sync <| schemaWithUnion.Value.AsyncExecute ( parse query)
388+
389+ let expected =
390+ NameValueLookup.ofList
391+ [ " nullablePets" ,
392+ upcast [ null ; NameValueLookup.ofList [ " name" , " Garfield" :> obj; " meows" , upcast false ] :> obj ] ]
393+
394+ ensureDirect result <| fun data errors ->
395+ empty errors
396+ data |> equals ( upcast expected)
397+
222398[<Fact>]
223399let ``Execute handles execution of abstract types : absent field resolution produces errors for Union`` () =
224400 let query =
0 commit comments