graphql 1.9.11 → 1.9.12

data/spec/graphql/input_object_type_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe GraphQL::InputObjectType do
-  describe 'default values' do
-    describe 'when the type is an enum with underlying ruby values' do
-      it 'provides the default value' do
-        TestEnum = GraphQL::EnumType.define do
-          name 'Test'
-
-          value 'A', 'Represents an authorized agent in our system.', value: 'a'
-          value 'B', 'Agent is disabled, web app access is denied.', value: 'b'
-        end
-
-        class TestInput < GraphQL::Schema::InputObject
-          argument :foo, TestEnum, 'TestEnum', required: false, default_value: 'a'
-        end
-
-        test_input_type = TestInput.to_graphql
-        default_test_input_value = test_input_type.coerce_isolated_input({})
-        assert_equal default_test_input_value[:foo], 'a'
-      end
-    end
-  end
-end

data/spec/graphql/int_type_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::INT_TYPE do
-  describe "coerce_input" do
-    it "accepts ints and floats" do
-      assert_equal 1, GraphQL::INT_TYPE.coerce_isolated_input(1)
-      assert_equal 6, GraphQL::INT_TYPE.coerce_isolated_input(6.1)
-    end
-
-    it "rejects other types" do
-      assert_nil GraphQL::INT_TYPE.coerce_isolated_input("55")
-      assert_nil GraphQL::INT_TYPE.coerce_isolated_input(true)
-    end
-
-    describe "handling boundaries" do
-      let(:context) { GraphQL::Query.new(Dummy::Schema, "{ __typename }").context }
-
-      it "accepts result values in bounds" do
-        assert_equal 0, GraphQL::INT_TYPE.coerce_result(0, context)
-        assert_equal (2**31) - 1, GraphQL::INT_TYPE.coerce_result((2**31) - 1, context)
-        assert_equal -(2**31), GraphQL::INT_TYPE.coerce_result(-(2**31), context)
-      end
-
-      it "replaces values, if configured to do so" do
-        assert_equal Dummy::Schema::MAGIC_INT_COERCE_VALUE, GraphQL::INT_TYPE.coerce_result(99**99, context)
-      end
-
-      it "raises on values out of bounds" do
-        assert_raises(GraphQL::IntegerEncodingError) { GraphQL::INT_TYPE.coerce_result(2**31, context) }
-        assert_raises(GraphQL::IntegerEncodingError) { GraphQL::INT_TYPE.coerce_result(-(2**31 + 1), context) }
-      end
-    end
-  end
-end

data/spec/graphql/interface_type_spec.rb

