rails-graphql 0.2.1 → 1.0.0.rc1

data/test/graphql/type_map_test.rb

@@ -15,49 +15,24 @@ class GraphQL_TypeMapTest < GraphQL::TestCase
     @subject ||= DESCRIBED_CLASS.new
   end
 
-  def test_loaded_bang
-    DESCRIBED_CLASS.stub(:base_classes, { Type: false }) do
-      refute(DESCRIBED_CLASS.base_classes[:Type])
-      DESCRIBED_CLASS.loaded!(:Type)
-      assert(DESCRIBED_CLASS.base_classes[:Type])
-    end
-
-    DESCRIBED_CLASS.stub(:base_classes, { Type: true }) do
-      assert(DESCRIBED_CLASS.base_classes[:Type])
-    end
-  end
-
   def test_reset_bang
     checkpoint = registered_double
     subject.instance_variable_set(:@objects, 1)
-    subject.instance_variable_set(:@pending, 2)
-    subject.instance_variable_set(:@callbacks, 3)
+    subject.instance_variable_set(:@version, 2)
+    subject.instance_variable_set(:@pending, 3)
     subject.instance_variable_set(:@skip_register, 4)
-    subject.instance_variable_set(:@index, 5)
-    subject.instance_variable_set(:@checkpoint, [checkpoint])
+    subject.instance_variable_set(:@callbacks, 5)
+    subject.instance_variable_set(:@dependencies, 6)
+    subject.instance_variable_set(:@index, 7)
     subject.reset!
 
     refute_equal(1, subject.instance_variable_get(:@objects))
-    refute_equal(2, subject.instance_variable_get(:@pending))
-    refute_equal(3, subject.instance_variable_get(:@callbacks))
+    refute_equal(2, subject.instance_variable_get(:@version))
+    refute_equal(3, subject.instance_variable_get(:@pending))
     refute_equal(4, subject.instance_variable_get(:@skip_register))
-    refute_equal(5, subject.instance_variable_get(:@index))
-    assert_predicate(checkpoint, :registered?)
-  end
-
-  def test_use_checkpoint_bang
-    subject.stub(:objects, [1]) do
-      assert_registered do
-        subject.use_checkpoint!
-        assert_equal([1], subject.instance_variable_get(:@checkpoint))
-      end
-    end
-
-    reset = false
-    subject.stub(:reset!, -> { reset  = true }) do
-      subject.use_checkpoint!
-      assert(reset)
-    end
+    refute_equal(5, subject.instance_variable_get(:@callbacks))
+    refute_equal(6, subject.instance_variable_get(:@dependencies))
+    refute_equal(7, subject.instance_variable_get(:@index))
   end
 
   def test_objects
@@ -66,15 +41,23 @@ class GraphQL_TypeMapTest < GraphQL::TestCase
       assert_empty(subject.objects)
     end
 
-    item = registered_double
-    subject.stub_ivar(:@index, { a: { b: { c: -> { item } }, d: { e: -> { 1 } } } }) do
+    item = double(
+      gql_name: 'name',
+      is_a?: ->(klass) { klass == Rails::GraphQL::Helpers::Registerable },
+    )
+
+    other = double(gql_name: 'otherName')
+
+    checker = -> { item }
+    subject.stub_ivar(:@index, { a: { b: { c: checker }, d: { e: checker }, f: { g: other } } }) do
       assert_empty(subject.objects(namespaces: :z))
       assert_empty(subject.objects(namespaces: :a, base_classes: :z))
-      assert_empty(subject.objects(namespaces: :a, base_classes: :d))
+      assert_empty(subject.objects(namespaces: :a, base_classes: :f))
 
-      result = subject.objects
-      refute_includes(result, 1)
-      assert_includes(result, item)
+      subject.class.stub(:base_classes, %i[b d f]) do
+        result = subject.objects
+        assert_equal([item], result)
+      end
     end
   end
 
@@ -86,36 +69,29 @@ class GraphQL_TypeMapTest < GraphQL::TestCase
 
     loaded = false
     subject.stub(:fetch, ->(*x) { x if loaded }) do
