interactor_with_steroids 0.0.1

data/spec/interactor/hooks_spec.rb

@@ -0,0 +1,358 @@
+module Interactor
+  describe Hooks do
+    describe "#with_hooks" do
+      def build_hooked(&block)
+        hooked = Class.new.send(:include, Interactor::Hooks)
+
+        hooked.class_eval do
+          attr_reader :steps
+
+          def self.process
+            new.tap(&:process).steps
+          end
+
+          def initialize
+            @steps = []
+          end
+
+          def process
+            with_hooks { steps << :process }
+          end
+        end
+
+        hooked.class_eval(&block) if block
+        hooked
+      end
+
+      context "with an around hook method" do
+        let(:hooked) {
+          build_hooked do
+            around :add_around_before_and_around_after
+
+            private
+
+            def add_around_before_and_around_after(hooked)
+              steps << :around_before
+              hooked.call
+              steps << :around_after
+            end
+          end
+        }
+
+        it "runs the around hook method" do
+          expect(hooked.process).to eq([
+            :around_before,
+            :process,
+            :around_after,
+          ])
+        end
+      end
+
+      context "with an around hook block" do
+        let(:hooked) {
+          build_hooked do
+            around do |hooked|
+              steps << :around_before
+              hooked.call
+              steps << :around_after
+            end
+          end
+        }
+
+        it "runs the around hook block" do
+          expect(hooked.process).to eq([
+            :around_before,
+            :process,
+            :around_after,
+          ])
+        end
+      end
+
+      context "with an around hook method and block in one call" do
+        let(:hooked) {
+          build_hooked do
+            around :add_around_before1_and_around_after1 do |hooked|
+              steps << :around_before2
+              hooked.call
+              steps << :around_after2
+            end
+
+            private
+
+            def add_around_before1_and_around_after1(hooked)
+              steps << :around_before1
+              hooked.call
+              steps << :around_after1
+            end
+          end
+        }
+
+        it "runs the around hook method and block in order" do
+          expect(hooked.process).to eq([
+            :around_before1,
+            :around_before2,
+            :process,
+            :around_after2,
+            :around_after1,
+          ])
+        end
+      end
+
+      context "with an around hook method and block in multiple calls" do
+        let(:hooked) {
+          build_hooked do
+            around do |hooked|
+              steps << :around_before1
+              hooked.call
+              steps << :around_after1
+            end
+
+            around :add_around_before2_and_around_after2
+
+            private
+
+            def add_around_before2_and_around_after2(hooked)
+              steps << :around_before2
+              hooked.call
+              steps << :around_after2
+            end
+          end
+        }
+
+        it "runs the around hook block and method in order" do
+          expect(hooked.process).to eq([
+            :around_before1,
+            :around_before2,
+            :process,
+            :around_after2,
+            :around_after1,
+          ])
+        end
+      end
+
+      context "with a before hook method" do
+        let(:hooked) {
+          build_hooked do
+            before :add_before
+
+            private
+
+            def add_before
+              steps << :before
+            end
+          end
+        }
+
+        it "runs the before hook method" do
+          expect(hooked.process).to eq([
+            :before,
+            :process,
+          ])
+        end
+      end
+
+      context "with a before hook block" do
+        let(:hooked) {
+          build_hooked do
+            before do
+              steps << :before
+            end
+          end
+        }
+
+        it "runs the before hook block" do
+          expect(hooked.process).to eq([
+            :before,
+            :process,
+          ])
+        end
+      end
+
+      context "with a before hook method and block in one call" do
+        let(:hooked) {
+          build_hooked do
+            before :add_before1 do
+              steps << :before2
+            end
+
+            private
+
+            def add_before1
+              steps << :before1
+            end
+          end
+        }
+
+        it "runs the before hook method and block in order" do
+          expect(hooked.process).to eq([
+            :before1,
+            :before2,
+            :process,
+          ])
+        end
+      end
+
+      context "with a before hook method and block in multiple calls" do
+        let(:hooked) {
+          build_hooked do
+            before do
+              steps << :before1
+            end
+
+            before :add_before2
+
+            private
+
+            def add_before2
+              steps << :before2
+            end
+          end
+        }
+
+        it "runs the before hook block and method in order" do
+          expect(hooked.process).to eq([
+            :before1,
+            :before2,
+            :process,
+          ])
+        end
+      end
+
+      context "with an after hook method" do
+        let(:hooked) {
+          build_hooked do
+            after :add_after
+
+            private
+
+            def add_after
+              steps << :after
+            end
+          end
+        }
+
+        it "runs the after hook method" do
+          expect(hooked.process).to eq([
+            :process,
+            :after,
+          ])
+        end
+      end
+
+      context "with an after hook block" do
+        let(:hooked) {
+          build_hooked do
+            after do
+              steps << :after
+            end
+          end
+        }
+
+        it "runs the after hook block" do
+          expect(hooked.process).to eq([
+            :process,
+            :after,
+          ])
+        end
+      end
+
+      context "with an after hook method and block in one call" do
+        let(:hooked) {
+          build_hooked do
+            after :add_after1 do
+              steps << :after2
+            end
+
+            private
+
+            def add_after1
+              steps << :after1
+            end
+          end
+        }
+
+        it "runs the after hook method and block in order" do
+          expect(hooked.process).to eq([
+            :process,
+            :after2,
+            :after1,
+          ])
+        end
+      end
+
+      context "with an after hook method and block in multiple calls" do
+        let(:hooked) {
+          build_hooked do
+            after do
+              steps << :after1
+            end
+
+            after :add_after2
+
+            private
+
+            def add_after2
+              steps << :after2
+            end
+          end
+        }
+
+        it "runs the after hook block and method in order" do
+          expect(hooked.process).to eq([
+            :process,
+            :after2,
+            :after1,
+          ])
+        end
+      end
+
+      context "with around, before and after hooks" do
+        let(:hooked) {
+          build_hooked do
+            around do |hooked|
+              steps << :around_before1
+              hooked.call
+              steps << :around_after1
+            end
+
+            around do |hooked|
+              steps << :around_before2
+              hooked.call
+              steps << :around_after2
+            end
+
+            before do
+              steps << :before1
+            end
+
+            before do
+              steps << :before2
+            end
+
+            after do
+              steps << :after1
+            end
+
+            after do
+              steps << :after2
+            end
+          end
+        }
+
+        it "runs hooks in the proper order" do
+          expect(hooked.process).to eq([
+            :around_before1,
+            :around_before2,
+            :before1,
+            :before2,
+            :process,
+            :after2,
+            :after1,
+            :around_after2,
+            :around_after1,
+          ])
+        end
+      end
+    end
+  end
+end

