Validate operation name matches an operation (#93)

Validate operation name matches an operation

Refactored for clarity.

Paired with @eoinkelly

Author: aweiker

lib/graphql/execution/execution_context.ex

@@ -13,31 +13,48 @@ defmodule GraphQL.Execution.ExecutionContext do
 
   @spec new(GraphQL.Schema.t, GraphQL.Document.t, map, map, String.t) :: __MODULE__.t
   def new(schema, document, root_value, variable_values, operation_name) do
-    Enum.reduce document.definitions, %__MODULE__{
+
+    initial_context = %__MODULE__{
       schema: schema,
       fragments: %{},
       root_value: root_value,
       operation: nil,
       variable_values: variable_values || %{},
       errors: []
-    }, fn(definition, context) ->
-
-      case definition do
-        %{kind: :OperationDefinition} ->
-          cond do
-            !operation_name && context.operation ->
-              report_error(context, "Must provide operation name if query contains multiple operations.")
-            !operation_name || definition.name.value === operation_name ->
-              context = %{context | operation: definition}
-              %{context | variable_values: GraphQL.Execution.Variables.extract(context) }
-            true -> context
-          end
-        %{kind: :FragmentDefinition} ->
-          put_in(context.fragments[definition.name.value], definition)
-      end
+    }
+
+    document.definitions
+    |> Enum.reduce(initial_context, build_definition_handler(operation_name))
+    |> validate_operation_exists(operation_name)
+  end
+
+  defp build_definition_handler(operation_name) do
+    fn(definition, context) -> handle_definition(operation_name, definition, context) end
+  end
+
+  defp handle_definition(operation_name, definition = %{kind: :OperationDefinition}, context) do
+    multiple_operations_no_operation_name = !operation_name && context.operation
+    should_set_operation = !operation_name || definition.name.value === operation_name
+    cond do
+      multiple_operations_no_operation_name ->
+        report_error(context, "Must provide operation name if query contains multiple operations.")
+      should_set_operation ->
+        context = %{context | operation: definition}
+        %{context | variable_values: GraphQL.Execution.Variables.extract(context) }
+      true -> context
     end
   end
 
+  defp handle_definition(_, definition = %{kind: :FragmentDefinition}, context) do
+    put_in(context.fragments[definition.name.value], definition)
+  end
+
+  defp validate_operation_exists(context, nil), do: context
+  defp validate_operation_exists(context = %{operation: nil}, operation_name) do
+    report_error(context, "Operation `#{operation_name}` not found in query.")
+  end
+  defp validate_operation_exists(context, _operation_name), do: context
+
   @spec report_error(__MODULE__.t, String.t) :: __MODULE__.t
   def report_error(context, msg) do
     put_in(context.errors, [%{"message" => msg} | context.errors])

lib/graphql/execution/executor.ex

@@ -16,9 +16,10 @@ defmodule GraphQL.Execution.Executor do
   """
   @spec execute(GraphQL.Schema.t, GraphQL.Document.t, list) :: result_data | {:error, %{errors: list}}
   def execute(schema, document, opts \\ []) do
-    schema          = Schema.with_type_cache(schema)
+    schema = Schema.with_type_cache(schema)
     {root_value, variable_values, operation_name} = expand_options(opts)
     context = ExecutionContext.new(schema, document, root_value, variable_values, operation_name)
+
     case context.errors do
       [] -> execute_operation(context, context.operation, root_value)
       _  -> {:error, %{errors: Enum.dedup(context.errors)}}

test/graphql/execution/executor_test.exs

@@ -158,6 +158,11 @@ defmodule GraphQL.Execution.Executor.ExecutorTest do
     assert_has_error(result, %{message: "Must provide operation name if query contains multiple operations."})
   end
 
+  test "operation name must match an operation defined in the query" do
+    {_, result} = execute(TestSchema.schema, "query a {greeting}", operation_name: "b")
+    assert_has_error(result, %{message: "Operation `b` not found in query."})
+  end
+
   test "do not include illegal fields in output" do
     {:ok, result} = execute(TestSchema.schema, ~S[query Q {g, h(name:"Joe")}], validate: false)
     assert_data(result, %{})