graphql 1.7.6 → 1.8.0

data/spec/graphql/query/variables_spec.rb

@@ -48,6 +48,47 @@ describe GraphQL::Query::Variables do
       end
     end
 
+    describe "symbol keys" do
+      let(:query_string) { <<-GRAPHQL
+        query testVariables(
+          $dairy_product_1: DairyProductInput!
+          $dairy_product_2: DairyProductInput!
+        ) {
+          __typename
+        }
+      GRAPHQL
+      }
+
+      let(:provided_variables) {
+        {
+          dairy_product_1: { source: "COW", fatContent: 0.99 },
+          "dairy_product_2" => { source: "DONKEY", "fatContent": 0.89 },
+        }
+      }
+
+      it "checks for string matches" do
+        # These get merged into all the values above
+        default_values = {
+          "originDairy"=>"Sugar Hollow Dairy",
+          "organic"=>false,
+          "order_by"=>{"direction"=>"ASC"}
+        }
+
+        expected_input_1 = {
+          "source" => 1,
+          "fatContent" => 0.99,
+        }.merge(default_values)
+
+        assert_equal(expected_input_1, variables["dairy_product_1"].to_h)
+
+        expected_input_2 = {
+          "source" => :donkey,
+          "fatContent" => 0.89,
+        }.merge(default_values)
+        assert_equal(expected_input_2, variables["dairy_product_2"].to_h)
+      end
+    end
+
     describe "validating input objects" do
       let(:query_string) {%|
       query searchMyDairy (
@@ -111,7 +152,7 @@ describe GraphQL::Query::Variables do
         let(:provided_variables) { { "ids" => [nil] } }
         it "returns an error" do
           assert_equal 1, result["errors"].length
-          assert_equal nil, result["data"]
+          assert_nil result["data"]
         end
       end
     end

data/spec/graphql/query_spec.rb

@@ -85,7 +85,7 @@ describe GraphQL::Query do
         operation_name: operation_name,
         max_depth: max_depth,
       )
-      query.query_string = '{ __type(name: "Cheese") { name } }'
+      query.query_string = '{ __type(name: """Cheese""") { name } }'
       assert_equal "Cheese", query.result["data"] ["__type"]["name"]
     end
   end
@@ -111,7 +111,7 @@ describe GraphQL::Query do
       }
 
       it "returns nil" do
-        assert_equal nil, query.operation_name
+        assert_nil query.operation_name
       end
     end
 
@@ -148,7 +148,7 @@ describe GraphQL::Query do
         }
 
         it "returns the inferred operation name" do
-          assert_equal nil, query.selected_operation_name
+          assert_nil query.selected_operation_name
         end
       end
     end
@@ -253,6 +253,32 @@ describe GraphQL::Query do
         assert_equal [nil], Instrumenter::ERROR_LOG
       end
     end
+
+    describe "when an error propagated through execution" do
+      module ExtensionsInstrumenter
+        LOG = []
+        def self.before_query(q); end;
+
+        def self.after_query(q)
+          q.result["extensions"] = { "a" => 1 }
+          LOG << :ok
+        end
+      end
+
+      let(:schema) {
+        Dummy::Schema.redefine {
+          instrument(:query, ExtensionsInstrumenter)
+        }
+      }
+
+      it "can add to extensions" do
+        ExtensionsInstrumenter::LOG.clear
+        assert_raises(RuntimeError) do
+          schema.execute "{ error }"
+        end
+        assert_equal [:ok], ExtensionsInstrumenter::LOG
+      end
+    end
   end
 
   it "uses root_value as the object for the root type" do
@@ -532,7 +558,7 @@ describe GraphQL::Query do
 
       it "overrides the schema's max_depth" do
         assert result["data"].key?("cheese")
-        assert_equal nil, result["errors"]
+        assert_nil result["errors"]
       end
     end
   end
@@ -699,7 +725,7 @@ describe GraphQL::Query do
 
     it "returns nil when there is no selected operation" do
       query = GraphQL::Query.new(schema, '# Only a comment')
