trailblazer-test 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02bdfafb7d0c3648980cf33724a89d9954428fbd8466fd0f58df7fe0366b8d25
-  data.tar.gz: 2753cb581aa889d898f5b23bff1daa44e802150e877087d32faf7e3a46357f90
+  metadata.gz: 484e57db55ede663a53082654e62fc6d12b1384b1591718dfc7fc440c59dd86b
+  data.tar.gz: 5595d2f6daab154412e612e226474e1e88592e82ebdc8d8a1cdf8afc1849ae1e
 SHA512:
-  metadata.gz: 9e999f603f7944601d56d17c18e1cbfebe43234fa539e5c7ce9176ca5cf3e1aa2e211bcc1097569b372776020a9b63c6fb86a0f8a350968bea4b0dc755a2eafb
-  data.tar.gz: 4701ebcfbb62202dcac8bbcc13149779c63add90ab9471484f1495a5a3a7ca682ee2e17c9210e8c70543f0707939edb3c4bda9d2de46283a54e9e91e5f0a024f
+  metadata.gz: 302594051f040ca9c3570ac2316cfb5c0a511814727fffc74727b9b2bd0d2adea2ee56a7037406af11c02c93b5c6fa91e7a0a28517352db72c2f6e99949b60c7
+  data.tar.gz: a510c4907ace3ba13e59872d698c8771705bd3047072e3296141381a9c0281ce36bae05759038052dc98a2e0e3421b8e5d3dae9ce28dc4249dab3289367e4ba0

data/.travis.yml

@@ -1,6 +1,5 @@
 language: ruby
-before_install:
-  - gem install bundler
+cache: bundler
 matrix:
   include:
     - rvm: 2.1
@@ -13,4 +12,3 @@ matrix:
       gemfile: Gemfile
     - rvm: 2.5.0
       gemfile: Gemfile
-      script: bundle exec rake test && rake rubocop

data/CHANGES.md

@@ -1,3 +1,7 @@
+# 0.1.1
+
+* Added `mock_step` helper to mock activity's or nested activity's step
+
 # 0.1.0
 
 * `ctx` and `params` helper methods implemented

data/README.md

