graphql 1.8.7 → 1.9.0

data/spec/integration/rails/graphql/input_object_type_spec.rb

@@ -0,0 +1,364 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::InputObjectType do
+  let(:input_object) { Dummy::DairyProductInput.graphql_definition }
+  it "has a description" do
+    assert(input_object.description)
+  end
+
+  it "has input fields" do
+    assert(input_object.input_fields["fatContent"])
+  end
+
+  describe "on a type unused by the schema" do
+    it "has input fields" do
+      UnreachedInputType = GraphQL::InputObjectType.define do
+        name 'UnreachedInputType'
+        description 'An input object type not directly used in the schema.'
+
+        input_field :field, types.String
+      end
+      assert(UnreachedInputType.input_fields['field'])
+    end
+  end
+
+  describe "input validation" do
+    it "Accepts anything that yields key-value pairs to #all?" do
+      values_obj = MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4})
+      assert input_object.valid_isolated_input?(values_obj)
+    end
+
+    describe "validate_input with non-enumerable input" do
+      it "returns a valid result for MinimumInputObject" do
+        result = input_object.validate_isolated_input(MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4}))
+        assert(result.valid?)
+      end
+
+      it "returns an invalid result for MinimumInvalidInputObject" do
+        invalid_input = MinimumInputObject.new({"source" => "KOALA", "fatContent" => 0.4})
+        result = input_object.validate_isolated_input(invalid_input)
+        assert(!result.valid?)
+      end
+    end
+
+    describe "validate_input with null" do
+      let(:schema) { GraphQL::Schema.from_definition(%|
+        type Query {
+          a: Int
+        }
+
+        input ExampleInputObject {
+          a: String
+          b: Int!
+        }
+      |) }
+      let(:input_type) { schema.types['ExampleInputObject'] }
+
+      it "returns an invalid result when value is null for non-null argument" do
+        invalid_input = MinimumInputObject.new({"a" => "Test", "b" => nil})
+        result = input_type.validate_isolated_input(invalid_input)
+        assert(!result.valid?)
+      end
+
+      it "returns valid result when value is null for nullable argument" do
+        invalid_input = MinimumInputObject.new({"a" => nil, "b" => 1})
+        result = input_type.validate_isolated_input(invalid_input)
+        assert(result.valid?)
+      end
+    end
+
+    describe "validate_input with enumerable input" do
+      describe "with good input" do
+        let(:input) do
+          {
+            "source" => "COW",
+            "fatContent" => 0.4
+          }
+        end
+        let(:result) { input_object.validate_isolated_input(input) }
+
+        it "returns a valid result" do
+          assert(result.valid?)
+        end
+      end
+
+      if ActionPack::VERSION::MAJOR > 3
+        describe "with a ActionController::Parameters" do
+          let(:input) do
+            ActionController::Parameters.new(
+              "source" => "COW",
+              "fatContent" => 0.4,
+            )
+          end
+          let(:result) { input_object.validate_isolated_input(input) }
+
+          it "returns a valid result" do
+            assert(result.valid?)
+          end
+        end
+      end
+
+      describe "with bad enum and float" do
+        let(:result) { input_object.validate_isolated_input({"source" => "KOALA", "fatContent" => "bad_num"}) }
+
+        it "returns an invalid result" do
+          assert(!result.valid?)
+        end
+
+        it "has problems with correct paths" do
+          paths = result.problems.map { |p| p["path"] }
+          assert(paths.include?(["source"]))
+          assert(paths.include?(["fatContent"]))
+        end
+
+        it "has correct problem explanation" do
+          expected = Dummy::DairyAnimal.graphql_definition.validate_isolated_input("KOALA").problems[0]["explanation"]
+
+          source_problem = result.problems.detect { |p| p["path"] == ["source"] }
+          actual = source_problem["explanation"]
+
+          assert_equal(expected, actual)
+        end
+      end
+
+      describe 'with a string as input' do
+        let(:result) { input_object.validate_isolated_input("just a string") }
+
+        it "returns an invalid result" do
+          assert(!result.valid?)
+        end
+
+        it "has problem with correct path" do
+          paths = result.problems.map { |p| p["path"] }
+          assert(paths.include?([]))
+        end
+
+        it "has correct problem explanation" do
+          assert(result.problems[0]["explanation"].include?("to be a key, value object"))
+        end
+      end
+
+      describe 'with an array as input' do
+        let(:result) { input_object.validate_isolated_input(["string array"]) }
+
+        it "returns an invalid result" do
+          assert(!result.valid?)
+        end
+
+        it "has problem with correct path" do
+          paths = result.problems.map { |p| p["path"] }
+          assert(paths.include?([]))
+        end
+
+        it "has correct problem explanation" do
+          assert(result.problems[0]["explanation"].include?("to be a key, value object"))
+        end
+      end
+
+      describe 'with a int as input' do
+        let(:result) { input_object.validate_isolated_input(10) }
+
+        it "returns an invalid result" do
+          assert(!result.valid?)
+        end
+
+        it "has problem with correct path" do
+          paths = result.problems.map { |p| p["path"] }
+          assert(paths.include?([]))
+        end
+
+        it "has correct problem explanation" do
+          assert(result.problems[0]["explanation"].include?("to be a key, value object"))
+        end
+      end
+
+      describe "with extra argument" do
+        let(:result) { input_object.validate_isolated_input({"source" => "COW", "fatContent" => 0.4, "isDelicious" => false}) }
+
+        it "returns an invalid result" do
+          assert(!result.valid?)
+        end
+
+        it "has problem with correct path" do
+          paths = result.problems.map { |p| p["path"] }
+          assert_equal([["isDelicious"]], paths)
+        end
+
+        it "has correct problem explanation" do
+          assert(result.problems[0]["explanation"].include?("Field is not defined"))
+        end
+      end
+
+      describe "list with one invalid element" do
+        let(:list_type) { GraphQL::ListType.new(of_type: Dummy::DairyProductInput.graphql_definition) }
+        let(:result) do
+          list_type.validate_isolated_input([
+            { "source" => "COW", "fatContent" => 0.4 },
+            { "source" => "KOALA", "fatContent" => 0.4 }
+          ])
+        end
+
+        it "returns an invalid result" do
+          assert(!result.valid?)
+        end
+
+        it "has one problem" do
+          assert_equal(result.problems.length, 1)
+        end
+
+        it "has problem with correct path" do
+          path = result.problems[0]["path"]
+          assert_equal(path, [1, "source"])
+        end
+
+        it "has problem with correct explanation" do
+          expected = Dummy::DairyAnimal.graphql_definition.validate_isolated_input("KOALA").problems[0]["explanation"]
+          actual = result.problems[0]["explanation"]
+          assert_equal(expected, actual)
+        end
+      end
+
+      describe 'with invalid name' do
+        it 'raises the correct error' do
+          assert_raises(GraphQL::InvalidNameError) do
+            InvalidInputTest = GraphQL::InputObjectType.define do
+              name "Some::Invalid Name"
+            end
+
+            # Force evaluation
+            InvalidInputTest.name
+          end
+        end
+      end
+    end
+  end
+
+  describe "coerce_result" do
+    it "omits unspecified arguments" do
+      result = input_object.coerce_isolated_result({fatContent: 0.3})
+      assert_equal ["fatContent"], result.keys
+      assert_equal 0.3, result["fatContent"]
+    end
+  end
+
+  describe "coercion of null inputs" do
+    let(:schema) { GraphQL::Schema.from_definition(%|
+      type Query {
+        a: Int
+      }
+
+      input ExampleInputObject {
+        a: String
+        b: Int!
+        c: String = "Default"
+        d: Boolean = false
+      }
+
+      input SecondLevelInputObject {
+        example: ExampleInputObject = {b: 42, d: true}
+      }
+    |) }
+    let(:input_type) { schema.types['ExampleInputObject'] }
+
+    it "null values are returned in coerced input" do
+      input = MinimumInputObject.new({"a" => "Test", "b" => nil,"c" => "Test"})
+      result = input_type.coerce_isolated_input(input)
+
+      assert_equal 'Test', result['a']
+
+      assert result.key?('b')
+      assert_nil result['b']
+
+      assert_equal "Test", result['c']
+    end
+
+    it "null values are preserved when argument has a default value" do
+      input = MinimumInputObject.new({"a" => "Test", "b" => 1, "c" => nil})
+      result = input_type.coerce_isolated_input(input)
+
+      assert_equal 'Test', result['a']
+      assert_equal 1, result['b']
+
+      assert result.key?('c')
+      assert_nil result['c']
+    end
+
+    it "omitted arguments are not returned" do
+      input = MinimumInputObject.new({"b" => 1, "c" => "Test"})
+      result = input_type.coerce_isolated_input(input)
+
+      assert !result.key?('a')
+      assert_equal 1, result['b']
+      assert_equal 'Test', result['c']
+    end
+
+    it "false default values are returned" do
+      input = MinimumInputObject.new({"b" => 1})
+      result = input_type.coerce_isolated_input(input)
+
+      assert_equal false, result['d']
+    end
+
+    it "merges defaults of nested input objects" do
+      result = schema.types['SecondLevelInputObject'].coerce_isolated_input({})
+      assert_equal 42, result['example']['b']
+      assert_equal "Default", result['example']['c']
+      assert_equal true, result['example']['d']
+    end
+  end
+
+  describe "when sent into a query" do
+    let(:variables) { {} }
+    let(:result) { Dummy::Schema.execute(query_string, variables: variables) }
+
+    describe "list inputs" do
+      let(:variables) { {"search" => [MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4})]} }
+      let(:query_string) {%|
+        query getCheeses($search: [DairyProductInput]!){
+            sheep: searchDairy(product: [{source: SHEEP, fatContent: 0.1}]) {
+              ... cheeseFields
+            }
+            cow: searchDairy(product: $search) {
+              ... cheeseFields
+            }
+        }
+
+        fragment cheeseFields on Cheese {
+          flavor
+        }
+      |}
+
+      it "converts items to plain values" do
+        sheep_value = result["data"]["sheep"]["flavor"]
+        cow_value = result["data"]["cow"]["flavor"]
+        assert_equal("Manchego", sheep_value)
+        assert_equal("Brie", cow_value)
+      end
+    end
+
+    describe "scalar inputs" do
+      let(:query_string) {%|
+        {
+          cheese(id: 1.4) {
+            flavor
+          }
+        }
+      |}
+
+      it "converts them to the correct type" do
+        cheese_name = result["data"]["cheese"]["flavor"]
+        assert_equal("Brie", cheese_name)
+      end
+    end
+  end
+
+  describe "#dup" do
+    it "shallow-copies internal state" do
+      input_object_2 = input_object.dup
+      input_object_2.arguments["nonsense"] = GraphQL::Argument.define(name: "int", type: GraphQL::INT_TYPE)
+      assert_equal 5, input_object.arguments.size
+      assert_equal 6, input_object_2.arguments.size
+    end
+  end
+end

