graphql 1.0.0 → 1.1.0

data/spec/graphql/compatibility/query_parser_specification_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+BuiltInQueryParserSuite = GraphQL::Compatibility::QueryParserSpecification.build_suite do |query_string|
+  GraphQL::Language::Parser.parse(query_string)
+end

data/spec/graphql/compatibility/schema_parser_specification_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+BuiltInSchemaParserSuite = GraphQL::Compatibility::SchemaParserSpecification.build_suite do |query_string|
+  GraphQL::Language::Parser.parse(query_string)
+end

data/spec/graphql/define/instance_definable_spec.rb

@@ -73,6 +73,26 @@ describe GraphQL::Define::InstanceDefinable do
     end
   end
 
+  describe "#redefine" do
+    it "re-runs definitions without modifying the original object" do
+      arugula = Garden::Vegetable.define(name: "Arugula", color: :green)
+
+      red_arugula = arugula.redefine(color: :red)
+      renamed_red_arugula = red_arugula.redefine do
+        name "Renamed Red Arugula"
+      end
+
+      assert_equal :green, arugula.metadata[:color]
+      assert_equal "Arugula", arugula.name
+
+      assert_equal :red, red_arugula.metadata[:color]
+      assert_equal "Arugula", red_arugula.name
+
+      assert_equal :red, renamed_red_arugula.metadata[:color]
+      assert_equal "Renamed Red Arugula", renamed_red_arugula.name
+    end
+  end
+
   describe "#metadata" do
     it "gets values from definitions" do
       arugula = Garden::Vegetable.define(name: "Arugula", color: :green)

data/spec/graphql/directive_spec.rb

@@ -212,4 +212,15 @@ describe GraphQL::Directive do
       end
     end
   end
+
+  describe "defining a directive" do
+    it "can accept an array of arguments" do
+      directive = GraphQL::Directive.define do
+        arguments [GraphQL::Argument.define(name: 'skip')]
+      end
+
+      assert_equal 1, directive.arguments.length
+      assert_equal 'skip', directive.arguments.first.name
+    end
+  end
 end

data/spec/graphql/enum_type_spec.rb

@@ -15,6 +15,25 @@ describe GraphQL::EnumType do
   it "coerces result values to value's value" do
     assert_equal("YAK", enum.coerce_result("YAK"))
     assert_equal("COW", enum.coerce_result(1))
+    assert_equal("REINDEER", enum.coerce_result('reindeer'))
+    assert_equal("DONKEY", enum.coerce_result(:donkey))
+  end
+
+  it "raises when a result value can't be coerced" do
+    assert_raises(GraphQL::EnumType::UnresolvedValueError) {
+      enum.coerce_result(:nonsense)
+    }
+  end
+
+  describe "resolving with a warden" do
+    it "gets values from the warden" do
+      # OK
+      assert_equal("YAK", enum.coerce_result("YAK"))
+      # NOT OK
+      assert_raises(GraphQL::EnumType::UnresolvedValueError) {
+        enum.coerce_result("YAK", NothingWarden)
+      }
+    end
   end
 
   it "has value description" do
@@ -22,7 +41,7 @@ describe GraphQL::EnumType do
   end
 
   describe "validate_input with bad input" do
-    let(:result) { DairyAnimalEnum.validate_input("bad enum") }
+    let(:result) { DairyAnimalEnum.validate_input("bad enum", PermissiveWarden) }
 
     it "returns an invalid result" do
       assert(!result.valid?)

data/spec/graphql/input_object_type_spec.rb

@@ -13,18 +13,18 @@ describe GraphQL::InputObjectType do
   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 DairyProductInputType.valid_input?(values_obj)
+      assert DairyProductInputType.valid_input?(values_obj, PermissiveWarden)
     end
 
     describe "validate_input with non-enumerable input" do
       it "returns a valid result for MinimumInputObject" do