-      assert_equal nil, query.irep_selection
+      assert_nil query.irep_selection
     end
   end
 

data/spec/graphql/rake_task_spec.rb

@@ -34,7 +34,9 @@ describe GraphQL::RakeTask do
       end
       dumped_json = File.read("./schema.json")
       expected_json = JSON.pretty_generate(RakeTaskSchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY))
-      assert_equal(expected_json, dumped_json)
+
+      # 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

data/spec/graphql/relay/base_connection_spec.rb

@@ -38,7 +38,7 @@ describe GraphQL::Relay::BaseConnection do
         first: nil,
       }
       conn = GraphQL::Relay::BaseConnection.new([], args, context: context)
-      assert_equal nil, conn.first
+      assert_nil conn.first
     end
   end
 

data/spec/graphql/relay/connection_instrumentation_spec.rb

@@ -12,7 +12,7 @@ describe GraphQL::Relay::ConnectionInstrumentation do
   end
 
   it "keeps a reference to the function" do
-    conn_field = StarWars::Faction.fields["shipsWithMaxPageSize"]
+    conn_field = StarWars::Faction.graphql_definition.fields["shipsWithMaxPageSize"]
     assert_instance_of StarWars::ShipsWithMaxPageSize, conn_field.function
   end
 
@@ -77,7 +77,7 @@ describe GraphQL::Relay::ConnectionInstrumentation do
       # 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::FactionRecord", "GraphQL::Relay::ArrayConnection", "GraphQL::Relay::ArrayConnection"], ctx[:after_built_ins]
+      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

@@ -57,7 +57,7 @@ describe GraphQL::Relay::ConnectionResolve do
     it "becomes null" do
       result = star_wars_query(query_string, { "name" => "null" })
       conn = result["data"]["rebels"]["ships"]
-      assert_equal nil, conn
+      assert_nil conn
     end
   end
 end

data/spec/graphql/relay/connection_type_spec.rb

@@ -73,7 +73,7 @@ describe GraphQL::Relay::ConnectionType do
 
       it "nullifies the parent and adds an error" do
         result = star_wars_query(query_string)
-        assert_equal nil, result["data"]["basesWithNullName"]["edges"][0]["node"]
+        assert_nil result["data"]["basesWithNullName"]["edges"][0]["node"]
         assert_equal "Boom!", result["errors"][0]["message"]
       end
     end

data/spec/graphql/relay/mongo_relation_connection_spec.rb

