Fixing parsing error

big_tests/tests/graphql_SUITE.erl

@@ -7,7 +7,8 @@
 -compile([export_all, nowarn_export_all]).
 
 -import(distributed_helper, [mim/0, require_rpc_nodes/1, rpc/4]).
--import(graphql_helper, [execute/3, execute_auth/2, execute_user/3]).
+-import(graphql_helper, [execute/3, execute_auth/2, execute_user/3,
+                         get_value/2, get_bad_request/1]).
 
 -define(assertAdminAuth(Domain, Type, Auth, Data),
         assert_auth(#{<<"domain">> => Domain,
@@ -54,7 +55,8 @@ common_tests() ->
 
 categories_disabled_tests() ->
     [category_disabled_error_test,
-     admin_checks_auth].
+     admin_checks_auth,
+     category_does_not_exists_error].
 
 init_per_suite(Config) ->
     Config1 = escalus:init_per_suite(Config),
@@ -157,7 +159,17 @@ auth_domain_admin_checks_auth(Config) ->
 
 category_disabled_error_test(Config) ->
     Ep = ?config(schema_endpoint, Config),
-    StatusData = execute(Ep, admin_server_get_loglevel_body(), undefined).
+    Status = execute(Ep, admin_server_get_loglevel_body(), undefined),
+    get_bad_request(Status),
+    {_Code, #{<<"errors">> := [Msg]}} = Status,
+    ?assertEqual(<<"category_disabled">>, get_value([extensions, code], Msg)).
+
+category_does_not_exists_error(Config) ->
+    Ep = ?config(schema_endpoint, Config),
+    Status = execute(Ep, #{<<"query">> => <<"{ field ">>}, undefined),
+    get_bad_request(Status),
+    {_Code, #{<<"errors">> := [Msg]}} = Status,
+    ?assertEqual(<<"parser_error">>, get_value([extensions, code], Msg)).
 
 %% Helpers
 

src/graphql/mongoose_graphql_cowboy_handler.erl

@@ -174,38 +174,53 @@ auth_domain_admin(_, State) ->
 
 run_request(#{document := undefined}, Req, State) ->
     reply_error(make_error(decode, no_query_supplied), Req, State);
-run_request(#{} = ReqCtx, Req, #{schema_endpoint := EpName,
-                                 authorized := AuthStatus} = State) ->
+run_request(#{} = ReqCtx, Req, State) ->
+    fold(ReqCtx, {ReqCtx, Req, State}, [fun retrieve_category_from_ctx/2,
+                                        fun check_allowed_categories/2,
+                                        fun execute_request/2]).
+
+fold({error, Error}, {_ReqCtx, Req, State}, _) ->
+    reply_error(Error, Req, State);
+fold(Reply, {_ReqCtx, _Req, State}, []) ->
+    {stop, Reply, State};
+fold(M, Data, [Step | Rest]) ->
+    fold(Step(M, Data), Data, Rest).
+
+retrieve_category_from_ctx(Ctx, _) ->
+    #{document := Doc} = Ctx,
+    try mongoose_graphql:graphql_parse(Doc) of
+        {ok, Document} ->
+            [Parsed] = Document#document.definitions,
+            [Field] = Parsed#op.selection_set,
+            {name, _, Category} = Field#field.id,
+            Category
+    catch
+        Error ->
+            Error
+    end.
+
+
+check_allowed_categories(Category, {_, _Req, State}) ->
     AllowedCategories = maps:get(allowed_categories, State, []),
-    Ep = mongoose_graphql:get_endpoint(EpName),
-    Ctx = maps:get(schema_ctx, State, #{}),
-    ReqCtx2 = ReqCtx#{authorized => AuthStatus, ctx => Ctx#{method => http}},
-    Category = retrieve_category_from_ctx(ReqCtx),
     case AllowedCategories =:= [] orelse lists:member(Category, AllowedCategories) of
         true ->
-            case mongoose_graphql:execute(Ep, ReqCtx2) of
-                {ok, Response} ->
-                    ResponseBody = mongoose_graphql_response:term_to_json(Response),
-                    Req2 = cowboy_req:set_resp_body(ResponseBody, Req),
-                    Reply = cowboy_req:reply(200, Req2),
-                    {stop, Reply, State};
-                {error, Reason} ->
-                    reply_error(Reason, Req, State)
-            end;
+            ok;
         false ->
-            reply_error({category_disabled, Category}, Req, State)
+            {error, {category_disabled, Category}}
     end.
 
-retrieve_category_from_ctx(Ctx)->
-    #{document := Doc} = Ctx,
-    {ok, Document} = mongoose_graphql:graphql_parse(Doc),
-    [Parsed] = Document#document.definitions,
-    [Field] = Parsed#op.selection_set,
-    case Field#field.id of
-        {name, _, Category} ->
-            Category;
-        Category ->
-            Category
+execute_request(_, {ReqCtx, Req, #{schema_endpoint := EpName,
+                                   authorized := AuthStatus} = State}) ->
+    Ep = mongoose_graphql:get_endpoint(EpName),
+    Ctx = maps:get(schema_ctx, State, #{}),
+    ReqCtx2 = ReqCtx#{authorized => AuthStatus, ctx => Ctx#{method => http}},
+    case mongoose_graphql:execute(Ep, ReqCtx2) of
+        {ok, Response} ->
+            ResponseBody = mongoose_graphql_response:term_to_json(Response),
+            Req2 = cowboy_req:set_resp_body(ResponseBody, Req),
+            cowboy_req:reply(200, Req2);
+        {error, Reason} ->
+            {error, Reason}
     end.
 
 gather(Req) ->