dry-transaction 0.11.2 → 0.13.2

data/spec/integration/around_spec.rb

@@ -1,81 +0,0 @@
-RSpec.describe "around steps" do
-  include_context "db transactions"
-
-  include Dry::Monads::Result::Mixin
-
-  before do
-    container.instance_exec do
-      register :validate, -> input { Success(input) }
-
-      register :persist_user do |user:, **other|
-        self[:database] << [:user, user]
-        Success(other)
-      end
-
-      register :persist_account do |account: |
-        self[:database] << [:account, account]
-        Success(true)
-      end
-    end
-  end
-
-  let(:transaction) do
-    Class.new do
-      include Dry::Transaction(container: Test::Container)
-
-      step :validate
-      around :transaction
-      step :persist_user
-      step :persist_account
-      step :finalize
-    end
-  end
-
-  let(:input) { { user: { name: "Jane" }, account: { balance: 0 } } }
-
-  it "starts a transaction" do
-    called = false
-
-    finalize = -> x do
-      called = true
-      expect(database).to(be_in_transaction)
-      Success(x)
-    end
-
-    result = transaction.new(finalize: finalize).call(input)
-    expect(called).to be true
-    expect(result).to eql(Success(true))
-  end
-
-  it "commits transactions" do
-    transaction.new(finalize: -> x { Success(x) }).call(input)
-
-    expect(database).to be_committed
-    expect(database).not_to be_rolled_back
-    expect(database).not_to be_in_transaction
-    expect(database).to eql([[:user, name: "Jane"],
-                             [:account, balance: 0]])
-  end
-
-  it "rolls back transactions on failure" do
-    transaction.new(finalize: -> x { Failure(x) }).call(input)
-
-    expect(database).to be_rolled_back
-    expect(database).not_to be_in_transaction
-    expect(database).not_to be_committed
-    expect(database).to be_empty
-  end
-
-  it "rolls back transaction on exception" do
-    uncaught = Class.new(StandardError)
-
-    expect {
-      transaction.new(finalize: -> x { raise uncaught }).call(input)
-    }.to raise_error(uncaught)
-
-    expect(database).to be_rolled_back
-    expect(database).not_to be_in_transaction
-    expect(database).not_to be_committed
-    expect(database).to be_empty
-  end
-end

data/spec/integration/auto_injection_spec.rb

@@ -1,32 +0,0 @@
-require "dry-monads"
-require "dry-auto_inject"
-
-RSpec.describe "Using dry-auto_inject" do
-  let(:transaction) {
-    Class.new do
-      include Dry::Transaction(container: Test::Container)
-      include Test::Inject[:extract_email]
-
-      step :symbolize
-
-      def call(input)
-        super(input).bind(extract_email)
-      end
-    end.new
-  }
-
-  before do
-    module Test
-      Container = {
-        symbolize: -> input { Dry::Monads::Right(name: input["name"], email: input["email"]) },
-        extract_email: -> input { Dry::Monads::Right(email: input[:email]) },
-      }
-
-      Inject = Dry::AutoInject(container: Container)
-    end
-  end
-
-  it "support auto-injection of dependencies alongside step operations" do
-    expect(transaction.("name" => "Jane", "email" => "jane@example.com").value).to eq(email: "jane@example.com")
-  end
-end

data/spec/integration/custom_step_adapters_spec.rb

@@ -1,41 +0,0 @@
-RSpec.describe "Custom step adapters" do
-  let(:transaction) {
-    Class.new do
-      include Dry::Transaction(container: Test::Container, step_adapters: Test::CustomStepAdapters)
-
-      check :jane?, with: :jane?
-      map :process, with: :process
-      tee :persist, with: :persist
-      enqueue :deliver, with: :deliver
-    end.new
-  }
-
-  before do
-    Test::DB = []
-    Test::QUEUE = []
-
-    module Test
-      Container = {
-        jane?:   -> input { input["name"] == "Jane" },
-        process: -> input { {name: input["name"], email: input["email"]} },
-        persist: -> input { Test::DB << input and true },
-        deliver: -> input { "Delivered email to #{input[:email]}" },
-      }
-
-      class CustomStepAdapters < Dry::Transaction::StepAdapters
-        extend Dry::Monads::Result::Mixin
-
-        register :enqueue, -> operation, _options, args {
-          Test::QUEUE << operation.(*args)
-          Success(args[0])
-        }
-      end
-    end
-  end
-
-  it "supports custom step adapters" do
-    input = {"name" => "Jane", "email" => "jane@doe.com"}
-    transaction.call(input)
-    expect(Test::QUEUE).to include("Delivered email to jane@doe.com")
-  end
-end

