rails-graphql 0.2.1 → 1.0.0.rc1

data/test/assets/translate.gql

@@ -0,0 +1,346 @@
+schema {
+  query: _Query
+}
+
+"The Boolean scalar type represents true or false."
+scalar Boolean
+
+"The Float scalar type represents signed double-precision fractional values."
+scalar Float
+
+"""
+The ID scalar type represents a unique identifier and it is serialized in the same
+way as a String but it accepts both numeric and string based values as input.
+"""
+scalar ID
+
+"The Int scalar type represents a signed 32-bit numeric non-fractional value."
+scalar Int
+
+"Scalar"
+scalar ScalarDesc
+
+"""
+The String scalar type represents textual data, represented as UTF-8 character
+sequences.
+"""
+scalar String
+
+"Enum"
+enum EnumDesc {
+  
+}
+
+"The valid locations that a directive may be placed."
+enum __DirectiveLocation {
+  "Mark as a executable directive usable on query objects."
+  QUERY
+  
+  "Mark as a executable directive usable on mutation objects."
+  MUTATION
+  
+  "Mark as a executable directive usable on subscription objects."
+  SUBSCRIPTION
+  
+  "Mark as a executable directive usable on field objects."
+  FIELD
+  
+  "Mark as a executable directive usable on fragment definition objects."
+  FRAGMENT_DEFINITION
+  
+  "Mark as a executable directive usable on fragment spread objects."
+  FRAGMENT_SPREAD
+  
+  "Mark as a executable directive usable on inline fragment objects."
+  INLINE_FRAGMENT
+  
+  "Mark as a type system directive usable on schema definitions."
+  SCHEMA
+  
+  "Mark as a type system directive usable on scalar definitions."
+  SCALAR
+  
+  "Mark as a type system directive usable on object definitions."
+  OBJECT
+  
+  "Mark as a type system directive usable on field definitions."
+  FIELD_DEFINITION
+  
+  "Mark as a type system directive usable on argument definitions."
+  ARGUMENT_DEFINITION
+  
+  "Mark as a type system directive usable on interface definitions."
+  INTERFACE
+  
+  "Mark as a type system directive usable on union definitions."
+  UNION
+  
+  "Mark as a type system directive usable on enum definitions."
+  ENUM
+  
+  "Mark as a type system directive usable on enum value definitions."
+  ENUM_VALUE
+  
+  "Mark as a type system directive usable on input object definitions."
+  INPUT_OBJECT
+  
+  "Mark as a type system directive usable on input field definitions."
+  INPUT_FIELD_DEFINITION
+}
+
+"""
+The fundamental unit of any GraphQL Schema is the type.
+This enum enlist all the valid base types.
+"""
+enum __TypeKind {
+  "Scalar types represent primitive leaf values in a GraphQL type system.\n"
+  SCALAR
+  
+  "Objects represent a list of named fields, each of which yield a value of a\nspecific type.\n"
+  OBJECT
+  
+  "Interfaces represent a list of named fields and their types.\n"
+  INTERFACE
+  
+  "Unions represent an object that could be one of a list of GraphQL Object types.\n"
+  UNION
+  
+  "Enum types, like scalar types, also represent leaf values in a GraphQL\ntype system. However Enum types describe the set of possible values.\n"
+  ENUM
+  
+  "Objects represent a list of named fields, each of which yield a value of\na specific type.\n"
+  INPUT_OBJECT
+  
+  "A GraphQL list is a special collection type which declares the type of\neach item in the List (referred to as the item type of the list).\n"
+  LIST
+  
+  "This type wraps an underlying type, and this type acts identically to that wrapped\ntype, with the exception that null is not a valid response for the wrapping type.\n"
+  NON_NULL
+}
+
+"Input"
+input InputDescInput {
+  
+}
+
+"Interface"
+interface InterfaceDesc {
+  
+}
+
+"Union"
+union UnionDesc = 
+
+"Object"
+type ObjectDesc {
+  
+}
+
+type _Query {
+  __schema: __Schema!
+  
+  __type(name: String!): __Type
+  
+  "A"
+  sampleA: String
+  
+  "B"
+  sampleB: String
+  
+  "C"
+  sampleC: String
+  
+  sampleD: String
+  
+  "E"
+  sampleE: String
+  
+  sampleF: String
+  
+  sampleField: String
+}
+
+"""
+Directives provide a way to describe alternate runtime execution
+and type validation behavior in a GraphQL document.
+
+In some cases, you need to provide options to alter GraphQL's execution
+behavior in ways field arguments will not suffice, such as conditionally
+including or skipping a field. Directives provide this by describing
+additional information to the executor.
+"""
+# Assigned to Rails::GraphQL::Directive class
+type __Directive {
+  args: [__InputValue!]!
+  
+  description: String
+  
+  isRepeatable: Boolean!
+  
+  locations: [__DirectiveLocation!]!
+  
+  name: String!
+}
+
+"""
+One of the values of an Enum object. It is unique within the Enum set
+of values. It's a string representation, not a numeric representation,
+of a value kept as all caps (ie. ONE_VALUE).
+"""
+type __EnumValue {
+  deprecationReason: String
+  
+  description: String
+  
+  isDeprecated: Boolean!
+  
+  name: String!
+}
+
+"""
+Fields are the elements that compose both Objects and Interfaces. Each
+field in these other objects may contain arguments and always yields
+a value of a specific type.
+"""
+# Assigned to Rails::GraphQL::Field class
+type __Field {
+  args: [__InputValue!]!
+  
+  deprecationReason: String
+  
+  description: String
+  
+  isDeprecated: Boolean!
+  
+  name: String!
+  
+  type: __Type!
+}
+
+"""
+Arguments provided to Fields or Directives and the input fields of an
+InputObject are represented as Input Values which describe their type
+and optionally a default value.
+"""
+# Assigned to Rails::GraphQL::Field::InputField class
+type __InputValue {
+  defaultValue: String
+  
+  description: String
+  
+  name: String!
+  
+  type: __Type!
+}
+
+"""
+A GraphQL service's collective type system capabilities are referred
+to as that service's "schema". A schema is defined in terms of the
+types and directives it supports as well as the root operation types
+for each kind of operation: query, mutation, and subscription; this
+determines the place in the type system where those operations begin.
+"""
+# Assigned to Rails::GraphQL::Schema class
+type __Schema {
+  directives: [__Directive!]!
+  
+  mutationType: __Type
+  
+  queryType: __Type!
+  
+  subscriptionType: __Type
+  
+  types: [__Type!]!
+}
+
+"""
+The fundamental unit of any GraphQL Schema is the type. There are six
+kinds of named type definitions in GraphQL, and two wrapping types.
+
+The most basic type is a +Scalar+. A scalar represents a primitive value,
+like a string or an integer.
+
++Scalars+ and +Enums+ form the leaves in response trees; the intermediate
+levels are +Object+ types, which define a set of fields.
+
+An +Interface+ defines a list of fields; +Object+ types that implement
+that interface are guaranteed to implement those fields.
+
+A +Union+ defines a list of possible types; similar to interfaces,
+whenever the type system claims a union will be returned, one of the
+possible types will be returned.
+
+Finally, oftentimes it is useful to provide complex structs as inputs
+to GraphQL field arguments or variables; the +Input Object+ type allows
+the schema to define exactly what data is expected.
+"""
+# Assigned to Rails::GraphQL::Type class
+type __Type {
+  description: String
+  
+  "ENUM only"
+  enumValues(includeDeprecated: Boolean = false): [__EnumValue!]
+  
+  "OBJECT and INTERFACE only"
+  fields(includeDeprecated: Boolean = false): [__Field!]
+  
+  "INPUT_OBJECT only"
+  inputFields: [__InputValue!]
+  
+  "OBJECT only"
+  interfaces: [__Type!]
+  
+  kind: __TypeKind!
+  
+  name: String
+  
+  "NON_NULL and LIST only"
+  ofType: __Type
+  
+  "INTERFACE and UNION only"
+  possibleTypes: [__Type!]
+  
+  specifiedByURL: String
+}
+
+"""
+Indicate deprecated portions of a GraphQL service's schema, such as deprecated
+fields on a type or deprecated enum values.
+"""
+directive @deprecated(
+
+  """
+  Explain why the underlying element was marked as deprecated. If possible,
+indicate what element should be used instead. This description is formatted
+using Markdown syntax (as specified by [CommonMark](http://commonmark.org/)).
+  """
+  reason: String
+  
+) on FIELD_DEFINITION | ENUM_VALUE
+
+"Allows for conditional inclusion during execution as described by the if argument."
+directive @include(
+
+  "When false, the underlying element will be automatically marked as null."
+  if: Boolean!
+  
+) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+"Allows for conditional exclusion during execution as described by the if argument."
+directive @skip(
+
+  "When true, the underlying element will be automatically marked as null."
+  if: Boolean!
+  
+) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+"""
+A built-in directive used within the type system definition language to provide
+a scalar specification URL for specifying the behavior of custom scalar types.
+"""
+directive @specifiedBy(
+
+  "Point to a human-readable specification of the data format."
+  url: String!
+  
+) on SCALAR