data/spec/interactor/organizer_spec.rb

@@ -0,0 +1,60 @@
+module Interactor
+  describe Organizer do
+    let(:organizer) {
+      Class.new do
+        include Organizer
+        include Declaration
+      end
+    }
+
+    describe ".organize" do
+      let(:interactor2) { double(:interactor2) }
+      let(:interactor3) { double(:interactor3) }
+
+      it "sets interactors given class arguments" do
+        expect {
+          organizer.organize(interactor2, interactor3)
+        }.to change {
+          organizer.organized
+        }.from([]).to([interactor2, interactor3])
+      end
+
+      it "sets interactors given an array of classes" do
+        expect {
+          organizer.organize([interactor2, interactor3])
+        }.to change {
+          organizer.organized
+        }.from([]).to([interactor2, interactor3])
+      end
+    end
+
+    describe ".organized" do
+      it "is empty by default" do
+        expect(organizer.organized).to eq([])
+      end
+    end
+
+    describe "#call" do
+      let(:instance) { organizer.new }
+      let(:context) { double(:context) }
+      let(:interactor2) { Class.new.send(:include, Interactor) }
+      let(:interactor3) { Class.new.send(:include, Interactor) }
+      let(:interactor4) { Class.new.send(:include, Interactor) }
+
+      before do
+        allow(instance).to receive(:context) { context }
+        allow(organizer).to receive(:organized) {
+          [interactor2, interactor3, interactor4]
+        }
+      end
+
+      it "calls each interactor in order with the context" do
+        expect(interactor2).to receive(:call!).once.ordered
+        expect(interactor3).to receive(:call!).once.ordered
+        expect(interactor4).to receive(:call!).once.ordered
+
+        instance.call
+      end
+    end
+  end
+end

data/spec/interactor_spec.rb