data/spec/integration/operation_spec.rb

@@ -1,30 +0,0 @@
-require "dry/transaction/operation"
-
-RSpec.describe Dry::Transaction::Operation do
-  subject(:operation) {
-    Class.new do
-      include Dry::Transaction::Operation
-
-      def call(input)
-        Success(input)
-      end
-    end.new
-  }
-
-  it "mixes in the Result monad constructors" do
-    expect(operation.("hello")).to be_success
-  end
-
-  it "supports pattern matching when called with a block" do
-    result = operation.("hello") do |m|
-      m.success do |v|
-        "Success: #{v}"
-      end
-      m.failure do |v|
-        "Failure: #{v}"
-      end
-    end
-
-    expect(result).to eq "Success: hello"
-  end
-end

data/spec/integration/passing_step_arguments_spec.rb

@@ -1,51 +0,0 @@
-RSpec.describe "Passing additional arguments to step operations" do
-  let(:call_transaction) { transaction.with_step_args(step_options).call(input) }
-
-  let(:transaction) {
-    Class.new do
-      include Dry::Transaction(container: Test::Container)
-
-      map :process, with: :process
-      try :validate, with: :validate, catch: Test::NotValidError
-      tee :persist, with: :persist
-    end.new
-  }
-
-  let(:input) { {"name" => "Jane", "email" => "jane@doe.com"} }
-
-  before do
-    Test::NotValidError = Class.new(StandardError)
-    Test::DB = []
-    module Test
-      Container = {
-        process:  -> input { {name: input["name"], email: input["email"]} },
-        validate: -> input, allowed { !input[:email].include?(allowed) ? raise(Test::NotValidError, "email not allowed") : input },
-        persist:  -> input { Test::DB << input and true }
-      }
-    end
-  end
-
-  context "required arguments provided" do
-    let(:step_options) { {validate: ["doe.com"]} }
-
-    it "passes the arguments and calls the operations successfully" do
-      expect(call_transaction).to be_a Dry::Monads::Result::Success
-    end
-  end
-
-  context "required arguments not provided" do
-    let(:step_options) { {} }
-
-    it "raises an ArgumentError" do
-      expect { call_transaction }.to raise_error(ArgumentError)
-    end
-  end
-
-  context "spurious arguments provided" do
-    let(:step_options) { {validate: ["doe.com"], bogus: ["not matching any step"]} }
-
-    it "raises an ArgumentError" do
-      expect { call_transaction }.to raise_error(ArgumentError)
-    end
-  end
-end

data/spec/integration/publishing_step_events_spec.rb

