graphql 0.11.1 → 0.12.0

data/spec/graphql/field_spec.rb

@@ -21,6 +21,7 @@ describe GraphQL::Field do
   describe '.property ' do
     let(:field) do
       GraphQL::Field.define do
+        name 'field_name'
         # satisfies 'can define by config' below
         property :internal_prop
       end
@@ -37,7 +38,7 @@ describe GraphQL::Field do
 
     describe 'default resolver' do
       def acts_like_default_resolver(field, old_prop, new_prop)
-        object = OpenStruct.new(old_prop => 'old value', new_prop => 'new value')
+        object = OpenStruct.new(old_prop => 'old value', new_prop => 'new value', field.name.to_sym => 'unset value')
 
         old_result = field.resolve(object, nil, nil)
         field.property = new_prop
@@ -47,7 +48,7 @@ describe GraphQL::Field do
 
         assert_equal(old_result, 'old value')
         assert_equal(new_result, 'new value')
-        assert_equal(unset_result, GraphQL::Query::DEFAULT_RESOLVE)
+        assert_equal(unset_result, 'unset value')
       end
 
       it 'responds to changes in property' do
@@ -60,4 +61,15 @@ describe GraphQL::Field do
       end
     end
   end
+
+  describe "#name" do
+    it "can't be reassigned" do
+      field = GraphQL::Field.define do
+        name("something")
+      end
+      assert_equal "something", field.name
+      assert_raises { field.name = "somethingelse" }
+      assert_equal "something", field.name
+    end
+  end
 end

data/spec/graphql/float_type_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe GraphQL::FLOAT_TYPE do
+  describe "coerce_input" do
+    it "accepts ints and floats" do
+      assert_equal 1.0, GraphQL::FLOAT_TYPE.coerce_input(1)
+      assert_equal 6.1, GraphQL::FLOAT_TYPE.coerce_input(6.1)
+    end
+
+    it "rejects other types" do
+      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_input("55")
+      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_input(true)
+    end
+  end
+end

data/spec/graphql/id_type_spec.rb

@@ -20,4 +20,13 @@ describe GraphQL::ID_TYPE do
       assert_equal(expected, result)
     end
   end
+
+  describe 'coercion for other types' do
+    let(:query_string) { %|query getMilk { cow: milk(id: 1.0) { id } }| }
+
+    it "doesn't allow other types" do
+      assert_equal nil, result["data"]
+      assert_equal 1, result["errors"].length
+    end
+  end
 end

data/spec/graphql/int_type_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe GraphQL::INT_TYPE do
+  describe "coerce_input" do
+    it "accepts ints and floats" do
+      assert_equal 1, GraphQL::INT_TYPE.coerce_input(1)
+      assert_equal 6, GraphQL::INT_TYPE.coerce_input(6.1)
+    end
+
+    it "rejects other types" do
+      assert_equal nil, GraphQL::INT_TYPE.coerce_input("55")
+      assert_equal nil, GraphQL::INT_TYPE.coerce_input(true)
+    end
+  end
+end

data/spec/graphql/introspection/input_value_type_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+
+describe GraphQL::Introspection::InputValueType do
+  let(:query_string) {%|
+     {
+       __type(name: "DairyProductInput") {
+         name,
+         description,
+         kind,
+         inputFields {
+           name,
+           type { name },
+           defaultValue
+         }
+       }
+     }
+  |}
+  let(:result) { DummySchema.execute(query_string)}
+
+  it 'exposes metadata about input objects, giving extra quotes for strings' do
+    expected = { "data" => {
+        "__type" => {
+          "name"=>"DairyProductInput",
+          "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"=>nil}
+          ]
+        }
+      }}
+    assert_equal(expected, result)
+  end
+end

data/spec/graphql/introspection/type_type_spec.rb

@@ -90,28 +90,5 @@ describe GraphQL::Introspection::TypeType do
       }}
       assert_equal(expected, result)
     end
-
-    describe 'input objects' do
-      let(:query_string) {%|
-         query introspectionQuery {
-           __type(name: "DairyProductInput") { name, description, kind, inputFields { name, type { name }, defaultValue } }
-         }
-      |}
-
-      it 'exposes metadata about input objects' do
-        expected = { "data" => {
-            "__type" => {
-              "name"=>"DairyProductInput",
-              "description"=>"Properties for finding a dairy product",
-              "kind"=>"INPUT_OBJECT",
-              "inputFields"=>[
-                {"name"=>"source", "type"=>{ "name" => "Non-Null"}, "defaultValue"=>nil},
-                {"name"=>"fatContent", "type"=>{ "name" => "Float"}, "defaultValue"=>nil}
-              ]
-            }
-          }}
-        assert_equal(expected, result)
-      end
-    end
   end
 end

data/spec/graphql/query_spec.rb