data/spec/{graphql → integration/rails/graphql}/query/variables_spec.rb

@@ -69,21 +69,21 @@ describe GraphQL::Query::Variables do
       it "checks for string matches" do
         # These get merged into all the values above
         default_values = {
-          "originDairy"=>"Sugar Hollow Dairy",
-          "organic"=>false,
-          "order_by"=>{"direction"=>"ASC"}
+          origin_dairy: "Sugar Hollow Dairy",
+          organic: false,
+          order_by: { direction: "ASC" },
         }
 
         expected_input_1 = {
-          "source" => 1,
-          "fatContent" => 0.99,
+          source: 1,
+          fat_content: 0.99,
         }.merge(default_values)
 
         assert_equal(expected_input_1, variables["dairy_product_1"].to_h)
 
         expected_input_2 = {
-          "source" => :donkey,
-          "fatContent" => 0.89,
+          source: :donkey,
+          fat_content: 0.89,
         }.merge(default_values)
         assert_equal(expected_input_2, variables["dairy_product_2"].to_h)
       end

data/spec/{graphql → integration/rails/graphql}/relay/array_connection_spec.rb

@@ -43,8 +43,8 @@ describe GraphQL::Relay::ArrayConnection do
       assert_equal(2, number_of_ships)
       assert_equal(true, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
       assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
-      assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
-      assert_equal("Mg==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
+      assert_equal("MQ", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
+      assert_equal("Mg", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
 
       result = star_wars_query(query_string, "first" => 3)
       number_of_ships = get_names(result).length
@@ -55,14 +55,14 @@ describe GraphQL::Relay::ArrayConnection do
       result = star_wars_query(query_string, "first" => 2)
       assert_equal(true, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
       assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
-      assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
-      assert_equal("Mg==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
+      assert_equal("MQ", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
+      assert_equal("Mg", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
 
       result = star_wars_query(query_string, "first" => 100)
       assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
       assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
-      assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
-      assert_equal("NQ==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
+      assert_equal("MQ", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
+      assert_equal("NQ", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
     end
 
     it "provides bidirectional_pagination" do
@@ -166,8 +166,8 @@ describe GraphQL::Relay::ArrayConnection do
 
       assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
       assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
-      assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
-      assert_equal("NQ==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
+      assert_equal("MQ", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
+      assert_equal("NQ", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
       assert_equal(5, result["data"]["rebels"]["ships"]["edges"].length)
     end
 
@@ -217,7 +217,7 @@ describe GraphQL::Relay::ArrayConnection do
         assert_equal(["Yavin", "Echo Base"], get_names(result))
         assert_equal(false, get_page_info(result)["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
 
-        third_cursor = "Mw=="
+        third_cursor = "Mw"
         first_and_second_names = ["Yavin", "Echo Base"]
         result = star_wars_query(query_string, "last" => 100, "before" => third_cursor)
         assert_equal(first_and_second_names, get_names(result))

data/spec/{graphql → integration/rails/graphql}/relay/base_connection_spec.rb

@@ -77,11 +77,11 @@ describe GraphQL::Relay::BaseConnection do
       assert_equal "Person/1", conn.decode("1/nosreP")
     end
 
-    it "defaults to base64" do
+    it "defaults to base64 (urlsafe_base64 without padding)" do
       conn = GraphQL::Relay::BaseConnection.new([], {}, context: nil)
 
-      assert_equal "UGVyc29uLzE=", conn.encode("Person/1")
-      assert_equal "Person/1", conn.decode("UGVyc29uLzE=")
+      assert_equal "UGVyc29uLzE", conn.encode("Person/1")
+      assert_equal "Person/1", conn.decode("UGVyc29uLzE=") # can decode with padding
     end
 
     it "handles trimmed base64" do
@@ -89,5 +89,13 @@ describe GraphQL::Relay::BaseConnection do
 
       assert_equal "Person/1", conn.decode("UGVyc29uLzE")
     end
+
+    it "raises an execution error when an invalid cursor is given" do
+      conn = GraphQL::Relay::BaseConnection.new([], {}, context: nil)
+
+      assert_raises(GraphQL::ExecutionError) do
+        conn.decode("0")
+      end
+    end
   end
 end

data/spec/{graphql → integration/rails/graphql}/relay/connection_instrumentation_spec.rb

@@ -11,11 +11,6 @@ describe GraphQL::Relay::ConnectionInstrumentation do
     assert_equal ["tests"], test_type.fields.keys
   end
 
-  it "keeps a reference to the function" do
-    conn_field = StarWars::Faction.graphql_definition.fields["shipsWithMaxPageSize"]
-    assert_instance_of StarWars::ShipsWithMaxPageSize, conn_field.function
-  end
-
   let(:build_schema) {
     test_type = nil
 
@@ -58,26 +53,28 @@ describe GraphQL::Relay::ConnectionInstrumentation do
     assert_instance_of GraphQL::Relay::ConnectionResolve, redefined_connection_field.resolve_proc
   end
 
-  describe "after_built_ins instrumentation" do
-    it "has access to connection objects" do
-      query_str = <<-GRAPHQL
-      {
-        rebels {
-          ships {
-            pageInfo {
-              __typename
+  # field instrumentation doesn't exist here
+  if !TESTING_INTERPRETER
+    describe "after_built_ins instrumentation" do
+      it "has access to connection objects" do
+        query_str = <<-GRAPHQL
+        {
+          rebels {
+            ships {
+              pageInfo {
+                __typename
+              }
             }
           }
         }
-      }
-      GRAPHQL
-      ctx = { before_built_ins: [], after_built_ins: [] }
-      star_wars_query(query_str, {}, context: ctx)
-      # The second item is different here:
-      # Before the object is wrapped in a connection, the instrumentation sees `Array`
-      assert_equal ["StarWars::FactionRecord", "Array", "GraphQL::Relay::ArrayConnection"], ctx[:before_built_ins]
-      # After the object is wrapped in a connection, it sees the connection object
-      assert_equal ["StarWars::Faction", "StarWars::ShipConnectionWithParentType", "GraphQL::Types::Relay::PageInfo"], ctx[:after_built_ins]
+        GRAPHQL
+        ctx = { before_built_ins: [], after_built_ins: [] }
+        star_wars_query(query_str, {}, context: ctx)
+        # These are data classes, later they're wrapped with type proxies
+        assert_equal ["StarWars::FactionRecord", "GraphQL::Relay::ArrayConnection", "GraphQL::Relay::ArrayConnection"], ctx[:before_built_ins]
+        # After the object is wrapped in a connection, it sees the connection object
+        assert_equal ["StarWars::Faction", "StarWars::ShipConnectionWithParentType", "GraphQL::Types::Relay::PageInfo"], ctx[:after_built_ins]
+      end
     end
   end
 end

data/spec/{graphql → integration/rails/graphql}/relay/connection_resolve_spec.rb

@@ -53,6 +53,22 @@ describe GraphQL::Relay::ConnectionResolve do
     end
   end
 
+  describe "when a resolver is used" do
+    it "returns the items with the correct parent" do
+      resolver_query_str = <<-GRAPHQL
+        {
+          rebels {
+            shipsByResolver {
+              parentClassName
+            }
+          }
+        }
+        GRAPHQL
+      result = star_wars_query(resolver_query_str)
+      assert_equal "StarWars::FactionRecord", result["data"]["rebels"]["shipsByResolver"]["parentClassName"]
+    end
+  end
+
   describe "when nil is returned" do
     it "becomes null" do
       result = star_wars_query(query_string, { "name" => "null" })

data/spec/{graphql → integration/rails/graphql}/relay/mutation_spec.rb

@@ -336,4 +336,52 @@ describe GraphQL::Relay::Mutation do
       assert_equal(expected, result)
     end
   end
+
+  describe 'supports new input object definition with old mutation definition' do
+    let(:some_attribute_type) do
+      Class.new(GraphQL::Schema::InputObject) do
+        graphql_name 'SomeAttribute'
+        argument :something, String, required: false
+      end
+    end
+
+    let(:do_something_mutation) do
+      some_attribute = some_attribute_type
+
+      GraphQL::Relay::Mutation.define do
+        name 'DoSomethingMutation'
+        input_field :someAttributes, types[some_attribute.graphql_definition]
+
+        return_field :anything, types.String
+
+        resolve ->(_obj, inputs, _ctx) {
+          {
+            anything: inputs.to_h['someAttributes'][0].class.to_s
+          }
+        }
+      end
+    end
+
+    let(:mutation_type) do
+      do_something = do_something_mutation
+
+      Class.new(GraphQL::Schema::Object) do
+        graphql_name 'Mutation'
+        field :doSomething, field: do_something.field
+      end
+    end
+
+    let(:schema) do
+      mutation = mutation_type
+
+      Class.new(GraphQL::Schema) do
+        mutation mutation
+      end
+    end
+
+    it 'converts to hash the whole input' do
+      result = schema.execute('mutation { doSomething(input: {someAttributes: [{something: "string"}]}) { anything } }')
+      assert_equal 'Hash', result['data']['doSomething']['anything']
+    end
+  end
 end