dry-transaction 0.12.0 → 0.13.3

data/spec/unit/step_adapters/tee_spec.rb

@@ -1,17 +0,0 @@
-RSpec.describe Dry::Transaction::StepAdapters::Tee, :adapter do
-
-  subject { described_class.new }
-
-  let(:operation) {
-    -> (input) { input.upcase }
-  }
-
-  let(:options) { { step_name: "unit" } }
-
-  describe "#call" do
-
-    it "return a Success value" do
-      expect(subject.(operation, options, ["input"])).to eql(Success("input"))
-    end
-  end
-end

data/spec/unit/step_adapters/try_spec.rb

@@ -1,89 +0,0 @@
-RSpec.describe Dry::Transaction::StepAdapters::Try do
-
-  subject { described_class.new }
-
-  let(:operation) {
-    -> (input) {
-      raise(Test::NotValidError, 'not a string') unless input.is_a? String
-      input.upcase
-    }
-  }
-
-  let(:options) { { catch: Test::NotValidError, step_name: "unit" } }
-
-  before do
-    Test::NotValidError = Class.new(StandardError)
-    Test::BetterNamingError = Class.new(StandardError)
-  end
-
-  describe "#call" do
-
-    context "without the :catch option" do
-      let(:options) { { step_name: "unit" } }
-
-      it "raises an ArgumentError" do
-        expect {
-          subject.(operation, options, ["something"])
-        }.to raise_error(
-               Dry::Transaction::MissingCatchListError,
-               "step +unit+ requires one or more exception classes provided via +catch:+"
-             )
-      end
-    end
-
-    context "with the :catch option" do
-
-      context "when the error was raised" do
-
-        it "returns a Failure value" do
-          expect(subject.(operation, options, [1234])).to be_a_failure
-        end
-
-        it "returns the raised error as output" do
-          result = subject.(operation, options, [1234])
-          expect(result.failure).to be_a Test::NotValidError
-          expect(result.failure.message).to eql("not a string")
-        end
-
-        context "when using the :raise option" do
-          let(:options) {
-            {
-              catch: Test::NotValidError,
-              raise: Test::BetterNamingError
-            }
-          }
-
-          it "returns a Failure value" do
-            expect(subject.(operation, options, [1234])).to be_a_failure
-          end
-
-          it "returns the error specified by :raise as output" do
-            result = subject.(operation, options, [1234])
-            expect(result.failure).to be_a Test::BetterNamingError
-            expect(result.failure.message).to eql("not a string")
-          end
-        end
-      end
-
-      context "when the error was NOT raised" do
-
-        it "returns a Success value" do
-          expect(subject.(operation, options, ["input"])).to eql(Success("INPUT"))
-        end
-
-        context "when using the :raise option" do
-          let(:options) {
-            {
-              catch: Test::NotValidError,
-              raise: Test::BetterNamingError
-            }
-          }
-
-          it "returns a Success value" do
-            expect(subject.(operation, options, ["input"])).to  eql(Success("INPUT"))
-          end
-        end
-      end
-    end
-  end
-end

data/spec/unit/step_spec.rb

@@ -1,131 +0,0 @@
-RSpec.describe Dry::Transaction::Step do
-  let(:step_adapter) { ->(step, input, *args) { step.operation.call(input, *args) } }
-  let(:step_name) { :test }
-  let(:operation_name) { step_name }
-
-  subject(:step) { described_class.new(step_adapter, step_name, operation_name, operation, {}) }
-
-  describe "#call" do
-    let(:listener) do
-      Class.new do
-        attr_reader :started, :success, :failed
-
-        def initialize
-          @started = []
-          @success = []
-          @failed = []
-        end
-
-        def on_step(event)
-          started << event[:step_name]
-        end
-        def on_step_succeeded(event)
-          success << "succeded_#{event[:step_name]}"
-        end
-        def on_step_failed(event)
-          failed << "failed_#{event[:step_name]}"
-        end
-      end.new
-    end
-
-    let(:input) { "input" }
-    subject { step.call(input) }
-
-    context "when operation succeeds" do
-      let(:operation) { proc { |input| Dry::Monads.Success(input) } }
-
-      it { is_expected.to be_success }
-
-      it "publishes step_succeeded" do
-        expect(listener).to receive(:on_step_succeeded).and_call_original
-        step.subscribe(listener)
-        subject
-
-        expect(listener.success).to eq ['succeded_test']
-      end
-    end
-
-    context "when operation starts" do
-      let(:operation) { proc { |input| Dry::Monads.Success(input) } }
-
-      it "publishes step" do
-        expect(listener).to receive(:on_step).and_call_original
-        step.subscribe(listener)
-        subject
-
-        expect(listener.started).to eq [:test]
-      end
-    end
-
-    context "when operation fails" do
-      let(:operation) { proc { |input| Dry::Monads.Failure("error") } }
-
-      it { is_expected.to be_failure }
-
-      it "wraps value in StepFailure" do
-        aggregate_failures do
-          expect(subject.failure).to be_a Dry::Transaction::StepFailure
-          expect(subject.failure.value).to eq "error"
-        end
-      end
-
-      it "publishes step_failed" do
-        expect(listener).to receive(:on_step_failed).and_call_original
-        step.subscribe(listener)
-        subject
-
-        expect(listener.failed).to eq ['failed_test']
-      end
-    end
-  end
-
-  describe "#with" do
-    let(:operation) { proc { |a, b| a + b } }
-    context "without arguments" do
-      it "returns itself" do
-        expect(step.with).to eq step
-      end
-    end
-
-    context "with operation argument" do
-      it "returns new instance with only operation changed" do
-        new_operation = proc { |a,b| a * b }
-        new_step = step.with(operation: new_operation)
-        expect(new_step).to_not eq step
-        expect(new_step.operation_name).to eq step.operation_name
-        expect(new_step.operation).to_not eq step.operation
-      end
-    end
-
-    context "with call_args argument" do
-      let(:call_args) { [12] }
-      it "returns new instance with only call_args changed" do
-        new_step = step.with(call_args: call_args)
-        expect(new_step).to_not eq step
-        expect(new_step.operation_name).to eq step.operation_name
-        expect(new_step.call_args).to_not eq step.call_args
-      end
-    end
-  end
-
-  describe "#arity" do
-    subject { step.arity }
-
-    context "when operation is a proc" do
-      let(:operation) { proc { |a, b| a + b } }
-      it { is_expected.to eq 2 }
-    end
-
-    context "when operation is an object with call method" do
-      let(:operation) do
-        Class.new do
-          def call(a, b, c)
-            a + b + c
-          end
-        end.new
-      end
-
-      it { is_expected.to eq 3 }
-    end
-  end
-end