-      subject.stub(:base_classes, { Type: true }) do
-        assert_raises(StandardError) { subject.fetch!(1) }
-      end
+      assert_raises(StandardError) { subject.fetch!(1) }
 
-      subject.stub(:base_classes, { Type: false }) do
-        Rails::GraphQL.stub_const(:Type, double(eager_load!: -> { loaded = true })) do
-          assert_equal([1, { base_class: :Type }], subject.fetch!(1))
-          assert(loaded)
-        end
+      subject.stub(:load_dependencies!, ->(*) { loaded = true }) do
+        assert_equal([1, {  base_class: :Type }], subject.fetch!(1))
       end
     end
   end
 
   def test_fetch
     stub_dig do
-      assert_registered(9) do
-        assert_nil(subject.fetch(:number))
-        assert_nil(subject.fetch(:number, base_class: :Other))
+      assert_nil(subject.fetch(:number))
+      assert_nil(subject.fetch(:number, base_class: :Other))
 
-        assert_equal(1, subject.fetch(:string))
-        assert_equal(1, subject.fetch(:string, prevent_register: true))
-        assert_equal(1, subject.fetch(:number, fallback: :string))
+      assert_equal(1, subject.fetch(:string))
+      assert_equal(1, subject.fetch(:string, prevent_register: true))
+      assert_equal(1, subject.fetch(:number, fallback: :string))
 
-        assert_equal(2, subject.fetch(:string, namespaces: :other))
-        assert_equal(3, subject.fetch(:number, namespaces: Set[:other]))
+      assert_equal(2, subject.fetch(:string, namespaces: :other))
+      assert_equal(3, subject.fetch(:number, namespaces: Set[:other]))
 
-        assert_equal(4, subject.fetch(:boolean))
-        assert_equal(4, subject.fetch(:boolean, namespaces: :other))
-        assert_nil(subject.fetch(:boolean, namespaces: :other, exclusive: true))
-      end
+      assert_equal(4, subject.fetch(:boolean))
+      assert_equal(4, subject.fetch(:boolean, namespaces: :other))
+      assert_nil(subject.fetch(:boolean, namespaces: :other, exclusive: true))
     end
   end
 
@@ -167,10 +143,9 @@ class GraphQL_TypeMapTest < GraphQL::TestCase
           assert_equal([:base, object1, :string],  added[0][0..-2])
           assert_equal([:base, object1, 'string'], added[1][0..-2])
 
-          subject.stub(:fetch, passallthrough) do
-            xargs = { base_class: object1, namespaces: :base, exclusive: true }
-            assert_equal([:string, xargs], added[1][-1].call)
-            assert_equal(object1, added[0][-1].call)
+          subject.stub(:dig, passallthrough) do
+            assert_equal([:base, object1, :string], added[1][-1].call)
+            assert_equal(object1, added[0][-1])
           end
 
           assert_equal(1, subject.instance_variable_get(:@objects))
@@ -212,7 +187,7 @@ class GraphQL_TypeMapTest < GraphQL::TestCase
         assert_equal([:base, :Type, :a], added[0][0..-2])
 
         subject.stub(:fetch, passallthrough) do
-          xargs = { base_class: :Type, namespaces: [:base], exclusive: true }
+          xargs = { base_class: :Type, namespaces: [:base].to_set, exclusive: true }
           assert_equal([:string, xargs], added[0][-1].call)
         end
 
@@ -229,13 +204,15 @@ class GraphQL_TypeMapTest < GraphQL::TestCase
 
   def test_each_from
     assert_registered(4) do
-      subject.stub_ivar(:@index, SAMPLE_INDEX) do
-        items = [1, 4]
-        subject.each_from(:base) { |x| assert_equal(items.shift, x) }
-
-        assert_equal([2, 3, 1, 4], subject.each_from(:other).entries)
-        assert_equal([2, 3], subject.each_from(:other, exclusive: true).entries)
-        assert_equal([], subject.each_from(:other, base_class: :Other).entries)
+      Integer.stub_imethod(:gql_name, -> { to_s }) do
+        subject.stub_ivar(:@index, SAMPLE_INDEX) do
+          items = [1, 4]
+          subject.each_from(:base) { |x| assert_equal(items.shift, x) }
+
+          assert_equal([2, 3, 1, 4], subject.each_from(:other).entries)
+          assert_equal([2, 3], subject.each_from(:other, exclusive: true).entries)
+          assert_equal([], subject.each_from(:other, base_class: :Other).entries)
+        end
       end
     end
   end
