graphql 1.7.6 → 1.8.0

data/spec/graphql/schema_spec.rb

@@ -6,29 +6,49 @@ describe GraphQL::Schema do
   let(:relay_schema)  { StarWars::Schema }
   let(:empty_schema) { GraphQL::Schema.define }
 
-  describe "#rescue_from" do
-    let(:rescue_middleware) { schema.middleware.first }
+  describe "#graphql_definition" do
+    it "returns itself" do
+      assert_equal empty_schema, empty_schema.graphql_definition
+    end
+  end
 
+  describe "#rescue_from" do
     it "adds handlers to the rescue middleware" do
+      schema_defn = schema.graphql_definition
+      rescue_middleware = schema_defn.middleware.first
       assert_equal(1, rescue_middleware.rescue_table.length)
       # normally, you'd use a real class, not a symbol:
-      schema.rescue_from(:error_class) { "my custom message" }
+      schema_defn.rescue_from(:error_class) { "my custom message" }
       assert_equal(2, rescue_middleware.rescue_table.length)
     end
   end
 
+  describe "#find" do
+    it "finds a member using a string path" do
+      field = schema.find("Edible.fatContent")
+      assert_equal "fatContent", field.name
+    end
+  end
+
   describe "#union_memberships" do
     it "returns a list of unions that include the type" do
       assert_equal [schema.types["Animal"], schema.types["AnimalAsCow"]], schema.union_memberships(schema.types["Cow"])
     end
   end
 
+  describe "#to_document" do
+    it "returns the AST for the schema IDL" do
+      expected = GraphQL::Language::DocumentFromSchemaDefinition.new(schema).document
+      assert expected.eql?(schema.to_document)
+    end
+  end
+
   describe "#root_types" do
     it "returns a list of the schema's root types" do
       assert_equal(
         [
           Dummy::DairyAppQueryType,
-          Dummy::DairyAppMutationType,
+          Dummy::DairyAppMutationType.graphql_definition,
           Dummy::SubscriptionType
         ],
         schema.root_types
@@ -372,24 +392,25 @@ type Query {
       assert_equal true, schema.lazy?(LazyObj.new)
       assert_equal :dup, schema.lazy_method_name(LazyObjChild.new)
       assert_equal true, schema.lazy?(LazyObjChild.new)
-      assert_equal nil, schema.lazy_method_name({})
+      assert_nil schema.lazy_method_name({})
       assert_equal false, schema.lazy?({})
     end
   end
 
   describe "#dup" do
     it "copies internal state" do
-      schema_2 = schema.dup
-      refute schema_2.types.equal?(schema.types)
+      schema_1 = schema.graphql_definition
+      schema_2 = schema_1.dup
+      refute schema_2.types.equal?(schema_1.types)
 
-      refute schema_2.instrumenters.equal?(schema.instrumenters)
-      assert_equal schema_2.instrumenters, schema.instrumenters
+      refute schema_2.instrumenters.equal?(schema_1.instrumenters)
+      assert_equal schema_2.instrumenters, schema_1.instrumenters
 
-      refute schema_2.middleware.equal?(schema.middleware)
-      assert_equal schema_2.middleware, schema.middleware
+      refute schema_2.middleware.equal?(schema_1.middleware)
+      assert_equal schema_2.middleware, schema_1.middleware
 
       schema_2.middleware << ->(*args) { :noop }
-      refute_equal schema_2.middleware, schema.middleware
+      refute_equal schema_2.middleware, schema_1.middleware
     end
   end
 
@@ -418,6 +439,13 @@ type Query {
     end
   end
 
+  describe "#as_json" do
+    it "returns a hash" do
+      result = schema.execute(GraphQL::Introspection::INTROSPECTION_QUERY)
+      assert_equal result.as_json.class, Hash
+    end
+  end
+
   describe "#get_field" do
     it "returns fields by type or type name" do
       field = schema.get_field("Cheese", "id")
@@ -426,4 +454,19 @@ type Query {
       assert_equal field, field_2
     end
   end
+
+  describe "class-based schemas" do
+    it "delegates to the graphql definition" do
+      # Not delegated:
+      assert_equal Jazz::Query.graphql_definition, Jazz::Schema.query
+      assert Jazz::Schema.respond_to?(:query)
+      # Delegated
+      assert_equal [], Jazz::Schema.tracers
+      assert Jazz::Schema.respond_to?(:tracers)
+    end
+
+    it "works with plugins" do
+      assert_equal "xyz", Jazz::Schema.metadata[:plugin_key]
+    end
+  end
 end

data/spec/graphql/static_validation/rules/fields_have_appropriate_selections_spec.rb

@@ -8,18 +8,19 @@ describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do
       okCheese: cheese(id: 1) { fatContent, similarCheese(source: YAK) { source } }
       missingFieldsCheese: cheese(id: 1)
       illegalSelectionCheese: cheese(id: 1) { id { something, ... someFields } }
+      incorrectFragmentSpread: cheese(id: 1) { flavor { ... on String { __typename } } }
     }
   "}
 
   it "adds errors for selections on scalars" do
-    assert_equal(2, errors.length)
+    assert_equal(3, errors.length)
 
     illegal_selection_error = {
       "message"=>"Selections can't be made on scalars (field 'id' returns Int but has selections [something, someFields])",
       "locations"=>[{"line"=>5, "column"=>47}],
       "fields"=>["query getCheese", "illegalSelectionCheese", "id"],
     }
-    assert_includes(errors, illegal_selection_error, "finds illegal selections on scalarss")
+    assert_includes(errors, illegal_selection_error, "finds illegal selections on scalars")
 
     selection_required_error = {
       "message"=>"Objects must have selections (field 'cheese' returns Cheese but has no selections)",
@@ -27,6 +28,13 @@ describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do
       "fields"=>["query getCheese", "missingFieldsCheese"],
     }
     assert_includes(errors, selection_required_error, "finds objects without selections")
+
+    incorrect_fragment_error = {
+      "message"=>"Selections can't be made on scalars (field 'flavor' returns String but has inline fragments [String])",
+      "locations"=>[{"line"=>6, "column"=>48}],
+      "fields"=>["query getCheese", "incorrectFragmentSpread", "flavor"],
+    }
+    assert_includes(errors, incorrect_fragment_error, "finds scalar fields with selections")
   end
 
   describe "anonymous operations" do

data/spec/graphql/static_validation/rules/fields_will_merge_spec.rb

@@ -515,7 +515,7 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
           scalar: String!
         }
 
-        type NonNullStringBox1Impl implements SomeBox, NonNullStringBox1 {
+        type NonNullStringBox1Impl implements SomeBox & NonNullStringBox1 {
           scalar: String!
           unrelatedField: String
           deepBox: SomeBox
@@ -525,7 +525,7 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
           scalar: String!
         }
 
-        type NonNullStringBox2Impl implements SomeBox, NonNullStringBox2 {
+        type NonNullStringBox2Impl implements SomeBox & NonNullStringBox2 {
           scalar: String!
           unrelatedField: String
           deepBox: SomeBox

data/spec/graphql/string_type_spec.rb

@@ -72,9 +72,9 @@ describe GraphQL::STRING_TYPE do
     end
 
     it "doesn't accept other types" do
-      assert_equal nil, string_type.coerce_isolated_input(100)
-      assert_equal nil, string_type.coerce_isolated_input(true)
-      assert_equal nil, string_type.coerce_isolated_input(0.999)
+      assert_nil string_type.coerce_isolated_input(100)
+      assert_nil string_type.coerce_isolated_input(true)
+      assert_nil string_type.coerce_isolated_input(0.999)
     end
   end
 end