graphql 1.8.0 → 1.12.12

data/spec/generators/graphql/install_generator_spec.rb

@@ -1,205 +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"
-    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
-DummySchema = GraphQL::Schema.define do
-  mutation(Types::MutationType)
-  query(Types::QueryType)
-end
-RUBY
-    assert_file "app/graphql/dummy_schema.rb", expected_schema
-
-
-    expected_query_type = <<-RUBY
-Types::QueryType = GraphQL::ObjectType.define do
-  name "Query"
-  # Add root-level fields here.
-  # They will be entry points for queries on your schema.
-
-  # TODO: remove me
-  field :testField, types.String do
-    description \"An example field added by the generator\"
-    resolve ->(obj, args, ctx) {
-      \"Hello World!\"
-    }
-  end
-end
-RUBY
-
-    assert_file "app/graphql/types/query_type.rb", expected_query_type
-    assert_file "app/controllers/graphql_controller.rb", EXPECTED_GRAPHQLS_CONTROLLER
-  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
-Types::QueryType = GraphQL::ObjectType.define do
-  name "Query"
-  # Add root-level fields here.
-  # They will be entry points for queries on your schema.
-
-  # TODO: remove me
-  field :testField, types.String do
-    description \"An example field added by the generator\"
-    resolve ->(obj, args, ctx) {
-      \"Hello World!\"
-    }
-  end
-
-  field :node, GraphQL::Relay::Node.field
-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", /CustomSchema = GraphQL::Schema\.define/
-    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
-  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
-end
-RUBY
-
-  EXPECTED_RELAY_BATCH_SCHEMA = <<-RUBY
-DummySchema = GraphQL::Schema.define do
-
-  mutation(Types::MutationType)
-  query(Types::QueryType)
-  # Relay Object Identification:
-
-  # Return a string UUID for `object`
-  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)
-  }
-
-  # Given a string UUID, find the object
-  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
-    # ...
-  }
-
-  # Object Resolution
-  resolve_type -> (type, obj, ctx) {
-    # TODO: Implement this function
-    # to return the correct type for `obj`
-    raise(NotImplementedError)
-  }
-
-  # GraphQL::Batch setup:
-  use GraphQL::Batch
-end
-RUBY
-end

data/spec/generators/graphql/interface_generator_spec.rb

@@ -1,32 +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:!types.Int", "foliage:types[Types::ColorType]"],
-      # Mixed
-      ["BirdType", "wingspan:!Int", "foliage:types[Color]"],
-    ]
-
-    expected_content = <<-RUBY
-Types::BirdType = GraphQL::InterfaceType.define do
-  name "Bird"
-  field :wingspan, !types.Int
-  field :foliage, types[Types::ColorType]
-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/generators/graphql/loader_generator_spec.rb

@@ -1,55 +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
-class Loaders::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
-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
-class Loaders::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
-RUBY
-
-    assert_file "app/graphql/loaders/active_record/record_loader.rb", expected_content
-  end
-end

data/spec/generators/graphql/mutation_generator_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "generators/graphql/mutation_generator"
-
-class GraphQLGeneratorsMutationGeneratorTest < BaseGeneratorTest
-  tests Graphql::Generators::MutationGenerator
-
-  destination File.expand_path("../../../tmp/dummy", File.dirname(__FILE__))
-
-  def setup(directory = "app/graphql")
-    prepare_destination
-    FileUtils.cd(File.expand_path("../../../tmp", File.dirname(__FILE__))) do
-      `rm -rf dummy`
-      `rails new dummy --skip-active-record --skip-test-unit --skip-spring --skip-bundle`
-    end
-
-    FileUtils.cd(destination_root) do
-      `rails g graphql:install --directory #{directory}`
-    end
-  end
-
-  test "it generates an empty resolver by name" do
-    setup
-    run_generator(["UpdateName"])
-
-    expected_content = <<-RUBY
-Mutations::UpdateName = GraphQL::Relay::Mutation.define do
-  name "UpdateName"
-  # TODO: define return fields
-  # return_field :post, Types::PostType
-
-  # TODO: define arguments
-  # input_field :name, !types.String
-
-  resolve ->(obj, args, ctx) {
-    # TODO: define resolve function
-  }
-end
-RUBY
-
-    assert_file "app/graphql/mutations/update_name.rb", expected_content
-  end
-
-  test "it allows for user-specified directory" do
-    setup "app/mydirectory"
-    run_generator(["UpdateName", "--directory", "app/mydirectory"])
-
-    expected_content = <<-RUBY
-Mutations::UpdateName = GraphQL::Relay::Mutation.define do
-  name "UpdateName"
-  # TODO: define return fields
-  # return_field :post, Types::PostType
-
-  # TODO: define arguments
-  # input_field :name, !types.String
-
-  resolve ->(obj, args, ctx) {
-    # TODO: define resolve function
-  }
-end
-RUBY
-
-    assert_file "app/mydirectory/mutations/update_name.rb", expected_content
-  end
-end

