graphql 1.9.11 → 1.9.12

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -1,261 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Analysis do
-  class TypeCollector
-    def initial_value(query)
-      []
-    end
-
-    def call(memo, visit_type, irep_node)
-      if visit_type == :enter
-        memo + [irep_node.return_type.unwrap]
-      else
-        memo
-      end
-    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
-
-  let(:schema) { Class.new(Dummy::Schema) }
-
-  describe ".analyze_query" do
-    let(:node_counter) {
-      ->(memo, visit_type, irep_node) {
-        memo ||= Hash.new { |h,k| h[k] = 0 }
-        visit_type == :enter && memo[irep_node.ast_node.class] += 1
-        memo
-      }
-    }
-    let(:type_collector) { TypeCollector.new }
-    let(:analyzers) { [type_collector, node_counter] }
-    let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
-    let(:variables) { {} }
-    let(:query) { GraphQL::Query.new(schema, query_string, variables: variables) }
-    let(:query_string) {%|
-      {
-        cheese(id: 1) {
-          id
-          flavor
-        }
-      }
-    |}
-
-    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(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(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::DairyAppQuery.graphql_definition, Dummy::Cheese.graphql_definition, GraphQL::INT_TYPE, GraphQL::STRING_TYPE]
-      assert_equal expected_visited_types, collected_types
-      expected_node_counts = {
-        GraphQL::Language::Nodes::OperationDefinition => 1,
-        GraphQL::Language::Nodes::Field => 3,
-      }
-      assert_equal expected_node_counts, node_counts
-    end
-
-    describe "tracing" do
-      let(:query_string) { "{ t: __typename }"}
-
-      it "emits traces" do
-        traces = TestTracing.with_trace do
-          ctx = { tracers: [TestTracing] }
-          schema.execute(query_string, context: ctx)
-        end
-
-        # The query_trace is on the list _first_ because it finished first
-        _lex, _parse, _validate, query_trace, multiplex_trace, *_rest = traces
-
-        assert_equal "analyze_multiplex", multiplex_trace[:key]
-        assert_instance_of GraphQL::Execution::Multiplex, multiplex_trace[:multiplex]
-
-        assert_equal "analyze_query", query_trace[:key]
-        assert_instance_of GraphQL::Query, query_trace[:query]
-      end
-    end
-
-    describe "when a variable is missing" do
-      let(:query_string) {%|
-        query something($cheeseId: Int!){
-          cheese(id: $cheeseId) {
-            id
-            flavor
-          }
-        }
-      |}
-      let(:variable_accessor) { ->(memo, visit_type, irep_node) { query.variables["cheeseId"] } }
-
-      before do
-        schema.query_analyzer(variable_accessor)
-      end
-
-      it "returns an error" do
-        error = query.result["errors"].first
-        assert_equal "Variable cheeseId of type Int! was provided invalid value", error["message"]
-      end
-    end
-
-    describe "when processing fields" do
-      let(:connection_counter) {
-        ->(memo, visit_type, irep_node) {
-          memo ||= Hash.new { |h,k| h[k] = 0 }
-          if visit_type == :enter
-            if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
-              if irep_node.definition.connection?
-                memo[:connection] ||= 0
-                memo[:connection] += 1
-              else
-                memo[:field] ||= 0
-                memo[:field] += 1
-              end
-            end
-          end
-          memo
-        }
-      }
-      let(:analyzers) { [connection_counter] }
-      let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
-      let(:query) { GraphQL::Query.new(StarWars::Schema, query_string, variables: variables) }
-      let(:query_string) {%|
-        query getBases {
-          empire {
-            basesByName(first: 30) { edges { cursor } }
-            bases(first: 30) { edges { cursor } }
-          }
-        }
-      |}
-
-      it "knows which fields are connections" do
-        connection_counts = reduce_result.first
-        expected_connection_counts = {
-          :field => 5,
-          :connection => 2
-        }
-        assert_equal expected_connection_counts, connection_counts
-      end
-    end
-  end
-
-  describe ".visit_analyzers" do
-    class IdCatcher
-      def call(memo, visit_type, irep_node)
-        if visit_type == :enter
-          if irep_node.ast_node.name == "id"
-            raise GraphQL::AnalysisError.new("Don't use the id field.", ast_node: irep_node.ast_node)
-          end
-        end
-        memo
-      end
-    end
-
-    class FlavorCatcher
-      def initial_value(query)
-        {
-          :errors => []
-        }
-      end
-
-      def call(memo, visit_type, irep_node)
-        if visit_type == :enter
-          if irep_node.ast_node.name == "flavor"
-            memo[:errors] << GraphQL::AnalysisError.new("Don't use the flavor field.", ast_node: irep_node.ast_node)
-          end
-        end
-        memo
-      end
-
-      def final_value(memo)
-        memo[:errors]
-      end
-    end
-
-    let(:id_catcher) { IdCatcher.new }
-    let(:flavor_catcher) { FlavorCatcher.new }
-    let(:analyzers) { [id_catcher, flavor_catcher] }
-    let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
-    let(:query) { GraphQL::Query.new(schema, query_string) }
-    let(:query_string) {%|
-      {
-        cheese(id: 1) {
-          id
-          flavor
-        }
-      }
-    |}
-    let(:schema) do
-      schema = Class.new(Dummy::Schema)
-      schema.query_analyzer(id_catcher)
-      schema.query_analyzer(flavor_catcher)
-      schema
-    end
-    let(:result) { schema.execute(query_string) }
-    let(:query_string) {%|
-      {
-        cheese(id: 1) {
-          id
-          flavor
-        }
-      }
-    |}
-
-    it "groups all errors together" do
-      data = result["data"]
-      errors = result["errors"]
-
-      id_error_hash = errors[0]
-      flavor_error_hash = errors[1]
-
-      id_error_response = {
-        "message"=>"Don't use the id field.",
-        "locations"=>[{"line"=>4, "column"=>11}]
-      }
-      flavor_error_response = {
-        "message"=>"Don't use the flavor field.",
-        "locations"=>[{"line"=>5, "column"=>11}]
-      }
-
-      assert_nil data
-
-      assert_equal id_error_response["message"], id_error_hash["message"]
-      assert_equal id_error_response["locations"], id_error_hash["locations"]
-
-      assert_equal flavor_error_response["message"], flavor_error_hash["message"]
-      assert_equal flavor_error_response["locations"], flavor_error_hash["locations"]
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Analysis::AST::FieldUsage do
-  let(:result) { GraphQL::Analysis::AST.analyze_query(query, [GraphQL::Analysis::AST::FieldUsage]).first }
-  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
-  let(:variables) { {} }
-
-  describe "query with deprecated fields" do
-    let(:query_string) {%|
-      query {
-        cheese(id: 1) {
-          id
-          fatContent
-        }
-      }
-    |}
-
-    it "keeps track of used fields" do
-      assert_equal ['Cheese.id', 'Cheese.fatContent', 'Query.cheese'], result[:used_fields]
-    end
-
-    it "keeps track of deprecated fields" do
-      assert_equal ['Cheese.fatContent'], result[:used_deprecated_fields]
-    end
-  end
-
-  describe "query with deprecated fields used more than once" do
-    let(:query_string) {%|
-      query {
-        cheese1: cheese(id: 1) {
-          id
-          fatContent
-        }
-
-        cheese2: cheese(id: 2) {
-          id
-          fatContent
-        }
-      }
-    |}
-
-    it "omits duplicate usage of a field" do
-      assert_equal ['Cheese.id', 'Cheese.fatContent', 'Query.cheese'], result[:used_fields]
-    end
-
-    it "omits duplicate usage of a deprecated field" do
-      assert_equal ['Cheese.fatContent'], result[:used_deprecated_fields]
-    end
-  end
-end

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

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Analysis::AST::MaxQueryComplexity do
-  let(:schema) { Class.new(Dummy::Schema) }
-  let(:query_string) {%|
-    {
-      a: cheese(id: 1) { id }
-      b: cheese(id: 1) { id }
-      c: cheese(id: 1) { id }
-      d: cheese(id: 1) { id }
-      e: cheese(id: 1) { id }
-    }
-  |}
-  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
-  }
-
-
-  describe "when a query goes over max complexity" do
-    let(:max_complexity) { 9 }
-
-    it "returns an error" do
-      assert_equal GraphQL::AnalysisError, result.class
-      assert_equal "Query has complexity of 10, which exceeds max complexity of 9", result.message
-    end
-  end
-
-  describe "when there is no max complexity" do
-    let(:max_complexity) { nil }
-
-    it "doesn't error" do
-      assert_nil result
-    end
-  end
-
-  describe "when the query is less than the max complexity" do
-    let(:max_complexity) { 99 }
-
-    it "doesn't error" do
-      assert_nil result
-    end
-  end
-
-  describe "when max_complexity is decreased at query-level" do
-    before do
-      schema.max_complexity(100)
-    end
-
-    let(:max_complexity) { 7 }
-
-    it "is applied" do
-      assert_equal GraphQL::AnalysisError, result.class
-      assert_equal "Query has complexity of 10, which exceeds max complexity of 7", result.message
-    end
-  end
-
-  describe "when max_complexity is increased at query-level" do
-    before do
-      schema.max_complexity(1)
-    end
-
-    let(:max_complexity) { 10 }
-
-    it "doesn't error" do
-      assert_nil result
-    end
-  end
-
-  describe "when max_complexity is nil at query-level" do
-    let(:max_complexity) { nil }
-
-    before do
-      schema.max_complexity(1)
-    end
-
-    it "is applied" do
-      assert_nil result
-    end
-  end
-
-  describe "across a multiplex" do
-    before do
-      schema.analysis_engine = GraphQL::Analysis::AST
-    end
-
-    let(:queries) {
-      5.times.map { |n|
-        GraphQL::Query.new(schema, "{ cheese(id: #{n}) { id } }", variables: {})
-      }
-    }
-
-    let(:max_complexity) { 9 }
-    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])
-    }
-
-    it "returns errors for all queries" do
-      analyze_multiplex
-      err_msg = "Query has complexity of 10, which exceeds max complexity of 9"
-      queries.each do |query|
-        assert_equal err_msg, query.analysis_errors[0].message
-      end
-    end
-
-    describe "with a local override" do
-      let(:max_complexity) { 10 }
-
-      it "uses the override" do
-        analyze_multiplex
-
-        queries.each do |query|
-          assert query.analysis_errors.empty?
-        end
-      end
-    end
-  end
-end

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

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Analysis::AST::MaxQueryDepth do
-  let(:schema) { Class.new(Dummy::Schema) }
-  let(:query_string) { "
-    {
-      cheese(id: 1) {
-        similarCheese(source: SHEEP) {
-          similarCheese(source: SHEEP) {
-            similarCheese(source: SHEEP) {
-              similarCheese(source: SHEEP) {
-                similarCheese(source: SHEEP) {
-                  id
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  "}
-  let(:query) { GraphQL::Query.new(schema, query_string) }
-  let(:result) {
-    GraphQL::Analysis::AST.analyze_query(query, [GraphQL::Analysis::AST::MaxQueryDepth]).first
-  }
-
-  describe "when the query is deeper than max depth" do
-    it "adds an error message for a too-deep query" do
-      assert_equal "Query has depth of 7, which exceeds max depth of 5", result.message
-    end
-  end
-
-  describe "when the query specifies a different max_depth" do
-    let(:query) { GraphQL::Query.new(schema, query_string, max_depth: 100) }
-
-    it "obeys that max_depth" do
-      assert_nil result
-    end
-  end
-
-  describe "when the query disables max_depth" do
-    let(:query) { GraphQL::Query.new(schema, query_string, max_depth: nil) }
-
-    it "obeys that max_depth" do
-      assert_nil result
-    end
-  end
-
-  describe "When the query includes introspective fields" do
-    let(:query_string) { "
-    query allSchemaTypes {
-      __schema {
-         types {
-            fields {
-              type {
-                fields {
-                  type {
-                    fields {
-                      type {
-                        name
-                      }
-                    }
-                  }
-                }
-              }
-            }
-         }
-      }
-    }
-  "}
-
-    it "adds an error message for a too-deep query" do
-      assert_equal "Query has depth of 9, which exceeds max depth of 5", result.message
-    end
-  end
-
-  describe "When the query is not deeper than max_depth" do
-    before do
-      schema.max_depth(100)
-    end
-
-    it "doesn't add an error" do
-      assert_nil result
-    end
-  end
-
-  describe "when the max depth isn't set" do
-    before do
-      # Yuck - Can't override GraphQL::Schema.max_depth to return nil if it has already been set
-      schema.define_singleton_method(:max_depth) { |*| nil }
-    end
-
-    it "doesn't add an error message" do
-      assert_nil result
-    end
-  end
-
-  describe "when a fragment exceeds max depth" do
-    before do
-      schema.max_depth(4)
-    end
-
-    let(:query_string) { "
-      {
-        cheese(id: 1) {
-          ...moreFields
-        }
-      }
-
-      fragment moreFields on Cheese {
-        similarCheese(source: SHEEP) {
-          similarCheese(source: SHEEP) {
-            similarCheese(source: SHEEP) {
-              ...evenMoreFields
-            }
-          }
-        }
-      }
-
-      fragment evenMoreFields on Cheese {
-        similarCheese(source: SHEEP) {
-          similarCheese(source: SHEEP) {
-            id
-          }
-        }
-      }
-    "}
-
-    it "adds an error message for a too-deep query" do
-      assert_equal "Query has depth of 7, which exceeds max depth of 4", result.message
-    end
-  end
-end