trailblazer-test 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 02bdfafb7d0c3648980cf33724a89d9954428fbd8466fd0f58df7fe0366b8d25
+  data.tar.gz: 2753cb581aa889d898f5b23bff1daa44e802150e877087d32faf7e3a46357f90
+SHA512:
+  metadata.gz: 9e999f603f7944601d56d17c18e1cbfebe43234fa539e5c7ce9176ca5cf3e1aa2e211bcc1097569b372776020a9b63c6fb86a0f8a350968bea4b0dc755a2eafb
+  data.tar.gz: 4701ebcfbb62202dcac8bbcc13149779c63add90ab9471484f1495a5a3a7ca682ee2e17c9210e8c70543f0707939edb3c4bda9d2de46283a54e9e91e5f0a024f

data/.gitignore

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

data/.rubocop-https---raw-githubusercontent-com-trailblazer-meta-master-rubocop-yml

@@ -0,0 +1,115 @@
+AllCops:
+  TargetRubyVersion: 2.5.0
+  DisplayCopNames: true
+Layout/CaseIndentation:
+  IndentOneStep: true
+Layout/FirstArrayElementLineBreak:
+  Enabled: true
+Layout/FirstHashElementLineBreak:
+  Enabled: true
+Layout/FirstMethodArgumentLineBreak:
+  Enabled: true
+Layout/FirstMethodParameterLineBreak:
+  Enabled: true
+Layout/MultilineAssignmentLayout:
+  Enabled: true
+  EnforcedStyle: same_line
+Layout/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+Metrics/LineLength:
+  Max: 130
+Metrics/ParameterLists:
+  Max: 5
+Naming/VariableNumber:
+  EnforcedStyle: snake_case
+Style/AndOr:
+  EnforcedStyle: conditionals
+Style/AutoResourceCleanup:
+  Enabled: true
+Style/CollectionMethods:
+  Enabled: true
+Style/Documentation:
+  Enabled: false
+Style/EmptyLiteral:
+  Enabled: false
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+Style/FormatStringToken:
+  EnforcedStyle: template
+Style/ImplicitRuntimeError:
+  Enabled: true
+Style/MethodCalledOnDoEndBlock:
+  Enabled: true
+Style/MethodDefParentheses:
+  EnforcedStyle: require_parentheses
+Style/MissingElse:
+  Enabled: true
+  EnforcedStyle: case
+Style/NumericLiterals:
+  Enabled: false
+Style/OptionHash:
+  Enabled: true
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    "%w": "[]"
+    "%W": "[]"
+    "%i": "[]"
+    "%I": "[]"
+    "%r": "()"
+Style/ReturnNil:
+  Enabled: true
+Style/SafeNavigation:
+  Enabled: false
+Style/Send:
+  Enabled: true
+Style/SignalException:
+  EnforcedStyle: semantic
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+Style/StringMethods:
+  Enabled: true
+Style/SymbolArray:
+  Enabled: true
+# this allows in rspec to have expect { } with multiple lines
+Style/BlockDelimiters:
+  EnforcedStyle: braces_for_chaining
+Layout/EndOfLine:
+  Enabled: false
+# don't need these checks in test folders
+Metrics/ModuleLength:
+  Exclude:
+    - "spec/**/*"
+    - "test/**/*"
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*"
+    - "test/**/*"
+    - "*.gemspec" # definitely not in the gemspec
+Metrics/MethodLength:
+  Max: 20
+Lint/UnreachableCode:
+  Description: 'Unreachable code.'
+  Enabled: false
+Lint/Void:
+  Enabled: false
+Layout/AlignHash:
+  EnforcedLastArgumentHashStyle: ignore_implicit
+Metrics/AbcSize:
+  Max: 25
+Style/LambdaCall:
+  Enabled: false
+Style/Semicolon:
+  Enabled: false
+Naming/UncommunicativeMethodParamName:
+  Enabled: false
+Style/ClassAndModuleChildren:
+  Enabled: false
+Layout/LeadingCommentSpace:
+  Exclude:
+    - 'test/docs/**/*'
+Layout/AlignHash:
+  EnforcedHashRocketStyle: table
+Style/FrozenStringLiteralComment:
+  Enabled: false

data/.rubocop.yml

