interactor 2.1.1 → 3.0.0

data/spec/interactor/context_spec.rb

@@ -1,5 +1,3 @@
-require "spec_helper"
-
 module Interactor
   describe Context do
     describe ".build" do
@@ -7,14 +5,14 @@ module Interactor
         context = Context.build(foo: "bar")
 
         expect(context).to be_a(Context)
-        expect(context).to eq(foo: "bar")
+        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).to eq({})
+        expect(context.send(:table)).to eq({})
       end
 
       it "doesn't affect the original hash" do
@@ -23,7 +21,7 @@ module Interactor
 
         expect(context).to be_a(Context)
         expect {
-          context[:foo] = "baz"
+          context.foo = "baz"
         }.not_to change {
           hash[:foo]
         }
@@ -35,32 +33,13 @@ module Interactor
 
         expect(context2).to be_a(Context)
         expect {
-          context2[:foo] = "baz"
+          context2.foo = "baz"
         }.to change {
-          context1[:foo]
+          context1.foo
         }.from("bar").to("baz")
       end
     end
 
-    describe "#initialize" do
-      it "defaults to empty" do
-        expect {
-          expect(Context.new).to eq({})
-        }.not_to raise_error
-      end
-    end
-
-    describe "#[]" do
-      it "maintains indifferent access" do
-        require "active_support/hash_with_indifferent_access"
-
-        context = Context.build(HashWithIndifferentAccess.new(foo: "bar"))
-
-        expect(context[:foo]).to eq("bar")
-        expect(context["foo"]).to eq("bar")
-      end
-    end
-
     describe "#success?" do
       let(:context) { Context.build }
 
@@ -82,7 +61,7 @@ module Interactor
 
       it "sets success to false" do
         expect {
-          context.fail!
+          context.fail! rescue nil
         }.to change {
           context.success?
         }.from(true).to(false)
@@ -90,17 +69,17 @@ module Interactor
 
       it "sets failure to true" do
         expect {
-          context.fail!
+          context.fail! rescue nil
         }.to change {
           context.failure?
         }.from(false).to(true)
       end
 
       it "preserves failure" do
-        context.fail!
+        context.fail! rescue nil
 
         expect {
-          context.fail!
+          context.fail! rescue nil
         }.not_to change {
           context.failure?
         }
