ector-multi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a20f20adbf811c03f487888057135de8267b17e5484792d7ab5a9096379321d4
+  data.tar.gz: f3011de86fd858e580b782059ffc5e36399183252a90c11936f8ffbc114b94a1
+SHA512:
+  metadata.gz: 3897ed4e2e54db0fbf30a9a5c63a9ab5265c1c7fd2f810893d913ade99e8f8e8207ac58680efe0d4b334b4f7ca780178010cbff770a9c7936f4033466f4f10cb
+  data.tar.gz: 79472b2e945fe5bb44597a68d042a099cff5019600f066244df1f9d123edad5df2623d181cbdc9bd519bb769cd7e335fb13629246b03a9ba27e3950e6fc85793

data/README.md

@@ -0,0 +1,2 @@
+# multi
+`Multi` is an object for grouping multiple DB operations that should be performed in a single database transaction.

data/ector-multi.gemspec

@@ -0,0 +1,28 @@
+require_relative 'lib/ector-multi'
+
+Gem::Specification.new do |s|
+  s.name        = 'ector-multi'
+  s.version     = ::Ector::VERSION
+  s.date        = Time.now.strftime('%Y-%m-%d')
+  s.summary     = 'Grouping multiple DB operations in a single transaction.'
+  s.description = 'Grouping multiple DB operations in a single transaction. 100% Inspired by Ecto'
+  s.authors     = ['Emiliano Mancuso']
+  s.email       = ['emiliano.mancuso@gmail.com']
+  s.homepage    = 'http://github.com/emancu/ector-multi'
+  s.license     = 'MIT'
+
+  s.files = Dir[
+    'README.md',
+    'rakefile',
+    'lib/**/*.rb',
+    '*.gemspec'
+  ]
+
+  s.test_files = Dir['test/*.*']
+
+  s.required_ruby_version = '>= 2.2'
+
+  s.add_dependency 'activerecord', '~> 5.2'
+  s.add_development_dependency 'protest', '~> 0'
+  s.add_development_dependency 'sqlite3', '~> 0'
+end

data/lib/ector-multi.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+require_relative 'ector-multi/errors'
+require_relative 'ector-multi/result'
+require_relative 'ector-multi/operations'
+require_relative 'ector-multi/multi'
+
+module Ector
+  VERSION = '0.0.1'
+end

data/lib/ector-multi/errors.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Ector
+  class Multi
+    # Parent class for all Multi errors
+    Error = Class.new(StandardError)
+
+    # Parent class for all "Rollback-able" errors
+    Rollback = Class.new(Error)
+
+    class OperationFailure < Rollback
+      attr_reader :operation, :arguments, :caused_by
+      alias_method :value, :arguments
+
+      def initialize(operation, arguments, caused_by)
+        @operation = operation
+        @arguments = arguments
+        @caused_by = caused_by
+
+        super("Rollback fired by #{operation.name}")
+      end
+
+      def inspect
+        "#<#{self.class.name} #{@operation.name} @caused_by=#{@caused_by.class} @arguments=#{@arguments}>"
+      end
+    end
+
+    class ControlledFailure < OperationFailure
+      def initialize(operation, value)
+        super(operation, value, nil)
+      end
+
+      def inspect
+        "#<#{self.class.name} #{@operation.name} value=#{@arguments}>"
+      end
+    end
+
+    class UniqueOperationError < Error
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+
+        super("Operation name '#{name}' is not unique!")
+      end
+    end
+  end
+end

