graphql 1.9.7 → 1.9.8

data/spec/graphql/analysis/ast/max_query_complexity_spec.rb

@@ -2,14 +2,7 @@
 require "spec_helper"
 
 describe GraphQL::Analysis::AST::MaxQueryComplexity do
-  before do
-    @prev_max_complexity = Dummy::Schema.max_complexity
-  end
-
-  after do
-    Dummy::Schema.max_complexity = @prev_max_complexity
-  end
-
+  let(:schema) { Class.new(Dummy::Schema) }
   let(:query_string) {%|
     {
       a: cheese(id: 1) { id }
@@ -19,7 +12,7 @@ describe GraphQL::Analysis::AST::MaxQueryComplexity do
       e: cheese(id: 1) { id }
     }
   |}
-  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: {}, max_complexity: max_complexity) }
+  let(:query) { GraphQL::Query.new(schema, query_string, variables: {}, max_complexity: max_complexity) }
   let(:result) {
     GraphQL::Analysis::AST.analyze_query(query, [GraphQL::Analysis::AST::MaxQueryComplexity]).first
   }
@@ -52,7 +45,7 @@ describe GraphQL::Analysis::AST::MaxQueryComplexity do
 
   describe "when max_complexity is decreased at query-level" do
     before do
-      Dummy::Schema.max_complexity = 100
+      schema.max_complexity = 100
     end
 
     let(:max_complexity) { 7 }
@@ -65,7 +58,7 @@ describe GraphQL::Analysis::AST::MaxQueryComplexity do
 
   describe "when max_complexity is increased at query-level" do
     before do
-      Dummy::Schema.max_complexity = 1
+      schema.max_complexity = 1
     end
 
     let(:max_complexity) { 10 }
@@ -77,22 +70,17 @@ describe GraphQL::Analysis::AST::MaxQueryComplexity do
 
   describe "across a multiplex" do
     before do
-      @old_analysis_engine = Dummy::Schema.analysis_engine
-      Dummy::Schema.analysis_engine = GraphQL::Analysis::AST
-    end
-
-    after do
-      Dummy::Schema.analysis_engine = @old_analysis_engine
+      schema.analysis_engine = GraphQL::Analysis::AST
     end
 
     let(:queries) {
       5.times.map { |n|
-        GraphQL::Query.new(Dummy::Schema, "{ cheese(id: #{n}) { id } }", variables: {})
+        GraphQL::Query.new(schema, "{ cheese(id: #{n}) { id } }", variables: {})
       }
     }
 
     let(:max_complexity) { 9 }
-    let(:multiplex) { GraphQL::Execution::Multiplex.new(schema: Dummy::Schema, queries: queries, context: {}, max_complexity: max_complexity) }
+    let(:multiplex) { GraphQL::Execution::Multiplex.new(schema: schema, queries: queries, context: {}, max_complexity: max_complexity) }
     let(:analyze_multiplex) {
       GraphQL::Analysis::AST.analyze_multiplex(multiplex, [GraphQL::Analysis::AST::MaxQueryComplexity])
     }

data/spec/graphql/analysis/ast/max_query_depth_spec.rb

@@ -2,14 +2,7 @@
 require "spec_helper"
 
 describe GraphQL::Analysis::AST::MaxQueryDepth do