@@ -3,25 +3,19 @@
 [![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:
+## Usage
 
-    $ bundle
+Testing Trailblazer applications usually involves the following tests.
 
-Or install it yourself as:
+1. **Unit tests for operations**: They test all edge cases in a nice, fast unit test environment without any HTTP involved.
+2. **Integration tests for controllers**: These Smoke tests only test the wiring between controller, operation and presentation   layer. Usually, a coded click path simulates you manually clicking through your app and testing if it works. The preferred way    here is using Rack-test and Capybara.
+3. **Unit tests for cells** By invoking your cells with arbitrary data you functionally test the rendered markup using Capybara.
 
-    $ gem install trailblazer-test
+All the up to date details on the available assertions and helpers is available at [official documentation](http://2019.trailblazer.to/2.1/docs/trailblazer.html#trailblazer-test).
 
-## Usage
+### Assertions
 
-Add in your test `_helper` the following modules:
+To use available assertions, add in your test `_helper` the following modules:
 
 ```ruby
 include Trailblazer::Test::Assertions
@@ -36,176 +30,111 @@ 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)`
+[Learn more](http://2019.trailblazer.to/2.1/docs/trailblazer.html#trailblazer-test-assertions)
 
-Those will merge params and options for you and return the final inputs which then can be passed to the operation under testing.
+#### assert_pass
 
-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`.
+Use `assert_pass` to run an operation and assert it was successful, while checking if the attributes of the operation's `model` are what you're expecting.
 
 ```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' } }
+it { assert_pass Blog::Operation::Create, { params: { title: "Ruby Soho" } }, title: "Ruby Soho" }
 ```
 
-#### ctx
+#### assert_fail
 
-`ctx` accepts 2 arguments, first one will be merged into the `default_params` and the second one will be merged into `default_options`
+To test an unsuccessful outcome of an operation, use `assert_fail`. This is used for testing all kinds of validations. By passing insufficient or wrong data to the operation, it will fail and mark errors on the errors object.
 
 ```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' }
+it { assert_fail Blog::Operation::Update, { params: { band: nil } }, expected_errors: [:band] }
 ```
 
-### assert_pass
+#### assert_policy_fail
 
-```ruby
-assert_pass(operation, ctx, expected_attributes)
-```
+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} }
-let(:expected_attrs) { { band: 'The Chats'} }
-
-it { assert_pass MyOp, ctx(title: 'Smoko'), title: 'Smoko' }
+it { assert_policy_fail Blog::Operation::Delete, ctx({title: "Ruby Soho"}, current_user: not_allowed_user) }
 ```
 
-Pass `deep_merge: false` to disable the deep merging of the third argument `expected_attributes` and the auxiliary method `expected_attrs`.
+#### assert_exposes
 
-It's also possible to test in a more detailed way using a block:
+Test attributes of an arbitrary object.
 
 ```ruby
-assert_pass MyOp, ctx(title: 'Smoko'), {} do |result|
-  assert_equal "Smoko", result[:model].title
-end
+it { assert_exposes model, title: "Timebomb", band: "Rancid" }
 ```
 
-### assert_fail
+### Helpers
 
-```ruby
-assert_fail(operation, ctx)
-```
+There are several helpers to deal with operation tests and operations used as factories.
+Add this in your `_helper.rb` file to use all available helpers.
 
-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') }
+include Trailblazer::Test::Operation::Helper
 ```
 
-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:
+[Learn more](http://2019.trailblazer.to/2.1/docs/trailblazer.html#trailblazer-test-helpers)
 
-```ruby
-assert_fail MyOp, ctx(band: 'Justing Beaver'), expected_errors: [:band] # definitely wrong!!!!
-```
+#### call
 
-Using the block here will allow to test the error message:
+Instead of manually invoking an operation, you can use the `call` helper.
 
 ```ruby
-assert_fail MyOp, ctx(band: 'Justing Beaver') do |result|
-  assert_equal 'You cannot listen Justing Beaver', result['contract.default'].errors.messages[:band]
+it do
+  result = call Blog::Operation::Create, params: {title: "Shipwreck", band: "Rancid"}
+  # use `result` object however you want
 end
 ```
 
-Change contract name using `contract_name`.
-
-*We will improve this part and allowing to the test message directly without using a block*
-
+#### factory
 
-### assert_policy_fail
+The `factory` method calls the operation and raises an error should the operation have failed. If successful, it will do the exact same thing `call` does.
 
-Add this in your test file to be able to use it:
 ```ruby
-include Trailblazer::Test::Operation::PolicyAssertions
+it do
+  assert_raises do
+    factory Blog::Operation::Create, params: {title: "Shipwreck", band: "The Chats"}
+  end
+end
 ```
 
-```ruby
-assert_policy_fail(operation, ctx)
-```
+#### mock_step
 
-This will test that the operation fails due to a policy failure.
+This helper allows you to mock any step within a given or deeply nested activities. For example,
 
-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) }
+class Show < Trailblazer::Operation
+  step :load_user
+  ...
+end
 ```
-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`:
+To skip processing inside `:load_user` and use a mock instead, use `mock_step`.
 
 ```ruby
-include Trailblazer::Test::Operation::Helper
+it do
+  new_activity = mock_step(Show, id: :load_user) do |ctx|
+    ctx[:user] = Struct.new(:name).new('Mocky')
+  end
+
+  assert_pass new_activity, {}, {} do |ctx|
+    assert_equal ctx[:user].name, 'Mocky'
+  end
+end
 ```
 
-In case you use are Trailblazer v2.0, you need to add this instead:
+## Installation
 
-```ruby
-require "trailblazer/test/deprecation/operation/helper"
+Add this line to your application's Gemfile:
 
-include Trailblazer::Test::Deprecation::Operation::Helper
+```ruby
+gem 'trailblazer-test'
 ```
 
-*Same API for both Trailblazer v2.0 and v2.1*
+And then execute:
 
-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
+    $ bundle
 
-# factory - this will raise an error if User::Create fails
-let(:user) { factory(User::Create, params: params)[:model] }
+Or install it yourself as:
 
-# 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
-```
+    $ gem install trailblazer-test

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

@@ -8,6 +8,22 @@ module Trailblazer::Test::Operation
       call!(operation_class, args.merge(raise_on_failure: true), &block)
     end
 
+    def mock_step(operation_class, id:, subprocess: nil, subprocess_path: nil)
+      raise ArgumentError, "Missing block: `mock_step` requires a block." unless block_given?
+
+      block = ->(ctx, **) { yield(ctx) }
+
+      # If deeply nested step needs to be mocked, use the `patch` provided by Subprocess
+      if subprocess
+        return Class.new(operation_class) do
+          patch = { subprocess_path => ->() { step block, replace: id, id: id } }
+          step Subprocess(subprocess, patch: patch), replace: subprocess, id: subprocess
+        end
+      end
+
+      Class.new(operation_class) { step block, replace: id, id: id }
+    end
+
     # @private
     def call!(operation_class, raise_on_failure: false, **args)
       operation_class.trace(**args).tap do |result|

data/lib/trailblazer/test/version.rb

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

data/trailblazer-test.gemspec

@@ -21,9 +21,12 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "hashie"
 
-  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rubocop"
   spec.add_development_dependency "simplecov"
+
+  spec.add_dependency "trailblazer-activity", ">= 0.10.0"
+  spec.add_dependency "trailblazer-activity-dsl-linear", ">= 0.2.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-test
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-02 00:00:00.000000000 Z
+date: 2020-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -28,16 +28,16 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +94,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: trailblazer-activity
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: trailblazer-activity-dsl-linear
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.5
 description: Assertions, matchers, and helpers to test Trailblazer code.
 email:
 - apotonick@gmail.com
@@ -136,8 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Assertions, matchers, and helpers to test Trailblazer code.