data/lib/ector-multi/multi.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Ector
+  class Multi
+    attr_reader :failure, :results, :operations
+
+    def initialize
+      @operations = []
+    end
+
+    def append(multi)
+      check_operation_uniqueness!(multi.to_list)
+
+      @operations.push *multi.operations
+
+      self
+    end
+
+    def create(name, model, attributes = {}, &block)
+      add_operation Operation::Create.new(name, model, operation_block(attributes, block))
+    end
+
+    def destroy(name, object = nil, &block)
+      add_operation Operation::Destroy.new(name, operation_block(object, block))
+    end
+
+    def destroy_all(name, dataset = nil, &block)
+      add_operation Operation::DestroyAll.new(name, operation_block(dataset, block))
+    end
+
+    def error(name, value)
+      add_operation Operation::Error.new(name, operation_block(value, nil))
+    end
+
+    def merge(multi)
+      raise NotImplemented
+    end
+
+    def prepend(multi)
+      check_operation_uniqueness!(multi.to_list)
+
+      @operations.prepend *multi.operations
+
+      self
+    end
+
+    def run(name, &procedure)
+      add_operation Operation::Lambda.new(name, procedure)
+    end
+
+    def update(name, object, new_values, &block)
+      add_operation Operation::Update.new(name, object, operation_block(new_values, block))
+    end
+
+    def update_all(name, dataset, new_values, &block)
+      add_operation Operation::UpdateAll.new(name, dataset, operation_block(new_values, block))
+    end
+
+    def commit
+      results = {}
+
+      operations.find(&:fail_fast?)&.run(results)
+
+      ::ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
+        operations.each do |operation|
+          ::ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
+            results[operation.name] = operation.run(::OpenStruct.new(results))
+          end
+        end
+      end
+
+      Ector::Multi::Result.new(results)
+    rescue Ector::Multi::Rollback => error
+      Ector::Multi::Result.new(results, error)
+    end
+
+    def to_list
+      operations.map(&:name)
+    end
+
+    private
+
+    def add_operation(operation)
+      check_operation_uniqueness!(operation.name)
+
+      @operations << operation
+
+      self
+    end
+
+    def check_operation_uniqueness!(names)
+      repeated_names = to_list & Array(names)
+
+      fail UniqueOperationError.new(repeated_names) if repeated_names.any?
+    end
+
+    def operation_block(args, block)
+      if block
+        Proc.new { |results| block.(results, args) }
+      else
+        Proc.new { |_| args }
+      end
+    end
+  end
+end

data/lib/ector-multi/operations.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Ector
+  class Multi
+    module Operation
+      class Base
+        attr_reader :name
+
+        def initialize(name, block)
+          @name = name
+          @block = block
+        end
+
+        def inspect
+          "#<#{self.class.name} #{@name}>"
+        end
+
+        def run(results)
+          output = @block.(results)
+
+          perform(output)
+        rescue Ector::Multi::Rollback => error
+          raise Ector::Multi::OperationFailure.new(self, output, error)
+        end
+
+        def fail_fast?
+          self.is_a?(Ector::Multi::Operation::Error)
+        end
+
+        private
+
+        def perform(_output)
+          raise NotImplemented
+        end
+      end
+
+      class Create < Base
+        def initialize(name, model, attributes_block)
+          @model = model
+          super(name, attributes_block)
+        end
+
+        private
+
+        def perform(attributes)
+          @model.create!(attributes)
+        end
+      end
+
+      class Update < Base
+        def initialize(name, instance, attributes_block)
+          @instance = instance
+          super(name, attributes_block)
+        end
+
+        private
+
+        def perform(attributes)
+          @instance.update!(attributes)
+
+          @instance
+        end
+      end
+
+      class UpdateAll < Base
+        def initialize(name, dataset, attributes_block)
+          @dataset = dataset
+          super(name, attributes_block)
+        end
+
+        private
+
+        def perform(attributes)
+          @dataset.update_all(attributes)
+        end
+      end
+
+      class Destroy < Base
+        private
+
+        def perform(model)
+          model.destroy
+        end
+      end
+
+      class DestroyAll < Base
+        private
+
+        def perform(dataset)
+          dataset.destroy_all
+        end
+      end
+
+      class Lambda < Base
+        private
+
+        def perform(block_output)
+          block_output
+        end
+      end
+
+      class Error < Base
+        def run(results)
+          output = @block.(results)
+
+          raise Ector::Multi::ControlledFailure.new(self, output)
+        end
+      end
+    end
+  end
+end

data/lib/ector-multi/result.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Ector
+  class Multi
+    class Result
+      attr_reader :results, :error
+
+      def initialize(results, error = nil)
+        @results = results
+        @error = error
+      end
+
+      def success?
+        !@error
+      end
+
+      def failure?
+        !success?
+      end
+    end
+  end
+end

