activeinteractor 1.2.1 → 1.2.2

data/spec/integration/an_organizer_with_failing_nested_organizer_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'An organizer with failing nested organizer', type: :integration do
-  let!(:parent_interactor1) { build_interactor('TestParentInteractor1') }
-  let!(:parent_interactor2) { build_interactor('TestParentInteractor2') }
-  let!(:child_interactor1) { build_interactor('TestChildInteractor1') }
-  let!(:child_interactor2) do
-    build_interactor('TestChildInteractor2') do
-      def perform
-        context.fail!
-      end
-    end
-  end
-
-  let!(:child_interactor_class) do
-    build_organizer('TestChildOrganizer') do
-      organize TestChildInteractor1, TestChildInteractor2
-    end
-  end
-
-  let(:parent_interactor_class) do
-    build_organizer('TestParentOrganizer') do
-      organize TestParentInteractor1, TestChildOrganizer, TestParentInteractor2
-    end
-  end
-
-  describe '.perform' do
-    subject { parent_interactor_class.perform }
-
-    before do
-      expect_any_instance_of(child_interactor_class).to receive(:perform).exactly(:once).and_call_original
-      expect_any_instance_of(child_interactor1).to receive(:perform).exactly(:once).and_call_original
-      expect_any_instance_of(child_interactor2).to receive(:perform).exactly(:once).and_call_original
-      expect_any_instance_of(child_interactor2).to receive(:rollback).exactly(:once).and_call_original
-      expect_any_instance_of(child_interactor1).to receive(:rollback).exactly(:once).and_call_original
-      expect_any_instance_of(parent_interactor1).to receive(:rollback).exactly(:once).and_call_original
-      expect_any_instance_of(parent_interactor2).not_to receive(:perform).exactly(:once).and_call_original
-      expect_any_instance_of(parent_interactor2).not_to receive(:rollback).exactly(:once).and_call_original
-    end
-
-    it { is_expected.to be_a parent_interactor_class.context_class }
-
-    it { is_expected.to be_failure }
-  end
-end

data/spec/integration/an_organizer_with_options_callbacks_spec.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'An organizer with options callbacks', type: :integration do
-  let!(:interactor1) do
-    build_interactor('TestInteractor1') do
-      def perform
-        context.step = 3 if context.step == 2
-        context.step = 6 if context.step == 5
-      end
-    end
-  end
-
-  let(:interactor_class) do
-    build_organizer do
-      organize do
-        add TestInteractor1, before: :test_before_method, after: :test_after_method
-        add TestInteractor1, before: lambda {
-          context.step = 5 if context.step == 4
-        }, after: lambda {
-          context.step = 7 if context.step == 6
-        }
-      end
-
-      private
-
-      def test_before_method
-        context.step = 2 if context.step == 1
-      end
-
-      def test_after_method
-        context.step = 4 if context.step == 3
-      end
-    end
-  end
-
-  include_examples 'a class with interactor methods'
-  include_examples 'a class with interactor callback methods'
-  include_examples 'a class with interactor context methods'
-  include_examples 'a class with organizer callback methods'
-
-  describe '.perform' do
-    subject { interactor_class.perform(step: 1) }
-
-    it { is_expected.to be_a interactor_class.context_class }
-
-    it 'is expected to receive #test_before_method once' do
-      expect_any_instance_of(interactor_class).to receive(:test_before_method)
-        .exactly(:once)
-      subject
-    end
-
-    it 'is expected to receive #test_after_method once' do
-      expect_any_instance_of(interactor_class).to receive(:test_after_method)
-        .exactly(:once)
-      subject
-    end
-
-    it 'runs callbacks in sequence' do
-      expect(subject.step).to eq(7)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'support/coverage'
-ActiveInteractor::Spec::Coverage.start
-
-require 'bundler/setup'
-require 'active_interactor'
-
-RSpec.configure do |config|
-  # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = 'spec/.rspec_status'
-
-  config.before do
-    # suppress logs in test
-    allow(ActiveInteractor.logger).to receive(:error).and_return(true)
-  end
-
-  config.after do
-    clean_factories!
-  end
-
-  # Disable RSpec exposing methods globally on `Module` and `main`
-  config.disable_monkey_patching!
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  config.order = :random
-  Kernel.srand config.seed
-end
-
-Dir[File.join(__dir__, 'support', '**', '*.rb')].sort.each { |f| require f }

