Merge pull request #3648 from esl/graphql/use-enum-in-handler-config

GraphQL - Use enum in cowboy handler configuration and provide test

big_tests/tests/graphql_helper.erl

@@ -16,7 +16,7 @@
 execute(EpName, Body, Creds) ->
     Request =
       #{port => get_listener_port(EpName),
-        role => {graphql, atom_to_binary(EpName)},
+        role => {graphql, EpName},
         method => <<"POST">>,
         return_maps => true,
         creds => Creds,
@@ -123,9 +123,9 @@ get_value([Field | Fields], Data) ->
     Data2 = maps:get(BinField, Data),
     get_value(Fields, Data2).
 
-is_graphql_config(#{module := ejabberd_cowboy, handlers := Handlers}, EpName) ->
-    lists:any(fun(#{module := mongoose_graphql_cowboy_handler, schema_endpoint := EpBin}) ->
-                      atom_to_binary(EpName) =:= EpBin;
+is_graphql_config(#{module := ejabberd_cowboy, handlers := Handlers}, ExpEpName) ->
+    lists:any(fun(#{module := mongoose_graphql_cowboy_handler, schema_endpoint := EpName}) ->
+                      ExpEpName =:= EpName;
                  (_) -> false
               end, Handlers);
 is_graphql_config(_, _EpName) ->

src/graphql/mongoose_graphql_cowboy_handler.erl

@@ -39,12 +39,15 @@
 
 -spec config_spec() -> mongoose_config_spec:config_section().
 config_spec() ->
-    #section{items = #{<<"username">> => #option{type = binary},
-                       <<"password">> => #option{type = binary},
-                       <<"schema_endpoint">> => #option{type = binary}},
-             format_items = map,
-             required = [<<"schema_endpoint">>],
-             process = fun ?MODULE:process_config/1}.
+    #section{
+       items = #{<<"username">> => #option{type = binary},
+                 <<"password">> => #option{type = binary},
+                 <<"schema_endpoint">> => #option{type = atom,
+                                                  validate = {enum, [admin, domain_admin, user]}}
+                },
+        format_items = map,
+        required = [<<"schema_endpoint">>],
+        process = fun ?MODULE:process_config/1}.
 
 process_config(Opts) ->
     case maps:is_key(username, Opts) =:= maps:is_key(password, Opts) of
@@ -118,11 +121,11 @@ to_json(Req, State) -> json_request(Req, State).
 
 %% Internal
 
-check_auth(Auth, #{schema_endpoint := <<"domain_admin">>} = State) ->
+check_auth(Auth, #{schema_endpoint := domain_admin} = State) ->
     auth_domain_admin(Auth, State);
-check_auth(Auth, #{schema_endpoint := <<"admin">>} = State) ->
+check_auth(Auth, #{schema_endpoint := admin} = State) ->
     auth_admin(Auth, State);
-check_auth(Auth, #{schema_endpoint := <<"user">>} = State) ->
+check_auth(Auth, #{schema_endpoint := user} = State) ->
     auth_user(Auth, State).
 
 auth_user({basic, User, Password}, State) ->
@@ -170,7 +173,7 @@ 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) ->
-    Ep = mongoose_graphql:get_endpoint(binary_to_existing_atom(EpName)),
+    Ep = mongoose_graphql:get_endpoint(EpName),
     Ctx = maps:get(schema_ctx, State, #{}),
     ReqCtx2 = ReqCtx#{authorized => AuthStatus, ctx => Ctx},
     case mongoose_graphql:execute(Ep, ReqCtx2) of

test/common/config_parser_helper.erl

@@ -1092,6 +1092,9 @@ default_config([listen, http, handlers, mongoose_client_api]) ->
 default_config([listen, http, handlers, mongoose_api]) ->
     #{handlers => [mongoose_api_metrics, mongoose_api_users],
       module => mongoose_api};
+default_config([listen, http, handlers, mongoose_graphql_cowboy_handler]) ->
+    #{module => mongoose_graphql_cowboy_handler,
+      schema_endpoint => admin};
 default_config([listen, http, handlers, Module]) ->
     #{module => Module};
 default_config([listen, http, transport]) ->

test/config_parser_SUITE.erl

@@ -99,7 +99,8 @@ groups() ->
                            listen_http_handlers_api,
                            listen_http_handlers_api_admin,
                            listen_http_handlers_api_client,
-                           listen_http_handlers_domain]},
+                           listen_http_handlers_domain,
+                           listen_http_handlers_graphql]},
      {auth, [parallel], [auth_methods,
                          auth_password,
                          auth_sasl_external,
@@ -680,6 +681,13 @@ listen_http_handlers_domain(_Config) ->
     {P, T} = test_listen_http_handler(mongoose_domain_handler),
     test_listen_http_handler_creds(P, T).
 
+listen_http_handlers_graphql(_Config) ->
+    T = fun graphql_handler_raw/1,
+    {P, _} = test_listen_http_handler(mongoose_graphql_cowboy_handler, T),
+    test_listen_http_handler_creds(P, T),
+    ?err(T(#{<<"schema_endpoint">> => <<"wrong_endpoint">>})),
+    ?err(http_handler_raw(mongoose_graphql_cowboy_handler, #{})).
+
 test_listen_http_handler_creds(P, T) ->
     CredsRaw = #{<<"username">> => <<"user">>, <<"password">> => <<"pass">>},
     ?cfg(P ++ [username], <<"user">>, T(CredsRaw)),
@@ -691,6 +699,9 @@ test_listen_http_handler_creds(P, T) ->
 
 test_listen_http_handler(Module) ->
     T = fun(Opts) -> http_handler_raw(Module, Opts) end,
+    test_listen_http_handler(Module, T).
+
+test_listen_http_handler(Module, T) ->
     P = [listen, 1, handlers, 1],
     ?cfg(P, config([listen, http, handlers, Module], #{host => "localhost", path => "/api"}),
          T(#{})),
@@ -3051,6 +3062,10 @@ check_module_defaults(Mod) ->
 listener(Type, Opts) ->
     config([listen, Type], Opts).
 
+graphql_handler_raw(Opts) ->
+    http_handler_raw(mongoose_graphql_cowboy_handler,
+                     maps:merge(#{<<"schema_endpoint">> => <<"admin">>}, Opts)).
+
 http_handler_raw(Type, Opts) ->
     MergedOpts = maps:merge(#{<<"host">> => <<"localhost">>, <<"path">> => <<"/api">>}, Opts),
     listen_raw(http, #{<<"port">> => 5280,

test/mongoose_graphql_SUITE.erl

@@ -151,12 +151,12 @@ init_per_group(user_listener, Config) ->
                     (#jid{luser = <<"alice">>}, <<"makota">>) -> {true, {}};
                     (_, _) -> false
                 end),
-    ListenerOpts = #{schema_endpoint => <<"user">>},
+    ListenerOpts = #{schema_endpoint => user},
     init_ep_listener(5557, user_schema_ep, ListenerOpts, Config);
 init_per_group(admin_listener, Config) ->
     ListenerOpts = #{username => <<"admin">>,
                      password => <<"secret">>,
-                     schema_endpoint => <<"admin">>},
+                     schema_endpoint => admin},
     init_ep_listener(5558, admin_schema_ep, ListenerOpts, Config);
 init_per_group(domain_admin_listener, Config) ->
     meck:new(mongoose_domain_api, [no_link]),
@@ -168,7 +168,7 @@ init_per_group(domain_admin_listener, Config) ->
                 end),
     meck:expect(mongoose_domain_api, get_subdomain_info,
                 fun (_) -> {error, not_found} end),
-    ListenerOpts = #{schema_endpoint => <<"domain_admin">>},
+    ListenerOpts = #{schema_endpoint => domain_admin},
     init_ep_listener(5560, domain_admin_schema_ep, ListenerOpts, Config);
 init_per_group(domain_permissions, Config) ->
     meck:new(mongoose_domain_api, [no_link]),
@@ -657,7 +657,7 @@ auth_user_can_access_protected_types(Config) ->
 no_creds_defined_admin_can_access_protected(_Config) ->
     Port = 5559,
     Ep = "http://localhost:" ++ integer_to_list(Port),
-    start_listener(no_creds_admin_listener, Port, #{schema_endpoint => <<"admin">>}),
+    start_listener(no_creds_admin_listener, Port, #{schema_endpoint => admin}),
     Body = #{<<"query">> => <<"{ field }">>},
     {Status, Data} = execute(Ep, Body, undefined),
     assert_access_granted(Status, Data).