@@ -108,19 +87,81 @@ module Interactor
 
       it "preserves the context" do
         expect {
-          context.fail!
+          context.fail! rescue nil
         }.not_to change {
-          context[:foo]
+          context.foo
         }
       end
 
       it "updates the context" do
         expect {
-          context.fail!(foo: "baz")
+          context.fail!(foo: "baz") rescue nil
         }.to change {
-          context[:foo]
+          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
+        begin
+          context.fail!
+        rescue Failure => error
+          expect(error.context).to eq(context)
+        end
+      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/organizer_spec.rb

@@ -1,17 +1,9 @@
-require "spec_helper"
-
 module Interactor
   describe Organizer do
     include_examples :lint
 
     let(:organizer) { Class.new.send(:include, Organizer) }
 
-    describe ".interactors" do
-      it "is empty by default" do
-        expect(organizer.interactors).to eq([])
-      end
-    end
-
     describe ".organize" do
       let(:interactor2) { double(:interactor2) }
       let(:interactor3) { double(:interactor3) }
@@ -20,7 +12,7 @@ module Interactor
         expect {
           organizer.organize(interactor2, interactor3)
         }.to change {
-          organizer.interactors
+          organizer.organized
         }.from([]).to([interactor2, interactor3])
       end
 
@@ -28,182 +20,37 @@ module Interactor
         expect {
           organizer.organize([interactor2, interactor3])
         }.to change {
-          organizer.interactors
+          organizer.organized
         }.from([]).to([interactor2, interactor3])
       end
     end
 
-    describe "#interactors" do
-      let(:interactors) { double(:interactors) }
-      let(:instance) { organizer.new }
-
-      before do
-        organizer.stub(:interactors) { interactors }
-      end
-
-      it "defers to the class" do
-        expect(instance.interactors).to eq(interactors)
+    describe ".organized" do
+      it "is empty by default" do
+        expect(organizer.organized).to eq([])
       end
     end
 
-    describe "#perform" do
+    describe "#call" do
       let(:instance) { organizer.new }
-      let(:context) { instance.context }
+      let(:context) { double(:context) }
       let(:interactor2) { double(:interactor2) }
       let(:interactor3) { double(:interactor3) }
       let(:interactor4) { double(:interactor4) }
-      let(:instance2) { double(:instance2) }
-      let(:instance3) { double(:instance3) }
-      let(:instance4) { double(:instance4) }
-
-      before do
-        organizer.stub(:interactors) { [interactor2, interactor3, interactor4] }
-      end
-
-      it "performs each interactor in order with the context" do
-        expect(interactor2).to receive(:perform).once.with(context).ordered { instance2 }
-        expect(interactor3).to receive(:perform).once.with(context).ordered { instance3 }
-        expect(interactor4).to receive(:perform).once.with(context).ordered { instance4 }
-
-        expect(instance).not_to receive(:rollback)
-
-        instance.perform
-      end
-
-      it "builds up the performed interactors" do
-        interactor2.stub(:perform) do
-          expect(instance.performed).to eq([])
-          instance2
-        end
-
-        interactor3.stub(:perform) do
-          expect(instance.performed).to eq([instance2])
-          instance3
-        end
-
-        interactor4.stub(:perform) do
-          expect(instance.performed).to eq([instance2, instance3])
-          instance4
-        end
-
-        expect {
-          instance.perform
-        }.to change {
-          instance.performed
-        }.from([]).to([instance2, instance3, instance4])
-      end
-
-      it "aborts and rolls back on failure" do
-        expect(interactor2).to receive(:perform).once.with(context).ordered { instance2 }
-        expect(interactor3).to receive(:perform).once.with(context).ordered { context.fail! }
-        expect(interactor4).not_to receive(:perform)
-
-        expect(instance).to receive(:rollback).once.ordered do
-          expect(instance.performed).to eq([instance2])
-        end
-
-        instance.perform
-      end
-
-      it "aborts and rolls back on error" do
-        error = StandardError.new("foo")
-        expect(interactor2).to receive(:perform).once.with(context).ordered { instance2 }
-        expect(interactor3).to receive(:perform).once.with(context).ordered { raise error }
-        expect(interactor4).not_to receive(:perform)
-
-        expect(instance).to receive(:rollback).once.ordered do
-          expect(instance.performed).to eq([instance2])
-        end
-
-        expect { instance.perform }.to raise_error(error)
-      end
-    end
-
-    describe "#rollback" do
-      let(:instance) { organizer.new }
-      let(:instance2) { double(:instance2) }
-      let(:instance3) { double(:instance3) }
 
       before do
-        instance.stub(:performed) { [instance2, instance3] }
+        allow(instance).to receive(:context) { context }
+        allow(organizer).to receive(:organized) {
+          [interactor2, interactor3, interactor4]
+        }
       end
 
-      it "rolls back each performed interactor in reverse" do
-        expect(instance3).to receive(:rollback).once.ordered
-        expect(instance2).to receive(:rollback).once.ordered
-
-        instance.rollback
-      end
-    end
-
-    describe "#performed" do
-      let(:instance) { organizer.new }
-
-      it "is empty by default" do
-        expect(instance.performed).to eq([])
-      end
-    end
-
-    # organizer
-    #  ├─ organizer2
-    #  │   ├─ interactor2a
-    #  │   ├─ interactor2b
-    #  │   └─ interactor2c
-    #  ├─ interactor3
-    #  ├─ organizer4
-    #  │   ├─ interactor4a
-    #  │   ├─ interactor4b
-    #  │   └─ interactor4c
-    #  └─ interactor5
-    #
-    context "organizers within organizers" do
-      let(:instance) { organizer.new }
-      let(:context) { instance.context }
-      let(:organizer2) { Class.new.send(:include, Organizer) }
-      let(:interactor2a) { double(:interactor2a) }
-      let(:interactor2b) { double(:interactor2b) }
-      let(:interactor2c) { double(:interactor2c) }
-      let(:interactor3) { double(:interactor3) }
-      let(:organizer4) { Class.new.send(:include, Organizer) }
-      let(:interactor4a) { double(:interactor4a) }
-      let(:interactor4b) { double(:interactor4b) }
-      let(:interactor4c) { double(:interactor4c) }
-      let(:interactor5) { double(:interactor5) }
-
-      let(:instance2a) { double(:instance2a) }
-      let(:instance2b) { double(:instance2b) }
-      let(:instance2c) { double(:instance2c) }
-      let(:instance3) { double(:instance3) }
-      let(:instance4a) { double(:instance4a) }
-      let(:instance4b) { double(:instance4b) }
-
-      before do
-        organizer.stub(:interactors) { [organizer2, interactor3, organizer4, interactor5] }
-        organizer2.stub(:interactors) { [interactor2a, interactor2b, interactor2c] }
-        organizer4.stub(:interactors) { [interactor4a, interactor4b, interactor4c] }
-      end
-
-      it "performs and rolls back properly" do
-        expect(interactor2a).to receive(:perform).once.with(context).ordered { instance2a }
-        expect(interactor2b).to receive(:perform).once.with(context).ordered { instance2b }
-        expect(interactor2c).to receive(:perform).once.with(context).ordered { instance2c }
-        expect(interactor3).to receive(:perform).once.with(context).ordered { instance3 }
-        expect(interactor4a).to receive(:perform).once.with(context).ordered { instance4a }
-        expect(interactor4b).to receive(:perform).once.with(context).ordered do
-          context.fail!
-          instance4b
-        end
-        expect(interactor4c).not_to receive(:perform)
-        expect(interactor5).not_to receive(:perform)
-
-        expect(instance4b).not_to receive(:rollback)
-        expect(instance4a).to receive(:rollback).once.with(no_args).ordered
-        expect(instance3).to receive(:rollback).once.with(no_args).ordered
-        expect(instance2c).to receive(:rollback).once.with(no_args).ordered
-        expect(instance2b).to receive(:rollback).once.with(no_args).ordered
-        expect(instance2a).to receive(:rollback).once.with(no_args).ordered
+      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.perform
+        instance.call
       end
     end
   end

data/spec/interactor_spec.rb

@@ -1,5 +1,3 @@
-require "spec_helper"
-
 describe Interactor do
   include_examples :lint
 end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
-if ENV["TRAVIS"]
-  require "coveralls"
-  Coveralls.wear!
+if ENV["CODECLIMATE_REPO_TOKEN"]
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
 end
 
 require "interactor"

data/spec/support/lint.rb

@@ -1,30 +1,41 @@
 shared_examples :lint do
   let(:interactor) { Class.new.send(:include, described_class) }
 
-  describe ".perform" do
-    let(:instance) { double(:instance, failure?: false) }
+  describe ".call" do
+    let(:context) { double(:context) }
+    let(:instance) { double(:instance, context: context) }
 
-    it "performs an instance with the given context" do
+    it "calls an instance with the given context" do
       expect(interactor).to receive(:new).once.with(foo: "bar") { instance }
-      expect(instance).to receive(:perform).once.with(no_args)
+      expect(instance).to receive(:run).once.with(no_args)
 
-      expect(interactor.perform(foo: "bar")).to eq(instance)
+      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(:perform).once.with(no_args)
+      expect(instance).to receive(:run).once.with(no_args)
 
-      expect(interactor.perform).to eq(instance)
+      expect(interactor.call).to eq(context)
     end
+  end
 
-    it "does not run perform if the context is a failure after setup" do
-      expect(interactor).to receive(:new).once { instance }
-      instance.stub(failure?: true)
+  describe ".call!" do
+    let(:context) { double(:context) }
+    let(:instance) { double(:instance, context: context) }
 
-      expect(instance).not_to receive(:perform)
+    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.perform).to eq(instance)
+      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
 
