rails-graphql 0.2.1 → 1.0.0.beta

data/test/integration/memory/star_wars_query_test.rb

@@ -86,6 +86,21 @@ class Integration_Memory_StarWarsQueryTest < GraphQL::IntegrationTestCase
     GQL
   end
 
+  def test_using_alias_to_change_key_name_on_array
+    friends = [
+      { name: 'Han Solo' },
+      { name: 'Leia Organa' },
+      { name: 'C-3PO' },
+      { name: 'R2-D2' },
+    ]
+
+    assert_result({ data: { luke: { name: 'Luke Skywalker', others: friends } } }, <<~GQL)
+      query FetchLukeDeepAliased { luke: human(id: "1000") {
+        name others: friends { name }
+      } }
+    GQL
+  end
+
   def test_using_alias_to_change_key_name_twice
     luke = { name: 'Luke Skywalker' }
     leia = { name: 'Leia Organa' }
@@ -108,6 +123,15 @@ class Integration_Memory_StarWarsQueryTest < GraphQL::IntegrationTestCase
     GQL
   end
 
+  def test_query_with_field_argument
+    vader = { name: 'Darth Vader', greeting: 'Be gone Luke!' }
+    assert_result({ data: { human: vader } }, <<~GQL, variables: { name: 'Luke' })
+      query WithFieldArgument($name: String!) {
+        human(id: "1001") { name greeting(name: $name) }
+      }
+    GQL
+  end
+
   def test_query_with_fragment
     luke = { name: 'Luke Skywalker', homePlanet: 'Tatooine' }
     leia = { name: 'Leia Organa', homePlanet: 'Alderaan' }
@@ -124,6 +148,33 @@ class Integration_Memory_StarWarsQueryTest < GraphQL::IntegrationTestCase
     GQL
   end
 
+  def test_query_with_fragment_and_field_argument
+    vader = { name: 'Darth Vader', greeting: 'Be gone Luke!' }
+    assert_result({ data: { human: vader } }, <<~GQL, variables: { name: 'Luke' })
+      query WithFieldArgument($name: String!) {
+        human(id: "1001") { ...HumanFragment }
+      }
+
+      fragment HumanFragment on Human { name greeting(name: $name) }
+    GQL
+  end
+
+  def test_query_with_fragment_and_field_argument_and_default_values
+    first = { human: { name: 'Darth Vader', greeting: 'Be gone Luke!' } }
+    second = { human: { name: 'Darth Vader', greeting: 'Be gone Leia!' } }
+    assert_result({ data: { first: first, second: second } }, <<~GQL)
+      query first($id: ID! = 1001, $name: String! = "Luke") {
+        human(id: $id) { ...HumanFragment }
+      }
+
+      query second($id: ID! = 1001, $name: String! = "Leia") {
+        human(id: $id) { ...HumanFragment }
+      }
+
+      fragment HumanFragment on Human { name greeting(name: $name) }
+    GQL
+  end
+
   def test_get_typename_field
     assert_result({ data: { hero: { __typename: 'Droid', name: 'R2-D2' } } }, <<~GQL)
       query CheckTypeOfR2 { hero { __typename name } }
@@ -143,7 +194,7 @@ class Integration_Memory_StarWarsQueryTest < GraphQL::IntegrationTestCase
       message: 'Secret backstory is secret',
       locations: [{ line: 1, column: 35 }, { line: 1, column: 50 }],
       path: %w[HeroNameQuery hero secretBackstory],
-      extensions: { exception: 'RuntimeError' },
+      extensions: { stage: 'resolve', exception: 'RuntimeError' },
     }]
 
     assert_result({ data: { hero: hero }, errors: errors }, <<~GQL)
@@ -159,7 +210,7 @@ class Integration_Memory_StarWarsQueryTest < GraphQL::IntegrationTestCase
         message: 'Secret backstory is secret',
         locations: [{ line: 1, column: 50 }, { line: 1, column: 65 }],
         path: ['HeroNameQuery', 'hero', 'friends', n, 'secretBackstory'],
-        extensions: { exception: 'RuntimeError' },
+        extensions: { stage: 'resolve', exception: 'RuntimeError' },
       }
     end
 
