much-result 0.1.0

data/lib/much-result/aggregate.rb

@@ -0,0 +1,57 @@
+require "much-result"
+
+class MuchResult; end
+class MuchResult::Aggregate
+  def self.call(values)
+    new(values).call
+  end
+
+  def initialize(values)
+    @values = values
+  end
+
+  def call
+    combine_values(@values)
+  end
+
+  private
+
+  def combine_values(values)
+    combine_in_a_collection(array_wrap(values))
+  end
+
+  def combine_in_a_collection(values)
+    if all_hash_values?(values)
+      values.
+        reduce { |acc, value| combine_in_a_hash(acc, value) }.
+        transform_values { |nested_values| combine_values(nested_values) }
+    else
+      array_wrap(
+        values.reduce([]) { |acc, value| combine_in_an_array(acc, value) }
+      )
+    end
+  end
+
+  def combine_in_a_hash(hash1, hash2)
+    ((h1 = hash1 || {}).keys + (h2 = hash2 || {}).keys).
+      uniq.
+      reduce({}) { |hash, key|
+        hash[key] = combine_in_an_array(h1[key], h2[key])
+        hash
+      }
+  end
+
+  def combine_in_an_array(acc, other)
+    array_wrap(acc) + array_wrap(other)
+  end
+
+  def array_wrap(value)
+    value.kind_of?(Array) ? value : [value]
+  end
+
+  def all_hash_values?(values)
+    (compacted = values.compact).reduce(compacted.any?) { |acc, value|
+      acc && value.kind_of?(::Hash)
+    }
+  end
+end

data/lib/much-result/transaction.rb

@@ -0,0 +1,56 @@
+require "much-result"
+
+class MuchResult; end
+class MuchResult::Transaction
+  def self.halt_throw_value
+    :muchresult_transaction_halt
+  end
+
+  def self.call(receiver, **result_kargs, &block)
+    new(receiver, **result_kargs).call(&block)
+  end
+
+  def initialize(receiver, **result_kargs)
+    @receiver = receiver
+    @result_kargs = result_kargs
+
+    result.much_result_transaction_rolled_back = false
+    result.much_result_transaction_halted = false
+  end
+
+  def result
+    @result ||= MuchResult.success(**@result_kargs)
+  end
+
+  def call(&block)
+    begin
+      @receiver.transaction do
+        catch(self.class.halt_throw_value) { block.call(self) }
+      end
+    rescue MuchResult::Rollback
+      # do nothing
+    end
+
+    result
+  end
+
+  def rollback
+    result.much_result_transaction_rolled_back = true
+    raise MuchResult::Rollback
+  end
+
+  def halt
+    result.much_result_transaction_halted = true
+    throw(self.class.halt_throw_value)
+  end
+
+  private
+
+  def respond_to_missing?(*args)
+    result.send(:respond_to_missing?, *args)
+  end
+
+  def method_missing(method, *args, &block)
+    result.public_send(method, *args, &block)
+  end
+end

data/lib/much-result/version.rb

@@ -0,0 +1,3 @@
+class MuchResult
+  VERSION = "0.1.0"
+end

data/much-result.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "much-result/version"
+
+Gem::Specification.new do |gem|
+  gem.name        = "much-result"
+  gem.version     = MuchResult::VERSION
+  gem.authors     = ["Kelly Redding", "Collin Redding"]
+  gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
+  gem.summary     = "API for managing the results of operations."
+  gem.description = "API for managing the results of operations."
+  gem.homepage    = "https://github.com/redding/much-result"
+  gem.license     = "MIT"
+
+  gem.files         = `git ls-files | grep "^[^.]"`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.required_ruby_version = "~> 2.5"
+
+  gem.add_development_dependency("assert", ["~> 2.18.4"])
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+# this file is automatically required when you run `assert`
+# put any test helpers here
+
+# add the root dir to the load path
+$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
+
+# require pry for debugging (`binding.pry`)
+require "pry"
+
+require "test/support/factory"

data/test/support/factory.rb