@@ -1,119 +0,0 @@
-RSpec.describe "publishing step events" do
-  let(:container) {
-    Class.new do
-      extend Dry::Container::Mixin
-
-      register :process, -> input { {name: input["name"]} }
-      register :verify,  -> input { input[:name].to_s != "" ? Dry::Monads.Success(input) : Dry::Monads.Failure("no name") }
-      register :persist, -> input { Test::DB << input and true }
-    end
-  }
-
-  let(:transaction) {
-    Class.new do
-      include Dry::Transaction(container: Test::Container)
-
-      map :process, with: :process
-      step :verify, with: :verify
-      tee :persist, with: :persist
-    end.new
-  }
-
-  let(:subscriber) 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 << {step_name: event[:step_name], args: event[:args]}
-      end
-      def on_step_failed(event)
-        failed << {step_name: event[:step_name], args: event[:args], value: event[:value]}
-      end
-    end.new
-  end
-
-  before do
-    Test::DB = []
-    Test::Container = container
-  end
-
-  context "subscribing to all step events" do
-    before do
-      transaction.subscribe(subscriber)
-    end
-
-    specify "subscriber receives success events" do
-      transaction.call("name" => "Jane")
-
-      expected_result = [
-        { step_name: :process, args: [ {"name" => "Jane"} ] },
-        { step_name: :verify, args: [ { name: "Jane" } ] },
-        { step_name: :persist, args: [ { name: "Jane" } ] }
-      ]
-
-      expect(subscriber.success).to eq expected_result
-    end
-
-    specify "subsriber receives success events for passing steps, a failure event for the failing step, and no subsequent events" do
-      transaction.call("name" => "")
-
-      expect(subscriber.success).to eq [ { step_name: :process, args:[ { "name" => "" } ] } ]
-      expect(subscriber.failed).to eq [ { step_name: :verify, args: [ { name: ""} ],  value: "no name" } ]
-    end
-  end
-
-  context "subscribing to particular step events" do
-    before do
-      transaction.subscribe(verify: subscriber)
-    end
-
-    specify "subscriber receives success event for the specified step" do
-      transaction.call("name" => "Jane")
-
-      expect(subscriber.success).to eq [ { step_name: :verify, args: [ { name: "Jane" } ] } ]
-    end
-
-    specify "subscriber receives failure event for the specified step" do
-      transaction.call("name" => "")
-
-      expect(subscriber.failed).to eq [ { step_name: :verify, args: [ { name: ""} ],  value: "no name" } ]
-    end
-  end
-
-  context "subscribing to step events when passing step arguments" do
-    before do
-      transaction.subscribe(verify: subscriber)
-    end
-
-    let(:container) {
-      Class.new do
-        extend Dry::Container::Mixin
-
-        register :process, -> input { {name: input["name"]} }
-        register :verify,  -> input, name { input[:name].to_s == name ? Dry::Monads.Success(input) : Dry::Monads.Failure("wrong name") }
-        register :persist, -> input { Test::DB << input and true }
-      end
-    }
-
-    specify "subscriber receives success event for the specified step" do
-      transaction.with_step_args(verify: ["Jane"]).call("name" => "Jane")
-
-      expect(subscriber.success).to eq [ { step_name: :verify, args: [ { name: "Jane" }, "Jane"] } ]
-    end
-
-    specify "subscriber receives failure event for the specified step" do
-      transaction.with_step_args(verify: ["Jade"]).call("name" => "")
-
-      expect(subscriber.failed).to eq [ { step_name: :verify, args: [ { name: "" }, "Jade"], value: "wrong name"} ]
-    end
-  end
-end

data/spec/integration/transaction_spec.rb

