dry-transaction 0.10.2 → 0.11.0

data/spec/integration/transaction_spec.rb

@@ -1,15 +1,16 @@
 RSpec.describe "Transactions" do
+  include_context "database"
+
+  include Dry::Monads::Result::Mixin
+
   let(:dependencies) { {} }
 
   before do
-    Test::NotValidError = Class.new(StandardError)
-    Test::DB = []
-    class Test::Container
-      extend Dry::Container::Mixin
+    container.instance_exec do
       register :process,  -> input { {name: input["name"], email: input["email"]} }
-      register :verify,   -> input { Dry::Monads::Right(input) }
+      register :verify,   -> input { Success(input) }
       register :validate, -> input { input[:email].nil? ? raise(Test::NotValidError, "email required") : input }
-      register :persist,  -> input { Test::DB << input and true }
+      register :persist,  -> input { self[:database] << input and true }
     end
   end
 
@@ -17,33 +18,33 @@ RSpec.describe "Transactions" do
     let(:transaction) {
       Class.new do
         include Dry::Transaction(container: Test::Container)
-          map :process
-          step :verify
-          try :validate, catch: Test::NotValidError
-          tee :persist
+        map :process
+        step :verify
+        try :validate, catch: Test::NotValidError
+        tee :persist
       end.new(**dependencies)
     }
     let(:input) { {"name" => "Jane", "email" => "jane@doe.com"} }
 
     it "calls the operations" do
       transaction.call(input)
-      expect(Test::DB).to include(name: "Jane", email: "jane@doe.com")
+      expect(database).to include(name: "Jane", email: "jane@doe.com")
     end
 
     it "returns a success" do
-      expect(transaction.call(input)).to be_a Dry::Monads::Either::Right
+      expect(transaction.call(input)).to be_a Dry::Monads::Result::Success
     end
 
     it "wraps the result of the final operation" do
-      expect(transaction.call(input).value).to eq(name: "Jane", email: "jane@doe.com")
+      expect(transaction.call(input).value!).to eq(name: "Jane", email: "jane@doe.com")
     end
 
     it "can be called multiple times to the same effect" do
       transaction.call(input)
       transaction.call(input)
 
-      expect(Test::DB[0]).to eq(name: "Jane", email: "jane@doe.com")
-      expect(Test::DB[1]).to eq(name: "Jane", email: "jane@doe.com")
+      expect(database[0]).to eql(name: "Jane", email: "jane@doe.com")
+      expect(database[1]).to eql(name: "Jane", email: "jane@doe.com")
     end
 
     it "supports matching on success" do
@@ -66,7 +67,7 @@ RSpec.describe "Transactions" do
       class Test::ContainerNames
         extend Dry::Container::Mixin
         register :process_step,  -> input { {name: input["name"], email: input["email"]} }
-        register :verify_step,   -> input { Dry::Monads::Right(input) }
+        register :verify_step,   -> input { Dry::Monads::Success(input) }
         register :persist_step,  -> input { Test::DB << input and true }
       end
     end
@@ -83,7 +84,7 @@ RSpec.describe "Transactions" do
 
     it "supports steps using differently named container operations" do
       transaction.call("name" => "Jane", "email" => "jane@doe.com")
-      expect(Test::DB).to include(name: "Jane", email: "jane@doe.com")
+      expect(database).to include(name: "Jane", email: "jane@doe.com")
     end
   end
 
@@ -98,13 +99,13 @@ RSpec.describe "Transactions" do
     }
 
     let(:dependencies) {
-      {verify_step: -> input { Dry::Monads.Right(input.merge(foo: :bar)) }}
+      {verify_step: -> input { Success(input.merge(foo: :bar)) }}
     }
 
     it "calls injected operations" do
       transaction.call("name" => "Jane", "email" => "jane@doe.com")
 
-      expect(Test::DB).to include(name: "Jane", email: "jane@doe.com", foo: :bar)
+      expect(database).to include(name: "Jane", email: "jane@doe.com", foo: :bar)
     end
   end
 
@@ -129,7 +130,32 @@ RSpec.describe "Transactions" do
     it "allows local methods to run operations via super" do
       transaction.call("name" => "Jane", "email" => "jane@doe.com")
 