@@ -0,0 +1,42 @@
+require "assert/factory"
+require "much-stub/call"
+
+module Factory
+  extend Assert::Factory
+
+  def self.value
+    [Factory.integer, Factory.string, Object.new].sample
+  end
+
+  def self.hash_value(with_nested_hash = true)
+    {
+      value1: Factory.value,
+      value2: with_nested_hash ? Factory.hash_value(false) : Factory.value
+    }
+  end
+
+  def self.backtrace
+    Factory.integer(3).times.map{ Factory.path }
+  end
+
+  def self.transaction_receiver
+    FakeTransactionReceiver.new
+  end
+
+  class FakeTransactionReceiver
+    attr_reader :last_transaction_call
+
+    def transaction(&block)
+      @rolled_back = false
+      @last_transaction_call = MuchStub::Call.new(&block)
+      block.call
+    rescue => exception
+      @rolled_back = true
+      raise exception
+    end
+
+    def rolled_back?
+      !!@rolled_back
+    end
+  end
+end

data/test/unit/aggregate_tests.rb

@@ -0,0 +1,103 @@
+require "assert"
+require "much-result/aggregate"
+
+class MuchResult::Aggregate
+  class UnitTests < Assert::Context
+    desc "MuchResult::Aggregate"
+    subject { unit_class }
+
+    let(:unit_class) { MuchResult::Aggregate }
+
+    let(:values1) {
+      [Factory.value, Factory.value, Factory.value, Hash.new]
+    }
+    let(:hash_values1) {
+      [Factory.hash_value, Factory.hash_value, Factory.hash_value]
+    }
+
+    should have_imeths :call
+
+    should "build instances and call them" do
+      Assert.stub_tap_on_call(subject, :new) { |instance, call|
+        @instance_new_call = call
+        Assert.stub(instance, :call) { @instance_called = true }
+      }
+
+      subject.call(values1)
+
+      assert_that(@instance_new_call.args).equals([values1])
+      assert_that(@instance_called).is_true
+    end
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject { unit_class.new(init_values) }
+
+    let(:init_values) { [values1, hash_values1, [], nil].sample }
+
+    should have_imeths :call
+  end
+
+  class CalledWithAnEmptyArrayTests < InitTests
+    desc "and called with an empty Array"
+
+    let(:init_values) { [] }
+    # let(:init_values) { [[], nil, [nil, nil]].sample }
+
+    should "return an empty Array" do
+      assert_that(subject.call).equals([])
+    end
+  end
+
+  class CalledWithASingleNonHashValueTests < InitTests
+    desc "and called with single non-Hash value"
+
+    let(:init_values) { [Factory.value, nil].sample }
+
+    should "return the value wrapped in an Array" do
+      assert_that(subject.call).equals([init_values])
+    end
+  end
+
+  class CalledWithASingleHashValueTests < InitTests
+    desc "and called with single Hash value"
+
+    let(:value1) { [Factory.value, nil].sample }
+    let(:init_values) { { value: value1 } }
+
+    should "return the Hash with its values wrapped in an Array" do
+      assert_that(subject.call).equals(value: [value1])
+    end
+  end
+
+  class CalledWithAMixedValueArrayTests < InitTests
+    desc "and called with a mixed-value Array"
+
+    let(:init_values) { [nil, values1, [], { value: 1 }, nil] }
+
+    should "combines the values into an Array, flattening any sub-Arrays" do
+      assert_that(subject.call).equals([nil, *values1, { value: 1 }, nil])
+    end
+  end
+
+  class CalledWithAnAllHashValueArrayTests < InitTests
+    desc "and called with an all-Hash-value Array"
+
+    let(:init_values) { [nil] + hash_values1 + [nil] }
+
+    let(:expected_aggregate_value) {
+      {
+        value1: init_values.map { |hash| (hash || {})[:value1] },
+        value2: {
+          value1: init_values.map { |hash| (hash || {}).dig(:value2, :value1) },
+          value2: init_values.map { |hash| (hash || {}).dig(:value2, :value2) }
+        }
+      }
+    }
+
+    should "recursively combine the hash values, removing any nils" do
+      assert_that(subject.call).equals(expected_aggregate_value)
+    end
+  end
+end

data/test/unit/much-result_tests.rb

