graphql 1.4.0 → 1.4.1

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -2,8 +2,8 @@
 require "spec_helper"
 
 describe GraphQL::InternalRepresentation::Rewrite do
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: Dummy::Schema) }
+  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
   let(:rewrite_result) {
     validator.validate(query)[:irep]
   }
@@ -24,18 +24,18 @@ describe GraphQL::InternalRepresentation::Rewrite do
     it "produces a tree of nodes" do
       op_node = rewrite_result["getCheeses"]
 
-      root_children = op_node.typed_children[DairyAppQueryType]
+      root_children = op_node.typed_children[Dummy::DairyAppQueryType]
       assert_equal 2, root_children.length
-      assert_equal DairyAppQueryType, op_node.return_type
+      assert_equal Dummy::DairyAppQueryType, op_node.return_type
       first_field = root_children.values.first
-      assert_equal 3, first_field.typed_children[CheeseType].length
-      assert_equal DairyAppQueryType, first_field.owner_type
-      assert_equal CheeseType, first_field.return_type
+      assert_equal 3, first_field.typed_children[Dummy::CheeseType].length
+      assert_equal Dummy::DairyAppQueryType, first_field.owner_type
+      assert_equal Dummy::CheeseType, first_field.return_type
 
       second_field = root_children.values.last
-      assert_equal 1, second_field.typed_children[CheeseType].length
-      assert_equal DairyAppQueryType.get_field("cheese"), second_field.definition
-      assert_equal CheeseType, second_field.return_type
+      assert_equal 1, second_field.typed_children[Dummy::CheeseType].length
+      assert_equal Dummy::DairyAppQueryType.get_field("cheese"), second_field.definition
+      assert_equal Dummy::CheeseType, second_field.return_type
       assert second_field.inspect.is_a?(String)
     end
   end
@@ -50,8 +50,8 @@ describe GraphQL::InternalRepresentation::Rewrite do
     |}
 
     it "gets dynamic field definitions" do
-      cheese_field = rewrite_result[nil].typed_children[DairyAppQueryType]["cheese"]
-      typename_field = cheese_field.typed_children[CheeseType]["typename"]
+      cheese_field = rewrite_result[nil].typed_children[Dummy::DairyAppQueryType]["cheese"]
+      typename_field = cheese_field.typed_children[Dummy::CheeseType]["typename"]
       assert_equal "__typename", typename_field.definition.name
       assert_equal "__typename", typename_field.definition_name
     end
@@ -128,41 +128,41 @@ describe GraphQL::InternalRepresentation::Rewrite do
     it "puts all fragment members as children" do
       op_node = rewrite_result[nil]
 
-      cheese_field = op_node.typed_children[DairyAppQueryType]["cheese"]
-      assert_equal ["id1", "id2", "fatContent", "similarCow", "flavor"], cheese_field.typed_children[CheeseType].keys
-      assert_equal ["fatContent", "origin"], cheese_field.typed_children[EdibleInterface].keys
+      cheese_field = op_node.typed_children[Dummy::DairyAppQueryType]["cheese"]
+      assert_equal ["id1", "id2", "fatContent", "similarCow", "flavor"], cheese_field.typed_children[Dummy::CheeseType].keys
+      assert_equal ["fatContent", "origin"], cheese_field.typed_children[Dummy::EdibleInterface].keys
       # Merge:
-      similar_cow_field = cheese_field.typed_children[CheeseType]["similarCow"]
-      assert_equal ["similarCowSource", "fatContent", "similarCheese", "id"], similar_cow_field.typed_children[CheeseType].keys
+      similar_cow_field = cheese_field.typed_children[Dummy::CheeseType]["similarCow"]
+      assert_equal ["similarCowSource", "fatContent", "similarCheese", "id"], similar_cow_field.typed_children[Dummy::CheeseType].keys
       # Deep merge:
-      similar_sheep_field = similar_cow_field.typed_children[CheeseType]["similarCheese"]
-      assert_equal ["flavor", "source"], similar_sheep_field.typed_children[CheeseType].keys
+      similar_sheep_field = similar_cow_field.typed_children[Dummy::CheeseType]["similarCheese"]
+      assert_equal ["flavor", "source"], similar_sheep_field.typed_children[Dummy::CheeseType].keys
 
