graphql 0.12.1 → 0.13.0

data/spec/graphql/id_type_spec.rb

@@ -1,27 +1,27 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::ID_TYPE do
   let(:result) { DummySchema.execute(query_string)}
 
-  describe 'coercion for int inputs' do
+  describe "coercion for int inputs" do
     let(:query_string) { %|query getMilk { cow: milk(id: 1) { id } }| }
 
-    it 'coerces IDs from ints and serializes as strings' do
+    it "coerces IDs from ints and serializes as strings" do
       expected = {"data" => {"cow" => {"id" => "1"}}}
       assert_equal(expected, result)
     end
   end
 
-  describe 'coercion for string inputs' do
+  describe "coercion for string inputs" do
     let(:query_string) { %|query getMilk { cow: milk(id: "1") { id } }| }
 
-    it 'coerces IDs from strings and serializes as strings' do
+    it "coerces IDs from strings and serializes as strings" do
       expected = {"data" => {"cow" => {"id" => "1"}}}
       assert_equal(expected, result)
     end
   end
 
-  describe 'coercion for other types' do
+  describe "coercion for other types" do
     let(:query_string) { %|query getMilk { cow: milk(id: 1.0) { id } }| }
 
     it "doesn't allow other types" do

data/spec/graphql/input_object_type_spec.rb

@@ -1,12 +1,12 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::InputObjectType do
   let(:input_object) { DairyProductInputType }
-  it 'has a description' do
+  it "has a description" do
     assert(input_object.description)
   end
 
-  it 'has input fields' do
+  it "has input fields" do
     assert(DairyProductInputType.input_fields["fatContent"])
   end
 
@@ -16,7 +16,7 @@ describe GraphQL::InputObjectType do
       assert DairyProductInputType.valid_input?(values_obj)
     end
 
-    describe 'validate_input with non-enumerable input' do
+    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}))
         assert(result.valid?)
@@ -29,86 +29,86 @@ describe GraphQL::InputObjectType do
       end
     end
 
-    describe 'validate_input with enumerable input' do
-      describe 'with good input' do
+    describe "validate_input with enumerable input" do
+      describe "with good input" do
         let(:input) do
           {
-            'source' => 'COW',
-            'fatContent' => 0.4
+            "source" => "COW",
+            "fatContent" => 0.4
           }
         end
         let(:result) { DairyProductInputType.validate_input(input) }
 
-        it 'returns a valid result' do
+        it "returns a valid result" do
           assert(result.valid?)
         end
       end
 
-      describe 'with bad enum and float' do
-        let(:result) { DairyProductInputType.validate_input('source' => 'KOALA', 'fatContent' => 'bad_num') }
+      describe "with bad enum and float" do
+        let(:result) { DairyProductInputType.validate_input("source" => "KOALA", "fatContent" => "bad_num") }
 
-        it 'returns an invalid result' do
+        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']))
+        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 = DairyAnimalEnum.validate_input('KOALA').problems[0]['explanation']
+        it "has correct problem explanation" do
+          expected = DairyAnimalEnum.validate_input("KOALA").problems[0]["explanation"]
 
-          source_problem = result.problems.detect { |p| p['path'] == ['source'] }
-          actual = source_problem['explanation']
+          source_problem = result.problems.detect { |p| p["path"] == ["source"] }
+          actual = source_problem["explanation"]
 
           assert_equal(expected, actual)
         end
       end
 
-      describe 'with extra argument' do
-        let(:result) { DairyProductInputType.validate_input('source' => 'COW', 'fatContent' => 0.4, 'isDelicious' => false) }
+      describe "with extra argument" do
+        let(:result) { DairyProductInputType.validate_input("source" => "COW", "fatContent" => 0.4, "isDelicious" => false) }
 
-        it 'returns an invalid result' do
+        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(paths, [['isDelicious']])
+        it "has problem with correct path" do
+          paths = result.problems.map { |p| p["path"] }
+          assert_equal(paths, [["isDelicious"]])
         end
 
-        it 'has correct problem explanation' do
-          assert(result.problems[0]['explanation'].include?('Field is not defined'))
+        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
+      describe "list with one invalid element" do
         let(:list_type) { GraphQL::ListType.new(of_type: DairyProductInputType) }
         let(:result) do
           list_type.validate_input([
-            { 'source' => 'COW', 'fatContent' => 0.4 },
-            { 'source' => 'KOALA', 'fatContent' => 0.4 }
+            { "source" => "COW", "fatContent" => 0.4 },
+            { "source" => "KOALA", "fatContent" => 0.4 }
           ])
         end
 