@@ -243,7 +220,7 @@ class GraphQL_TypeMapTest < GraphQL::TestCase
   def test_after_register
     subject.stub(:fetch, passallthrough) do
       result = subject.after_register(:a, &passthrough)
-      xargs = { prevent_register: true, base_class: :Type, namespaces: :base }
+      xargs = { prevent_register: true, base_class: :Type }
       assert_equal([:a, xargs], result)
     end
 
@@ -268,15 +245,20 @@ class GraphQL_TypeMapTest < GraphQL::TestCase
       [:other, :Type],
       [:other, :Type],
     ].each_with_index do |(ns, bc), idx|
-      assert_nil(register[:a][idx].call(:x, bc, :non_called))
-      assert_nil(register[:a][idx].call(ns, :y, :non_called))
-      assert_equal(idx, register[:a][idx].call(ns, bc, :called))
+      assert_nil(register[:a][3 - idx].call(:x, bc, :non_called))
+      assert_nil(register[:a][3 - idx].call(ns, :y, :non_called))
+      assert(register[:a][3 - idx].call(ns, bc, :called))
     end
   end
 
   def test_inspect
-    assert_equal(<<~INFO.chomp, subject.inspect)
-      #<Rails::GraphQL::TypeMap [index] @namespaces=0 @base_classes=3 @objects=0 @pending=0>
+    assert_equal(<<~INFO.squish, subject.inspect)
+      #<Rails::GraphQL::TypeMap [index]
+      @namespaces=0
+      @base_classes=3
+      @objects=0
+      @pending=0
+      @dependencies={base: 15}>
     INFO
   end
 
@@ -320,11 +302,11 @@ class GraphQL_TypeMapTest < GraphQL::TestCase
 
   def test_register_pending_bang
     registered = false
-    object = double(register!: -> { -> { registered = true } }, registered?: false)
+    object = double(register!: -> { registered = true }, registered?: false)
     skipped = double(registered?: false)
     other = double(registered?: true)
 
-    subject.stub(:skip_register, [skipped]) do
+    subject.stub(:skip_register, [[skipped].to_set]) do
       subject.stub_ivar(:@pending, [[skipped, :a], [object, :b], [other, :c]]) do
         subject.send(:register_pending!)
         assert(registered)

data/test/graphql/type_test.rb

@@ -38,25 +38,6 @@ class GraphQL_TypeTest < GraphQL::TestCase
     assert_equal(1, DESCRIBED_CLASS.decorate(1))
   end
 
-  def test_gql_resolver_ask
-    DESCRIBED_CLASS.stub(:base_object?, false) do
-      refute(DESCRIBED_CLASS.gql_resolver?(:calculate))
-      DESCRIBED_CLASS.send(:define_method, :calculate) {}
-
-      assert(DESCRIBED_CLASS.gql_resolver?(:calculate))
-
-      other_class = unmapped_class(DESCRIBED_CLASS)
-      assert(other_class.gql_resolver?(:calculate))
-
-      other_class.stub(:base_object?, true) do
-        refute(other_class.gql_resolver?(:calculate))
-      end
-
-      DESCRIBED_CLASS.send(:undef_method, :calculate)
-      refute(DESCRIBED_CLASS.gql_resolver?(:calculate))
-    end
-  end
-
   def test_kind_ask
     assert_respond_to(DESCRIBED_CLASS, :scalar?)
     assert_respond_to(DESCRIBED_CLASS, :object?)

data/test/graphql_test.rb

@@ -12,7 +12,7 @@ class GraphQLTest < GraphQL::TestCase
   end
 
   def test_ar_adapter_key