@@ -174,7 +225,7 @@ class Integration_Memory_StarWarsQueryTest < GraphQL::IntegrationTestCase
       message: 'Secret backstory is secret',
       locations: [{ line: 1, column: 35 }, { line: 1, column: 57 }],
       path: %w[HeroNameQuery hero story],
-      extensions: { exception: 'RuntimeError' },
+      extensions: { stage: 'resolve', exception: 'RuntimeError' },
     }]
 
     assert_result({ data: { hero: hero }, errors: errors }, <<~GQL)

data/test/integration/memory/star_wars_validation_test.rb

@@ -23,7 +23,7 @@ class Integration_Memory_StarWarsValidationTest < GraphQL::IntegrationTestCase
 
   def test_invalid_query
     errors = [{
-      message: 'syntax error, unexpected EOF',
+      message: 'Parser error: unexpected "EOF"',
       locations: [{ line: 2, column: 1 }],
     }]
 

data/test/integration/mysql/star_wars_introspection_test.rb

@@ -0,0 +1,25 @@
+require 'integration/config'
+
+class Integration_MySQL_StarWarsIntrospectionTest < GraphQL::IntegrationTestCase
+  load_schema 'mysql'
+
+  SCHEMA = ::StartWarsMySQLSchema
+
+  def test_auto_introspection
+    assert(SCHEMA.introspection?)
+    assert(SCHEMA.has_field?(:query, :__schema))
+    assert(SCHEMA.has_field?(:query, :__type))
+  end
+
+  # Test this spec with all avaliable scalars
+  def remove_keys_form_type_map
+  end
+
+  # There are some issues with the end sorting, so compare the string result
+  # with sorted characters, which will produce the exact match
+  def test_gql_introspection
+    # File.write('test/assets/mysql.gql', SCHEMA.to_gql)
+    result = gql_file('mysql').split('').sort.join.squish
+    assert_equal(result, SCHEMA.to_gql.split('').sort.join.squish)
+  end
+end

data/test/integration/persisted_query_test.rb

@@ -0,0 +1,87 @@
+require 'integration/config'
+
+class Integration_PersistedQueryTest < GraphQL::IntegrationTestCase
+  class SCHEMA < GraphQL::Schema
+    namespace :cached
+
+    configure do |config|
+      config.enable_string_collector = false
+      config.default_response_format = :json
+    end
+
+    query_fields do
+      field(:one, :string).resolve { 'One!' }
+      field(:two, :string).resolve { 'Two!' }
+    end
+
+    class_attribute :cache, instance_writer: false, default: {}
+
+    class << self
+      def cached?(name, *)
+        cache.key?(name)
+      end
+
+      def delete_from_cache(name, *)
+        cache.delete(name)
+      end
+
+      def read_from_cache(name, *)
+        cache[name]
+      end
+
+      def write_on_cache(name, value, *)
+        cache[name] = value
+      end
+    end
+  end
+
+  def teardown
+    SCHEMA.cache.clear
+  end
+
+  def test_uncached_query
+    assert_result('One!', :one)
+  end
+
+  def test_cache_key
+    gen_key = cache_key('B')
+    assert_equal('graphql/cached/A', SCHEMA.send(:expand_cache_key, 'A'))
+    assert_equal('graphql/cached/B', SCHEMA.send(:expand_cache_key, gen_key).cache_key)
+  end
+
+  def test_cached_query
+    value = ::GQLParser.parse_execution('{ two }')
+    SCHEMA.write_on_cache((key = cache_key), value)
+    assert_result('Two!', :two, hash: key, cache_only: true)
+  end
+
+  def test_persist_query
+    assert_result('One!', :one, hash: (key = cache_key))
+    assert_operator(SCHEMA, :cached?, key)
+  end
+
+  def test_subsequent_query
+    assert_result('One!', :one, hash: (key = cache_key))
+    assert_result('One!', :one, hash: key, cache_only: true)
+  end
+
+  def test_execute_compiled_query
+    query = GraphQL.compile('{ one }', schema: SCHEMA)
+    result = GraphQL.execute(query, compiled: true, schema: SCHEMA)
+
+    assert_equal('One!', result.dig('data', 'one'))
+  end
+
+  private
+
+    def cache_key(key = nil, version = nil)
+      key ||= SCHEMA.config.cache_prefix + SecureRandom.uuid
+      Rails::GraphQL::CacheKey.new(key, version)
+    end
+
+    def assert_result(value, field, **options)
+      query = options.delete(:cache_only) ? nil : "{ #{field} }"
+      result = GraphQL.execute(query, **options, schema: SCHEMA)
+      assert_equal(value, result.dig('data', field.to_s))
+    end
+end

