graphql 1.8.5 → 1.8.6

data/lib/graphql/types/relay/base_connection.rb

@@ -48,7 +48,7 @@ module GraphQL
           # It's called when you subclass this base connection, trying to use the
           # class name to set defaults. You can call it again in the class definition
           # to override the default (or provide a value, if the default lookup failed).
-          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type)
+          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: true)
             # Set this connection's graphql name
             node_type_name = node_type.graphql_name
 
@@ -61,16 +61,22 @@ module GraphQL
               method: :edge_nodes,
               edge_class: edge_class
 
-            field :nodes, [node_type, null: true],
-              null: true,
-              description: "A list of nodes."
+            define_nodes_field if nodes_field
 
             description("The connection type for #{node_type_name}.")
           end
 
           # Add the shortcut `nodes` field to this connection and its subclasses
           def nodes_field
-            field :nodes, [@node_type, null: true], null: true
+            define_nodes_field
+          end
+
+          private
+
+          def define_nodes_field
+            field :nodes, [@node_type, null: true],
+              null: true,
+              description: "A list of nodes."
           end
         end
 

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.8.5"
+  VERSION = "1.8.6"
 end

data/spec/generators/graphql/mutation_generator_spec.rb

@@ -31,6 +31,18 @@ class Mutations::UpdateName < GraphQL::Schema::RelayClassicMutation
     # TODO: define resolve method
   end
 end
+RUBY
+
+  EXPECTED_MUTATION_TYPE = <<-RUBY
+class Types::MutationType < Types::BaseObject
+  field :updateName, mutation: Mutations::UpdateName
+  # TODO: remove me
+  field :test_field, String, null: false,
+    description: "An example field added by the generator"
+  def test_field
+    "Hello World"
+  end
+end
 RUBY
 
   test "it generates an empty resolver by name" do
@@ -39,6 +51,12 @@ RUBY
     assert_file "app/graphql/mutations/update_name.rb", UPDATE_NAME_MUTATION
   end
 
+  test "it inserts the field into the MutationType" do
+    setup
+    run_generator(["UpdateName"])
+    assert_file "app/graphql/types/mutation_type.rb", EXPECTED_MUTATION_TYPE
+  end
+
   test "it allows for user-specified directory" do
     setup "app/mydirectory"
     run_generator(["UpdateName", "--directory", "app/mydirectory"])

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -16,6 +16,21 @@ describe GraphQL::Analysis do
     end
   end
 
+  class ConditionalAnalyzer
+    def analyze?(query)
+      !!query.context[:analyze]
+    end
+
+    def initial_value(query)
+      {}
+    end
+
+    def call(memo, visit_type, irep_node)
+      memo[:i_have_been_called] ||= true
+      memo
+    end
+  end
+
   describe ".analyze_query" do
     let(:node_counter) {
       ->(memo, visit_type, irep_node) {
@@ -38,6 +53,29 @@ describe GraphQL::Analysis do
       }
     |}
 
+    describe "conditional analysis" do
+      let(:conditional_analyzer) { ConditionalAnalyzer.new }
+      let(:analyzers) { [type_collector, conditional_analyzer] }
+
+      describe "when analyze? returns false" do
+        let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables, context: { analyze: false }) }
+
+        it "does not run the analyzer" do
+          # Only type_collector ran
+          assert_equal 1, reduce_result.size
+        end
+      end
+
+      describe "when analyze? returns true" do
+        let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables, context: { analyze: true }) }
+
+        it "it runs the analyzer" do
+          # Both analyzers ran
+          assert_equal 2, reduce_result.size
+        end
+      end
+    end
+
     it "calls the defined analyzers" do
       collected_types, node_counts = reduce_result
       expected_visited_types = [Dummy::DairyAppQueryType, Dummy::CheeseType, GraphQL::INT_TYPE, GraphQL::STRING_TYPE]

data/spec/graphql/argument_spec.rb

