graphql 1.9.0 → 2.1.1

data/spec/graphql/analysis/ast_spec.rb

@@ -1,269 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Analysis::AST do
-  class AstTypeCollector < GraphQL::Analysis::AST::Analyzer
-    def initialize(query)
-      super
-      @types = []
-    end
-
-    def on_enter_operation_definition(node, parent, visitor)
-      @types << visitor.type_definition
-    end
-
-    def on_enter_field(memo, node, visitor)
-      @types << visitor.field_definition.type.unwrap
-    end
-
-    def result
-      @types
-    end
-  end
-
-  class AstNodeCounter < GraphQL::Analysis::AST::Analyzer
-    def initialize(query)
-      super
-      @nodes = Hash.new { |h,k| h[k] = 0 }
-    end
-
-    def on_enter_abstract_node(node, parent, _visitor)
-      @nodes[node.class] += 1
-    end
-
-    def result
-      @nodes
-    end
-  end
-
-  class AstConditionalAnalyzer < GraphQL::Analysis::AST::Analyzer
-    def initialize(query)
-      super
-      @i_have_been_called = false
-    end
-
-    def analyze?
-      !!query.context[:analyze]
-    end
-
-    def on_operation_definition(node, parent, visitor)
-      @i_have_been_called = true
-    end
-
-    def result
-      @i_have_been_called
-    end
-  end
-
-  class AstErrorAnalyzer < GraphQL::Analysis::AST::Analyzer
-    def result
-      GraphQL::AnalysisError.new("An Error!")
-    end
-  end
-
-  class AstPreviousField < GraphQL::Analysis::AST::Analyzer
-    def on_enter_field(node, parent, visitor)
-      @previous_field = visitor.previous_field_definition
-    end
-
-    def result
-      @previous_field
-    end
-  end
-
-  describe "using the AST analysis engine" do
-    let(:schema) do
-      query_type = Class.new(GraphQL::Schema::Object) do
-        graphql_name 'Query'
-
-        field :foobar, Integer, null: false
-
-        def foobar
-          1337
-        end
-      end
-
-      Class.new(GraphQL::Schema) do
-        query query_type
-        use GraphQL::Analysis::AST
-        query_analyzer AstErrorAnalyzer
-        use GraphQL::Execution::Interpreter
-      end
-    end
-
-    let(:query_string) {%|
-      query {
-        foobar
-      }
-    |}
-
-    let(:query) { GraphQL::Query.new(schema, query_string, variables: {}) }
-
-    it "runs the AST analyzers correctly" do
-      res = query.result
-      refute res.key?("data")
-      assert_equal ["An Error!"], res["errors"].map { |e| e["message"] }
-    end
-
-    it "skips rewrite" do
-      # Try running the query:
-      query.result
-      # But the validation step doesn't build an irep_node tree
-      assert_nil query.irep_selection
-    end
-
-    describe "when validate: false" do
-      let(:query) { GraphQL::Query.new(schema, query_string, validate: false) }
-      it "Skips rewrite" do
-        # Try running the query:
-        query.result
-        # But the validation step doesn't build an irep_node tree
-        assert_nil query.irep_selection
-      end
-    end
-  end
-
-  describe ".analyze_query" do
-    let(:analyzers) { [AstTypeCollector, AstNodeCounter] }
-    let(:reduce_result) { GraphQL::Analysis::AST.analyze_query(query, analyzers) }
-    let(:variables) { {} }
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
-    let(:query_string) {%|
-      {
-        cheese(id: 1) {
-          id
-          flavor
-        }
-      }
-    |}
-
-    describe "without a selected operation" do
-      let(:query_string) {%|
-        # A comment
-        # And nothing else
-        # Should not break
-      |}
-
-      it "bails early when there is no selected operation to be executed" do
-        assert_equal 2, reduce_result.size
-      end
-    end
-
-    describe "conditional analysis" do
-      let(:analyzers) { [AstTypeCollector, AstConditionalAnalyzer] }
-
-      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
-
-      describe "Visitor#previous_field_definition" do
-        let(:analyzers) { [AstPreviousField] }
-        let(:query) { GraphQL::Query.new(Dummy::Schema, "{ __schema { types { name } } }") }
-
-        it "it runs the analyzer" do
-          prev_field = reduce_result.first
-          assert_equal "__Schema.types", prev_field.metadata[:type_class].path
-        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,
-        GraphQL::Language::Nodes::Argument => 1
-      }
-
-      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] }
-          Dummy::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
-
-    class AstConnectionCounter < GraphQL::Analysis::AST::Analyzer
-      def initialize(query)
-        super
-        @fields = 0
-        @connections = 0
-      end
-
-      def on_enter_field(node, parent, visitor)
-        if visitor.field_definition.connection?
-          @connections += 1
-        else
-          @fields += 1
-        end
-      end
-
-      def result
-        {
-          fields: @fields,
-          connections: @connections
-        }
-      end
-    end
-
-    describe "when processing fields" do
-      let(:analyzers) { [AstConnectionCounter] }
-      let(:reduce_result) { GraphQL::Analysis::AST.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 = {
-          :fields => 5,
-          :connections => 2
-        }
-        assert_equal expected_connection_counts, connection_counts
-      end
-    end
-  end
-end

data/spec/graphql/analysis/field_usage_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Analysis::FieldUsage do
-  let(:result) { [] }
-  let(:field_usage_analyzer) { GraphQL::Analysis::FieldUsage.new { |query, used_fields, used_deprecated_fields| result << query << used_fields << used_deprecated_fields } }
-  let(:reduce_result) { GraphQL::Analysis.analyze_query(query, [field_usage_analyzer]) }
-  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 "returns query in reduced result" do
-      reduce_result
-      assert_equal query, result[0]
-    end
-
-    it "keeps track of used fields" do
-      reduce_result
-      assert_equal ['Cheese.id', 'Cheese.fatContent', 'Query.cheese'], result[1]
-    end
-
-    it "keeps track of deprecated fields" do
-      reduce_result
-      assert_equal ['Cheese.fatContent'], result[2]
-    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
-      reduce_result
-      assert_equal ['Cheese.id', 'Cheese.fatContent', 'Query.cheese'], result[1]
-    end
-
-    it "omits duplicate usage of a deprecated field" do
-      reduce_result
-      assert_equal ['Cheese.fatContent'], result[2]
-    end
-  end
-end

data/spec/graphql/analysis/max_query_complexity_spec.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-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(: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 }
-    }
-  |}
-
-  describe "when a query goes over max complexity" do
-    before do
-      Dummy::Schema.max_complexity = 9
-    end
-
-    it "returns an error" do
-      assert_equal "Query has complexity of 10, which exceeds max complexity of 9", result["errors"][0]["message"]
-    end
-  end
-
-  describe "when there is no max complexity" do
-    before do
-      Dummy::Schema.max_complexity = nil
-    end
-    it "doesn't error" do
-      assert_nil result["errors"]
-    end
-  end
-
-  describe "when the query is less than the max complexity" do
-    before do
-      Dummy::Schema.max_complexity = 99
-    end
-    it "doesn't error" do
-      assert_nil result["errors"]
-    end
-  end
-
-  describe "when max_complexity is decreased at query-level" do
-    before do
-      Dummy::Schema.max_complexity = 100
-    end
-    let(:result) { Dummy::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"]
-    end
-  end
-
-  describe "when max_complexity is increased at query-level" do
-    before do
-      Dummy::Schema.max_complexity = 1
-    end
-    let(:result) { Dummy::Schema.execute(query_string, max_complexity: 10) }
-
-    it "doesn't error" do
-      assert_nil result["errors"]
-    end
-  end
-
-  describe "across a multiplex" do
-    before do
-      Dummy::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)
-      assert_equal 5, results.length
-      err_msg = "Query has complexity of 10, which exceeds max complexity of 9"
-      results.each do |res|
-        assert_equal err_msg, res["errors"][0]["message"]
-      end
-    end
-
-    describe "with a local override" do
-      it "uses the override" do
-        results = Dummy::Schema.multiplex(queries, max_complexity: 10)
-        assert_equal 5, results.length
-        results.each do |res|
-          assert_equal true, res.key?("data")
-          assert_equal false, res.key?("errors")
-        end
-      end
-    end
-  end
-end

data/spec/graphql/analysis/max_query_depth_spec.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-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(:query_string) { "
-    {
-      cheese(id: 1) {
-        similarCheese(source: SHEEP) {
-          similarCheese(source: SHEEP) {
-            similarCheese(source: SHEEP) {
-              similarCheese(source: SHEEP) {
-                similarCheese(source: SHEEP) {
-                  id
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  "}
-
-  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["errors"][0]["message"]
-    end
-  end
-
-  describe "when the query specifies a different max_depth" do
-    let(:result) { Dummy::Schema.execute(query_string, max_depth: 100) }
-
-    it "obeys that max_depth" do
-      assert_nil result["errors"]
-    end
-  end
-
-  describe "When the query is not deeper than max_depth" do
-    before do
-      Dummy::Schema.max_depth = 100
-    end
-
-    it "doesn't add an error" do
-      assert_nil result["errors"]
-    end
-  end
-
-  describe "when the max depth isn't set" do
-    before do
-      Dummy::Schema.max_depth = nil
-    end
-
-    it "doesn't add an error message" do
-      assert_nil result["errors"]
-    end
-  end
-
-  describe "when a fragment exceeds max depth" do
-    before do
-      Dummy::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 1, result["errors"].length
-    end
-  end
-end