-      edible_origin_node = cheese_field.typed_children[EdibleInterface]["origin"]
-      assert_equal EdibleInterface.get_field("origin"), edible_origin_node.definition
-      assert_equal EdibleInterface, edible_origin_node.owner_type
+      edible_origin_node = cheese_field.typed_children[Dummy::EdibleInterface]["origin"]
+      assert_equal Dummy::EdibleInterface.get_field("origin"), edible_origin_node.definition
+      assert_equal Dummy::EdibleInterface, edible_origin_node.owner_type
 
-      edible_fat_content_node = cheese_field.typed_children[EdibleInterface]["fatContent"]
-      assert_equal EdibleInterface.get_field("fatContent"), edible_fat_content_node.definition
-      assert_equal EdibleInterface, edible_fat_content_node.owner_type
+      edible_fat_content_node = cheese_field.typed_children[Dummy::EdibleInterface]["fatContent"]
+      assert_equal Dummy::EdibleInterface.get_field("fatContent"), edible_fat_content_node.definition
+      assert_equal Dummy::EdibleInterface, edible_fat_content_node.owner_type
 
-      cheese_fat_content_node = cheese_field.typed_children[CheeseType]["fatContent"]
-      assert_equal CheeseType.get_field("fatContent"), cheese_fat_content_node.definition
-      assert_equal CheeseType, cheese_fat_content_node.owner_type
+      cheese_fat_content_node = cheese_field.typed_children[Dummy::CheeseType]["fatContent"]
+      assert_equal Dummy::CheeseType.get_field("fatContent"), cheese_fat_content_node.definition
+      assert_equal Dummy::CheeseType, cheese_fat_content_node.owner_type
 
-      cheese_flavor_node = cheese_field.typed_children[CheeseType]["flavor"]
-      assert_equal CheeseType.get_field("flavor"), cheese_flavor_node.definition
-      assert_equal CheeseType, cheese_flavor_node.owner_type
+      cheese_flavor_node = cheese_field.typed_children[Dummy::CheeseType]["flavor"]
+      assert_equal Dummy::CheeseType.get_field("flavor"), cheese_flavor_node.definition
+      assert_equal Dummy::CheeseType, cheese_flavor_node.owner_type
 
 
       # nested spread inside fragment definition:
-      cheese_2_field = op_node.typed_children[DairyAppQueryType]["cheese2"].typed_children[CheeseType]["similarCheese"]
-      assert_equal ["id", "fatContent"], cheese_2_field.typed_children[CheeseType].keys
+      cheese_2_field = op_node.typed_children[Dummy::DairyAppQueryType]["cheese2"].typed_children[Dummy::CheeseType]["similarCheese"]
+      assert_equal ["id", "fatContent"], cheese_2_field.typed_children[Dummy::CheeseType].keys
     end
   end
 
   describe "nested fields on typed fragments" do
-    let(:result) { DummySchema.execute(query_string) }
+    let(:result) { Dummy::Schema.execute(query_string) }
     let(:query_string) {%|
     {
       allDairy {

data/spec/graphql/introspection/directive_type_spec.rb

@@ -17,7 +17,7 @@ describe GraphQL::Introspection::DirectiveType do
       }
     }
   |}
-  let(:result) { DummySchema.execute(query_string) }
+  let(:result) { Dummy::Schema.execute(query_string) }
 
   it "shows directive info " do
     expected = { "data" => {

data/spec/graphql/introspection/input_value_type_spec.rb

@@ -18,7 +18,7 @@ describe GraphQL::Introspection::InputValueType do
        }
      }
   |}