@@ -1,196 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::InterfaceType do
-  let(:interface) { Dummy::Edible.graphql_definition }
-  let(:dummy_query_context) { OpenStruct.new(schema: Dummy::Schema) }
-
-  it "has possible types" do
-    assert_equal([Dummy::Cheese.graphql_definition, Dummy::Honey.graphql_definition, Dummy::Milk.graphql_definition], Dummy::Schema.possible_types(interface))
-  end
-
-  describe "query evaluation" do
-    let(:result) { Dummy::Schema.execute(query_string, variables: {"cheeseId" => 2})}
-    let(:query_string) {%|
-      query fav {
-        favoriteEdible { fatContent }
-      }
-    |}
-    it "gets fields from the type for the given object" do
-      expected = {"data"=>{"favoriteEdible"=>{"fatContent"=>0.04}}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "mergable query evaluation" do
-    let(:result) { Dummy::Schema.execute(query_string, variables: {"cheeseId" => 2})}
-    let(:query_string) {%|
-      query fav {
-        favoriteEdible { fatContent }
-        favoriteEdible { origin }
-      }
-    |}
-    it "gets fields from the type for the given object" do
-      expected = {"data"=>{"favoriteEdible"=>{"fatContent"=>0.04, "origin"=>"Antiquity"}}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "fragments" do
-    let(:query_string) {%|
-    {
-      favoriteEdible {
-        fatContent
-        ... on LocalProduct {
-          origin
-        }
-      }
-    }
-    |}
-    let(:result) { Dummy::Schema.execute(query_string) }
-
-    it "can apply interface fragments to an interface" do
-      expected_result = { "data" => {
-        "favoriteEdible" => {
-          "fatContent" => 0.04,
-          "origin" => "Antiquity",
-        }
-      } }
-
-      assert_equal(expected_result, result)
-    end
-
-    describe "filtering members by type" do
-      let(:query_string) {%|
-      {
-        allEdible {
-          __typename
-          ... on LocalProduct {
-            origin
-          }
-        }
-      }
-      |}
-
-      it "only applies fields to the right object" do
-        expected_data = [
-          {"__typename"=>"Cheese", "origin"=>"France"},
-          {"__typename"=>"Cheese", "origin"=>"Netherlands"},
-          {"__typename"=>"Cheese", "origin"=>"Spain"},
-          {"__typename"=>"Milk", "origin"=>"Antiquity"},
-        ]
-
-        assert_equal expected_data, result["data"]["allEdible"]
-      end
-    end
-  end
-
-  describe "#dup" do
-    it "copies the fields without altering the original" do
-      interface_2 = interface.dup
-      interface_2.fields["extra"] = GraphQL::Field.define(name: "extra", type: GraphQL::BOOLEAN_TYPE)
-      assert_equal 3, interface.fields.size
-      assert_equal 4, interface_2.fields.size
-    end
-
-    it "copies orphan types without affecting the original" do
-      interface = GraphQL::InterfaceType.define do
-        name "AInterface"
-        orphan_types [Dummy::Honey]
-      end
-
-      interface_2 = interface.dup
-      interface_2.orphan_types << Dummy::Cheese
-      assert_equal 1, interface.orphan_types.size
-      assert_equal 2, interface_2.orphan_types.size
-    end
-  end
-
-  describe "#resolve_type" do
-    let(:result) { Dummy::Schema.execute(query_string) }
-    let(:query_string) {%|
-      {
-        allEdible {
-          __typename
-          ... on Milk {
-            milkFatContent: fatContent
-          }
-          ... on Cheese {
-            cheeseFatContent: fatContent
-          }
-        }
-
-        allEdibleAsMilk {
-          __typename
-          ... on Milk {
-            fatContent
-          }
-        }
-      }
-    |}
-
-    it 'returns correct types for general schema and specific interface' do
-      expected_result = {
-        # Uses schema-level resolve_type
-        "allEdible"=>[
-          {"__typename"=>"Cheese", "cheeseFatContent"=>0.19},
-          {"__typename"=>"Cheese", "cheeseFatContent"=>0.3},
-          {"__typename"=>"Cheese", "cheeseFatContent"=>0.065},
-          {"__typename"=>"Milk", "milkFatContent"=>0.04}
-        ],
-        # Uses type-level resolve_type
-        "allEdibleAsMilk"=>[
-          {"__typename"=>"Milk", "fatContent"=>0.19},
-          {"__typename"=>"Milk", "fatContent"=>0.3},
-          {"__typename"=>"Milk", "fatContent"=>0.065},
-          {"__typename"=>"Milk", "fatContent"=>0.04}
-        ]
-      }
-      assert_equal expected_result, result["data"]
-    end
-  end
-
-  describe "#get_possible_type" do
-    let(:query_string) {%|
-      query fav {
-        favoriteEdible { fatContent }
-      }
-    |}
-
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-
-    it "returns the type definition if the type exists and is a possible type of the interface" do
-      assert interface.get_possible_type("Cheese", query.context)
-    end
-
-    it "returns nil if the type is not found in the schema" do
-      assert_nil interface.get_possible_type("Foo", query.context)
-    end
-
-    it "returns nil if the type is not a possible type of the interface" do
-      assert_nil interface.get_possible_type("Beverage", query.context)
-    end
-  end
-
-  describe "#possible_type?" do
-    let(:query_string) {%|
-      query fav {
-        favoriteEdible { fatContent }
-      }
-    |}
-
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-
-    it "returns true if the type exists and is a possible type of the interface" do
-      assert interface.possible_type?("Cheese", query.context)
-    end
-
-    it "returns false if the type is not found in the schema" do
-      refute interface.possible_type?("Foo", query.context)
-    end
-
-    it "returns false if the type is not a possible type of the interface" do
-      refute interface.possible_type?("Beverage", query.context)
-    end
-  end
-end

data/spec/graphql/internal_representation/print_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::InternalRepresentation::Print do
-  describe "printing queries" do
-    let(:query_str) { <<-GRAPHQL
-    {
-      cheese(id: 1) {
-        flavor
-        ...EdibleFields
-        ... on Edible {
-          o2: origin
-        }
-      }
-    }
-
-    fragment EdibleFields on Edible {
-      o: origin
-    }
-    GRAPHQL
-  }
-    it "prints the rewritten query" do
-      query_plan = GraphQL::InternalRepresentation::Print.print(Dummy::Schema, query_str)
-      expected_plan = <<-GRAPHQL
-query {
-  ... on Query {
-    cheese(id: 1) {
-      ... on Cheese {
-        flavor()
-        o2: origin()
-        o: origin()
-      }
-    }
-  }
-}
-      GRAPHQL
-
-      assert_equal expected_plan, query_plan
-    end
-  end
-end

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -1,381 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::InternalRepresentation::Rewrite do
-  let(:schema) {
-    GraphQL::Schema.from_definition <<-GRAPHQL
-    type Query {
-      plant(id: ID!): Plant
-      fruit(id: ID!): [Fruit!]
-    }
-
-    union Plant = Grain | Fruit | Vegetable | Nut
-
-    interface Tree {
-      name: String!
-      leafType: LeafType
-      habitats: [Habitat]
-    }
-
-    enum LeafType {
-      NEEDLE
-      LEAF
-    }
-
-    type Fruit implements Tree {
-      name: String!
-      color: [Int!]!
-      leafType: LeafType
-      habitats: [Habitat]
-    }
-
-    type Vegetable {
-      name: String!
-      edibleParts: [String!]!
-    }
-
-    type Grain {
-      name: String!
-    }
-
-    type Nut implements Tree {
-      name: String!
-      diameter: Int!
-      leafType: LeafType
-      habitats: [Habitat]
-    }
-
-    interface Environ {
-      seasons: [String]
-    }
-
-    type Habitat implements Environ {
-      residentName: String!
-      averageWeight: Int!
-      seasons: [String]
-    }
-    GRAPHQL
-
-  }
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: schema) }
-  let(:query) { GraphQL::Query.new(schema, query_string) }
-  let(:rewrite_result) {
-    res = validator.validate(query)
-    res[:errors].any? && raise(res[:errors].map(&:message).join("; "))
-    res[:irep]
-  }
-
-  describe "building a tree over concrete types with fragments" do
-    let(:query_string) {
-      <<-GRAPHQL
-      query getPlant($id: ID!) {
-        plant(id: $id) {
-          __typename
-          ... on Tree {
-            leafType
-            habitats {
-              averageWeight
-            }
-          }
-          ... on Fruit {
-            name
-            color
-            ... on Tree {
-              leafType
-            }
-          }
-          ... on Nut {
-            leafType
-            ...NutFields
-          }
-        }
-      }
-
-      fragment NutFields on Nut {
-        leafType
-        ... TreeFields
-      }
-
-      fragment TreeFields on Tree {
-        habitats {
-          ... HabitatFields
-        }
-      }
-
-      fragment HabitatFields on Habitat {
-        seasons
-      }
-      GRAPHQL
-    }
-
-    it "groups selections by object types which they apply to" do
-      doc = rewrite_result.operation_definitions["getPlant"]
-      assert_nil doc.definition
-
-      plant_scoped_selection = doc.scoped_children[schema.types["Query"]]["plant"]
-      assert_equal ["Fruit", "Nut", "Plant"], plant_scoped_selection.scoped_children.keys.map(&:name).sort
-
-      plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
-      assert_equal ["Fruit", "Grain", "Nut", "Vegetable"], plant_selection.typed_children.keys.map(&:name).sort
-
-      fruit_selections = plant_selection.typed_children[schema.types["Fruit"]]
-      assert_equal ["__typename", "color", "habitats", "leafType", "name"], fruit_selections.keys.sort
-      assert_equal 2, fruit_selections["leafType"].ast_nodes.size
-
-      nut_selections = plant_selection.typed_children[schema.types["Nut"]]
-      # `... on Tree`, `... on Nut`, and `NutFields`, but not `... on Fruit { ... on Tree }`
-
-      if RUBY_VERSION < "2.5"
-        # Ruby 2.5 changed how hash key collisions worked a little bit.
-        # This test is "broken", but honestly, it doesn't matter.
-        # Apparently nobody uses `IrepNode#ast_nodes`, and that's for the best.
-        assert_equal 3, nut_selections["leafType"].ast_nodes.size
-      end
-
-      # Multi-level merging when including fragments:
-      habitats_selections = nut_selections["habitats"].typed_children[schema.types["Habitat"]]
-      assert_equal ["averageWeight", "seasons"], habitats_selections.keys
-    end
-
-    it "tracks parent nodes" do
-      doc = rewrite_result.operation_definitions["getPlant"]
-      assert_nil doc.parent
-
-      plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
-      assert_equal doc, plant_selection.parent
-
-      leaf_type_selection = plant_selection.typed_children[schema.types["Nut"]]["leafType"]
-      assert_equal plant_selection, leaf_type_selection.parent
-
-      habitats_selection = plant_selection.typed_children[schema.types["Nut"]]["habitats"]
-      assert_equal plant_selection, habitats_selection.parent
-
-      seasons_selection = habitats_selection.typed_children[schema.types["Habitat"]]["seasons"]
-      average_weight_selection = habitats_selection.typed_children[schema.types["Habitat"]]["averageWeight"]
-      assert_equal habitats_selection, seasons_selection.parent
-      assert_equal habitats_selection, average_weight_selection.parent
-    end
-
-    it "tracks field return type" do
-      doc = rewrite_result.operation_definitions["getPlant"]
-
-      assert plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
-      assert_equal "Plant", plant_selection.return_type.to_s
-
-      assert tree_selection = plant_selection.typed_children[schema.types["Fruit"]]
-      assert_equal "[Int!]!", tree_selection["color"].return_type.to_s
-    end
-  end
-
-  describe "tracking directives on fragment spreads" do
-    let(:query_string) { <<-GRAPHQL
-      query getPlant($id: ID!) {
-        plant(id: $id) {
-          ... on Nut @skip(if: true) {
-            leafType
-          }
-
-          ... on Tree {
-            leafType @include(if: true)
-          }
-
-          ... on Nut {
-            leafType # no directives
-          }
-
-          ... NutFields @include(if: false)
-        }
-      }
-      fragment NutFields on Nut {
-        leafType @skip(if: false)
-      }
-    GRAPHQL
-    }
-
-    it "applies directives from all contexts" do
-      doc = rewrite_result.operation_definitions["getPlant"]
-      plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
-      leaf_type_selection = plant_selection.typed_children[schema.types["Nut"]]["leafType"]
-      # Only unskipped occurrences in the AST
-      assert_equal 2, leaf_type_selection.ast_nodes.size
-    end
-  end
-
-  describe "deep fragment merging" do
-    let(:query_string) { <<-GRAPHQL
-      {
-        plant(id: 1) {
-          ...TreeFields
-          ...NutFields
-        }
-      }
-
-      fragment TreeFields on Tree {
-        habitats {
-          seasons
-        }
-      }
-
-      fragment NutFields on Nut {
-        habitats {
-          residentName
-          ... HabitatFields
-        }
-      }
-
-      fragment HabitatFields on Habitat {
-        averageWeight
-      }
-      GRAPHQL
-    }
-
-    it "applies spreads to their parents only" do
-      doc = rewrite_result.operation_definitions[nil]
-      plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
-      nut_habitat_selections = plant_selection.typed_children[schema.types["Nut"]]["habitats"].typed_children[schema.types["Habitat"]]
-      assert_equal ["averageWeight", "residentName", "seasons"], nut_habitat_selections.keys.sort
-      fruit_habitat_selections = plant_selection.typed_children[schema.types["Fruit"]]["habitats"].typed_children[schema.types["Habitat"]]
-      assert_equal ["seasons"], fruit_habitat_selections.keys
-    end
-  end
-
-  describe "nested fields on typed fragments" do
-    let(:result) { Dummy::Schema.execute(query_string) }
-    let(:query_string) {%|
-    {
-      allDairy {
-        __typename
-
-        ... on Milk {
-          selfAsEdible {
-            milkInlineOrigin: origin
-          }
-        }
-
-        ... on Cheese {
-          selfAsEdible {
-            cheeseInlineOrigin: origin
-          }
-        }
-
-        ... on Edible {
-          selfAsEdible {
-            edibleInlineOrigin: origin
-          }
-        }
-
-        ... {
-          ... on Edible {
-            selfAsEdible {
-              untypedInlineOrigin: origin
-            }
-          }
-        }
-        ...milkFields
-        ...cheeseFields
-      }
-    }
-
-    fragment cheeseFields on Cheese {
-      selfAsEdible {
-        cheeseFragmentOrigin: origin
-      }
-    }
-    fragment milkFields on Milk {
-      selfAsEdible {
-        milkFragmentOrigin: origin
-      }
-    }
-    |}
-
-    it "distinguishes between nested fields with the same name on different typed fragments" do
-      all_dairy = result["data"]["allDairy"]
-      cheeses = all_dairy.select { |d| d["__typename"] == "Cheese" }
-      milks = all_dairy.select { |d| d["__typename"] == "Milk" }
-
-      # Make sure all the data is there:
-      assert_equal 3, cheeses.length
-      assert_equal 1, milks.length
-
-      expected_cheese_fields = ["cheeseFragmentOrigin", "cheeseInlineOrigin", "edibleInlineOrigin", "untypedInlineOrigin"]
-      cheeses.each do |cheese|
-        assert_equal expected_cheese_fields, cheese["selfAsEdible"].keys.sort
-      end
-
-      expected_milk_fields = ["edibleInlineOrigin", "milkFragmentOrigin", "milkInlineOrigin", "untypedInlineOrigin"]
-      milks.each do |milk|
-        assert_equal expected_milk_fields, milk["selfAsEdible"].keys.sort
-      end
-    end
-  end
-
-  describe "fragment merging bug" do
-    let(:query_string) {
-      <<-GRAPHQL
-      {
-        ...Frag1
-        __type(name: "Query") {
-          ...Frag2
-        }
-      }
-
-      fragment Frag1 on Query {
-        __type(name: "Query") {
-          ...Frag2
-        }
-      }
-
-      fragment Frag2 on __Type {
-        __typename
-      }
-      GRAPHQL
-    }
-
-    it "finishes" do
-      doc = rewrite_result.operation_definitions[nil]
-      type_node = doc.typed_children[schema.types["Query"]]["__type"]
-      typename_node = type_node.typed_children[schema.types["__Type"]]["__typename"]
-      assert_equal 1, typename_node.ast_nodes.size
-      assert_equal 15, typename_node.ast_node.line
-      assert_equal 9, typename_node.ast_node.col
-    end
-  end
-
-  describe "fragment definition without query" do
-    let(:query_string) {
-      <<-GRAPHQL
-      fragment NutFields on Nut {
-        leafType
-        ... TreeFields
-      }
-
-      fragment TreeFields on Tree {
-        habitats {
-          ... HabitatFields
-        }
-      }
-
-      fragment HabitatFields on Habitat {
-        seasons
-      }
-      GRAPHQL
-    }
-
-    let(:validator) {
-      rules = GraphQL::StaticValidation::ALL_RULES - [
-        GraphQL::StaticValidation::FragmentsAreUsed
-      ]
-      GraphQL::StaticValidation::Validator.new(schema: schema, rules: rules)
-    }
-
-    it "tracks fragment definitions without operation" do
-      doc = rewrite_result.fragment_definitions["NutFields"]
-
-      assert doc.typed_children[schema.types["Nut"]]["leafType"]
-
-      assert nut_selections = doc.typed_children[schema.types["Nut"]]
-      habitats_selections = nut_selections["habitats"].typed_children[schema.types["Habitat"]]
-      assert_equal ["seasons"], habitats_selections.keys
-    end
-  end
-end