graphql 0.16.0 → 2.0.15

data/spec/graphql/analysis/query_complexity_spec.rb

@@ -1,235 +0,0 @@
-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(DummySchema, 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 5, complexities.last
-      end
-    end
-
-
-    describe "when there are no selections on any object types" do
-      let(:query_string) {%|
-        {
-          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 3, 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 "custom complexities" do
-    let(:query) { GraphQL::Query.new(complexity_schema, query_string) }
-    let(:complexity_schema) {
-      complexity_type = GraphQL::ObjectType.define do
-        name "Complexity"
-        field :value, types.Int, complexity: 0.1 do
-          resolve -> (obj, args, ctx) { obj }
-        end
-        field :complexity, -> { complexity_type } do
-          argument :value, types.Int
-          complexity -> (ctx, args, child_complexity) { args[:value] + child_complexity }
-          resolve -> (obj, args, ctx) { args[:value] }
-        end
-      end
-
-      query_type = GraphQL::ObjectType.define do
-        name "Query"
-        field :complexity, -> { complexity_type } do
-          argument :value, types.Int
-          complexity -> (ctx, args, child_complexity) { args[:value] + child_complexity }
-          resolve -> (obj, args, ctx) { args[:value] }
-        end
-      end
-
-      GraphQL::Schema.new(query: query_type)
-    }
-    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
-  end
-end

data/spec/graphql/analysis/query_depth_spec.rb

@@ -1,80 +0,0 @@
-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(DummySchema, 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,20 +0,0 @@
-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 {
-      schema = GraphQL::Schema.new(query: query_type)
-      schema.types
-    }
-
-    expected_error = %|Query is invalid: field "invalid" argument "invalid" default value ["123"] is not valid for type Float|
-    assert_equal expected_error, err.message
-  end
-end

data/spec/graphql/base_type_spec.rb

@@ -1,24 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::BaseType do
-  it "becomes non-null with !" do
-    type = GraphQL::EnumType.new
-    non_null_type = !type
-    assert_equal(GraphQL::TypeKinds::NON_NULL, non_null_type.kind)
-    assert_equal(type, non_null_type.of_type)
-    assert_equal(GraphQL::TypeKinds::NON_NULL, (!GraphQL::STRING_TYPE).kind)
-  end
-
-  it "can be compared" do
-    assert_equal(!GraphQL::INT_TYPE, !GraphQL::INT_TYPE)
-    refute_equal(!GraphQL::FLOAT_TYPE, GraphQL::FLOAT_TYPE)
-    assert_equal(
-      GraphQL::ListType.new(of_type: MilkType),
-      GraphQL::ListType.new(of_type: MilkType)
-    )
-    refute_equal(
-      GraphQL::ListType.new(of_type: MilkType),
-      GraphQL::ListType.new(of_type: !MilkType)
-    )
-  end
-end

data/spec/graphql/boolean_type_spec.rb

@@ -1,20 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::BOOLEAN_TYPE do
-  describe "coerce_input" do
-    def coerce_input(input)
-      GraphQL::BOOLEAN_TYPE.coerce_input(input)
-    end
-
-    it "accepts true and false" do
-      assert_equal true, coerce_input(true)
-      assert_equal false, coerce_input(false)
-    end
-
-    it "rejects other types" do
-      assert_equal nil, coerce_input("true")
-      assert_equal nil, coerce_input(5.5)
-      assert_equal nil, coerce_input(nil)
-    end
-  end
-end

data/spec/graphql/define/instance_definable_spec.rb

@@ -1,55 +0,0 @@
-require "date"
-require "spec_helper"
-
-module Garden
-  module DefinePlantBetween
-    def self.call(plant, plant_range)
-      plant.start_planting_on = plant_range.begin
-      plant.end_planting_on = plant_range.end
-    end
-  end
-
-  class Vegetable
-    attr_accessor :name, :start_planting_on, :end_planting_on
-    include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, plant_between: DefinePlantBetween
-
-    # definition added later:
-    attr_accessor :height
-  end
-end
-
-describe GraphQL::Define::InstanceDefinable do
-  describe "extending definitions" do
-    before do
-      Garden::Vegetable.accepts_definitions(:height)
-    end
-
-    after do
-      Garden::Vegetable.own_dictionary.delete(:height)
-    end
-
-    it "accepts after-the-fact definitions" do
-      corn = Garden::Vegetable.define do
-        name "Corn"
-        height 8
-      end
-
-      assert_equal "Corn", corn.name
-      assert_equal 8, corn.height
-    end
-  end
-
-  describe "applying custom definitions" do
-    it "uses custom callables" do
-      tomato = Garden::Vegetable.define do
-        name "Tomato"
-        plant_between Date.new(2000, 4, 20)..Date.new(2000, 6, 1)
-      end
-
-      assert_equal "Tomato", tomato.name
-      assert_equal Date.new(2000, 4, 20), tomato.start_planting_on
-      assert_equal Date.new(2000, 6, 1), tomato.end_planting_on
-    end
-  end
-end

data/spec/graphql/directive_spec.rb

@@ -1,77 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Directive do
-  let(:result) { DummySchema.execute(query_string, variables: {"t" => true, "f" => false}) }
-  describe "on fields" do
-    let(:query_string) { %|query directives($t: Boolean!, $f: Boolean!) {
-      cheese(id: 1) {
-        # plain fields:
-        skipFlavor: flavor @skip(if: true)
-        dontSkipFlavor: flavor @skip(if: false)
-        dontSkipDontIncludeFlavor: flavor @skip(if: false), @include(if: false)
-        skipAndInclude: flavor @skip(if: true), @include(if: true)
-        includeFlavor: flavor @include(if: $t)
-        dontIncludeFlavor: flavor @include(if: $f)
-        # fields in fragments
-        ... includeIdField
-        ... dontIncludeIdField
-        ... skipIdField
-        ... dontSkipIdField
-        }
-      }
-      fragment includeIdField on Cheese { includeId: id @include(if: true) }
-      fragment dontIncludeIdField on Cheese { dontIncludeId: id @include(if: false) }
-      fragment skipIdField on Cheese { skipId: id @skip(if: true) }
-      fragment dontSkipIdField on Cheese { dontSkipId: id @skip(if: false) }
-    |
-    }
-
-    it "intercepts fields" do
-      expected = { "data" =>{
-        "cheese" => {
-          "dontSkipFlavor" => "Brie",
-          "includeFlavor" => "Brie",
-          "includeId" => 1,
-          "dontSkipId" => 1,
-        },
-      }}
-      assert_equal(expected, result)
-    end
-  end
-  describe "on fragments spreads and inline fragments" do
-    let(:query_string) { %|query directives {
-      cheese(id: 1) {
-        ... skipFlavorField @skip(if: true)
-        ... dontSkipFlavorField @skip(if: false)
-        ... includeFlavorField @include(if: true)
-        ... dontIncludeFlavorField @include(if: false)
-
-
-        ... on Cheese @skip(if: true) { skipInlineId: id }
-        ... on Cheese @skip(if: false) { dontSkipInlineId: id }
-        ... on Cheese @include(if: true) { includeInlineId: id }
-        ... on Cheese @include(if: false) { dontIncludeInlineId: id }
-        ... @skip(if: true) { skipNoType: id }
-        ... @skip(if: false) { dontSkipNoType: id }
-        }
-      }
-      fragment includeFlavorField on Cheese { includeFlavor: flavor  }
-      fragment dontIncludeFlavorField on Cheese { dontIncludeFlavor: flavor  }
-      fragment skipFlavorField on Cheese { skipFlavor: flavor  }
-      fragment dontSkipFlavorField on Cheese { dontSkipFlavor: flavor }
-    |}
-
-    it "intercepts fragment spreads" do
-      expected = { "data" => {
-        "cheese" => {
-          "dontSkipFlavor" => "Brie",
-          "includeFlavor" => "Brie",
-          "dontSkipInlineId" => 1,
-          "includeInlineId" => 1,
-          "dontSkipNoType" => 1,
-        },
-      }}
-      assert_equal(expected, result)
-    end
-  end
-end

data/spec/graphql/enum_type_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::EnumType do
-  let(:enum) { DairyAnimalEnum }
-
-  it "coerces names to underlying values" do
-    assert_equal("YAK", enum.coerce_input("YAK"))
-    assert_equal(1, enum.coerce_input("COW"))
-  end
-
-  it "coerces invalid names to nil" do
-    assert_equal(nil, enum.coerce_input("YAKKITY"))
-  end
-
-  it "coerces result values to value's value" do
-    assert_equal("YAK", enum.coerce_result("YAK"))
-    assert_equal("COW", enum.coerce_result(1))
-  end
-
-  it "has value description" do
-    assert_equal("Animal with horns", enum.values["GOAT"].description)
-  end
-
-  describe "validate_input with bad input" do
-    let(:result) { DairyAnimalEnum.validate_input("bad enum") }
-
-    it "returns an invalid result" do
-      assert(!result.valid?)
-    end
-  end
-end

data/spec/graphql/execution_error_spec.rb

@@ -1,61 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::ExecutionError do
-  let(:result) { DummySchema.execute(query_string) }
-  describe "when returned from a field" do
-    let(:query_string) {%|
-    {
-      cheese(id: 1) {
-        id
-        error1: similarCheese(source: [YAK]) {
-          ... similarCheeseFields
-        }
-        error2: similarCheese(source: [YAK]) {
-          ... similarCheeseFields
-        }
-        nonError: similarCheese(source: [SHEEP]) {
-          ... similarCheeseFields
-        }
-        flavor
-      }
-      executionError
-    }
-
-    fragment similarCheeseFields on Cheese {
-      id, flavor
-    }
-    |}
-    it "the error is inserted into the errors key and the rest of the query is fulfilled" do
-      expected_result = {
-        "data"=>{
-          "cheese"=>{
-            "id" => 1,
-            "error1"=> nil,
-            "error2"=> nil,
-            "nonError"=> {
-              "id" => 3,
-              "flavor" => "Manchego",
-            },
-            "flavor" => "Brie",
-            },
-            "executionError" => nil,
-          },
-          "errors"=>[
-            {
-              "message"=>"No cheeses are made from Yak milk!",
-              "locations"=>[{"line"=>5, "column"=>9}]
-            },
-            {
-              "message"=>"No cheeses are made from Yak milk!",
-              "locations"=>[{"line"=>8, "column"=>9}]
-            },
-            {
-              "message"=>"There was an execution error",
-              "locations"=>[{"line"=>16, "column"=>7}]
-            },
-          ]
-        }
-      assert_equal(expected_result, result)
-    end
-  end
-end

data/spec/graphql/field_spec.rb

@@ -1,92 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Field do
-  it "accepts a proc as type" do
-    field = GraphQL::Field.define do
-      type(-> { DairyProductUnion })
-    end
-
-    assert_equal(DairyProductUnion, field.type)
-  end
-
-  it "accepts a string as a type" do
-    field = GraphQL::Field.define do
-      type("DairyProductUnion")
-    end
-
-    assert_equal(DairyProductUnion, field.type)
-  end
-
-
-  describe ".property " do
-    let(:field) do
-      GraphQL::Field.define do
-        name "field_name"
-        # satisfies 'can define by config' below
-        property :internal_prop
-      end
-    end
-
-    it "can define by config" do
-      assert_equal(field.property, :internal_prop)
-    end
-
-    it "has nil property if not defined" do
-      no_prop_field = GraphQL::Field.define { }
-      assert_equal(no_prop_field.property, nil)
-    end
-
-    describe "default resolver" do
-      def acts_like_default_resolver(field, old_prop, new_prop)
-        object = OpenStruct.new(old_prop => "old value", new_prop => "new value", field.name.to_sym => "unset value")
-
-
-        old_result = field.resolve(object, nil, nil)
-        field.property = new_prop
-        new_result = field.resolve(object, nil, nil)
-        field.property = nil
-        unset_result = field.resolve(object, nil, nil)
-
-        assert_equal(old_result, "old value")
-        assert_equal(new_result, "new value")
-        assert_equal(unset_result, "unset value")
-      end
-
-      it "responds to changes in property" do
-        acts_like_default_resolver(field, :internal_prop, :new_prop)
-      end
-
-      it "is reassigned if resolve is set to nil" do
-        field.resolve = nil
-        acts_like_default_resolver(field, :internal_prop, :new_prop)
-      end
-    end
-  end
-
-  describe "#name" do
-    it "can't be reassigned" do
-      field = GraphQL::Field.define do
-        name("something")
-      end
-      assert_equal "something", field.name
-      assert_raises { field.name = "somethingelse" }
-      assert_equal "something", field.name
-    end
-
-    it "must be a string" do
-      dummy_query = GraphQL::ObjectType.define do
-        name "QueryType"
-      end
-
-      invalid_field = GraphQL::Field.new
-      invalid_field.type = dummy_query
-      invalid_field.name = :symbol_name
-
-      dummy_query.fields["symbol_name"] = invalid_field
-      dummy_schema = GraphQL::Schema.new(query: dummy_query)
-
-      err = assert_raises(GraphQL::Schema::InvalidTypeError) { dummy_schema.types }
-      assert_equal "QueryType is invalid: field :symbol_name name must return String, not Symbol (:symbol_name)", err.message
-    end
-  end
-end