data/spec/generators/graphql/object_generator_spec.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "generators/graphql/object_generator"
-
-class GraphQLGeneratorsObjectGeneratorTest < BaseGeneratorTest
-  tests Graphql::Generators::ObjectGenerator
-
-  test "it generates fields with types" do
-    commands = [
-      # GraphQL-style:
-      ["Bird", "wingspan:Int!", "foliage:[Color]"],
-      # Ruby-style:
-      ["BirdType", "wingspan:!types.Int", "foliage:types[Types::ColorType]"],
-      # Mixed
-      ["BirdType", "wingspan:!Int", "foliage:types[Color]"],
-    ]
-
-    expected_content = <<-RUBY
-Types::BirdType = GraphQL::ObjectType.define do
-  name "Bird"
-  field :wingspan, !types.Int
-  field :foliage, types[Types::ColorType]
-end
-RUBY
-
-    commands.each do |c|
-      prepare_destination
-      run_generator(c)
-      assert_file "app/graphql/types/bird_type.rb", expected_content
-    end
-  end
-
-  test "it generates classifed file" do
-    run_generator(["page"])
-    assert_file "app/graphql/types/page_type.rb", <<-RUBY
-Types::PageType = GraphQL::ObjectType.define do
-  name "Page"
-end
-RUBY
-  end
-
-  test "it makes Relay nodes" do
-    run_generator(["Page", "--node"])
-    assert_file "app/graphql/types/page_type.rb", <<-RUBY
-Types::PageType = GraphQL::ObjectType.define do
-  name "Page"
-  implements GraphQL::Relay::Node.interface
-end
-RUBY
-  end
-end