@@ -0,0 +1,17 @@
+inherit_from:
+  - https://raw.githubusercontent.com/trailblazer/meta/master/rubocop.yml
+
+Style/SignalException:
+  Exclude:
+    - lib/trailblazer/test/operation/assertions.rb
+    - lib/trailblazer/test/operation/helper.rb
+    - lib/trailblazer/test/deprecation/operation/helper.rb
+
+Metrics/ParameterLists:
+  Exclude:
+    - lib/trailblazer/test/operation/assertions.rb
+
+Metrics/LineLength:
+  Exclude:
+    - lib/trailblazer/test/operation/assertions.rb
+

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+before_install:
+  - gem install bundler
+matrix:
+  include:
+    - rvm: 2.1
+      gemfile: Gemfile
+    - rvm: 2.2
+      gemfile: Gemfile
+    - rvm: 2.3.1
+      gemfile: Gemfile
+    - rvm: 2.4.1
+      gemfile: Gemfile
+    - rvm: 2.5.0
+      gemfile: Gemfile
+      script: bundle exec rake test && rake rubocop

data/CHANGES.md

@@ -0,0 +1,8 @@
+# 0.1.0
+
+* `ctx` and `params` helper methods implemented
+* `call` and `factory` improved
+* auxiliary methods renamed:
+  * `params_pass` -> `default_params`
+  * `options_pass` -> `default_options`
+  * `attr_pass` -> `expected_attrs`

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in trailblazer-test.gemspec
+gemspec

data/README.md

