rails-graphql 0.1.0

data/test/integration/config.rb

@@ -0,0 +1,56 @@
+require 'config'
+
+require 'active_support/core_ext/class/subclasses'
+
+module GraphQL
+  class IntegrationTestCase < TestCase
+    SCHEMAS = Pathname.new(__dir__).join('schemas')
+    ASSETS = Pathname.new(__dir__).join('../assets')
+
+    def setup
+      reset_type_map!
+    end
+
+    protected
+
+      def self.load_schema(name)
+        require(SCHEMAS.join("#{name}"))
+      end
+
+      def reset_type_map!
+        Rails::GraphQL.type_map.hard_reset!
+      end
+
+      def named_list(*list, **extra)
+        list.map { |x| extra.reverse_merge(name: x) }
+      end
+
+      def gql_file(name)
+        ASSETS.join("#{name}.gql").read
+      end
+
+      def text_file(name)
+        ASSETS.join("#{name}.txt").read
+      end
+
+      def json_file(name)
+        JSON.parse(ASSETS.join("#{name}.json").read)
+      end
+
+      def execute(*args, **xargs)
+        xargs[:as] ||= :object
+        xargs[:schema] ||= self.class.const_get(:SCHEMA)
+        ::GraphQL.execute(*args, **xargs)
+      end
+
+      def assert_result(obj, *args, dig: nil, **xargs)
+        result = execute(*args, **xargs)
+        result = result.try(:dig, *dig) if !!dig
+        yield result if block_given?
+
+        obj = obj.deep_stringify_keys if obj.is_a?(Hash)
+        obj = obj.map(&:deep_stringify_keys) if obj.is_a?(Array)
+        obj.nil? ? assert_nil(result) : assert_equal(obj, result)
+      end
+  end
+end

data/test/integration/memory/star_wars_introspection_test.rb