-        result = DairyProductInputType.validate_input(MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4}))
+        result = DairyProductInputType.validate_input(MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4}), PermissiveWarden)
         assert(result.valid?)
       end
 
       it "returns an invalid result for MinimumInvalidInputObject" do
         invalid_input = MinimumInputObject.new({"source" => "KOALA", "fatContent" => 0.4})
-        result = DairyProductInputType.validate_input(invalid_input)
+        result = DairyProductInputType.validate_input(invalid_input, PermissiveWarden)
         assert(!result.valid?)
       end
     end
@@ -37,7 +37,7 @@ describe GraphQL::InputObjectType do
             "fatContent" => 0.4
           }
         end
-        let(:result) { DairyProductInputType.validate_input(input) }
+        let(:result) { DairyProductInputType.validate_input(input, PermissiveWarden) }
 
         it "returns a valid result" do
           assert(result.valid?)
@@ -45,7 +45,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe "with bad enum and float" do
-        let(:result) { DairyProductInputType.validate_input("source" => "KOALA", "fatContent" => "bad_num") }
+        let(:result) { DairyProductInputType.validate_input({"source" => "KOALA", "fatContent" => "bad_num"}, PermissiveWarden) }
 
         it "returns an invalid result" do
           assert(!result.valid?)
@@ -58,7 +58,7 @@ describe GraphQL::InputObjectType do
         end
 
         it "has correct problem explanation" do
-          expected = DairyAnimalEnum.validate_input("KOALA").problems[0]["explanation"]
+          expected = DairyAnimalEnum.validate_input("KOALA", PermissiveWarden).problems[0]["explanation"]
 
           source_problem = result.problems.detect { |p| p["path"] == ["source"] }
           actual = source_problem["explanation"]
@@ -68,7 +68,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe "with extra argument" do
-        let(:result) { DairyProductInputType.validate_input("source" => "COW", "fatContent" => 0.4, "isDelicious" => false) }
+        let(:result) { DairyProductInputType.validate_input({"source" => "COW", "fatContent" => 0.4, "isDelicious" => false}, PermissiveWarden) }
 
         it "returns an invalid result" do
           assert(!result.valid?)
@@ -90,7 +90,7 @@ describe GraphQL::InputObjectType do
           list_type.validate_input([
             { "source" => "COW", "fatContent" => 0.4 },
             { "source" => "KOALA", "fatContent" => 0.4 }
-          ])
+          ], PermissiveWarden)
         end
 
         it "returns an invalid result" do
@@ -107,7 +107,7 @@ describe GraphQL::InputObjectType do
         end
 
         it "has problem with correct explanation" do
-          expected = DairyAnimalEnum.validate_input("KOALA").problems[0]["explanation"]
+          expected = DairyAnimalEnum.validate_input("KOALA", PermissiveWarden).problems[0]["explanation"]
           actual = result.problems[0]["explanation"]
           assert_equal(expected, actual)
         end

data/spec/graphql/introspection/directive_type_spec.rb

