Initial setup

.github/workflows/ci.yml

@@ -0,0 +1,29 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - gemfile: Gemfile
+            ruby: 3.3
+    steps:
+    - run: echo BUNDLE_GEMFILE=${{ matrix.gemfile }} > $GITHUB_ENV
+    - uses: actions/checkout@v4
+    - name: Setup Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: |
+        gem install bundler -v 2.4.22
+        bundle install --jobs 4 --retry 3
+        bundle exec rake test

.gitignore

@@ -9,12 +9,15 @@
 /test/tmp/
 /test/version_tmp/
 /tmp/
-
-# Used by dotenv library to load environment variables.
-# .env
-
-# Ignore Byebug command history file.
+.envrc
 .byebug_history
+.ruby-version
+.rvmrc
+.DS_Store
+
+Gemfile.lock
+secrets.json
+example/*/*.graphql
 
 ## Specific to RubyMotion:
 .dat*
@@ -24,14 +27,6 @@ build/
 build-iPhoneOS/
 build-iPhoneSimulator/
 
-## Specific to RubyMotion (use of CocoaPods):
-#
-# We recommend against adding the Pods directory to your .gitignore. However
-# you should judge for yourself, the pros and cons are mentioned at:
-# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
-#
-# vendor/Pods/
-
 ## Documentation cache and generated files:
 /.yardoc/
 /_yardoc/
@@ -42,15 +37,3 @@ build-iPhoneSimulator/
 /.bundle/
 /vendor/bundle
 /lib/bundler/man/
-
-# for a library or gem, you might want to ignore these files since the code is
-# intended to run in multiple environments; otherwise, check them in:
-# Gemfile.lock
-# .ruby-version
-# .ruby-gemset
-
-# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
-.rvmrc
-
-# Used by RuboCop. Remote config files pulled in from inherit_from directive.
-# .rubocop-https?--*

Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+gem 'pry'

README.md

@@ -1,2 +1,29 @@
-# graphql-response_fixture
-Validate that GraphQL response fixtures match their test queries
+# GraphQL response fixtures
+
+Testing GraphQL queries using fixture responses runs the risk of false-positive outcomes when a query changes without its response fixture getting updated accordingly. This gem provides a simple utility for loading JSON response fixtures and validating them against the shape of the query to assure they match.
+
+```shell
+gem "graphql-response_fixture"
+```
+
+## Usage
+
+Build a test query and its response data into a `GraphQL::ResponseFixture`, then assert that the fixture is correct for the query as part of your test:
+
+```ruby
+def test_my_stuff
+  query = %|{ widget { id title } }|
+  result = { 
+    "widget" => { 
+      "id" => "1", 
+      "name" => "My widget", # << incorrect, the query requests `title`
+    },
+  }
+
+  request = GraphQL::Query.new(MySchema, query: query)
+  response = GraphQL::ResponseFixture.new(request, result)
+
+  assert response.valid?, response.error_message
+  # Results in: "Expected data to provide field `widget.title`"
+end
+```

Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t, args|
+  puts args
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

graphql-response_fixture.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "graphql/response_fixture/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "graphql-response_fixture"
+  spec.version       = GraphQL::ResponseFixture::VERSION
+  spec.authors       = ["Greg MacWilliam"]
+  spec.summary       = "Validate that a GraphQL response fixture matches its test query."
+  spec.description   = "Validate that a GraphQL response fixture matches its test query."
+  spec.homepage      = "https://github.com/gmac/graphql-response_fixture"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata    = {
+    "homepage_uri" => "https://github.com/gmac/graphql-response_fixture",
+    "changelog_uri" => "https://github.com/gmac/graphql-response_fixture/releases",
+    "source_code_uri" => "https://github.com/gmac/graphql-response_fixture",
+    "bug_tracker_uri" => "https://github.com/gmac/graphql-response_fixture/issues",
+  }
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^test/})
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "graphql", ">= 2.0.0"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "minitest", "~> 5.12"
+end

lib/graphql/response_fixture.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "graphql"
+
+module GraphQL
+  class ResponseFixture
+    SYSTEM_TYPENAME = "__typename__"
+    SCALAR_VALIDATORS = {
+      "Boolean" => -> (data) { data.is_a?(TrueClass) || data.is_a?(FalseClass) },
+      "Float" => -> (data) { data.is_a?(Numeric) },
+      "ID" => -> (data) { data.is_a?(String) || data.is_a?(Integer) },
+      "Int" => -> (data) { data.is_a?(Integer) },
+      "JSON" => -> (data) { data.is_a?(Hash) },
+      "String" => -> (data) { data.is_a?(String) },
+    }.freeze
+
+    class ResponseFixtureError < StandardError; end
+
+    attr_reader :error_message
+
+    def initialize(
+      query,
+      data,
+      scalar_validators: SCALAR_VALIDATORS,
+      system_typename: SYSTEM_TYPENAME
+    )
+      @query = query
+      @data = data
+      @valid = nil
+      @error_message = nil
+      @scalar_validators = scalar_validators
+      @system_typename = system_typename
+      @system_typenames = Set.new
+    end
+
+    def valid?
+      return @valid unless @valid.nil?
+
+      op = @query.selected_operation
+      parent_type = @query.root_type_for_operation(op.operation_type)
+      validate_selections(parent_type, op, @data)
+      @valid = true
+    rescue ResponseFixtureError => e
+      @error_message = e.message
+      @valid = false
+    end
+
+    def prune!
+      @system_typenames.each { _1.delete(@system_typename) }
+      self
+    end
+
+    def to_h
+      @data
+    end
+
+    private
+
+    def validate_selections(parent_type, parent_node, data_part, path = [])
+      if parent_type.non_null?
+        raise ResponseFixtureError, "Expected non-null selection `#{path.join(".")}` to provide value" if data_part.nil?
+        return validate_selections(parent_type.of_type, parent_node, data_part, path)
+
+      elsif data_part.nil?
+        # nullable node with a null value is okay
+        return true
+
+      elsif parent_type.list?
+        raise ResponseFixtureError, "Expected list selection `#{path.join(".")}` to provide Array" unless data_part.is_a?(Array)
+        return data_part.all? { |item| validate_selections(parent_type.of_type, parent_node, item, path) }
+
+      elsif parent_type.kind.leaf?
+        return validate_leaf(parent_type, data_part, path)
+
+      elsif !data_part.is_a?(Hash)
+        raise ResponseFixtureError, "Expected composite selection `#{path.join(".")}` to provide Hash"
+      end
+
+      parent_node.selections.all? do |node|
+        case node
+        when GraphQL::Language::Nodes::Field
+          field_name = node.alias || node.name
+          path << field_name
+          raise ResponseFixtureError, "Expected data to provide field `#{path.join(".")}`" unless data_part.key?(path.last)
+
+          next_value = data_part[path.last]
+          next_type = if node.name == "__typename"
+            annotation_type = @query.get_type(data_part[field_name])
+            unless annotation_type && @query.possible_types(parent_type).include?(annotation_type)
+              raise ResponseFixtureError, "Expected selection `#{path.join(".")}` to provide a possible type name of `#{parent_type.graphql_name}`"
+            end
+
+            @query.get_type("String")
+          else
+            @query.get_field(parent_type, node.name)&.type
+          end
+          raise ResponseFixtureError, "Invalid selection for `#{parent_type.graphql_name}.#{node.name}`" unless next_type
+
+          result = validate_selections(next_type, node, next_value, path)
+          path.pop
+          result
+
+        when GraphQL::Language::Nodes::InlineFragment
+          resolved_type = resolved_type(parent_type, data_part, path)
+          fragment_type = node.type.nil? ? parent_type : @query.get_type(node.type.name)
+          return true unless @query.possible_types(fragment_type).include?(resolved_type)
+
+          validate_selections(fragment_type, node, data_part, path)
+
+        when GraphQL::Language::Nodes::FragmentSpread
+          resolved_type = resolved_type(parent_type, data_part, path)
+          fragment_def = @query.fragments[node.name]
+          fragment_type = @query.get_type(fragment_def.type.name)
+          return true unless @query.possible_types(fragment_type).include?(resolved_type)
+
+          validate_selections(fragment_type, fragment_def, data_part, path)
+        end
+      end
+    end
+
+    def validate_leaf(parent_type, value, path)
+      valid = if parent_type.kind.enum?
+        parent_type.values.key?(value)
+      elsif parent_type.kind.scalar?
+        validator = @scalar_validators[parent_type.graphql_name]
+        validator.nil? || validator.call(value)
+      end
+
+      unless valid
+        raise ResponseFixtureError, "Expected `#{path.join(".")}` to provide a valid `#{parent_type.graphql_name}` value"
+      end
+      true
+    end
+
+    def resolved_type(parent_type, data_part, path)
+      return parent_type unless parent_type.kind.abstract?
+
+      typename = data_part["__typename"] || data_part[@system_typename]
+      if typename.nil?
+        raise ResponseFixtureError, "Abstract position at `#{path.join(".")}` expects `__typename` or system typename hint"
+      end
+
+      @system_typenames.add(data_part) if data_part.key?(@system_typename)
+      annotated_type = @query.get_type(typename)
+
+      if annotated_type.nil?
+        raise ResponseFixtureError, "Abstract typename `#{typename}` is not a valid type"
+      elsif [email protected]_types(parent_type).include?(annotated_type)
+        raise ResponseFixtureError, "Abstract type `#{typename}` does not belong to `#{parent_type.graphql_name}`"
+      else
+        annotated_type
+      end
+    end
+  end
+end
+
+require_relative "./response_fixture/repository"
+require_relative "./response_fixture/version"

lib/graphql/response_fixture/repository.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class ResponseFixture
+    class Repository
+      def initialize(base_path: "./", scalar_validators: {}, system_typename: SYSTEM_TYPENAME)
+        @base_path = base_path
+        @scalar_validators = SCALAR_VALIDATORS.merge(scalar_validators)
+        @system_typename = system_typename
+      end
+
+      def fetch(fixture_name, query)
+        data = File.read(fixture_file_path(fixture_name))
+        fixture = ResponseFixture.new(
+        query,
+        data,
+        scalar_validators: @scalar_validators,
+        system_typename: @system_typename,
+        )
+        fixture.valid?
+        fixture.prune!
+      end
+
+      def write(fixture_name, data)
+        File.write(fixture_file_path(fixture_name), JSON.generate(data))
+      end
+
+      def fixture_file_path(fixture_name)
+        "#{@base_path}/#{fixture_name}.json"
+      end
+    end
+  end
+end

lib/graphql/response_fixture/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class ResponseFixture
+    VERSION = "0.0.1"
+  end
+end