-    DESCRIBED_CLASS.stub(:config, double(ar_adapters: { 'a' => 1 })) do
+    DESCRIBED_CLASS.stub(:config, double(ar_adapters: { 'a' => { key: 1 } })) do
       assert_equal(1, DESCRIBED_CLASS.ar_adapter_key('a'))
       assert_nil(DESCRIBED_CLASS.ar_adapter_key('b'))
     end

data/test/integration/{authorization/authorization_test.rb → authorization_test.rb}

@@ -1,9 +1,20 @@
 require 'integration/config'
 
-class Integration_Memory_AuthorizationTest < GraphQL::IntegrationTestCase
-  load_schema 'authorization'
+class Integration_AuthorizationTest < GraphQL::IntegrationTestCase
+  class SCHEMA < GraphQL::Schema
+    namespace :authorization
+
+    configure do |config|
+      config.enable_string_collector = false
+      config.default_response_format = :json
+    end
+
+    query_fields do
+      field(:sample1, :string).resolve { 'Ok 1' }
+      field(:sample2, :string).authorize.resolve { 'Ok 2' }
+    end
+  end
 
-  SCHEMA = ::AuthorizationSchema
   EXCEPTION_NAME = 'Rails::GraphQL::UnauthorizedFieldError'
   EXCEPTION_PATH = ['errors', 0, 'extensions', 'exception']
 
@@ -22,11 +33,11 @@ class Integration_Memory_AuthorizationTest < GraphQL::IntegrationTestCase
     assert_exception('{ sample2 }')
     assert_result({ sample1: 'Ok 1', sample2: nil }, '{ sample1 sample2 }', dig: 'data')
 
-    SCHEMA.stub_imethod(:authorize!, &:authorize!).call do
+    SCHEMA.stub_imethod(:authorize!, -> { authorized! }) do
       assert_result(SAMPLE2, '{ sample2 }')
     end
 
-    SCHEMA.stub_imethod(:authorize!, &:unauthorize!).call do
+    SCHEMA.stub_imethod(:authorize!, -> { unauthorized! }) do
       assert_exception('{ sample2 }')
     end
   end
@@ -38,7 +49,7 @@ class Integration_Memory_AuthorizationTest < GraphQL::IntegrationTestCase
       assert_executed { assert_result(SAMPLE1, '{ sample1 }') }
     end
 
-    block = ->(ev) { executed! && ev.unauthorize! }
+    block = ->(ev) { executed! && ev.unauthorized! }
     field.stub_ivar(:@authorizer, [[], {}, block]) do
       assert_executed { assert_exception('{ sample1 }') }
     end
@@ -51,7 +62,7 @@ class Integration_Memory_AuthorizationTest < GraphQL::IntegrationTestCase
       assert_executed { assert_result(SAMPLE2, '{ sample2 }') }
 
       assert_executed do
-        field.on(:authorize) { |event| event.unauthorize! }
+        field.on(:authorize) { |event| event.unauthorized! }
         assert_exception('{ sample2 }')
       end
     end
@@ -64,29 +75,44 @@ class Integration_Memory_AuthorizationTest < GraphQL::IntegrationTestCase
     auth_directive.on(:authorize, &method(:executed!))
 
     auth_directive.stub_ivar(:@gql_name, 'AuthDirective') do
-      field.stub_ivar(:@directives, [auth_directive.new]) do
+      instance = auth_directive.new.tap { |dir| dir.instance_variable_set(:@owner, nil) }
+      field.stub_ivar(:@directives, [instance]) do
         assert_executed { assert_result(SAMPLE2, '{ sample2 }') }
       end
 