data/test/config.rb

@@ -4,24 +4,33 @@ SimpleCov.start do
 
   add_filter '/test/'
 
-  add_group 'Definition', ['/graphql/type', '/graphql/introspection', '/graphql/schema']
-  add_group 'Source', '/graphql/source'
-  add_group 'Native', '/graphql/native'
-  add_group 'Field', '/graphql/field'
+  add_group 'Definition', ['/graphql/type', '/graphql/directive']
+  add_group 'Field', ['/graphql/alternative', '/graphql/field']
   add_group 'Helpers', '/graphql/helpers'
-  add_group 'Request', '/graphql/request'
+  add_group 'Rails', '/graphql/railties'
+  add_group 'Request', ['/graphql/collectors', '/graphql/request']
+  add_group 'Subscription', '/graphql/subscription'
+  add_group 'Source', ['/graphql/adapters', '/graphql/source']
 end
 
 require 'minitest/autorun'
 require 'minitest/reporters'
+require 'active_record'
 require 'rails-graphql'
-require 'pry'
+require 'pry-byebug'
+
+$config = Rails::GraphQL.config
+$config.logger = ActiveSupport::TaggedLogging.new(Logger.new('/dev/null'))
+$config.enable_introspection = true
+Rails::GraphQL::Request::Backtrace.skip_base_class = NilClass
+
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
 
 require_relative './test_ext'
 
 Minitest::Reporters.use!(Minitest::Reporters::SpecReporter.new)
 