@@ -6,7 +6,7 @@ describe GraphQL::Introspection::DirectiveType do
       __schema {
         directives {
           name,
-          args { name, type { name, ofType { name } } },
+          args { name, type { kind, name, ofType { name } } },
           locations
           # Deprecated fields:
           onField
@@ -25,7 +25,7 @@ describe GraphQL::Introspection::DirectiveType do
           {
             "name" => "include",
             "args" => [
-              {"name"=>"if", "type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Boolean"}}}
+              {"name"=>"if", "type"=>{"kind"=>"NON_NULL", "name"=>nil, "ofType"=>{"name"=>"Boolean"}}}
             ],
             "locations"=>["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
             "onField" => true,
@@ -35,7 +35,7 @@ describe GraphQL::Introspection::DirectiveType do
           {
             "name" => "skip",
             "args" => [
-              {"name"=>"if", "type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Boolean"}}}
+              {"name"=>"if", "type"=>{"kind"=>"NON_NULL", "name"=>nil, "ofType"=>{"name"=>"Boolean"}}}
             ],
             "locations"=>["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
             "onField" => true,
@@ -45,7 +45,7 @@ describe GraphQL::Introspection::DirectiveType do
           {
             "name" => "deprecated",
             "args" => [
-              {"name"=>"reason", "type"=>{"name"=>"String", "ofType"=>nil}}
+              {"name"=>"reason", "type"=>{"kind"=>"SCALAR", "name"=>"String", "ofType"=>nil}}
             ],
             "locations"=>["FIELD_DEFINITION", "ENUM_VALUE"],
             "onField" => false,

data/spec/graphql/introspection/input_value_type_spec.rb

@@ -10,7 +10,7 @@ describe GraphQL::Introspection::InputValueType do
          kind,
          inputFields {
            name,
-           type { name },
+           type { kind, name },
            defaultValue
            description
          }
@@ -26,13 +26,13 @@ describe GraphQL::Introspection::InputValueType do
           "description"=>"Properties for finding a dairy product",
           "kind"=>"INPUT_OBJECT",
           "inputFields"=>[
-            {"name"=>"source", "type"=>{ "name" => "Non-Null"}, "defaultValue"=>nil,
+            {"name"=>"source", "type"=>{"kind"=>"NON_NULL", "name" => nil}, "defaultValue"=>nil,
              "description" => "Where it came from"},
-            {"name"=>"originDairy", "type"=>{ "name" => "String"}, "defaultValue"=>"\"Sugar Hollow Dairy\"",
+            {"name"=>"originDairy", "type"=>{"kind"=>"SCALAR", "name" => "String"}, "defaultValue"=>"\"Sugar Hollow Dairy\"",
              "description" => "Dairy which produced it"},
-            {"name"=>"fatContent", "type"=>{ "name" => "Float"}, "defaultValue"=>"0.3",
+            {"name"=>"fatContent", "type"=>{"kind"=>"SCALAR",  "name" => "Float"}, "defaultValue"=>"0.3",
              "description" => "How much fat it has"},
-            {"name"=>"organic", "type"=>{ "name" => "Boolean"}, "defaultValue"=>"false",
+            {"name"=>"organic", "type"=>{"kind"=>"SCALAR",  "name" => "Boolean"}, "defaultValue"=>"false",
              "description" => nil}
           ]
         }
@@ -58,7 +58,7 @@ describe GraphQL::Introspection::InputValueType do
 
   it "converts default values to GraphQL values" do
     field = cheese_type['data']['__type']['fields'].detect { |f| f['name'] == 'similarCheese' }
-    arg = field['args'].detect { |a| a['name'] == 'source' }
+    arg = field['args'].detect { |a| a['name'] == 'nullableSource' }
 
     assert_equal('["COW"]', arg['defaultValue'])
   end

data/spec/graphql/introspection/type_type_spec.rb

@@ -3,8 +3,8 @@ require "spec_helper"
 describe GraphQL::Introspection::TypeType do
   let(:query_string) {%|
      query introspectionQuery {
-       cheeseType:    __type(name: "Cheese") { name, kind, fields { name, isDeprecated, type { name, ofType { name } } } }
-       milkType:      __type(name: "Milk") { interfaces { name }, fields { type { name, ofType { name } } } }
+       cheeseType:    __type(name: "Cheese") { name, kind, fields { name, isDeprecated, type { kind, name, ofType { name } } } }
+       milkType:      __type(name: "Milk") { interfaces { name }, fields { type { kind, name, ofType { name } } } }
        dairyAnimal:   __type(name: "DairyAnimal") { name, kind, enumValues(includeDeprecated: false) { name, isDeprecated } }
        dairyProduct:  __type(name: "DairyProduct") { name, kind, possibleTypes { name } }
        animalProduct: __type(name: "AnimalProduct") { name, kind, possibleTypes { name }, fields { name } }
@@ -13,19 +13,21 @@ describe GraphQL::Introspection::TypeType do
   |}
   let(:result) { DummySchema.execute(query_string, context: {}, variables: {"cheeseId" => 2}) }
   let(:cheese_fields) {[
-    {"name"=>"deeplyNullableCheese", "isDeprecated"=>false, "type"=>{"name"=>"Cheese", "ofType"=>nil}},
-    {"name"=>"flavor",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "String"}}},
-    {"name"=>"id",          "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "Int"}}},
-    {"name"=>"nullableCheese", "isDeprecated"=>false, "type"=>{"name"=>"Cheese", "ofType"=>nil}},
-    {"name"=>"origin",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "String"}}},
-    {"name"=>"similarCheese", "isDeprecated"=>false, "type"=>{"name"=>"Cheese", "ofType"=>nil}},
-    {"name"=>"source",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "DairyAnimal"}}},
+    {"name"=>"deeplyNullableCheese", "isDeprecated" => false, "type"=>{ "kind" => "OBJECT", "name" => "Cheese", "ofType" => nil}},
+    {"name"=>"flavor",      "isDeprecated" => false, "type" => { "kind" => "NON_NULL", "name" => nil, "ofType" => { "name" => "String"}}},
+    {"name"=>"id",          "isDeprecated" => false, "type" => { "kind" => "NON_NULL", "name" => nil, "ofType" => { "name" => "Int"}}},
+    {"name"=>"nullableCheese", "isDeprecated"=>false, "type"=>{ "kind" => "OBJECT",  "name" => "Cheese", "ofType"=>nil}},
+    {"name"=>"origin",      "isDeprecated" => false, "type" => { "kind" => "NON_NULL", "name" => nil, "ofType" => { "name" => "String"}}},
+    {"name"=>"similarCheese", "isDeprecated"=>false, "type"=>{ "kind" => "OBJECT", "name"=>"Cheese", "ofType"=>nil}},
+    {"name"=>"source",      "isDeprecated" => false, "type" => { "kind" => "NON_NULL", "name" => nil, "ofType" => { "name" => "DairyAnimal"}}},
   ]}
 
   let(:dairy_animals) {[
-    {"name"=>"COW",   "isDeprecated"=> false },
-    {"name"=>"GOAT",  "isDeprecated"=> false },
-    {"name"=>"SHEEP", "isDeprecated"=> false },
+    {"name"=>"COW",       "isDeprecated"=> false },
+    {"name"=>"DONKEY",    "isDeprecated"=> false },
+    {"name"=>"GOAT",      "isDeprecated"=> false },
+    {"name"=>"REINDEER",  "isDeprecated"=> false },
+    {"name"=>"SHEEP",     "isDeprecated"=> false },
   ]}
   it "exposes metadata about types" do
     expected = {"data"=> {
@@ -41,13 +43,13 @@ describe GraphQL::Introspection::TypeType do
           {"name"=>"LocalProduct"},
         ],
         "fields"=>[
-          {"type"=>{"name"=>"List", "ofType"=>{"name"=>"DairyProduct"}}},
-          {"type"=>{"name"=>"String", "ofType"=>nil}},
-          {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Float"}}},
-          {"type"=>{"name"=>"List", "ofType"=>{"name"=>"String"}}},
-          {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"ID"}}},
-          {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"String"}}},
-          {"type"=>{"name"=>"DairyAnimal", "ofType"=>nil}},
+          {"type"=>{"kind"=>"LIST","name"=>nil, "ofType"=>{"name"=>"DairyProduct"}}},
+          {"type"=>{"kind"=>"SCALAR","name"=>"String", "ofType"=>nil}},
+          {"type"=>{"kind"=>"NON_NULL","name"=>nil, "ofType"=>{"name"=>"Float"}}},
+          {"type"=>{"kind"=>"LIST","name"=>nil, "ofType"=>{"name"=>"String"}}},
+          {"type"=>{"kind"=>"NON_NULL","name"=>nil, "ofType"=>{"name"=>"ID"}}},
+          {"type"=>{"kind"=>"NON_NULL","name"=>nil, "ofType"=>{"name"=>"String"}}},
+          {"type"=>{"kind"=>"ENUM","name"=>"DairyAnimal", "ofType"=>nil}},
         ]
       },
       "dairyAnimal"=>{
@@ -76,11 +78,11 @@ describe GraphQL::Introspection::TypeType do
   describe "deprecated fields" do
     let(:query_string) {%|
        query introspectionQuery {
-         cheeseType:    __type(name: "Cheese") { name, kind, fields(includeDeprecated: true) { name, isDeprecated, type { name, ofType { name } } } }
+         cheeseType:    __type(name: "Cheese") { name, kind, fields(includeDeprecated: true) { name, isDeprecated, type { kind, name, ofType { name } } } }
          dairyAnimal:   __type(name: "DairyAnimal") { name, kind, enumValues(includeDeprecated: true) { name, isDeprecated } }
        }
     |}
-    let(:deprecated_fields) { {"name"=>"fatContent", "isDeprecated"=>true, "type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Float"}}} }
+    let(:deprecated_fields) { {"name"=>"fatContent", "isDeprecated"=>true, "type"=>{"kind"=>"NON_NULL","name"=>nil, "ofType"=>{"name"=>"Float"}}} }
 
     it "can expose deprecated fields" do
       new_cheese_fields = ([deprecated_fields] + cheese_fields).sort_by { |f| f["name"] }