-      expect(Test::DB).to include(name: "Jane", email: "jane@doe.com", greeting: "hello!")
+      expect(database).to include(name: "Jane", email: "jane@doe.com", greeting: "hello!")
+    end
+  end
+
+  context "wrapping operations with private local methods" do
+    let(:transaction) do
+      Class.new do
+        include Dry::Transaction(container: Test::Container)
+
+        map :process, with: :process
+        step :verify, with: :verify
+        tee :persist, with: :persist
+
+        private
+
+        def verify(input)
+          new_input = input.merge(greeting: "hello!")
+          super(new_input)
+        end
+      end.new(**dependencies)
+    end
+
+    it "allows local methods to run operations via super" do
+      transaction.call("name" => "Jane", "email" => "jane@doe.com")
+
+      expect(database).to include(name: "Jane", email: "jane@doe.com", greeting: "hello!")
     end
   end
 
@@ -143,7 +169,7 @@ RSpec.describe "Transactions" do
         tee :persist, with: :persist
 
         def verify(input)
-          Right(input.keys)
+          Success(input.keys)
         end
       end.new
     end
@@ -151,7 +177,7 @@ RSpec.describe "Transactions" do
     it "execute step only defined as local method" do
       transaction.call("name" => "Jane", "email" => "jane@doe.com")
 
-      expect(Test::DB).to include([:name, :email])
+      expect(database).to include([:name, :email])
     end
   end
 
@@ -165,7 +191,7 @@ RSpec.describe "Transactions" do
         tee :persist, with: :persist
 
         def verify_only_local(input)
-          Right(input.keys)
+          Success(input.keys)
         end
       end.new
     end
@@ -173,7 +199,7 @@ RSpec.describe "Transactions" do
     it "execute step only defined as local method" do
       transaction.call("name" => "Jane", "email" => "jane@doe.com")
 
-      expect(Test::DB).to include([:name, :email])
+      expect(database).to include([:name, :email])
     end
   end
 
@@ -192,18 +218,18 @@ RSpec.describe "Transactions" do
         end
 
         def verify(input)
-          Dry::Monads.Right(input)
+          Success(input)
         end
 
         def persist(input)
-          Test::DB << input and true
+          Test::Container[:database] << input and true
         end
       end.new
     end
 
     it "executes succesfully" do
       transaction.call("name" => "Jane", "email" => "jane@doe.com")
-      expect(Test::DB).to include([["name", "Jane"], ["email", "jane@doe.com"]])
+      expect(database).to include([["name", "Jane"], ["email", "jane@doe.com"]])
     end
   end
 
@@ -221,15 +247,15 @@ RSpec.describe "Transactions" do
 
     it "does not run subsequent operations" do
       transaction.call(input)
-      expect(Test::DB).to be_empty
+      expect(database).to be_empty
     end
 
     it "returns a failure" do
-      expect(transaction.call(input)).to be_a Dry::Monads::Either::Left
+      expect(transaction.call(input)).to be_a Dry::Monads::Result::Failure
     end
 
     it "wraps the result of the failing operation" do
-      expect(transaction.call(input).value).to be_a Test::NotValidError
+      expect(transaction.call(input).left).to be_a Test::NotValidError
     end
 
     it "supports matching on failure" do
@@ -285,9 +311,10 @@ RSpec.describe "Transactions" do
     before do
       class Test::ContainerRaw
         extend Dry::Container::Mixin
+        extend Dry::Monads::Result::Mixin
         register :process_step,  -> input { {name: input["name"], email: input["email"]} }
-        register :verify_step,   -> input { Dry::Monads::Left("raw failure") }
-        register :persist_step,  -> input { Test::DB << input and true }
+        register :verify_step,   -> input { Failure("raw failure") }
+        register :persist_step,  -> input { self[:database] << input and true }
       end
     end
 
@@ -303,25 +330,25 @@ RSpec.describe "Transactions" do
 
     it "does not run subsequent operations" do
       transaction.call(input)
-      expect(Test::DB).to be_empty
+      expect(database).to be_empty
     end
 
     it "returns a failure" do