-      SCHEMA.stub_ivar(:@directives, [auth_directive.new]) do
-        assert_executed { assert_result(SAMPLE2, '{ sample2 }') }
+      instance = auth_directive.new.tap { |dir| dir.instance_variable_set(:@owner, nil) }
+      SCHEMA.stub_ivar(:@directives, [instance]) do
+        assert_executed(0) { assert_result(SAMPLE2, '{ sample2 }') }
+      end
+
+      auth_directive.events[:authorize][0].stub_ivar(:@exclusive, false) do
+        SCHEMA.stub_ivar(:@directives, [instance]) do
+          assert_executed { assert_result(SAMPLE2, '{ sample2 }') }
+        end
+      end
+
+      instance = auth_directive.new.tap { |dir| dir.instance_variable_set(:@owner, nil) }
+      method = ->(*) { @directives = Set.new([instance]) }
+      Rails::GraphQL::Request::Component::Field.stub_imethod(:parse_directives, method) do
+        assert_executed { assert_result(SAMPLE2, '{ sample2 @AuthDirective }') }
       end
     end
   end
 
   def test_authorize_bypass
     field = SCHEMA.query_field(:sample2)
-    auth_block   = ->(e, event) { e.call && event.authorize!   }.curry(2)[method(:executed!)]
-    unauth_block = ->(e, event) { e.call && event.unauthorize! }.curry(2)[method(:executed!)]
+    counter = method(:executed!)
+    auth_block   = ->(ev = nil) { counter.call && (ev || itself).authorized!   }
+    unauth_block = ->(ev = nil) { counter.call && (ev || itself).unauthorized! }
 
     field.stub_ivar(:@events, { authorize: [unauth_block] }) do
-      SCHEMA.stub_imethod(:authorize!, &auth_block).call do
+      SCHEMA.stub_imethod(:authorize!, auth_block) do
         assert_executed { assert_result(SAMPLE2, '{ sample2 }') }
       end
     end
 
     field.stub_ivar(:@events, { authorize: [auth_block] }) do
-      SCHEMA.stub_imethod(:authorize!, &unauth_block).call do
+      SCHEMA.stub_imethod(:authorize!, unauth_block) do
         assert_executed { assert_exception('{ sample2 }') }
       end
     end

data/test/integration/config.rb

@@ -7,8 +7,28 @@ module GraphQL
     SCHEMAS = Pathname.new(__dir__).join('schemas')
     ASSETS = Pathname.new(__dir__).join('../assets')
 
+    I18n.load_path <<  ASSETS.join("en.yml")
+
+    BASE_SCHEMA = ::Rails::GraphQL::Schema
+
+    def run(*)
+      BASE_SCHEMA.send(:introspection_dependencies!)
+      BASE_SCHEMA.type_map.send(:load_dependencies!)
+
+      super
+    end
+
     def setup
-      reset_type_map!
+      BASE_SCHEMA.type_map.base_classes.each do |base_class|
+        ::GraphQL.const_get(base_class).descendants.each(&:register!)
+      end
+
+      index = BASE_SCHEMA.type_map.instance_variable_get(:@index)[:base][:Type]
+      remove_keys_form_type_map&.each(&index.method(:delete))
+    end
+
+    def teardown
+      BASE_SCHEMA.type_map.reset!
     end
 
     protected
@@ -17,8 +37,8 @@ module GraphQL
         require(SCHEMAS.join("#{name}"))
       end
 
-      def reset_type_map!
-        Rails::GraphQL.type_map.hard_reset!
+      def remove_keys_form_type_map
+        all_non_spec_keys
       end
 
       def named_list(*list, **extra)
@@ -52,5 +72,18 @@ module GraphQL
         obj = obj.map(&:deep_stringify_keys) if obj.is_a?(Array)
         obj.nil? ? assert_nil(result) : assert_equal(obj, result)
       end
+
+      def all_non_spec_keys
+        [
+          :any, 'Any',
+          :bigint, 'Bigint',
+          :binary, 'Binary', :file,
+          :date_time, 'DateTime', :datetime,
+          :date, 'Date',
+          :decimal, 'Decimal',
+          :time, 'Time',
+          :json, 'JSON',
+        ]
+      end
   end
 end

data/test/integration/customization_test.rb

