dry-transaction 0.9.0 → 0.10.0

data/spec/integration/custom_matcher_spec.rb

@@ -1,59 +0,0 @@
-require "dry-matcher"
-require "dry-monads"
-
-RSpec.describe "Custom matcher" do
-  let(:transaction) {
-    Dry.Transaction(container: container, matcher: Test::CustomMatcher) do
-      step :process
-      step :validate, failure: :bad_value
-      step :persist
-    end
-  }
-
-  let(:container) {
-    {
-      process: -> input { Dry::Monads.Right(name: input["name"], email: input["email"]) },
-      validate: -> input { input[:email].nil? ? Dry::Monads.Left(:email_required) : Dry::Monads.Right(input) },
-      persist:  -> input { Test::DB << input and Dry::Monads.Right(input) }
-    }
-  }
-
-  before do
-    Test::DB = []
-    Test::QUEUE = []
-
-    module Test
-      CustomMatcher = Dry::Matcher.new(
-        yep: Dry::Matcher::Case.new(
-          match: -> result { result.right? },
-          resolve: -> result { result.value }
-        ),
-        nup: Dry::Matcher::Case.new(
-          match: -> result, failure = nil {
-            if failure
-              result.left? && result.value.step.options[:failure] == failure
-            else
-              result.left?
-            end
-          },
-          resolve: -> result { result.value.value }
-        )
-      )
-    end
-  end
-
-  it "supports a custom matcher" do
-    matches = -> m {
-      m.yep { |v| "Yep! #{v[:email]}" }
-      m.nup(:bad_value) { |v| "Nup. #{v.to_s}" }
-    }
-
-    input = {"name" => "Jane", "email" => "jane@doe.com"}
-    result = transaction.(input, &matches)
-    expect(result).to eq "Yep! jane@doe.com"
-
-    input = {"name" => "Jane"}
-    result = transaction.(input, &matches)
-    expect(result).to eq "Nup. email_required"
-  end
-end

data/spec/unit/step_definition_spec.rb

@@ -1,32 +0,0 @@
-RSpec.describe Dry::Transaction::StepDefinition do
-  let(:container) do
-    { test: -> input { "This is a test with input: #{input.inspect}" } }
-  end
-
-  let(:step_definition) do
-    Dry::Transaction::StepDefinition.new(container) do |input|
-      Right(container[:test].call(input))
-    end
-  end
-
-  it { expect(step_definition).to be_kind_of(Dry::Monads::Either::Mixin) }
-
-  describe '#initialize' do
-    subject! { step_definition }
-
-    it { is_expected.to be_frozen }
-  end
-
-  describe '#call' do
-    let(:input) { { test: 'test' } }
-
-    subject!(:result) { step_definition.call(input) }
-
-    it do
-      expect(result.value).to eq(
-        "This is a test with input: {:test=>\"test\"}"
-      )
-    end
-    it { is_expected.to be_a(Dry::Monads::Either::Right) }
-  end
-end

data/spec/unit/transaction_spec.rb