@@ -48,122 +59,77 @@ shared_examples :lint do
       expect(instance).to be_a(interactor)
       expect(instance.context).to eq(context)
     end
-
-    it "calls setup" do
-      interactor.class_eval do
-        def setup
-          context[:foo] = bar
-        end
-      end
-
-      instance = interactor.new(bar: "baz")
-
-      expect(instance.context[:foo]).to eq("baz")
-    end
   end
 
-  describe "#setup" do
+  describe "#run" do
     let(:instance) { interactor.new }
 
-    it "exists" do
-      expect(instance).to respond_to(:setup)
-      expect { instance.setup }.not_to raise_error
-      expect { instance.method(:setup) }.not_to raise_error
-    end
-  end
-
-  describe "#perform" do
-    let(:instance) { interactor.new }
+    it "runs the interactor" do
+      expect(instance).to receive(:run!).once.with(no_args)
 
-    it "exists" do
-      expect(instance).to respond_to(:perform)
-      expect { instance.perform }.not_to raise_error
-      expect { instance.method(:perform) }.not_to raise_error
+      instance.run
     end
-  end
 
-  describe "#rollback" do
-    let(:instance) { interactor.new }
+    it "rescues failure" do
+      expect(instance).to receive(:run!).and_raise(Interactor::Failure)
 