-  before do
-    @prev_max_depth = Dummy::Schema.max_depth
-  end
-
-  after do
-    Dummy::Schema.max_depth = @prev_max_depth
-  end
-
+  let(:schema) { Class.new(Dummy::Schema) }
   let(:query_string) { "
     {
       cheese(id: 1) {
@@ -30,7 +23,7 @@ describe GraphQL::Analysis::AST::MaxQueryDepth do
   let(:max_depth) { nil }
   let(:query) {
     GraphQL::Query.new(
-      Dummy::Schema.graphql_definition,
+      schema.graphql_definition,
       query_string,
       variables: {},
       max_depth: max_depth
@@ -58,7 +51,7 @@ describe GraphQL::Analysis::AST::MaxQueryDepth do
 
   describe "When the query is not deeper than max_depth" do
     before do
-      Dummy::Schema.max_depth = 100
+      schema.max_depth = 100
     end
 
     it "doesn't add an error" do
@@ -68,7 +61,7 @@ describe GraphQL::Analysis::AST::MaxQueryDepth do
 
   describe "when the max depth isn't set" do
     before do
-      Dummy::Schema.max_depth = nil
+      schema.max_depth = nil
     end
 
     it "doesn't add an error message" do
@@ -78,7 +71,7 @@ describe GraphQL::Analysis::AST::MaxQueryDepth do
 
   describe "when a fragment exceeds max depth" do
     before do
-      Dummy::Schema.max_depth = 4
+      schema.max_depth = 4
     end
 
     let(:query_string) { "

data/spec/graphql/analysis/max_query_complexity_spec.rb

@@ -2,16 +2,8 @@
 require "spec_helper"
 
 describe GraphQL::Analysis::MaxQueryComplexity do
-  before do
-    @prev_max_complexity = Dummy::Schema.max_complexity
-  end
-
-  after do
-    Dummy::Schema.max_complexity = @prev_max_complexity
-  end
-
-
-  let(:result) { Dummy::Schema.execute(query_string) }
+  let(:schema) { Class.new(Dummy::Schema) }
+  let(:result) { schema.execute(query_string) }
   let(:query_string) {%|
     {
       a: cheese(id: 1) { id }
@@ -24,7 +16,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "when a query goes over max complexity" do
     before do
-      Dummy::Schema.max_complexity = 9
+      schema.max_complexity = 9
     end
 
     it "returns an error" do
@@ -34,7 +26,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "when there is no max complexity" do
     before do
-      Dummy::Schema.max_complexity = nil
+      schema.max_complexity = nil
     end
     it "doesn't error" do
       assert_nil result["errors"]
@@ -43,7 +35,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "when the query is less than the max complexity" do
     before do
-      Dummy::Schema.max_complexity = 99
+      schema.max_complexity = 99
     end
     it "doesn't error" do
       assert_nil result["errors"]
@@ -52,9 +44,9 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "when max_complexity is decreased at query-level" do
     before do
-      Dummy::Schema.max_complexity = 100
+      schema.max_complexity = 100
     end
-    let(:result) { Dummy::Schema.execute(query_string, max_complexity: 7) }
+    let(:result) {schema.execute(query_string, max_complexity: 7) }
 
     it "is applied" do
       assert_equal "Query has complexity of 10, which exceeds max complexity of 7", result["errors"][0]["message"]
@@ -63,9 +55,9 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "when max_complexity is increased at query-level" do
     before do
-      Dummy::Schema.max_complexity = 1
+      schema.max_complexity = 1
     end
-    let(:result) { Dummy::Schema.execute(query_string, max_complexity: 10) }
+    let(:result) {schema.execute(query_string, max_complexity: 10) }
 
     it "doesn't error" do
       assert_nil result["errors"]
@@ -74,13 +66,13 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "across a multiplex" do
     before do
-      Dummy::Schema.max_complexity = 9
+      schema.max_complexity = 9
     end
 
     let(:queries) { 5.times.map { |n|  { query: "{ cheese(id: #{n}) { id } }" } } }
 
     it "returns errors for all queries" do
-      results = Dummy::Schema.multiplex(queries)
+      results = schema.multiplex(queries)
       assert_equal 5, results.length
       err_msg = "Query has complexity of 10, which exceeds max complexity of 9"
       results.each do |res|
@@ -90,7 +82,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
     describe "with a local override" do
       it "uses the override" do
-        results = Dummy::Schema.multiplex(queries, max_complexity: 10)
+        results = schema.multiplex(queries, max_complexity: 10)
         assert_equal 5, results.length
         results.each do |res|
           assert_equal true, res.key?("data")

data/spec/graphql/analysis/max_query_depth_spec.rb

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

data/spec/graphql/language/lexer_spec.rb

@@ -53,6 +53,13 @@ describe GraphQL::Language::Lexer do
         tokens = subject.tokenize('"""{"foo":"bar"}"""')
         assert_equal '{"foo":"bar"}', tokens[0].value
       end
+
+      it "tokenizes empty block strings correctly" do
+        empty_block_string = '""""""'
+        tokens = subject.tokenize(empty_block_string)
+
+        assert_equal '', tokens[0].value
+      end
     end
 
     it "unescapes escaped characters" do
@@ -67,6 +74,17 @@ describe GraphQL::Language::Lexer do
       assert_equal :BAD_UNICODE_ESCAPE, subject.tokenize('"\\u0XXF \\u0009"').first.name
     end
 
+    it "rejects truly invalid UTF-8 bytes" do
+      error_filename = "spec/support/parser/filename_example_invalid_utf8.graphql"
+      assert_equal :BAD_UNICODE_ESCAPE, subject.tokenize(File.read(error_filename)).first.name
+    end
+
+    it "rejects unicode that's well-formed but results in invalidly-encoded strings" do
+      # when the string here gets tokenized into an actual `:STRING`, it results in `valid_encoding?` being false for
+      # the ruby string so application code usually blows up trying to manipulate it
+      assert_equal :BAD_UNICODE_ESCAPE, subject.tokenize('"\\ud83c\\udf2c"').first.name
+    end
+
     it "clears the previous_token between runs" do
       tok_2 = subject.tokenize(query_string)
       assert_nil tok_2[0].prev_token
@@ -80,7 +98,7 @@ describe GraphQL::Language::Lexer do
       assert_equal 8, str_token.col
       assert_equal '(STRING "c" [1:8])', str_token.inspect
       rparen_token = tokens[6]
-      assert_equal '(RPAREN ")" [1:10])', rparen_token.inspect
+      assert_equal '(RPAREN ")" [1:11])', rparen_token.inspect
     end
 
     it "counts block string line properly" do

data/spec/graphql/schema/argument_spec.rb

@@ -18,7 +18,7 @@ describe GraphQL::Schema::Argument do
           raise GraphQL::ExecutionError.new('boom!')
         end
 
-        argument :keys, [String], required: false
+        argument :keys, [String], required: false, method_access: false
 
         class Multiply
           def call(val, context)

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -1063,6 +1063,16 @@ SCHEMA
 
       assert_equal({ "str" => "abc", "int" => 123 }, result["data"])
     end
+
+    it "doesn't warn about method conflicts" do
+      assert_output "", "" do
+        GraphQL::Schema.from_definition "
+        type Query {
+          int(method: Int): Int
+        }
+        "
+      end
+    end
   end
 
   describe "executable schemas from string" do

data/spec/graphql/schema/catchall_middleware_spec.rb

@@ -2,16 +2,13 @@
 require "spec_helper"
 
 describe GraphQL::Schema::CatchallMiddleware do
-  let(:result) { Dummy::Schema.execute(query_string) }
-  let(:query_string) {%| query noMilk { error }|}
-
-  before do
-    Dummy::Schema.middleware << GraphQL::Schema::CatchallMiddleware
-  end
-
-  after do
-    Dummy::Schema.middleware.delete(GraphQL::Schema::CatchallMiddleware)
+  let(:schema) do
+    Class.new(Dummy::Schema) do
+      middleware GraphQL::Schema::CatchallMiddleware
+    end
   end
+  let(:result) { schema.execute(query_string) }
+  let(:query_string) {%| query noMilk { error }|}
 
   if TESTING_RESCUE_FROM
     describe "rescuing errors" do

data/spec/graphql/schema/input_object_spec.rb

@@ -393,4 +393,29 @@ describe GraphQL::Schema::InputObject do
       assert_equal ["ensembleId", "stringValue", "nestedInput", "legacyInput"], input_type["inputFields"].map { |f| f["name"] }
     end
   end
+
+  describe "warning for method objects" do
+    it "warns for method conflicts" do
+      input_object = Class.new(GraphQL::Schema::InputObject) do
+        graphql_name "X"
+        argument :method, String, required: true
+      end
+
+      expected_warning = "Unable to define a helper for argument with name 'method' as this is a reserved name. Add `method_access: false` to stop this warning.\n"
+      assert_output "", expected_warning do
+        input_object.graphql_definition
+      end
+    end
+
+    it "doesn't warn with `method_access: false`" do
+      input_object = Class.new(GraphQL::Schema::InputObject) do
+        graphql_name "X"
+        argument :method, String, required: true, method_access: false
+      end
+
+      assert_output "", "" do
+        input_object.graphql_definition
+      end
+    end
+  end
 end

data/spec/graphql/schema/loader_spec.rb

@@ -275,7 +275,71 @@ describe GraphQL::Schema::Loader do
       assert type.arguments['sub'].default_value.nil?
     end
 
-    it "sets correct default values `null` on complex field arguments" do
+    it "doesnt warn about method conflicts (because it doesn't make method accesses)" do
+      assert_output "", "" do
+        GraphQL::Schema.from_introspection({
+          "data" => {
+            "__schema" => {
+              "queryType" => {
+                "name" => "Query"
+              },
+              "mutationType" => nil,
+              "subscriptionType" => nil,
+              "types" => [
+                {
+                  "kind" => "OBJECT",
+                  "name" => "Query",
+                  "description" => nil,
+                  "fields" => [
+                    {
+                      "name" => "int",
+                      "description" => nil,
+                      "args" => [
+                        {
+                          "name" => "method",
+                          "description" => nil,
+                          "type" => {
+                            "kind" => "SCALAR",
+                            "name" => "Int",
+                            "ofType" => nil
+                          },
+                          "defaultValue" => nil
+                        }
+                      ],
+                      "type" => {
+                        "kind" => "SCALAR",
+                        "name" => "Int",
+                        "ofType" => nil
+                      },
+                      "isDeprecated" => false,
+                      "deprecationReason" => nil
+                    }
+                  ],
+                  "inputFields" => nil,
+                  "interfaces" => [
+
+                  ],
+                  "enumValues" => nil,
+                  "possibleTypes" => nil
+                },
+                {
+                  "kind" => "SCALAR",
+                  "name" => "Int",
+                  "description" => "Represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.",
+                  "fields" => nil,
+                  "inputFields" => nil,
+                  "interfaces" => nil,
+                  "enumValues" => nil,
+                  "possibleTypes" => nil
+                },
+              ]
+            }
+          }
+        })
+      end
+    end
+
+    it "sets correct default values `nil` on complex field arguments" do
       type = loaded_schema.types['Query']
       field = type.fields['post']
       arg = field.arguments['variedWithNull']