@@ -1,566 +0,0 @@
-RSpec.describe "Transactions" do
-  include_context "database"
-
-  include Dry::Monads::Result::Mixin
-
-  let(:dependencies) { {} }
-
-  before do
-    container.instance_exec do
-      register :process,  -> input { {name: input["name"], email: input["email"]} }
-      register :verify,   -> input { Success(input) }
-      register :validate, -> input { input[:email].nil? ? raise(Test::NotValidError, "email required") : input }
-      register :persist,  -> input { self[:database] << input and true }
-    end
-  end
-
-  context "successful" do
-    let(:transaction) {
-      Class.new do
-        include Dry::Transaction(container: Test::Container)
-        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(database).to include(name: "Jane", email: "jane@doe.com")
-    end
-
-    it "returns a success" do
-      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")
-    end
-
-    it "can be called multiple times to the same effect" do
-      transaction.call(input)
-      transaction.call(input)
-
-      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
-      results = []
-
-      transaction.call(input) 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 "different step names" do
-    before do
-      class Test::ContainerNames
-        extend Dry::Container::Mixin
-        register :process_step,  -> input { {name: input["name"], email: input["email"]} }
-        register :verify_step,   -> input { Dry::Monads::Success(input) }
-        register :persist_step,  -> input { Test::DB << input and true }
-      end
-    end
-
-    let(:transaction) {
-      Class.new do
-        include Dry::Transaction(container: Test::ContainerNames)
-
-        map :process, with: :process_step
-        step :verify, with: :verify_step
-        tee :persist, with: :persist_step
-      end.new(**dependencies)
-    }
-
-    it "supports steps using differently named container operations" do
-      transaction.call("name" => "Jane", "email" => "jane@doe.com")
-      expect(database).to include(name: "Jane", email: "jane@doe.com")
-    end
-  end
-
-  describe "operation injection" do
-    let(:transaction) {
-      Class.new do
-        include Dry::Transaction(container: Test::Container)
-          map :process
-          step :verify_step, with: :verify
-          tee :persist
-      end.new(**dependencies)
-    }
-
-    let(:dependencies) {
-      {verify_step: -> input { Success(input.merge(foo: :bar)) }}
-    }
-
-    it "calls injected operations" do
-      transaction.call("name" => "Jane", "email" => "jane@doe.com")
-
-      expect(database).to include(name: "Jane", email: "jane@doe.com", foo: :bar)
-    end
-  end
-
-  context "wrapping operations with 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
-
-        def verify(input)
-          new_input = input.merge(greeting: "hello!")
-          super(new_input)
-        end
-      end.new(**dependencies)
-    end
-
-    let(:dependencies) { {} }
-
-    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
-
-  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
-
-  context "operation injection of step only defined in the transaction class not in the container" do
-    let(:transaction) do
-      Class.new do
-        include Dry::Transaction
-
-        step :process
-
-        def process(input)
-          new_input = input << :world
-          super(new_input)
-        end
-      end.new(**dependencies)
-    end
-
-    let(:dependencies) do
-      {process: -> input { Failure(input)} }
-    end
-
-    it "execute the transaction and execute the injected operation" do
-      result = transaction.call([:hello])
-
-      expect(result).to eq (Failure([:hello, :world]))
-    end
-  end
-
-  context "operation injection of step without container and no transaction instance methods" do
-    let(:transaction) do
-      Class.new do
-        include Dry::Transaction
-
-        map :process
-        step :verify
-        try :validate, catch: Test::NotValidError
-        tee :persist
-
-      end.new(**dependencies)
-    end
-
-    let(:dependencies) do
-      {
-        process:  -> input { {name: input["name"], email: input["email"]} },
-        verify:  -> input { Success(input) },
-        validate: -> input { input[:email].nil? ? raise(Test::NotValidError, "email required") : input },
-        persist:  -> input { database << input and true }
-      }
-    end
-
-    let(:input) { {"name" => "Jane", "email" => "jane@doe.com"} }
-
-    it "calls the injected operations" do
-      transaction.call(input)
-      expect(database).to include(name: "Jane", email: "jane@doe.com")
-    end
-  end
-
-  context "operation injection of step without container and no transaction instance methods but missing an injected operation" do
-    let(:transaction) do
-      Class.new do
-        include Dry::Transaction
-
-        map :process
-        step :verify
-        try :validate, catch: Test::NotValidError
-        tee :persist
-
-      end.new(**dependencies)
-    end
-
-    let(:dependencies) do
-      {
-        process:  -> input { {name: input["name"], email: input["email"]} },
-        verify:  -> input { Success(input) },
-        validate: -> input { input[:email].nil? ? raise(Test::NotValidError, "email required") : input }
-      }
-    end
-
-    let(:input) { {"name" => "Jane", "email" => "jane@doe.com"} }
-
-    it "raises an exception" do
-      expect { transaction }.to raise_error(Dry::Transaction::MissingStepError)
-    end
-  end
-
-  context "local step definition" do
-    let(:transaction) do
-      Class.new do
-        include Dry::Transaction(container: Test::Container)
-
-        map :process, with: :process
-        step :verify
-        tee :persist, with: :persist
-
-        def verify(input)
-          Success(input.keys)
-        end
-      end.new
-    end
-
-    it "execute step only defined as local method" do
-      transaction.call("name" => "Jane", "email" => "jane@doe.com")
-
-      expect(database).to include([:name, :email])
-    end
-  end
-
-  context "local step definition not in container" do
-    let(:transaction) do
-      Class.new do
-        include Dry::Transaction(container: Test::Container)
-
-        map :process, with: :process
-        step :verify_only_local
-        tee :persist, with: :persist
-
-        def verify_only_local(input)
-          Success(input.keys)
-        end
-      end.new
-    end
-
-    it "execute step only defined as local method" do
-      transaction.call("name" => "Jane", "email" => "jane@doe.com")
-
-      expect(database).to include([:name, :email])
-    end
-  end
-
-
-  context "all steps are local methods" do
-    let(:transaction) do
-      Class.new do
-        include Dry::Transaction
-
-        map :process
-        step :verify
-        tee :persist
-
-        def process(input)
-          input.to_a
-        end
-
-        def verify(input)
-          Success(input)
-        end
-
-        def persist(input)
-          Test::Container[:database] << input and true
-        end
-      end.new
-    end
-
-    it "executes succesfully" do
-      transaction.call("name" => "Jane", "email" => "jane@doe.com")
-      expect(database).to include([["name", "Jane"], ["email", "jane@doe.com"]])
-    end
-  end
-
-  context "failed in a try step" do
-    let(:transaction) {
-      Class.new do
-        include Dry::Transaction(container: Test::Container)
-        map :process
-        step :verify
-        try :validate, catch: Test::NotValidError
-        tee :persist
-      end.new(**dependencies)
-    }
-    let(:input) { {"name" => "Jane"} }
-
-    it "does not run subsequent operations" do
-      transaction.call(input)
-      expect(database).to be_empty
-    end
-
-    it "returns a failure" do
-      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).left).to be_a Test::NotValidError
-    end
-
-    it "supports matching on failure" do
-      results = []
-
-      transaction.call(input) do |m|
-        m.success { }
-
-        m.failure do |value|
-          results << "Failed: #{value}"
-        end
-      end
-
-      expect(results.first).to eq "Failed: email required"
-    end
-
-    it "supports matching on specific step failures" do
-      results = []
-
-      transaction.call(input) do |m|
-        m.success { }
-
-        m.failure :validate do |value|
-          results << "Validation failure: #{value}"
-        end
-      end
-
-      expect(results.first).to eq "Validation failure: email required"
-    end
-
-    it "supports matching on un-named step failures" do
-      results = []
-
-      transaction.call(input) do |m|
-        m.success { }
-
-        m.failure :some_other_step do |value|
-          results << "Some other step failure"
-        end
-
-        m.failure do |value|
-          results << "Catch-all failure: #{value}"
-        end
-      end
-
-      expect(results.first).to eq "Catch-all failure: email required"
-    end
-  end
-
-  context "failed in a raw step" do
-    let(:input) { {"name" => "Jane", "email" => "jane@doe.com"} }
-
-    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 { Failure("raw failure") }
-        register :persist_step,  -> input { self[:database] << input and true }
-      end
-    end
-
-    let(:transaction) {
-      Class.new do
-        include Dry::Transaction(container: Test::ContainerRaw)
-
-        map :process, with: :process_step
-        step :verify, with: :verify_step
-        tee :persist, with: :persist_step
-      end.new(**dependencies)
-    }
-
-    it "does not run subsequent operations" do
-      transaction.call(input)
-      expect(database).to be_empty
-    end
-
-    it "returns a failure" do
-      expect(transaction.call(input)).to be_a_failure
-    end
-
-    it "returns the failing value from the operation" do
-      expect(transaction.call(input).left).to eq "raw failure"
-    end
-
-    it "returns an object that quacks like expected" do
-      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).left
-
-      expect { result.print('') }.to raise_error(NoMethodError)
-    end
-  end
-
-  context "non-confirming raw step result" do
-    let(:input) { {"name" => "Jane", "email" => "jane@doe.com"} }
-
-    let(:transaction) {
-      Class.new do
-        include Dry::Transaction(container: Test::ContainerRaw)
-        map :process
-        step :verify
-        tee :persist
-      end.new(**dependencies)
-    }
-
-    before do
-      class Test::ContainerRaw
-        extend Dry::Container::Mixin
-        register :process,  -> input { {name: input["name"], email: input["email"]} }
-        register :verify,   -> input { "failure" }
-        register :persist,  -> input { Test::DB << input and true }
-      end
-    end
-
-    it "raises an exception" 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