-    it "exists" do
-      expect(instance).to respond_to(:rollback)
-      expect { instance.rollback }.not_to raise_error
-      expect { instance.method(:rollback) }.not_to raise_error
+      expect {
+        instance.run
+      }.not_to raise_error
     end
-  end
 
-  describe "#success?" do
-    let(:instance) { interactor.new }
-    let(:context) { instance.context }
-
-    it "defers to the context" do
-      context.stub(success?: true)
-      expect(instance.success?).to eq(true)
+    it "raises other errors" do
+      expect(instance).to receive(:run!).and_raise("foo")
 
-      context.stub(success?: false)
-      expect(instance.success?).to eq(false)
+      expect {
+        instance.run
+      }.to raise_error("foo")
     end
   end
 
-  describe "#failure?" do
+  describe "#run!" do
     let(:instance) { interactor.new }
-    let(:context) { instance.context }
 
-    it "defers to the context" do
-      context.stub(failure?: true)
-      expect(instance.failure?).to eq(true)
+    it "calls the interactor" do
+      expect(instance).to receive(:call).once.with(no_args)
 
-      context.stub(failure?: false)
-      expect(instance.failure?).to eq(false)
+      instance.run!
     end
-  end
-
-  describe "#fail!" do
-    let(:instance) { interactor.new }
-    let(:context) { instance.context }
 
-    it "defers to the context" do
-      expect(context).to receive(:fail!).once.with(no_args)
+    it "raises failure" do
+      expect(instance).to receive(:run!).and_raise(Interactor::Failure)
 
-      instance.fail!
+      expect {
+        instance.run!
+      }.to raise_error(Interactor::Failure)
     end
 
-    it "passes updates to the context" do
-      expect(context).to receive(:fail!).once.with(foo: "bar")
+    it "raises other errors" do
+      expect(instance).to receive(:run!).and_raise("foo")
 
-      instance.fail!(foo: "bar")
+      expect {
+        instance.run
+      }.to raise_error("foo")
     end
   end
 
-  describe "context deferral" do
-    context "initialized" do
-      let(:instance) { interactor.new(foo: "bar", "hello" => "world") }
-
-      it "defers to keys that exist in the context" do
-        expect(instance).to respond_to(:foo)
-        expect(instance.foo).to eq("bar")
-        expect { instance.method(:foo) }.not_to raise_error
-      end
-
-      it "defers to string keys that exist in the context" do
-        expect(instance).to respond_to(:hello)
-        expect(instance.hello).to eq("world")
-        expect { instance.method(:hello) }.not_to raise_error
-      end
-
-      it "bombs if the key does not exist in the context" do
-        expect(instance).not_to respond_to(:baz)
-        expect { instance.baz }.to raise_error(NoMethodError)
-        expect { instance.method(:baz) }.to raise_error(NameError)
-      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
 
-    context "allocated" do
-      let(:instance) { interactor.allocate }
+  describe "#rollback" do
+    let(:instance) { interactor.new }
 
-      it "doesn't respond to context keys before the context is set" do
-        expect(instance).not_to respond_to(:foo)
-      end
+    it "exists" do
+      expect(instance).to respond_to(:rollback)
+      expect { instance.rollback }.not_to raise_error
+      expect { instance.method(:rollback) }.not_to raise_error
     end
   end
 end