@@ -0,0 +1,39 @@
+require 'integration/config'
+
+class Integration_CustomizationTest < GraphQL::IntegrationTestCase
+  class SCHEMA < GraphQL::Schema
+    namespace :customization
+
+    configure do |config|
+      config.schema_type_names = {
+        query: 'A',
+        mutation: 'B',
+        subscription: 'C',
+      }
+    end
+
+    query_fields { field(:one, :string) }
+    mutation_fields { field(:two, :string) }
+    subscription_fields { field(:three, :string) }
+  end
+
+  def test_type_name_for
+    assert_equal('A', SCHEMA.type_name_for(:query))
+    assert_equal('B', SCHEMA.type_name_for(:mutation))
+    assert_equal('C', SCHEMA.type_name_for(:subscription))
+  end
+
+  def test_type_map
+    assert_equal(SCHEMA.query_type, SCHEMA.find_type('A'))
+    assert_equal(SCHEMA.mutation_type, SCHEMA.find_type('B'))
+    assert_equal(SCHEMA.subscription_type, SCHEMA.find_type('C'))
+  end
+
+  def test_cache_prefix
+    assert_equal('graphql/customization/', SCHEMA.config.cache_prefix)
+    SCHEMA.config.cache_prefix = 'banana'
+    assert_equal('banana', SCHEMA.config.cache_prefix)
+    SCHEMA.config.cache_prefix = nil
+    assert_equal('graphql/customization/', SCHEMA.config.cache_prefix)
+  end
+end

data/test/integration/global_id_test.rb

@@ -0,0 +1,99 @@
+require 'integration/config'
+
+class Integration_GlobalIDTest < GraphQL::IntegrationTestCase
+  load_schema 'memory'
+
+  SCHEMA = ::StartWarsMemSchema
+
+  ## CREATE
+
+  def test_create_directive
+    obj = GraphQL::Directive::DeprecatedDirective
+    assert_gid_value('gql://base/Directive/deprecated', obj)
+  end
+
+  def test_create_directive_instance
+    obj = GraphQL::DeprecatedDirective()
+    assert_gid_value('gql://base/Directive/deprecated?', obj)
+
+    obj = GraphQL::DeprecatedDirective(reason: 'A B')
+    assert_gid_value('gql://base/Directive/deprecated?reason=A+B', obj)
+  end
+
+  def test_create_schema
+    assert_gid_value('gql://start-wars-mem/Schema', SCHEMA)
+  end
+
+  def test_create_query_field
+    obj = SCHEMA[:query][:hero]
+    assert_gid_value('gql://start-wars-mem/Schema/query/hero', obj)
+  end
+
+  def test_create_mutation_field
+    obj = SCHEMA[:mutation][:change_human]
+    assert_gid_value('gql://start-wars-mem/Schema/mutation/changeHuman', obj)
+  end
+
+  def test_create_object_field
+    obj = SCHEMA::NestedTypes::HumanObject[:name]
+    assert_gid_value('gql://start-wars-mem/Human/name', obj)
+  end
+
+  def test_create_scalar_type
+    obj = GraphQL.type_map.fetch(:string)
+    assert_gid_value('gql://base/Type/String', obj)
+  end
+
+  def assert_gid_value(result, object)
+    assert_equal(result, object.to_gid.to_s)
+  end
+
+  ## PARSE
+
+  def test_parse_directive
+    obj = find_gid('gql://base/Directive/deprecated')
+    assert_equal(GraphQL::Directive::DeprecatedDirective, obj)
+  end
+
+  def test_parse_directive_instance
+    obj = find_gid('gql://base/Directive/deprecated?')
+    assert_instance_of(GraphQL::Directive::DeprecatedDirective, obj)
+    assert_nil(obj.args[:reason])
+
+    obj = find_gid('gql://base/Directive/deprecated?reason=A+B')
+    assert_instance_of(GraphQL::Directive::DeprecatedDirective, obj)
+    assert_equal('A B', obj.args[:reason])
+
+    obj = find_gid('gql://base/Directive/skip?if=false')
+    assert_instance_of(GraphQL::Directive::SkipDirective, obj)
+    assert_equal(false, obj.args[:if])
+  end
+
+  def test_parse_schema
+    assert_equal(SCHEMA, find_gid('gql://start-wars-mem/Schema'))
+  end
+
+  def test_parse_query_field
+    obj = find_gid('gql://start-wars-mem/Schema/query/hero')
+    assert_equal(SCHEMA[:query][:hero], obj)
+  end
+
+  def test_parse_mutation_field
+    obj = find_gid('gql://start-wars-mem/Schema/mutation/changeHuman')
+    assert_equal(SCHEMA[:mutation][:change_human], obj)
+  end
+
+  def test_parse_object_field
+    obj = find_gid('gql://start-wars-mem/Human/name')
+    assert_equal(SCHEMA::NestedTypes::HumanObject[:name], obj)
+  end
+
+  def test_parse_scalar_type
+    obj = find_gid('gql://base/Type/String')
+    assert_equal(GraphQL.type_map.fetch(:string), obj)
+  end
+
+  def find_gid(gid)
+    GraphQL::GlobalID.find(gid)
+  end
+end