-      expect(transaction.call(input)).to be_a Dry::Monads::Either::Left
+      expect(transaction.call(input)).to be_a_failure
     end
 
     it "returns the failing value from the operation" do
-      expect(transaction.call(input).value).to eq "raw failure"
+      expect(transaction.call(input).left).to eq "raw failure"
     end
 
     it "returns an object that quacks like expected" do
-      result = transaction.call(input).value
+      result = transaction.call(input).left
 
       expect(Array(result)).to eq(['raw failure'])
     end
 
     it "does not allow to call private methods on the result accidently" do
-      result = transaction.call(input).value
+      result = transaction.call(input).left
 
       expect { result.print('') }.to raise_error(NoMethodError)
     end
@@ -352,4 +379,105 @@ RSpec.describe "Transactions" do
       expect { transaction.call(input) }.to raise_error(ArgumentError)
     end
   end
+
+  context "keyword arguments" do
+    let(:input) { { name: 'jane', age: 20 } }
+
+    let(:upcaser) do
+      Class.new {
+        include Dry::Monads::Result::Mixin
+
+        def call(name: 'John', **rest)
+          Success(name: name[0].upcase + name[1..-1], **rest)
+        end
+      }.new
+    end
+
+    let(:transaction) do
+      Class.new {
+        include Dry::Transaction
+
+        step :camelize
+
+      }.new(camelize: upcaser)
+    end
+
+    it "calls the operations" do
+      expect(transaction.(input).value).to eql(name: 'Jane', age: 20)
+    end
+  end
+
+  context "invalid steps" do
+    context "non-callable step" do
+      context "with container" do
+        let(:input) { {} }
+
+        let(:transaction) {
+          Class.new do
+            include Dry::Transaction(container: Test::ContainerRaw)
+            map :not_a_proc
+          end.new
+        }
+
+        before do
+          class Test::ContainerRaw
+            extend Dry::Container::Mixin
+
+            register :not_a_proc, "definitely not a proc"
+          end
+        end
+
+        it "raises an exception" do
+          expect { transaction.call(input) }.to raise_error(Dry::Transaction::InvalidStepError)
+        end
+      end
+    end
+
+    context "missing steps" do
+      context "no container" do
+        let(:input) { {} }
+
+        let(:transaction) {
+          Class.new do
+            include Dry::Transaction
+            map :noop
+            map :i_am_missing
+
+            def noop
+              Success(input)
+            end
+          end.new
+        }
+
+        it "raises an exception" do
+          expect { transaction.call(input) }.to raise_error(Dry::Transaction::MissingStepError)
+        end
+      end
+
+      context "with container" do
+        let(:input) { {} }
+
+        let(:transaction) {
+          Class.new do
+            include Dry::Transaction(container: Test::ContainerRaw)
+            map :noop
+            map :i_am_missing
+
+          end.new
+        }
+
+        before do
+          class Test::ContainerRaw
+            extend Dry::Container::Mixin
+
+            register :noop, -> input { Success(input) }
+          end
+        end
+
+        it "raises an exception" do
+          expect { transaction.call(input) }.to raise_error(Dry::Transaction::MissingStepError)
+        end
+      end
+    end
+  end
 end

data/spec/integration/transaction_without_steps_spec.rb