data/test/integration/resolver_precedence_test.rb

@@ -0,0 +1,154 @@
+require 'integration/config'
+
+class Integration_ResolverPrecedenceTest < GraphQL::IntegrationTestCase
+  EVENT_HANDLERS = { resolve: :@resolver, perform: :@performer }
+
+  class SCHEMA < GraphQL::Schema
+    namespace :precedence
+
+    configure do |config|
+      config.enable_string_collector = false
+      config.default_response_format = :json
+    end
+
+    object 'Object1' do
+      field(:field1, :string)
+    end
+
+    query_fields do
+      field(:query1, :string)
+      field(:query2, 'Object1').resolve { OpenStruct.new(field1: 'Default Value') }
+    end
+
+    mutation_fields do
+      field(:mutation1, :string).perform { }
+    end
+  end
+
+  attr_reader :object, :field
+
+  def test_simple_query
+    object = SCHEMA
+    field = object[:query][:query1]
+
+    # (1) Resolver as block comes first
+    stub_handler(field, :resolve, -> { 'Ok 1' }) do
+      assert_result('Ok 1', 'query1')
+    end
+
+    # (2) Method on schema comes second
+    stub_callable(object, field, :query1, -> { 'Ok 2' }) do
+      assert_result('Ok 2', 'query1')
+    end
+
+    # (1) Resolver block has higher precedence than method on schema
+    stub_callable(object, field, :query1, -> { 'Nok 3' }) do
+      stub_handler(field, :resolve, -> { 'Ok 3' }) do
+        assert_result('Ok 3', 'query1')
+      end
+    end
+  end
+
+  def test_simple_mutation
+    object = SCHEMA
+    field = object[:mutation][:mutation1]
+
+    # (1) With performer but no resolver has the higher precedence
+    $check = true
+    stub_handler(field, :perform, -> { 'Ok 1' }) do
+      assert_result('Ok 1', 'mutation1', :mutation)
+    end
+
+    # (2) Performer first and then resolver has the second precedence
+    result = ''
+    stub_handler(field, :perform, -> { result << 'Ok 2' }) do
+      stub_handler(field, :resolve, -> { result << 'Ok 3' }) do
+        assert_result('Ok 2Ok 3', 'mutation1', :mutation)
+      end
+    end
+
+    # (3) Performer as a method but resolver as block
+    result = ''
+    stub_callable(object, field, :mutation1!, -> { result << 'Ok 4' }) do
+      stub_handler(field, :resolve, -> { result << 'Ok 5' }) do
+        assert_result('Ok 4Ok 5', 'mutation1', :mutation)
+      end
+    end
+
+    # (4) Performer as a method first and then resolve as a method
+    result = ''
+    stub_callable(object, field, :mutation1!, -> { result << 'Ok 6' }) do
+      stub_callable(object, field, :mutation1, -> { result << 'Ok 7' }) do
+        assert_result('Ok 6Ok 7', 'mutation1', :mutation)
+      end
+    end
+
+    # (2) Blocks has higher precedence than methods
+    result = ''
+    stub_callable(object, field, :mutation1!, -> { result << 'Nok 8' }) do
+      stub_callable(object, field, :mutation1, -> { result << 'Nok 9' }) do
+        stub_handler(field, :perform, -> { result << 'Ok 8' }) do
+          stub_handler(field, :resolve, -> { result << 'Ok 9' }) do
+            assert_result('Ok 8Ok 9', 'mutation1', :mutation)
+          end
+        end
+      end
+    end
+  end
+
+  def test_simple_object
+    object = GraphQL::Object1Object
+    field = object[:field1]
+
+    # (1) Block has higher precedence than default value
+    stub_handler(field, :resolve, -> { 'Ok 1' }) do
+      assert_result('Ok 1', 'field1.query2')
+    end
+
+    # (2) Method on object comes second
+    stub_callable(object, field, :field1, -> { 'Ok 2' }) do
+      assert_result('Ok 2', 'field1.query2')
+    end
+
+    # (3) Lastly it will simply put the original resolved value
+    assert_result('Default Value', 'field1.query2')
+
+    # (1) Block has higher precedence than methond on object
+    stub_callable(object, field, :field1, -> { 'Nok 3' }) do
+      stub_handler(field, :resolve, -> { 'Ok 3' }) do
+        assert_result('Ok 3', 'field1.query2')
+      end
+    end
+  end
+
+  protected
+
+    def assert_result(expected, field, operation = :query)
+      doc, data = field.split('.').reduce(['', expected]) do |(d, r), part|
+        ["{ #{part} #{d} }", { part => r }]
+      end
+
+      super({ data: data }, "#{operation} #{doc}")
+    end
+
+    def stub_handler(field, event, *args, **xargs)
+      block = args.shift if args.first.is_a?(Proc)
+      cb = create_callback(field, event, *args, **xargs, &block)
+
+      field.get_reset_ivar(:@dynamic_resolver, event == :resolve) do
+        field.stub_ivar(EVENT_HANDLERS[event], cb) { yield }
+      end
+    end
+
+    def stub_callable(object, field, method_name, block)
+      field.get_reset_ivar(:@dynamic_resolver) do
+        field.get_reset_ivar(:@resolver) do
+          object.stub_imethod(method_name, block) { yield }
+        end
+      end
+    end
+
+    def create_callback(source, event, *args, **xargs, &block)
+      Rails::GraphQL::Callback.new(source, event, *args, **xargs, &block)
+    end
+end