@@ -0,0 +1,447 @@
+require "assert"
+require "much-result"
+
+class MuchResult
+  class UnitTests < Assert::Context
+    desc "MuchResult"
+    subject { unit_class }
+
+    let(:unit_class) { MuchResult }
+
+    let(:identifier1) { Factory.string }
+    let(:description1) { Factory.string }
+    let(:backtrace1) { Factory.backtrace }
+    let(:value1) { Factory.value }
+
+    should have_imeths :success, :failure, :for, :tap, :transaction
+
+    should "build success instances" do
+      result = subject.success
+
+      assert_that(result.success?).is_true
+      assert_that(result.failure?).is_false
+
+      assert_that(result.sub_results).equals([])
+      assert_that(result.success_sub_results).equals([])
+      assert_that(result.failure_sub_results).equals([])
+
+      assert_that(result.all_results).equals([result])
+      assert_that(result.all_success_results).equals([result])
+      assert_that(result.all_failure_results).equals([])
+    end
+
+    should "build failure instances" do
+      result = subject.failure
+
+      assert_that(result.success?).is_false
+      assert_that(result.failure?).is_true
+
+      assert_that(result.sub_results).equals([])
+      assert_that(result.success_sub_results).equals([])
+      assert_that(result.failure_sub_results).equals([])
+
+      assert_that(result.all_results).equals([result])
+      assert_that(result.all_success_results).equals([])
+      assert_that(result.all_failure_results).equals([result])
+    end
+
+    should "build instances based on given values" do
+      true_result = subject.for(true, value: value1)
+      assert_that(true_result.success?).is_true
+      assert_that(true_result.failure?).is_false
+      assert_that(true_result.value).equals(value1)
+
+      false_result = subject.for(false, value: value1)
+      assert_that(false_result.success?).is_false
+      assert_that(false_result.failure?).is_true
+      assert_that(false_result.value).equals(value1)
+
+      value1_result = subject.for(value1, value: value1)
+      assert_that(value1_result.success?).is_true
+      assert_that(value1_result.failure?).is_false
+      assert_that(value1_result.value).equals(value1)
+
+      nil_result = subject.for(nil, value: value1)
+      assert_that(nil_result.success?).is_false
+      assert_that(nil_result.failure?).is_true
+      assert_that(nil_result.value).equals(value1)
+
+      result_result = subject.for(true_result, value2: value1)
+      assert_that(result_result).is_the_same_as(true_result)
+      assert_that(result_result.value2).equals(value1)
+    end
+
+    should "build instances yielded to a given block" do
+      yielded_result = nil
+      tap_result =
+        subject.tap { |result|
+          yielded_result = result
+
+          assert_that(result.success?).is_true
+          assert_that(result.sub_results.size).equals(0)
+          assert_that(result.all_results.size).equals(1)
+        }
+      assert_that(tap_result).is_the_same_as(yielded_result)
+    end
+
+    should "call transactions on a transaction receiver" do
+      MuchStub.on_call(MuchResult::Transaction, :call) { |call|
+        @transaction_call = call
+      }
+
+      receiver1 = Factory.transaction_receiver
+      kargs1 = {
+        backtrace: Factory.backtrace,
+        value: value1
+      }
+      block1 = -> {}
+      subject.transaction(receiver1, **kargs1, &block1)
+
+      assert_that(@transaction_call.pargs).equals([receiver1])
+      assert_that(@transaction_call.kargs).equals(kargs1)
+      assert_that(@transaction_call.block).equals(block1)
+    end
+
+    should "halt transactions" do
+      receiver1 = Factory.transaction_receiver
+      result =
+        subject.transaction(receiver1) do |transaction|
+          transaction.capture { "something1"}
+          transaction.halt
+          transaction.capture { "something2" }
+        end
+
+      assert_that(result.sub_results.size).equals(1)
+    end
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject { unit_class.success }
+
+    let(:failure1) {
+      unit_class.failure(description: Factory.string)
+    }
+    let(:failure2) {
+      unit_class.failure(exception: StandardError.new(Factory.string))
+    }
+
+    should have_imeths :description, :backtrace, :set
+    should have_imeths :success?, :failure?
+    should have_imeths :capture_for, :capture_for!
+    should have_imeths :capture_for_all, :capture_for_all!
+    should have_imeths :capture, :capture!
+    should have_imeths :capture_all, :capture_all!
+    should have_imeths :capture_exception
+    should have_imeths :sub_results, :success_sub_results, :failure_sub_results
+    should have_imeths :all_results, :all_success_results, :all_failure_results
+    should have_imeths :get_for_sub_results
+    should have_imeths :get_for_success_sub_results, :get_for_failure_sub_results
+    should have_imeths :get_for_all_results
+    should have_imeths :get_for_all_success_results, :get_for_all_failure_results
+    should have_imeths :to_much_result
+
+    should "know its attributes" do
+      assert_that(subject.description).is_nil
+      assert_that(subject.backtrace).is_not_nil
+      assert_that(subject.backtrace).is_not_empty
+
+      result =
+        unit_class.success(
+          identifier: identifier1,
+          description: description1,
+          backtrace: backtrace1,
+          value: value1
+        )
+      assert_that(result.identifier).equals(identifier1)
+      assert_that(result.description).equals(description1)
+      assert_that(result.backtrace).equals(backtrace1)
+      assert_that(result.value).equals(value1)
+
+      exception = result.capture_exception
+      assert_that(exception).is_instance_of(MuchResult::Error)
+      assert_that(exception.message).equals(description1)
+      assert_that(exception.backtrace).equals(backtrace1)
+    end
+
+    should "allow setting arbitrary values" do
+      assert_that(subject.other_value).is_nil
+
+      subject.set(other_value: value1)
+      assert_that(subject.other_value).equals(value1)
+    end
+
+    should "capture MuchResults as sub-results" do
+      subject.capture_for(unit_class.success(values: { value1: Factory.value }))
+      assert_that(subject.success?).is_true
+      assert_that(subject.sub_results.size).equals(1)
+      assert_that(subject.success_sub_results.size).equals(1)
+      assert_that(subject.failure_sub_results.size).equals(0)
+      assert_that(subject.get_for_sub_results("values")[:value1]).equals(
+        [
+          subject.success_sub_results.first.values[:value1]
+        ])
+      assert_that(subject.get_for_success_sub_results("values")[:value1]).equals(
+        [
+          subject.success_sub_results.first.values[:value1]
+        ])
+      assert_that(subject.get_for_failure_sub_results("values")).equals(
+        [])
+      assert_that(subject.all_results.size).equals(2)
+      assert_that(subject.all_success_results.size).equals(2)
+      assert_that(subject.all_failure_results.size).equals(0)
+      assert_that(subject.get_for_all_results("values")[:value1]).equals(
+        [
+          nil,
+          subject.success_sub_results.first.values[:value1]
+        ])
+      assert_that(subject.get_for_all_success_results("values")[:value1]).equals(
+        [
+          nil,
+          subject.success_sub_results.first.values[:value1]
+        ])
+      assert_that(subject.get_for_all_failure_results("values")).equals(
+        [])
+
+      subject.capture_for(unit_class.failure(values: { value1: Factory.value }))
+      assert_that(subject.success?).is_false
+      assert_that(subject.sub_results.size).equals(2)
+      assert_that(subject.success_sub_results.size).equals(1)
+      assert_that(subject.failure_sub_results.size).equals(1)
+      assert_that(subject.get_for_sub_results("values")[:value1]).equals(
+        [
+          subject.success_sub_results.first.values[:value1],
+          subject.failure_sub_results.first.values[:value1]
+        ])
+      assert_that(subject.get_for_success_sub_results("values")[:value1]).equals(
+        [
+          subject.success_sub_results.first.values[:value1]
+        ])
+      assert_that(subject.get_for_failure_sub_results("values")[:value1]).equals(
+        [
+          subject.failure_sub_results.first.values[:value1]
+        ])
+      assert_that(subject.all_results.size).equals(3)
+      assert_that(subject.all_success_results.size).equals(1)
+      assert_that(subject.all_failure_results.size).equals(2)
+      assert_that(subject.get_for_all_results("values")[:value1]).equals(
+        [
+          nil,
+          subject.success_sub_results.first.values[:value1],
+          subject.failure_sub_results.first.values[:value1]
+        ])
+      assert_that(subject.get_for_all_success_results("values")[:value1]).equals(
+        [
+          subject.success_sub_results.first.values[:value1]
+        ])
+      assert_that(subject.get_for_all_failure_results("values")[:value1]).equals(
+        [
+          nil,
+          subject.failure_sub_results.first.values[:value1]
+        ])
+
+      result = unit_class.success
+
+      result.capture_for([true, Factory.integer, Factory.string].sample)
+      assert_that(result.success?).is_true
+      assert_that(result.sub_results.size).equals(1)
+      assert_that(result.success_sub_results.size).equals(1)
+      assert_that(result.failure_sub_results.size).equals(0)
+      assert_that(result.all_results.size).equals(2)
+      assert_that(result.all_success_results.size).equals(2)
+      assert_that(result.all_failure_results.size).equals(0)
+
+      result.capture_for([false, nil].sample)
+      assert_that(result.success?).is_false
+      assert_that(result.sub_results.size).equals(2)
+      assert_that(result.success_sub_results.size).equals(1)
+      assert_that(result.failure_sub_results.size).equals(1)
+      assert_that(result.all_results.size).equals(3)
+      assert_that(result.all_success_results.size).equals(1)
+      assert_that(result.all_failure_results.size).equals(2)
+
+      result = unit_class.success
+
+      # Test the default built capture exception.
+      exception =
+        assert_that(-> {
+          result.capture_for!(failure1)
+        }).raises(MuchResult::Error)
+      assert_that(exception.message).equals(failure1.description)
+      assert_that(exception.backtrace).equals(failure1.backtrace)
+      assert_that(result.success?).is_false
+      assert_that(result.sub_results.size).equals(1)
+      assert_that(result.success_sub_results.size).equals(0)
+      assert_that(result.failure_sub_results.size).equals(1)
+      assert_that(result.all_results.size).equals(2)
+      assert_that(result.all_success_results.size).equals(0)
+      assert_that(result.all_failure_results.size).equals(2)
+
+      # Test that we prefer any set `result.exception` over the default built
+      # capture exception.
+      exception =
+        assert_that(-> {
+          result.capture_for!(failure2)
+        }).raises(failure2.exception.class)
+      assert_that(exception.message).equals(failure2.exception.message)
+      assert_that(exception.backtrace).equals(failure2.exception.backtrace)
+      assert_that(result.success?).is_false
+      assert_that(result.sub_results.size).equals(2)
+      assert_that(result.success_sub_results.size).equals(0)
+      assert_that(result.failure_sub_results.size).equals(2)
+      assert_that(result.all_results.size).equals(3)
+      assert_that(result.all_success_results.size).equals(0)
+      assert_that(result.all_failure_results.size).equals(3)
+    end
+
+    should "capture MuchResults from an Array as sub-results" do
+      subject.capture_for_all([unit_class.success, unit_class.failure])
+      assert_that(subject.success?).is_false
+      assert_that(subject.sub_results.size).equals(2)
+      assert_that(subject.success_sub_results.size).equals(1)
+      assert_that(subject.failure_sub_results.size).equals(1)
+      assert_that(subject.all_results.size).equals(3)
+      assert_that(subject.all_success_results.size).equals(1)
+      assert_that(subject.all_failure_results.size).equals(2)
+
+      result = unit_class.success
+
+      result.capture_for_all(
+        [
+          [true, Factory.integer, Factory.string].sample,
+          [false, nil].sample
+        ]
+      )
+      assert_that(result.success?).is_false
+      assert_that(result.sub_results.size).equals(2)
+      assert_that(result.success_sub_results.size).equals(1)
+      assert_that(result.failure_sub_results.size).equals(1)
+      assert_that(result.all_results.size).equals(3)
+      assert_that(result.all_success_results.size).equals(1)
+      assert_that(result.all_failure_results.size).equals(2)
+
+      result = unit_class.success
+
+      exception =
+        assert_that(-> {
+          result.capture_for_all!([failure1, failure2])
+        }).raises(MuchResult::Error)
+      assert_that(exception.message).equals(failure1.description)
+      assert_that(exception.backtrace).equals(failure1.backtrace)
+      assert_that(result.success?).is_false
+      assert_that(result.sub_results.size).equals(2)
+      assert_that(result.success_sub_results.size).equals(0)
+      assert_that(result.failure_sub_results.size).equals(2)
+      assert_that(result.all_results.size).equals(3)
+      assert_that(result.all_success_results.size).equals(0)
+      assert_that(result.all_failure_results.size).equals(3)
+    end
+
+    should "capture MuchResults from a block as sub-results" do
+      subject.capture { unit_class.success }
+      assert_that(subject.success?).is_true
+      assert_that(subject.sub_results.size).equals(1)
+      assert_that(subject.success_sub_results.size).equals(1)
+      assert_that(subject.failure_sub_results.size).equals(0)
+      assert_that(subject.all_results.size).equals(2)
+      assert_that(subject.all_success_results.size).equals(2)
+      assert_that(subject.all_failure_results.size).equals(0)
+
+      subject.capture { unit_class.failure }
+      assert_that(subject.success?).is_false
+      assert_that(subject.sub_results.size).equals(2)
+      assert_that(subject.success_sub_results.size).equals(1)
+      assert_that(subject.failure_sub_results.size).equals(1)
+      assert_that(subject.all_results.size).equals(3)
+      assert_that(subject.all_success_results.size).equals(1)
+      assert_that(subject.all_failure_results.size).equals(2)
+
+      result = unit_class.success
+
+      result.capture { [true, Factory.integer, Factory.string].sample }
+      assert_that(result.success?).is_true
+      assert_that(result.sub_results.size).equals(1)
+      assert_that(result.success_sub_results.size).equals(1)
+      assert_that(result.failure_sub_results.size).equals(0)
+      assert_that(result.all_results.size).equals(2)
+      assert_that(result.all_success_results.size).equals(2)
+      assert_that(result.all_failure_results.size).equals(0)
+
+      result.capture { [false, nil].sample }
+      assert_that(result.success?).is_false
+      assert_that(result.sub_results.size).equals(2)
+      assert_that(result.success_sub_results.size).equals(1)
+      assert_that(result.failure_sub_results.size).equals(1)
+      assert_that(result.all_results.size).equals(3)
+      assert_that(result.all_success_results.size).equals(1)
+      assert_that(result.all_failure_results.size).equals(2)
+
+      result = unit_class.success
+
+      exception =
+        assert_that(-> {
+          result.capture! { failure1 }
+        }).raises(MuchResult::Error)
+      assert_that(exception.message).equals(failure1.description)
+      assert_that(exception.backtrace).equals(failure1.backtrace)
+      assert_that(result.success?).is_false
+      assert_that(result.sub_results.size).equals(1)
+      assert_that(result.success_sub_results.size).equals(0)
+      assert_that(result.failure_sub_results.size).equals(1)
+      assert_that(result.all_results.size).equals(2)
+      assert_that(result.all_success_results.size).equals(0)
+      assert_that(result.all_failure_results.size).equals(2)
+    end
+
+    should "capture MuchResults from a block from an Array as sub-results" do
+      subject.capture_all { [unit_class.success, unit_class.failure] }
+      assert_that(subject.success?).is_false
+      assert_that(subject.sub_results.size).equals(2)
+      assert_that(subject.success_sub_results.size).equals(1)
+      assert_that(subject.failure_sub_results.size).equals(1)
+      assert_that(subject.all_results.size).equals(3)
+      assert_that(subject.all_success_results.size).equals(1)
+      assert_that(subject.all_failure_results.size).equals(2)
+
+      result = unit_class.success
+
+      result.capture_all do
+        [
+          [true, Factory.integer, Factory.string].sample,
+          [false, nil].sample
+        ]
+      end
+      assert_that(result.success?).is_false
+      assert_that(result.sub_results.size).equals(2)
+      assert_that(result.success_sub_results.size).equals(1)
+      assert_that(result.failure_sub_results.size).equals(1)
+      assert_that(result.all_results.size).equals(3)
+      assert_that(result.all_success_results.size).equals(1)
+      assert_that(result.all_failure_results.size).equals(2)
+
+      result = unit_class.success
+
+      exception =
+        assert_that(-> {
+          result.capture_all! { [failure1, failure2] }
+        }).raises(MuchResult::Error)
+      assert_that(exception.message).equals(failure1.description)
+      assert_that(exception.backtrace).equals(failure1.backtrace)
+      assert_that(result.success?).is_false
+      assert_that(result.sub_results.size).equals(2)
+      assert_that(result.success_sub_results.size).equals(0)
+      assert_that(result.failure_sub_results.size).equals(2)
+      assert_that(result.all_results.size).equals(3)
+      assert_that(result.all_success_results.size).equals(0)
+      assert_that(result.all_failure_results.size).equals(3)
+    end
+
+    should "convert itself to a MuchResult" do
+      assert_that(subject.value).is_nil
+
+      result = subject.to_much_result(value: value1)
+      assert_that(result).is_the_same_as(subject)
+      assert_that(subject.value).equals(value1)
+    end
+  end
+end