graphql 1.9.11 → 1.9.12

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

@@ -1,299 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Analysis::AST::QueryComplexity do
-  let(:reduce_result) { GraphQL::Analysis::AST.analyze_query(query, [GraphQL::Analysis::AST::QueryComplexity]) }
-  let(:variables) { {} }
-  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
-
-  describe "simple queries" do
-    let(:query_string) {%|
-      query cheeses($isSkipped: Boolean = false){
-        # complexity of 3
-        cheese1: cheese(id: 1) {
-          id
-          flavor
-        }
-
-        # complexity of 4
-        cheese2: cheese(id: 2) @skip(if: $isSkipped) {
-          similarCheese(source: SHEEP) {
-            ... on Cheese {
-              similarCheese(source: SHEEP) {
-                id
-              }
-            }
-          }
-        }
-      }
-    |}
-
-    it "sums the complexity" do
-      complexities = reduce_result.first
-      assert_equal 7, complexities
-    end
-
-    describe "when skipped by directives" do
-      let(:variables) { { "isSkipped" => true } }
-      it "doesn't include skipped fields" do
-        complexity = reduce_result.first
-        assert_equal 3, complexity
-      end
-    end
-  end
-
-  describe "query with fragments" do
-    let(:query_string) {%|
-      {
-        # complexity of 3
-        cheese1: cheese(id: 1) {
-          id
-          flavor
-        }
-
-        # complexity of 7
-        cheese2: cheese(id: 2) {
-          ... cheeseFields1
-          ... cheeseFields2
-        }
-      }
-
-      fragment cheeseFields1 on Cheese {
-        similarCow: similarCheese(source: COW) {
-          id
-          ... cheeseFields2
-        }
-      }
-
-      fragment cheeseFields2 on Cheese {
-        similarSheep: similarCheese(source: SHEEP) {
-          id
-        }
-      }
-    |}
-
-    it "counts all fragment usages, not the definitions" do
-      complexity = reduce_result.first
-      assert_equal 10, complexity
-    end
-
-    describe "mutually exclusive types" do
-      let(:query_string) {%|
-        {
-          favoriteEdible {
-            # 1 for everybody
-            fatContent
-
-            # 1 for everybody
-            ... on Edible {
-              origin
-            }
-
-            # 1 for honey
-            ... on Sweetener {
-              sweetness
-            }
-
-            # 2 for milk
-            ... milkFields
-            # 1 for cheese
-            ... cheeseFields
-            # 1 for honey
-            ... honeyFields
-            # 1 for milk + cheese
-            ... dairyProductFields
-          }
-        }
-
-        fragment milkFields on Milk {
-          id
-          source
-        }
-
-        fragment cheeseFields on Cheese {
-          source
-        }
-
-        fragment honeyFields on Honey {
-          flowerType
-        }
-
-        fragment dairyProductFields on DairyProduct {
-          ... on Cheese {
-            flavor
-          }
-
-          ... on Milk {
-            flavors
-          }
-        }
-      |}
-
-      it "gets the max among options" do
-        complexity = reduce_result.first
-        assert_equal 6, complexity
-      end
-    end
-
-
-    describe "when there are no selections on any object types" do
-      let(:query_string) {%|
-        {
-          # 1 for everybody
-          favoriteEdible {
-            # 1 for everybody
-            fatContent
-
-            # 1 for everybody
-            ... on Edible { origin }
-
-            # 1 for honey
-            ... on Sweetener { sweetness }
-          }
-        }
-      |}
-
-      it "gets the max among interface types" do
-        complexity = reduce_result.first
-        assert_equal 4, complexity
-      end
-    end
-
-    describe "redundant fields" do
-      let(:query_string) {%|
-      {
-        favoriteEdible {
-          fatContent
-          # this is executed separately and counts separately:
-          aliasedFatContent: fatContent
-
-          ... on Edible {
-            fatContent
-          }
-
-          ... edibleFields
-        }
-      }
-
-      fragment edibleFields on Edible {
-        fatContent
-      }
-      |}
-
-      it "only counts them once" do
-        complexity = reduce_result.first
-        assert_equal 3, complexity
-      end
-    end
-  end
-
-  describe "relay types" do
-    let(:query) { GraphQL::Query.new(StarWars::Schema, query_string) }
-    let(:query_string) {%|
-    {
-      rebels {
-        ships {
-          edges {
-            node {
-              id
-            }
-          }
-          pageInfo {
-            hasNextPage
-          }
-        }
-      }
-    }
-    |}
-
-    it "gets the complexity" do
-      complexity = reduce_result.first
-      assert_equal 7, complexity
-    end
-  end
-
-  describe "custom complexities" do
-    let(:query) { GraphQL::Query.new(complexity_schema, query_string) }
-    let(:complexity_schema) {
-      complexity_interface = GraphQL::InterfaceType.define do
-        name "ComplexityInterface"
-        field :value, types.Int
-      end
-
-      single_complexity_type = GraphQL::ObjectType.define do
-        name "SingleComplexity"
-        field :value, types.Int, complexity: 0.1 do
-          resolve ->(obj, args, ctx) { obj }
-        end
-        field :complexity, single_complexity_type do
-          argument :value, types.Int
-          complexity ->(ctx, args, child_complexity) { args[:value] + child_complexity }
-          resolve ->(obj, args, ctx) { args[:value] }
-        end
-        interfaces [complexity_interface]
-      end
-
-      double_complexity_type = GraphQL::ObjectType.define do
-        name "DoubleComplexity"
-        field :value, types.Int, complexity: 4 do
-          resolve ->(obj, args, ctx) { obj }
-        end
-        interfaces [complexity_interface]
-      end
-
-      query_type = GraphQL::ObjectType.define do
-        name "Query"
-        field :complexity, single_complexity_type do
-          argument :value, types.Int
-          complexity ->(ctx, args, child_complexity) { args[:value] + child_complexity }
-          resolve ->(obj, args, ctx) { args[:value] }
-        end
-
-        field :innerComplexity, complexity_interface do
-          argument :value, types.Int
-          resolve ->(obj, args, ctx) { args[:value] }
-        end
-      end
-
-      GraphQL::Schema.define(
-        query: query_type,
-        orphan_types: [double_complexity_type],
-        resolve_type: ->(a,b,c) { :pass }
-      )
-    }
-    let(:query_string) {%|
-      {
-        a: complexity(value: 3) { value }
-        b: complexity(value: 6) {
-          value
-          complexity(value: 1) {
-            value
-          }
-        }
-      }
-    |}
-
-    it "sums the complexity" do
-      complexity = reduce_result.first
-      # 10 from `complexity`, `0.3` from `value`
-      assert_equal 10.3, complexity
-    end
-
-    describe "same field on multiple types" do
-      let(:query_string) {%|
-      {
-        innerComplexity(value: 2) {
-          ... on SingleComplexity { value }
-          ... on DoubleComplexity { value }
-        }
-      }
-      |}
-
-      it "picks them max for those fields" do
-        complexity = reduce_result.first
-        # 1 for innerComplexity + 4 for DoubleComplexity.value
-        assert_equal 5, complexity
-      end
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Analysis::AST::QueryDepth do
-  let(:result) { GraphQL::Analysis::AST.analyze_query(query, [GraphQL::Analysis::AST::QueryDepth]) }
-  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
-  let(:variables) { {} }
-
-  describe "multiple operations" do
-    let(:query_string) {%|
-      query Cheese1 {
-        cheese1: cheese(id: 1) {
-          id
-          flavor
-        }
-      }
-
-      query Cheese2 {
-        cheese(id: 2) {
-          similarCheese(source: SHEEP) {
-            ... on Cheese {
-              similarCheese(source: SHEEP) {
-                id
-              }
-            }
-          }
-        }
-      }
-    |}
-
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables, operation_name: "Cheese1") }
-
-    it "analyzes the selected operation only" do
-      depth = result.first
-      assert_equal 2, depth
-    end
-  end
-
-  describe "simple queries" do
-    let(:query_string) {%|
-      query cheeses($isIncluded: Boolean = true){
-        # depth of 2
-        cheese1: cheese(id: 1) {
-          id
-          flavor
-        }
-
-        # depth of 4
-        cheese2: cheese(id: 2) @include(if: $isIncluded) {
-          similarCheese(source: SHEEP) {
-            ... on Cheese {
-              similarCheese(source: SHEEP) {
-                id
-              }
-            }
-          }
-        }
-      }
-    |}
-
-    it "finds the max depth" do
-      depth = result.first
-      assert_equal 4, depth
-    end
-
-    describe "with directives" do
-      let(:variables) { { "isIncluded" => false } }
-
-      it "doesn't count skipped fields" do
-        assert_equal 2, result.first
-      end
-    end
-  end
-
-  describe "query with fragments" do
-    let(:query_string) {%|
-      {
-        # depth of 2
-        cheese1: cheese(id: 1) {
-          id
-          flavor
-        }
-
-        # depth of 4
-        cheese2: cheese(id: 2) {
-          ... cheeseFields1
-        }
-      }
-
-      fragment cheeseFields1 on Cheese {
-        similarCheese(source: COW) {
-          id
-          ... cheeseFields2
-        }
-      }
-
-      fragment cheeseFields2 on Cheese {
-        similarCheese(source: SHEEP) {
-          id
-        }
-      }
-    |}
-
-    it "finds the max depth" do
-      assert_equal 4, result.first
-    end
-  end
-end

data/spec/graphql/analysis/ast_spec.rb

@@ -1,296 +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
-
-  class AstArguments < GraphQL::Analysis::AST::Analyzer
-    def on_enter_argument(node, parent, visitor)
-      @argument = visitor.argument_definition
-      @previous_argument = visitor.previous_argument_definition
-    end
-
-    def result
-      [@argument, @previous_argument]
-    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
-
-      describe "Visitor#argument_definition" do
-        let(:analyzers) { [AstArguments] }
-        let(:query) do
-          GraphQL::Query.new(
-            Dummy::Schema,
-            '{ searchDairy(product: [{ source: "SHEEP" }]) { ... on Cheese { id } } }'
-          )
-        end
-
-        it "it runs the analyzer" do
-          argument, prev_argument = reduce_result.first
-          assert_equal "DairyProductInput.source", argument.metadata[:type_class].path
-          assert_equal "Query.searchDairy.product", prev_argument.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