@@ -0,0 +1,127 @@
+describe Interactor do
+  let(:interactor) { Class.new.send(:include, described_class) }
+
+  describe ".call" do
+    let(:context) { double(:context) }
+    let(:instance) { double(:instance, context: context) }
+
+    it "calls an instance with the given context" do
+      expect(interactor).to receive(:new).once.with(foo: "bar") { instance }
+      expect(instance).to receive(:run).once.with(no_args)
+
+      expect(interactor.call(foo: "bar")).to eq(context)
+    end
+
+    it "provides a blank context if none is given" do
+      expect(interactor).to receive(:new).once.with({}) { instance }
+      expect(instance).to receive(:run).once.with(no_args)
+
+      expect(interactor.call).to eq(context)
+    end
+  end
+
+  describe ".call!" do
+    let(:context) { double(:context) }
+    let(:instance) { double(:instance, context: context) }
+
+    it "calls an instance with the given context" do
+      expect(interactor).to receive(:new).once.with(foo: "bar") { instance }
+      expect(instance).to receive(:run!).once.with(no_args)
+
+      expect(interactor.call!(foo: "bar")).to eq(context)
+    end
+
+    it "provides a blank context if none is given" do
+      expect(interactor).to receive(:new).once.with({}) { instance }
+      expect(instance).to receive(:run!).once.with(no_args)
+
+      expect(interactor.call!).to eq(context)
+    end
+  end
+
+  describe ".new" do
+    let(:context) { double(:context) }
+
+    it "initializes a context" do
+      expect(Interactor::Context).to receive(:build).once.with(foo: "bar") { context }
+
+      instance = interactor.new(foo: "bar")
+
+      expect(instance).to be_a(interactor)
+      expect(instance.context).to eq(context)
+    end
+
+    it "initializes a blank context if none is given" do
+      expect(Interactor::Context).to receive(:build).once.with({}) { context }
+
+      instance = interactor.new
+
+      expect(instance).to be_a(interactor)
+      expect(instance.context).to eq(context)
+    end
+  end
+
+  describe "#run" do
+    let(:instance) { interactor.new }
+
+    it "runs the interactor" do
+      expect(instance).to receive(:run!).once.with(no_args)
+
+      instance.run
+    end
+
+    it "rescues failure" do
+      expect(instance).to receive(:run!).and_raise(Interactor::Failure)
+
+      expect {
+        instance.run
+      }.not_to raise_error
+    end
+
+    it "raises other errors" do
+      expect(instance).to receive(:run!).and_raise("foo")
+
+      expect {
+        instance.run
+      }.to raise_error("foo")
+    end
+  end
+
+  describe "#run!" do
+    let(:instance) { interactor.new(context) }
+    let(:context) { double(:context, to_h: {}) }
+
+    it "calls the interactor" do
+      expect(instance).to receive(:call).once.with(no_args)
+
+      instance.run!
+    end
+
+    it "raises failure" do
+      expect(instance).to receive(:call).and_raise(Interactor::Failure)
+      expect(instance.context).to receive(:fail!).and_raise(Interactor::Failure)
+
+      expect {
+        instance.run!
+      }.to raise_error(Interactor::Failure)
+    end
+
+    it "raises other errors" do
+      expect(instance).to receive(:run!).and_raise("foo")
+
+      expect {
+        instance.run
+      }.to raise_error("foo")
+    end
+  end
+
+  describe "#call" do
+    let(:instance) { interactor.new }
+
+    it "exists" do
+      expect(instance).to respond_to(:call)
+      expect { instance.call }.not_to raise_error
+      expect { instance.method(:call) }.not_to raise_error
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+if ENV["CODECLIMATE_REPO_TOKEN"]
+  require "simplecov"
+  SimpleCov.start
+end
+
+require "interactor"

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: interactor_with_steroids
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Collective Idea/Sorare Team
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-01-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Interactor provides a common interface for performing complex user interactions.
+email: hello@sorare.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".standard.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- interactor.gemspec
+- lib/interactor.rb
+- lib/interactor/context.rb
+- lib/interactor/declaration.rb
+- lib/interactor/error.rb
+- lib/interactor/hooks.rb
+- lib/interactor/organizer.rb
+- spec/interactor/context_spec.rb
+- spec/interactor/declaration_spec.rb
+- spec/interactor/hooks_spec.rb
+- spec/interactor/organizer_spec.rb
+- spec/interactor_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/sorare/interactor
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Simple interactor implementation
+test_files:
+- spec/interactor/context_spec.rb
+- spec/interactor/declaration_spec.rb
+- spec/interactor/hooks_spec.rb
+- spec/interactor/organizer_spec.rb
+- spec/interactor_spec.rb
+- spec/spec_helper.rb