-# Load all files for coverage ensurance
+# Load all files for coverage insurance
 Rails::GraphQL.eager_load!
 
 module GraphQL
@@ -61,7 +70,9 @@ module GraphQL
       end
 
       def fake_type_map(pass = :fetch!, *others)
-        double(**others.unshift(pass).map { |m| [m, passthrough] }.to_h)
+        methods = others.unshift(pass).product([passthrough]).to_h
+        methods[:associated_namespace_of] ||= ->(*) { }
+        double(**methods)
       end
 
       def stubbed_type_map(*others, &block)

data/test/graphql/schema_test.rb

@@ -4,8 +4,8 @@ class GraphQL_SchemaTest < GraphQL::TestCase
   DESCRIBED_CLASS = unmapped_class(Rails::GraphQL::Schema)
 
   def test_gql_name
-    assert_equal('schema', DESCRIBED_CLASS.gql_name)
-    assert_equal('schema', DESCRIBED_CLASS.graphql_name)
+    assert_equal('__Schema', DESCRIBED_CLASS.gql_name)
+    assert_equal('__Schema', DESCRIBED_CLASS.graphql_name)
   end
 
   def test_kind
@@ -36,19 +36,21 @@ class GraphQL_SchemaTest < GraphQL::TestCase
   end
 
   def test_set_namespace
-    result = DESCRIBED_CLASS.get_reset_ivar(:@namespaces) { set_namespace('a') }
-    assert_equal(Set[:a], result)
+    result = DESCRIBED_CLASS.get_reset_ivar(:@namespace) { set_namespace('a') }
+    assert_equal(:a, result)
 
-    result = DESCRIBED_CLASS.get_reset_ivar(:@namespaces) { set_namespace('b', 'c') }
-    assert_equal(Set[:b], result)
+    result = DESCRIBED_CLASS.get_reset_ivar(:@namespace) { set_namespace('b', 'c') }
+    assert_equal(:b, result)
   end
 
   def test_namespace
-    DESCRIBED_CLASS.stub(:namespaces, []) do
+    assert_equal(:base, DESCRIBED_CLASS.namespace)
+
+    DESCRIBED_CLASS.stub_ivar(:@namespace, nil) do
       assert_equal(:base, DESCRIBED_CLASS.namespace)
     end
 
