graphql 1.4.0 → 1.4.1

data/spec/graphql/analysis/max_query_depth_spec.rb

@@ -3,14 +3,14 @@ require "spec_helper"
 
 describe GraphQL::Analysis::MaxQueryDepth do
   before do
-    @prev_max_depth = DummySchema.max_depth
+    @prev_max_depth = Dummy::Schema.max_depth
   end
 
   after do
-    DummySchema.max_depth = @prev_max_depth
+    Dummy::Schema.max_depth = @prev_max_depth
   end
 
-  let(:result) { DummySchema.execute(query_string) }
+  let(:result) { Dummy::Schema.execute(query_string) }
   let(:query_string) { "
     {
       cheese(id: 1) {
@@ -36,7 +36,7 @@ describe GraphQL::Analysis::MaxQueryDepth do
   end
 
   describe "when the query specifies a different max_depth" do
-    let(:result) { DummySchema.execute(query_string, max_depth: 100) }
+    let(:result) { Dummy::Schema.execute(query_string, max_depth: 100) }
 
     it "obeys that max_depth" do
       assert_equal nil, result["errors"]
@@ -45,7 +45,7 @@ describe GraphQL::Analysis::MaxQueryDepth do
 
   describe "When the query is not deeper than max_depth" do
     before do
-      DummySchema.max_depth = 100
+      Dummy::Schema.max_depth = 100
     end
 
     it "doesn't add an error" do
@@ -55,7 +55,7 @@ describe GraphQL::Analysis::MaxQueryDepth do
 
   describe "when the max depth isn't set" do
     before do
-      DummySchema.max_depth = nil
+      Dummy::Schema.max_depth = nil
     end
 
     it "doesn't add an error message" do
@@ -65,7 +65,7 @@ describe GraphQL::Analysis::MaxQueryDepth do
 
   describe "when a fragment exceeds max depth" do
     before do
-      DummySchema.max_depth = 4
+      Dummy::Schema.max_depth = 4
     end
 
     let(:query_string) { "

data/spec/graphql/analysis/query_complexity_spec.rb

@@ -6,7 +6,7 @@ describe GraphQL::Analysis::QueryComplexity do
   let(:query_complexity) { GraphQL::Analysis::QueryComplexity.new { |this_query, complexity|  complexities << this_query << complexity } }
   let(:reduce_result) { GraphQL::Analysis.analyze_query(query, [query_complexity]) }
   let(:variables) { {} }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string, variables: variables) }
+  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
 
   describe "simple queries" do
     let(:query_string) {%|
@@ -189,7 +189,7 @@ describe GraphQL::Analysis::QueryComplexity do
   end
 
   describe "relay types" do
-    let(:query) { GraphQL::Query.new(StarWarsSchema, query_string) }
+    let(:query) { GraphQL::Query.new(StarWars::Schema, query_string) }
     let(:query_string) {%|
     {
       rebels {

data/spec/graphql/analysis/query_depth_spec.rb

@@ -5,7 +5,7 @@ describe GraphQL::Analysis::QueryDepth do
   let(:depths) { [] }
   let(:query_depth) { GraphQL::Analysis::QueryDepth.new { |query, max_depth|  depths << query << max_depth } }
   let(:reduce_result) { GraphQL::Analysis.analyze_query(query, [query_depth]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string, variables: variables) }
+  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
   let(:variables) { {} }
 
   describe "simple queries" do

data/spec/graphql/base_type_spec.rb

@@ -11,31 +11,39 @@ describe GraphQL::BaseType do
   end
 
   it "can be compared" do
+    obj_type = Dummy::MilkType
     assert_equal(!GraphQL::INT_TYPE, !GraphQL::INT_TYPE)
     refute_equal(!GraphQL::FLOAT_TYPE, GraphQL::FLOAT_TYPE)
     assert_equal(
-      GraphQL::ListType.new(of_type: MilkType),
-      GraphQL::ListType.new(of_type: MilkType)
+      GraphQL::ListType.new(of_type: obj_type),
+      GraphQL::ListType.new(of_type: obj_type)
     )
     refute_equal(
-      GraphQL::ListType.new(of_type: MilkType),
-      GraphQL::ListType.new(of_type: !MilkType)
+      GraphQL::ListType.new(of_type: obj_type),
+      GraphQL::ListType.new(of_type: !obj_type)
     )
   end
 
   it "Accepts arbitrary metadata" do
-    assert_equal ["Cheese"], CheeseType.metadata[:class_names]
+    assert_equal ["Cheese"], Dummy::CheeseType.metadata[:class_names]
   end
 
   describe "#dup" do
+    let(:obj_type) {
+      GraphQL::ObjectType.define do
+        name "SomeObject"
+        field :id, types.Int
+      end
+    }
+
     it "resets connection types" do
       # Make sure the defaults have been calculated
-      cheese_edge = CheeseType.edge_type
-      cheese_conn = CheeseType.connection_type
-      cheese_2 = CheeseType.dup
-      cheese_2.name = "Cheese2"
-      refute_equal cheese_edge, cheese_2.edge_type
-      refute_equal cheese_conn, cheese_2.connection_type
+      obj_edge = obj_type.edge_type
+      obj_conn = obj_type.connection_type
+      obj_2 = obj_type.dup
+      obj_2.name = "Cheese2"
+      refute_equal obj_edge, obj_2.edge_type
+      refute_equal obj_edge, obj_2.connection_type
     end
   end
 end

data/spec/graphql/directive_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 
 describe GraphQL::Directive do
   let(:variables) { {"t" => true, "f" => false} }
-  let(:result) { DummySchema.execute(query_string, variables: variables) }
+  let(:result) { Dummy::Schema.execute(query_string, variables: variables) }
   describe "on fields" do
     let(:query_string) { %|query directives($t: Boolean!, $f: Boolean!) {
       cheese(id: 1) {

data/spec/graphql/enum_type_spec.rb

@@ -2,7 +2,7 @@
 require "spec_helper"
 
 describe GraphQL::EnumType do
-  let(:enum) { DairyAnimalEnum }
+  let(:enum) { Dummy::DairyAnimalEnum }
 
   it "coerces names to underlying values" do
     assert_equal("YAK", enum.coerce_input("YAK"))
@@ -72,7 +72,7 @@ describe GraphQL::EnumType do
   end
 
   describe "validate_input with bad input" do
-    let(:result) { DairyAnimalEnum.validate_input("bad enum", PermissiveWarden) }
+    let(:result) { enum.validate_input("bad enum", PermissiveWarden) }
 
     it "returns an invalid result" do
       assert(!result.valid?)

data/spec/graphql/execution/typecast_spec.rb

@@ -5,7 +5,7 @@ describe GraphQL::Execution::Typecast do
   let(:milk_value) { MILKS[1] }
   let(:cheese_value) { CHEESES[1] }
 
-  let(:schema) { DummySchema }
+  let(:schema) { Dummy::Schema }
   let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil) }
 
   def compatible?(*args)
@@ -13,40 +13,40 @@ describe GraphQL::Execution::Typecast do
   end
 
   it "resolves correctly when both types are the same" do
-    assert compatible?(MilkType, MilkType, context)
+    assert compatible?(Dummy::MilkType, Dummy::MilkType, context)
 
-    assert !compatible?(MilkType, CheeseType, context)
+    assert !compatible?(Dummy::MilkType, Dummy::CheeseType, context)
   end
 
   it "resolves a union type to a matching member" do
-    assert compatible?(DairyProductUnion, MilkType, context)
-    assert compatible?(DairyProductUnion, CheeseType, context)
+    assert compatible?(Dummy::DairyProductUnion, Dummy::MilkType, context)
+    assert compatible?(Dummy::DairyProductUnion, Dummy::CheeseType, context)
 
-    assert !compatible?(DairyProductUnion, GraphQL::INT_TYPE, context)
-    assert !compatible?(DairyProductUnion, HoneyType, context)
+    assert !compatible?(Dummy::DairyProductUnion, GraphQL::INT_TYPE, context)
+    assert !compatible?(Dummy::DairyProductUnion, Dummy::HoneyType, context)
   end
 
   it "resolves correcty when potential type is UnionType and current type is a member of that union" do
-    assert compatible?(MilkType, DairyProductUnion, context)
-    assert compatible?(CheeseType, DairyProductUnion, context)
+    assert compatible?(Dummy::MilkType, Dummy::DairyProductUnion, context)
+    assert compatible?(Dummy::CheeseType, Dummy::DairyProductUnion, context)
 
-    assert !compatible?(QueryType, DairyProductUnion, context)
-    assert !compatible?(EdibleInterface, DairyProductUnion, context)
+    assert !compatible?(Dummy::DairyAppQueryType, Dummy::DairyProductUnion, context)
+    assert !compatible?(Dummy::EdibleInterface, Dummy::DairyProductUnion, context)
   end
 
   it "resolves an object type to one of its interfaces" do
-    assert compatible?(CheeseType, EdibleInterface, context)
-    assert compatible?(MilkType, EdibleInterface, context)
+    assert compatible?(Dummy::CheeseType, Dummy::EdibleInterface, context)
+    assert compatible?(Dummy::MilkType, Dummy::EdibleInterface, context)
 
-    assert !compatible?(QueryType, EdibleInterface, context)
-    assert !compatible?(LocalProductInterface, EdibleInterface, context)
+    assert !compatible?(Dummy::DairyAppQueryType, Dummy::EdibleInterface, context)
+    assert !compatible?(Dummy::LocalProductInterface, Dummy::EdibleInterface, context)
   end
 
   it "resolves an interface to a matching member" do
-    assert compatible?(EdibleInterface, CheeseType, context)
-    assert compatible?(EdibleInterface, MilkType, context)
+    assert compatible?(Dummy::EdibleInterface, Dummy::CheeseType, context)
+    assert compatible?(Dummy::EdibleInterface, Dummy::MilkType, context)
 
-    assert !compatible?(EdibleInterface, GraphQL::STRING_TYPE, context)
-    assert !compatible?(EdibleInterface, DairyProductInputType, context)
+    assert !compatible?(Dummy::EdibleInterface, GraphQL::STRING_TYPE, context)
+    assert !compatible?(Dummy::EdibleInterface, Dummy::DairyProductInputType, context)
   end
 end

data/spec/graphql/execution_error_spec.rb

@@ -2,7 +2,7 @@
 require "spec_helper"
 
 describe GraphQL::ExecutionError do
-  let(:result) { DummySchema.execute(query_string) }
+  let(:result) { Dummy::Schema.execute(query_string) }
   describe "when returned from a field" do
     let(:query_string) {%|
     {

data/spec/graphql/field_spec.rb

@@ -1,26 +1,34 @@
 # frozen_string_literal: true
 require "spec_helper"
 
+# Must be top-level so it can be found by string
+FieldSpecReturnType = GraphQL::ObjectType.define do
+  name "FieldReturn"
+  field :id, types.Int
+  field :source, types.String, hash_key: :source
+end
+
 describe GraphQL::Field do
+
   it "accepts a proc as type" do
     field = GraphQL::Field.define do
-      type(-> { DairyProductUnion })
+      type(-> { FieldSpecReturnType })
     end
 
-    assert_equal(DairyProductUnion, field.type)
+    assert_equal(FieldSpecReturnType, field.type)
   end
 
   it "accepts a string as a type" do
     field = GraphQL::Field.define do
-      type("DairyProductUnion")
+      type("FieldSpecReturnType")
     end
 
-    assert_equal(DairyProductUnion, field.type)
+    assert_equal(FieldSpecReturnType, field.type)
   end
 
   it "accepts arguments definition" do
     number = GraphQL::Argument.define(name: :number, type: -> { GraphQL::INT_TYPE })
-    field = GraphQL::Field.define(type: DairyProductUnion, arguments: [number])
+    field = GraphQL::Field.define(type: FieldSpecReturnType, arguments: [number])
     assert_equal([number], field.arguments)
   end
 
@@ -98,7 +106,7 @@ describe GraphQL::Field do
   end
 
   describe "#hash_key" do
-    let(:source_field) { MilkType.get_field("source") }
+    let(:source_field) { FieldSpecReturnType.get_field("source") }
     after { source_field.hash_key = :source }
 
     it "looks up a value with obj[hash_key]" do
@@ -117,7 +125,7 @@ describe GraphQL::Field do
 
   describe "#metadata" do
     it "accepts user-defined metadata" do
-      similar_cheese_field = CheeseType.get_field("similarCheese")
+      similar_cheese_field = Dummy::CheeseType.get_field("similarCheese")
       assert_equal [:cheeses, :milks], similar_cheese_field.metadata[:joins]
     end
   end

data/spec/graphql/id_type_spec.rb

@@ -2,7 +2,7 @@
 require "spec_helper"
 
 describe GraphQL::ID_TYPE do
-  let(:result) { DummySchema.execute(query_string)}
+  let(:result) { Dummy::Schema.execute(query_string)}
 
   describe "coercion for int inputs" do
     let(:query_string) { %|query getMilk { cow: milk(id: 1) { id } }| }

data/spec/graphql/input_object_type_spec.rb

@@ -2,13 +2,13 @@
 require "spec_helper"
 
 describe GraphQL::InputObjectType do
-  let(:input_object) { DairyProductInputType }
+  let(:input_object) { Dummy::DairyProductInputType }
   it "has a description" do
     assert(input_object.description)
   end
 
   it "has input fields" do
-    assert(DairyProductInputType.input_fields["fatContent"])
+    assert(input_object.input_fields["fatContent"])
   end
 
   describe "on a type unused by the schema" do
@@ -26,18 +26,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, PermissiveWarden)
+      assert input_object.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}), PermissiveWarden)
+        result = input_object.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, PermissiveWarden)
+        result = input_object.validate_input(invalid_input, PermissiveWarden)
         assert(!result.valid?)
       end
     end
@@ -76,7 +76,7 @@ describe GraphQL::InputObjectType do
             "fatContent" => 0.4
           }
         end
-        let(:result) { DairyProductInputType.validate_input(input, PermissiveWarden) }
+        let(:result) { input_object.validate_input(input, PermissiveWarden) }
 
         it "returns a valid result" do
           assert(result.valid?)
@@ -91,7 +91,7 @@ describe GraphQL::InputObjectType do
               "fatContent" => 0.4,
             )
           end
-          let(:result) { DairyProductInputType.validate_input(input, PermissiveWarden) }
+          let(:result) { input_object.validate_input(input, PermissiveWarden) }
 
           it "returns a valid result" do
             assert(result.valid?)
@@ -100,7 +100,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe "with bad enum and float" do
-        let(:result) { DairyProductInputType.validate_input({"source" => "KOALA", "fatContent" => "bad_num"}, PermissiveWarden) }
+        let(:result) { input_object.validate_input({"source" => "KOALA", "fatContent" => "bad_num"}, PermissiveWarden) }
 
         it "returns an invalid result" do
           assert(!result.valid?)
@@ -113,7 +113,7 @@ describe GraphQL::InputObjectType do
         end
 
         it "has correct problem explanation" do
-          expected = DairyAnimalEnum.validate_input("KOALA", PermissiveWarden).problems[0]["explanation"]
+          expected = Dummy::DairyAnimalEnum.validate_input("KOALA", PermissiveWarden).problems[0]["explanation"]
 
           source_problem = result.problems.detect { |p| p["path"] == ["source"] }
           actual = source_problem["explanation"]
@@ -123,7 +123,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe 'with a string as input' do
-        let(:result) { DairyProductInputType.validate_input("just a string", PermissiveWarden) }
+        let(:result) { input_object.validate_input("just a string", PermissiveWarden) }
 
         it "returns an invalid result" do
           assert(!result.valid?)
@@ -140,7 +140,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe 'with an array as input' do
-        let(:result) { DairyProductInputType.validate_input(["string array"], PermissiveWarden) }
+        let(:result) { input_object.validate_input(["string array"], PermissiveWarden) }
 
         it "returns an invalid result" do
           assert(!result.valid?)
@@ -157,7 +157,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe 'with a int as input' do
-        let(:result) { DairyProductInputType.validate_input(10, PermissiveWarden) }
+        let(:result) { input_object.validate_input(10, PermissiveWarden) }
 
         it "returns an invalid result" do
           assert(!result.valid?)
@@ -174,7 +174,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe "with extra argument" do
-        let(:result) { DairyProductInputType.validate_input({"source" => "COW", "fatContent" => 0.4, "isDelicious" => false}, PermissiveWarden) }
+        let(:result) { input_object.validate_input({"source" => "COW", "fatContent" => 0.4, "isDelicious" => false}, PermissiveWarden) }
 
         it "returns an invalid result" do
           assert(!result.valid?)
@@ -191,7 +191,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe "list with one invalid element" do
-        let(:list_type) { GraphQL::ListType.new(of_type: DairyProductInputType) }
+        let(:list_type) { GraphQL::ListType.new(of_type: Dummy::DairyProductInputType) }
         let(:result) do
           list_type.validate_input([
             { "source" => "COW", "fatContent" => 0.4 },
@@ -213,7 +213,7 @@ describe GraphQL::InputObjectType do
         end
 
         it "has problem with correct explanation" do
-          expected = DairyAnimalEnum.validate_input("KOALA", PermissiveWarden).problems[0]["explanation"]
+          expected = Dummy::DairyAnimalEnum.validate_input("KOALA", PermissiveWarden).problems[0]["explanation"]
           actual = result.problems[0]["explanation"]
           assert_equal(expected, actual)
         end
@@ -278,7 +278,7 @@ describe GraphQL::InputObjectType do
 
   describe "when sent into a query" do
     let(:variables) { {} }
-    let(:result) { DummySchema.execute(query_string, variables: variables) }
+    let(:result) { Dummy::Schema.execute(query_string, variables: variables) }
 
     describe "list inputs" do
       let(:variables) { {"search" => [MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4})]} }

data/spec/graphql/interface_type_spec.rb

@@ -2,15 +2,15 @@
 require "spec_helper"
 
 describe GraphQL::InterfaceType do
-  let(:interface) { EdibleInterface }
-  let(:dummy_query_context) { OpenStruct.new(schema: DummySchema) }
+  let(:interface) { Dummy::EdibleInterface }
+  let(:dummy_query_context) { OpenStruct.new(schema: Dummy::Schema) }
 
   it "has possible types" do
-    assert_equal([CheeseType, HoneyType, MilkType], DummySchema.possible_types(interface))
+    assert_equal([Dummy::CheeseType, Dummy::HoneyType, Dummy::MilkType], Dummy::Schema.possible_types(interface))
   end
 
   describe "query evaluation" do
-    let(:result) { DummySchema.execute(query_string, variables: {"cheeseId" => 2})}
+    let(:result) { Dummy::Schema.execute(query_string, variables: {"cheeseId" => 2})}
     let(:query_string) {%|
       query fav {
         favoriteEdible { fatContent }
@@ -23,7 +23,7 @@ describe GraphQL::InterfaceType do
   end
 
   describe "mergable query evaluation" do
-    let(:result) { DummySchema.execute(query_string, variables: {"cheeseId" => 2})}
+    let(:result) { Dummy::Schema.execute(query_string, variables: {"cheeseId" => 2})}
     let(:query_string) {%|
       query fav {
         favoriteEdible { fatContent }
@@ -47,7 +47,7 @@ describe GraphQL::InterfaceType do
       }
     }
     |}
-    let(:result) { DummySchema.execute(query_string) }
+    let(:result) { Dummy::Schema.execute(query_string) }
 
     it "can apply interface fragments to an interface" do
       expected_result = { "data" => {