graphql 1.9.11 → 1.9.12

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
-  let(:schema) { Class.new(Dummy::Schema) }
-  let(:result) { 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
-      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
-    it "doesn't error" do
-      assert_nil result["errors"]
-    end
-  end
-
-  describe "when the query is less than the max complexity" do
-    before do
-      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
-      schema.max_complexity(100)
-    end
-    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"]
-    end
-  end
-
-  describe "when max_complexity is increased at query-level" do
-    before do
-      schema.max_complexity(1)
-    end
-    let(:result) {schema.execute(query_string, max_complexity: 10) }
-
-    it "doesn't error" do
-      assert_nil result["errors"]
-    end
-  end
-
-  describe "when max_complexity is nil query-level" do
-    before do
-      schema.max_complexity(1)
-    end
-    let(:result) {schema.execute(query_string, max_complexity: nil) }
-
-    it "is applied" do
-      assert_nil result["errors"]
-    end
-  end
-
-  describe "across a multiplex" do
-    before do
-      schema.max_complexity(9)
-    end
-
-    let(:queries) { 5.times.map { |n|  { query: "{ cheese(id: #{n}) { id } }" } } }
-
-    it "returns errors for all queries" do
-      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|
-        assert_equal err_msg, res["errors"][0]["message"]
-      end
-    end
-
-    describe "with a local override" do
-      it "uses the override" do
-        results = 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,103 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Analysis::MaxQueryDepth do
-  let(:schema) { Class.new(Dummy::Schema) }
-  let(:result) { 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) { schema.execute(query_string, max_depth: 100) }
-
-    it "obeys that max_depth" do
-      assert_nil result["errors"]
-    end
-  end
-
-  describe "when the query specifies a nil max_depth" do
-    let(:result) { schema.execute(query_string, max_depth: nil) }
-
-    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
-      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
-      # 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["errors"]
-    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 1, result["errors"].length
-    end
-  end
-end

data/spec/graphql/analysis/query_complexity_spec.rb

@@ -1,301 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Analysis::QueryComplexity do
-  let(:complexities) { [] }
-  let(:query_complexity) { GraphQL::Analysis::QueryComplexity.new { |this_query, complexity|  complexities << this_query << complexity } }
-  let(:reduce_result) { GraphQL::Analysis.analyze_query(query, [query_complexity]) }
-  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
-      reduce_result
-      assert_equal complexities, [query, 7]
-    end
-
-    describe "when skipped by directives" do
-      let(:variables) { { "isSkipped" => true } }
-      it "doesn't include skipped fields" do
-        reduce_result
-        assert_equal complexities, [query, 3]
-      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
-      reduce_result
-      assert_equal complexities, [query, 10]
-    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
-        reduce_result
-        assert_equal 6, complexities.last
-      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
-        reduce_result
-        assert_equal 4, complexities.last
-      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
-        reduce_result
-        assert_equal 3, complexities.last
-      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
-      reduce_result
-      assert_equal 7, complexities.last
-    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
-      reduce_result
-      # 10 from `complexity`, `0.3` from `value`
-      assert_equal complexities, [query, 10.3]
-    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
-        reduce_result
-        # 1 for innerComplexity + 4 for DoubleComplexity.value
-        assert_equal complexities, [query, 5]
-      end
-    end
-  end
-end