-    DESCRIBED_CLASS.stub(:namespaces, [1]) do
+    DESCRIBED_CLASS.stub_ivar(:@namespace, 1) do
       assert_equal(1, DESCRIBED_CLASS.namespace)
     end
 
@@ -64,16 +66,6 @@ class GraphQL_SchemaTest < GraphQL::TestCase
     end
   end
 
-  def test_gql_resolver_ask
-    refute(DESCRIBED_CLASS.gql_resolver?(:calculate))
-
-    DESCRIBED_CLASS.send(:define_method, :calculate) {}
-    assert(DESCRIBED_CLASS.gql_resolver?(:calculate))
-
-    DESCRIBED_CLASS.send(:undef_method, :calculate)
-    refute(DESCRIBED_CLASS.gql_resolver?(:calculate))
-  end
-
   def test_find_type
     DESCRIBED_CLASS.stub(:namespaces, :a) do
       DESCRIBED_CLASS.stub(:type_map, double(fetch: passallthrough)) do
@@ -128,51 +120,23 @@ class GraphQL_SchemaTest < GraphQL::TestCase
     end
   end
 
-  def test_create_type
-    DESCRIBED_CLASS.stub(:create_klass, passallthrough) do
-      other = double(Module.new, base_type: double(name: 'A::Sample'))
-      result = [:some, other, type_const, { suffix: 'Sample' }]
-      assert_equal(result, DESCRIBED_CLASS.send(:create_type, :some, other))
-
-      result = [:some, type_const::Scalar, type_const, { suffix: 'Scalar' }]
-      assert_equal(result, DESCRIBED_CLASS.send(:create_type, :some, :Scalar))
-    end
-  end
-
-  def test_source
-    DESCRIBED_CLASS.stub(:create_klass, passallthrough) do
-      result = [:some, 1, source_const, { suffix: 'Source' }]
-      assert_equal(result, DESCRIBED_CLASS.send(:source, :some, 1))
-
-      source_const.stub(:find_for!, 2) do
-        result = [:some, 2, source_const, { suffix: 'Source' }]
-        assert_equal(result, DESCRIBED_CLASS.send(:source, :some))
-      end
-    end
-  end
-
   def test_sources
     result, passthrough = collect_all_through
+    xargs = { build: true }
     DESCRIBED_CLASS.stub(:source, passthrough) do
       result.clear && DESCRIBED_CLASS.send(:sources, :a, of_type: 1)
-      assert_equal([[:a, 1]], result)
+      assert_equal([[:a, 1, xargs]], result)
 
       result.clear && DESCRIBED_CLASS.send(:sources, :a, :b, of_type: 1)
-      assert_equal([[:a, 1], [:b, 1]], result)
+      assert_equal([[:a, 1, xargs], [:b, 1, xargs]], result)
 
       source_const.stub(:find_for!, 2) do
         result.clear && DESCRIBED_CLASS.send(:sources, %i[c d e])
-        assert_equal([[:c, 2], [:d, 2], [:e, 2]], result)
+        assert_equal([[:c, 2, xargs], [:d, 2, xargs], [:e, 2, xargs]], result)
       end
     end
   end
 
-  def test_create_klass
-    skip 'Needs branching testing'
-    new_klass = DESCRIBED_CLASS.send :create_klass, 'Test', unmapped_class(type_const::Enum)
-    assert(new_klass < type_const::Enum)
-  end
-
   protected
 
     def type_const

data/test/graphql/source_test.rb

@@ -24,21 +24,13 @@ class GraphQL_SourceTest < GraphQL::TestCase
   end
 
   def test_base_name
-    described_class.stub(:abstract?, true) do
-      assert_nil(described_class.base_name)
-    end
-
     described_class.stub(:abstract?, false) do
       assert_equal('DESCRIBED', described_class.base_name)
     end
   end
 
   def test_inherited
-    assert_pending([])
-
-    other = unmapped_class(described_class)
-    refute_predicate(other, :abstract?)
-    assert_pending(described_class, other)
+    skip
   end
 
   def test_find_for_bang
@@ -66,32 +58,13 @@ class GraphQL_SourceTest < GraphQL::TestCase
   end
 
   def test_built_ask
