MinaProtocol / mina / 538

Committed 25 Aug 2025 05:35PM UTC coverage: 61.202% (+0.4%) from 60.772%

Build # 538

Build Type

push

buildkite

Committed by

web-flow

Commit Message

Merge pull request #17673 from MinaProtocol/amcie-merge-release320-to-master

amcie-merge-release320-to-master

Coverage Stats

3142 of 4828 new or added lines in 308 files covered. (65.08%)

205 existing lines in 68 files now uncovered.

50733 of 82894 relevant lines covered (61.2%)

470098.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.43

/src/lib/graphql_wrapper/ocaml_graphql_server_tests/error_test.ml

open Graphql
module Schema = Graphql_wrapper.Make (Schema)
open Test_common

let nullable_error_test () =
  let schema =
    Schema.(
      schema
        [ io_field "nullable" ~typ:int
            ~args:Arg.[]
            ~resolve:(fun _ () -> Error "boom")
        ])
  in
  let query = "{ nullable }" in
  test_query schema () query
    (`Assoc
      [ ( "errors"
        , `List
            [ `Assoc
                [ ("message", `String "boom")
                ; ("path", `List [ `String "nullable" ])
                ]
            ] )
      ; ("data", `Assoc [ ("nullable", `Null) ])
      ] )

let non_nullable_error_test () =
  let schema =
    Schema.(
      schema
        [ io_field "non_nullable" ~typ:(non_null int)
            ~args:Arg.[]
            ~resolve:(fun _ () -> Error "boom")
        ])
  in
  let query = "{ non_nullable }" in
  test_query schema () query
    (`Assoc
      [ ( "errors"
        , `List
            [ `Assoc
                [ ("message", `String "boom")
                ; ("path", `List [ `String "non_nullable" ])
                ]
            ] )
      ; ("data", `Null)
      ] )

let nested_nullable_error_test () =
  let obj_with_non_nullable_field =
    Schema.(
      obj "obj" ~fields:(fun _ ->
          [ io_field "non_nullable" ~typ:(non_null int)
              ~args:Arg.[]
              ~resolve:(fun _ () -> Error "boom")
          ] ))
  in
  let schema =
    Schema.(
      schema
        [ field "nullable" ~typ:obj_with_non_nullable_field
            ~args:Arg.[]
            ~resolve:(fun _ () -> Some ())
        ])
  in
  let query = "{ nullable { non_nullable } }" in
  test_query schema () query
    (`Assoc
      [ ( "errors"
        , `List
            [ `Assoc
                [ ("message", `String "boom")
                ; ("path", `List [ `String "nullable"; `String "non_nullable" ])
                ]
            ] )
      ; ("data", `Assoc [ ("nullable", `Null) ])
      ] )

let error_in_list_test () =
  let foo =
    Schema.(
      obj "Foo" ~fields:(fun _ ->
          [ io_field "id" ~typ:int
              ~args:Arg.[]
              ~resolve:(fun _ (id, should_fail) ->
                if should_fail then Error "boom" else Ok (Some id) )
          ] ))
  in
  let schema =
    Schema.(
      schema
        [ field "foos"
            ~typ:(non_null (list (non_null foo)))
            ~args:Arg.[]
            ~resolve:(fun _ () -> [ (0, false); (1, false); (2, true) ])
        ])
  in
  let query = "{ foos { id } }" in
  test_query schema () query
    (`Assoc
      [ ( "errors"
        , `List
            [ `Assoc
                [ ("message", `String "boom")
                ; ("path", `List [ `String "foos"; `Int 2; `String "id" ])
                ]
            ] )
      ; ( "data"
        , `Assoc
            [ ( "foos"
              , `List
                  [ `Assoc [ ("id", `Int 0) ]
                  ; `Assoc [ ("id", `Int 1) ]
                  ; `Assoc [ ("id", `Null) ]
                  ] )
            ] )
      ] )

(* Run tests *)
let () =
  Alcotest.run "GraphQL Error Tests"
    [ ( "error handling"
      , [ Alcotest.test_case "nullable error" `Quick nullable_error_test
        ; Alcotest.test_case "non-nullable error" `Quick non_nullable_error_test
        ; Alcotest.test_case "nested nullable error" `Quick
            nested_nullable_error_test
        ; Alcotest.test_case "error in list" `Quick error_in_list_test
        ] )
    ]

