graphql 1.7.14 → 1.8.0.pre1

data/spec/graphql/query/serial_execution/value_resolution_spec.rb

@@ -88,7 +88,7 @@ describe GraphQL::Query::SerialExecution::ValueResolution do
         err = assert_raises(GraphQL::UnresolvedTypeError) { result }
         expected_message = "The value from \"resolvesToNilInterface\" on \"Query\" could not be resolved to \"SomeInterface\". " \
           "(Received: `nil`, Expected: [SomeObject]) " \
-          "Make sure you have defined a `resolve_type` proc on your schema and that value `1337` " \
+          "Make sure you have defined a `type_from_object` proc on your schema and that value `1337` " \
           "gets resolved to a valid type."
         assert_equal expected_message, err.message
       end
@@ -105,7 +105,7 @@ describe GraphQL::Query::SerialExecution::ValueResolution do
         err = assert_raises(GraphQL::UnresolvedTypeError) { result }
         expected_message = "The value from \"resolvesToWrongTypeInterface\" on \"Query\" could not be resolved to \"SomeInterface\". " \
           "(Received: `OtherObject`, Expected: [SomeObject]) " \
-          "Make sure you have defined a `resolve_type` proc on your schema and that value `:something` " \
+          "Make sure you have defined a `type_from_object` proc on your schema and that value `:something` " \
           "gets resolved to a valid type."
         assert_equal expected_message, err.message
       end

data/spec/graphql/query/variables_spec.rb

@@ -111,7 +111,7 @@ describe GraphQL::Query::Variables do
         let(:provided_variables) { { "ids" => [nil] } }
         it "returns an error" do
           assert_equal 1, result["errors"].length
-          assert_nil result["data"]
+          assert_equal nil, result["data"]
         end
       end
     end

data/spec/graphql/query_spec.rb

@@ -85,7 +85,7 @@ describe GraphQL::Query do
         operation_name: operation_name,
         max_depth: max_depth,
       )
-      query.query_string = '{ __type(name: """Cheese""") { name } }'
+      query.query_string = '{ __type(name: "Cheese") { name } }'
       assert_equal "Cheese", query.result["data"] ["__type"]["name"]
     end
   end
@@ -111,7 +111,7 @@ describe GraphQL::Query do
       }
 
       it "returns nil" do
-        assert_nil query.operation_name
+        assert_equal nil, query.operation_name
       end
     end
 
@@ -148,7 +148,7 @@ describe GraphQL::Query do
         }
 
         it "returns the inferred operation name" do
-          assert_nil query.selected_operation_name
+          assert_equal nil, query.selected_operation_name
         end
       end
     end
@@ -253,32 +253,6 @@ describe GraphQL::Query do
         assert_equal [nil], Instrumenter::ERROR_LOG
       end
     end
-
-    describe "when an error propagated through execution" do
-      module ExtensionsInstrumenter
-        LOG = []
-        def self.before_query(q); end;
-
-        def self.after_query(q)
-          q.result["extensions"] = { "a" => 1 }
-          LOG << :ok
-        end
-      end
-
-      let(:schema) {
-        Dummy::Schema.redefine {
-          instrument(:query, ExtensionsInstrumenter)
-        }
-      }
-
-      it "can add to extensions" do
-        ExtensionsInstrumenter::LOG.clear
-        assert_raises(RuntimeError) do
-          schema.execute "{ error }"
-        end
-        assert_equal [:ok], ExtensionsInstrumenter::LOG
-      end
-    end
   end
 
   it "uses root_value as the object for the root type" do
@@ -558,7 +532,7 @@ describe GraphQL::Query do
 
       it "overrides the schema's max_depth" do
         assert result["data"].key?("cheese")
-        assert_nil result["errors"]
+        assert_equal nil, result["errors"]
       end
     end
   end
@@ -725,7 +699,7 @@ describe GraphQL::Query do
 
     it "returns nil when there is no selected operation" do
       query = GraphQL::Query.new(schema, '# Only a comment')
-      assert_nil query.irep_selection
+      assert_equal nil, query.irep_selection
     end
   end
 

data/spec/graphql/rake_task_spec.rb

@@ -34,9 +34,7 @@ describe GraphQL::RakeTask do
       end
       dumped_json = File.read("./schema.json")
       expected_json = JSON.pretty_generate(RakeTaskSchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY))
