graphql 1.8.0 → 1.12.12

data/spec/graphql/rake_task_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-rake_task_schema_defn = <<-GRAPHQL
-type Query {
-  allowed(allowed: ID!, excluded: ID!): Int
-  excluded(excluded: ID!): Boolean
-  ignored: Float
-}
-GRAPHQL
-
-RakeTaskSchema = GraphQL::Schema.from_definition(rake_task_schema_defn)
-
-# Default task
-GraphQL::RakeTask.new(schema_name: "RakeTaskSchema")
-# Configured task
-GraphQL::RakeTask.new(idl_outfile: "tmp/configured_schema.graphql") do |t|
-  t.namespace = "graphql_custom"
-  t.load_context = ->(task) { {filtered: true} }
-  t.only = ->(member, ctx) { member.is_a?(GraphQL::ScalarType) || (ctx[:filtered] && ["Query", "allowed"].include?(member.name)) }
-  t.load_schema = ->(task) { RakeTaskSchema }
-end
-
-describe GraphQL::RakeTask do
-  describe "default settings" do
-    after do
-      FileUtils.rm_rf("./schema.json")
-      FileUtils.rm_rf("./schema.graphql")
-    end
-
-    it "writes JSON" do
-      capture_io do
-        Rake::Task["graphql:schema:dump"].invoke
-      end
-      dumped_json = File.read("./schema.json")
-      expected_json = JSON.pretty_generate(RakeTaskSchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY))
-
-      # Test that that JSON is logically equivalent, not serialized the same
-      assert_equal(JSON.parse(expected_json), JSON.parse(dumped_json))
-
-      dumped_idl = File.read("./schema.graphql")
-      expected_idl = rake_task_schema_defn.chomp
-      assert_equal(expected_idl, dumped_idl)
-    end
-  end
-
-  describe "customized settings" do
-    it "writes GraphQL" do
-      capture_io do
-        Rake::Task["graphql_custom:schema:idl"].invoke
-      end
-      dumped_idl = File.read("./tmp/configured_schema.graphql")
-      expected_idl = "type Query {
-  allowed(allowed: ID!): Int
-}"
-      assert_equal expected_idl, dumped_idl
-    end
-  end
-end

data/spec/graphql/relay/array_connection_spec.rb