@@ -1,209 +0,0 @@
-RSpec.describe Dry::Transaction do
-  subject(:container) {
-    {
-      upcase: -> input { input.upcase },
-      reverse: -> input { input.reverse },
-      exclaim_all: -> input { input.split(" ").map { |str| str + "!" }.join(" ") },
-    }
-  }
-
-  describe "#prepend" do
-    let(:initial_transaction) {
-      Dry.Transaction(container: container) do
-        map :exclaim_all
-      end
-    }
-
-    it "prepends the transaction" do
-      other_transaction = Dry.Transaction(container: container) do
-        map :reverse
-      end
-      new_transaction = initial_transaction.prepend(other_transaction)
-
-      expect(new_transaction.call("hello world").right).to eq "dlrow! olleh!"
-    end
-
-    it "accepts a transaction defined in a block" do
-      new_transaction = initial_transaction.prepend(container: container) do
-        map :reverse
-      end
-
-      expect(new_transaction.call("hello world").right).to eq "dlrow! olleh!"
-    end
-
-    it "raises an argument error if a transaction is neither passed nor defined" do
-      expect { initial_transaction.prepend }.to raise_error(ArgumentError)
-    end
-
-    it "leaves the original transaction unmodified" do
-      _new_transaction = initial_transaction.prepend(container: container) do
-        map :reverse
-      end
-
-      expect(initial_transaction.call("the quick brown fox").right).to eq "the! quick! brown! fox!"
-    end
-  end
-
-  describe "#append" do
-    let(:initial_transaction) {
-      Dry.Transaction(container: container) do
-        map :exclaim_all
-      end
-    }
-
-    it "appends the transaction" do
-      other_transaction = Dry.Transaction(container: container) do
-        map :reverse
-      end
-      new_transaction = initial_transaction.append(other_transaction)
-
-      expect(new_transaction.call("hello world").right).to eq "!dlrow !olleh"
-    end
-
-    it "accepts a transaction defined in a block" do
-      new_transaction = initial_transaction.append(container: container) do
-        map :reverse
-      end
-
-      expect(new_transaction.call("hello world").right).to eq "!dlrow !olleh"
-    end
-
-    it "raises an argument error if a transaction is neither passed nor defined" do
-      expect { initial_transaction.insert(before: :reverse) }.to raise_error(ArgumentError)
-    end
-
-    it "leaves the original transaction unmodified" do
-      _new_transaction = initial_transaction.append(container: container) do
-        map :reverse
-      end
-
-      expect(initial_transaction.call("hello world").right).to eq "hello! world!"
-    end
-  end
-
-  describe "#remove" do
-    let(:initial_transaction) {
-      Dry.Transaction(container: container) do
-        map :upcase
-        map :exclaim_all
-        map :reverse
-      end
-    }
-
-    it "removes the specified steps" do
-      new_transaction = initial_transaction.remove(:exclaim_all, :reverse)
-      expect(new_transaction.call("hello world").right).to eq "HELLO WORLD"
-    end
-
-    it "leaves the original transaction unmodified" do
-      _new_transaction = initial_transaction.remove(:exclaim_all, :reverse)
-      expect(initial_transaction.call("hello world").right).to eq "!DLROW !OLLEH"
-    end
-  end
-
-  describe "#insert" do
-    let(:initial_transaction) {
-      Dry.Transaction(container: container) do
-        map :upcase
-        map :reverse
-      end
-    }
-
-    it "accepts a transaction passed as an argument" do
-      other_transaction = Dry.Transaction(container: container) do
-        map :exclaim_all
-      end
-      new_transaction = initial_transaction.insert(other_transaction, before: :reverse)
-
-      expect(new_transaction.call("hello world").right).to eq "!DLROW !OLLEH"
-    end
-
-    it "accepts a transaction defined in a block" do
-      new_transaction = initial_transaction.insert(before: :reverse, container: container) do
-        map :exclaim_all
-      end
-
-      expect(new_transaction.call("hello world").right).to eq "!DLROW !OLLEH"
-    end
-
-    it "raises an argument error if a transaction is neither passed nor defined" do
-      expect { initial_transaction.insert(before: :reverse) }.to raise_error(ArgumentError)
-    end
-
-    it "raises an argument error if an invalid step name is provided" do
-      expect {
-        initial_transaction.insert(before: :non_existent, container: container) do
-          map :exclaim_all
-        end
-      }.to raise_error(ArgumentError)
-    end
-
-    context "before" do
-      let!(:new_transaction) {
-        initial_transaction.insert(before: :reverse, container: container) do
-          map :exclaim_all
-        end
-      }
-
-      it "inserts the new steps before the specified one" do
-        expect(new_transaction.call("hello world").right).to eq "!DLROW !OLLEH"
-      end
-
-      it "leaves the original transaction unmodified" do
-        expect(initial_transaction.call("hello world").right).to eq "DLROW OLLEH"
-      end
-    end
-
-    context "after" do
-      let!(:new_transaction) {
-        initial_transaction.insert(after: :reverse, container: container) do
-          map :exclaim_all
-        end
-      }
-
-      it "inserts the new steps after the specified one" do
-        expect(new_transaction.call("hello world").right).to eq "DLROW! OLLEH!"
-      end
-
-      it "leaves the original transaction unmodified" do
-        expect(initial_transaction.call("hello world").right).to eq "DLROW OLLEH"
-      end
-    end
-
-    context "with code block explicitly passed to step" do
-      class WithBlockStepAdapters < ::Dry::Transaction::StepAdapters # :nodoc:
-        class WithBlock
-          include Dry::Monads::Either::Mixin
-          def call(step, input, *args, &cb)
-            Right(step.operation.((block_given? ? yield(input) : input), *args))
-          end
-        end
-        register :with_block, WithBlock.new
-      end
-      let!(:with_block_container) {
-        { exclaim_all: -> input { input.split(" ").map { |str| "#{str}!" }.join(" ") } }
-      }
-
-      let!(:no_block_transaction) {
-        Dry.Transaction(container: with_block_container, step_adapters: WithBlockStepAdapters) do
-          with_block :exclaim_all
-        end
-      }
-      let!(:with_block_transaction) {
-        Dry.Transaction(container: with_block_container, step_adapters: WithBlockStepAdapters) do
-          with_block :exclaim_all do |input|
-            input.gsub(/(?<=\s|\A)/, '¡')
-          end
-        end
-      }
-
-      it "inserts normal bangs without block given" do
-        expect(no_block_transaction.call("hello world").right).to eq "hello! world!"
-      end
-
-      it "inserts spanish bangs with block given" do
-        expect(with_block_transaction.call("hello world").right).to eq "¡hello! ¡world!"
-      end
-    end
-  end
-end