-
-      # Test that that JSON is logically equivalent, not serialized the same
-      assert_equal(JSON.parse(expected_json), JSON.parse(dumped_json))
+      assert_equal(expected_json, dumped_json)
 
       dumped_idl = File.read("./schema.graphql")
       expected_idl = rake_task_schema_defn.chomp

data/spec/graphql/relay/base_connection_spec.rb

@@ -38,7 +38,7 @@ describe GraphQL::Relay::BaseConnection do
         first: nil,
       }
       conn = GraphQL::Relay::BaseConnection.new([], args, context: context)
-      assert_nil conn.first
+      assert_equal nil, conn.first
     end
   end
 

data/spec/graphql/relay/connection_instrumentation_spec.rb

@@ -12,7 +12,7 @@ describe GraphQL::Relay::ConnectionInstrumentation do
   end
 
   it "keeps a reference to the function" do
-    conn_field = StarWars::Faction.fields["shipsWithMaxPageSize"]
+    conn_field = StarWars::Faction.graphql_definition.fields["shipsWithMaxPageSize"]
     assert_instance_of StarWars::ShipsWithMaxPageSize, conn_field.function
   end
 
@@ -77,7 +77,7 @@ describe GraphQL::Relay::ConnectionInstrumentation do
       # Before the object is wrapped in a connection, the instrumentation sees `Array`
       assert_equal ["StarWars::FactionRecord", "Array", "GraphQL::Relay::ArrayConnection"], ctx[:before_built_ins]
       # After the object is wrapped in a connection, it sees the connection object
-      assert_equal ["StarWars::FactionRecord", "GraphQL::Relay::ArrayConnection", "GraphQL::Relay::ArrayConnection"], ctx[:after_built_ins]
+      assert_equal ["StarWars::Faction", "GraphQL::Relay::ArrayConnection", "GraphQL::Relay::ArrayConnection"], ctx[:after_built_ins]
     end
   end
 end

data/spec/graphql/relay/connection_resolve_spec.rb

@@ -57,7 +57,7 @@ describe GraphQL::Relay::ConnectionResolve do
     it "becomes null" do
       result = star_wars_query(query_string, { "name" => "null" })
       conn = result["data"]["rebels"]["ships"]
-      assert_nil conn
+      assert_equal nil, conn
     end
   end
 end

data/spec/graphql/relay/connection_type_spec.rb

@@ -73,7 +73,7 @@ describe GraphQL::Relay::ConnectionType do
 
       it "nullifies the parent and adds an error" do
         result = star_wars_query(query_string)
-        assert_nil result["data"]["basesWithNullName"]["edges"][0]["node"]
+        assert_equal nil, result["data"]["basesWithNullName"]["edges"][0]["node"]
         assert_equal "Boom!", result["errors"][0]["message"]
       end
     end

data/spec/graphql/relay/mutation_spec.rb

@@ -193,17 +193,17 @@ describe GraphQL::Relay::Mutation do
     end
 
     it "doesn't get a mutation in the metadata" do
-      assert_nil custom_return_type.mutation
+      assert_equal nil, custom_return_type.mutation
     end
 
     it "supports input fields with nil default value" do
       assert input.arguments['nullDefault'].default_value?
-      assert_nil input.arguments['nullDefault'].default_value
+      assert_equal nil, input.arguments['nullDefault'].default_value
     end
 
     it "supports input fields with no default value" do
       assert !input.arguments['noDefault'].default_value?
-      assert_nil input.arguments['noDefault'].default_value
+      assert_equal nil, input.arguments['noDefault'].default_value
     end
 
     it "supports input fields with non-nil default value" do

data/spec/graphql/relay/relation_connection_spec.rb

@@ -74,35 +74,6 @@ describe GraphQL::Relay::RelationConnection do
       )
     end
 
-    it "makes one sql query for items and another for count" do
-      query_str = <<-GRAPHQL
-      {
-        empire {
-          bases(first: 2) {
-            totalCount
-            edges {
-              cursor
-              node {
-                name
-              }
-            }
-          }
-        }
-      }
-      GRAPHQL
-      io = StringIO.new
-      begin
-        prev_logger = ActiveRecord::Base.logger
-        ActiveRecord::Base.logger = Logger.new(io)
-        result = star_wars_query(query_str, "first" => 2)
-      ensure
-        ActiveRecord::Base.logger = prev_logger
-      end
-      assert_equal 2, io.string.scan("\n").count, "Two log entries"
-      assert_equal 3, result["data"]["empire"]["bases"]["totalCount"]
-      assert_equal 2, result["data"]["empire"]["bases"]["edges"].size
-    end
-
     it "provides bidirectional_pagination" do
       result = star_wars_query(query_string, "first" => 1)
       last_cursor = get_last_cursor(result)