@@ -102,7 +104,7 @@ describe GraphQL::Introspection::TypeType do
     describe "input objects" do
       let(:query_string) {%|
          query introspectionQuery {
-           __type(name: "DairyProductInput") { name, description, kind, inputFields { name, type { name }, defaultValue } }
+           __type(name: "DairyProductInput") { name, description, kind, inputFields { name, type { kind, name }, defaultValue } }
          }
       |}
 
@@ -113,10 +115,10 @@ describe GraphQL::Introspection::TypeType do
               "description"=>"Properties for finding a dairy product",
               "kind"=>"INPUT_OBJECT",
               "inputFields"=>[
-                {"name"=>"source", "type"=>{ "name" => "Non-Null"}, "defaultValue"=>nil},
-                {"name"=>"originDairy", "type"=>{"name"=>"String"}, "defaultValue"=>"\"Sugar Hollow Dairy\""},
-                {"name"=>"fatContent", "type"=>{ "name" => "Float"}, "defaultValue"=>"0.3"},
-                {"name"=>"organic", "type"=>{ "name" => "Boolean"}, "defaultValue"=>"false"},
+                {"name"=>"source", "type"=>{"kind"=>"NON_NULL","name"=>nil, }, "defaultValue"=>nil},
+                {"name"=>"originDairy", "type"=>{"kind"=>"SCALAR","name"=>"String"}, "defaultValue"=>"\"Sugar Hollow Dairy\""},
+                {"name"=>"fatContent", "type"=>{"kind"=>"SCALAR","name" => "Float"}, "defaultValue"=>"0.3"},
+                {"name"=>"organic", "type"=>{"kind"=>"SCALAR","name" => "Boolean"}, "defaultValue"=>"false"},
               ]
             }
           }}

