rails-graphql 0.1.0

data/test/integration/schemas/memory.rb

@@ -0,0 +1,232 @@
+EPISODES = %w[new_hope empire jedi]
+
+module MemoryTest
+  class Character
+    attr_accessor :id, :name
+    attr_writer :friends, :appears_in
+
+    def initialize(**data)
+      data.each { |k, v| send("#{k}=", v) }
+    end
+
+    def friends
+      @friends.map do |id|
+        STAR_WARS_DATA[:humans][id] || STAR_WARS_DATA[:droids][id]
+      end
+    end
+
+    def appears_in
+      @appears_in.map { |i| EPISODES[i].upcase }
+    end
+
+    def secret_backstory
+      raise 'Secret backstory is secret'
+    end
+  end
+
+  class Human < Character
+    attr_accessor :home_planet
+  end
+
+  class Droid < Character
+    attr_accessor :primary_function
+  end
+
+  STAR_WARS_DATA = {
+    humans: {
+      '1000' => Human.new(
+        id: '1000',
+        name: 'Luke Skywalker',
+        friends: ['1002', '1003', '2000', '2001'],
+        appears_in: [0, 1, 2],
+        home_planet: 'Tatooine'
+      ),
+      '1001' => Human.new(
+        id: '1001',
+        name: 'Darth Vader',
+        friends: ['1004'],
+        appears_in: [0, 1, 2],
+        home_planet: 'Tatooine'
+      ),
+      '1002' => Human.new(
+        id: '1002',
+        name: 'Han Solo',
+        friends: ['1000', '1003', '2001'],
+        appears_in: [0, 1, 2]
+      ),
+      '1003' => Human.new(
+        id: '1003',
+        name: 'Leia Organa',
+        friends: ['1000', '1002', '2000', '2001'],
+        appears_in: [0, 1, 2],
+        home_planet: 'Alderaan'
+      ),
+      '1004' => Human.new(
+        id: '1004',
+        name: 'Wilhuff Tarkin',
+        friends: ['1001'],
+        appears_in: [0]
+      ),
+    },
+    droids: {
+      '2000' => Droid.new(
+        id: '2000',
+        name: 'C-3PO',
+        friends: ['1000', '1002', '1003', '2001'],
+        appears_in: [0, 1, 2],
+        primary_function: 'Protocol'
+      ),
+      '2001' => Droid.new(
+        id: '2001',
+        name: 'R2-D2',
+        friends: ['1000', '1002', '1003'],
+        appears_in: [0, 1, 2],
+        primary_function: 'Astromech'
+      ),
+    },
+  }
+end
+
+class StartWarsMemSchema < GraphQL::Schema
+  namespace :start_wars_mem
+
+  configure do |config|
+    config.enable_string_collector = false
+  end
+
+  rescue_from('StandardError') do |exception|
+    !!field ? request.exception_to_error(exception, field) : raise
+  end
+
+  enum 'Episode' do
+    desc 'One of the films in the Star Wars Trilogy'
+
+    add 'NEW_HOPE', desc: 'Released in 1977.'
+    add 'EMPIRE',   desc: 'Released in 1980.'
+    add 'JEDI',     desc: 'Released in 1983.'
+  end
+
+  interface 'Character' do
+    desc 'A character in the Star Wars Trilogy'
+
+    field :id, :id, null: false,
+      desc: 'The id of the character'
+
+    field :name, :string,
+      desc: 'The name of the character'
+
+    field :friends, 'Character', array: true,
+      desc: 'The friends of the character, or an empty list if they have none'
+
+    field :appears_in, 'Episode', array: true,
+      desc: 'Which movies they appear in'
+
+    field :secret_backstory, :string,
+      desc: 'All secrets about their past'
+  end
+
+  object 'Human' do
+    self.assigned_to = MemoryTest::Human
+
+    implements 'Character'
+
+    desc 'A humanoid creature in the Star Wars universe'
+
+    change_field :id,
+      desc: 'The id of the human'
+
+    change_field :name,
+      desc: 'The name of the human'
+
+    change_field :friends,
+      desc: 'The friends of the human, or an empty list if they have none'
+
+    change_field :appears_in,
+      desc: 'Which movies they appear in'
+
+    change_field :secret_backstory,
+      desc: 'Where are they from and how they came to be who they are'
+
+    field :home_planet, :string,
+      desc: 'The home planet of the human, or null if unknown'
+  end
+
+  object 'Droid' do
+    self.assigned_to = MemoryTest::Droid
+
+    implements 'Character'
+
+    desc 'A mechanical creature in the Star Wars universe'
+
+    change_field :id,
+      desc: 'The id of the droid'
+
+    change_field :name,
+      desc: 'The name of the droid'
+
+    change_field :friends,
+      desc: 'The friends of the droid, or an empty list if they have none'
+
+    change_field :appears_in,
+      desc: 'Which movies they appear in'
+
+    change_field :secret_backstory,
+      desc: 'Construction date and the name of the designer'
+
+    field :primary_function, :string,
+      desc: 'The primary function of the droid'
+  end
+
+  query_fields do
+    field :hero, 'Character', method_name: :find_hero,
+      arguments: arg(:episode, 'Episode', desc: 'Return for a specific episode'),
+      desc: 'Find the hero of the whole saga'
+
+    field :human, 'Human', method_name: :find_human,
+      arguments: arg(:id, :id, null: false, desc: 'ID of the human'),
+      desc: 'Find a human character'
+
+    field :droid, 'Droid', method_name: :find_droid,
+      arguments: arg(:id, :id, null: false, desc: 'ID of the droid'),
+      desc: 'Find a droid character'
+  end
+
+  mutation_fields do
+    field :change_human, 'Character', full: true do
+      desc 'Change the episodes of a human and return a set of characters'
+
+      id_argument desc: 'The ID of the human to be changed'
+      argument :episodes, 'Episode', array: true, nullable: false
+
+      perform :change_episodes, :humans, episodes: %w[NEW_HOPE EMPIRE]
+      resolve :character_set
+    end
+  end
+
+  def find_hero(episode:)
+    episode.to_i === 1 \
+      ? MemoryTest::STAR_WARS_DATA[:humans]['1000'] \
+      : MemoryTest::STAR_WARS_DATA[:droids]['2001']
+  end
+
+  def find_human(id:)
+    MemoryTest::STAR_WARS_DATA[:humans][id]
+  end
+
+  def find_droid(id:)
+    MemoryTest::STAR_WARS_DATA[:droids][id]
+  end
+
+  def change_episodes(source, id:, episodes:)
+    MemoryTest::STAR_WARS_DATA[source][id].appears_in = episodes.map do |item|
+      EPISODES.index(item.downcase)
+    end
+  end
+
+  def character_set(id:)
+    [
+      MemoryTest::STAR_WARS_DATA[:humans][id],
+      MemoryTest::STAR_WARS_DATA[:droids]['2001'],
+    ]
+  end
+end