@@ -0,0 +1,211 @@
+# Trailblazer::Test
+
+[![Build Status](https://travis-ci.org/trailblazer/trailblazer-test.svg)](https://travis-ci.org/trailblazer/trailblazer-test)
+[![Gem Version](https://badge.fury.io/rb/trailblazer-test.svg)](http://badge.fury.io/rb/trailblazer-test)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'trailblazer-test'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install trailblazer-test
+
+## Usage
+
+Add in your test `_helper` the following modules:
+
+```ruby
+include Trailblazer::Test::Assertions
+include Trailblazer::Test::Operation::Assertions
+```
+
+If you are using Trailblazer v2.0 you need to add also:
+
+```ruby
+require "trailblazer/test/deprecation/operation/assertions"
+
+include Trailblazer::Test::Deprecation::Operation::Assertions # in your test class
+```
+
+To be able to test an operation we need 3 auxiliary methods which have to be defined at the start of your tests:
+* `default_params` (**required**): hash of params which will be always passed to the operation unless overriden by `params` or `ctx`
+* `expected_attrs` (**required**): hash always used to assert model attributes
+* `default_options` (**required if using `ctx`**): hash of options which will be always passed to the operation unless overriden by `ctx`
+
+We are also providing 2 helper methods:
+* `params(new_params)`
+* `ctx(new_params, options)`
+
+Those will merge params and options for you and return the final inputs which then can be passed to the operation under testing.
+
+Pass `deep_merge: false` to the helper methods to disable the default deep merging of params and options.
+
+*Same API for Trailblazer v2.0 and v2.1.*
+
+Finally, using the built-in assertions you are able to test your operations in a fast and easy way:
+* `assert_pass` -> your operation is successful and model has the correct attributes
+* `assert_fail` -> your operation fails and returns some specific errors
+* `assert_policy_fail` -> your operation fails because policy fails
+
+#### params
+
+`params` accepts one argument which is merged into `default_params`.
+
+```ruby
+let(:default_params) { { title: 'My title' } }
+
+params(artist: 'My Artist') -> { params: { title: 'My title', artist: 'My Artist' } }
+params(title: 'Other one') -> { params: { title: 'Other one' } }
+```
+
+#### ctx
+
+`ctx` accepts 2 arguments, first one will be merged into the `default_params` and the second one will be merged into `default_options`
+
+```ruby
+let(:default_params)  { { title: 'My title' } }
+let(:default_options) { { current_user: 'me' } }
+
+ctx(artist: 'My Artist') -> { params: { title: 'My title', artist: 'My Artist' }, current_user: 'me' }
+ctx({title: 'Other one'}, current_user: 'you') -> { params: { title: 'Other one' }, current_user: 'you' }
+```
+
+### assert_pass
+
+```ruby
+assert_pass(operation, ctx, expected_attributes)
+```
+
+Example:
+```ruby
+let(:default_params) { { band: 'The Chats'} }
+let(:default_options) { { current_user: user} }
+let(:expected_attrs) { { band: 'The Chats'} }
+
+it { assert_pass MyOp, ctx(title: 'Smoko'), title: 'Smoko' }
+```
+
+Pass `deep_merge: false` to disable the deep merging of the third argument `expected_attributes` and the auxiliary method `expected_attrs`.
+
+It's also possible to test in a more detailed way using a block:
+
+```ruby
+assert_pass MyOp, ctx(title: 'Smoko'), {} do |result|
+  assert_equal "Smoko", result[:model].title
+end
+```
+
+### assert_fail
+
+```ruby
+assert_fail(operation, ctx)
+```
+
+Example:
+```ruby
+let(:default_params) { { band: 'The Chats'} }
+let(:default_options) { { current_user: user} }
+let(:expected_attrs) { { band: 'The Chats'} }
+
+it { assert_fail MyOp, ctx(title: 'Smoko') }
+```
+
+This will just test that the operation fails instead passing `expected_errors` as an array of symbols will also test that specific attribute has an error:
+
+```ruby
+assert_fail MyOp, ctx(band: 'Justing Beaver'), expected_errors: [:band] # definitely wrong!!!!
+```
+
+Using the block here will allow to test the error message:
+
+```ruby
+assert_fail MyOp, ctx(band: 'Justing Beaver') do |result|
+  assert_equal 'You cannot listen Justing Beaver', result['contract.default'].errors.messages[:band]
+end
+```
+
+Change contract name using `contract_name`.
+
+*We will improve this part and allowing to the test message directly without using a block*
+
+
+### assert_policy_fail
+
+Add this in your test file to be able to use it:
+```ruby
+include Trailblazer::Test::Operation::PolicyAssertions
+```
+
+```ruby
+assert_policy_fail(operation, ctx)
+```
+
+This will test that the operation fails due to a policy failure.
+
+Example:
+```ruby
+let(:default_params) { { band: 'The Chats'} }
+let(:default_options) { { current_user: user} }
+
+it { assert_policy_fail MyOp, ctx({title: 'Smoko'}, current_user: another) }
+```
+Change policy name using `policy_name`.
+
+## Test Setup
+
+It is obviously crucial to test your operation in the correct test enviroment calling operation instead of using `FactoryBot` or simply `Model.create`.
+
+To do so we provide 2 helper methods:
+* `call`: will call the operation and **will not raise** an error in case of failure
+* `factory`: will call the operation and **will raise** an error in case of failure returning also the trace and a validate error message in case exists
+
+### Usage
+
+Add this in your test `_helper.rb`:
+
+```ruby
+include Trailblazer::Test::Operation::Helper
+```
+
+In case you use are Trailblazer v2.0, you need to add this instead:
+
+```ruby
+require "trailblazer/test/deprecation/operation/helper"
+
+include Trailblazer::Test::Deprecation::Operation::Helper
+```
+
+*Same API for both Trailblazer v2.0 and v2.1*
+
+Examples:
+```ruby
+# call
+let(:user) { call(User::Create, params: params)[:model] }
+
+# call with block
+let(:user) do
+  call User::Create, params: params do |result|
+    # run some code to reproduce some async jobs (for example)
+  end[:model]
+end
+
+# factory - this will raise an error if User::Create fails
+let(:user) { factory(User::Create, params: params)[:model] }
+
+# factory - this will raise an error if User::Create fails
+let(:user) do
+  factory User::Create, params: params do |result|
+    # this block will be yield only if User::Create is successful
+    # run some code to reproduce some async jobs (for example)
+  end[:model]
+end
+```

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new(:rubocop)
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/lib/trailblazer/test.rb

@@ -0,0 +1,12 @@
+require "trailblazer/test/version"
+
+module Trailblazer
+  module Test
+    # Your code goes here...
+  end
+end
+
+require "trailblazer/test/assertions"
+require "trailblazer/test/operation/helper"
+require "trailblazer/test/operation/assertions"
+require "trailblazer/test/operation/policy_assertions"

data/lib/trailblazer/test/assertions.rb

@@ -0,0 +1,37 @@
+# module MiniTest::Assertions
+module Trailblazer
+  module Test
+    # Evaluate value if it's a lambda, and let the caller know whether we need an
+    # assert_equal or an assert.
+    def self.expected(asserted, value, actual)
+      value.is_a?(Proc) ? [value.(actual: actual, asserted: asserted), false] : [value, true]
+    end
+
+    # Read the actual value from the asserted object (e.g. a model).
+    def self.actual(asserted, reader, name)
+      reader ? asserted.public_send(reader, name) : asserted.public_send(name)
+    end
+
+    module Assertions
+      module_function
+
+      # tuples = defaults.merge(overrides) # FIXME: merge with above!
+
+      # Test if all `tuples` values on `asserted` match the expected values.
+      # @param asserted Object Object that exposes attributes to test
+      # @param tuples Hash Key/value attribute pairs to test
+      # @param options Hash Default :reader is `asserted.{name}`,
+      # TODO: test err msgs!
+      def assert_exposes(asserted, tuples, reader: nil)
+        tuples.each do |k, v|
+          actual          = Test.actual(asserted, reader, k)
+          expected, is_eq = Test.expected(asserted, v, actual)
+
+          is_eq ? assert_equal(expected, actual, "Property [#{k}] mismatch") : assert(expected, "Actual: #{actual.inspect}.")
+        end
+      end
+    end
+  end
+end
+# Trailblazer::Operation::Result.infect_an_assertion :assert_result_matches, :must_match, :do_not_flip
+# Object.infect_an_assertion :assert_exposes, :must_expose, :do_not_flip

data/lib/trailblazer/test/deprecation/operation/assertions.rb

@@ -0,0 +1,42 @@
+module Trailblazer::Test
+  module Deprecation
+    module Operation
+      module Assertions
+        include Trailblazer::Test::Operation::Assertions
+
+        # @needs default_params
+        # @needs default_options
+
+        def params(default_params: self.default_params, deep_merge: true, **new_params)
+          [merge_for(default_params, new_params, deep_merge), {}]
+        end
+
+        def ctx(new_params, *options)
+          # need *options to allow user to do something like:
+          # ctx({yeah: 'nah'}, "current_user" => Object, some: 'other' )
+
+          # this is not greate but seems necessary using *options
+          new_options = options.first || {}
+          deep_merge = new_options[:deep_merge].nil? ? true : deep_merge
+          new_options.delete(:deep_merge)
+
+          ctx = merge_for(_default_options, options.first || {}, deep_merge)
+          [merge_for(params[0], new_params, deep_merge), ctx]
+        end
+
+        def _default_options(options: default_options)
+          options
+        end
+
+        # compatibility call for TRB 2.0
+        def _call_operation(operation_class, *args)
+          operation_class.(args[0][0], args[0][1])
+        end
+
+        def _model(result)
+          result["model"]
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/test/deprecation/operation/helper.rb

@@ -0,0 +1,28 @@
+module Trailblazer::Test
+  module Deprecation
+    module Operation
+      module Helper
+        def call(operation_class, *args, &block)
+          call!(operation_class, args, &block)
+        end
+
+        def factory(operation_class, *args, &block)
+          call!(operation_class, args, raise_on_failure: true, &block)
+        end
+
+        # @private
+        def call!(operation_class, args, raise_on_failure: false)
+          operation_class.(*args).tap do |result|
+            unless result.success?
+              yield result if block_given?
+
+              raise OperationFailedError, "factory(#{operation_class}) failed." if raise_on_failure
+            end
+          end
+        end
+      end
+    end
+
+    class OperationFailedError < RuntimeError; end
+  end
+end

data/lib/trailblazer/test/operation/assertions.rb

@@ -0,0 +1,89 @@
+require "hashie"
+
+module Trailblazer::Test::Operation
+  module Assertions
+    # @needs default_params
+    # @needs default_options
+    # @needs expected_attrs
+
+    def params(default_params: self.default_params, deep_merge: true, **new_params)
+      {params: merge_for(default_params, new_params, deep_merge)}
+    end
+
+    def ctx(new_params, default_options: self.default_options, deep_merge: true, **options)
+      new_params  = merge_for(params[:params], new_params, deep_merge)
+      new_options = merge_for(default_options, options, deep_merge)
+
+      {params: new_params, **new_options}
+    end
+
+    def assert_pass(operation_class, operation_inputs, expected_attributes, default_attributes: expected_attrs, deep_merge: true, &block)
+      expected_attributes = merge_for(default_attributes, expected_attributes, deep_merge)
+
+      assert_pass_with_model(operation_class, operation_inputs, expected_model_attributes: expected_attributes, &block)
+    end
+
+    def assert_fail(operation_class, operation_inputs, expected_errors: nil, contract_name: "default", &block)
+      assert_fail_with_model(operation_class, operation_inputs, expected_errors: expected_errors, contract_name: contract_name, &block)
+    end
+
+    # @private
+    # TODO: test expected_attributes default param and explicit!
+    def assert_pass_with_model(operation_class, operation_inputs, expected_model_attributes: {}, &user_block)
+      _assert_call(operation_class, operation_inputs, user_block: user_block) do |result|
+        assert_equal true, result.success?
+        assert_exposes(_model(result), expected_model_attributes)
+      end
+    end
+
+    # @private
+    def assert_fail_with_model(operation_class, operation_inputs, expected_errors: nil, contract_name: raise, &user_block)
+      _assert_call(operation_class, operation_inputs, user_block: user_block) do |result|
+        assert_equal true, result.failure?
+
+        raise ExpectedErrorsTypeError, "expected_errors has to be an Array" unless expected_errors.is_a?(Array)
+
+        # only test _if_ errors are present, not the content.
+        errors = result["contract.#{contract_name}"].errors.messages # TODO: this will soon change with the operation Errors object.
+
+        assert_equal expected_errors.sort, errors.keys.sort
+      end
+    end
+
+    # @private
+    def _assert_call(operation_class, operation_inputs, user_block: raise)
+      result = _call_operation(operation_class, operation_inputs)
+
+      return user_block.call(result) if user_block # DISCUSS: result or model?
+
+      yield(result)
+
+      result
+    end
+
+    # @private
+    class ExpectedErrorsTypeError < RuntimeError; end
+
+    # @private
+    class CtxHash < Hash
+      include Hashie::Extensions::DeepMerge
+    end
+
+    # @private
+    def merge_for(dest, source, deep_merge)
+      return dest.merge(source) unless deep_merge
+
+      CtxHash[dest].deep_merge(CtxHash[source])
+    end
+
+    # @private
+    def _call_operation(operation_class, operation_inputs)
+      operation_class.(operation_inputs)
+    end
+
+    # @private
+    def _model(result)
+      result[:model]
+    end
+  end
+end

data/lib/trailblazer/test/operation/helper.rb

@@ -0,0 +1,38 @@
+module Trailblazer::Test::Operation
+  module Helper
+    def call(operation_class, **args, &block)
+      call!(operation_class, args, &block)
+    end
+
+    def factory(operation_class, **args, &block)
+      call!(operation_class, args.merge(raise_on_failure: true), &block)
+    end
+
+    # @private
+    def call!(operation_class, raise_on_failure: false, **args)
+      operation_class.trace(**args).tap do |result|
+        unless result.success?
+
+          msg = "factory(#{operation_class}) has failed"
+
+          unless result["contract.default"].nil? # should we allow to change contract name?
+            if result["contract.default"].errors.messages.any?
+              msg += " due to validation errors: #{result["contract.default"].errors.messages}"
+            end
+          end
+
+          if raise_on_failure
+            result.wtf?
+            raise OperationFailedError, msg
+          end
+        end
+
+        yield result if block_given?
+
+        result
+      end
+    end
+
+    class OperationFailedError < RuntimeError; end
+  end
+end

data/lib/trailblazer/test/operation/policy_assertions.rb

@@ -0,0 +1,13 @@
+module Trailblazer::Test::Operation
+  module PolicyAssertions
+    include Assertions
+    # @needs params_pass
+    # @needs options_pass
+    def assert_policy_fail(operation_class, ctx, policy_name: "default")
+      _assert_call(operation_class, ctx, user_block: nil) do |result|
+        assert_equal true, result.failure?
+        assert_equal true, result["result.policy.#{policy_name}"].failure?
+      end
+    end
+  end
+end

data/lib/trailblazer/test/version.rb

@@ -0,0 +1,5 @@
+module Trailblazer
+  module Test
+    VERSION = "0.1.0".freeze
+  end
+end

data/trailblazer-test.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "trailblazer/test/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "trailblazer-test"
+  spec.version       = Trailblazer::Test::VERSION
+  spec.authors       = ["Nick Sutterer"]
+  spec.email         = ["apotonick@gmail.com"]
+
+  spec.summary       = "Assertions, matchers, and helpers to test Trailblazer code."
+  spec.description   = "Assertions, matchers, and helpers to test Trailblazer code."
+  spec.homepage      = "http://trailblazer.to"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |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_dependency "hashie"
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "simplecov"
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: trailblazer-test
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nick Sutterer
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashie
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Assertions, matchers, and helpers to test Trailblazer code.
+email:
+- apotonick@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop-https---raw-githubusercontent-com-trailblazer-meta-master-rubocop-yml"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGES.md
+- Gemfile
+- README.md
+- Rakefile
+- lib/trailblazer/test.rb
+- lib/trailblazer/test/assertions.rb
+- lib/trailblazer/test/deprecation/operation/assertions.rb
+- lib/trailblazer/test/deprecation/operation/helper.rb
+- lib/trailblazer/test/operation/assertions.rb
+- lib/trailblazer/test/operation/helper.rb
+- lib/trailblazer/test/operation/policy_assertions.rb
+- lib/trailblazer/test/version.rb
+- trailblazer-test.gemspec
+homepage: http://trailblazer.to
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Assertions, matchers, and helpers to test Trailblazer code.
+test_files: []