@@ -0,0 +1,101 @@
+RSpec.describe "Transactions steps without arguments" do
+  let(:dependencies) { {} }
+
+  before do
+    Test::NotValidError = Class.new(StandardError)
+    Test::DB = [{"name" => "Jane", "email" => "jane@doe.com"}]
+    Test::Http = Class.new do
+      def self.get
+        "pong"
+      end
+
+      def self.post(value)
+        Test::DB <<  value
+      end
+    end
+    class Test::Container
+      extend Dry::Container::Mixin
+      register :fetch_data,     -> { Test::DB.delete_at(0) }, call: false
+      register :call_outside,   -> { Test::Http.get }, call: false
+      register :external_store, -> input { Test::Http.post(input) }
+      register :process,        -> input { { name: input["name"], email: input["email"] } }
+      register :validate,       -> input { input[:email].nil? ? raise(Test::NotValidError, "email required") : input }
+      register :persist,        -> input { Test::DB << input and true }
+    end
+  end
+
+  context "successful" do
+    let(:transaction) {
+      Class.new do
+        include Dry::Transaction(container: Test::Container)
+          map :fetch_data
+          map :process
+          try :validate, catch: Test::NotValidError
+          tee :persist
+      end.new(**dependencies)
+    }
+
+    it "calls the operations" do
+      transaction.call
+      expect(Test::DB).to include(name: "Jane", email: "jane@doe.com")
+    end
+
+    it "returns a success" do
+      expect(transaction.call()).to be_a Dry::Monads::Result::Success
+    end
+
+    it "wraps the result of the final operation" do
+      expect(transaction.call().value!).to eq(name: "Jane", email: "jane@doe.com")
+    end
+
+    it "supports matching on success" do
+      results = []
+
+      transaction.call() do |m|
+        m.success do |value|
+          results << "success for #{value[:email]}"
+        end
+
+        m.failure { }
+      end
+
+      expect(results.first).to eq "success for jane@doe.com"
+    end
+  end
+
+  context "using multiple tee step operators" do
+    let(:transaction) {
+      Class.new do
+        include Dry::Transaction(container: Test::Container)
+          tee :call_outside
+          map :fetch_data
+          map :process
+          try :validate, catch: Test::NotValidError
+          tee :external_store
+      end.new(**dependencies)
+    }
+
+    it "calls the operations" do
+      transaction.call
+      expect(Test::DB).to include(name: "Jane", email: "jane@doe.com")
+    end
+  end
+
+  context "not needing arguments in the middle of the transaction" do
+    let(:transaction) {
+      Class.new do
+        include Dry::Transaction(container: Test::Container)
+          map :process
+          try :validate, catch: Test::NotValidError
+          tee :call_outside
+          tee :external_store
+      end.new(**dependencies)
+    }
+    let(:input) { {"name" => "Jane", "email" => "jane@doe.com"} }
+
+    it "calls the operations" do
+      transaction.call(input)
+      expect(Test::DB).to include(name: "Jane", email: "jane@doe.com")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,12 +1,19 @@
-if RUBY_ENGINE == "ruby" && RUBY_VERSION >= "2.4"
-  require "simplecov"
-  SimpleCov.start do
-    add_filter "/spec/"
+if RUBY_ENGINE == 'ruby' && ENV['COVERAGE'] == 'true'
+  require 'yaml'
+  rubies = YAML.load(File.read(File.join(__dir__, '..', '.travis.yml')))['rvm']
+  latest_mri = rubies.select { |v| v =~ /\A\d+\.\d+.\d+\z/ }.max
+
+  if RUBY_VERSION == latest_mri
+    require 'simplecov'
+    SimpleCov.start do
+      add_filter '/spec/'
+    end
   end
 end
 
 begin
-  require "byebug"
+  require "pry"
+  require "pry-byebug"
 rescue LoadError; end
 
 require "dry-transaction"
@@ -104,4 +111,6 @@ RSpec.configure do |config|
   # test failures related to randomization by passing the same `--seed` value
   # as the one that triggered the failure.
   Kernel.srand config.seed
+
+  config.include Dry::Monads::Result::Mixin, adapter: true
 end

data/spec/support/container.rb

@@ -0,0 +1,10 @@
+RSpec.shared_context "container" do
+  before do
+    class Test::Container
+      extend Dry::Container::Mixin
+      extend Dry::Monads::Result::Mixin
+    end
+  end
+
+  let(:container) { Test::Container }
+end

data/spec/support/database.rb

@@ -0,0 +1,12 @@
+RSpec.shared_context "database" do
+  include_context "container"
+
+  before do
+    Test::NotValidError = Class.new(StandardError)
+    Test::DB = []
+
+    Test::Container.register(:database, Test::DB)
+  end
+
+  let(:database) { Test::DB }
+end

data/spec/support/db_transactions.rb