data/test/integration/schemas/sqlite.rb

@@ -0,0 +1,82 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.irregular 'base', 'bases'
+end
+
+ActiveRecord::Schema.define(version: 1) do
+  self.verbose = false
+
+  create_table 'lite_factions', force: :cascade do |t|
+    t.string 'name'
+  end
+
+  create_table 'lite_bases', force: :cascade do |t|
+    t.integer 'faction_id'
+    t.string 'name'
+    t.string 'planet'
+  end
+
+  create_table 'lite_ships', force: :cascade do |t|
+    t.integer 'faction_id'
+    t.string 'name'
+  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
+
+  accepts_nested_attributes_for :bases
+  accepts_nested_attributes_for :ships
+
+  REBELS = create!(name: 'Alliance to Restore the Republic')
+  EMPIRE = create!(name: 'Galactic Empire')
+end
+
+class LiteBase < SQLiteRecord
+  belongs_to :faction, class_name: 'LiteFaction', foreign_key: :faction_id
+
+  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)
+  create!(name: 'Death Star',       planet: nil,         faction: LiteFaction::EMPIRE)
+  create!(name: 'Shield Generator', planet: 'Endor',     faction: LiteFaction::EMPIRE)
+  create!(name: 'Headquarters',     planet: 'Coruscant', faction: LiteFaction::EMPIRE)
+end
+
+class LiteShip < SQLiteRecord
+  belongs_to :faction, class_name: 'LiteFaction', foreign_key: :faction_id
+
+  create!(name: 'X-Wing',           faction: LiteFaction::REBELS)
+  create!(name: 'Y-Wing',           faction: LiteFaction::REBELS)
+  create!(name: 'A-Wing',           faction: LiteFaction::REBELS)
+  create!(name: 'Millenium Falcon', faction: LiteFaction::REBELS)
+  create!(name: 'Home One',         faction: LiteFaction::REBELS)
+  create!(name: 'TIE Fighter',      faction: LiteFaction::EMPIRE)
+  create!(name: 'TIE Interceptor',  faction: LiteFaction::EMPIRE)
+  create!(name: 'Executor',         faction: LiteFaction::EMPIRE)
+end
+
+class StartWarsSqliteSchema < GraphQL::Schema
+  namespace :start_wars_sqlite
+
+  configure do |config|
+    config.enable_string_collector = false
+  end
+
+  sources LiteFaction do
+    with_options on: 'liteFactions' do
+      scoped_argument(:order) { |o| order(name: o) }
+    end
+  end
+
+  sources LiteBase
+  sources LiteShip
+end