-    refute_predicate(described_class, :built?)
-
-    described_class.stub_ivar(:@built, false) do
-      refute_predicate(described_class, :built?)
-    end
-
-    described_class.stub_ivar(:@built, true) do
-      assert_predicate(described_class, :built?)
-    end
+    skip
   end
 
   def test_attach_fields_bang
     skip
   end
 
-  def test_refresh_schemas_bang
-    described_class.stub(:namespaces, [:base]) do
-      schema = unmapped_class(Rails::GraphQL::Schema)
-      Rails::GraphQL::Schema.stub(:find, schema) do
-        described_class.refresh_schemas!
-        result = described_class.instance_variable_get(:@schemas)
-        assert_equal({ base: schema }, result)
-      end
-    end
-  end
-
   def test_find_type_bang
     described_class.stub(:namespaces, :a) do
       Rails::GraphQL.stub(:type_map, double(fetch!: passallthrough)) do
@@ -122,16 +95,16 @@ class GraphQL_SourceTest < GraphQL::TestCase
     skip
   end
 
-  def test_skip_on
+  def test_skip_from
     hash_list = Hash.new { |h, k| h[k] = Set.new }
     described_class.stub(:segmented_skip_fields, -> { hash_list }) do
-      assert_equal(Set[:a], described_class.send(:skip_on, 1, :a))
-      assert_equal(Set[:b], described_class.send(:skip_on, 2, 'b'))
-      assert_equal(Set[:b, :c, :d], described_class.send(:skip_on, 2, 'c', :d))
+      assert_equal(Set[:a], described_class.send(:skip_from, 1, :a))
+      assert_equal(Set[:b], described_class.send(:skip_from, 2, 'b'))
+      assert_equal(Set[:b, :c, :d], described_class.send(:skip_from, 2, 'c', :d))
     end
   end
 
-  def test_on
+  def test_step
     skip
   end
 
@@ -147,7 +120,7 @@ class GraphQL_SourceTest < GraphQL::TestCase
   def test_override
     sequence = []
     described_class.stub(:skip, ->(*args) { sequence += args }) do
-      described_class.stub(:on, ->(*args, &block) { sequence += args << block }) do
+      described_class.stub(:step, ->(*args, &block) { sequence += args << block }) do
         described_class.send(:override, :start, &passthrough)
         assert_equal(0, described_class.hooks[:start].size)
         assert_equal([:start, :start, passthrough], sequence)
@@ -171,60 +144,10 @@ class GraphQL_SourceTest < GraphQL::TestCase
     end
   end
 
-  def test_gql_module
-    assert_equal(::GraphQL, described_class.send(:gql_module))
-
-    ::GraphQL.stub_const(:Other, Module.new) do
-      sample = unmapped_class(source_const)
-      ::GraphQL::Other.const_set(:Source, sample)
-      assert_equal(::GraphQL::Other, sample.send(:gql_module))
-    end
-  end
-
-  def test_skips_for
-    described_class.stub(:all_segmented_skip_fields, { input: Set[:a] }) do
-      described_class.stub(:all_skip_fields, Set[:b]) do
-        result = described_class.send(:skips_for, double(kind: :input_object))
-        assert_equal(Set[:b, :a], result)
-
-        result = described_class.send(:skips_for, double(kind: :object))
-        assert_equal(Set[:b], result)
-      end
-    end
-  end
-
-  def test_pending_ask
-    refute_predicate(source_const, :pending?)
-
-    sample = unmapped_class(source_const)
-    assert_predicate(source_const, :pending?)
-  end
-
-  def test_build_pending_bang
-    built = [false, false]
-    object1 = double(build!: -> { built[0] = true }, abstract?: false)
-    object2 = double(build!: -> { built[1] = true }, abstract?: true)
-
-    described_class.stub(:pending, [object1, object2]) do
-      described_class.send(:build_pending!)
-      assert_equal([true, false], built)
-    end
-  end
-
   def test_build_bang
     skip
   end
 
-  def test_run_hooks
-    assert_respond_to(described_class, :run_start_hooks)
-    assert_respond_to(described_class, :run_finish_hooks)
-    assert_respond_to(described_class, :run_object_hooks)
-    assert_respond_to(described_class, :run_input_hooks)
-    assert_respond_to(described_class, :run_query_hooks)
-    assert_respond_to(described_class, :run_mutation_hooks)
-    assert_respond_to(described_class, :run_subscription_hooks)
-  end
-
   protected
 
     def assert_pending(*items)