graphql 1.9.0 → 2.1.1

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
-  before do
-    @prev_max_complexity = Dummy::Schema.max_complexity
-  end
-
-  after do
-    Dummy::Schema.max_complexity = @prev_max_complexity
-  end
-
-  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(Dummy::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
-      Dummy::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
-      Dummy::Schema.max_complexity = 1
-    end
-
-    let(:max_complexity) { 10 }
-
-    it "doesn't error" do
-      assert_nil result
-    end
-  end
-
-  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
-    end
-
-    let(:queries) {
-      5.times.map { |n|
-        GraphQL::Query.new(Dummy::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(: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,114 +0,0 @@
-# frozen_string_literal: true
-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(:query_string) { "
-    {
-      cheese(id: 1) {
-        similarCheese(source: SHEEP) {
-          similarCheese(source: SHEEP) {
-            similarCheese(source: SHEEP) {
-              similarCheese(source: SHEEP) {
-                similarCheese(source: SHEEP) {
-                  id
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  "}
-  let(:max_depth) { nil }
-  let(:query) {
-    GraphQL::Query.new(
-      Dummy::Schema.graphql_definition,
-      query_string,
-      variables: {},
-      max_depth: max_depth
-    )
-  }
-  let(:result) {
-    GraphQL::Analysis::AST.analyze_query(query, [GraphQL::Analysis::AST::MaxQueryDepth]).first
-  }
-
-  describe "when the query is deeper than max depth" do
-    let(:max_depth) { 5 }
-
-    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(:max_depth) { 100 }
-
-    it "obeys that max_depth" do
-      assert_nil result
-    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
-    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
-    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 "Query has depth of 7, which exceeds max depth of 4", result.message
-    end
-  end
-end

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