trailblazer-test 0.1.1 → 1.0.0

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

@@ -1,42 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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
-
-    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|
-        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

@@ -1,13 +0,0 @@
-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