data/spec/generators/graphql/union_generator_spec.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "generators/graphql/union_generator"
-
-class GraphQLGeneratorsUnionGeneratorTest < BaseGeneratorTest
-  tests Graphql::Generators::UnionGenerator
-
-  test "it generates a union with possible types" do
-    commands = [
-      # GraphQL-style:
-      ["WingedCreature", "Insect", "Bird"],
-      # Ruby-style:
-      ["Types::WingedCreatureType", "Types::InsectType", "Types::BirdType"],
-    ]
-
-    expected_content = <<-RUBY
-Types::WingedCreatureType = GraphQL::UnionType.define do
-  name "WingedCreature"
-  possible_types [Types::InsectType, Types::BirdType]
-end
-RUBY
-
-    commands.each do |c|
-      prepare_destination
-      run_generator(c)
-      assert_file "app/graphql/types/winged_creature_type.rb", expected_content
-    end
-  end
-
-  test "it works with no possible types" do
-    commands = [
-      # GraphQL-style:
-      ["WingedCreature"],
-      # Ruby-style:
-      ["Types::WingedCreatureType"],
-    ]
-
-    expected_content = <<-RUBY
-Types::WingedCreatureType = GraphQL::UnionType.define do
-  name "WingedCreature"
-end
-RUBY
-
-    commands.each do |c|
-      prepare_destination
-      run_generator(c)
-      assert_file "app/graphql/types/winged_creature_type.rb", expected_content
-    end
-  end
-
-  test "it accepts a user-specified directory" do
-    command = ["WingedCreature", "--directory", "app/mydirectory"]
-
-    expected_content = <<-RUBY
-Types::WingedCreatureType = GraphQL::UnionType.define do
-  name "WingedCreature"
-end
-RUBY
-
-    prepare_destination
-    run_generator(command)
-    assert_file "app/mydirectory/types/winged_creature_type.rb", expected_content
-  end
-end

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -1,234 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Analysis do
-  class TypeCollector
-    def initial_value(query)
-      []
-    end
-
-    def call(memo, visit_type, irep_node)
-      if visit_type == :enter
-        memo + [irep_node.return_type.unwrap]
-      else
-        memo
-      end
-    end
-  end
-
-  describe ".analyze_query" do
-    let(:node_counter) {
-      ->(memo, visit_type, irep_node) {
-        memo ||= Hash.new { |h,k| h[k] = 0 }
-        visit_type == :enter && memo[irep_node.ast_node.class] += 1
-        memo
-      }
-    }
-    let(:type_collector) { TypeCollector.new }
-    let(:analyzers) { [type_collector, node_counter] }
-    let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
-    let(:variables) { {} }
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
-    let(:query_string) {%|
-      {
-        cheese(id: 1) {
-          id
-          flavor
-        }
-      }
-    |}
-
-    it "calls the defined analyzers" do
-      collected_types, node_counts = reduce_result
-      expected_visited_types = [Dummy::DairyAppQueryType, Dummy::CheeseType, GraphQL::INT_TYPE, GraphQL::STRING_TYPE]
-      assert_equal expected_visited_types, collected_types
-      expected_node_counts = {
-        GraphQL::Language::Nodes::OperationDefinition => 1,
-        GraphQL::Language::Nodes::Field => 3,
-      }
-      assert_equal expected_node_counts, node_counts
-    end
-
-    describe "tracing" do
-      let(:query_string) { "{ t: __typename }"}
-
-      it "emits traces" do
-        traces = TestTracing.with_trace do
-          ctx = { tracers: [TestTracing] }
-          Dummy::Schema.execute(query_string, context: ctx)
-        end
-
-        # The query_trace is on the list _first_ because it finished first
-        _lex, _parse, _validate, query_trace, multiplex_trace, *_rest = traces
-
-        assert_equal "analyze_multiplex", multiplex_trace[:key]
-        assert_instance_of GraphQL::Execution::Multiplex, multiplex_trace[:multiplex]
-
-        assert_equal "analyze_query", query_trace[:key]
-        assert_instance_of GraphQL::Query, query_trace[:query]
-      end
-    end
-
-    describe "when a variable is missing" do
-      let(:query_string) {%|
-        query something($cheeseId: Int!){
-          cheese(id: $cheeseId) {
-            id
-            flavor
-          }
-        }
-      |}
-      let(:variable_accessor) { ->(memo, visit_type, irep_node) { query.variables["cheeseId"] } }
-
-      before do
-        @previous_query_analyzers = Dummy::Schema.query_analyzers.dup
-        Dummy::Schema.query_analyzers.clear
-        Dummy::Schema.query_analyzers << variable_accessor
-      end
-
-      after do
-        Dummy::Schema.query_analyzers.clear
-        Dummy::Schema.query_analyzers.push(*@previous_query_analyzers)
-      end
-
-      it "returns an error" do
-        error = query.result["errors"].first
-        assert_equal "Variable cheeseId of type Int! was provided invalid value", error["message"]
-      end
-    end
-
-    describe "when processing fields" do
-      let(:connection_counter) {
-        ->(memo, visit_type, irep_node) {
-          memo ||= Hash.new { |h,k| h[k] = 0 }
-          if visit_type == :enter
-            if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
-              if irep_node.definition.connection?
-                memo[:connection] ||= 0
-                memo[:connection] += 1
-              else
-                memo[:field] ||= 0
-                memo[:field] += 1
-              end
-            end
-          end
-          memo
-        }
-      }
-      let(:analyzers) { [connection_counter] }
-      let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
-      let(:query) { GraphQL::Query.new(StarWars::Schema, query_string, variables: variables) }
-      let(:query_string) {%|
-        query getBases {
-          empire {
-            basesByName(first: 30) { edges { cursor } }
-            bases(first: 30) { edges { cursor } }
-          }
-        }
-      |}
-
-      it "knows which fields are connections" do
-        connection_counts = reduce_result.first
-        expected_connection_counts = {
-          :field => 5,
-          :connection => 2
-        }
-        assert_equal expected_connection_counts, connection_counts
-      end
-    end
-  end
-
-  describe ".visit_analyzers" do
-    class IdCatcher
-      def call(memo, visit_type, irep_node)
-        if visit_type == :enter
-          if irep_node.ast_node.name == "id"
-            raise GraphQL::AnalysisError.new("Don't use the id field.", ast_node: irep_node.ast_node)
-          end
-        end
-        memo
-      end
-    end
-
-    class FlavorCatcher
-      def initial_value(query)
-        {
-          :errors => []
-        }
-      end
-
-      def call(memo, visit_type, irep_node)
-        if visit_type == :enter
-          if irep_node.ast_node.name == "flavor"
-            memo[:errors] << GraphQL::AnalysisError.new("Don't use the flavor field.", ast_node: irep_node.ast_node)
-          end
-        end
-        memo
-      end
-
-      def final_value(memo)
-        memo[:errors]
-      end
-    end
-
-    let(:id_catcher) { IdCatcher.new }
-    let(:flavor_catcher) { FlavorCatcher.new }
-    let(:analyzers) { [id_catcher, flavor_catcher] }
-    let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-    let(:query_string) {%|
-      {
-        cheese(id: 1) {
-          id
-          flavor
-        }
-      }
-    |}
-    let(:schema) { Dummy::Schema }
-    let(:result) { schema.execute(query_string) }
-    let(:query_string) {%|
-      {
-        cheese(id: 1) {
-          id
-          flavor
-        }
-      }
-    |}
-
-    before do
-      @previous_query_analyzers = Dummy::Schema.query_analyzers.dup
-      Dummy::Schema.query_analyzers.clear
-      Dummy::Schema.query_analyzers << id_catcher << flavor_catcher
-    end
-
-    after do
-      Dummy::Schema.query_analyzers.clear
-      Dummy::Schema.query_analyzers.push(*@previous_query_analyzers)
-    end
-
-    it "groups all errors together" do
-      data = result["data"]
-      errors = result["errors"]
-
-      id_error_hash = errors[0]
-      flavor_error_hash = errors[1]
-
-      id_error_response = {
-        "message"=>"Don't use the id field.",
-        "locations"=>[{"line"=>4, "column"=>11}]
-      }
-      flavor_error_response = {
-        "message"=>"Don't use the flavor field.",
-        "locations"=>[{"line"=>5, "column"=>11}]
-      }
-
-      assert_nil data
-
-      assert_equal id_error_response["message"], id_error_hash["message"]
-      assert_equal id_error_response["locations"], id_error_hash["locations"]
-
-      assert_equal flavor_error_response["message"], flavor_error_hash["message"]
-      assert_equal flavor_error_response["locations"], flavor_error_hash["locations"]
-    end
-  end
-end