@@ -117,13 +88,6 @@ describe GraphQL::Relay::RelationConnection do
       assert_equal true, get_page_info(result)["hasNextPage"]
       assert_equal true, get_page_info(result)["hasPreviousPage"]
 
-      last_cursor = get_last_cursor(result)
-      result = with_bidirectional_pagination {
-        star_wars_query(query_string, "last" => 1, "before" => last_cursor)
-      }
-      assert_equal true, get_page_info(result)["hasNextPage"]
-      assert_equal false, get_page_info(result)["hasPreviousPage"]
-
       result = star_wars_query(query_string, "first" => 100)
       last_cursor = get_last_cursor(result)
 
@@ -136,6 +100,7 @@ describe GraphQL::Relay::RelationConnection do
       }
       assert_equal true, get_page_info(result)["hasNextPage"]
       assert_equal true, get_page_info(result)["hasPreviousPage"]
+
     end
 
     it 'slices the result' do
@@ -599,35 +564,6 @@ describe GraphQL::Relay::RelationConnection do
         result = star_wars_query(query_string, "last" => 1, "nameIncludes" => "ea", "before" => before)
         assert_equal(["Death Star"], get_names(result))
       end
-
-      it "makes one sql query for items and another for count" do
-        query_str = <<-GRAPHQL
-        {
-          empire {
-            basesAsSequelDataset(first: 2) {
-              totalCount
-              edges {
-                cursor
-                node {
-                  name
-                }
-              }
-            }
-          }
-        }
-        GRAPHQL
-        result = nil
-        io = StringIO.new
-        begin
-          StarWars::DB.loggers << Logger.new(io)
-          result = star_wars_query(query_str, "first" => 2)
-        ensure
-          StarWars::DB.loggers.pop
-        end
-        assert_equal 2, io.string.scan("SELECT").count
-        assert_equal 3, result["data"]["empire"]["basesAsSequelDataset"]["totalCount"]
-        assert_equal 2, result["data"]["empire"]["basesAsSequelDataset"]["edges"].size
-      end
     end
   end
 

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -30,20 +30,6 @@ type HelloScalars {
       build_schema_and_compare_output(schema.chop)
     end
 
-    it 'can build a schema with default input object values' do
-      schema = <<-SCHEMA
-input InputObject {
-  a: Int
-}
-
-type Query {
-  a(input: InputObject = {a: 1}): String
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
     it 'can build a schema with directives' do
       schema = <<-SCHEMA
 schema {
@@ -308,7 +294,7 @@ schema {
 }
 
 type Hello {
-  str(bool: Boolean, int: Int): String
+  str(int: Int, bool: Boolean): String
 }
       SCHEMA
 
@@ -505,7 +491,7 @@ type HelloScalars {
 }
 
 type Mutation {
-  addHelloScalars(bool: Boolean, int: Int, str: String): HelloScalars
+  addHelloScalars(str: String, int: Int, bool: Boolean): HelloScalars
 }
       SCHEMA
 
@@ -520,7 +506,7 @@ enum Color {
 }
 
 type Mutation {
-  hello(color: Color = RED, int: Int, nullDefault: Int = null, str: String): String
+  hello(str: String, int: Int, color: Color = RED, nullDefault: Int = null): String
 }
 
 type Query {
@@ -545,7 +531,7 @@ type HelloScalars {
 }
 
 type Subscription {
-  subscribeHelloScalars(bool: Boolean, int: Int, str: String): HelloScalars
+  subscribeHelloScalars(str: String, int: Int, bool: Boolean): HelloScalars
 }
       SCHEMA
 
@@ -603,74 +589,6 @@ type Query {
 
       build_schema_and_compare_output(schema.chop)
     end
-
-    it 'supports empty types' do
-      schema = <<-SCHEMA
-type Query {
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it "tracks original AST node" do
-      schema_definition = <<-GRAPHQL
-schema {
-  query: Query
-}
-
-enum Enum {
-  VALUE
-}
-
-type Query {
-  field(argument: String): String
-  deprecatedField(argument: String): String @deprecated(reason: "Test")
-}
-
-interface Interface {
-  field(argument: String): String
-}
-
-union Union = Query
-
-scalar Scalar
-
-input Input {
-  argument: String
-}
-
-directive @Directive (
-  # Argument
-  argument: String
-) on SCHEMA
-
-type Type implements Interface {
-  field(argument: String): String
-}
-      GRAPHQL
-
-      schema = GraphQL::Schema.from_definition(schema_definition)
-
-      assert_equal [1, 1], schema.ast_node.position
-      assert_equal [5, 1], schema.types["Enum"].ast_node.position
-      assert_equal [6, 3], schema.types["Enum"].values["VALUE"].ast_node.position
-      assert_equal [9, 1], schema.types["Query"].ast_node.position
-      assert_equal [10, 3], schema.types["Query"].fields["field"].ast_node.position
-      assert_equal [10, 9], schema.types["Query"].fields["field"].arguments["argument"].ast_node.position
-      assert_equal [11, 45], schema.types["Query"].fields["deprecatedField"].ast_node.directives[0].position
-      assert_equal [11, 57], schema.types["Query"].fields["deprecatedField"].ast_node.directives[0].arguments[0].position
-      assert_equal [14, 1], schema.types["Interface"].ast_node.position
-      assert_equal [15, 3], schema.types["Interface"].fields["field"].ast_node.position
-      assert_equal [15, 9], schema.types["Interface"].fields["field"].arguments["argument"].ast_node.position
-      assert_equal [18, 1], schema.types["Union"].ast_node.position
-      assert_equal [20, 1], schema.types["Scalar"].ast_node.position
-      assert_equal [22, 1], schema.types["Input"].ast_node.position
-      assert_equal [22, 1], schema.types["Input"].arguments["argument"].ast_node.position
-      assert_equal [26, 1], schema.directives["Directive"].ast_node.position
-      assert_equal [28, 3], schema.directives["Directive"].arguments["argument"].ast_node.position
-      assert_equal [31, 22], schema.types["Type"].ast_node.interfaces[0].position
-    end
   end
 
   describe 'Failures' do

data/spec/graphql/schema/enum_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Enum do
+  let(:enum) { Jazz::Family }
+  describe "type info" do
+    it "tells about the definition" do
+      assert_equal "Family", enum.graphql_name
+      assert_equal 29, enum.description.length
+      assert_equal 6, enum.values.size
+    end
+
+    it "inherits values and description" do
+      new_enum = Class.new(enum) do
+        value :Nonsense
+        value :PERCUSSION, "new description"
+      end
+
+      # Description was inherited
+      assert_equal 29, new_enum.description.length
+      # values were inherited without modifying the parent
+      assert_equal 6, enum.values.size
+      assert_equal 7, new_enum.values.size
+      perc_value = new_enum.values.find { |v| v.name == "PERCUSSION" }
+      assert_equal "new description", perc_value.description
+    end
+  end
+
+
+  describe ".to_graphql" do
+    it "creates an EnumType" do
+      enum_type = enum.to_graphql
+      assert_equal "Family", enum_type.name
+      assert_equal "Groups of musical instruments", enum_type.description
+
+      string_val = enum_type.values["STRING"]
+      didg_val = enum_type.values["DIDGERIDOO"]
+      assert_equal "STRING", string_val.name
+      assert_equal :str, string_val.value
+      assert_equal "DIDGERIDOO", didg_val.name
+      assert_equal "Merged into BRASS", didg_val.deprecation_reason
+    end
+  end
+
+  describe "in queries" do
+    it "works as return values" do
+      query_str = "{ instruments { family } }"
+      expected_families = ["STRING", "WOODWIND", "BRASS", "KEYS", "KEYS", "PERCUSSION"]
+      result = Jazz::Schema.execute(query_str)
+      assert_equal expected_families, result["data"]["instruments"].map { |i| i["family"] }
+    end
+
+    it "works as input" do
+      query_str = "query($family: Family!) { instruments(family: $family) { name } }"
+      expected_names = ["Piano", "Organ"]
+      result = Jazz::Schema.execute(query_str, variables: { "family" => "KEYS" })
+      assert_equal expected_names, result["data"]["instruments"].map { |i| i["name"] }
+    end
+  end
+end