@@ -0,0 +1,144 @@
+require 'integration/config'
+
+# See: https://github.com/graphql/graphql-js/blob/master/src/__tests__/starWarsIntrospection-test.js
+class Integration_Memory_StarWarsIntrospectionTest < GraphQL::IntegrationTestCase
+  load_schema 'memory'
+
+  SCHEMA = ::StartWarsMemSchema
+
+  def test_query_schema_types
+    types = named_list(*%w[Bigint Binary Boolean Character Date DateTime Decimal Droid Episode
+      Float Human ID Int String Time _Mutation _Query __Directive __DirectiveLocation
+      __EnumValue __Field __InputValue __Schema __Type __TypeKind])
+
+    sort_items = ->(result) do
+      result.dig('data', '__schema', 'types').sort_by! { |t| t['name'] }
+    end
+
+    assert_result({ data: { __schema: { types: types } } }, <<~GQL, &sort_items)
+      { __schema { types { name } } }
+    GQL
+  end
+
+  def test_query_schema_query_type
+    assert_result({ data: { __schema: { queryType: { name: '_Query' } } } }, <<~GQL)
+      { __schema { queryType { name } } }
+    GQL
+  end
+
+  def test_query_schema_mutation_type
+    assert_result({ data: { __schema: { mutationType: { name: '_Mutation' } } } }, <<~GQL)
+      { __schema { mutationType { name } } }
+    GQL
+  end
+
+  def test_query_specific_type
+    assert_result({ data: { __type: { name: 'Droid' } } }, <<~GQL)
+      { __type(name: "Droid") { name } }
+    GQL
+  end
+
+  def test_query_specific_type_with_kind
+    assert_result({ data: { __type: { name: 'Droid', kind: 'OBJECT' } } }, <<~GQL)
+      { __type(name: "Droid") { name kind } }
+    GQL
+  end
+
+  def test_query_specific_type_as_interface
+    assert_result({ data: { __type: { name: 'Character', kind: 'INTERFACE' } } }, <<~GQL)
+      { __type(name: "Character") { name kind } }
+    GQL
+  end
+
+  def test_query_object_fields
+    fields = [
+      { name: 'id', type: { name: nil, kind: 'NON_NULL' } },
+      { name: 'name', type: { name: 'String', kind: 'SCALAR' } },
+      { name: 'friends', type: { name: nil, kind: 'LIST' } },
+      { name: 'appearsIn', type: { name: nil, kind: 'LIST' } },
+      { name: 'secretBackstory', type: { name: 'String', kind: 'SCALAR' } },
+      { name: 'primaryFunction', type: { name: 'String', kind: 'SCALAR' } },
+    ]
+
+    assert_result({ data: { __type: { name: 'Droid', fields: fields } } }, <<~GQL)
+      { __type(name: "Droid") { name fields { name type { name kind } } } }
+    GQL
+  end
+
+  def test_query_object_fields_with_nested_type
+    fields = [
+      { name: 'id', type: { name: nil, kind: 'NON_NULL', ofType: { name: 'ID', kind: 'SCALAR' } } },
+      { name: 'name', type: { name: 'String', kind: 'SCALAR', ofType: nil } },
+      { name: 'friends', type: { name: nil, kind: 'LIST', ofType: { name: 'Character', kind: 'INTERFACE' } } },
+      { name: 'appearsIn', type: { name: nil, kind: 'LIST', ofType: { name: 'Episode', kind: 'ENUM' } } },
+      { name: 'secretBackstory', type: { name: 'String', kind: 'SCALAR', ofType: nil } },
+      { name: 'primaryFunction', type: { name: 'String', kind: 'SCALAR', ofType: nil } },
+    ]
+
+    assert_result({ data: { __type: { name: 'Droid', fields: fields } } }, <<~GQL)
+      {
+        __type(name: "Droid") {
+          name fields { name type { name kind ofType { name kind } } }
+        }
+      }
+    GQL
+  end
+
+  def test_query_object_with_arguments
+    name_arg = { name: 'name', description: nil, type: {
+      name: nil, kind: 'NON_NULL', ofType: { name: 'String', kind: 'SCALAR' } ,
+    }, defaultValue: nil }
+
+    epi_arg = { name: 'episode', description: 'Return for a specific episode', type: {
+      name: 'Episode', kind: 'ENUM', ofType: nil,
+    }, defaultValue: nil }
+
+    id_arg = { name: 'id', description: nil, type: {
+      name: nil, kind: 'NON_NULL', ofType: { name: 'ID', kind: 'SCALAR' } ,
+    }, defaultValue: nil }
+
+    fields = [
+      { name: '__schema', args: [] },
+      { name: '__type', args: [name_arg] },
+      { name: 'hero', args: [epi_arg] },
+      { name: 'human', args: [id_arg.merge(description: 'ID of the human')] },
+      { name: 'droid', args: [id_arg.merge(description: 'ID of the droid')] },
+    ]
+
+    assert_result({ data: { __schema: { queryType: { fields: fields } } } }, <<~GQL)
+      { __schema { queryType { fields {
+        name
+        args {
+          name
+          description
+          type { name kind ofType { name kind } }
+          defaultValue
+        }
+      } } } }
+    GQL
+  end
+
+  def test_query_schema_documentation
+    description = 'A mechanical creature in the Star Wars universe'
+    assert_result({ data: { __type: { name: 'Droid', description: description } } }, <<~GQL)
+      { __type(name: "Droid") { name description } }
+    GQL
+  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_query_full_introspection
+    query = gql_file('introspection')
+    result = text_file('introspection-mem').split('').sort.join
+    assert_result(result, query, as: :string) do |res|
+      # File.write('test/assets/introspection-mem.txt', res)
+      res.replace(res.split('').sort.join)
+    end
+  end
+
+  def test_gql_introspection
+    # File.write('test/assets/mem.gql', SCHEMA.to_gql)
+    result = gql_file('mem').split('').sort.join.squish
+    assert_equal(result, SCHEMA.to_gql.split('').sort.join.squish)
+  end
+end

