graphql 1.8.4 → 1.8.5

data/spec/graphql/schema/relay_classic_mutation_spec.rb

@@ -51,4 +51,51 @@ describe GraphQL::Schema::RelayClassicMutation do
       assert_equal "Sitar", res["data"]["addSitar"]["instrument"]["name"]
     end
   end
+
+  describe "loading application objects" do
+    let(:query_str) {
+      <<-GRAPHQL
+        mutation($id: ID!, $newName: String!) {
+          renameEnsemble(input: {ensembleId: $id, newName: $newName}) {
+            ensemble {
+              name
+            }
+          }
+        }
+      GRAPHQL
+    }
+
+    it "loads arguments as objects of the given type" do
+      res = Jazz::Schema.execute(query_str, variables: { id: "Ensemble/Robert Glasper Experiment", newName: "August Greene"})
+      assert_equal "August Greene", res["data"]["renameEnsemble"]["ensemble"]["name"]
+    end
+
+    it "returns an error instead when the ID resolves to nil" do
+      res = Jazz::Schema.execute(query_str, variables: {
+        id: "Ensemble/Nonexistant Name",
+        newName: "August Greene"
+      })
+      assert_nil res["data"].fetch("renameEnsemble")
+      assert_equal ['No object found for `ensembleId: "Ensemble/Nonexistant Name"`'], res["errors"].map { |e| e["message"] }
+    end
+
+    it "returns an error instead when the ID resolves to an object of the wrong type" do
+      res = Jazz::Schema.execute(query_str, variables: {
+        id: "Instrument/Organ",
+        newName: "August Greene"
+      })
+      assert_nil res["data"].fetch("renameEnsemble")
+      assert_equal ["No object found for `ensembleId: \"Instrument/Organ\"`"], res["errors"].map { |e| e["message"] }
+    end
+
+    it "raises an authorization error when the type's auth fails" do
+      res = Jazz::Schema.execute(query_str, variables: {
+        id: "Ensemble/Spinal Tap",
+        newName: "August Greene"
+      })
+      assert_nil res["data"].fetch("renameEnsemble")
+      # Failed silently
+      refute res.key?("errors")
+    end
+  end
 end

data/spec/graphql/schema/resolver_spec.rb

@@ -3,6 +3,16 @@ require "spec_helper"
 
 describe GraphQL::Schema::Resolver do
   module ResolverTest
+    class LazyBlock
+      def initialize
+        @get_value = Proc.new
+      end
+
+      def value
+        @get_value.call
+      end
+    end
+
     class BaseResolver < GraphQL::Schema::Resolver
     end
 
@@ -64,6 +74,90 @@ describe GraphQL::Schema::Resolver do
     class Resolver8 < Resolver7
     end
 
+    class PrepResolver1 < BaseResolver
+      argument :int, Integer, required: true
+
+      def load_int(i)
+        i * 10
+      end
+
+      type Integer, null: false
+
+      def resolve(int:)
+        int
+      end
+
+      private
+
+      def check_for_magic_number(int)
+        if int == 13
+          raise GraphQL::ExecutionError, "13 is unlucky!"
+        elsif int > 99
+          raise GraphQL::UnauthorizedError, "Top secret big number: #{int}"
+        else
+          int
+        end
+      end
+    end
+
+    class PrepResolver2 < PrepResolver1
+      def load_int(i)
+        LazyBlock.new {
+          super - 35
+        }
+      end
+    end
+
+    class PrepResolver3 < PrepResolver1
+      type Integer, null: true
+
+      def load_int(i)
+        check_for_magic_number(i)
+      end
+    end
+
+    class PrepResolver4 < PrepResolver3
+      def load_int(i)
+        LazyBlock.new {
+          super
+        }
+      end
+    end
+
+    class PrepResolver5 < PrepResolver1
+      type Integer, null: true
+
+      def before_prepare(int:)
+        check_for_magic_number(int)
+      end
+    end
+
+    class PrepResolver6 < PrepResolver5
+      def before_prepare(**args)
+        LazyBlock.new {
+          super
+        }
+      end
+    end
+
+    class PrepResolver7 < PrepResolver1
+      type Integer, null: true
+
+      def load_int(int)
+        int
+      end
+
+      def validate_int(int)
+        check_for_magic_number(int)
+      end
+    end
+
+    class PrepResolver8 < PrepResolver7
+      def validate_int(int)
+        LazyBlock.new { super }
+      end
+    end
+
     class Query < GraphQL::Schema::Object
       class CustomField < GraphQL::Schema::Field
         def resolve_field(*args)