data/spec/support/coverage.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'simplecov'
-require 'simplecov-lcov'
-
-module ActiveInteractor
-  module Spec
-    class Coverage
-      DEFAULT_COVERAGE_TYPE = 'unit'
-      EXCLUDED_FILES_PATTERN = '/spec/'
-      TRACKED_FILES_PATTERN = 'lib/**/*.rb'
-
-      FORMATTERS = [
-        SimpleCov::Formatter::HTMLFormatter,
-        SimpleCov::Formatter::LcovFormatter
-      ].freeze
-
-      class << self
-        def start
-          setup_lcov_formatter
-          start_simplecov
-        end
-
-        private
-
-        def simplecov_formatter
-          @simplecov_formatter ||= SimpleCov::Formatter::MultiFormatter.new(FORMATTERS)
-        end
-
-        def setup_lcov_formatter
-          coverage_type = ENV.fetch('COVERAGE_TYPE', DEFAULT_COVERAGE_TYPE)
-
-          SimpleCov::Formatter::LcovFormatter.config do |config|
-            config.report_with_single_file = true
-            config.single_report_path = "coverage/#{coverage_type}_lcov.info"
-          end
-        end
-
-        def start_simplecov
-          SimpleCov.start do
-            add_filter EXCLUDED_FILES_PATTERN
-            enable_coverage :branch
-            track_files TRACKED_FILES_PATTERN
-            formatter simplecov_formatter
-          end
-        end
-      end
-    end
-  end
-end

data/spec/support/helpers/factories.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string/inflections'
-
-module Spec
-  module Helpers
-    module FactoryCollection
-      def self.factories
-        @factories ||= []
-      end
-    end
-
-    module Factories
-      def build_class(class_name, parent_class = nil, &block)
-        Object.send(:remove_const, class_name.to_sym) if Object.const_defined?(class_name)
-        klass = create_class(class_name, parent_class)
-        klass.class_eval(&block) if block
-        FactoryCollection.factories << klass.name.to_sym
-        klass
-      end
-
-      def build_context(class_name = 'TestContext', &block)
-        build_class(class_name, ActiveInteractor::Context::Base, &block)
-      end
-
-      def build_interactor(class_name = 'TestInteractor', &block)
-        build_class(class_name, ActiveInteractor::Base, &block)
-      end
-
-      def build_organizer(class_name = 'TestOrganizer', &block)
-        build_class(class_name, ActiveInteractor::Organizer::Base, &block)
-      end
-
-      def clean_factories!
-        FactoryCollection.factories.each do |factory|
-          Object.send(:remove_const, factory) if Object.const_defined?(factory)
-        end
-      end
-
-      private
-
-      def create_class(class_name, parent_class = nil)
-        return Object.const_set(class_name, Class.new) unless parent_class
-
-        Object.const_set(class_name, Class.new(parent_class))
-      end
-    end
-  end
-end

data/spec/support/shared_examples/a_class_that_extends_active_interactor_models_example.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'A class that extends ActiveInteractor::Models' do
-  it { expect(model_class).to respond_to :attribute }
-  it { expect(model_class).to respond_to :attributes }
-
-  describe 'as an instance' do
-    subject { model_class.new }
-
-    it { is_expected.to respond_to :attributes }
-    it { is_expected.to respond_to :called! }
-    it { is_expected.to respond_to :fail! }
-    it { is_expected.to respond_to :fail? }
-    it { is_expected.to respond_to :failure? }
-    it { is_expected.to respond_to :merge! }
-    it { is_expected.to respond_to :rollback! }
-    it { is_expected.to respond_to :success? }
-    it { is_expected.to respond_to :successful? }
-  end
-
-  describe '.new' do
-    subject { model_class.new(attributes) }
-
-    describe 'with arguments {:foo => "foo"}' do
-      let(:attributes) { { foo: 'foo' } }
-
-      it { is_expected.to have_attributes(foo: 'foo') }
-    end
-
-    describe 'with arguments {:bar => "bar"}' do
-      let(:attributes) { model_class.new(bar: 'bar') }
-
-      it { expect { subject }.to raise_error(ActiveModel::UnknownAttributeError) }
-    end
-
-    describe 'with arguments <#ModelClass foo="foo">' do
-      let(:other_instance) { model_class.new(foo: 'foo') }
-      let(:attributes) { other_instance }
-
-      it { is_expected.to have_attributes(foo: 'foo') }
-
-      context 'with argument instance having @_failed eq to true' do
-        before { other_instance.instance_variable_set('@_failed', true) }
-
-        it { is_expected.to be_failure }
-      end
-
-      context 'with argument instance having @_called eq to ["foo"]' do
-        before { other_instance.instance_variable_set('@_called', %w[foo]) }
-
-        it 'is expected to have instance variable @_called eq to ["foo"]' do
-          expect(subject.instance_variable_get('@_called')).to eq %w[foo]
-        end
-      end
-
-      context 'with argument instance having @_rolled_back eq to true' do
-        before { other_instance.instance_variable_set('@_rolled_back', true) }
-
-        it 'is expected to have instance variable @_rolled_back eq to true' do
-          expect(subject.instance_variable_get('@_rolled_back')).to eq true
-        end
-      end
-    end
-
-    describe 'with arguments <#OtherClass bar="bar">' do
-      let(:attributes) { model_class.new(other_instance) }
-      let!(:other_class) do
-        build_class('OtherClass') do
-          include ActiveModel::Attributes
-          include ActiveModel::Model
-          extend ActiveInteractor::Models
-          acts_as_context
-          attribute :bar
-        end
-      end
-      let(:other_instance) { other_class.new(bar: 'bar') }
-
-      it { expect { subject }.to raise_error(ActiveModel::UnknownAttributeError) }
-    end
-  end
-end