-        it 'returns an invalid result' do
+        it "returns an invalid result" do
           assert(!result.valid?)
         end
 
-        it 'has one problem' do
+        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'])
+        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 = DairyAnimalEnum.validate_input('KOALA').problems[0]['explanation']
-          actual = result.problems[0]['explanation']
+        it "has problem with correct explanation" do
+          expected = DairyAnimalEnum.validate_input("KOALA").problems[0]["explanation"]
+          actual = result.problems[0]["explanation"]
           assert_equal(expected, actual)
         end
       end

data/spec/graphql/interface_type_spec.rb

@@ -1,56 +1,40 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::InterfaceType do
   let(:interface) { EdibleInterface }
-  it 'has possible types' do
-    assert_equal([CheeseType, MilkType, HoneyType], interface.possible_types)
-  end
+  let(:dummy_query_context) { OpenStruct.new(schema: DummySchema) }
 
-  it 'resolves types for objects' do
-    assert_equal(CheeseType, interface.resolve_type(CHEESES.values.first))
-    assert_equal(MilkType, interface.resolve_type(MILKS.values.first))
+  it "has possible types" do
+    assert_equal([CheeseType, HoneyType, MilkType], DummySchema.possible_types(interface))
   end
 
-  it 'handles when interfaces are re-assigned' do
-    iface = GraphQL::InterfaceType.define do
-    end
-    type = GraphQL::ObjectType.define do
-      interfaces [iface]
-    end
-    assert_equal([type], iface.possible_types)
-
-    type.interfaces = []
-    assert_equal([], iface.possible_types)
-
-    type.interfaces = [iface]
-    assert_equal([type], iface.possible_types)
-
-    type.interfaces = [iface]
-    assert_equal([type], iface.possible_types)
+  it "resolves types for objects" do
+    assert_equal(CheeseType, interface.resolve_type(CHEESES.values.first, dummy_query_context))
+    assert_equal(MilkType, interface.resolve_type(MILKS.values.first, dummy_query_context))
   end
 
-  describe 'query evaluation' do
-    let(:result) { DummySchema.execute(query_string, context: {}, variables: {"cheeseId" => 2})}
+  describe "query evaluation" do
+    let(:result) { DummySchema.execute(query_string, variables: {"cheeseId" => 2})}
     let(:query_string) {%|
       query fav {
         favoriteEdible { fatContent }
       }
     |}
-    it 'gets fields from the type for the given object' do
+    it "gets fields from the type for the given object" do
       expected = {"data"=>{"favoriteEdible"=>{"fatContent"=>0.04}}}
       assert_equal(expected, result)
     end
   end
 
-  describe 'mergable query evaluation' do
-    let(:result) { DummySchema.execute(query_string, context: {}, variables: {"cheeseId" => 2})}
+  describe "mergable query evaluation" do
+    let(:result) { DummySchema.execute(query_string, variables: {"cheeseId" => 2})}
     let(:query_string) {%|
       query fav {
         favoriteEdible { fatContent }
         favoriteEdible { origin }
       }
     |}
-    it 'gets fields from the type for the given object' do
+    it "gets fields from the type for the given object" do
       expected = {"data"=>{"favoriteEdible"=>{"fatContent"=>0.04, "origin"=>"Antiquity"}}}
       assert_equal(expected, result)
     end
@@ -59,14 +43,14 @@ describe GraphQL::InterfaceType do
   describe '#resolve_type' do
     let(:interface) {
       GraphQL::InterfaceType.define do
-        resolve_type -> (object) {
+        resolve_type -> (object, ctx) {
           :custom_resolve
         }
       end
     }
 
-    it 'can be overriden in the definition' do
-      assert_equal(interface.resolve_type(123), :custom_resolve)
+    it "can be overriden in the definition" do
+      assert_equal(interface.resolve_type(123, nil), :custom_resolve)
     end
   end
 end

data/spec/graphql/introspection/directive_type_spec.rb

@@ -1,16 +1,16 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::Introspection::DirectiveType do
   let(:query_string) {%|
     query getDirectives {
       __schema {
-        directives { name, args { name, type { name, ofType { name } } }, onField, onFragment, onOperation }
+        directives { name, args { name, type { name, ofType { name } } }, locations }
       }
     }
   |}
   let(:result) { DummySchema.execute(query_string) }
 
-  it 'shows directive info ' do
+  it "shows directive info " do
     expected = { "data" => {
       "__schema" => {
         "directives" => [
@@ -19,18 +19,14 @@ describe GraphQL::Introspection::DirectiveType do
             "args" => [
               {"name"=>"if", "type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Boolean"}}}
             ],
-            "onField" => true,
-            "onFragment" => true,
-            "onOperation" => false,
+            "locations"=>["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
           },
           {
             "name" => "include",
             "args" => [
               {"name"=>"if", "type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Boolean"}}}
             ],
-            "onField" => true,
-            "onFragment" => true,
-            "onOperation" => false,
+            "locations"=>["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
           },
         ]
       }