data/test/integration/schemas/memory.rb

@@ -25,7 +25,7 @@ module MemoryTest
   end
 
   class Human < Character
-    attr_accessor :home_planet
+    attr_accessor :home_planet, :greeting
   end
 
   class Droid < Character
@@ -39,33 +39,38 @@ module MemoryTest
         name: 'Luke Skywalker',
         friends: ['1002', '1003', '2000', '2001'],
         appears_in: [0, 1, 2],
-        home_planet: 'Tatooine'
+        home_planet: 'Tatooine',
+        greeting: 'Hi %s!',
       ),
       '1001' => Human.new(
         id: '1001',
         name: 'Darth Vader',
         friends: ['1004'],
         appears_in: [0, 1, 2],
-        home_planet: 'Tatooine'
+        home_planet: 'Tatooine',
+        greeting: 'Be gone %s!',
       ),
       '1002' => Human.new(
         id: '1002',
         name: 'Han Solo',
         friends: ['1000', '1003', '2001'],
-        appears_in: [0, 1, 2]
+        appears_in: [0, 1, 2],
+        greeting: 'Hello %s!',
       ),
       '1003' => Human.new(
         id: '1003',
         name: 'Leia Organa',
         friends: ['1000', '1002', '2000', '2001'],
         appears_in: [0, 1, 2],
-        home_planet: 'Alderaan'
+        home_planet: 'Alderaan',
+        greeting: 'Greetings %s!',
       ),
       '1004' => Human.new(
         id: '1004',
         name: 'Wilhuff Tarkin',
         friends: ['1001'],
-        appears_in: [0]
+        appears_in: [0],
+        greeting: 'Sup %s!',
       ),
     },
     droids: {
@@ -92,10 +97,12 @@ class StartWarsMemSchema < GraphQL::Schema
 
   configure do |config|
     config.enable_string_collector = false
+    config.default_response_format = :json
   end
 
   rescue_from('StandardError') do |exception|
-    !!field ? request.exception_to_error(exception, field) : raise
+    raise unless exception.source.is_a?(Rails::GraphQL::Request::Component::Field)
+    exception.request.exception_to_error(exception, exception.source)
   end
 
   enum 'Episode' do
@@ -149,6 +156,14 @@ class StartWarsMemSchema < GraphQL::Schema
 
     field :home_planet, :string,
       desc: 'The home planet of the human, or null if unknown'
+
+    field :greeting, :string,
+      desc: 'A greeting phrase from this person to someone',
+      arguments: arg(:name, :string, null: false)
+
+    def greeting(name:)
+      format(current_value.greeting, name)
+    end
   end
 
   object 'Droid' do

data/test/integration/schemas/mysql.rb

@@ -0,0 +1,62 @@
+require 'active_record'
+
+class MySQLRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  establish_connection(
+    name: 'mysql',
+    adapter: 'mysql2',
+    host: ENV.fetch('GQL_MYSQL_HOST', 'localhost'),
+    database: ENV.fetch('GQL_MYSQL_DATABASE', 'starwars'),
+    username: ENV.fetch('GQL_MYSQL_USERNAME', 'root'),
+    password: ENV['GQL_MYSQL_PASSWORD'],
+  )
+end
+
+MySQLRecord.connection.instance_eval do
+  create_table 'jedi_types', force: :cascade do |t|
+    t.string 'name'
+  end
+
+  create_table 'jedis', force: :cascade do |t|
+    t.integer 'jedi_type_id'
+    t.string 'name'
+  end
+end
+
+class JediType < MySQLRecord
+  has_many :jedi, class_name: 'Jedi', foreign_key: :jedi_type_id
+
+  accepts_nested_attributes_for :jedi
+
+  MASTER = create!(name: 'Master')
+  PADAWAN = create!(name: 'Padawan')
+end
+
+class Jedi < MySQLRecord
+  belongs_to :jedi_type, class_name: 'JediType', foreign_key: :jedi_type_id
+
+  validates :name, presence: true, if: -> { true }
+
+  create!(name: 'Ioda',             jedi_type: JediType::MASTER)
+  create!(name: 'Obi-Wan Kenobi',   jedi_type: JediType::MASTER)
+  create!(name: 'Anakin Skywalker', jedi_type: JediType::PADAWAN)
+  create!(name: 'Mace Windu',       jedi_type: JediType::MASTER)
+end
+
+class StartWarsMySQLSchema < GraphQL::Schema
+  namespace :star_wars_mysql
+
+  configure do |config|
+    config.enable_string_collector = false
+    config.default_response_format = :json
+  end
+
+  source JediType do
+    with_options on: 'jediTypes' do
+      scoped_argument(:order) { |o| order(name: o) }
+    end
+  end
+
+  source Jedi
+end

data/test/integration/schemas/sqlite.rb

@@ -1,14 +1,17 @@
 require 'active_record'
-
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+require 'active_record/database_configurations'
 
 ActiveSupport::Inflector.inflections(:en) do |inflect|
   inflect.irregular 'base', 'bases'
 end
 
-ActiveRecord::Schema.define(version: 1) do
-  self.verbose = false
+class SQLiteRecord < ActiveRecord::Base
+  self.abstract_class = true
 
+  establish_connection(adapter: 'sqlite3', database: ':memory:')
+end
+
+SQLiteRecord.connection.instance_eval do
   create_table 'lite_factions', force: :cascade do |t|
     t.string 'name'
   end
@@ -25,10 +28,6 @@ ActiveRecord::Schema.define(version: 1) do
   end
 end
 
-class SQLiteRecord < ActiveRecord::Base
-  self.abstract_class = true
-end
-
 class LiteFaction < SQLiteRecord
   has_many :bases, class_name: 'LiteBase', foreign_key: :faction_id
   has_many :ships, class_name: 'LiteShip', foreign_key: :faction_id
@@ -43,6 +42,8 @@ end
 class LiteBase < SQLiteRecord
   belongs_to :faction, class_name: 'LiteFaction', foreign_key: :faction_id
 
+  validates :name, presence: true
+
   create!(name: 'Yavin',            planet: 'Yavin 4',   faction: LiteFaction::REBELS)
   create!(name: 'Echo Base',        planet: 'Hoth',      faction: LiteFaction::REBELS)
   create!(name: 'Secret Hideout',   planet: 'Dantooine', faction: LiteFaction::REBELS)
@@ -54,6 +55,8 @@ end
 class LiteShip < SQLiteRecord
   belongs_to :faction, class_name: 'LiteFaction', foreign_key: :faction_id
 
+  validates :name, presence: true, if: -> { true }
+
   create!(name: 'X-Wing',           faction: LiteFaction::REBELS)
   create!(name: 'Y-Wing',           faction: LiteFaction::REBELS)
   create!(name: 'A-Wing',           faction: LiteFaction::REBELS)
@@ -65,18 +68,24 @@ class LiteShip < SQLiteRecord
 end
 
 class StartWarsSqliteSchema < GraphQL::Schema
-  namespace :start_wars_sqlite
+  namespace :star_wars_sqlite
 
   configure do |config|
     config.enable_string_collector = false
+    config.default_response_format = :json
   end
 
-  sources LiteFaction do
+  source LiteFaction do
     with_options on: 'liteFactions' do
       scoped_argument(:order) { |o| order(name: o) }
     end
   end
 
-  sources LiteBase
-  sources LiteShip
+  source LiteBase do
+    with_options on: 'liteBases' do
+      scoped_argument(:order, default: :desc) { |o| order(name: o) }
+    end
+  end
+
+  source LiteShip
 end

data/test/integration/sqlite/star_wars_global_id_test.rb

@@ -0,0 +1,83 @@
+require 'integration/config'
+
+class Integration_SQLite_StarWarsGlobalIDTest < GraphQL::IntegrationTestCase
+  load_schema 'sqlite'
+
+  SCHEMA = ::StartWarsSqliteSchema
+
+  ## CREATE
+
+  def test_create_query_field
+    obj = GraphQL::LiteFactionSource[:query][:lite_factions]
+    assert_gid_value('gql://star-wars-sqlite/LiteFactionSource/query/liteFactions', obj)
+  end
+
+  def test_create_object
+    obj = GraphQL::LiteFactionSource.object
+    assert_gid_value('gql://star-wars-sqlite/Type/LiteFaction', obj)
+  end
+
+  def test_create_input
+    obj = GraphQL::LiteFactionSource.input
+    assert_gid_value('gql://star-wars-sqlite/Type/LiteFactionInput', obj)
+
+    obj = GraphQL::LiteFactionSource.input.deserialize(nil)
+    assert_gid_value('gql://star-wars-sqlite/Type/LiteFactionInput?', obj)
+
+    params = { name: 'Sample' }
+    obj = GraphQL::LiteFactionSource.input.deserialize(params)
+    assert_gid_value('gql://star-wars-sqlite/Type/LiteFactionInput?name=Sample', obj)
+
+    params = { name: 'Sample', bases_attributes: [{ name: 'Other' }] }
+    obj = GraphQL::LiteFactionSource.input.deserialize(params)
+    assert_gid_value('gql://star-wars-sqlite/Type/LiteFactionInput?basesAttributes[][name]=Other&name=Sample', obj)
+  end
+
+  def test_create_object_field
+    obj = GraphQL::LiteFactionSource.object[:name]
+    assert_gid_value('gql://star-wars-sqlite/LiteFactionObject/name', obj)
+  end
+
+  def assert_gid_value(result, object)
+    assert_equal(result.gsub(/\[|\]/, { '[' => '%5B', ']' => '%5D' }), object.to_gid.to_s)
+  end
+
+  ## PARSE
+
+  def test_parse_query_field
+    obj = find_gid('gql://star-wars-sqlite/LiteFactionSource/query/liteFactions')
+    assert_equal(GraphQL::LiteFactionSource[:query][:lite_factions], obj)
+  end
+
+  def test_parse_object
+    obj = find_gid('gql://star-wars-sqlite/Type/LiteFaction')
+    assert_equal(GraphQL::LiteFactionSource.object, obj)
+  end
+
+  def test_parse_input
+    obj = find_gid('gql://star-wars-sqlite/Type/LiteFactionInput')
+    assert_equal(GraphQL::LiteFactionSource.input, obj)
+
+    obj = find_gid('gql://star-wars-sqlite/Type/LiteFactionInput?')
+    assert_instance_of(GraphQL::LiteFactionSource.input, obj)
+    assert_empty(obj.params)
+
+    obj = find_gid('gql://star-wars-sqlite/Type/LiteFactionInput?name=Sample')
+    assert_instance_of(GraphQL::LiteFactionSource.input, obj)
+    assert_equal('Sample', obj.params[:name])
+
+    obj = find_gid('gql://star-wars-sqlite/Type/LiteFactionInput?bases_attributes[][name]=Other&name=Sample')
+    assert_instance_of(GraphQL::LiteFactionSource.input, obj)
+    assert_equal([{name: 'Other'}], obj.params[:bases_attributes])
+    assert_equal('Sample', obj.params[:name])
+  end
+
+  def test_parse_object_field
+    obj = find_gid('gql://star-wars-sqlite/LiteFactionObject/name')
+    assert_equal(GraphQL::LiteFactionSource.object[:name], obj)
+  end
+
+  def find_gid(gid)
+    GraphQL::GlobalID.find(gid)
+  end
+end