data/spec/support/shared_examples/a_class_with_interactor_callback_methods_example.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'a class with interactor callback methods' do
-  describe '.after_context_validation' do
-    subject { interactor_class.after_context_validation(*args) }
-
-    let(:args) { :some_method }
-
-    it 'is expected to receive #set_callback with :validation, :after, :some_method, { :prepend => true }' do
-      expect(interactor_class).to receive(:set_callback)
-        .with(:validation, :after, :some_method, { prepend: true })
-        .and_return(true)
-      subject
-    end
-  end
-
-  describe '.after_perform' do
-    subject { interactor_class.after_perform(*args) }
-
-    let(:args) { :some_method }
-
-    it 'is expected to receive #set_callback with :perform, :after, :some_method' do
-      expect(interactor_class).to receive(:set_callback)
-        .with(:perform, :after, :some_method)
-        .and_return(true)
-      subject
-    end
-  end
-
-  describe '.after_rollback' do
-    subject { interactor_class.after_rollback(*args) }
-
-    let(:args) { :some_method }
-
-    it 'is expected to receive #set_callback with :rollback, :after, :some_method' do
-      expect(interactor_class).to receive(:set_callback)
-        .with(:rollback, :after, :some_method)
-        .and_return(true)
-      subject
-    end
-  end
-
-  describe '.around_perform' do
-    subject { interactor_class.around_perform(*args) }
-
-    let(:args) { :some_method }
-
-    it 'is expected to receive #set_callback with :perform, :around, :some_method' do
-      expect(interactor_class).to receive(:set_callback)
-        .with(:perform, :around, :some_method)
-        .and_return(true)
-      subject
-    end
-  end
-
-  describe '.around_rollback' do
-    subject { interactor_class.around_rollback(*args) }
-
-    let(:args) { :some_method }
-
-    it 'is expected to receive #set_callback with :rollback, :around, :some_method' do
-      expect(interactor_class).to receive(:set_callback)
-        .with(:rollback, :around, :some_method)
-        .and_return(true)
-      subject
-    end
-  end
-
-  describe '.before_context_validation' do
-    subject { interactor_class.before_context_validation(*args) }
-
-    let(:args) { :some_method }
-
-    it 'is expected to receive #set_callback with :validation, :before, :some_method' do
-      expect(interactor_class).to receive(:set_callback)
-        .with(:validation, :before, :some_method, {})
-        .and_return(true)
-      subject
-    end
-  end
-
-  describe '.before_perform' do
-    subject { interactor_class.before_perform(*args) }
-
-    let(:args) { :some_method }
-
-    it 'is expected to receive #set_callback with :perform, :before, :some_method' do
-      expect(interactor_class).to receive(:set_callback)
-        .with(:perform, :before, :some_method)
-        .and_return(true)
-      subject
-    end
-  end
-
-  describe '.before_rollback' do
-    subject { interactor_class.before_rollback(*args) }
-
-    let(:args) { :some_method }
-
-    it 'is expected to receive #set_callback with :rollback, :before, :some_method' do
-      expect(interactor_class).to receive(:set_callback)
-        .with(:rollback, :before, :some_method)
-        .and_return(true)
-      subject
-    end
-  end
-end

data/spec/support/shared_examples/a_class_with_interactor_context_methods_example.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'a class with interactor context methods' do
-  describe '.context_attributes' do
-    subject { interactor_class.context_attributes(attributes) }
-
-    let(:attributes) { :some_attribute }
-
-    it 'is expected to receive #attributes on .context_class with :some_attribute' do
-      expect(interactor_class.context_class).to receive(:attributes)
-        .with(:some_attribute)
-        .and_return(true)
-      subject
-    end
-  end
-
-  describe '#context_fail!' do
-    subject { interactor_class.new.context_fail! }
-
-    it 'is expected to receive #fail! on instance of .context_class' do
-      expect_any_instance_of(interactor_class.context_class).to receive(:fail!)
-        .and_return(true)
-      subject
-    end
-  end
-
-  describe '#context_rollback!' do
-    subject { interactor_class.new.context_rollback! }
-
-    it 'is expected to receive #rollback! on instance of .context_class' do
-      expect_any_instance_of(interactor_class.context_class).to receive(:rollback!)
-        .and_return(true)
-      subject
-    end
-  end
-
-  describe '#context_valid?' do
-    subject { interactor_class.new.context_valid? }
-
-    it 'is expected to receive #valid? on instance of .context_class' do
-      expect_any_instance_of(interactor_class.context_class).to receive(:valid?)
-        .and_return(true)
-      subject
-    end
-  end
-
-  describe '#finalize_context!' do
-    subject { instance.finalize_context! }
-
-    let(:instance) { interactor_class.new }
-
-    it 'is expected to receive #called! on instance of .context_class' do
-      expect_any_instance_of(interactor_class.context_class).to receive(:called!)
-        .with(instance)
-      subject
-    end
-
-    it { is_expected.to be_an interactor_class.context_class }
-  end
-end

data/spec/support/shared_examples/a_class_with_interactor_methods_example.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'a class with interactor methods' do
-  describe '.perform' do
-    subject { interactor_class.perform }
-
-    it 'is expected to receive #execute_perform on a new instance of ActiveInteractor::Interactor::Worker' do
-      expect_any_instance_of(ActiveInteractor::Interactor::Worker).to receive(:execute_perform)
-      subject
-    end
-  end
-
-  describe '.perform!' do
-    subject { interactor_class.perform! }
-
-    it 'is expected to receive #execute_perform! on a new instance of ActiveInteractor::Interactor::Worker' do
-      expect_any_instance_of(ActiveInteractor::Interactor::Worker).to receive(:execute_perform!)
-      subject
-    end
-  end
-end

data/spec/support/shared_examples/a_class_with_organizer_callback_methods_example.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'a class with organizer callback methods' do
-  describe '.after_each_perform' do
-    subject { interactor_class.after_each_perform(*args) }
-
-    let(:args) { :some_method }
-
-    it 'is expected to receive #set_callback with :each_perform, :after, :some_method' do
-      expect(interactor_class).to receive(:set_callback)
-        .with(:each_perform, :after, :some_method)
-        .and_return(true)
-      subject
-    end
-  end
-
-  describe '.around_each_perform' do
-    subject { interactor_class.around_each_perform(*args) }
-
-    let(:args) { :some_method }
-
-    it 'is expected to receive #set_callback with :each_perform, :around, :some_method' do
-      expect(interactor_class).to receive(:set_callback)
-        .with(:each_perform, :around, :some_method)
-        .and_return(true)
-      subject
-    end
-  end
-
-  describe '.before_each_perform' do
-    subject { interactor_class.before_each_perform(*args) }
-
-    let(:args) { :some_method }
-
-    it 'is expected to receive #set_callback with :each_perform, :before, :some_method' do
-      expect(interactor_class).to receive(:set_callback)
-        .with(:each_perform, :before, :some_method)
-        .and_return(true)
-      subject
-    end
-  end
-end

data/spec/support/spec_helpers.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-Dir[File.join(__dir__, 'helpers', '**', '*.rb')].sort.each { |f| require f }
-
-RSpec.configure do |config|
-  config.include Spec::Helpers::Factories
-end