data/spec/graphql/introspection/input_value_type_spec.rb

@@ -12,22 +12,28 @@ describe GraphQL::Introspection::InputValueType do
            name,
            type { name },
            defaultValue
+           description
          }
        }
      }
   |}
   let(:result) { DummySchema.execute(query_string)}
 
-  it 'exposes metadata about input objects, giving extra quotes for strings' do
+  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}
+            {"name"=>"source", "type"=>{ "name" => "Non-Null"}, "defaultValue"=>nil,
+             "description" => "Where it came from"},
+            {"name"=>"originDairy", "type"=>{ "name" => "String"}, "defaultValue"=>"\"Sugar Hollow Dairy\"",
+             "description" => "Dairy which produced it"},
+            {"name"=>"fatContent", "type"=>{ "name" => "Float"}, "defaultValue"=>"0.3",
+             "description" => "How much fat it has"},
+            {"name"=>"organic", "type"=>{ "name" => "Boolean"}, "defaultValue"=>"false",
+             "description" => nil}
           ]
         }
       }}

data/spec/graphql/introspection/introspection_query_spec.rb

@@ -1,10 +1,10 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe "GraphQL::Introspection::INTROSPECTION_QUERY" do
   let(:query_string) { GraphQL::Introspection::INTROSPECTION_QUERY }
   let(:result) { DummySchema.execute(query_string) }
 
-  it 'runs' do
+  it "runs" do
     assert(result["data"])
   end
 end

data/spec/graphql/introspection/schema_type_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::Introspection::SchemaType do
   let(:query_string) {%|
@@ -12,7 +12,7 @@ describe GraphQL::Introspection::SchemaType do
   |}
   let(:result) { DummySchema.execute(query_string) }
 
-  it 'exposes the schema' do
+  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} },

data/spec/graphql/introspection/type_type_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::Introspection::TypeType do
   let(:query_string) {%|
@@ -12,8 +12,10 @@ 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"}}},
@@ -24,7 +26,7 @@ describe GraphQL::Introspection::TypeType do
     {"name"=>"GOAT",  "isDeprecated"=> false },
     {"name"=>"SHEEP", "isDeprecated"=> false },
   ]}
-  it 'exposes metadata about types' do
+  it "exposes metadata about types" do
     expected = {"data"=> {
       "cheeseType" => {
         "name"=> "Cheese",
@@ -57,7 +59,7 @@ describe GraphQL::Introspection::TypeType do
       "animalProduct" => {
         "name"=>"AnimalProduct",
         "kind"=>"INTERFACE",
-        "possibleTypes"=>[{"name"=>"Cheese"}, {"name"=>"Milk"}, {"name"=>"Honey"}],
+        "possibleTypes"=>[{"name"=>"Cheese"}, {"name"=>"Honey"}, {"name"=>"Milk"}],
         "fields"=>[
           {"name"=>"source"},
         ]
@@ -66,7 +68,7 @@ describe GraphQL::Introspection::TypeType do
     assert_equal(expected, result)
   end
 
-  describe 'deprecated fields' 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 } } } }
@@ -74,8 +76,9 @@ describe GraphQL::Introspection::TypeType do
        }
     |}
     let(:deprecated_fields) { {"name"=>"fatContent", "isDeprecated"=>true, "type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Float"}}} }
-    it 'can expose deprecated fields' do
-      new_cheese_fields = [deprecated_fields] + cheese_fields
+
+    it "can expose deprecated fields" do
+      new_cheese_fields = ([deprecated_fields] + cheese_fields).sort_by { |f| f["name"] }
       expected = { "data" => {
         "cheeseType" => {
           "name"=> "Cheese",
@@ -90,5 +93,30 @@ 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"=>"originDairy", "type"=>{"name"=>"String"}, "defaultValue"=>"\"Sugar Hollow Dairy\""},
+                {"name"=>"fatContent", "type"=>{ "name" => "Float"}, "defaultValue"=>"0.3"},
+                {"name"=>"organic", "type"=>{ "name" => "Boolean"}, "defaultValue"=>"false"},
+              ]
+            }
+          }}
+        assert_equal(expected, result)
+      end
+    end
   end
 end