graphql 1.9.11 → 1.9.12

data/spec/integration/rails/data.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-require_relative 'spec_helper'
-require 'ostruct'
-
-# platform helper
-def jruby?
-  RUBY_ENGINE == 'jruby'
-end
-
-module StarWars
-  names = [
-    'X-Wing',
-    'Y-Wing',
-    'A-Wing',
-    'Millenium Falcon',
-    'Home One',
-    'TIE Fighter',
-    'TIE Interceptor',
-    'Executor',
-  ]
-
-  `rm -f ./_test_.db`
-  # Set up "Bases" in ActiveRecord
-
-  if jruby?
-    ActiveRecord::Base.establish_connection(adapter: "jdbcsqlite3", database: "./_test_.db")
-    DB = Sequel.connect('jdbc:sqlite:./_test_.db')
-  elsif ENV['DATABASE'] == 'POSTGRESQL'
-    ActiveRecord::Base.establish_connection(
-      adapter: "postgresql",
-      username: "postgres",
-      database: "graphql_ruby_test"
-    )
-    DB = Sequel.connect('postgres://postgres:@localhost:5432/graphql_ruby_test')
-  else
-    ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: "./_test_.db")
-    DB = Sequel.sqlite("./_test_.db")
-  end
-
-  ActiveRecord::Schema.define do
-    self.verbose = false
-    create_table :bases, force: true do |t|
-      t.column :name, :string
-      t.column :planet, :string
-      t.column :faction_id, :integer
-    end
-  end
-
-  class Base < ActiveRecord::Base
-  end
-
-  Base.create!(name: "Yavin", planet: "Yavin 4", faction_id: 1)
-  Base.create!(name: "Echo Base", planet: "Hoth", faction_id: 1)
-  Base.create!(name: "Secret Hideout", planet: "Dantooine", faction_id: 1)
-  Base.create!(name: "Death Star", planet: nil, faction_id: 2)
-  Base.create!(name: "Shield Generator", planet: "Endor", faction_id: 2)
-  Base.create!(name: "Headquarters", planet: "Coruscant", faction_id: 2)
-
-  class SequelBase < Sequel::Model(:bases)
-  end
-
-  class FactionRecord
-    attr_reader :id, :name, :ships, :bases, :bases_clone
-    def initialize(id:, name:, ships:, bases:, bases_clone:)
-      @id = id
-      @name = name
-      @ships = ships
-      @bases = bases
-      @bases_clone = bases_clone
-    end
-  end
-
-  rebels  = FactionRecord.new({
-    id: '1',
-    name: 'Alliance to Restore the Republic',
-    ships:  ['1', '2', '3', '4', '5'],
-    bases: Base.where(faction_id: 1),
-    bases_clone: Base.where(faction_id: 1),
-  })
-
-
-  empire = FactionRecord.new({
-    id: '2',
-    name: 'Galactic Empire',
-    ships: ['6', '7', '8'],
-    bases: Base.where(faction_id: 2),
-    bases_clone: Base.where(faction_id: 2),
-  })
-
-  DATA = {
-    "Faction" => {
-      "1" => rebels,
-      "2" => empire,
-    },
-    "Ship" => names.each_with_index.reduce({}) do |memo, (name, idx)|
-      id = (idx + 1).to_s
-      memo[id] = OpenStruct.new(name: name, id: id)
-      memo
-    end,
-    "Base" => Hash.new { |h, k| h[k] = Base.find(k) }
-  }
-
-  def DATA.create_ship(name, faction_id)
-    new_id = (self["Ship"].keys.map(&:to_i).max + 1).to_s
-    new_ship = OpenStruct.new(id: new_id, name: name)
-    self["Ship"][new_id] = new_ship
-    self["Faction"][faction_id].ships << new_id
-    new_ship
-  end
-end