data/test/integration/sqlite/star_wars_introspection_test.rb

@@ -0,0 +1,15 @@
+require 'integration/config'
+
+class Integration_SQLite_StarWarsIntrospectionTest < GraphQL::IntegrationTestCase
+  load_schema 'sqlite'
+
+  SCHEMA = ::StartWarsSqliteSchema
+
+  # 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/sqlite.gql', SCHEMA.to_gql)
+    result = gql_file('sqlite').split('').sort.join.squish
+    assert_equal(result, SCHEMA.to_gql.split('').sort.join.squish)
+  end
+end

data/test/integration/sqlite/star_wars_mutation_test.rb

@@ -0,0 +1,82 @@
+require 'integration/config'
+
+class Integration_SQLite_StarWarsMutationTest < GraphQL::IntegrationTestCase
+  load_schema 'sqlite'
+
+  SCHEMA = ::StartWarsSqliteSchema
+
+  def test_can_create_faction
+    args = { data: { name: 'Aliens' } }
+    record = { id: next_id, name: 'Aliens' }
+    assert_result({ data: { record: record } }, <<~GQL, args: args)
+      mutation($data: LiteFactionInput!) {
+        record: createLiteFaction(liteFaction: $data) { id name }
+      }
+    GQL
+
+    assert_equal(3, LiteFaction.count)
+    assert_equal('Aliens', LiteFaction.last.name)
+    LiteFaction.last.destroy!
+  end
+
+  def test_can_update_faction
+    args = { id: '1', data: { name: 'ARR' } }
+    record = { id: '1', name: 'ARR' }
+    assert_result({ data: { record: record } }, <<~GQL, args: args)
+      mutation($id: ID!, $data: LiteFactionInput!) {
+        record: updateLiteFaction(id: $id, liteFaction: $data) { id name }
+      }
+    GQL
+
+    assert_equal('ARR', LiteFaction.find(1).name)
+    LiteFaction.find(1).update(name: 'Alliance to Restore the Republic')
+  end
+
+  def test_can_create_and_delete_faction
+    args = { data: { name: 'Should not Exist' } }
+    record = { id: next_id, name: 'Should not Exist' }
+    assert_result({ data: { record: record } }, <<~GQL, args: args)
+      mutation($data: LiteFactionInput!) {
+        record: createLiteFaction(liteFaction: $data) { id name }
+      }
+    GQL
+
+    assert_equal(3, LiteFaction.count)
+    assert_equal('Should not Exist', LiteFaction.last.name)
+
+    assert_result({ data: { record: true } }, <<~GQL, args: { id: record[:id] })
+      mutation($id: ID!) { record: deleteLiteFaction(id: $id) }
+    GQL
+
+    assert_equal(2, LiteFaction.count)
+    refute_equal('Should not Exist', LiteFaction.last.name)
+  end
+
+  def test_can_create_faction_with_ships
+    ships = [{ name: 'Alpha' }, { name: 'Delta' }]
+    args = { data: { name: 'Emperor', ships_attributes: ships } }
+    record = { id: next_id, name: 'Emperor', ships: ships }
+    assert_result({ data: { record: record } }, <<~GQL, args: args)
+      mutation($data: LiteFactionInput!) {
+        record: createLiteFaction(liteFaction: $data) { id name ships { name } }
+      }
+    GQL
+
+    assert_equal(3, LiteFaction.count)
+    assert_equal('Emperor', LiteFaction.last.name)
+
+    assert_equal(10, LiteShip.count)
+    assert_equal(['Alpha', 'Delta'], LiteShip.last(2).map(&:name))
+
+    LiteShip.last(2).map(&:destroy!)
+    LiteFaction.last.destroy!
+  end
+
+  protected
+
+    def next_id
+      @@next_id ||= 2
+      @@next_id += 1
+      @@next_id.to_s
+    end
+end