data/test/integration/memory/star_wars_query_test.rb

@@ -0,0 +1,184 @@
+require 'integration/config'
+
+# See: https://github.com/graphql/graphql-js/blob/master/src/__tests__/starWarsQuery-test.js
+class Integration_Memory_StarWarsQueryTest < GraphQL::IntegrationTestCase
+  load_schema 'memory'
+
+  SCHEMA = ::StartWarsMemSchema
+  ALL_EPISODES = %w[NEW_HOPE EMPIRE JEDI]
+
+  def test_r2d2_saga_hero
+    assert_result({ data: { hero: { name: 'R2-D2' } } }, <<~GQL)
+      query HeroNameQuery { hero { name } }
+    GQL
+  end
+
+  def test_r2d2_by_id_and_friends
+    friends = named_list('Luke Skywalker', 'Han Solo', 'Leia Organa')
+    hero = { id: '2001', name: 'R2-D2', friends: friends }
+    assert_result({ data: { hero: hero } }, <<~GQL)
+      query HeroNameAndFriendsQuery {
+        hero { id name friends { name } }
+      }
+    GQL
+  end
+
+  def test_r2d2_friends_of_friends
+    friends1 = named_list('Han Solo', 'Leia Organa', 'C-3PO', 'R2-D2')
+    friends2 = named_list('Luke Skywalker', 'Leia Organa', 'R2-D2')
+    friends3 = named_list('Luke Skywalker', 'Han Solo', 'C-3PO', 'R2-D2')
+    friends = [
+      { name: 'Luke Skywalker', appearsIn: ALL_EPISODES, friends: friends1 },
+      { name: 'Han Solo',       appearsIn: ALL_EPISODES, friends: friends2 },
+      { name: 'Leia Organa',    appearsIn: ALL_EPISODES, friends: friends3 },
+    ]
+
+    hero = { name: 'R2-D2', friends: friends }
+    assert_result({ data: { hero: hero } }, <<~GQL)
+      query NestedQuery {
+        hero { name friends { name appearsIn friends { name } } }
+      }
+    GQL
+  end
+
+  def test_using_ids_refetch
+    human = { name: 'Luke Skywalker' }
+    droid = { name: 'C-3PO' }
+
+    assert_result({ data: { human: human, droid: droid } }, <<~GQL)
+      query FetchLukeAndC3POQuery {
+        human(id: "1000") { name }
+        droid(id: "2000") { name }
+      }
+    GQL
+  end
+
+  def test_generic_query_fetch_by_id_luke
+    xargs = { args: { some_id: '1000' } }
+    assert_result({ data: { human: { name: 'Luke Skywalker' } } }, <<~GQL, **xargs)
+      query FetchSomeIDQuery($someId: ID!) {
+        human(id: $someId) { name }
+      }
+    GQL
+  end
+
+  def test_generic_query_fetch_by_id_han
+    xargs = { args: { some_id: '1002' } }
+    assert_result({ data: { human: { name: 'Han Solo' } } }, <<~GQL, **xargs)
+      query FetchSomeIDQuery($someId: ID!) {
+        human(id: $someId) { name }
+      }
+    GQL
+  end
+
+  def test_generic_query_fetch_by_id_invalid
+    xargs = { args: { id: 'not a valid id' } }
+    assert_result({ data: { human: nil } }, <<~GQL, **xargs)
+      query FetchSomeIDQuery($id: ID!) {
+        human(id: $id) { name }
+      }
+    GQL
+  end
+
+  def test_using_alias_to_change_key_name
+    assert_result({ data: { luke: { name: 'Luke Skywalker' } } }, <<~GQL)
+      query FetchLukeAliased { luke: human(id: "1000") { name } }
+    GQL
+  end
+
+  def test_using_alias_to_change_key_name_twice
+    luke = { name: 'Luke Skywalker' }
+    leia = { name: 'Leia Organa' }
+    assert_result({ data: { luke: luke, leia: leia } }, <<~GQL)
+      query FetchLukeAliased {
+        luke: human(id: "1000") { name }
+        leia: human(id: "1003") { name }
+      }
+    GQL
+  end
+
+  def test_query_with_duplicated_content
+    luke = { name: 'Luke Skywalker', homePlanet: 'Tatooine' }
+    leia = { name: 'Leia Organa', homePlanet: 'Alderaan' }
+    assert_result({ data: { luke: luke, leia: leia } }, <<~GQL)
+      query DuplicateFields {
+        luke: human(id: "1000") { name homePlanet }
+        leia: human(id: "1003") { name homePlanet }
+      }
+    GQL
+  end
+
+  def test_query_with_fragment
+    luke = { name: 'Luke Skywalker', homePlanet: 'Tatooine' }
+    leia = { name: 'Leia Organa', homePlanet: 'Alderaan' }
+    assert_result({ data: { luke: luke, leia: leia } }, <<~GQL)
+      query DuplicateFields {
+        luke: human(id: "1000") { ...HumanFragment }
+        leia: human(id: "1003") { ...HumanFragment }
+      }
+
+      fragment HumanFragment on Human {
+        name
+        homePlanet
+      }
+    GQL
+  end
+
+  def test_get_typename_field
+    assert_result({ data: { hero: { __typename: 'Droid', name: 'R2-D2' } } }, <<~GQL)
+      query CheckTypeOfR2 { hero { __typename name } }
+    GQL
+  end
+
+  def test_get_typename_from_luke
+    luke = { __typename: 'Human', name: 'Luke Skywalker' }
+    assert_result({ data: { hero: luke } }, <<~GQL)
+      query CheckTypeOfLuke { hero(episode: EMPIRE) { __typename name } }
+    GQL
+  end
+
+  def test_error_on_secret_backstory
+    hero = { name: 'R2-D2', secretBackstory: nil }
+    errors = [{
+      message: 'Secret backstory is secret',
+      locations: [{ line: 1, column: 35 }, { line: 1, column: 50 }],
+      path: %w[HeroNameQuery hero secretBackstory],
+      extensions: { exception: 'RuntimeError' },
+    }]
+
+    assert_result({ data: { hero: hero }, errors: errors }, <<~GQL)
+      query HeroNameQuery { hero { name secretBackstory } }
+    GQL
+  end
+
+  def test_nested_secret_backstory
+    friends = named_list('Luke Skywalker', 'Han Solo', 'Leia Organa', secretBackstory: nil)
+    hero = { name: 'R2-D2', friends: friends }
+    errors = 3.times.map do |n|
+      {
+        message: 'Secret backstory is secret',
+        locations: [{ line: 1, column: 50 }, { line: 1, column: 65 }],
+        path: ['HeroNameQuery', 'hero', 'friends', n, 'secretBackstory'],
+        extensions: { exception: 'RuntimeError' },
+      }
+    end
+
+    assert_result({ data: { hero: hero }, errors: errors }, <<~GQL)
+      query HeroNameQuery { hero { name friends { name secretBackstory } } }
+    GQL
+  end
+
+  def test_backstory_on_alias
+    hero = { name: 'R2-D2', story: nil }
+    errors = [{
+      message: 'Secret backstory is secret',
+      locations: [{ line: 1, column: 35 }, { line: 1, column: 57 }],
+      path: %w[HeroNameQuery hero story],
+      extensions: { exception: 'RuntimeError' },
+    }]
+
+    assert_result({ data: { hero: hero }, errors: errors }, <<~GQL)
+      query HeroNameQuery { hero { name story: secretBackstory } }
+    GQL
+  end
+end