1	open Graphql
2	module Schema = Graphql_wrapper.Make (Schema)
3	open Test_common
4
5	let nullable_error_test () =
6	let schema =	1✔
7	Schema.(
8	schema	1✔
9	[ io_field "nullable" ~typ:int	1✔
10	~args:Arg.[]
11	~resolve:(fun _ () -> Error "boom")	1✔
12	])
13	in
14	let query = "{ nullable }" in
15	test_query schema () query
16	(`Assoc
17	[ ( "errors"
18	, `List
19	[ `Assoc
20	[ ("message", `String "boom")
21	; ("path", `List [ `String "nullable" ])
22	]
23	] )
24	; ("data", `Assoc [ ("nullable", `Null) ])
25	] )
26
27	let non_nullable_error_test () =
28	let schema =	1✔
29	Schema.(
30	schema	1✔
31	[ io_field "non_nullable" ~typ:(non_null int)	1✔
32	~args:Arg.[]
33	~resolve:(fun _ () -> Error "boom")	1✔
34	])
35	in
36	let query = "{ non_nullable }" in
37	test_query schema () query
38	(`Assoc
39	[ ( "errors"
40	, `List
41	[ `Assoc
42	[ ("message", `String "boom")
43	; ("path", `List [ `String "non_nullable" ])
44	]
45	] )
46	; ("data", `Null)
47	] )
48
49	let nested_nullable_error_test () =
50	let obj_with_non_nullable_field =	1✔
51	Schema.(
52	obj "obj" ~fields:(fun _ ->	1✔
53	[ io_field "non_nullable" ~typ:(non_null int)	1✔
54	~args:Arg.[]
55	~resolve:(fun _ () -> Error "boom")	1✔
56	] ))
57	in
58	let schema =
59	Schema.(
60	schema	1✔
61	[ field "nullable" ~typ:obj_with_non_nullable_field	1✔
62	~args:Arg.[]
63	~resolve:(fun _ () -> Some ())	1✔
64	])
65	in
66	let query = "{ nullable { non_nullable } }" in
67	test_query schema () query
68	(`Assoc
69	[ ( "errors"
70	, `List
71	[ `Assoc
72	[ ("message", `String "boom")
73	; ("path", `List [ `String "nullable"; `String "non_nullable" ])
74	]
75	] )
76	; ("data", `Assoc [ ("nullable", `Null) ])
77	] )
78
79	let error_in_list_test () =
80	let foo =	1✔
81	Schema.(
82	obj "Foo" ~fields:(fun _ ->	1✔
83	[ io_field "id" ~typ:int	1✔
84	~args:Arg.[]
85	~resolve:(fun _ (id, should_fail) ->
86	if should_fail then Error "boom" else Ok (Some id) )	1✔
87	] ))
88	in
89	let schema =
90	Schema.(
91	schema	1✔
92	[ field "foos"	1✔
93	~typ:(non_null (list (non_null foo)))	1✔
94	~args:Arg.[]
95	~resolve:(fun _ () -> [ (0, false); (1, false); (2, true) ])	1✔
96	])
97	in
98	let query = "{ foos { id } }" in
99	test_query schema () query
100	(`Assoc
101	[ ( "errors"
102	, `List
103	[ `Assoc
104	[ ("message", `String "boom")
105	; ("path", `List [ `String "foos"; `Int 2; `String "id" ])
106	]
107	] )
108	; ( "data"
109	, `Assoc
110	[ ( "foos"
111	, `List
112	[ `Assoc [ ("id", `Int 0) ]
113	; `Assoc [ ("id", `Int 1) ]
114	; `Assoc [ ("id", `Null) ]
115	] )
116	] )
117	] )
118
119	(* Run tests *)
120	let () =
NEW 121	Alcotest.run "GraphQL Error Tests"	×
122	[ ( "error handling"
123	, [ Alcotest.test_case "nullable error" `Quick nullable_error_test	1✔
124	; Alcotest.test_case "non-nullable error" `Quick non_nullable_error_test	1✔
125	; Alcotest.test_case "nested nullable error" `Quick	1✔
126	nested_nullable_error_test
127	; Alcotest.test_case "error in list" `Quick error_in_list_test	1✔
128	] )
129	]

MinaProtocol / mina / 538

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous