dry-transaction 0.13.0 → 0.13.1

data/spec/integration/transaction_without_steps_spec.rb

@@ -1,101 +0,0 @@
-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, with: :fetch_data
-          map :process, with: :process
-          try :validate, with: :validate, catch: Test::NotValidError
-          tee :persist, with: :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, with: :call_outside
-          map :fetch_data, with: :fetch_data
-          map :process, with: :process
-          try :validate, with: :validate, catch: Test::NotValidError
-          tee :external_store, with: :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, with: :process
-          try :validate, with: :validate, catch: Test::NotValidError
-          tee :call_outside, with: :call_outside
-          tee :external_store, with: :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,116 +0,0 @@
-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 "pry"
-  require "pry-byebug"
-rescue LoadError; end
-
-require "dry-transaction"
-require "dry-matcher"
-require "dry-monads"
-require "dry-container"
-
-# Requires supporting ruby files with custom matchers and macros, etc, in
-# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
-# run as spec files by default. This means that files in spec/support that end
-# in _spec.rb will both be required and run as specs, causing the specs to be
-# run twice. It is recommended that you do not name files matching this glob to
-# end with _spec.rb. You can configure this pattern with the --pattern
-# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
-#
-# The following line is provided for convenience purposes. It has the downside
-# of increasing the boot-up time by auto-requiring all files in the support
-# directory. Alternatively, in the individual `*_spec.rb` files, manually
-# require only the support files necessary.
-Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")].each do |f| require f end
-
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause
-# this file to always be loaded, without a need to explicitly require it in any
-# files.
-#
-# Given that it is always loaded, you are encouraged to keep this file as
-# light-weight as possible. Requiring heavyweight dependencies from this file
-# will add to the boot time of your test suite on EVERY test run, even for an
-# individual file that may not need all of that loaded. Instead, consider making
-# a separate helper file that requires the additional dependencies and performs
-# the additional setup, and require it from the spec files that actually need
-# it.
-#
-# The `.rspec` file also contains a few flags that are not defaults but that
-# users commonly want.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  # rspec-expectations config goes here. You can use an alternate
-  # assertion/expectation library such as wrong or the stdlib/minitest
-  # assertions if you prefer.
-  config.expect_with :rspec do |expectations|
-    # This option will default to `true` in RSpec 4. It makes the `description`
-    # and `failure_message` of custom matchers include text for helper methods
-    # defined using `chain`, e.g.:
-    #     be_bigger_than(2).and_smaller_than(4).description
-    #     # => "be bigger than 2 and smaller than 4"
-    # ...rather than:
-    #     # => "be bigger than 2"
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  # rspec-mocks config goes here. You can use an alternate test double
-  # library (such as bogus or mocha) by changing the `mock_with` option here.
-  config.mock_with :rspec do |mocks|
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended, and will default to
-    # `true` in RSpec 4.
-    mocks.verify_partial_doubles = true
-  end
-
-  # Allows RSpec to persist some state between runs in order to support
-  # the `--only-failures` and `--next-failure` CLI options. We recommend
-  # you configure your source control system to ignore this file.
-  config.example_status_persistence_file_path = "spec/examples.txt"
-
-  # Limits the available syntax to the non-monkey patched syntax that is
-  # recommended.
-  config.disable_monkey_patching!
-
-  # This setting enables warnings. It's recommended, but in some cases may
-  # be too noisy due to issues in dependencies.
-  config.warnings = true
-
-  # Many RSpec users commonly either run the entire suite or an individual
-  # file, and it's useful to allow more verbose output when running an
-  # individual spec file.
-  if config.files_to_run.one?
-    # Use the documentation formatter for detailed output,
-    # unless a formatter has already been configured
-    # (e.g. via a command-line flag).
-    config.default_formatter = "doc"
-  end
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = :random
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # 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

@@ -1,10 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

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

data/spec/support/test_module_constants.rb

@@ -1,11 +0,0 @@
-module Test
-  def self.remove_constants
-    constants.each(&method(:remove_const))
-  end
-end
-
-RSpec.configure do |config|
-  config.after do
-    Test.remove_constants
-  end
-end

data/spec/unit/step_adapters/around_spec.rb

@@ -1,46 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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 failure 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,16 +0,0 @@
-RSpec.describe Dry::Transaction::StepAdapters::Map, :adapter do
-
-  subject { described_class.new }
-
-  let(:options) { {} }
-
-  let(:operation) {
-    -> (input) { input.upcase }
-  }
-
-  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/raw_spec.rb

@@ -1,36 +0,0 @@
-RSpec.describe Dry::Transaction::StepAdapters::Raw, adapter: true do
-
-  subject { described_class.new }
-
-  let(:options) { { step_name: "unit" } }
-
-  describe "#call" do
-
-    context "when the result of the operation is NOT a Dry::Monads::Result" do
-
-      let(:operation) {
-        -> (input) { input.upcase }
-      }
-
-      it "raises an InvalidResultError" do
-        expect {
-          subject.(operation, options, "input")
-        }.to raise_error(
-               Dry::Transaction::InvalidResultError,
-               "step +unit+ must return a Result object"
-             )
-      end
-    end
-
-    context "when the result of the operation is a Success value" do
-
-      let(:operation) {
-        -> (input) { Success(input.upcase) }
-      }
-
-      it "return a Success value" do
-        expect(subject.(operation, options, "input")).to eql(Success("INPUT"))
-      end
-    end
-  end
-end