data/test/integration/memory/star_wars_validation_test.rb

@@ -0,0 +1,99 @@
+require 'integration/config'
+
+# See: https://github.com/graphql/graphql-js/blob/master/src/__tests__/starWarsValidation-test.js
+class Integration_Memory_StarWarsValidationTest < GraphQL::IntegrationTestCase
+  load_schema 'memory'
+
+  SCHEMA = ::StartWarsMemSchema
+
+  def test_complex_but_valid_query
+    assert_result(nil, <<~GQL, dig: 'errors')
+      query NestedQueryWithFragment { hero {
+        ...NameAndAppearances friends { ...NameAndAppearances friends {
+          ...NameAndAppearances
+        } }
+      } }
+
+      fragment NameAndAppearances on Character {
+        name
+        appearsIn
+      }
+    GQL
+  end
+
+  def test_invalid_query
+    errors = [{
+      message: 'syntax error, unexpected EOF',
+      locations: [{ line: 2, column: 1 }],
+    }]
+
+    assert_result(errors, <<~GQL, dig: 'errors')
+      query DroidFieldInFragment { hero { name ... on Droid { primaryFunction
+    GQL
+  end
+
+  def test_nonexistent_fields
+    errors = [{
+      message: 'Unable to find a field named "favoriteSpaceship" on GraphQL::CharacterInterface.',
+      locations: [{ line: 1, column: 35 }, { line: 1, column: 52 }],
+      path: %w[HeroSpaceshipQuery hero favoriteSpaceship],
+      extensions: { stage: 'organize', exception: 'Rails::GraphQL::MissingFieldError' },
+    }]
+
+    assert_result(errors, <<~GQL, dig: 'errors')
+      query HeroSpaceshipQuery { hero { favoriteSpaceship } }
+    GQL
+  end
+
+  def test_requires_fields
+    errors = [{
+      message: 'The "hero" was assigned to the Character which is not a leaf type and requires a selection of fields.',
+      locations: [{ line: 1, column: 28 }, { line: 1, column: 32 }],
+      path: %w[HeroSpaceshipQuery hero],
+      extensions: { stage: 'organize', exception: 'Rails::GraphQL::FieldError' },
+    }]
+
+    assert_result(errors, <<~GQL, dig: 'errors')
+      query HeroSpaceshipQuery { hero }
+    GQL
+  end
+
+  def test_disallows_fields_on_scalars
+    errors = [{
+      message: 'The "name" was assigned to the String which is a leaf type and does not have nested fields.',
+      locations: [{ line: 1, column: 35 }, { line: 1, column: 64 }],
+      path: %w[HeroSpaceshipQuery hero name],
+      extensions: { stage: 'organize', exception: 'Rails::GraphQL::FieldError' },
+    }]
+
+    assert_result(errors, <<~GQL, dig: 'errors')
+      query HeroSpaceshipQuery { hero { name { firstCharacterOfName } } }
+    GQL
+  end
+
+  def test_specific_fields_on_interfaces
+    errors = [{
+      message: 'Unable to find a field named "primaryFunction" on GraphQL::CharacterInterface.',
+      locations: [{ line: 1, column: 40 }, { line: 1, column: 55 }],
+      path: %w[HeroSpaceshipQuery hero primaryFunction],
+      extensions: { stage: 'organize', exception: 'Rails::GraphQL::MissingFieldError' },
+    }]
+
+    assert_result(errors, <<~GQL, dig: 'errors')
+      query HeroSpaceshipQuery { hero { name primaryFunction } }
+    GQL
+  end
+
+  def test_allow_specific_fields_with_fragments
+    assert_result(nil, <<~GQL, dig: 'errors')
+      query DroidFieldInFragment { hero { name ...DroidFields } }
+      fragment DroidFields on Droid { primaryFunction }
+    GQL
+  end
+
+  def test_allow_specific_fields_with_spread
+    assert_result(nil, <<~GQL, dig: 'errors')
+      query DroidFieldInFragment { hero { name ... on Droid { primaryFunction } } }
+    GQL
+  end
+end