graphql 1.8.7 → 1.9.0

data/spec/graphql/schema/relay_classic_mutation_spec.rb

@@ -50,6 +50,97 @@ describe GraphQL::Schema::RelayClassicMutation do
 
       assert_equal "Sitar", res["data"]["addSitar"]["instrument"]["name"]
     end
+
+    it "supports extras" do
+      res = Jazz::Schema.execute <<-GRAPHQL
+      mutation {
+        hasExtras(input: {}) {
+          nodeClass
+          int
+        }
+      }
+      GRAPHQL
+
+      assert_equal "GraphQL::Language::Nodes::Field", res["data"]["hasExtras"]["nodeClass"]
+      assert_nil res["data"]["hasExtras"]["int"]
+
+      # Also test with given args
+      res = Jazz::Schema.execute <<-GRAPHQL
+      mutation {
+        hasExtras(input: {int: 5}) {
+          nodeClass
+          int
+        }
+      }
+      GRAPHQL
+      assert_equal "GraphQL::Language::Nodes::Field", res["data"]["hasExtras"]["nodeClass"]
+      assert_equal 5, res["data"]["hasExtras"]["int"]
+    end
+  end
+
+  describe "loading multiple application objects" do
+    let(:query_str) {
+      <<-GRAPHQL
+        mutation($ids: [ID!]!) {
+          upvoteEnsembles(input: {ensembleIds: $ids}) {
+            ensembles {
+              id
+            }
+          }
+        }
+      GRAPHQL
+    }
+
+    it "loads arguments as objects of the given type and strips `_ids` suffix off argument name and appends `s`" do
+      res = Jazz::Schema.execute(query_str, variables: { ids: ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"]})
+      assert_equal ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"], res["data"]["upvoteEnsembles"]["ensembles"].map { |e| e["id"] }
+    end
+
+    it "uses the `as:` name when loading" do
+      as_bands_query_str = query_str.sub("upvoteEnsembles", "upvoteEnsemblesAsBands")
+      res = Jazz::Schema.execute(as_bands_query_str, variables: { ids: ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"]})
+      assert_equal ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"], res["data"]["upvoteEnsemblesAsBands"]["ensembles"].map { |e| e["id"] }
+    end
+
+    it "doesn't append `s` to argument names that already end in `s`" do
+      query = <<-GRAPHQL
+        mutation($ids: [ID!]!) {
+          upvoteEnsemblesIds(input: {ensemblesIds: $ids}) {
+            ensembles {
+              id
+            }
+          }
+        }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query, variables: { ids: ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"]})
+      assert_equal ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"], res["data"]["upvoteEnsemblesIds"]["ensembles"].map { |e| e["id"] }
+    end
+
+    it "returns an error instead when the ID resolves to nil" do
+      res = Jazz::Schema.execute(query_str, variables: {
+        ids: ["Ensemble/Nonexistant Name"],
+      })
+      assert_nil res["data"].fetch("upvoteEnsembles")
+      assert_equal ['No object found for `ensembleIds: "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: {
+        ids: ["Instrument/Organ"],
+      })
+      assert_nil res["data"].fetch("upvoteEnsembles")
+      assert_equal ["No object found for `ensembleIds: \"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: {
+        ids: ["Ensemble/Spinal Tap"],
+      })
+      assert_nil res["data"].fetch("upvoteEnsembles")
+      # Failed silently
+      refute res.key?("errors")
+    end
   end
 
   describe "loading application objects" do
@@ -70,6 +161,48 @@ describe GraphQL::Schema::RelayClassicMutation do
       assert_equal "August Greene", res["data"]["renameEnsemble"]["ensemble"]["name"]
     end
 
+    it "loads arguments as objects when provided an interface type" do
+      query = <<-GRAPHQL
+        mutation($id: ID!, $newName: String!) {
+          renameNamedEntity(input: {namedEntityId: $id, newName: $newName}) {
+            namedEntity {
+              __typename
+              name
+            }
+          }
+        }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query, variables: { id: "Ensemble/Robert Glasper Experiment", newName: "August Greene"})
+      assert_equal "August Greene", res["data"]["renameNamedEntity"]["namedEntity"]["name"]
+      assert_equal "Ensemble", res["data"]["renameNamedEntity"]["namedEntity"]["__typename"]
+    end
+
+    it "loads arguments as objects when provided an union type" do
+      query = <<-GRAPHQL
+        mutation($id: ID!, $newName: String!) {
+          renamePerformingAct(input: {performingActId: $id, newName: $newName}) {
+            performingAct {
+              __typename
+              ... on Ensemble {
+                name
+              }
+            }
+          }
+        }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query, variables: { id: "Ensemble/Robert Glasper Experiment", newName: "August Greene"})
+      assert_equal "August Greene", res["data"]["renamePerformingAct"]["performingAct"]["name"]
+      assert_equal "Ensemble", res["data"]["renamePerformingAct"]["performingAct"]["__typename"]
+    end
+
+    it "uses the `as:` name when loading" do
+      band_query_str = query_str.sub("renameEnsemble", "renameEnsembleAsBand")
+      res = Jazz::Schema.execute(band_query_str, variables: { id: "Ensemble/Robert Glasper Experiment", newName: "August Greene"})
+      assert_equal "August Greene", res["data"]["renameEnsembleAsBand"]["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",

data/spec/graphql/schema/resolver_spec.rb

@@ -56,6 +56,15 @@ describe GraphQL::Schema::Resolver do
       end
     end
 
+    class ResolverWithPath < BaseResolver
+      type String, null: false
+
+      extras [:path]
+      def resolve(path:)
+        path.inspect
+      end
+    end
+
     class Resolver5 < Resolver4
     end
 
@@ -172,7 +181,7 @@ describe GraphQL::Schema::Resolver do
 
     class IntegerWrapper < GraphQL::Schema::Object
       implements HasValue
-      field :value, Integer, null: false, method: :object
+      field :value, Integer, null: false, method: :itself
     end
 
     class PrepResolver9 < BaseResolver
@@ -192,28 +201,45 @@ describe GraphQL::Schema::Resolver do
       end
     end
 
+    class PrepResolver9Array < BaseResolver
+      argument :int_ids, [ID], required: true, loads: HasValue, as: :ints
+      # Make sure the lazy object is resolved properly:
+      type [HasValue], null: false
+      def object_from_id(type, id, ctx)
+        # Make sure a lazy object is handled appropriately
+        LazyBlock.new {
+          # Make sure that the right type ends up here
+          id.to_i + type.graphql_name.length
+        }
+      end
+
+      def resolve(ints:)
+        ints.map { |int| int * 3}
+      end
+    end
+
     class PrepResolver10 < BaseResolver
       argument :int1, Integer, required: true
-      argument :int2, Integer, required: true
+      argument :int2, Integer, required: true, as: :integer_2
       type Integer, null: true
-      def authorized?(int1:, int2:)
-        if int1 + int2 > context[:max_int]
+      def authorized?(int1:, integer_2:)
+        if int1 + integer_2 > context[:max_int]
           raise GraphQL::ExecutionError, "Inputs too big"
-        elsif context[:min_int] && (int1 + int2 < context[:min_int])
+        elsif context[:min_int] && (int1 + integer_2 < context[:min_int])
           false
         else
           true
         end
       end
 
-      def resolve(int1:, int2:)
-        int1 + int2
+      def resolve(int1:, integer_2:)
+        int1 + integer_2
       end
     end
 
     class PrepResolver11 < PrepResolver10
-      def authorized?(int1:, int2:)
-        LazyBlock.new { super(int1: int1 * 2, int2: int2) }
+      def authorized?(int1:, integer_2:)
+        LazyBlock.new { super(int1: int1 * 2, integer_2: integer_2) }
       end
     end
 
@@ -242,6 +268,47 @@ describe GraphQL::Schema::Resolver do
       end
     end
 
+    class PrepResolver14 < GraphQL::Schema::RelayClassicMutation
+      field :number, Integer, null: false
+
+      def authorized?
+        true
+      end
+
+      def resolve
+        { number: 1 }
+      end
+    end
+
+    class MutationWithNullableLoadsArgument < GraphQL::Schema::Mutation
+      argument :label_id, ID, required: false, loads: HasValue
+      argument :label_ids, [ID], required: false, loads: HasValue
+
+      field :inputs, String, null: false
+
+      def resolve(**inputs)
+        {
+          inputs: JSON.dump(inputs)
+        }
+      end
+    end
+
+    class MutationWithRequiredLoadsArgument < GraphQL::Schema::Mutation
+      argument :label_id, ID, required: true, loads: HasValue
+
+      field :inputs, String, null: false
+
+      def resolve(**inputs)
+        {
+          inputs: JSON.dump(inputs)
+        }
+      end
+    end
+
+    class Mutation < GraphQL::Schema::Object
+      field :mutation_with_nullable_loads_argument, mutation: MutationWithNullableLoadsArgument
+      field :mutation_with_required_loads_argument, mutation: MutationWithRequiredLoadsArgument
+    end
 
     class Query < GraphQL::Schema::Object
       class CustomField < GraphQL::Schema::Field
@@ -252,6 +319,14 @@ describe GraphQL::Schema::Resolver do
           end
           value
         end
+
+        def resolve(*)
+          value = super
+          if @name == "resolver3"
+            value << -1
+          end
+          value
+        end
       end
 
       field_class(CustomField)
@@ -265,6 +340,7 @@ describe GraphQL::Schema::Resolver do
       field :resolver_6, resolver: Resolver6
       field :resolver_7, resolver: Resolver7
       field :resolver_8, resolver: Resolver8
+      field :resolver_with_path, resolver: ResolverWithPath
 
       field :prep_resolver_1, resolver: PrepResolver1
       field :prep_resolver_2, resolver: PrepResolver2
@@ -274,16 +350,30 @@ describe GraphQL::Schema::Resolver do
       field :prep_resolver_6, resolver: PrepResolver6
       field :prep_resolver_7, resolver: PrepResolver7
       field :prep_resolver_9, resolver: PrepResolver9
+      field :prep_resolver_9_array, resolver: PrepResolver9Array
       field :prep_resolver_10, resolver: PrepResolver10
       field :prep_resolver_11, resolver: PrepResolver11
       field :prep_resolver_12, resolver: PrepResolver12
       field :prep_resolver_13, resolver: PrepResolver13
+      field :prep_resolver_14, resolver: PrepResolver14
     end
 
     class Schema < GraphQL::Schema
       query(Query)
+      mutation(Mutation)
       lazy_resolve LazyBlock, :value
       orphan_types IntegerWrapper
+      if TESTING_INTERPRETER
+        use GraphQL::Execution::Interpreter
+      end
+
+      def object_from_id(id, ctx)
+        if id == "invalid"
+          nil
+        else
+          1
+        end
+      end
     end
   end
 
@@ -291,6 +381,22 @@ describe GraphQL::Schema::Resolver do
     ResolverTest::Schema.execute(*args)
   end
 
+  describe ".path" do
+    it "is the name" do
+      assert_equal "Resolver1", ResolverTest::Resolver1.path
+    end
+
+    it "is used for arguments and fields" do
+      assert_equal "Resolver1.value", ResolverTest::Resolver1.arguments["value"].path
+      assert_equal "PrepResolver7.int", ResolverTest::PrepResolver7.fields["int"].path
+    end
+
+    it "works on instances" do
+      r = ResolverTest::Resolver1.new(object: nil, context: nil)
+      assert_equal "Resolver1", r.path
+    end
+  end
+
   it "gets initialized for each resolution" do
     # State isn't shared between calls:
     res = exec_query " { r1: resolver1(value: 1) r2: resolver1 }"
@@ -320,6 +426,11 @@ describe GraphQL::Schema::Resolver do
       res = exec_query " { resolver4 } ", root_value: OpenStruct.new(value: 0)
       assert_equal 9, res["data"]["resolver4"]
     end
+
+    it "gets path from extras" do
+      res = exec_query " { resolverWithPath } ", root_value: OpenStruct.new(value: 0)
+      assert_equal '["resolverWithPath"]', res["data"]["resolverWithPath"]
+    end
   end
 
   describe "extras" do
@@ -426,6 +537,11 @@ describe GraphQL::Schema::Resolver do
           assert_equal 11, res["data"]["prepResolver10"]
         end
 
+        it "uses the argument name provided in `as:`" do
+          res = exec_query("{ prepResolver10(int1: 5, int2: 6) }", context: { max_int: 90 })
+          assert_equal 11, res["data"]["prepResolver10"]
+        end
+
         it "can return a lazy object" do
           # This is too big because it's modified in the overridden authorized? hook:
           res = exec_query("{ prepResolver11(int1: 3, int2: 5) }", context: { max_int: 9 })
@@ -462,6 +578,11 @@ describe GraphQL::Schema::Resolver do
           res = exec_query(str, context: { max_int: 100, min_int: 20 })
           assert_equal({ "prepResolver10" => nil, "prepResolver11" => nil }, res["data"])
         end
+
+        it "works with no arguments for RelayClassicMutation" do
+          res = exec_query("{ prepResolver14(input: {}) { number } }")
+          assert_equal 1, res["data"]["prepResolver14"]["number"]
+        end
       end
     end
 
@@ -471,6 +592,49 @@ describe GraphQL::Schema::Resolver do
         # (5 + 8) * 3
         assert_equal 39, res["data"]["prepResolver9"]["value"]
       end
+
+      it "supports loading array of ids" do
+        res = exec_query('{ prepResolver9Array(intIds: ["1", "10", "100"]) { value } }')
+        # (1 + 8) * 3
+        # (10 + 8) * 3
+        # (100 + 8) * 3
+        assert_equal [27, 54, 324], res["data"]["prepResolver9Array"].map { |v| v["value"] }
+      end
+
+      it "preserves `nil` when nullable argument is provided `null`" do
+        res = exec_query("mutation { mutationWithNullableLoadsArgument(labelId: null) { inputs } }")
+
+        assert_equal nil, res["errors"]
+        assert_equal '{"label":null}', res["data"]["mutationWithNullableLoadsArgument"]["inputs"]
+      end
+
+      it "preserves `nil` when nullable list argument is provided `null`" do
+        res = exec_query("mutation { mutationWithNullableLoadsArgument(labelIds: null) { inputs } }")
+
+        assert_equal nil, res["errors"]
+        assert_equal '{"labels":null}', res["data"]["mutationWithNullableLoadsArgument"]["inputs"]
+      end
+
+      it "omits omitted nullable argument" do
+        res = exec_query("mutation { mutationWithNullableLoadsArgument { inputs } }")
+
+        assert_equal nil, res["errors"]
+        assert_equal "{}", res["data"]["mutationWithNullableLoadsArgument"]["inputs"]
+      end
+
+      it "returns an error when nullable argument is provided an invalid value" do
+        res = exec_query('mutation { mutationWithNullableLoadsArgument(labelId: "invalid") { inputs } }')
+
+        assert res["errors"]
+        assert_equal 'No object found for `labelId: "invalid"`', res["errors"][0]["message"]
+      end
+
+      it "returns an error when a non-nullable argument is provided an invalid value" do
+        res = exec_query('mutation { mutationWithRequiredLoadsArgument(labelId: "invalid") { inputs } }')
+
+        assert res["errors"]
+        assert_equal 'No object found for `labelId: "invalid"`', res["errors"][0]["message"]
+      end
     end
   end
 end

data/spec/graphql/schema/scalar_spec.rb

@@ -2,6 +2,12 @@
 require "spec_helper"
 
 describe GraphQL::Schema::Scalar do
+  describe ".path" do
+    it "is the name" do
+      assert_equal "String", GraphQL::Types::String.path
+    end
+  end
+
   describe "in queries" do
     it "becomes output" do
       query_str = <<-GRAPHQL