data/spec/graphql/language/parser_spec.rb

@@ -1,8 +1,6 @@
 require "spec_helper"
-require 'graphql/language/parser_tests'
 
 describe GraphQL::Language::Parser do
-  include GraphQL::Language::ParserTests
   subject { GraphQL::Language::Parser }
 
   describe "anonymous fragment extension" do
@@ -13,23 +11,35 @@ describe GraphQL::Language::Parser do
       }
     |}
 
-    describe ".parse" do
-      it "parses queries" do
-        assert document
-      end
+    let(:fragment) { document.definitions.first }
 
-      describe "visited nodes" do
-        let(:fragment) { document.definitions.first }
+    it "creates an anonymous fragment definition" do
+      assert fragment.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+      assert_equal nil, fragment.name
+      assert_equal 1, fragment.selections.length
+      assert_equal "NestedType", fragment.type.name
+      assert_equal 1, fragment.directives.length
+      assert_equal [2, 7], fragment.position
+    end
+  end
 
-        it "creates an anonymous fragment definition" do
-          assert fragment.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-          assert_equal nil, fragment.name
-          assert_equal 1, fragment.selections.length
-          assert_equal "NestedType", fragment.type.name
-          assert_equal 1, fragment.directives.length
-          assert_equal [2, 7], fragment.position
-        end
-      end
+  it "parses empty arguments" do
+    strings = [
+      "{ field { inner } }",
+      "{ field() { inner }}",
+    ]
+    strings.each do |query_str|
+      doc = subject.parse(query_str)
+      field = doc.definitions.first.selections.first
+      assert_equal 0, field.arguments.length
+      assert_equal 1, field.selections.length
     end
   end