@@ -1,290 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe GraphQL::Relay::ArrayConnection do
-  def get_names(result)
-    ships = result["data"]["rebels"]["ships"]["edges"]
-    ships.map { |e| e["node"]["name"] }
-  end
-
-  def get_last_cursor(result)
-    result["data"]["rebels"]["ships"]["edges"].last["cursor"]
-  end
-
-  def get_page_info(result, key = "bases")
-    result["data"]["rebels"][key]["pageInfo"]
-  end
-
-  describe "results" do
-    let(:query_string) {%|
-      query getShips($first: Int, $after: String, $last: Int, $before: String, $nameIncludes: String){
-        rebels {
-          ships(first: $first, after: $after, last: $last, before: $before, nameIncludes: $nameIncludes) {
-            edges {
-              cursor
-              node {
-                name
-              }
-            }
-            pageInfo {
-              hasNextPage
-              hasPreviousPage
-              startCursor
-              endCursor
-            }
-          }
-        }
-      }
-    |}
-
-    it 'limits the result' do
-      result = star_wars_query(query_string, "first" => 2)
-      number_of_ships = get_names(result).length
-      assert_equal(2, number_of_ships)
-      assert_equal(true, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
-      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
-      assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
-      assert_equal("Mg==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
-
-      result = star_wars_query(query_string, "first" => 3)
-      number_of_ships = get_names(result).length
-      assert_equal(3, number_of_ships)
-    end
-
-    it 'provides pageInfo' do
-      result = star_wars_query(query_string, "first" => 2)
-      assert_equal(true, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
-      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
-      assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
-      assert_equal("Mg==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
-
-      result = star_wars_query(query_string, "first" => 100)
-      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
-      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
-      assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
-      assert_equal("NQ==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
-    end
-
-    it "provides bidirectional_pagination" do
-      result = star_wars_query(query_string, "first" => 1)
-      last_cursor = get_last_cursor(result)
-
-      # When going forwards, bi-directional pagination
-      # returns `true` even for `hasPreviousPage`
-      result = star_wars_query(query_string, "first" => 1, "after" => last_cursor)
-      assert_equal(true, get_page_info(result, "ships")["hasNextPage"])
-      assert_equal(false, get_page_info(result, "ships")["hasPreviousPage"])
-
-      result = with_bidirectional_pagination {
-        star_wars_query(query_string, "first" => 3, "after" => last_cursor)
-      }
-      assert_equal(true, get_page_info(result, "ships")["hasNextPage"])
-      assert_equal(true, get_page_info(result, "ships")["hasPreviousPage"])
-
-      # When going backwards, bi-directional pagination
-      # returns true for `hasNextPage`
-      last_cursor = get_last_cursor(result)
-      result = star_wars_query(query_string, "last" => 1, "before" => last_cursor)
-      assert_equal(false, get_page_info(result, "ships")["hasNextPage"])
-      assert_equal(true, get_page_info(result, "ships")["hasPreviousPage"])
-
-      result = with_bidirectional_pagination {
-        star_wars_query(query_string, "last" => 2, "before" => last_cursor)
-      }
-      assert_equal(true, get_page_info(result, "ships")["hasNextPage"])
-      assert_equal(true, get_page_info(result, "ships")["hasPreviousPage"])
-    end
-
-    it 'slices the result' do
-      result = star_wars_query(query_string, "first" => 1)
-      assert_equal(["X-Wing"], get_names(result))
-
-      # After the last result, find the next 2:
-      last_cursor = get_last_cursor(result)
-
-      result = star_wars_query(query_string, "after" => last_cursor, "first" => 2)
-      assert_equal(["Y-Wing", "A-Wing"], get_names(result))
-
-      # After the last result, find the next 2:
-      last_cursor = get_last_cursor(result)
-
-      result = star_wars_query(query_string, "after" => last_cursor, "first" => 2)
-      assert_equal(["Millenium Falcon", "Home One"], get_names(result))
-
-      result = star_wars_query(query_string, "before" => last_cursor, "last" => 2)
-      assert_equal(["X-Wing", "Y-Wing"], get_names(result))
-
-      result = star_wars_query(query_string, "last" => 2)
-      assert_equal(["Millenium Falcon", "Home One"], get_names(result))
-
-      result = star_wars_query(query_string, "last" => 10)
-      assert_equal(["X-Wing", "Y-Wing", "A-Wing", "Millenium Falcon", "Home One"], get_names(result))
-      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
-      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
-    end
-
-    it 'works with before and after specified together' do
-      result = star_wars_query(query_string, "first" => 1)
-      assert_equal(["X-Wing"], get_names(result))
-
-      first_cursor = get_last_cursor(result)
-
-      # There is no records between before and after if they point to the same cursor
-      result = star_wars_query(query_string, "before" => first_cursor, "after" => first_cursor, "last" => 2)
-      assert_equal([], get_names(result))
-
-      result = star_wars_query(query_string, "after" => first_cursor, "first" => 2)
-      assert_equal(["Y-Wing", "A-Wing"], get_names(result))
-
-      # After the last result, find the next 2:
-      second_cursor = get_last_cursor(result)
-
-      # There is only 2 results between the cursors
-      result = star_wars_query(query_string, "after" => first_cursor, "before" => second_cursor, "first" => 5)
-      assert_equal(["Y-Wing", "A-Wing"], get_names(result))
-    end
-
-    it 'handles cursors beyond the bounds of the array' do
-      overreaching_cursor = Base64.strict_encode64("100")
-      result = star_wars_query(query_string, "after" => overreaching_cursor, "first" => 2)
-      assert_equal([], get_names(result))
-    end
-
-    it 'applies custom arguments' do
-      result = star_wars_query(query_string, "nameIncludes" => "Wing", "first" => 2)
-      names = get_names(result)
-      assert_equal(2, names.length)
-
-      after = get_last_cursor(result)
-      result = star_wars_query(query_string, "nameIncludes" => "Wing", "after" => after, "first" => 3)
-      names = get_names(result)
-      assert_equal(1, names.length)
-    end
-
-    it 'works without first/last/after/before' do
-      result = star_wars_query(query_string)
-
-      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
-      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
-      assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
-      assert_equal("NQ==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
-      assert_equal(5, result["data"]["rebels"]["ships"]["edges"].length)
-    end
-
-    describe "applying max_page_size" do
-      def get_names(result)
-        result["data"]["rebels"]["bases"]["edges"].map { |e| e["node"]["name"] }
-      end
-
-      let(:query_string) {%|
-        query getShips($first: Int, $after: String, $last: Int, $before: String){
-          rebels {
-            bases: basesWithMaxLimitArray(first: $first, after: $after, last: $last, before: $before) {
-              edges {
-                cursor
-                node {
-                  name
-                }
-              }
-              pageInfo {
-                hasNextPage
-                hasPreviousPage
-              }
-            }
-          }
-        }
-      |}
-
-      it "applies to queries by `first`" do
-        result = star_wars_query(query_string, "first" => 100)
-        assert_equal(["Yavin", "Echo Base"], get_names(result))
-        assert_equal(true, get_page_info(result)["hasNextPage"])
-
-        # Max page size is applied _without_ `first`, also
-        result = star_wars_query(query_string)
-        assert_equal(["Yavin", "Echo Base"], get_names(result))
-        assert_equal(false, get_page_info(result)["hasNextPage"], "hasNextPage is false when first is not specified")
-      end
-
-      it "applies to queries by `last`" do
-        last_cursor = "Ng=="
-
-        result = star_wars_query(query_string, "last" => 100, "before" => last_cursor)
-        assert_equal(["Death Star", "Shield Generator"], get_names(result))
-        assert_equal(true, get_page_info(result)["hasPreviousPage"])
-
-        result = star_wars_query(query_string, "before" => last_cursor)
-        assert_equal(["Yavin", "Echo Base"], get_names(result))
-        assert_equal(false, get_page_info(result)["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
-
-        third_cursor = "Mw=="
-        first_and_second_names = ["Yavin", "Echo Base"]
-        result = star_wars_query(query_string, "last" => 100, "before" => third_cursor)
-        assert_equal(first_and_second_names, get_names(result))
-
-        result = star_wars_query(query_string, "before" => third_cursor)
-        assert_equal(first_and_second_names, get_names(result))
-      end
-    end
-
-    describe "applying default_max_page_size" do
-      def get_names(result)
-        result["data"]["rebels"]["bases"]["edges"].map { |e| e["node"]["name"] }
-      end
-
-      def get_page_info(result)
-        result["data"]["rebels"]["bases"]["pageInfo"]
-      end
-
-      let(:query_string) {%|
-        query getShips($first: Int, $after: String, $last: Int, $before: String){
-          rebels {
-            bases: basesWithDefaultMaxLimitArray(first: $first, after: $after, last: $last, before: $before) {
-              edges {
-                cursor
-                node {
-                  name
-                }
-              }
-              pageInfo {
-                hasNextPage
-                hasPreviousPage
-              }
-            }
-          }
-        }
-      |}
-
-      it "applies to queries by `first`" do
-        result = star_wars_query(query_string, "first" => 100)
-        assert_equal(["Yavin", "Echo Base", "Secret Hideout"], get_names(result))
-        assert_equal(true, get_page_info(result)["hasNextPage"])
-
-        # Max page size is applied _without_ `first`, also
-        result = star_wars_query(query_string)
-        assert_equal(["Yavin", "Echo Base", "Secret Hideout"], get_names(result))
-        assert_equal(false, get_page_info(result)["hasNextPage"], "hasNextPage is false when first is not specified")
-      end
-
-      it "applies to queries by `last`" do
-        last_cursor = "Ng=="
-
-        result = star_wars_query(query_string, "last" => 100, "before" => last_cursor)
-        assert_equal(["Secret Hideout", "Death Star", "Shield Generator"], get_names(result))
-        assert_equal(true, get_page_info(result)["hasPreviousPage"])
-
-        result = star_wars_query(query_string, "before" => last_cursor)
-        assert_equal(["Yavin", "Echo Base", "Secret Hideout"], get_names(result))
-        assert_equal(false, get_page_info(result)["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
-
-        fourth_cursor = "NA=="
-        first_second_and_third_names = ["Yavin", "Echo Base", "Secret Hideout"]
-        result = star_wars_query(query_string, "last" => 100, "before" => fourth_cursor)
-        assert_equal(first_second_and_third_names, get_names(result))
-
-        result = star_wars_query(query_string, "before" => fourth_cursor)
-        assert_equal(first_second_and_third_names, get_names(result))
-      end
-    end
-  end
-end

data/spec/graphql/relay/base_connection_spec.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe GraphQL::Relay::BaseConnection do
-  module Encoder
-    module_function
-    def encode(str, nonce: false); str; end
-    def decode(str, nonce: false); str; end
-  end
-
-  let(:schema) { OpenStruct.new(cursor_encoder: Encoder) }
-  let(:context) { OpenStruct.new(schema: schema) }
-
-  describe ".connection_for_nodes" do
-    it "resolves most specific connection type" do
-      class SpecialArray < Array; end
-      class SpecialArrayConnection < GraphQL::Relay::BaseConnection; end
-      GraphQL::Relay::BaseConnection.register_connection_implementation(SpecialArray, SpecialArrayConnection)
-
-      nodes = SpecialArray.new
-
-      conn_class = GraphQL::Relay::BaseConnection.connection_for_nodes(nodes)
-      assert_equal conn_class, SpecialArrayConnection
-    end
-  end
-
-  describe "arguments" do
-    it "limits pagination args to positive numbers" do
-      args = {
-        first: 1,
-        last: -1,
-      }
-      conn = GraphQL::Relay::BaseConnection.new([], args, context: context)
-      assert_equal 1, conn.first
-      assert_equal 0, conn.last
-
-      args = {
-        first: nil,
-      }
-      conn = GraphQL::Relay::BaseConnection.new([], args, context: context)
-      assert_nil conn.first
-    end
-  end
-
-  describe "#context" do
-    it "Has public access to the field context" do
-      conn = GraphQL::Relay::BaseConnection.new([], {}, context: context)
-      assert_equal context, conn.context
-    end
-  end
-
-  describe "#inspect" do
-    it "inspects nicely" do
-      args = {
-        first: 1,
-        last: -1,
-      }
-      conn = GraphQL::Relay::BaseConnection.new([], args, context: context)
-      assert_equal "#<GraphQL::Relay::Connection @parent=nil @arguments={:first=>1, :last=>-1}>", conn.inspect
-    end
-  end
-
-  describe "#encode / #decode" do
-    module ReverseEncoder
-      module_function
-      def encode(str, nonce: false); str.reverse; end
-      def decode(str, nonce: false); str.reverse; end
-    end
-
-    let(:schema) { OpenStruct.new(cursor_encoder: ReverseEncoder) }
-    let(:context) { OpenStruct.new(schema: schema) }
-
-    it "Uses the schema's encoder" do
-      conn = GraphQL::Relay::BaseConnection.new([], {}, context: context)
-
-      assert_equal "1/nosreP", conn.encode("Person/1")
-      assert_equal "Person/1", conn.decode("1/nosreP")
-    end
-
-    it "defaults to base64" do
-      conn = GraphQL::Relay::BaseConnection.new([], {}, context: nil)
-
-      assert_equal "UGVyc29uLzE=", conn.encode("Person/1")
-      assert_equal "Person/1", conn.decode("UGVyc29uLzE=")
-    end
-
-    it "handles trimmed base64" do
-      conn = GraphQL::Relay::BaseConnection.new([], {}, context: nil)
-
-      assert_equal "Person/1", conn.decode("UGVyc29uLzE")
-    end
-  end
-end

data/spec/graphql/relay/connection_instrumentation_spec.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Relay::ConnectionInstrumentation do
-  it "replaces the previous field definition" do
-    test_type = GraphQL::ObjectType.define do
-      name "Test"
-      connection :tests, test_type.connection_type
-    end
-
-    assert_equal ["tests"], test_type.fields.keys
-  end
-
-  it "keeps a reference to the function" do
-    conn_field = StarWars::Faction.graphql_definition.fields["shipsWithMaxPageSize"]
-    assert_instance_of StarWars::ShipsWithMaxPageSize, conn_field.function
-  end
-
-  let(:build_schema) {
-    test_type = nil
-
-    test_field = GraphQL::Field.define do
-      type(test_type.connection_type)
-      property(:something)
-    end
-
-    test_type = GraphQL::ObjectType.define do
-      name "Test"
-      connection :tests, test_field
-    end
-
-    [
-      test_field,
-      GraphQL::Schema.define(query: test_type, raise_definition_error: true)
-    ]
-  }
-
-  it "leaves the original field untouched" do
-    test_field, test_schema = build_schema
-    conn_field = test_schema.get_field(test_schema.query, "tests")
-
-    assert_equal 0, test_field.arguments.length
-    assert_equal 4, conn_field.arguments.length
-
-    assert_instance_of GraphQL::Field::Resolve::MethodResolve, test_field.resolve_proc
-    assert_instance_of GraphQL::Relay::ConnectionResolve, conn_field.resolve_proc
-  end
-
-  it "passes connection behaviors to redefinitions" do
-    _test_field, test_schema = build_schema
-    connection_field = test_schema.get_field(test_schema.query, "tests")
-    redefined_connection_field = connection_field.redefine { argument "name", types.String }
-
-    assert_equal 4, connection_field.arguments.size
-    assert_equal 5, redefined_connection_field.arguments.size
-
-    assert_instance_of GraphQL::Relay::ConnectionResolve, connection_field.resolve_proc
-    assert_instance_of GraphQL::Relay::ConnectionResolve, redefined_connection_field.resolve_proc
-  end
-
-  describe "after_built_ins instrumentation" do
-    it "has access to connection objects" do
-      query_str = <<-GRAPHQL
-      {
-        rebels {
-          ships {
-            pageInfo {
-              __typename
-            }
-          }
-        }
-      }
-      GRAPHQL
-      ctx = { before_built_ins: [], after_built_ins: [] }
-      star_wars_query(query_str, {}, context: ctx)
-      # The second item is different here:
-      # Before the object is wrapped in a connection, the instrumentation sees `Array`
-      assert_equal ["StarWars::FactionRecord", "Array", "GraphQL::Relay::ArrayConnection"], ctx[:before_built_ins]
-      # After the object is wrapped in a connection, it sees the connection object
-      assert_equal ["StarWars::Faction", "GraphQL::Relay::ArrayConnection", "GraphQL::Relay::ArrayConnection"], ctx[:after_built_ins]
-    end
-  end
-end

data/spec/graphql/relay/connection_resolve_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Relay::ConnectionResolve do
-  let(:query_string) { <<-GRAPHQL
-    query getShips($name: String!){
-      rebels {
-        ships(nameIncludes: $name) {
-          edges {
-            node {
-              name
-            }
-          }
-          parentClassName
-        }
-      }
-    }
-    GRAPHQL
-  }
-
-  describe "when an execution error is returned" do
-    it "adds an error" do
-      result = star_wars_query(query_string, { "name" => "error"})
-      assert_equal 1, result["errors"].length
-      assert_equal "error from within connection", result["errors"][0]["message"]
-    end
-
-    it "adds an error for a lazy error" do
-      result = star_wars_query(query_string, { "name" => "lazyError"})
-      assert_equal 1, result["errors"].length
-      assert_equal "lazy error from within connection", result["errors"][0]["message"]
-    end
-
-    it "adds an error for a lazy raised error" do
-      result = star_wars_query(query_string, { "name" => "lazyRaisedError"})
-      assert_equal 1, result["errors"].length
-      assert_equal "lazy raised error from within connection", result["errors"][0]["message"]
-    end
-
-    it "adds an error for a raised error" do
-      result = star_wars_query(query_string, { "name" => "raisedError"})
-      assert_equal 1, result["errors"].length
-      assert_equal "error raised from within connection", result["errors"][0]["message"]
-    end
-  end
-
-
-  describe "when a lazy object is returned" do
-    it "returns the items with the correct parent" do
-      result = star_wars_query(query_string, { "name" => "lazyObject"})
-      assert_equal 5, result["data"]["rebels"]["ships"]["edges"].length
-      assert_equal "StarWars::FactionRecord", result["data"]["rebels"]["ships"]["parentClassName"]
-    end
-  end
-
-  describe "when nil is returned" do
-    it "becomes null" do
-      result = star_wars_query(query_string, { "name" => "null" })
-      conn = result["data"]["rebels"]["ships"]
-      assert_nil conn
-    end
-  end
-end

data/spec/graphql/relay/connection_type_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Relay::ConnectionType do
-  describe ".create_type" do
-    describe "connections with custom Edge classes / EdgeTypes" do
-      let(:query_string) {%|
-        {
-          rebels {
-            basesWithCustomEdge {
-              totalCountTimes100
-              fieldName
-              edges {
-                upcasedName
-                upcasedParentName
-                edgeClassName
-                node {
-                  name
-                }
-                cursor
-              }
-            }
-          }
-        }
-      |}
-
-      it "uses the custom edge and custom connection" do
-        result = star_wars_query(query_string)
-        bases = result["data"]["rebels"]["basesWithCustomEdge"]
-        assert_equal 300, bases["totalCountTimes100"]
-        assert_equal 'basesWithCustomEdge', bases["fieldName"]
-        assert_equal ["YAVIN", "ECHO BASE", "SECRET HIDEOUT"] , bases["edges"].map { |e| e["upcasedName"] }
-        assert_equal ["Yavin", "Echo Base", "Secret Hideout"] , bases["edges"].map { |e| e["node"]["name"] }
-        assert_equal ["StarWars::CustomBaseEdge"] , bases["edges"].map { |e| e["edgeClassName"] }.uniq
-        upcased_rebels_name = "ALLIANCE TO RESTORE THE REPUBLIC"
-        assert_equal [upcased_rebels_name] , bases["edges"].map { |e| e["upcasedParentName"] }.uniq
-      end
-    end
-
-    describe "connections with nodes field" do
-      let(:query_string) {%|
-        {
-          rebels {
-            bases: basesWithCustomEdge {
-              nodes {
-                name
-              }
-            }
-          }
-        }
-      |}
-
-      it "uses the custom edge and custom connection" do
-        result = star_wars_query(query_string)
-        bases = result["data"]["rebels"]["bases"]
-        assert_equal ["Yavin", "Echo Base", "Secret Hideout"] , bases["nodes"].map { |e| e["name"] }
-      end
-    end
-
-
-    describe "when an execution error is raised" do
-      let(:query_string) {%|
-        {
-          basesWithNullName {
-            edges {
-              node {
-                name
-              }
-            }
-          }
-        }
-      |}
-
-      it "nullifies the parent and adds an error" do
-        result = star_wars_query(query_string)
-        assert_nil result["data"]["basesWithNullName"]["edges"][0]["node"]
-        assert_equal "Boom!", result["errors"][0]["message"]
-      end
-    end
-  end
-end

data/spec/graphql/relay/edge_spec.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Relay::Edge do
-  it "inspects nicely" do
-    connection = OpenStruct.new(parent: "Parent")
-    edge = GraphQL::Relay::Edge.new("Node", connection)
-    assert_equal '#<GraphQL::Relay::Edge ("Parent" => "Node")>', edge.inspect
-  end
-end