interaktor 0.1.3

data/spec/interactor/context_spec.rb

@@ -0,0 +1,187 @@
+module Interaktor
+  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 StandardError
+            nil
+          end
+        }.to change(context, :success?).from(true).to(false)
+      end
+
+      it "sets failure to true" do
+        expect {
+          begin
+            context.fail!
+          rescue StandardError
+            nil
+          end
+        }.to change(context, :failure?).from(false).to(true)
+      end
+
+      it "preserves failure" do
+        begin
+          context.fail!
+        rescue StandardError
+          nil
+        end
+
+        expect {
+          begin
+            context.fail!
+          rescue StandardError
+            nil
+          end
+        }.not_to change(context, :failure?)
+      end
+
+      it "preserves the context" do
+        expect {
+          begin
+            context.fail!
+          rescue StandardError
+            nil
+          end
+        }.not_to change(context, :foo)
+      end
+
+      it "updates the context" do
+        expect {
+          begin
+            context.fail!(foo: "baz")
+          rescue StandardError
+            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 StandardError
+            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 => e
+        expect(e.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 Interaktor
+  describe Hooks do
+    describe "#with_hooks" do
+      def build_hooked(&block)
+        hooked = Class.new.send(:include, Interaktor::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