@@ -0,0 +1,474 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe GraphQL::Relay::RelationConnection do
+  def get_names(result)
+    ships = result["data"]["federation"]["bases"]["edges"]
+    ships.map { |e| e["node"]["name"] }
+  end
+
+  def get_page_info(result)
+    result["data"]["federation"]["bases"]["pageInfo"]
+  end
+
+  def get_first_cursor(result)
+    result["data"]["federation"]["bases"]["edges"].first["cursor"]
+  end
+
+  def get_last_cursor(result)
+    result["data"]["federation"]["bases"]["edges"].last["cursor"]
+  end
+
+  describe "results" do
+    let(:query_string) {%|
+      query getShips($first: Int, $after: String, $last: Int, $before: String,  $nameIncludes: String){
+        federation {
+          bases(first: $first, after: $after, last: $last, before: $before, nameIncludes: $nameIncludes) {
+            ... basesConnection
+          }
+        }
+      }
+
+      fragment basesConnection on BasesConnectionWithTotalCount {
+        totalCount,
+        edges {
+          cursor
+          node {
+            name
+          }
+        },
+        pageInfo {
+          hasNextPage
+          hasPreviousPage
+          startCursor
+          endCursor
+        }
+      }
+    |}
+
+    it 'limits the result' do
+      result = star_trek_query(query_string, "first" => 2)
+      assert_equal(2, get_names(result).length)
+      assert_equal(true, get_page_info(result)["hasNextPage"])
+      assert_equal(false, get_page_info(result)["hasPreviousPage"])
+      assert_equal("MQ==", get_page_info(result)["startCursor"])
+      assert_equal("Mg==", get_page_info(result)["endCursor"])
+      assert_equal("MQ==", get_first_cursor(result))
+      assert_equal("Mg==", get_last_cursor(result))
+
+      result = star_trek_query(query_string, "first" => 3)
+      assert_equal(3, get_names(result).length)
+      assert_equal(false, get_page_info(result)["hasNextPage"])
+      assert_equal(false, get_page_info(result)["hasPreviousPage"])
+      assert_equal("MQ==", get_page_info(result)["startCursor"])
+      assert_equal("Mw==", get_page_info(result)["endCursor"])
+      assert_equal("MQ==", get_first_cursor(result))
+      assert_equal("Mw==", get_last_cursor(result))
+    end
+
+    it 'provides custom fields on the connection type' do
+      result = star_trek_query(query_string, "first" => 2)
+      assert_equal(
+        StarTrek::Base.where(faction_id: 1).count,
+        result["data"]["federation"]["bases"]["totalCount"]
+      )
+    end
+
+    it "provides bidirectional_pagination" do
+      result = star_trek_query(query_string, "first" => 1)
+      last_cursor = get_last_cursor(result)
+
+      result = star_trek_query(query_string, "first" => 1, "after" => last_cursor)
+      assert_equal true, get_page_info(result)["hasNextPage"]
+      assert_equal false, get_page_info(result)["hasPreviousPage"]
+
+      result = with_bidirectional_pagination {
+        star_trek_query(query_string, "first" => 1, "after" => last_cursor)
+      }
+      assert_equal true, get_page_info(result)["hasNextPage"]
+      assert_equal true, get_page_info(result)["hasPreviousPage"]
+
+      last_cursor = get_last_cursor(result)
+      result = with_bidirectional_pagination {
+        star_trek_query(query_string, "last" => 1, "before" => last_cursor)
+      }
+      assert_equal true, get_page_info(result)["hasNextPage"]
+      assert_equal false, get_page_info(result)["hasPreviousPage"]
+
+      result = star_trek_query(query_string, "first" => 100)
+      last_cursor = get_last_cursor(result)
+
+      result = star_trek_query(query_string, "last" => 1, "before" => last_cursor)
+      assert_equal false, get_page_info(result)["hasNextPage"]
+      assert_equal true, get_page_info(result)["hasPreviousPage"]
+
+      result = with_bidirectional_pagination {
+        star_trek_query(query_string, "last" => 1, "before" => last_cursor)
+      }
+      assert_equal true, get_page_info(result)["hasNextPage"]
+      assert_equal true, get_page_info(result)["hasPreviousPage"]
+    end
+
+    it 'slices the result' do
+      result = star_trek_query(query_string, "first" => 2)
+      assert_equal(["Deep Space Station K-7", "Regula I"], get_names(result))
+
+      # After the last result, find the next 2:
+      last_cursor = get_last_cursor(result)
+
+      result = star_trek_query(query_string, "after" => last_cursor, "first" => 2)
+      assert_equal(["Deep Space Nine"], get_names(result))
+
+      last_cursor = get_last_cursor(result)
+
+      result = star_trek_query(query_string, "before" => last_cursor, "last" => 1)
+      assert_equal(["Regula I"], get_names(result))
+
+      result = star_trek_query(query_string, "before" => last_cursor, "last" => 2)
+      assert_equal(["Deep Space Station K-7", "Regula I"], get_names(result))
+
+      result = star_trek_query(query_string, "before" => last_cursor, "last" => 10)
+      assert_equal(["Deep Space Station K-7", "Regula I"], get_names(result))
+
+      result = star_trek_query(query_string, "last" => 2)
+      assert_equal(["Regula I", "Deep Space Nine"], get_names(result))
+
+      result = star_trek_query(query_string, "last" => 10)
+      assert_equal(["Deep Space Station K-7", "Regula I", "Deep Space Nine"], get_names(result))
+      assert_equal(false, result["data"]["federation"]["bases"]["pageInfo"]["hasNextPage"])
+      assert_equal(false, result["data"]["federation"]["bases"]["pageInfo"]["hasPreviousPage"])
+    end
+
+    it 'works with before and after specified together' do
+      result = star_trek_query(query_string, "first" => 2)
+      assert_equal(["Deep Space Station K-7", "Regula I"], 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_trek_query(query_string, "before" => first_cursor, "after" => first_cursor, "last" => 2)
+      assert_equal([], get_names(result))
+
+      result = star_trek_query(query_string, "after" => first_cursor, "first" => 2)
+      assert_equal(["Deep Space Nine"], get_names(result))
+
+      second_cursor = get_last_cursor(result)
+
+      result = star_trek_query(query_string, "after" => first_cursor, "before" => second_cursor, "first" => 3)
+      assert_equal([], get_names(result)) # TODO: test fails. fixme
+    end
+
+    it 'handles cursors above the bounds of the array' do
+      overreaching_cursor = Base64.strict_encode64("100")
+      result = star_trek_query(query_string, "after" => overreaching_cursor, "first" => 2)
+      assert_equal([], get_names(result))
+    end
+
+    it 'handles cursors below the bounds of the array' do
+      underreaching_cursor = Base64.strict_encode64("1")
+      result = star_trek_query(query_string, "before" => underreaching_cursor, "first" => 2)
+      assert_equal([], get_names(result))
+    end
+
+
+    it 'handles grouped connections with only last argument' do
+      grouped_conn_query = <<-GRAPHQL
+      query {
+        newestBasesGroupedByFaction(last: 2) {
+          edges {
+            node {
+              name
+            }
+          }
+        }
+      }
+      GRAPHQL
+
+      result = star_trek_query(grouped_conn_query)
+      names = result['data']['newestBasesGroupedByFaction']['edges'].map { |edge| edge['node']['name'] }
+      assert_equal(['Ganalda Space Station', 'Deep Space Nine'], names)
+    end
+
+    it "applies custom arguments" do
+      result = star_trek_query(query_string, "first" => 1, "nameIncludes" => "eep")
+      assert_equal(["Deep Space Station K-7"], get_names(result))
+
+      after = get_last_cursor(result)
+
+      result = star_trek_query(query_string, "first" => 2, "nameIncludes" => "eep", "after" => after )
+      assert_equal(["Deep Space Nine"], get_names(result))
+      before = get_last_cursor(result)
+
+      result = star_trek_query(query_string, "last" => 1, "nameIncludes" => "eep", "before" => before)
+      assert_equal(["Deep Space Station K-7"], get_names(result))
+    end
+
+    it 'works without first/last/after/before' do
+      result = star_trek_query(query_string)
+
+      assert_equal(3, result["data"]["federation"]["bases"]["edges"].length)
+    end
+
+    describe "applying max_page_size" do
+      let(:query_string) {%|
+        query getBases($first: Int, $after: String, $last: Int, $before: String){
+          federation {
+            bases: basesWithMaxLimitRelation(first: $first, after: $after, last: $last, before: $before) {
+              ... basesConnection
+            }
+          }
+        }
+
+        fragment basesConnection on BaseConnection {
+          edges {
+            cursor
+            node {
+              name
+            }
+          },
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+        }
+      |}
+
+      it "applies to queries by `first`" do
+        result = star_trek_query(query_string, "first" => 100)
+        assert_equal(2, result["data"]["federation"]["bases"]["edges"].size)
+        assert_equal(true, result["data"]["federation"]["bases"]["pageInfo"]["hasNextPage"])
+
+        # Max page size is applied _without_ `first`, also
+        result = star_trek_query(query_string)
+        assert_equal(2, result["data"]["federation"]["bases"]["edges"].size)
+        assert_equal(false, result["data"]["federation"]["bases"]["pageInfo"]["hasNextPage"], "hasNextPage is false when first is not specified")
+      end
+
+      it "applies to queries by `last`" do
+        second_to_last_two_names = ["Firebase P'ok", "Ganalda Space Station"]
+        first_and_second_names = ["Deep Space Station K-7", "Regula I"]
+
+        last_cursor = "Ng=="
+        result = star_trek_query(query_string, "last" => 100, "before" => last_cursor)
+        assert_equal(second_to_last_two_names, get_names(result))
+        assert_equal(true, result["data"]["federation"]["bases"]["pageInfo"]["hasPreviousPage"])
+
+        result = star_trek_query(query_string, "before" => last_cursor)
+        assert_equal(first_and_second_names, get_names(result))
+        assert_equal(false, result["data"]["federation"]["bases"]["pageInfo"]["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
+
+        third_cursor = "Mw=="
+        result = star_trek_query(query_string, "last" => 100, "before" => third_cursor)
+        assert_equal(first_and_second_names, get_names(result))
+
+        result = star_trek_query(query_string, "before" => third_cursor)
+        assert_equal(first_and_second_names, get_names(result))
+      end
+    end
+
+    describe "applying default_max_page_size" do
+      let(:query_string) {%|
+        query getBases($first: Int, $after: String, $last: Int, $before: String){
+          federation {
+            bases: basesWithDefaultMaxLimitRelation(first: $first, after: $after, last: $last, before: $before) {
+              ... basesConnection
+            }
+          }
+        }
+
+        fragment basesConnection on BaseConnection {
+          edges {
+            cursor
+            node {
+              name
+            }
+          },
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+        }
+        |}
+
+      it "applies to queries by `first`" do
+        result = star_trek_query(query_string, "first" => 100)
+        assert_equal(3, result["data"]["federation"]["bases"]["edges"].size)
+        assert_equal(true, result["data"]["federation"]["bases"]["pageInfo"]["hasNextPage"])
+
+        # Max page size is applied _without_ `first`, also
+        result = star_trek_query(query_string)
+        assert_equal(3, result["data"]["federation"]["bases"]["edges"].size)
+        assert_equal(false, result["data"]["federation"]["bases"]["pageInfo"]["hasNextPage"], "hasNextPage is false when first is not specified")
+      end
+
+      it "applies to queries by `last`" do
+        second_to_last_three_names = ["Deep Space Nine", "Firebase P'ok", "Ganalda Space Station"]
+        first_second_and_third_names = ["Deep Space Station K-7", "Regula I", "Deep Space Nine"]
+
+        last_cursor = "Ng=="
+        result = star_trek_query(query_string, "last" => 100, "before" => last_cursor)
+        assert_equal(second_to_last_three_names, get_names(result))
+        assert_equal(true, result["data"]["federation"]["bases"]["pageInfo"]["hasPreviousPage"])
+
+        result = star_trek_query(query_string, "before" => last_cursor)
+        assert_equal(first_second_and_third_names, get_names(result))
+        assert_equal(false, result["data"]["federation"]["bases"]["pageInfo"]["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
+
+        fourth_cursor = "NA=="
+        result = star_trek_query(query_string, "last" => 100, "before" => fourth_cursor)
+        assert_equal(first_second_and_third_names, get_names(result))
+
+        result = star_trek_query(query_string, "before" => fourth_cursor)
+        assert_equal(first_second_and_third_names, get_names(result))
+      end
+    end
+  end
+
+  describe "applying a max_page_size bigger than the results" do
+    let(:query_string) {%|
+      query getBases($first: Int, $after: String, $last: Int, $before: String){
+        federation {
+          bases: basesWithLargeMaxLimitRelation(first: $first, after: $after, last: $last, before: $before) {
+            ... basesConnection
+          }
+        }
+      }
+
+      fragment basesConnection on BaseConnection {
+        edges {
+          cursor
+          node {
+            name
+          }
+        },
+        pageInfo {
+          hasNextPage
+          hasPreviousPage
+          startCursor
+          endCursor
+        }
+      }
+      |}
+
+    it "applies to queries by `first`" do
+      result = star_trek_query(query_string, "first" => 100)
+      assert_equal(6, result["data"]["federation"]["bases"]["edges"].size)
+      assert_equal(false, result["data"]["federation"]["bases"]["pageInfo"]["hasNextPage"])
+
+      # Max page size is applied _without_ `first`, also
+      result = star_trek_query(query_string)
+      assert_equal(6, result["data"]["federation"]["bases"]["edges"].size)
+      assert_equal(false, result["data"]["federation"]["bases"]["pageInfo"]["hasNextPage"], "hasNextPage is false when first is not specified")
+    end
+
+    it "applies to queries by `last`" do
+      all_names = ["Deep Space Station K-7", "Regula I", "Deep Space Nine", "Firebase P'ok", "Ganalda Space Station", "Rh'Ihho Station"]
+
+      last_cursor = "Ng=="
+      result = star_trek_query(query_string, "last" => 100, "before" => last_cursor)
+      assert_equal(all_names[0..4], get_names(result))
+      assert_equal(false, result["data"]["federation"]["bases"]["pageInfo"]["hasPreviousPage"])
+
+      result = star_trek_query(query_string, "last" => 100)
+      assert_equal(all_names, get_names(result))
+      assert_equal(false, result["data"]["federation"]["bases"]["pageInfo"]["hasPreviousPage"])
+
+      result = star_trek_query(query_string, "before" => last_cursor)
+      assert_equal(all_names[0..4], get_names(result))
+      assert_equal(false, result["data"]["federation"]["bases"]["pageInfo"]["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
+
+      fourth_cursor = "NA=="
+      result = star_trek_query(query_string, "last" => 100, "before" => fourth_cursor)
+      assert_equal(all_names[0..2], get_names(result))
+
+      result = star_trek_query(query_string, "before" => fourth_cursor)
+      assert_equal(all_names[0..2], get_names(result))
+    end
+  end
+
+  describe "without a block" do
+    let(:query_string) {%|
+      {
+        federation {
+          basesClone(first: 10) {
+            edges {
+              node {
+                name
+              }
+            }
+          }
+        }
+    }|}
+    it "uses default resolve" do
+      result = star_trek_query(query_string)
+      bases = result["data"]["federation"]["basesClone"]["edges"]
+      assert_equal(3, bases.length)
+    end
+  end
+
+  describe "custom ordering" do
+    let(:query_string) {%|
+      query getBases {
+        federation {
+          basesByName(first: 30) { ... basesFields }
+          bases(first: 30) { ... basesFields2 }
+        }
+      }
+      fragment basesFields on BaseConnection {
+        edges {
+          node {
+            name
+          }
+        }
+      }
+      fragment basesFields2 on BasesConnectionWithTotalCount {
+        edges {
+          node {
+            name
+          }
+        }
+      }
+    |}
+
+    def get_names(result, field_name)
+      bases = result["data"]["federation"][field_name]["edges"]
+      bases.map { |b| b["node"]["name"] }
+    end
+
+    it "applies the default value" do
+      result = star_trek_query(query_string)
+      bases_by_id   = ["Deep Space Station K-7", "Regula I", "Deep Space Nine"]
+      bases_by_name = ["Deep Space Nine", "Deep Space Station K-7", "Regula I"]
+
+      assert_equal(bases_by_id, get_names(result, "bases"))
+      assert_equal(bases_by_name, get_names(result, "basesByName"))
+    end
+  end
+
+  describe "#cursor_from_node" do
+    let(:connection) { GraphQL::Relay::MongoRelationConnection.new(StarTrek::Base.where(faction_id: 1), {}) }
+
+    it "returns the cursor for a node in the connection" do
+      assert_equal "MQ==", connection.cursor_from_node(StarTrek::Base.all[0])
+      assert_equal "Mg==", connection.cursor_from_node(StarTrek::Base.all[1])
+    end
+
+    it "raises when the node isn't found" do
+      err = assert_raises(RuntimeError) {
+        connection.cursor_from_node(:not_found)
+      }
+      assert_includes err.message, "item not found"
+    end
+  end
+
+  it "is chosen for a relation" do
+    relation = StarTrek::Base.where(faction_id: 1)
+    assert relation.is_a?(Mongoid::Criteria)
+    connection = GraphQL::Relay::BaseConnection.connection_for_nodes(relation)
+    assert_equal GraphQL::Relay::MongoRelationConnection, connection
+  end
+end