data/rakefile

@@ -0,0 +1,8 @@
+task :default => :test
+
+desc 'Run tests'
+task :test do
+  require File.expand_path("./test/helper", File.dirname(__FILE__))
+
+  Dir["test/**/*_test.rb"].each { |file| load file }
+end

data/test/helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Protest
+require 'protest'
+
+Protest.report_with(:progress)
+
+def refute(condition, message="Expected condition to be unsatisfied")
+  assert !condition, message
+end
+
+# ActiveRecord
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+ActiveRecord::Schema.verbose = false
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+ActiveRecord::Migration.create_table :dummies, force: true do |t|
+  t.integer :user_id
+  t.string :name
+end
+
+class Dummy < ActiveRecord::Base; end
+
+# Load lib
+
+require_relative '../lib/ector-multi.rb'

data/test/multi_test.rb

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+Protest.describe 'Ector::Multi' do
+  setup do
+    Dummy.delete_all
+    @multi = Ector::Multi.new
+  end
+
+  context '#append' do
+    setup do
+      @left_multi = @multi.run(:left) { |_| }
+    end
+
+    test 'adds operations to the end of the queue' do
+      right_multi =
+        Ector::Multi.new
+        .run(:right) { |_| }
+        .run(:far_right) { |_| }
+
+      @left_multi.append(right_multi)
+
+      assert_equal @left_multi.to_list, [:left, :right, :far_right]
+    end
+
+    test 'nothing changes when appends an empty multi' do
+      @left_multi.append(Ector::Multi.new)
+
+      assert_equal @left_multi.to_list, [:left]
+    end
+
+    test 'fails when there are duplicated operations' do
+      duplicated_multi =
+        Ector::Multi.new
+        .run(:should_fail) { |_| }
+        .run(:left) { |_| }
+
+      assert_raise(Ector::Multi::UniqueOperationError) { @left_multi.append(duplicated_multi) }
+      assert_equal @left_multi.to_list, [:left]
+    end
+
+    test 'returns self' do
+      right_multi = Ector::Multi.new.run(:right) { |_| }
+
+      returned = @left_multi.append(right_multi)
+
+      assert_equal @left_multi, returned
+    end
+  end
+
+  context '#create' do
+    test 'adds a Create operation to the queue' do
+      @multi.create(:dummy, Dummy, id: 1)
+
+      assert_equal @multi.to_list, [:dummy]
+      assert_equal @multi.operations.first.class, Ector::Multi::Operation::Create
+    end
+
+    test 'fails when the operation name exists' do
+      @multi.run(:operation) { |_| }
+
+      assert_raise(Ector::Multi::UniqueOperationError) { @multi.create(:operation, Dummy, id: 1) }
+    end
+
+    test 'does not create an instance yet' do
+      @multi.create(:dummy, Dummy, name: 'New one')
+
+      assert_equal Dummy.count, 0
+    end
+
+    test 'returns self' do
+      assert_equal @multi, @multi.create(:dummy, Dummy, id: 1)
+    end
+  end
+
+  context '#destroy' do
+    setup do
+      @instance = Dummy.create(name: 'Destroyable')
+    end
+
+    test 'adds a Delete operation to the queue' do
+      @multi.destroy(:destroy_object, @instance)
+
+      assert_equal @multi.to_list, [:destroy_object]
+      assert_equal @multi.operations.first.class, Ector::Multi::Operation::Destroy
+    end
+
+    test 'fails when the operation name exists' do
+      @multi.run(:operation) { |_| }
+
+      assert_raise(Ector::Multi::UniqueOperationError) { @multi.destroy(:operation, @instance) }
+    end
+
+    test 'does not delete the instance yet' do
+      @multi.destroy(:destroy_object, @instance)
+
+      assert Dummy.find(@instance.id)
+    end
+
+    test 'returns self' do
+      assert_equal @multi, @multi.destroy(:dummy, @instance)
+    end
+  end
+
+  context '#destroy_all' do
+    setup do
+      Dummy.create(name: 'Destroyable')
+    end
+
+    test 'adds a Delete operation to the queue' do
+      @multi.destroy_all(:destroy_object, Dummy)
+
+      assert_equal @multi.to_list, [:destroy_object]
+      assert_equal @multi.operations.first.class, Ector::Multi::Operation::DestroyAll
+    end
+
+    test 'fails when the operation name exists' do
+      @multi.run(:operation) { |_| }
+
+      assert_raise(Ector::Multi::UniqueOperationError) { @multi.destroy(:operation, @instance) }
+    end
+
+    test 'does not delete the instance yet' do
+      @multi.destroy(:destroy_object, @instance)
+
+      assert Dummy.count, 1
+    end
+
+    test 'returns self' do
+      assert_equal @multi, @multi.destroy_all(:dummy, Dummy)
+    end
+  end
+
+  context '#error' do
+    test 'adds an Error operation to the queue' do
+      @multi.error(:fail_fast, 1)
+
+      assert_equal @multi.to_list, [:fail_fast]
+      assert_equal @multi.operations.first.class, Ector::Multi::Operation::Error
+    end
+
+    test 'fails when the operation name exists' do
+      @multi.run(:operation) { |_| }
+
+      assert_raise(Ector::Multi::UniqueOperationError) { @multi.error(:operation, 1) }
+    end
+
+    test 'returns self' do
+      assert_equal @multi, @multi.error(:dummy, 1)
+    end
+  end
+
+  context '#merge'
+
+    # test 'returns self' do
+      # assert_equal @multi, @multi.merge(:dummy, ???)
+    # end
+  # end
+
+  context '#prepend' do
+    setup do
+      @left_multi = @multi.run(:left) { }
+    end
+
+    test 'adds operations to the beginning of the queue' do
+      right_multi =
+        Ector::Multi.new
+        .run(:right) { }
+        .run(:far_right) { }
+
+      @left_multi.prepend(right_multi)
+
+      assert_equal @left_multi.to_list, [:right, :far_right, :left]
+    end
+
+    test 'nothing changes when prepends an empty multi' do
+      @left_multi.prepend(Ector::Multi.new)
+
+      assert_equal @left_multi.to_list, [:left]
+    end
+
+    test 'fails when there are duplicated operations' do
+      duplicated_multi =
+        Ector::Multi.new
+        .run(:should_fail) { }
+        .run(:left) { }
+
+      assert_raise(Ector::Multi::UniqueOperationError) { @left_multi.prepend(duplicated_multi) }
+      assert_equal @left_multi.to_list, [:left]
+    end
+
+    test 'returns self' do
+      right_multi = Ector::Multi.new.run(:right) { }
+
+      returned = @left_multi.prepend(right_multi)
+
+      assert_equal @left_multi, returned
+    end
+  end
+
+  context '#run' do
+    test 'adds an Lambda operation to the queue' do
+      @multi.run(:procedure) { |results| results }
+
+      operation = @multi.operations.first
+      assert_equal @multi.to_list, [:procedure]
+      assert_equal operation.class, Ector::Multi::Operation::Lambda
+    end
+
+    test 'fails when the operation name exists' do
+      @multi.run(:operation) { }
+
+      assert_raise(Ector::Multi::UniqueOperationError) { @multi.run(:operation) { |_| 1 } }
+    end
+
+    test 'does not run the block yet' do
+      call_counter = 0
+
+      @multi.run(:procedure) { call_counter += 1 }
+
+      assert_equal call_counter, 0
+    end
+
+    test 'returns self' do
+      assert_equal(@multi, @multi.run(:dummy ) { })
+    end
+  end
+
+  context '#update' do
+    setup do
+      @instance = Dummy.create(name: 'Original')
+    end
+
+    test 'adds an Update operation to the queue' do
+      @multi.update(:change_name, @instance, name: 'Updated')
+
+      operation = @multi.operations.first
+      assert_equal @multi.to_list, [:change_name]
+      assert_equal operation.class, Ector::Multi::Operation::Update
+    end
+
+    test 'fails when the operation name exists' do
+      @multi.run(:operation) { |_| }
+
+      assert_raise(Ector::Multi::UniqueOperationError) { @multi.update(:operation, @instance, id: 1) }
+    end
+
+    test 'does not update the instance yet' do
+      @multi.update(:change_name, @instance, name: 'Updated')
+
+      assert_equal @instance.reload.name, 'Original'
+    end
+
+    test 'returns self' do
+      assert_equal @multi, @multi.update(:dummy, @instance, name: 'asd')
+    end
+  end
+
+  context '#update_all' do
+    setup do
+      @instance = Dummy.create(name: 'Original')
+    end
+
+    test 'adds an UpdateAll operation to the queue' do
+      @multi.update_all(:change_name, Dummy, name: 'Updated')
+
+      operation = @multi.operations.first
+      assert_equal @multi.to_list, [:change_name]
+      assert_equal operation.class, Ector::Multi::Operation::UpdateAll
+    end
+
+    test 'fails when the operation name exists' do
+      @multi.run(:operation) { |_| }
+
+      assert_raise(Ector::Multi::UniqueOperationError) { @multi.update(:operation, @instance, id: 1) }
+    end
+
+    test 'does not update the instance yet' do
+      @multi.update_all(:change_name, Dummy, name: 'Updated')
+
+      assert_equal @instance.reload.name, 'Original'
+    end
+
+    test 'returns self' do
+      assert_equal @multi, @multi.update_all(:dummy, Dummy, name: 'asd')
+    end
+  end
+
+  context '#commit' do
+    test 'trap Ector::Multi::Rollback exceptions' do
+      @multi.run(:fail_gracefully) { fail Ector::Multi::Rollback.new 'handled' }
+
+      result = @multi.commit
+
+      assert result.failure?
+      assert result.error.caused_by.is_a?(Ector::Multi::Rollback)
+    end
+
+    test 'raises any exception that is not a Ector::Multi::Rollback' do
+      @multi.run(:fail_violently) { fail 'unhandled' }
+
+      assert_raise(StandardError) { @multi.commit }
+    end
+
+    test 'stops execution immediately when an exception occurs' do
+      @multi
+      .run(:op1) { :should_pass }
+      .run(:op2) { fail Ector::Multi::Rollback.new 'sorry' }
+      .run(:op3) { :never_gets_called }
+
+      result = @multi.commit
+
+      assert result.failure?
+      assert_equal result.results.keys, [:op1]
+      assert_equal result.error.operation.name, :op2
+    end
+
+    test 'fails immediately when an Error Operation is enqueued' do
+      @multi
+      .run(:op1) { :never_gets_called }
+      .run(:op2) { :never_gets_called }
+      .run(:op3) { :never_gets_called }
+      .error(:fail_fast, 1)
+
+      result = @multi.commit
+
+      assert result.failure?
+      assert result.results.empty?
+      assert_equal result.error.value, 1
+      assert_equal result.error.operation.name, :fail_fast
+    end
+
+    test 'creates a transaction for each operation' do
+      transaction_ids =
+        @multi
+        .run(:op1) { ActiveRecord::Base.connection.current_transaction.__id__ }
+        .run(:op2) { ActiveRecord::Base.connection.current_transaction.__id__ }
+        .run(:op3) { ActiveRecord::Base.connection.current_transaction.__id__ }
+        .commit
+        .results
+        .values
+        .uniq
+
+      assert_equal transaction_ids.size, 3
+    end
+
+    test 'changes are persisted on success' do
+      instance = Dummy.create(name: 'Original')
+      deletable = Dummy.create(name: 'Deletable')
+
+      result =
+        @multi
+        .create(:new_dummy, Dummy, name: 'From multi')
+        .update(:rename, instance, name: 'Updated')
+        .destroy(:remove, deletable)
+        .commit
+
+      assert result.success?
+      assert_equal Dummy.all.map(&:name), ['Updated', 'From multi']
+      assert_equal result.results.keys, [:new_dummy, :rename, :remove]
+    end
+
+    test 'changes are rolledback on failure' do
+      instance = Dummy.create(name: 'Original')
+      deletable = Dummy.create(name: 'Deletable')
+
+      result =
+        @multi
+        .create(:new_dummy, Dummy, name: 'From multi')
+        .update(:rename, instance, name: 'Updated')
+        .destroy(:remove, deletable)
+        .run(:force_failure) { fail Ector::Multi::Rollback.new('abort')}
+        .commit
+
+      assert result.failure?
+      assert_equal Dummy.all.map(&:name), ['Original', 'Deletable']
+      assert_equal result.results.keys, [:new_dummy, :rename, :remove]
+      assert_equal result.error.operation.name, :force_failure
+    end
+
+    test 'returns a Ector::Multi::Result' do
+      assert @multi.commit.is_a?(Ector::Multi::Result)
+    end
+  end
+
+  context '#to_list' do
+    test 'returns an ordered list with the name of the operations' do
+      nop = -> { }
+      empty = @multi
+      single = Ector::Multi.new.run(:lambda, &nop)
+      multi = Ector::Multi.new.run(:annonymous, &nop).run(:operations, &nop)
+
+      assert_equal empty.to_list, []
+      assert_equal single.to_list, [:lambda]
+      assert_equal multi.to_list, [:annonymous, :operations]
+    end
+  end
+end

