graphql 1.8.7 → 1.8.8

data/spec/graphql/schema/object_spec.rb

@@ -14,6 +14,12 @@ describe GraphQL::Schema::Object do
       assert object_class.respond_to?(:connection_type)
     end
 
+    describe "path" do
+      it "is the type name" do
+        assert_equal "Ensemble", object_class.path
+      end
+    end
+
     it "inherits fields and interfaces" do
       new_object_class = Class.new(object_class) do
         field :newField, String, null: true

data/spec/graphql/schema/relay_classic_mutation_spec.rb

@@ -52,6 +52,71 @@ describe GraphQL::Schema::RelayClassicMutation do
     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
     let(:query_str) {
       <<-GRAPHQL
@@ -70,6 +135,12 @@ describe GraphQL::Schema::RelayClassicMutation do
       assert_equal "August Greene", res["data"]["renameEnsemble"]["ensemble"]["name"]
     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

@@ -192,28 +192,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 +259,17 @@ 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 Query < GraphQL::Schema::Object
       class CustomField < GraphQL::Schema::Field
@@ -274,10 +302,12 @@ 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
@@ -291,6 +321,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 }"
@@ -426,6 +472,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 +513,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 +527,14 @@ 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
     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

data/spec/graphql/schema/union_spec.rb

@@ -3,6 +3,13 @@ require "spec_helper"
 
 describe GraphQL::Schema::Union do
   let(:union) { Jazz::PerformingAct }
+
+  describe ".path" do
+    it "is the name" do
+      assert_equal "PerformingAct", union.path
+    end
+  end
+
   describe "type info" do
     it "has some" do
       assert_equal 2, union.possible_types.size

data/spec/graphql/upgrader/member_spec.rb

@@ -292,6 +292,10 @@ RUBY
       new = %{field :name, String, null: false}
       assert_equal new, upgrade(old)
 
+      old = %{field :name, types.String.to_non_null_type}
+      new = %{field :name, String, null: false}
+      assert_equal new, upgrade(old)
+
       old = %{field :name, !types.String, "description", method: :name_full}
       new = %{field :name, String, "description", method: :name_full, null: false}
       assert_equal new, upgrade(old)
@@ -300,6 +304,10 @@ RUBY
       new = %{field :name, String, null: false}
       assert_equal new, upgrade(old)
 
+      old = %{field :name, -> { types.String.to_non_null_type }}
+      new = %{field :name, String, null: false}
+      assert_equal new, upgrade(old)
+
       old = %{connection :name, Name.connection_type, "names"}
       new = %{field :name, Name.connection_type, "names", null: true, connection: true}
       assert_equal new, upgrade(old)
@@ -308,10 +316,18 @@ RUBY
       new = %{field :name, Name.connection_type, "names", null: false, connection: true}
       assert_equal new, upgrade(old)
 
+      old = %{connection :name, Name.connection_type.to_non_null_type, "names"}
+      new = %{field :name, Name.connection_type, "names", null: false, connection: true}
+      assert_equal new, upgrade(old)
+
       old = %{field :names, types[!types.String]}
       new = %{field :names, [String], null: true}
       assert_equal new, upgrade(old)
 
+      old = %{field :names, types[types.String.to_non_null_type]}
+      new = %{field :names, [String], null: true}
+      assert_equal new, upgrade(old)
+
       old = %{field :names, !types[types.String]}
       new = %{field :names, [String, null: true], null: false}
       assert_equal new, upgrade(old)
@@ -341,6 +357,22 @@ RUBY
       }
       assert_equal new, upgrade(old)
 
+      old = %{
+        field :name, types.String.to_non_null_type do
+          description "abc"
+        end
+
+        field :name2, types.Int.to_non_null_type do
+          description "def"
+        end
+      }
+      new = %{
+        field :name, String, description: "abc", null: false
+
+        field :name2, Integer, description: "def", null: false
+      }
+      assert_equal new, upgrade(old)
+
       old = %{
         field :name, -> { !types.String } do
         end
@@ -350,6 +382,15 @@ RUBY
       }
       assert_equal new, upgrade(old)
 
+      old = %{
+        field :name, -> { types.String.to_non_null_type } do
+        end
+      }
+      new = %{
+        field :name, String, null: false
+      }
+      assert_equal new, upgrade(old)
+
       old = %{
         field :name do
           type -> { String }
@@ -376,6 +417,22 @@ RUBY
       }
       assert_equal new, upgrade(old)
 
+      old = %{
+        field :name do
+          type String.to_non_null_type
+        end
+
+        field :name2 do
+          type String.to_non_null_type
+        end
+      }
+      new = %{
+        field :name, String, null: false
+
+        field :name2, String, null: false
+      }
+      assert_equal new, upgrade(old)
+
       old = %{
         field :name, -> { types.String },
           "newline description" do
@@ -396,6 +453,16 @@ RUBY
       }
       assert_equal new, upgrade(old)
 
+      old = %{
+        field :name, -> { types.String.to_non_null_type },
+          "newline description" do
+        end
+      }
+      new = %{
+        field :name, String, "newline description", null: false
+      }
+      assert_equal new, upgrade(old)
+
       old = %{
        field :name, String,
          field: SomeField do

data/spec/{graphql → integration/mongoid/graphql}/relay/mongo_relation_connection_spec.rb

@@ -1,18 +1,7 @@
 # frozen_string_literal: true
 require 'spec_helper'
 
-if MONGO_DETECTED
-  require "support/star_trek/data"
-  require "support/star_trek/schema"
-end
-
 describe GraphQL::Relay::MongoRelationConnection do
-  before do
-    if !MONGO_DETECTED
-      skip("Mongo not detected")
-    end
-  end
-
   def get_names(result)
     ships = result["data"]["federation"]["bases"]["edges"]
     ships.map { |e| e["node"]["name"] }

data/spec/integration/mongoid/spec_helper.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+require "mongoid" if RUBY_ENGINE == 'ruby'

data/spec/{support/star_wars → integration/rails}/data.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require_relative 'spec_helper'
 require 'ostruct'
 
 # platform helper