graphql 1.7.14 → 1.8.0.pre1

data/spec/graphql/schema/field_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Field do
+  describe "graphql definition" do
+    let(:object_class) { Jazz::Query }
+    let(:field) { object_class.fields.find { |f| f.name == "find" } }
+
+    it "uses the argument class" do
+      arg_defn = field.graphql_definition.arguments.values.first
+      assert_equal :ok, arg_defn.metadata[:custom]
+    end
+  end
+end

data/spec/graphql/schema/input_object_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::InputObject do
+  let(:input_object) { Jazz::EnsembleInput }
+  describe "type info" do
+    it "has it" do
+      assert_equal "EnsembleInput", input_object.graphql_name
+      assert_equal nil, input_object.description
+      assert_equal 1, input_object.arguments.size
+    end
+  end
+
+  describe ".to_graphql" do
+    it "assigns itself as the arguments_class" do
+      assert_equal input_object, input_object.to_graphql.arguments_class
+    end
+  end
+
+  describe "in queries" do
+    it "is passed to the field method" do
+      query_str = <<-GRAPHQL
+      {
+        inspectInput(input: {
+          stringValue: "ABC",
+          legacyInput: { intValue: 4 },
+          nestedInput: { stringValue: "xyz"}
+        })
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str, context: { message: "hi" })
+      expected_info = [
+        "Jazz::InspectableInput",
+        "hi, ABC, 4, (hi, xyz, -, (-))",
+        "ABC",
+        "ABC",
+        "ABC",
+      ]
+      assert_equal expected_info, res["data"]["inspectInput"]
+    end
+  end
+end

data/spec/graphql/schema/interface_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Interface do
+  let(:interface) { Jazz::GloballyIdentifiableType }
+
+  describe "type info" do
+    it "tells its type info" do
+      assert_equal "GloballyIdentifiable", interface.graphql_name
+      assert_equal 2, interface.fields.size
+    end
+
+    class NewInterface1 < Jazz::GloballyIdentifiableType
+    end
+
+    class NewInterface2 < Jazz::GloballyIdentifiableType
+      module Implementation
+        def new_method
+        end
+      end
+    end
+
+    it "can override Implementation" do
+
+      new_object_1 = Class.new(GraphQL::Schema::Object) do
+        implements NewInterface1
+      end
+
+      assert_equal 2, new_object_1.fields.size
+      assert new_object_1.method_defined?(:id)
+
+      new_object_2 = Class.new(GraphQL::Schema::Object) do
+        implements NewInterface2
+      end
+
+      assert_equal 2, new_object_2.fields.size
+      # It got the new method
+      assert new_object_2.method_defined?(:new_method)
+      # But not the old method
+      refute new_object_2.method_defined?(:id)
+    end
+  end
+
+  describe ".to_graphql" do
+    it "creates an InterfaceType" do
+      interface_type = interface.to_graphql
+      assert_equal "GloballyIdentifiable", interface_type.name
+      field = interface_type.all_fields.first
+      assert_equal "id", field.name
+      assert_equal GraphQL::ID_TYPE.to_non_null_type, field.type
+      assert_equal "A unique identifier for this object", field.description
+    end
+  end
+
+  describe "in queries" do
+    it "works" do
+      query_str = <<-GRAPHQL
+      {
+        piano: find(id: "Instrument/Piano") {
+          id
+          upcasedId
+          ... on Instrument {
+            family
+          }
+        }
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str)
+      expected_piano = {
+        "id" => "Instrument/Piano",
+        "upcasedId" => "INSTRUMENT/PIANO",
+        "family" => "KEYS",
+      }
+      assert_equal(expected_piano, res["data"]["piano"])
+    end
+
+    it "applies custom field attributes" do
+      query_str = <<-GRAPHQL
+      {
+        find(id: "Ensemble/Bela Fleck and the Flecktones") {
+          upcasedId
+          ... on Ensemble {
+            name
+          }
+        }
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str)
+      expected_data = {
+        "upcasedId" => "ENSEMBLE/BELA FLECK AND THE FLECKTONES",
+        "name" => "Bela Fleck and the Flecktones"
+      }
+      assert_equal(expected_data, res["data"]["find"])
+    end
+  end
+end