data/test/integration/sqlite/star_wars_query_test.rb

@@ -0,0 +1,71 @@
+require 'integration/config'
+
+class Integration_SQLite_StarWarsQueryTest < GraphQL::IntegrationTestCase
+  load_schema 'sqlite'
+
+  SCHEMA = ::StartWarsSqliteSchema
+
+  def test_query_factions
+    faction = named_list('Alliance to Restore the Republic', 'Galactic Empire')
+    assert_result({ data: { liteFactions: faction } }, <<~GQL)
+      query AllFactions { liteFactions { name } }
+    GQL
+  end
+
+  def test_query_single_faction
+    assert_result({ data: { liteFaction: { name: 'Galactic Empire' } } }, <<~GQL)
+      query FindEmpireFaction { liteFaction(id: "2") { name } }
+    GQL
+  end
+
+  def test_base_with_faction
+    faction = { name: 'Alliance to Restore the Republic' }
+    base = { name: 'Yavin', planet: 'Yavin 4', faction: faction }
+    assert_result({ data: { liteBase: base } }, <<~GQL)
+      query YavinBaseAndFaction { liteBase(id: "1") { name planet faction { name } } }
+    GQL
+  end
+
+  def test_faction_with_bases_and_ships
+    ships = named_list('TIE Fighter', 'TIE Interceptor', 'Executor')
+    bases = named_list('Death Star', 'Shield Generator', 'Headquarters')
+    faction = { name: 'Galactic Empire', bases: bases, ships: ships }
+    assert_result({ data: { liteFaction: faction } }, <<~GQL)
+      query EmpireFleet { liteFaction(id: "2") { name bases { name } ships { name } } }
+    GQL
+  end
+
+  def test_full_data
+    ships1 = named_list('X-Wing', 'Y-Wing', 'A-Wing', 'Millenium Falcon', 'Home One')
+    bases1 = named_list('Yavin', 'Echo Base', 'Secret Hideout')
+
+    ships2 = named_list('TIE Fighter', 'TIE Interceptor', 'Executor')
+    bases2 = named_list('Death Star', 'Shield Generator', 'Headquarters')
+
+    factions = [
+      { name: 'Alliance to Restore the Republic', bases: bases1, ships: ships1 },
+      { name: 'Galactic Empire', bases: bases2, ships: ships2 },
+    ]
+
+    assert_result({ data: { liteFactions: factions } }, <<~GQL)
+      query FullData { liteFactions { name bases { name } ships { name } } }
+    GQL
+  end
+
+  def test_data_recusivity
+    faction = { name: 'Galactic Empire' }
+    bases = named_list('Death Star', 'Shield Generator', 'Headquarters', faction: faction.dup)
+    faction[:bases] = bases
+
+    assert_result({ data: { liteFaction: faction } }, <<~GQL)
+      query EmpireFleet { liteFaction(id: "2") { name bases { name faction { name } } } }
+    GQL
+  end
+
+  def test_factions_scoped_argument
+    faction = named_list('Galactic Empire', 'Alliance to Restore the Republic')
+    assert_result({ data: { liteFactions: faction } }, <<~GQL, args: { order: 'desc' })
+      query AllFactions($order: String!) { liteFactions(order: $order) { name } }
+    GQL
+  end
+end