@@ -86,47 +180,61 @@ describe GraphQL::Schema::Resolver do
       field :resolver_6, resolver: Resolver6
       field :resolver_7, resolver: Resolver7
       field :resolver_8, resolver: Resolver8
+
+      field :prep_resolver_1, resolver: PrepResolver1
+      field :prep_resolver_2, resolver: PrepResolver2
+      field :prep_resolver_3, resolver: PrepResolver3
+      field :prep_resolver_4, resolver: PrepResolver4
+      field :prep_resolver_5, resolver: PrepResolver5
+      field :prep_resolver_6, resolver: PrepResolver6
+      field :prep_resolver_7, resolver: PrepResolver7
+      field :prep_resolver_8, resolver: PrepResolver8
     end
 
     class Schema < GraphQL::Schema
       query(Query)
+      lazy_resolve LazyBlock, :value
     end
   end
 
+  def exec_query(*args)
+    ResolverTest::Schema.execute(*args)
+  end
+
   it "gets initialized for each resolution" do
     # State isn't shared between calls:
-    res = ResolverTest::Schema.execute " { r1: resolver1(value: 1) r2: resolver1 }"
+    res = exec_query " { r1: resolver1(value: 1) r2: resolver1 }"
     assert_equal [100, 1], res["data"]["r1"]
     assert_equal [100, nil], res["data"]["r2"]
   end
 
   it "inherits type and arguments" do
-    res = ResolverTest::Schema.execute " { r1: resolver2(value: 1, extraValue: 2) r2: resolver2(extraValue: 3) }"
+    res = exec_query " { r1: resolver2(value: 1, extraValue: 2) r2: resolver2(extraValue: 3) }"
     assert_equal [100, 1, 2], res["data"]["r1"]
     assert_equal [100, nil, 3], res["data"]["r2"]
   end
 
   it "uses the object's field_class" do
-    res = ResolverTest::Schema.execute " { r1: resolver3(value: 1) r2: resolver3 }"
+    res = exec_query " { r1: resolver3(value: 1) r2: resolver3 }"
     assert_equal [100, 1, -1], res["data"]["r1"]
     assert_equal [100, nil, -1], res["data"]["r2"]
   end
 
   describe "resolve method" do
     it "has access to the application object" do
-      res = ResolverTest::Schema.execute " { resolver4 } ", root_value: OpenStruct.new(value: 4)
+      res = exec_query " { resolver4 } ", root_value: OpenStruct.new(value: 4)
       assert_equal 13, res["data"]["resolver4"]
     end
 
     it "gets extras" do
-      res = ResolverTest::Schema.execute " { resolver4 } ", root_value: OpenStruct.new(value: 0)
+      res = exec_query " { resolver4 } ", root_value: OpenStruct.new(value: 0)
       assert_equal 9, res["data"]["resolver4"]
     end
   end
 
   describe "extras" do
     it "is inherited" do
-      res = ResolverTest::Schema.execute " { resolver4 resolver5 } ", root_value: OpenStruct.new(value: 0)
+      res = exec_query " { resolver4 resolver5 } ", root_value: OpenStruct.new(value: 0)
       assert_equal 9, res["data"]["resolver4"]
       assert_equal 9, res["data"]["resolver5"]
     end
@@ -134,12 +242,12 @@ describe GraphQL::Schema::Resolver do
 
   describe "complexity" do
     it "has default values" do
-      res = ResolverTest::Schema.execute " { resolver6 } ", root_value: OpenStruct.new(value: 0)
+      res = exec_query " { resolver6 } ", root_value: OpenStruct.new(value: 0)
       assert_equal 1, res["data"]["resolver6"]
     end
 
     it "is inherited" do
-      res = ResolverTest::Schema.execute " { resolver7 resolver8 } ", root_value: OpenStruct.new(value: 0)
+      res = exec_query " { resolver7 resolver8 } ", root_value: OpenStruct.new(value: 0)
       assert_equal 2, res["data"]["resolver7"]
       assert_equal 2, res["data"]["resolver8"]
     end
@@ -159,4 +267,70 @@ describe GraphQL::Schema::Resolver do
       assert ResolverTest::Schema.find("Query.resolver3Again")
     end
   end