data/test/operations_test.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+Protest.describe 'Operations' do
+  setup do
+    Dummy.delete_all
+  end
+
+  context 'Create' do
+    setup do
+      @op = Ector::Multi::Operation::Create.new(:t, Dummy, lambda { |results| { name: 'Emi' }.merge(results) } )
+    end
+
+    test 'it does not fail fast' do
+      refute @op.fail_fast?
+    end
+
+    test 'raises an exception when creation fails' do
+      assert_raise(StandardError) do
+        @op.run(unknown_attribute: 123)
+      end
+
+      assert_equal Dummy.count, 0
+    end
+
+    test 'returns the object created' do
+      res = @op.run(name: 'Created')
+
+      assert_equal res.class, Dummy
+      assert_equal res.name, 'Created'
+      assert_equal res.id, Dummy.last.id
+    end
+  end
+
+  context 'Update' do
+    setup do
+      @instance = Dummy.create(name: 'Original')
+      @op = Ector::Multi::Operation::Update.new(:t, @instance, lambda { |results| { name: 'Updated' }.merge(results) } )
+    end
+
+    test 'it does not fail fast' do
+      refute @op.fail_fast?
+    end
+
+    test 'raises an exception when update fails' do
+      assert_raise(StandardError) do
+        @op.run(unknown_attribute: 123)
+      end
+
+      assert_equal @instance.reload.name, 'Original'
+    end
+
+    test 'returns the object created' do
+      res = @op.run(name: 'Updated baby')
+
+      assert_equal res.class, Dummy
+      assert_equal res.name, 'Updated baby'
+      assert_equal res.id, @instance.id
+    end
+  end
+
+  context 'UpdateAll' do
+    setup do
+      @instance = Dummy.create(name: 'Original')
+      @op = Ector::Multi::Operation::UpdateAll.new(:t, Dummy, lambda { |results| { name: 'Updated' }.merge(results) } )
+    end
+
+    test 'it does not fail fast' do
+      refute @op.fail_fast?
+    end
+
+    test 'raises an exception when update fails' do
+      assert_raise(StandardError) do
+        @op.run(unknown_attribute: 123)
+      end
+
+      assert_equal @instance.reload.name, 'Original'
+    end
+
+    test 'returns how many records were updated' do
+      res = @op.run(name: 'Mass update')
+
+      assert_equal res, 1
+      assert_equal @instance.reload.name, 'Mass update'
+    end
+
+    test 'accepts a dataset' do
+      Dummy.create(name: 'original 2')
+      Dummy.create(name: 'original 3')
+
+      @op = Ector::Multi::Operation::UpdateAll.new(:t, Dummy.where.not(name: 'original 2'), lambda { |results| results } )
+      res = @op.run(name: 'MassUpdated')
+
+      assert_equal res, 2
+      assert_equal Dummy.count, 3
+      assert_equal Dummy.all.map(&:name), ['MassUpdated', 'original 2', 'MassUpdated']
+    end
+  end
+
+  context 'Destroy' do
+    setup do
+      @instance = Dummy.create(name: 'Original')
+      @op = Ector::Multi::Operation::Destroy.new(:t, lambda { |_| @instance } )
+    end
+
+    test 'it does not fail fast' do
+      refute @op.fail_fast?
+    end
+
+    test 'returns the object destroyed' do
+      res = @op.run({})
+
+      assert res.frozen?
+      assert_equal res.class, Dummy
+      assert_equal res.id, @instance.id
+    end
+  end
+
+  context 'DestroyAll' do
+    setup do
+      @instance = Dummy.create(name: 'Original')
+      @op = Ector::Multi::Operation::DestroyAll.new(:t, lambda { |_| Dummy })
+    end
+
+    test 'it does not fail fast' do
+      refute @op.fail_fast?
+    end
+
+    test 'returns a list of instances destroyed' do
+      res = @op.run(destroy: 'all')
+
+      assert_equal res, [@instance]
+      assert_equal Dummy.count, 0
+      assert_raise(ActiveRecord::RecordNotFound) { @instance.reload }
+    end
+
+    test 'accepts a dataset' do
+      Dummy.create(name: 'original 2')
+      Dummy.create(name: 'original 3')
+
+      @op = Ector::Multi::Operation::DestroyAll.new(:t, lambda { |_| Dummy.where.not(name: 'original 2') } )
+      res = @op.run(destroy: 'with where')
+
+      assert_equal res.map(&:name), ['Original', 'original 3']
+      assert_equal Dummy.count, 1
+      assert_equal Dummy.all.map(&:name), ['original 2']
+    end
+  end
+
+  context 'Lambda' do
+    setup do
+      @lambda = Proc.new { [true, 1] }
+      @op = Ector::Multi::Operation::Lambda.new(:t, @lambda )
+    end
+
+    test 'it does not fail fast' do
+      refute @op.fail_fast?
+    end
+
+    test 'returns the return value of the block' do
+      res = @op.run({})
+
+      assert_equal res, [true, 1]
+      assert_equal res, @lambda.call
+    end
+  end
+
+  context 'Error' do
+    setup do
+      @op = Ector::Multi::Operation::Error.new(:t, lambda { |r| 1} )
+    end
+
+    test 'it does not fail fast' do
+      assert @op.fail_fast?
+    end
+
+    test 'returns the return value of the block' do
+      assert_raise(Ector::Multi::ControlledFailure) { @op.run({}) }
+    end
+  end
+end