+
+  it "parses the test schema" do
+    schema = DummySchema
+    schema_string = GraphQL::Schema::Printer.print_schema(schema)
+    document = subject.parse(schema_string)
+    assert_equal schema_string, document.to_query_string
+  end
 end

data/spec/graphql/list_type_spec.rb

@@ -9,7 +9,7 @@ describe GraphQL::ListType do
 
   describe "validate_input with bad input" do
     let(:bad_num) { "bad_num" }
-    let(:result) { float_list.validate_input([bad_num, 2.0, 3.0]) }
+    let(:result) { float_list.validate_input([bad_num, 2.0, 3.0], PermissiveWarden) }
 
     it "returns an invalid result" do
       assert(!result.valid?)
@@ -24,7 +24,7 @@ describe GraphQL::ListType do
     end
 
     it "has the correct explanation" do
-      expected = GraphQL::FLOAT_TYPE.validate_input(bad_num).problems[0]["explanation"]
+      expected = GraphQL::FLOAT_TYPE.validate_input(bad_num, PermissiveWarden).problems[0]["explanation"]
       actual = result.problems[0]["explanation"]
       assert_equal(actual, expected)
     end

data/spec/graphql/query/variables_spec.rb

@@ -11,6 +11,7 @@ describe GraphQL::Query::Variables do
   let(:ast_variables) { GraphQL.parse(query_string).definitions.first.variables }
   let(:variables) { GraphQL::Query::Variables.new(
     DummySchema,
+    GraphQL::Schema::Warden.new(DummySchema, GraphQL::Query::NullExcept),
     ast_variables,
     provided_variables)
   }

data/spec/graphql/scalar_type_spec.rb

@@ -23,7 +23,7 @@ describe GraphQL::ScalarType do
   end
 
   describe "custom scalar errors" do
-    let(:result) { custom_scalar.validate_input("xyz") }
+    let(:result) { custom_scalar.validate_input("xyz", PermissiveWarden) }
 
     it "returns an invalid result" do
       assert !result.valid?
@@ -32,7 +32,7 @@ describe GraphQL::ScalarType do
   end
 
   describe "validate_input with good input" do
-    let(:result) { GraphQL::INT_TYPE.validate_input(150) }
+    let(:result) { GraphQL::INT_TYPE.validate_input(150, PermissiveWarden) }
 
     it "returns a valid result" do
       assert(result.valid?)
@@ -40,7 +40,7 @@ describe GraphQL::ScalarType do
   end
 
   describe "validate_input with bad input" do
-    let(:result) { GraphQL::INT_TYPE.validate_input("bad num") }
+    let(:result) { GraphQL::INT_TYPE.validate_input("bad num", PermissiveWarden) }
 
     it "returns an invalid result for bad input" do
       assert(!result.valid?)