+
+  describe "preparing inputs" do
+    # Add assertions for a given field, assuming the behavior of `check_for_magic_number`
+    def add_error_assertions(field_name, description)
+      res = exec_query("{ int: #{field_name}(int: 13) }")
+      assert_nil res["data"].fetch("int"), "#{description}: no result for execution error"
+      assert_equal ["13 is unlucky!"], res["errors"].map { |e| e["message"] }, "#{description}: top-level error is added"
+
+      res = exec_query("{ int: #{field_name}(int: 200) }")
+      assert_nil res["data"].fetch("int"), "#{description}: No result for authorization error"
+      refute res.key?("errors"), "#{description}: silent auth failure (no top-level error)"
+    end
+
+    describe "before_prepare" do
+      it "can raise errors" do
+        res = exec_query("{ int: prepResolver5(int: 5) }")
+        assert_equal 50, res["data"]["int"]
+        add_error_assertions("prepResolver5", "before_prepare")
+      end
+
+      it "can raise errors in lazy sync" do
+        res = exec_query("{ int: prepResolver6(int: 5) }")
+        assert_equal 50, res["data"]["int"]
+        add_error_assertions("prepResolver6", "lazy before_prepare")
+      end
+    end
+
+    describe "loading arguments" do
+      it "calls load methods and injects the return value" do
+        res = exec_query("{ prepResolver1(int: 5) }")
+        assert_equal 50, res["data"]["prepResolver1"], "The load multiplier was called"
+      end
+
+      it "supports lazy values" do
+        res = exec_query("{ prepResolver2(int: 5) }")
+        assert_equal 15, res["data"]["prepResolver2"], "The load multiplier was called"
+      end
+
+      it "supports raising GraphQL::UnauthorizedError and GraphQL::ExecutionError" do
+        res = exec_query("{ prepResolver3(int: 5) }")
+        assert_equal 5, res["data"]["prepResolver3"]
+        add_error_assertions("prepResolver3", "load_ hook")
+      end
+
+      it "supports raising errors from promises" do
+        res = exec_query("{ prepResolver4(int: 5) }")
+        assert_equal 5, res["data"]["prepResolver4"]
+        add_error_assertions("prepResolver4", "lazy load_ hook")
+      end
+    end
+
+    describe "validating arguments" do
+      test_cases = {
+        "eager" => "prepResolver7",
+        "lazy" => "prepResolver8",
+      }
+
+      test_cases.each do |mode, field_name|
+        it "supports raising #{mode} errors" do
+          res = exec_query("{ validatedInt: #{field_name}(int: 5) }")
+          assert_equal 5, res["data"]["validatedInt"]
+          add_error_assertions(field_name, "#{mode} validation")
+        end
+      end
+    end
+  end
 end

data/spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb

@@ -222,7 +222,8 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
 
   describe "custom error messages" do
     let(:schema) {
-      TimeType = GraphQL::ScalarType.define do
+
+      CoerceTestTimeType = GraphQL::ScalarType.define do
         name "Time"
         description "Time since epoch in seconds"
 
@@ -237,19 +238,19 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
         coerce_result ->(value, ctx) { value.to_f }
       end
 
-      QueryType = GraphQL::ObjectType.define do
+      CoerceTestQueryType = GraphQL::ObjectType.define do
         name "Query"
         description "The query root of this schema"
 
         field :time do
-          type TimeType
-          argument :value, !TimeType
+          type CoerceTestTimeType
+          argument :value, !CoerceTestTimeType
           resolve ->(obj, args, ctx) { args[:value] }
         end
       end
 
       GraphQL::Schema.define do
-        query QueryType
+        query CoerceTestQueryType
       end
     }
 

data/spec/graphql/static_validation/rules/no_definitions_are_present_spec.rb

@@ -25,4 +25,38 @@ describe GraphQL::StaticValidation::NoDefinitionsArePresent do
       assert_equal [{"line"=>5, "column"=>7}, {"line"=>9, "column"=>7}], err["locations"]
     end
   end