@@ -30,6 +30,7 @@ describe GraphQL::Query do
   |}
   let(:debug) { false }
   let(:operation_name) { nil }
+  let(:max_depth) { nil }
   let(:query_variables) { {"cheeseId" => 2} }
   let(:schema) { DummySchema }
   let(:query) { GraphQL::Query.new(
@@ -38,6 +39,7 @@ describe GraphQL::Query do
     variables: query_variables,
     debug: debug,
     operation_name: operation_name,
+    max_depth: max_depth,
   )}
   let(:result) { query.result }
   describe '#result' do
@@ -317,4 +319,18 @@ describe GraphQL::Query do
       end
     end
   end
+
+  describe "#max_depth" do
+    it "defaults to the schema's max_depth" do
+      assert_equal 5, query.max_depth
+    end
+
+    describe "overriding max_depth" do
+      let(:max_depth) { 12 }
+
+      it "overrides the schema's max_depth" do
+        assert_equal 12, query.max_depth
+      end
+    end
+  end
 end

data/spec/graphql/static_validation/complexity_validator_spec.rb

@@ -1,7 +1,7 @@
 # require "spec_helper"
 #
 # describe GraphQL::StaticValidation::ComplexityValidator do
-#   let(:document) { GraphQL.parse(query_string)}
+#   let(:query_string) {query_string)}
 #   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [complexity_validator]) }
 #   let(:errors) { validator.validate(document) }
 #   let(:complexity_validator) { GraphQL::StaticValidation::ComplexityValidator.new(max_fields: 6, list_multiplier: 2) }

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
-  let(:document) { GraphQL.parse(%|
+  let(:query_string) {%|
     query getCheese {
       cheese(id: "aasdlkfj") { source }
       cheese(id: 1) { source @skip(if: {id: 1})}
@@ -15,10 +15,11 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
     fragment cheeseFields on Cheese {
       similarCheese(source: 4.5)
     }
-  |)}
+  |}
 
   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::ArgumentLiteralsAreCompatible]) }
-  let(:errors) { validator.validate(document) }
+  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:errors) { validator.validate(query) }
 
   it 'finds undefined or missing-required arguments to fields and directives' do
     assert_equal(6, errors.length)

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GraphQL::StaticValidation::ArgumentsAreDefined do
-  let(:document) { GraphQL.parse("
+  let(:query_string) {"
     query getCheese {
       cheese(id: 1) { source }
       cheese(silly: false) { source }
@@ -12,10 +12,11 @@ describe GraphQL::StaticValidation::ArgumentsAreDefined do
       similarCheese(source: SHEEP, nonsense: 1)
       id @skip(something: 3.4)
     }
-  ")}
+  "}
 
   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::ArgumentsAreDefined]) }
-  let(:errors) { validator.validate(document) }
+  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:errors) { validator.validate(query) }
 
   it 'finds undefined arguments to fields and directives' do
     assert_equal(4, errors.length)

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GraphQL::StaticValidation::DirectivesAreDefined do
-  let(:document) { GraphQL.parse("
+  let(:query_string) {"
     query getCheese {
       okCheese: cheese(id: 1) {
         id @skip(if: true),
@@ -11,10 +11,11 @@ describe GraphQL::StaticValidation::DirectivesAreDefined do
         }
       }
     }
-  ")}
+  "}
 
   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::DirectivesAreDefined]) }
-  let(:errors) { validator.validate(document) }
+  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:errors) { validator.validate(query) }
 
   describe 'non-existent directives' do
     it 'makes errors for them' do

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

@@ -3,7 +3,8 @@ require "spec_helper"
 describe GraphQL::StaticValidation::DocumentDoesNotExceedMaxDepth do
   let(:rule) { GraphQL::StaticValidation::DocumentDoesNotExceedMaxDepth }
   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [rule]) }
-  let(:errors) { validator.validate(GraphQL.parse(query_string)) }
+  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:errors) { validator.validate(query) }
 
   let(:query_string) { "
     {
@@ -29,6 +30,13 @@ describe GraphQL::StaticValidation::DocumentDoesNotExceedMaxDepth do
     end
   end
 
+  describe "when the query specifies a different max_depth" do
+    let(:query) { GraphQL::Query.new(DummySchema, query_string, max_depth: 100) }
+    it "obeys that max_depth" do
+      assert_equal 0, errors.length
+    end
+  end
+
   describe "When the query is not deeper than max_depth" do
     before do
       @prev_max_depth = DummySchema.max_depth

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

@@ -12,8 +12,9 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
   "}
 
   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FieldsAreDefinedOnType]) }