data/spec/integration/rails/generators/base_generator_test.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-class BaseGeneratorTest < Rails::Generators::TestCase
-  destination File.expand_path("../../tmp", File.dirname(__FILE__))
-  setup :prepare_destination
-end

data/spec/integration/rails/generators/graphql/enum_generator_spec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "generators/graphql/enum_generator"
-
-class GraphQLGeneratorsEnumGeneratorTest < BaseGeneratorTest
-  tests Graphql::Generators::EnumGenerator
-
-  test "it generate enums with values" do
-    expected_content = <<-RUBY
-module Types
-  class FamilyType < Types::BaseEnum
-    value "NIGHTSHADE"
-    value "BRASSICA", value: Family::COLE
-    value "UMBELLIFER", value: :umbellifer
-    value "LEGUME", value: "bean & friends"
-    value "CURCURBITS", value: 5
-  end
-end
-RUBY
-
-    run_generator(["Family",
-      "NIGHTSHADE",
-      "BRASSICA:Family::COLE",
-      "UMBELLIFER::umbellifer",
-      'LEGUME:"bean & friends"',
-      "CURCURBITS:5"
-    ])
-    assert_file "app/graphql/types/family_type.rb", expected_content
-  end
-end

data/spec/integration/rails/generators/graphql/install_generator_spec.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "generators/graphql/install_generator"
-
-class GraphQLGeneratorsInstallGeneratorTest < Rails::Generators::TestCase
-  tests Graphql::Generators::InstallGenerator
-  destination File.expand_path("../../../tmp/dummy", File.dirname(__FILE__))
-
-  setup do
-    prepare_destination
-
-    FileUtils.cd(File.join(destination_root, '..')) do
-      `rails new dummy --skip-active-record --skip-test-unit --skip-spring --skip-bundle`
-    end
-  end
-
-  test "it generates a folder structure" do
-    run_generator
-
-    assert_file "app/graphql/types/.keep"
-    assert_file "app/graphql/mutations/.keep"
-    ["base_object", "base_input_object", "base_enum", "base_scalar", "base_union", "base_interface"].each do |base_type|
-      assert_file "app/graphql/types/#{base_type}.rb"
-    end
-    expected_query_route = %|post "/graphql", to: "graphql#execute"|
-    expected_graphiql_route = %|
-  if Rails.env.development?
-    mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "/graphql"
-  end
-|
-
-    assert_file "config/routes.rb" do |contents|
-      assert_includes contents, expected_query_route
-      assert_includes contents, expected_graphiql_route
-    end
-
-    assert_file "Gemfile" do |contents|
-      assert_match %r{gem ('|")graphiql-rails('|"), :?group(:| =>) :development}, contents
-    end
-
-    expected_schema = <<-RUBY
-class DummySchema < GraphQL::Schema
-  mutation(Types::MutationType)
-  query(Types::QueryType)
-end
-RUBY
-    assert_file "app/graphql/dummy_schema.rb", expected_schema
-
-
-    expected_query_type = <<-RUBY
-module Types
-  class QueryType < Types::BaseObject
-    # Add root-level fields here.
-    # They will be entry points for queries on your schema.
-
-    # TODO: remove me
-    field :test_field, String, null: false,
-      description: \"An example field added by the generator\"
-    def test_field
-      \"Hello World!\"
-    end
-  end
-end
-RUBY
-
-    assert_file "app/graphql/types/query_type.rb", expected_query_type
-    assert_file "app/controllers/graphql_controller.rb", EXPECTED_GRAPHQLS_CONTROLLER
-    expected_base_field = <<-RUBY
-module Types
-  class BaseField < GraphQL::Schema::Field
-    argument_class Types::BaseArgument
-
-    def resolve_field(obj, args, ctx)
-      resolve(obj, args, ctx)
-    end
-  end
-end
-RUBY
-    assert_file "app/graphql/types/base_field.rb", expected_base_field
-
-    expected_base_argument = <<-RUBY
-module Types
-  class BaseArgument < GraphQL::Schema::Argument
-  end
-end
-RUBY
-    assert_file "app/graphql/types/base_argument.rb", expected_base_argument
-  end
-
-  test "it allows for a user-specified install directory" do
-    run_generator(["--directory", "app/mydirectory"])
-
-    assert_file "app/mydirectory/types/.keep"
-    assert_file "app/mydirectory/mutations/.keep"
-  end
-
-  test "it generates graphql-batch and relay boilerplate" do
-    run_generator(["--batch", "--relay"])
-    assert_file "app/graphql/loaders/.keep"
-    assert_file "Gemfile" do |contents|
-      assert_match %r{gem ('|")graphql-batch('|")}, contents
-    end
-
-    expected_query_type = <<-RUBY
-module Types
-  class QueryType < Types::BaseObject
-    # Add root-level fields here.
-    # They will be entry points for queries on your schema.
-
-    # TODO: remove me
-    field :test_field, String, null: false,
-      description: \"An example field added by the generator\"
-    def test_field
-      \"Hello World!\"
-    end
-
-    field :node, field: GraphQL::Relay::Node.field
-  end
-end
-RUBY
-
-    assert_file "app/graphql/types/query_type.rb", expected_query_type
-    assert_file "app/graphql/dummy_schema.rb", EXPECTED_RELAY_BATCH_SCHEMA
-  end
-
-  test "it doesn't install graphiql when API Only" do
-    run_generator(['--api'])
-
-    assert_file "Gemfile" do |contents|
-      refute_includes contents, "graphiql-rails"
-    end
-
-    assert_file "config/routes.rb" do |contents|
-      refute_includes contents, "GraphiQL::Rails"
-    end
-  end
-
-  test "it can skip keeps, skip graphiql and customize schema name" do
-    run_generator(["--skip-keeps", "--skip-graphiql", "--schema=CustomSchema"])
-    assert_no_file "app/graphql/types/.keep"
-    assert_no_file "app/graphql/mutations/.keep"
-    assert_file "app/graphql/types"
-    assert_file "app/graphql/mutations"
-    assert_file "Gemfile" do |contents|
-      refute_includes contents, "graphiql-rails"
-    end
-
-    assert_file "config/routes.rb" do |contents|
-      refute_includes contents, "GraphiQL::Rails"
-    end
-
-    assert_file "app/graphql/custom_schema.rb", /class CustomSchema < GraphQL::Schema/
-    assert_file "app/controllers/graphql_controller.rb", /CustomSchema\.execute/
-  end
-
-  EXPECTED_GRAPHQLS_CONTROLLER = <<-'RUBY'
-class GraphqlController < ApplicationController
-  def execute
-    variables = ensure_hash(params[:variables])
-    query = params[:query]
-    operation_name = params[:operationName]
-    context = {
-      # Query context goes here, for example:
-      # current_user: current_user,
-    }
-    result = DummySchema.execute(query, variables: variables, context: context, operation_name: operation_name)
-    render json: result
-  rescue => e
-    raise e unless Rails.env.development?
-    handle_error_in_development e
-  end
-
-  private
-
-  # Handle form data, JSON body, or a blank value
-  def ensure_hash(ambiguous_param)
-    case ambiguous_param
-    when String
-      if ambiguous_param.present?
-        ensure_hash(JSON.parse(ambiguous_param))
-      else
-        {}
-      end
-    when Hash, ActionController::Parameters
-      ambiguous_param
-    when nil
-      {}
-    else
-      raise ArgumentError, "Unexpected parameter: #{ambiguous_param}"
-    end
-  end
-
-  def handle_error_in_development(e)
-    logger.error e.message
-    logger.error e.backtrace.join("\n")
-
-    render json: { error: { message: e.message, backtrace: e.backtrace }, data: {} }, status: 500
-  end
-end
-RUBY
-
-  EXPECTED_RELAY_BATCH_SCHEMA = <<-RUBY
-class DummySchema < GraphQL::Schema
-
-  mutation(Types::MutationType)
-  query(Types::QueryType)
-  # Relay Object Identification:
-
-  # Return a string UUID for `object`
-  def self.id_from_object(object, type_definition, query_ctx)
-    # Here's a simple implementation which:
-    # - joins the type name & object.id
-    # - encodes it with base64:
-    # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
-  end
-
-  # Given a string UUID, find the object
-  def self.object_from_id(id, query_ctx)
-    # For example, to decode the UUIDs generated above:
-    # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
-    #
-    # Then, based on `type_name` and `id`
-    # find an object in your application
-    # ...
-  end
-
-  # Object Resolution
-  def self.resolve_type(type, obj, ctx)
-    # TODO: Implement this function
-    # to return the correct type for `obj`
-    raise(NotImplementedError)
-  end
-
-  # GraphQL::Batch setup:
-  use GraphQL::Batch
-end
-RUBY
-end

data/spec/integration/rails/generators/graphql/interface_generator_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "generators/graphql/interface_generator"
-
-class GraphQLGeneratorsInterfaceGeneratorTest < BaseGeneratorTest
-  tests Graphql::Generators::InterfaceGenerator
-
-  test "it generates fields with types" do
-    commands = [
-      # GraphQL-style:
-      ["Bird", "wingspan:Int!", "foliage:[Color]"],
-      # Ruby-style:
-      ["BirdType", "wingspan:Integer!", "foliage:[Types::ColorType]"],
-      # Mixed
-      ["BirdType", "wingspan:!Int", "foliage:[Color]"],
-    ]
-
-    expected_content = <<-RUBY
-module Types
-  module BirdType
-    include Types::BaseInterface
-    field :wingspan, Integer, null: false
-    field :foliage, [Types::ColorType], null: true
-  end
-end
-RUBY
-
-    commands.each do |c|
-      prepare_destination
-      run_generator(c)
-      assert_file "app/graphql/types/bird_type.rb", expected_content
-    end
-  end
-end

data/spec/integration/rails/generators/graphql/loader_generator_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "generators/graphql/loader_generator"
-
-class GraphQLGeneratorsLoaderGeneratorTest < BaseGeneratorTest
-  tests Graphql::Generators::LoaderGenerator
-
-  test "it generates an empty loader by name" do
-    run_generator(["RecordLoader"])
-
-    expected_content = <<-RUBY
-module Loaders
-  class RecordLoader < GraphQL::Batch::Loader
-    # Define `initialize` to store grouping arguments, eg
-    #
-    #     Loaders::RecordLoader.for(group).load(value)
-    #
-    # def initialize()
-    # end
-
-    # `keys` contains each key from `.load(key)`.
-    # Find the corresponding values, then
-    # call `fulfill(key, value)` or `fulfill(key, nil)`
-    # for each key.
-    def perform(keys)
-    end
-  end
-end
-RUBY
-
-    assert_file "app/graphql/loaders/record_loader.rb", expected_content
-  end
-
-  test "it generates a namespaced loader by name" do
-    run_generator(["active_record::record_loader"])
-
-    expected_content = <<-RUBY
-module Loaders
-  class ActiveRecord::RecordLoader < GraphQL::Batch::Loader
-    # Define `initialize` to store grouping arguments, eg
-    #
-    #     Loaders::ActiveRecord::RecordLoader.for(group).load(value)
-    #
-    # def initialize()
-    # end
-
-    # `keys` contains each key from `.load(key)`.
-    # Find the corresponding values, then
-    # call `fulfill(key, value)` or `fulfill(key, nil)`
-    # for each key.
-    def perform(keys)
-    end
-  end
-end
-RUBY
-
-    assert_file "app/graphql/loaders/active_record/record_loader.rb", expected_content
-  end
-end