interactor-strict 1.0.0

data/spec/interactor/context_spec.rb

@@ -0,0 +1,201 @@
+module Interactor
+  describe Context do
+    describe ".build" do
+      it "converts the given hash to a context" do
+        context = Context.build(foo: "bar")
+
+        expect(context).to be_a(Context)
+        expect(context.foo).to eq("bar")
+      end
+
+      it "builds an empty context if no hash is given" do
+        context = Context.build
+
+        expect(context).to be_a(Context)
+        expect(context.send(:table)).to eq({})
+      end
+
+      it "doesn't affect the original hash" do
+        hash = {foo: "bar"}
+        context = Context.build(hash)
+
+        expect(context).to be_a(Context)
+        expect {
+          context.foo = "baz"
+        }.not_to change {
+          hash[:foo]
+        }
+      end
+
+      it "preserves an already built context" do
+        context1 = Context.build(foo: "bar")
+        context2 = Context.build(context1)
+
+        expect(context2).to be_a(Context)
+        expect {
+          context2.foo = "baz"
+        }.to change {
+          context1.foo
+        }.from("bar").to("baz")
+      end
+    end
+
+    describe "#success?" do
+      let(:context) { Context.build }
+
+      it "is true by default" do
+        expect(context.success?).to eq(true)
+      end
+    end
+
+    describe "#failure?" do
+      let(:context) { Context.build }
+
+      it "is false by default" do
+        expect(context.failure?).to eq(false)
+      end
+    end
+
+    describe "#fail!" do
+      let(:context) { Context.build(foo: "bar") }
+
+      it "sets success to false" do
+        expect {
+          begin
+            context.fail!
+          rescue
+            nil
+          end
+        }.to change {
+          context.success?
+        }.from(true).to(false)
+      end
+
+      it "sets failure to true" do
+        expect {
+          begin
+            context.fail!
+          rescue
+            nil
+          end
+        }.to change {
+          context.failure?
+        }.from(false).to(true)
+      end
+
+      it "preserves failure" do
+        begin
+          context.fail!
+        rescue
+          nil
+        end
+
+        expect {
+          begin
+            context.fail!
+          rescue
+            nil
+          end
+        }.not_to change {
+          context.failure?
+        }
+      end
+
+      it "preserves the context" do
+        expect {
+          begin
+            context.fail!
+          rescue
+            nil
+          end
+        }.not_to change {
+          context.foo
+        }
+      end
+
+      it "updates the context" do
+        expect {
+          begin
+            context.fail!(foo: "baz")
+          rescue
+            nil
+          end
+        }.to change {
+          context.foo
+        }.from("bar").to("baz")
+      end
+
+      it "updates the context with a string key" do
+        expect {
+          begin
+            context.fail!("foo" => "baz")
+          rescue
+            nil
+          end
+        }.to change {
+          context.foo
+        }.from("bar").to("baz")
+      end
+
+      it "raises failure" do
+        expect {
+          context.fail!
+        }.to raise_error(Failure)
+      end
+
+      it "makes the context available from the failure" do
+        context.fail!
+      rescue Failure => error
+        expect(error.context).to eq(context)
+      end
+    end
+
+    describe "#called!" do
+      let(:context) { Context.build }
+      let(:instance1) { double(:instance1) }
+      let(:instance2) { double(:instance2) }
+
+      it "appends to the internal list of called instances" do
+        expect {
+          context.called!(instance1)
+          context.called!(instance2)
+        }.to change {
+          context._called
+        }.from([]).to([instance1, instance2])
+      end
+    end
+
+    describe "#rollback!" do
+      let(:context) { Context.build }
+      let(:instance1) { double(:instance1) }
+      let(:instance2) { double(:instance2) }
+
+      before do
+        allow(context).to receive(:_called) { [instance1, instance2] }
+      end
+
+      it "rolls back each instance in reverse order" do
+        expect(instance2).to receive(:rollback).once.with(no_args).ordered
+        expect(instance1).to receive(:rollback).once.with(no_args).ordered
+
+        context.rollback!
+      end
+
+      it "ignores subsequent attempts" do
+        expect(instance2).to receive(:rollback).once
+        expect(instance1).to receive(:rollback).once
+
+        context.rollback!
+        context.rollback!
+      end
+    end
+
+    describe "#_called" do
+      let(:context) { Context.build }
+
+      it "is empty by default" do
+        expect(context._called).to eq([])
+      end
+    end
+  end
+end

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,57 @@
+module Interactor
+  describe Organizer do
+    include_examples :lint
+
+    let(:organizer) { Class.new.send(:include, Organizer) }
+
+    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) { double(:interactor2) }
+      let(:interactor3) { double(:interactor3) }
+      let(:interactor4) { double(:interactor4) }
+
+      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.with(context).ordered
+        expect(interactor3).to receive(:call!).once.with(context).ordered
+        expect(interactor4).to receive(:call!).once.with(context).ordered
+
+        instance.call
+      end
+    end
+  end
+end

data/spec/interactor/strict_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "interactor/strict"
+
+RSpec.describe Interactor::Strict do
+  let(:service_class) do
+    Class.new do
+      include Interactor
+      include Interactor::Strict
+
+      before :before_one
+      before :before_two
+      after :after_one
+      after :after_two
+
+      def call(foo:, bar:, with_default: 'default')
+        context.args = [foo, bar, with_default]
+      end
+
+      def before_one
+        context.hooks = ["before_one"]
+      end
+
+      def before_two
+        context.hooks << "before_two"
+      end
+
+      def after_one
+        context.hooks << "after_one"
+      end
+
+      def after_two
+        context.hooks << "after_two"
+      end
+    end
+  end
+
+
+  let(:loose_params_service) do
+    Class.new do
+      include Interactor
+      include Interactor::Strict
+
+      def call(foo:, bar:, **others)
+        context.args = [foo, bar, others]
+      end
+    end
+  end
+
+  describe ".call" do
+    context "when they are defined" do
+      it "works when all keyword arguments are passed" do
+        context = service_class.call(foo: "the-foo", bar: "the-bar")
+
+        expect(context.args).to eq(%w[the-foo the-bar default])
+      end
+
+      it "works with regular hooks" do
+        context = service_class.call(foo: "the-foo", bar: "the-bar")
+
+        expect(context.hooks).to eq(%w[before_one before_two after_two after_one])
+      end
+
+      it "can take looser params" do
+        context = loose_params_service.call(foo: "foo", bar: "bar", other: "other")
+
+        expect(context.args).to eq(["foo", "bar", { other: "other"}])
+      end
+
+      it "raises when keyword arguments are not properly passed" do
+        expect { service_class.call(foo: "the-foo") }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe ".call!" do
+    context "when they are defined" do
+      it "works when all keyword arguments are passed" do
+        context = service_class.call!(foo: "the-foo", bar: "the-bar")
+
+        expect(context.args).to eq(%w[the-foo the-bar default])
+      end
+
+      it "works with regular hooks" do
+        context = service_class.call!(foo: "the-foo", bar: "the-bar")
+
+        expect(context.hooks).to eq(%w[before_one before_two after_two after_one])
+      end
+
+      it "raises when keyword arguments are not properly passed" do
+        expect { service_class.call!(foo: "the-foo") }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/interactor_spec.rb

@@ -0,0 +1,3 @@
+describe Interactor do
+  include_examples :lint
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+if ENV["CODECLIMATE_REPO_TOKEN"]
+  require "simplecov"
+  SimpleCov.start
+end
+
+require "interactor/strict"
+
+Dir[File.expand_path("../support/*.rb", __FILE__)].sort.each { |f| require f }