+
+  describe "when schema extensions are present in the query" do
+    let(:query_string) {
+      <<-GRAPHQL
+      {
+        cheese(id: 1) { flavor }
+      }
+
+      extend schema {
+        subscription: Query
+      }
+
+      extend scalar TracingScalar @deprecated
+      extend type Dairy @deprecated
+      extend interface Edible @deprecated
+      extend union Beverage @deprecated
+      extend enum DairyAnimal @deprecated
+      extend input ResourceOrderType @deprecated
+      GRAPHQL
+    }
+
+    it "adds an error" do
+      assert_equal 1, errors.length
+      err = errors[0]
+      assert_equal "Query cannot contain schema definitions", err["message"]
+      assert_equal [{"line"=>5, "column"=>7},
+        {"line"=>9, "column"=>7},
+        {"line"=>10, "column"=>7},
+        {"line"=>11, "column"=>7},
+        {"line"=>12, "column"=>7},
+        {"line"=>13, "column"=>7},
+        {"line"=>14, "column"=>7}], err["locations"]
+    end
+  end
 end

data/spec/graphql/static_validation/validator_spec.rb

@@ -25,6 +25,21 @@ describe GraphQL::StaticValidation::Validator do
     end
   end
 
+  describe "error format" do
+    let(:query_string) { "{ cheese(id: $undefinedVar) { source } }" }
+    let(:document) { GraphQL.parse_with_racc(query_string, filename: "not_a_real.graphql") }
+    let(:query) { GraphQL::Query.new(Dummy::Schema, nil, document: document) }
+
+    it "includes message, locations, and fields keys" do
+      expected_errors = [{
+        "message" => "Variable $undefinedVar is used by  but not declared",
+        "locations" => [{"line" => 1, "column" => 14, "filename" => "not_a_real.graphql"}],
+        "fields" => ["query", "cheese", "id"]
+      }]
+      assert_equal expected_errors, errors
+    end
+  end
+
   describe "validation order" do
     let(:document) { GraphQL.parse(query_string)}
 

data/spec/support/jazz.rb

@@ -32,6 +32,7 @@ module Jazz
         "Ensemble" => [
           Models::Ensemble.new("Bela Fleck and the Flecktones"),
           Models::Ensemble.new("Robert Glasper Experiment"),
+          Models::Ensemble.new("Spinal Tap"),
         ],
         "Musician" => [
           Models::Musician.new("Herbie Hancock", Models::Key.from_notation("B♭")),
@@ -190,6 +191,12 @@ module Jazz
     def overridden_name
       @object.name.sub("Robert Glasper", "ROBERT GLASPER")
     end
+
+    def self.authorized?(object, context)
+      # Spinal Tap is top-secret, don't show it to anyone.
+      obj_name = object.is_a?(Hash) ? object[:name] : object.name
+      obj_name != "Spinal Tap"
+    end
   end
 
   class Family < BaseEnum
@@ -344,7 +351,8 @@ module Jazz
     end
 
     def ensembles
-      Models.data["Ensemble"]
+      # Filter out the unauthorized one to avoid an error later
+      Models.data["Ensemble"].select { |e| e.name != "Spinal Tap" }
     end
 
     def find(id:)
@@ -419,6 +427,12 @@ module Jazz
     def hash_by_sym
       { falsey: false }
     end
+
+    field :named_entities, [NamedEntity, null: true], null: false
+
+    def named_entities
+      [Models.data["Ensemble"].first, nil]
+    end
   end
 
   class EnsembleInput < GraphQL::Schema::InputObject
@@ -458,6 +472,22 @@ module Jazz
     end
   end
 
+  class RenameEnsemble < GraphQL::Schema::RelayClassicMutation
+    argument :ensemble_id, ID, required: true, loads: Ensemble
+    argument :new_name, String, required: true
+
+    field :ensemble, Ensemble, null: false
+
+    def resolve(ensemble:, new_name:)
+      # doesn't actually update the "database"
+      dup_ensemble = ensemble.dup
+      dup_ensemble.name = new_name
+      {
+        ensemble: dup_ensemble
+      }
+    end
+  end
+
   class Mutation < BaseObject
     field :add_ensemble, Ensemble, null: false do
       argument :input, EnsembleInput, required: true
@@ -465,6 +495,7 @@ module Jazz
 
     field :add_instrument, mutation: AddInstrument
     field :add_sitar, mutation: AddSitar
+    field :rename_ensemble, mutation: RenameEnsemble
 
     def add_ensemble(input:)
       ens = Models::Ensemble.new(input.name)
@@ -553,5 +584,9 @@ module Jazz
       class_name = obj.class.name.split("::").last
       ctx.schema.types[class_name] || raise("No type for #{obj.inspect}")
     end
+
+    def self.object_from_id(id, ctx)
+      GloballyIdentifiableType.find(id)
+    end
   end
 end