-  let(:errors) { validator.validate(GraphQL.parse(query_string)) }
-  let(:error_messages) { errors.map { |e| e["message" ] }}
+  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:errors) { validator.validate(query) }
+  let(:error_messages) { errors.map { |e| e["message"] } }
 
   it "finds fields that are requested on types that don't have that field" do
     expected_errors = [

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

@@ -1,16 +1,17 @@
 require 'spec_helper'
 
 describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do
-  let(:document) { GraphQL.parse("
+  let(:query_string) {"
     query getCheese {
       okCheese: cheese(id: 1) { fatContent, similarCheese(source: YAK) { source } }
       missingFieldsCheese: cheese(id: 1)
       illegalSelectionCheese: cheese(id: 1) { id { something, ... someFields } }
     }
-  ")}
+  "}
 
   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FieldsHaveAppropriateSelections]) }
-  let(:errors) { validator.validate(document) }
+  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:errors) { validator.validate(query) }
 
   it 'adds errors for selections on scalars' do
     assert_equal(2, errors.length)

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GraphQL::StaticValidation::FieldsWillMerge do
-  let(:document) { GraphQL.parse("
+  let(:query_string) {"
     query getCheese($sourceVar: DairyAnimal!) {
       cheese(id: 1) {
         id,
@@ -27,10 +27,11 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
       similarCow: similarCheese(source: COW) { similarCowSource: id, id }
       id @someFlag
     }
-  ")}
+  "}
 
   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FieldsWillMerge]) }
-  let(:errors) { validator.validate(document) }
+  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:errors) { validator.validate(query) }
   let(:error_messages) { errors.map { |e| e["message" ] }}
 
   it 'finds field naming conflicts' do

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GraphQL::StaticValidation::FragmentSpreadsArePossible do
-  let(:document) { GraphQL.parse(%|
+  let(:query_string) {%|
     query getCheese {
       cheese(id: 1) {
         ... milkFields
@@ -20,10 +20,11 @@ describe GraphQL::StaticValidation::FragmentSpreadsArePossible do
       fatContent
       ... milkFields
     }
-  |)}
+  |}
 
   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentSpreadsArePossible]) }
-  let(:errors) { validator.validate(document) }
+  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:errors) { validator.validate(query) }
 
   it "doesnt allow spreads where they'll never apply" do
     # TODO: more negative, abstract examples here, add stuff to the schema

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GraphQL::StaticValidation::FragmentTypesExist do
-  let(:document) { GraphQL.parse("
+  let(:query_string) {"
     query getCheese {
       cheeese(id: 1) {
         ... on Cheese { source }
@@ -17,10 +17,11 @@ describe GraphQL::StaticValidation::FragmentTypesExist do
     fragment cheeseFields on Cheese {
       fatContent
     }
-  ")}
+  "}
 
   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentTypesExist]) }
-  let(:errors) { validator.validate(document) }
+  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:errors) { validator.validate(query) }
 
   it 'finds non-existent types on fragments' do
     assert_equal(2, errors.length)

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GraphQL::StaticValidation::FragmentsAreFinite do
-  let(:document) { GraphQL.parse(%|
+  let(:query_string) {%|
     query getCheese {
       cheese(id: 1) {
         ... idField
@@ -22,10 +22,11 @@ describe GraphQL::StaticValidation::FragmentsAreFinite do
     fragment idField on Cheese {
       id
     }
-  |)}
+  |}
 
   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentsAreFinite]) }
-  let(:errors) { validator.validate(document) }
+  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:errors) { validator.validate(query) }
 
   it 'doesnt allow infinite loops' do
     expected = [

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GraphQL::StaticValidation::FragmentsAreOnCompositeTypes do
-  let(:document) { GraphQL.parse(%|
+  let(:query_string) {%|
     query getCheese {
       cheese(id: 1) {
         ... on Cheese {
@@ -23,10 +23,11 @@ describe GraphQL::StaticValidation::FragmentsAreOnCompositeTypes do
     fragment intFields on Int {
       something
     }
-  |)}
+  |}
 
   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentsAreOnCompositeTypes]) }
-  let(:errors) { validator.validate(document) }
+  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:errors) { validator.validate(query) }
 
   it 'requires Object/Union/Interface fragment types' do
     expected = [

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GraphQL::StaticValidation::FragmentsAreUsed do
-  let(:document) { GraphQL.parse("
+  let(:query_string) {"
     query getCheese {
       name,
       ...cheeseFields
@@ -9,10 +9,11 @@ describe GraphQL::StaticValidation::FragmentsAreUsed do
     }
     fragment cheeseFields on Cheese { fatContent }
     fragment unusedFields on Cheese { is, not, used }
-  ")}
+  "}
 
   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentsAreUsed]) }
-  let(:errors) { validator.validate(document) }
+  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:errors) { validator.validate(query) }
 
   it 'adds errors for unused fragment definitions' do
     assert_includes(errors, {"message"=>"Fragment unusedFields was defined, but not used", "locations"=>[{"line"=>8, "column"=>5}]})