data/test/result_test.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+Protest.describe 'Ector::Multi::Result' do
+  test 'attribute readers' do
+    results = { operation: 1, procedure: 2 }
+    error = Ector::Multi::Rollback.new
+    result = Ector::Multi::Result.new(results, error)
+
+    assert_equal result.results, results
+    assert_equal result.error, error
+  end
+
+  context 'succcess?' do
+    test 'returns `true` when it succeeded' do
+      result = Ector::Multi::Result.new({})
+
+      assert result.success?
+    end
+
+    test 'returns `false` when there is an error' do
+      result = Ector::Multi::Result.new({}, Ector::Multi::Rollback.new)
+
+      refute result.success?
+    end
+  end
+
+  context 'failure?' do
+    test 'returns `true` when it failed' do
+      result = Ector::Multi::Result.new({}, Ector::Multi::Rollback.new)
+
+      assert result.failure?
+    end
+
+    test 'returns `false` when there is no error' do
+      result = Ector::Multi::Result.new({})
+
+      refute result.failure?
+    end
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: ector-multi
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Emiliano Mancuso
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-12-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: protest
+  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: sqlite3
+  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: Grouping multiple DB operations in a single transaction. 100% Inspired
+  by Ecto
+email:
+- emiliano.mancuso@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- ector-multi.gemspec
+- lib/ector-multi.rb
+- lib/ector-multi/errors.rb
+- lib/ector-multi/multi.rb
+- lib/ector-multi/operations.rb
+- lib/ector-multi/result.rb
+- rakefile
+- test/helper.rb
+- test/multi_test.rb
+- test/operations_test.rb
+- test/result_test.rb
+homepage: http://github.com/emancu/ector-multi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: Grouping multiple DB operations in a single transaction.
+test_files:
+- test/helper.rb
+- test/multi_test.rb
+- test/operations_test.rb
+- test/result_test.rb