@@ -0,0 +1,45 @@
+RSpec.shared_context "db transactions" do
+  include_context "database"
+
+  before do
+    Test::Rollback = Class.new(StandardError)
+
+    class << Test::DB
+      attr_accessor :in_transaction, :rolled_back, :committed
+      alias_method :in_transaction?, :in_transaction
+      alias_method :rolled_back?, :rolled_back
+      alias_method :committed?, :committed
+
+      def transaction
+        self.in_transaction = true
+        self.rolled_back = false
+        self.committed = false
+
+        yield.tap do
+          self.committed = true
+        end
+      rescue => error
+        self.rolled_back = true
+        clear
+
+        raise error
+      ensure
+        self.in_transaction = false
+      end
+    end
+
+    container.register(:transaction) do |input, &block|
+      result = nil
+
+      begin
+        Test::DB.transaction do
+          result = block.(Success(input))
+          raise Test::Rollback if result.failure?
+          result
+        end
+      rescue Test::Rollback
+        result
+      end
+    end
+  end
+end

data/spec/support/result_mixin.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.include Dry::Monads::Result::Mixin
+end

data/spec/unit/step_adapters/around_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe Dry::Transaction::StepAdapters::Around, :adapter do
+  subject { described_class.new }
+
+  let(:operation) {
+    -> (input, &block) { block.(Success(input.upcase)) }
+  }
+
+  let(:options) { { step_name: "unit" } }
+
+  let(:continue) do
+    -> (input) { input.fmap { |v| v + " terminated" } }
+  end
+
+  describe "#call" do
+    context "when the result of the operation is NOT a Dry::Monads::Result" do
+      let(:continue) do
+        -> (input) { "plain string" }
+      end
+
+      it "raises an InvalidResultError" do
+        expect {
+          subject.(operation, options, ["input"], &continue)
+        }.to raise_error(
+               Dry::Transaction::InvalidResultError,
+               "step +unit+ must return a Result object"
+             )
+      end
+    end
+
+    context "passing a block" do
+      it "returns a Success value with result from block" do
+        expect(subject.(operation, options, ["input"], &continue)).to eql(Success("INPUT terminated"))
+      end
+    end
+
+    context "when the result of the operation is a Failure value" do
+      let(:operation) {
+        -> (input, &block) { block.(Failure(input.upcase)) }
+      }
+
+      it "return a Failure value" do
+        expect(subject.(operation, options, ["input"], &continue)).to eql(Failure("INPUT"))
+      end
+    end
+  end
+end

data/spec/unit/step_adapters/check_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe Dry::Transaction::StepAdapters::Check, :adapter do
+
+  subject { described_class.new }
+
+  let(:operation) {
+    -> (input) { input == "right" }
+  }
+
+  let(:options) { { step_name: "unit" } }
+
+  describe "#call" do
+
+    it "returns the result of the operation as output" do
+      expect(subject.(operation, options, ["right"])).to eql(Success("right"))
+    end
+
+    context "when check fails" do
+      it "return a Failure" do
+        expect(subject.(operation, options, ["wrong"])).to eql(Failure("wrong"))
+      end
+    end
+
+    context "when operation return right monad" do
+      let(:operation) {
+        -> (input) { Success(true) }
+      }
+
+      it "return a Success" do
+        expect(subject.(operation, options, ["input"])).to eql(Success("input"))
+      end
+    end
+
+    context "when operation return left monad" do
+      let(:operation) {
+        -> (input) { Failure(true) }
+      }
+
+      it "return a Failure" do
+        expect(subject.(operation, options, ["input"])).to eql(Failure("input"))
+      end
+    end
+  end
+end

data/spec/unit/step_adapters/map_spec.rb

@@ -1,23 +1,16 @@
-RSpec.describe Dry::Transaction::StepAdapters::Map do
+RSpec.describe Dry::Transaction::StepAdapters::Map, :adapter do
 
   subject { described_class.new }
 
+  let(:options) { {} }
+
   let(:operation) {
     -> (input) { input.upcase }
   }
 
-  let(:step) {
-    Dry::Transaction::Step.new(subject, :step, :step, operation, {})
-  }
-
   describe "#call" do
-
-    it "return a Right Monad" do
-      expect(subject.call(step, 'input')).to be_a Dry::Monads::Either::Right
-    end
-
-    it "return the result of the operation as output" do
-      expect(subject.call(step, 'input').value).to eql 'INPUT'
+    it "return a Success value" do
+      expect(subject.(operation, options, 'input')).to eql(Success('INPUT'))
     end
   end
 end