graphql 1.9.0 → 2.1.1

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

data/spec/graphql/analysis/query_depth_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Analysis::QueryDepth do
-  let(:depths) { [] }
-  let(:query_depth) { GraphQL::Analysis::QueryDepth.new { |query, max_depth|  depths << query << max_depth } }
-  let(:reduce_result) { GraphQL::Analysis.analyze_query(query, [query_depth]) }
-  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
-  let(:variables) { {} }
-
-  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
-      reduce_result
-      assert_equal depths, [query, 4]
-    end
-
-    describe "with directives" do
-      let(:variables) { { "isIncluded" => false } }
-      it "doesn't count skipped fields" do
-        reduce_result
-        assert_equal depths.last, 2
-      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
-      reduce_result
-      assert_equal depths, [query, 4]
-    end
-  end
-end

data/spec/graphql/argument_spec.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Argument do
-  it "is validated at schema build-time" do
-    query_type = GraphQL::ObjectType.define do
-      name "Query"
-      field :invalid, types.Boolean do
-        argument :invalid, types.Float, default_value: ["123"]
-      end
-    end
-
-    err = assert_raises(GraphQL::Schema::InvalidTypeError) {
-      schema = GraphQL::Schema.define(query: query_type)
-      schema.types
-    }
-
-    expected_error = %|Query is invalid: field "invalid" argument "invalid" default value ["123"] is not valid for type Float|
-    assert_includes err.message, expected_error
-  end
-
-  describe ".from_dsl" do
-    it "accepts an existing argument" do
-      existing = GraphQL::Argument.define do
-        name "bar"
-        type GraphQL::STRING_TYPE
-      end
-
-      arg = GraphQL::Argument.from_dsl(:foo, existing)
-
-      assert_equal "foo", arg.name
-      assert_equal GraphQL::STRING_TYPE, arg.type
-    end
-
-    it "accepts a definition block after defining kwargs" do
-      arg = GraphQL::Argument.from_dsl(:foo, GraphQL::STRING_TYPE) do
-        description "my type is #{target.type}"
-      end
-
-      assert_equal "my type is String", arg.description
-    end
-
-    it "accepts a definition block and yields the argument if the block has an arity of one" do
-      arg = GraphQL::Argument.from_dsl(:foo, GraphQL::STRING_TYPE) do |argument|
-        argument.description "my type is #{target.type}"
-      end
-
-      assert_equal "my type is String", arg.description
-    end
-
-    it "accepts a definition block with existing arg" do
-      existing = GraphQL::Argument.define do
-        name "bar"
-        type GraphQL::STRING_TYPE
-      end
-
-      arg = GraphQL::Argument.from_dsl(:foo, existing) do
-        description "Description for an existing field."
-      end
-
-      assert_equal "Description for an existing field.", arg.description
-    end
-
-    it "creates an argument from dsl arguments" do
-      arg = GraphQL::Argument.from_dsl(
-        :foo,
-        GraphQL::STRING_TYPE,
-        "A Description",
-        default_value: "Bar"
-      )
-
-      assert_equal "foo", arg.name
-      assert_equal GraphQL::STRING_TYPE, arg.type
-      assert_equal "A Description", arg.description
-      assert_equal "Bar", arg.default_value
-    end
-  end
-
-  it "accepts custom keywords" do
-    type = GraphQL::ObjectType.define do
-      name "Something"
-      field :something, types.String do
-        argument "flagged", types.Int, metadata_flag: :flag_1
-      end
-    end
-
-    arg = type.fields["something"].arguments["flagged"]
-    assert_equal true, arg.metadata[:flag_1]
-  end
-
-  it "accepts proc type" do
-    argument = GraphQL::Argument.define(name: :favoriteFood, type: -> { GraphQL::STRING_TYPE })
-    assert_equal GraphQL::STRING_TYPE, argument.type
-  end
-
-  it "accepts a default_value" do
-    argument = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE, default_value: 'Default')
-    assert_equal 'Default', argument.default_value
-    assert argument.default_value?
-  end
-
-  it "accepts a default_value of nil" do
-    argument = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE, default_value: nil)
-    assert argument.default_value.nil?
-    assert argument.default_value?
-  end
-
-  it "default_value is optional" do
-    argument = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE)
-    assert argument.default_value.nil?
-    assert !argument.default_value?
-  end
-
-  describe "#as, #exposed_as" do
-    it "accepts a `as` property to define the arg name at resolve time" do
-      argument = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE, as: :favFood)
-      assert_equal argument.as, :favFood
-    end
-
-    it "uses `name` or `as` for `expose_as`" do
-      arg_1 = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE, as: :favFood)
-      assert_equal arg_1.expose_as, "favFood"
-      arg_2 = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE)
-      assert_equal arg_2.expose_as, "favoriteFood"
-      arg_3 = arg_2.redefine { as :ff }
-      assert_equal arg_3.expose_as, "ff"
-    end
-
-    it "can be set in the passed block" do
-      argument = GraphQL::Argument.define do
-        name "arg"
-        as "arg_name"
-      end
-      assert_equal "arg_name", argument.as
-    end
-  end
-
-  describe "prepare" do
-    it "accepts a prepare proc and calls it to generate the prepared value" do
-      prepare_proc = Proc.new { |arg, ctx| arg + ctx[:val] }
-      argument = GraphQL::Argument.define(name: :plusOne, type: GraphQL::INT_TYPE, prepare: prepare_proc)
-      assert_equal argument.prepare(1, {val: 1}), 2
-    end
-
-    it "returns the value itself if no prepare proc is provided" do
-      argument = GraphQL::Argument.define(name: :someNumber, type: GraphQL::INT_TYPE)
-      assert_equal argument.prepare(1, nil), 1
-    end
-
-    it "can be set in the passed block" do
-      prepare_proc = Proc.new { |arg, ctx| arg + ctx[:val] }
-      argument = GraphQL::Argument.define do
-        name "arg"
-        prepare prepare_proc
-      end
-      assert_equal argument.prepare(1, {val: 1}), 2
-    end
-  end
-end