@@ -40,6 +40,14 @@ describe GraphQL::Argument do
       assert_equal "my type is String", arg.description
     end
 
+    it "accepts a definition block and yields the argument if the block has an arity of one" do
+      arg = GraphQL::Argument.from_dsl(:foo, GraphQL::STRING_TYPE) do |argument|
+        argument.description "my type is #{target.type}"
+      end
+
+      assert_equal "my type is String", arg.description
+    end
+
     it "accepts a definition block with existing arg" do
       existing = GraphQL::Argument.define do
         name "bar"

data/spec/graphql/language/parser_spec.rb

@@ -24,6 +24,91 @@ describe GraphQL::Language::Parser do
     end
   end
 
+  describe "string description" do
+    it "is parsed for scalar definitions" do
+      document = subject.parse <<-GRAPHQL
+        "Thing description"
+        scalar Thing
+      GRAPHQL
+
+      thing_defn = document.definitions[0]
+      assert_equal "Thing", thing_defn.name
+      assert_equal "Thing description", thing_defn.description
+    end
+
+    it "is parsed for object definitions, field definitions, and input value definitions" do
+      document = subject.parse <<-GRAPHQL
+      "Thing description"
+      type Thing {
+        "field description"
+        field("arg description" arg: Stuff): Stuff
+      }
+      GRAPHQL
+
+      thing_defn = document.definitions[0]
+      assert_equal "Thing", thing_defn.name
+      assert_equal "Thing description", thing_defn.description
+
+      field_defn = thing_defn.fields[0]
+      assert_equal "field", field_defn.name
+      assert_equal "field description", field_defn.description
+
+      arg_defn = field_defn.arguments[0]
+      assert_equal "arg", arg_defn.name
+      assert_equal "arg description", arg_defn.description
+    end
+
+    it "is parsed for interface definitions" do
+      document = subject.parse <<-GRAPHQL
+        "Thing description"
+        interface Thing {}
+      GRAPHQL
+
+      thing_defn = document.definitions[0]
+      assert_equal "Thing", thing_defn.name
+      assert_equal "Thing description", thing_defn.description
+    end
+
+    it "is parsed for union definitions" do
+      document = subject.parse <<-GRAPHQL
+        "Thing description"
+        union Thing = Int | String
+      GRAPHQL
+
+      thing_defn = document.definitions[0]
+      assert_equal "Thing", thing_defn.name
+      assert_equal "Thing description", thing_defn.description
+    end
+
+    it "is parsed for enum definitions and enum value definitions" do
+      document = subject.parse <<-GRAPHQL
+        "Thing description"
+        enum Thing {
+          "VALUE description"
+          VALUE
+        }
+      GRAPHQL
+
+      thing_defn = document.definitions[0]
+      assert_equal "Thing", thing_defn.name
+      assert_equal "Thing description", thing_defn.description
+
+      value_defn = thing_defn.values[0]
+      assert_equal "VALUE", value_defn.name
+      assert_equal "VALUE description", value_defn.description
+    end
+
+    it "is parsed for directive definitions" do
+      document = subject.parse <<-GRAPHQL
+      "thing description" directive @thing on FIELD
+      GRAPHQL
+
+      thing_defn = document.definitions[0]
+      assert_equal "thing", thing_defn.name
+      assert_equal "thing description", thing_defn.description
+    end
+  end
+
   it "parses empty arguments" do
     strings = [
       "{ field { inner } }",

data/spec/graphql/relay/connection_type_spec.rb

@@ -41,7 +41,12 @@ describe GraphQL::Relay::ConnectionType do
       let(:query_string) {%|
         {
           rebels {
-            bases: basesWithCustomEdge {
+            bases {
+              nodes {
+                name
+              }
+            }
+            basesWithCustomEdge {
               nodes {
                 name
               }
@@ -54,9 +59,29 @@ describe GraphQL::Relay::ConnectionType do
         result = star_wars_query(query_string)
         bases = result["data"]["rebels"]["bases"]
         assert_equal ["Yavin", "Echo Base", "Secret Hideout"] , bases["nodes"].map { |e| e["name"] }
+        bases_with_custom_edge = result["data"]["rebels"]["basesWithCustomEdge"]
+        assert_equal ["Yavin", "Echo Base", "Secret Hideout"] , bases_with_custom_edge["nodes"].map { |e| e["name"] }
       end
     end
 
+    describe "connections without nodes field" do
+      let(:query_string) {%|
+        {
+          rebels {
+            basesWithoutNodes {
+              nodes {
+                name
+              }
+            }
+          }
+        }
+      |}
+
+      it "raises error" do
+        result = star_wars_query(query_string)
+        assert_includes result["errors"][0]["message"], "Field 'nodes' doesn't exist"
+      end
+    end
 
     describe "when an execution error is raised" do
       let(:query_string) {%|

data/spec/graphql/schema/argument_spec.rb

@@ -51,14 +51,20 @@ describe GraphQL::Schema::Argument do
   end
 
   describe "#description" do
+    let(:arg) { SchemaArgumentTest::Query.fields["field"].arguments["arg"] }
     it "sets description" do
-      SchemaArgumentTest::Query.fields["field"].arguments["arg"].description "new description"
-      assert_equal "new description", SchemaArgumentTest::Query.fields["field"].arguments["arg"].description
+      arg.description "new description"
+      assert_equal "new description", arg.description
     end
 
     it "returns description" do
       assert_equal "test", SchemaArgumentTest::Query.fields["field"].arguments["argWithBlock"].description
     end
+
+    it "has an assignment method" do
+      arg.description = "another new description"
+      assert_equal "another new description", arg.description
+    end
   end
 
   describe "as:" do

data/spec/graphql/schema/enum_value_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::EnumValue do
+  describe "#deprecation_reason" do
+    it "can be written and read" do
+      enum_value = GraphQL::Schema::EnumValue.new(:x, owner: nil)
+      assert_nil enum_value.deprecation_reason
+      enum_value.deprecation_reason = "No good!"
+      assert_equal "No good!", enum_value.deprecation_reason
+    end
+  end
+end

data/spec/graphql/schema/field_spec.rb

@@ -51,6 +51,20 @@ describe GraphQL::Schema::Field do
       assert_equal "A Description.", object.fields["test"].description
     end
 
+    it "accepts a block for defintion and yields the field if the block has an arity of one" do
+      object = Class.new(Jazz::BaseObject) do
+        graphql_name "JustAName"
+
+        field :test, String, null: true do |field|
+          field.argument :test, String, required: true
+          field.description "A Description."
+        end
+      end.to_graphql
+
+      assert_equal "test", object.fields["test"].arguments["test"].name
+      assert_equal "A Description.", object.fields["test"].description
+    end
+
     it "accepts anonymous classes as type" do
       type = Class.new(GraphQL::Schema::Object) do
         graphql_name 'MyType'
@@ -222,4 +236,17 @@ describe GraphQL::Schema::Field do
       assert_equal obj.fields["myField"].mutation, mutation_class
     end
   end
+
+  describe '#deprecation_reason' do
+    it "reads and writes" do
+      object_class = Class.new(GraphQL::Schema::Object) do
+        graphql_name "Thing"
+        field :stuff, String, null: false, deprecation_reason: "Broken"
+      end
+      field = object_class.fields["stuff"]
+      assert_equal "Broken", field.deprecation_reason
+      field.deprecation_reason += "!!"
+      assert_equal "Broken!!", field.deprecation_reason
+    end
+  end
 end

data/spec/graphql/schema/interface_spec.rb

@@ -177,8 +177,18 @@ describe GraphQL::Schema::Interface do
       include GraphQL::Schema::Interface
     end
 
-    class ObjectA < GraphQL::Schema::Object
-      implements InterfaceA
+    module InterfaceD
+      include InterfaceA
+
+      definition_methods do
+        def some_method
+          'not 42'
+        end
+      end
+    end
+
+    module InterfaceE
+      include InterfaceD
     end
 
     it "doesn't overwrite them when including multiple interfaces" do
@@ -192,8 +202,8 @@ describe GraphQL::Schema::Interface do
       assert_equal(InterfaceC::DefinitionMethods, def_methods)
     end
 
-    it "extends classes with the defined methods" do
-      assert_equal(ObjectA.some_method, InterfaceA.some_method)
+    it "follows the normal Ruby ancestor chain when including other interfaces" do
+      assert_equal('not 42', InterfaceE.some_method)
     end
   end
 end

data/spec/graphql/schema/object_spec.rb

@@ -41,14 +41,32 @@ describe GraphQL::Schema::Object do
       assert_equal object_class.description, new_subclass_2.description
     end
 
-    it "does not inherit singleton methods from base interface when implementing base interface" do
+    it "should take Ruby name (without Type suffix) as default graphql name" do
+      TestingClassType = Class.new(GraphQL::Schema::Object)
+      assert_equal "TestingClass", TestingClassType.graphql_name
+    end
+
+    it "raise on anonymous class without declared graphql name" do
+      anonymous_class = Class.new(GraphQL::Schema::Object)
+      assert_raises NotImplementedError do
+        anonymous_class.graphql_name
+      end
+    end
+  end
+
+  describe "implementing interfaces" do
+    it "raises an error when trying to implement a non-interface module" do
       object_type = Class.new(GraphQL::Schema::Object)
-      methods = object_type.singleton_methods
-      method_defs = Hash[methods.zip(methods.map{|method| object_type.method(method.to_sym)})]
 
-      object_type.implements(GraphQL::Schema::Interface)
-      new_method_defs = Hash[methods.zip(methods.map{|method| object_type.method(method.to_sym)})]
-      assert_equal method_defs, new_method_defs
+      module NotAnInterface
+      end
+
+      err = assert_raises do
+        object_type.implements(NotAnInterface)
+      end
+
+      message = "NotAnInterface cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
+      assert_equal message, err.message
     end
 
     it "does not inherit singleton methods from base interface when implementing another interface" do
@@ -64,18 +82,6 @@ describe GraphQL::Schema::Object do
       new_method_defs = Hash[methods.zip(methods.map{|method| object_type.method(method.to_sym)})]
       assert_equal method_defs, new_method_defs
     end
-
-    it "should take Ruby name (without Type suffix) as default graphql name" do
-      TestingClassType = Class.new(GraphQL::Schema::Object)
-      assert_equal "TestingClass", TestingClassType.graphql_name
-    end
-
-    it "raise on anonymous class without declared graphql name" do
-      anonymous_class = Class.new(GraphQL::Schema::Object)
-      assert_raises NotImplementedError do
-        anonymous_class.graphql_name
-      end
-    end
   end
 
   describe "wrapping a Hash" do

data/spec/graphql/tracing/prometheus_tracing_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe GraphQL::Tracing::PrometheusTracing do
+  module PrometheusTracingTest
+    class Query < GraphQL::Schema::Object
+      field :int, Integer, null: false
+
+      def int
+        1
+      end
+    end
+
+    class Schema < GraphQL::Schema
+      query Query
+    end
+  end
+
+  describe "Observing" do
+    it "sends JSON to Prometheus client" do
+      client = Minitest::Mock.new
+
+      client.expect :send_json, true do |obj|
+        obj[:type] == 'graphql' &&
+          obj[:key] == 'execute_field' &&
+          obj[:platform_key] == 'Query.int'
+      end
+
+      PrometheusTracingTest::Schema.use(
+        GraphQL::Tracing::PrometheusTracing,
+        client: client,
+        trace_scalars: true
+      )
+
+      PrometheusTracingTest::Schema.execute "query X { int }"
+    end
+  end
+end