data/spec/graphql/schema/object_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Object do
+  describe "class attributes" do
+    let(:object_class) { Jazz::Ensemble }
+    it "tells type data" do
+      assert_equal "Ensemble", object_class.graphql_name
+      assert_equal "A group of musicians playing together", object_class.description
+      assert_equal 5, object_class.fields.size
+      assert_equal 2, object_class.interfaces.size
+      # Compatibility methods are delegated to the underlying BaseType
+      assert object_class.respond_to?(:connection_type)
+    end
+
+    it "inherits fields and interfaces" do
+      new_object_class = Class.new(object_class) do
+        field :newField, String, null: true
+        field :name, String, "The new description", null: true
+      end
+
+      # one more than the parent class
+      assert_equal 6, new_object_class.fields.size
+      # inherited interfaces are present
+      assert_equal 2, new_object_class.interfaces.size
+      # The new field is present
+      assert new_object_class.fields.find { |f| f.name == "newField" }
+      # The overridden field is present:
+      name_field = new_object_class.fields.find { |f| f.name == "name" }
+      assert_equal "The new description", name_field.description
+    end
+  end
+
+  describe ".to_graphql_type" do
+    let(:obj_type) { Jazz::Ensemble.to_graphql }
+    it "returns a matching GraphQL::ObjectType" do
+      assert_equal "Ensemble", obj_type.name
+      assert_equal "A group of musicians playing together", obj_type.description
+      assert_equal 5, obj_type.all_fields.size
+
+      name_field = obj_type.all_fields[2]
+      assert_equal "name", name_field.name
+      assert_equal GraphQL::STRING_TYPE.to_non_null_type, name_field.type
+      assert_equal nil, name_field.description
+    end
+
+    it "has a custom implementation" do
+      assert_equal obj_type.metadata[:config], :configged
+    end
+
+    it "uses the custom field class" do
+      query_str = <<-GRAPHQL
+      {
+        ensembles { upcaseName }
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str)
+      assert_equal ["BELA FLECK AND THE FLECKTONES"], res["data"]["ensembles"].map { |e| e["upcaseName"] }
+    end
+  end
+
+
+  describe "in queries" do
+    after {
+      Jazz::Models.reset
+    }
+
+    it "returns data" do
+      query_str = <<-GRAPHQL
+      {
+        ensembles { name }
+        instruments { name }
+      }
+      GRAPHQL
+      res = Jazz::Schema.execute(query_str)
+      assert_equal [{"name" => "Bela Fleck and the Flecktones"}], res["data"]["ensembles"]
+      assert_equal({"name" => "Banjo"}, res["data"]["instruments"].first)
+    end
+
+    it "does mutations" do
+      mutation_str = <<-GRAPHQL
+      mutation AddEnsemble($name: String!) {
+        addEnsemble(input: { name: $name }) {
+          id
+        }
+      }
+      GRAPHQL
+
+      query_str = <<-GRAPHQL
+      query($id: ID!) {
+        find(id: $id) {
+          ... on Ensemble {
+            name
+          }
+        }
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(mutation_str, variables: { "name" => "Miles Davis Quartet" })
+      new_id = res["data"]["addEnsemble"]["id"]
+
+      res2 = Jazz::Schema.execute(query_str, variables: { "id" => new_id })
+      assert_equal "Miles Davis Quartet", res2["data"]["find"]["name"]
+    end
+
+    it "initializes root wrappers once" do
+      query_str = " { oid1: objectId oid2: objectId }"
+      res = Jazz::Schema.execute(query_str)
+      assert_equal res["data"]["oid1"], res["data"]["oid2"]
+    end
+
+    it "skips fields properly" do
+      query_str = "{ find(id: \"MagicalSkipId\") { __typename } }"
+      res = Jazz::Schema.execute(query_str)
+      assert_equal({"data" => nil }, res.to_h)
+    end
+  end
+end

data/spec/graphql/schema/printer_spec.rb

@@ -14,11 +14,7 @@ describe GraphQL::Schema::Printer do
 
       value "FOO", value: :foo
       value "BAR", value: :bar
-      value "BAZ", deprecation_reason: <<-REASON
-Use "BAR" instead.
-
-It's the replacement for this value.
-REASON
+      value "BAZ", deprecation_reason: 'Use "BAR".'
       value "WOZ", deprecation_reason: GraphQL::Directive::DEFAULT_DEPRECATION_REASON
     end
 
@@ -140,14 +136,6 @@ schema {
   query: Root
 }
 
-# Marks an element of a GraphQL schema as no longer supported.
-directive @deprecated(
-  # Explains why this element was deprecated, usually also including a suggestion
-  # for how to access supported similar data. Formatted in
-  # [Markdown](https://daringfireball.net/projects/markdown/).
-  reason: String = "No longer supported"
-) on FIELD_DEFINITION | ENUM_VALUE
-
 # Directs the executor to include this field or fragment only when the `if` argument is true.
 directive @include(
   # Included when true.
@@ -160,6 +148,14 @@ directive @skip(
   if: Boolean!
 ) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
 
+# Marks an element of a GraphQL schema as no longer supported.
+directive @deprecated(
+  # Explains why this element was deprecated, usually also including a suggestion
+  # for how to access supported similar data. Formatted in
+  # [Markdown](https://daringfireball.net/projects/markdown/).
+  reason: String = "No longer supported"
+) on FIELD_DEFINITION | ENUM_VALUE
+
 # A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.
 #
 # In some cases, you need to provide options to alter GraphQL's execution behavior
@@ -349,6 +345,7 @@ schema {
   subscription: Subscription
 }
 SCHEMA
+
       assert_match expected, GraphQL::Schema::Printer.print_schema(custom_schema)
     end
 
@@ -356,6 +353,7 @@ SCHEMA
       custom_mutation = schema.mutation.redefine(name: "MyMutationRoot")
       custom_schema = schema.redefine(mutation: custom_mutation)
 
+
       expected = <<SCHEMA
 schema {
   query: Query
@@ -392,7 +390,7 @@ type Audio {
 
 enum Choice {
   BAR
-  BAZ @deprecated(reason: "Use \\\"BAR\\\" instead.\\n\\nIt's the replacement for this value.\\n")
+  BAZ @deprecated(reason: "Use \\\"BAR\\\".")
   FOO
   WOZ @deprecated
 }
@@ -491,6 +489,7 @@ enum Choice {
 }
 
 type Subscription {
+
 }
 
 input Varied {
@@ -510,9 +509,7 @@ SCHEMA
       when GraphQL::Argument
         member.name != "id"
       else
-        if member.respond_to?(:deprecation_reason)
-          member.deprecation_reason.nil?
-        end
+        member.deprecation_reason.nil?
       end
     }
 
@@ -603,86 +600,12 @@ SCHEMA
 type Post {
   body: String!
   comments: [Comment!]
-  comments_count: Int! @deprecated(reason: "Use \\\"comments\\\".")
+  comments_count: Int! @deprecated(reason: \"Use \\\"comments\\\".\")
   id: ID!
   title: String!
 }
 SCHEMA
       assert_equal expected.chomp, GraphQL::Schema::Printer.new(schema).print_type(schema.types['Post'])
     end
-
-    it "can print arguments that use non-standard Ruby objects as default values" do
-      backing_object = Struct.new(:value)
-
-      scalar_type = GraphQL::ScalarType.define do
-        name "SomeType"
-        coerce_input ->(value, ctx) { backing_object.new(value) }
-        coerce_result ->(obj, ctx) { obj.value }
-      end
-
-      query_root = GraphQL::ObjectType.define do
-        name "Query"
-        description "The query root of this schema"
-
-        field :example do
-          type scalar_type
-          argument :input, scalar_type, default_value: backing_object.new("Howdy")
-          resolve ->(obj, args, ctx) { args[:input] }
-        end
-      end
-
-      schema = GraphQL::Schema.define do
-        query query_root
-      end
-
-      expected = <<SCHEMA
-# The query root of this schema
-type Query {
-  example(input: SomeType = "Howdy"): SomeType
-}
-SCHEMA
-
-      assert_equal expected.chomp, GraphQL::Schema::Printer.new(schema).print_type(query_root)
-    end
-  end
-
-  describe "#print_directive" do
-    it "prints the deprecation reason in a single line escaped string including line breaks" do
-      expected = <<SCHEMA
-enum Choice {
-  BAR
-  BAZ @deprecated(reason: "Use \\\"BAR\\\" instead.\\n\\nIt's the replacement for this value.\\n")
-  FOO
-  WOZ @deprecated
-}
-
-type Subscription {
-}
-
-input Varied {
-  bool: Boolean
-  enum: Choice = FOO
-  float: Float
-  int: Int
-}
-SCHEMA
-
-      only_filter = ->(member, ctx) {
-        case member
-        when GraphQL::ScalarType
-          true
-        when GraphQL::BaseType
-          ctx[:names].include?(member.name)
-        when GraphQL::Argument
-          member.name != "id"
-        else
-          true
-        end
-      }
-
-      context = { names: ["Varied", "Choice", "Subscription"] }
-
-      assert_equal expected.chomp, GraphQL::Schema::Printer.new(schema, context: context, only: only_filter).print_schema
-    end
   end
 end