graphql-autotest 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bdebda4eb82e44a457ec65e9384f1a338311ef74516511f73ec20b4d2cd2e1cc
+  data.tar.gz: 9796606bbf638c223082b7dcb10179cca31f30c19d0e3ffd028ebda1c1250903
+SHA512:
+  metadata.gz: f0de4ae0c8ad47fd05fb75243b95e64e8f8481ff506154d28003e4d2e701428f7151364f768cb6198f2f4a91755b3f11cbcc04ce71937eed2baffe544c2516b7
+  data.tar.gz: fa0ecb913081ac8e642eb83aeb4b6b5ec14baf8c0af8052a74e427407d1970d4056b4fea3f9a50caca9c67b853d40d70e3a7c030a7ec66599be3715b2d8d9216

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Gemfile.lock

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.7.0
+  - 2.6.5
+  - ruby-head

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in graphql-autotest.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem 'minitest', '>= 5'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Bit Journey, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,132 @@
+# GraphQL::Autotest
+
+GraphQL::Autotest tests your GraphQL API with auto-generated queries.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'graphql-autotest'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install graphql-autotest
+
+## Usage
+
+### Generate queries and execute them
+
+```ruby
+require 'graphql/autotest'
+
+class YourSchema < GraphQL::Schema
+end
+
+runner = GraphQL::Autotest::Runner.new(
+  schema: YourSchema,
+  # The context that is passed to GraphQL::Schema.execute
+  context: { current_user: User.first },
+)
+
+# * Generate queries from YourSchema
+# * Then execute the queries
+# * Raise an error if the results contain error(s)
+runner.report!
+```
+
+### Generate queries from `GraphQL::Schema` (not execute)
+
+```ruby
+require 'graphql/autotest'
+
+class YourSchema < GraphQL::Schema
+end
+
+fields = GraphQL::Autotest::QueryGenerator.generate(document: YourSchema.to_document)
+
+# Print all generated queries
+fields.each do |field|
+  puts field.to_query
+end
+```
+
+### Generate queries from file (not execute)
+
+It is useful for non graphql-ruby user.
+
+```ruby
+require 'graphql/autotest'
+
+fields = GraphQL::Autotest::QueryGenerator.from_file(path: 'path/to/definition.graphql')
+
+# Print all generated queries
+fields.each do |field|
+  puts field.to_query
+end
+```
+
+### Configuration
+
+`GraphQL::Autotest::Runner.new`, `GraphQL::Autotest::QueryGenerator.generate` and `GraphQL::Autotest::QueryGenerator.from_file` receives the following arguments to configure how to generates queries.
+
+* `arguments_fetcher`
+  * A proc to fill arguments of the received field.
+  * default: `GraphQL::Autotest::ArgumentsFetcher::DEFAULT`, that allows empty arguments, and arguments that has no required argument.
+  * You need to specify the proc if you need to test field that has required arguments.
+* `max_depth`
+  * Max query depth.
+  * default: 10
+* `skip_if`
+  * A proc to specify field that you'd like to skip to generate query.
+  * default: skip nothing
+
+For example:
+
+```ruby
+require 'graphql/autotest'
+
+class YourSchema < GraphQL::Schema
+end
+
+# Fill `first` argument to reduce result size.
+fill_first = proc do |field|
+  field.arguments.any? { |arg| arg.name == 'first' } && { first: 5 }
+end
+
+# Skip a sensitive field
+skip_if = proc do |field|
+  field.name == 'sensitiveField'
+end
+
+fields = GraphQL::Autotest::QueryGenerator.generate(
+  document: YourSchema.to_document,
+  arguments_fetcher: GraphQL::Autotest::ArgumentsFetcher.combine(
+    fill_first,
+    GraphQL::Autotest::ArgumentsFetcher::DEFAULT,
+  ),
+  max_depth: 5,
+  skip_if: skip_if,
+)
+
+# Print all generated queries
+fields.each do |field|
+  puts field.to_query
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/bitjourney/graphql-autotest.
+

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+task :default => :test
+
+Rake::TestTask.new do |test|
+  test.libs << 'test'
+  test.test_files = Dir['test/**/*_test.rb']
+  test.verbose = true
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "graphql/autotest"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/graphql-autotest.gemspec

@@ -0,0 +1,29 @@
+require_relative 'lib/graphql/autotest/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "graphql-autotest"
+  spec.version       = GraphQL::Autotest::VERSION
+  spec.authors       = ["Masataka Pocke Kuwabara"]
+  spec.email         = ["kuwabara@pocke.me"]
+
+  spec.summary       = %q{Test GraphQL queries automatically}
+  spec.description   = %q{Test GraphQL queries automatically}
+  spec.homepage      = "https://github.com/bitjourney/graphql-autotest"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.license       = 'MIT'
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'graphql'
+end

data/lib/graphql/autotest.rb

@@ -0,0 +1,14 @@
+require 'graphql'
+
+require_relative "autotest/version"
+require_relative "autotest/util"
+require_relative 'autotest/field'
+require_relative 'autotest/arguments_fetcher'
+require_relative 'autotest/report'
+require_relative 'autotest/runner'
+require_relative "autotest/query_generator"
+
+module GraphQL
+  module Autotest
+  end
+end

data/lib/graphql/autotest/arguments_fetcher.rb

@@ -0,0 +1,18 @@
+module GraphQL
+  module Autotest
+    module ArgumentsFetcher
+      def self.combine(*strategy)
+        -> (*args, **kwargs) do
+          strategy.find do |s|
+            r = s.call(*args, **kwargs)
+            break r if r
+          end
+        end
+      end
+
+      EMPTY = -> (field, ancestors:) { field.arguments.empty? && {} }
+      NO_REQUIRED = -> (field, ancestors:) { field.arguments.none? { |arg| Util.non_null?(arg.type) } && {} }
+      DEFAULT = combine(EMPTY, NO_REQUIRED)
+    end
+  end
+end

data/lib/graphql/autotest/field.rb

@@ -0,0 +1,58 @@
+module GraphQL
+  module Autotest
+    class Field < Struct.new(:name, :children, :arguments, keyword_init: true)
+      TYPE_NAME = Field.new(name: '__typename', children: nil)
+
+      def to_query
+        return name unless children
+
+        <<~GRAPHQL
+          #{name}#{arguments_to_query} {
+          #{indent(children_to_query, 2)}
+          }
+        GRAPHQL
+      end
+
+      private def children_to_query
+        sorted_children.map do |child|
+          child.to_query
+        end.join("\n")
+      end
+
+      private def arguments_to_query
+        return unless arguments
+        return if arguments.empty?
+
+        inner = arguments.map do |k, v|
+          "#{k}: #{v}"
+        end.join(', ')
+        "(#{inner})"
+      end
+
+      private def indent(str, n)
+        str.lines(chomp: true).map do |line|
+          if line.empty?
+            ""
+          else
+            " " * n + line
+          end
+        end.join("\n")
+      end
+
+      private def sorted_children
+        children.sort_by { |child| child.sort_key }
+      end
+
+      protected def sort_key
+        [
+          # '__typename' is at the last
+          name == '__typename' ? 1 : 0,
+          # no-children field is at the first
+          children ? 1 : 0,
+          # alphabetical order
+          name,
+        ]
+      end
+    end
+  end
+end

data/lib/graphql/autotest/query_generator.rb

@@ -0,0 +1,77 @@
+module GraphQL
+  module Autotest
+    class QueryGenerator
+      attr_reader :document, :arguments_fetcher, :max_depth, :skip_if
+      private :document, :arguments_fetcher, :max_depth, :skip_if
+
+      def self.from_file(path: nil, content: nil, **kw)
+        raise ArgumentError, "path or content is required" if !path && !content
+
+        content ||= File.read(path)
+        document = GraphQL.parse(content)
+        generate(document: document, **kw)
+      end
+
+      # See Runner#initialize for arguments documentation.
+      def self.generate(document:, arguments_fetcher: ArgumentsFetcher::DEFAULT, max_depth: 10, skip_if: -> (_field, **) { false })
+        self.new(document: document, arguments_fetcher: arguments_fetcher, max_depth: max_depth, skip_if: skip_if).generate
+      end
+
+      def initialize(document:, arguments_fetcher:, max_depth: , skip_if:)
+        @document = document
+        @arguments_fetcher = arguments_fetcher
+        @max_depth = max_depth
+        @skip_if = skip_if
+      end
+
+      def generate
+        query_type = type_definition('Query')
+        testable_fields(query_type)
+      end
+
+      # It returns testable fields as a tree.
+      # "Testable" means that it can fill the arguments.
+      private def testable_fields(type_def, called_fields: Set.new, depth: 0, ancestors: [])
+        return [Field::TYPE_NAME] if depth > max_depth
+
+        type_def.fields.map do |f|
+          next if skip_if.call(f, ancestors: ancestors)
+
+          arguments = arguments_fetcher.call(f, ancestors: ancestors)
+          next unless arguments
+          already_called_key = [type_def, f.name, ancestors.first&.name]
+          next if called_fields.include?(already_called_key) && f.name != 'id'
+
+          called_fields << already_called_key
+
+          field_type = Util.unwrap f.type
+          field_type_def = type_definition(field_type.name)
+
+          case field_type_def
+          when nil, GraphQL::Language::Nodes::EnumTypeDefinition, GraphQL::Language::Nodes::ScalarTypeDefinition
+            Field.new(name: f.name, children: nil, arguments: arguments)
+          when GraphQL::Language::Nodes::UnionTypeDefinition
+            possible_types = field_type_def.types.map do |t|
+              t_def = type_definition(t.name)
+              children = testable_fields(t_def, called_fields: called_fields.dup, depth: depth + 1, ancestors: [f, *ancestors])
+              Field.new(name: "... on #{t.name}", children: children)
+            end
+            Field.new(name: f.name, children: possible_types + [Field::TYPE_NAME], arguments: arguments)
+          else
+            children = testable_fields(field_type_def, called_fields: called_fields.dup, depth: depth + 1, ancestors: [f, *ancestors])
+
+            Field.new(
+              name: f.name,
+              children: children,
+              arguments: arguments,
+            )
+          end
+        end.compact + [Field::TYPE_NAME]
+      end
+
+      private def type_definition(name)
+        document.definitions.find { |f| f.name == name }
+      end
+    end
+  end
+end

data/lib/graphql/autotest/report.rb

@@ -0,0 +1,27 @@
+module GraphQL
+  module Autotest
+    class Report < Struct.new(:executions, keyword_init: true)
+      Execution = Struct.new(:query, :result, keyword_init: true) do
+        def query_summary
+          query.lines[1].strip
+        end
+
+        def to_error_message
+          query_summary + "\n" + result['errors'].inspect
+        end
+      end
+
+      def error?
+        !errored_executions.empty?
+      end
+
+      def errored_executions
+        executions.select { |e| e.result['errors'] }
+      end
+
+      def raise_if_error!
+        raise errored_executions.map(&:to_error_message).join("\n\n") if error?
+      end
+    end
+  end
+end

data/lib/graphql/autotest/runner.rb

@@ -0,0 +1,60 @@
+module GraphQL
+  module Autotest
+    class Runner
+      attr_reader :schema, :context, :arguments_fetcher, :max_depth, :skip_if
+      private :schema, :context, :arguments_fetcher, :max_depth, :skip_if
+
+      # @param schema [Class<GraphQL::Schema>]
+      # @param context [Hash] it passes to GraphQL::Schema.execute
+      # @param arguments_fetcher [Proc] A proc receives a field and ancestors keyword argument, and it returns a Hash. The hash is passed to call the field.
+      # @param max_depth [Integer] Max query depth. It is recommended to specify to avoid too large query.
+      # @param skip_if [Proc] A proc receives a field and ancestors keyword argument, and it returns a boolean. If it returns ture, the field is skipped.
+      def initialize(schema:, context:, arguments_fetcher: ArgumentsFetcher::DEFAULT, max_depth: 10, skip_if: -> (_field, **) { false })
+        @schema = schema
+        @context = context
+        @arguments_fetcher = arguments_fetcher
+        @max_depth = max_depth
+        @skip_if = skip_if
+      end
+
+      def report(dry_run: false)
+        report = Report.new(executions: [])
+
+        fields = QueryGenerator.generate(
+          document: schema.to_document,
+          arguments_fetcher: arguments_fetcher,
+          max_depth: max_depth,
+          skip_if: skip_if,
+        )
+        fields.each do |f|
+          q = f.to_query
+          q = <<~GRAPHQL
+            {
+            #{q.indent(2)}
+            }
+          GRAPHQL
+
+          result = if dry_run
+                     {}
+                   else
+                     schema.execute(
+                       document: GraphQL.parse(q),
+                       variables: {},
+                       operation_name: nil,
+                       context: context,
+                     )
+                   end
+          report.executions << Report::Execution.new(query: q, result: result)
+        end
+
+        report
+      end
+
+      def report!(dry_run: false)
+        report(dry_run: dry_run).tap do |r|
+          r.raise_if_error!
+        end
+      end
+    end
+  end
+end

data/lib/graphql/autotest/util.rb

@@ -0,0 +1,17 @@
+module GraphQL
+  module Autotest
+    module Util
+      extend self
+
+      def non_null?(type)
+        type.is_a?(GraphQL::Language::Nodes::NonNullType)
+      end
+
+      def unwrap(type)
+        return type unless type.respond_to?(:of_type)
+
+        unwrap(type.of_type)
+      end
+    end
+  end
+end

data/lib/graphql/autotest/version.rb

@@ -0,0 +1,5 @@
+module GraphQL
+  module Autotest
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: graphql-autotest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Masataka Pocke Kuwabara
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Test GraphQL queries automatically
+email:
+- kuwabara@pocke.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- graphql-autotest.gemspec
+- lib/graphql/autotest.rb
+- lib/graphql/autotest/arguments_fetcher.rb
+- lib/graphql/autotest/field.rb
+- lib/graphql/autotest/query_generator.rb
+- lib/graphql/autotest/report.rb
+- lib/graphql/autotest/runner.rb
+- lib/graphql/autotest/util.rb
+- lib/graphql/autotest/version.rb
+homepage: https://github.com/bitjourney/graphql-autotest
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/bitjourney/graphql-autotest
+  source_code_uri: https://github.com/bitjourney/graphql-autotest
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.0.pre1
+signing_key: 
+specification_version: 4
+summary: Test GraphQL queries automatically
+test_files: []