-  let(:result) { DummySchema.execute(query_string) }
+  let(:result) { Dummy::Schema.execute(query_string) }
 
   it "exposes metadata about input objects, giving extra quotes for strings" do
     expected = { "data" => {
@@ -42,7 +42,7 @@ describe GraphQL::Introspection::InputValueType do
   end
 
   let(:cheese_type) {
-    DummySchema.execute(%|
+    Dummy::Schema.execute(%|
       {
         __type(name: "Cheese") {
           fields {

data/spec/graphql/introspection/introspection_query_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 
 describe "GraphQL::Introspection::INTROSPECTION_QUERY" do
   let(:query_string) { GraphQL::Introspection::INTROSPECTION_QUERY }
-  let(:result) { DummySchema.execute(query_string) }
+  let(:result) { Dummy::Schema.execute(query_string) }
 
   it "runs" do
     assert(result["data"])

data/spec/graphql/introspection/schema_type_spec.rb

@@ -11,12 +11,12 @@ describe GraphQL::Introspection::SchemaType do
       }
     }
   |}
-  let(:result) { DummySchema.execute(query_string) }
+  let(:result) { Dummy::Schema.execute(query_string) }
 
   it "exposes the schema" do
     expected = { "data" => {
       "__schema" => {
-        "types" => DummySchema.types.values.map { |t| t.name.nil? ? (p t; raise("no name for #{t}")) : {"name" => t.name} },
+        "types" => Dummy::Schema.types.values.map { |t| t.name.nil? ? (p t; raise("no name for #{t}")) : {"name" => t.name} },
         "queryType"=>{
           "fields"=>[
             {"name"=>"allDairy"},

data/spec/graphql/introspection/type_type_spec.rb

@@ -12,7 +12,7 @@ describe GraphQL::Introspection::TypeType do
        missingType:   __type(name: "NotAType") { name }
      }
   |}
-  let(:result) { DummySchema.execute(query_string, context: {}, variables: {"cheeseId" => 2}) }
+  let(:result) { Dummy::Schema.execute(query_string, context: {}, variables: {"cheeseId" => 2}) }
   let(:cheese_fields) {[
     {"name"=>"deeplyNullableCheese", "isDeprecated" => false, "type"=>{ "kind" => "OBJECT", "name" => "Cheese", "ofType" => nil}},
     {"name"=>"flavor",      "isDeprecated" => false, "type" => { "kind" => "NON_NULL", "name" => nil, "ofType" => { "name" => "String"}}},

data/spec/graphql/language/parser_spec.rb

@@ -38,7 +38,7 @@ describe GraphQL::Language::Parser do
   end
 
   it "parses the test schema" do
-    schema = DummySchema
+    schema = Dummy::Schema
     schema_string = GraphQL::Schema::Printer.print_schema(schema)
     document = subject.parse(schema_string)
     assert_equal schema_string, document.to_query_string

data/spec/graphql/non_null_type_spec.rb

@@ -5,7 +5,7 @@ describe GraphQL::NonNullType do
   describe "when a non-null field returns null" do
     it "nulls out the parent selection" do
       query_string = %|{ cow { name cantBeNullButIs } }|
-      result = DummySchema.execute(query_string)
+      result = Dummy::Schema.execute(query_string)
       assert_equal({"cow" => nil }, result["data"])
       assert_equal([{"message"=>"Cannot return null for non-nullable field Cow.cantBeNullButIs"}], result["errors"])
     end
@@ -24,14 +24,14 @@ describe GraphQL::NonNullType do
         }
       }
       |
-      result = DummySchema.execute(query_string)
+      result = Dummy::Schema.execute(query_string)
       assert_equal(nil, result["data"])
       assert_equal([{"message"=>"Cannot return null for non-nullable field DeepNonNull.nonNullInt"}], result["errors"])
     end
 
     describe "when type_error is configured to raise an error" do
       it "crashes query execution" do
-        raise_schema = DummySchema.redefine {
+        raise_schema = Dummy::Schema.redefine {
           type_error ->(type_err, ctx) {
             raise type_err
           }

data/spec/graphql/object_type_spec.rb

@@ -2,7 +2,7 @@
 require "spec_helper"
 
 describe GraphQL::ObjectType do
-  let(:type) { CheeseType }
+  let(:type) { Dummy::CheeseType }
 
   it "has a name" do
     assert_equal("Cheese", type.name)
@@ -16,16 +16,16 @@ describe GraphQL::ObjectType do
   end
 
   it "may have interfaces" do
-    assert_equal([EdibleInterface, AnimalProductInterface, LocalProductInterface], type.interfaces)
+    assert_equal([Dummy::EdibleInterface, Dummy::AnimalProductInterface, Dummy::LocalProductInterface], type.interfaces)
   end
 
   it "accepts fields definition" do
-    last_produced_dairy = GraphQL::Field.define(name: :last_produced_dairy, type: DairyProductUnion)
+    last_produced_dairy = GraphQL::Field.define(name: :last_produced_dairy, type: Dummy::DairyProductUnion)
     cow_type = GraphQL::ObjectType.define(name: "Cow", fields: [last_produced_dairy])
     assert_equal([last_produced_dairy], cow_type.fields)
   end
 
-  describe '#get_field ' do
+  describe '#get_field' do
     it "exposes fields" do
       field = type.get_field("id")
       assert_equal(GraphQL::TypeKinds::NON_NULL, field.type.kind)
@@ -33,15 +33,15 @@ describe GraphQL::ObjectType do
     end
 
     it "exposes defined field property" do
-      field_without_prop = CheeseType.get_field("flavor")
-      field_with_prop = CheeseType.get_field("fatContent")
+      field_without_prop = Dummy::CheeseType.get_field("flavor")
+      field_with_prop = Dummy::CheeseType.get_field("fatContent")
       assert_equal(field_without_prop.property, nil)
       assert_equal(field_with_prop.property, :fat_content)
     end
 
     it "looks up from interfaces" do
-      field_from_self = CheeseType.get_field("fatContent")
-      field_from_iface = MilkType.get_field("fatContent")
+      field_from_self = Dummy::CheeseType.get_field("fatContent")
+      field_from_iface = Dummy::MilkType.get_field("fatContent")
       assert_equal(field_from_self.property, :fat_content)
       assert_equal(field_from_iface.property, nil)
     end

data/spec/graphql/query/executor_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 
 describe GraphQL::Query::Executor do
   let(:operation_name) { nil }
-  let(:schema) { DummySchema }
+  let(:schema) { Dummy::Schema }
   let(:variables) { {"cheeseId" => 2} }
   let(:query) { GraphQL::Query.new(
     schema,
@@ -77,16 +77,16 @@ describe GraphQL::Query::Executor do
       DummyQueryType = GraphQL::ObjectType.define do
         name "Query"
         field :dairy do
-          type DairyType
+          type Dummy::DairyType
           resolve ->(t, a, c) {
             raise if resolved
             resolved = true
-            DAIRY
+            Dummy::DAIRY
           }
         end
       end
 
-      GraphQL::Schema.define(query: DummyQueryType, mutation: MutationType, resolve_type: :pass, id_from_object: :pass)
+      GraphQL::Schema.define(query: DummyQueryType, mutation: Dummy::DairyAppMutationType, resolve_type: :pass, id_from_object: :pass)
     }
     let(:variables) { nil }
     let(:query_string) { %|

data/spec/graphql/query/variables_spec.rb

@@ -3,14 +3,19 @@ require "spec_helper"
 
 describe GraphQL::Query::Variables do
   let(:query_string) {%|
-  query getCheese($animals: [DairyAnimal!], $int: Int, $intWithDefault: Int = 10) {
+  query getCheese(
+    $animals: [DairyAnimal!],
+    $intDefaultNull: Int = null,
+    $int: Int,
+    $intWithDefault: Int = 10)
+  {
     cheese(id: 1) {
       similarCheese(source: $animals)
     }
   }
   |}
   let(:ast_variables) { GraphQL.parse(query_string).definitions.first.variables }
-  let(:schema) { DummySchema }
+  let(:schema) { Dummy::Schema }
   let(:variables) { GraphQL::Query::Variables.new(
     schema,
     GraphQL::Schema::Warden.new(schema.default_mask, schema: schema, context: nil),
@@ -57,7 +62,7 @@ describe GraphQL::Query::Variables do
         end
       end
 
-      describe "when a nullable list has a null in it" do
+      describe "when a non-nullable list has a null in it" do
         let(:provided_variables) { { "ids" => [nil] } }
         it "returns an error" do
           assert_equal 1, result["errors"].length
@@ -71,13 +76,24 @@ describe GraphQL::Query::Variables do
         {"int" => nil, "intWithDefault" => nil}
       }
 
-      it "null variable" do
+      it "preserves explicit null" do
         assert_equal nil, variables["int"]
+        assert_equal true, variables.key?("int")
+      end
+
+      it "doesn't contain variables that weren't present" do
+        assert_equal nil, variables["animals"]
+        assert_equal false, variables.key?("animals")
       end
 
       it "preserves explicit null when variable has a default value" do
         assert_equal nil, variables["intWithDefault"]
       end
+
+      it "uses null default value" do
+        assert_equal nil, variables["intDefaultNull"]
+        assert_equal true, variables.key?("intDefaultNull")
+      end
     end
   end
 end

data/spec/graphql/query_spec.rb

@@ -32,7 +32,7 @@ describe GraphQL::Query do
   let(:operation_name) { nil }
   let(:max_depth) { nil }
   let(:query_variables) { {"cheeseId" => 2} }
-  let(:schema) { DummySchema }
+  let(:schema) { Dummy::Schema }
   let(:document) { GraphQL.parse(query_string) }
 
   let(:query) { GraphQL::Query.new(
@@ -132,7 +132,7 @@ describe GraphQL::Query do
       end
 
       let(:schema) {
-        DummySchema.redefine {
+        Dummy::Schema.redefine {
           instrument(:query, Instrumenter)
         }
       }
@@ -334,6 +334,24 @@ describe GraphQL::Query do
       end
     end
 
+    describe "when they are non-null and provided a null value" do
+      let(:query_variables) { { "cheeseId" => nil } }
+
+      it "raises an error" do
+        expected = {
+          "errors" => [
+            {
+              "message" => "Variable cheeseId of type Int! was provided invalid value",
+              "locations" => [{"line" => 2, "column" => 23}],
+              "value" => nil,
+              "problems" => [{ "path" => [], "explanation" => "Expected value to not be null" }]
+            }
+          ]
+        }
+        assert_equal(expected, result)
+      end
+    end
+
     describe "when they're a string" do
       let(:query_variables) { '{ "var" : 1 }' }
       it "raises an error" do

data/spec/graphql/relay/connection_type_spec.rb

@@ -31,7 +31,7 @@ describe GraphQL::Relay::ConnectionType do
         assert_equal 'basesWithCustomEdge', bases["fieldName"]
         assert_equal ["YAVIN", "ECHO BASE", "SECRET HIDEOUT"] , bases["edges"].map { |e| e["upcasedName"] }
         assert_equal ["Yavin", "Echo Base", "Secret Hideout"] , bases["edges"].map { |e| e["node"]["name"] }
-        assert_equal ["CustomBaseEdge"] , bases["edges"].map { |e| e["edgeClassName"] }.uniq
+        assert_equal ["StarWars::CustomBaseEdge"] , bases["edges"].map { |e| e["edgeClassName"] }.uniq
         upcased_rebels_name = "ALLIANCE TO RESTORE THE REPUBLIC"
         assert_equal [upcased_rebels_name] , bases["edges"].map { |e| e["upcasedParentName"] }.uniq
       end

data/spec/graphql/relay/mutation_spec.rb

@@ -22,8 +22,8 @@ describe GraphQL::Relay::Mutation do
   |}
 
   after do
-    STAR_WARS_DATA["Ship"].delete("9")
-    STAR_WARS_DATA["Faction"]["1"].ships.delete("9")
+    StarWars::DATA["Ship"].delete("9")
+    StarWars::DATA["Faction"]["1"].ships.delete("9")
   end
 
   it "supports null values" do
@@ -38,7 +38,7 @@ describe GraphQL::Relay::Mutation do
             "id" => GraphQL::Schema::UniqueWithinType.encode("Ship", "9"),
           },
         },
-        "faction" => {"name" => STAR_WARS_DATA["Faction"]["1"].name }
+        "faction" => {"name" => StarWars::DATA["Faction"]["1"].name }
       }
     }}
     assert_equal(expected, result)
@@ -60,7 +60,7 @@ describe GraphQL::Relay::Mutation do
             "id" => GraphQL::Schema::UniqueWithinType.encode("Ship", "9"),
           },
         },
-        "faction" => {"name" => STAR_WARS_DATA["Faction"]["1"].name }
+        "faction" => {"name" => StarWars::DATA["Faction"]["1"].name }
       }
     }}
     assert_equal(expected, result)
@@ -73,14 +73,14 @@ describe GraphQL::Relay::Mutation do
   end
 
   it "applies the description to the derived field" do
-    assert_equal "Add a ship to this faction", IntroduceShipMutation.field.description
+    assert_equal "Add a ship to this faction", StarWars::IntroduceShipMutation.field.description
   end
 
   it "inserts itself into the derived objects' metadata" do
-    assert_equal IntroduceShipMutation, IntroduceShipMutation.field.mutation
-    assert_equal IntroduceShipMutation, IntroduceShipMutation.return_type.mutation
-    assert_equal IntroduceShipMutation, IntroduceShipMutation.input_type.mutation
-    assert_equal IntroduceShipMutation, IntroduceShipMutation.result_class.mutation
+    assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.field.mutation
+    assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.return_type.mutation
+    assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.input_type.mutation
+    assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.result_class.mutation
   end
 
   describe "aliased methods" do