data/test/integration/memory/star_wars_introspection_test.rb

@@ -6,13 +6,19 @@ class Integration_Memory_StarWarsIntrospectionTest < GraphQL::IntegrationTestCas
 
   SCHEMA = ::StartWarsMemSchema
 
+  def test_auto_introspection
+    assert(SCHEMA.introspection?)
+    assert(SCHEMA.has_field?(:query, :__schema))
+    assert(SCHEMA.has_field?(:query, :__type))
+  end
+
   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])
+    types = named_list(*%w[Boolean Character Droid Episode Float Human ID Int String
+      _Mutation _Query __Directive __DirectiveLocation __EnumValue __Field __InputValue
+      __Schema __Type __TypeKind])
 
     sort_items = ->(result) do
-      result.dig('data', '__schema', 'types').sort_by! { |t| t['name'] }
+      result.dig('data', '__schema', 'types')&.sort_by! { |t| t['name'] }
     end
 
     assert_result({ data: { __schema: { types: types } } }, <<~GQL, &sort_items)
@@ -53,11 +59,11 @@ class Integration_Memory_StarWarsIntrospectionTest < GraphQL::IntegrationTestCas
   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: 'friends', type: { name: nil, kind: 'LIST' } },
+      { name: 'name', type: { name: 'String', kind: 'SCALAR' } },
       { name: 'primaryFunction', type: { name: 'String', kind: 'SCALAR' } },
+      { name: 'secretBackstory', type: { name: 'String', kind: 'SCALAR' } },
     ]
 
     assert_result({ data: { __type: { name: 'Droid', fields: fields } } }, <<~GQL)
@@ -68,11 +74,11 @@ class Integration_Memory_StarWarsIntrospectionTest < GraphQL::IntegrationTestCas
   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: 'friends', type: { name: nil, kind: 'LIST', ofType: { name: 'Character', kind: 'INTERFACE' } } },
+      { name: 'name', type: { name: 'String', kind: 'SCALAR', ofType: nil } },
       { name: 'primaryFunction', type: { name: 'String', kind: 'SCALAR', ofType: nil } },
+      { name: 'secretBackstory', type: { name: 'String', kind: 'SCALAR', ofType: nil } },
     ]
 
     assert_result({ data: { __type: { name: 'Droid', fields: fields } } }, <<~GQL)
@@ -98,11 +104,9 @@ class Integration_Memory_StarWarsIntrospectionTest < GraphQL::IntegrationTestCas
     }, defaultValue: nil }
 
     fields = [
-      { name: '__schema', args: [] },
-      { name: '__type', args: [name_arg] },
+      { name: 'droid', args: [id_arg.merge(description: 'ID of the droid')] },
       { 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)
@@ -128,6 +132,8 @@ class Integration_Memory_StarWarsIntrospectionTest < GraphQL::IntegrationTestCas
   # 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
+    SCHEMA.send(:enable_introspection!)
+
     query = gql_file('introspection')
     result = text_file('introspection-mem').split('').sort.join
     assert_result(result, query, as: :string) do |res|
@@ -137,8 +143,10 @@ class Integration_Memory_StarWarsIntrospectionTest < GraphQL::IntegrationTestCas
   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)
+    result = SCHEMA.to_gql
+    expected = gql_file('mem').split('').sort.join.squish
+
+    # File.write('test/assets/mem.gql', result)
+    assert_equal(expected, result.split('').sort.join.squish)
   end
 end