flow_machine 0.2.2 → 0.2.3

data/spec/flow_machine/factory_methods_spec.rb

@@ -5,44 +5,52 @@ RSpec.describe FlowMachine::Workflow do
     include FlowMachine::Workflow
   end
 
-  describe '.class_for' do
+  describe ".class_for" do
     subject(:workflow_class) { described_class.class_for(target) }
 
-    describe 'with a class' do
+    describe "with a class" do
       let(:target) { TestClass }
-      it { should eq(TestClassWorkflow) }
+
+      it { is_expected.to eq(TestClassWorkflow) }
     end
 
-    describe 'with an object' do
+    describe "with an object" do
       let(:target) { TestClass.new }
-      it { should eq(TestClassWorkflow) }
+
+      it { is_expected.to eq(TestClassWorkflow) }
     end
   end
 
-  describe '.for' do
+  describe ".for" do
     subject(:workflow) { described_class.for(target) }
+
     class SomeNewClass; end
 
-    describe 'not found' do
+    describe "not found" do
       let(:target) { SomeNewClass.new }
-      it { should be_nil }
+
+      it { is_expected.to be_nil }
     end
 
-    describe 'with an object' do
+    describe "with an object" do
       let(:target) { TestClass.new }
-      it { should be_an_instance_of(TestClassWorkflow) }
-      its(:object) { should eq(target) }
+
+      it { is_expected.to be_an_instance_of(TestClassWorkflow) }
+      its(:object) { is_expected.to eq(target) }
     end
 
-    describe 'with an array of objects' do
+    describe "with an array of objects" do
       let(:target) { [TestClass.new, TestClass.new] }
-      it { should match [an_instance_of(TestClassWorkflow), an_instance_of(TestClassWorkflow)] }
+
+      it { is_expected.to match [an_instance_of(TestClassWorkflow), an_instance_of(TestClassWorkflow)] }
     end
   end
 
-  describe '.workflow_for_collection' do
+  describe ".workflow_for_collection" do
     subject(:result) { described_class.for_collection(target) }
+
     let(:target) { [TestClass.new, TestClass.new] }
-    it { should match [an_instance_of(TestClassWorkflow), an_instance_of(TestClassWorkflow)] }
+
+    it { is_expected.to match [an_instance_of(TestClassWorkflow), an_instance_of(TestClassWorkflow)] }
   end
 end

data/spec/flow_machine/multiple_workflow_spec.rb

@@ -1,14 +1,18 @@
 RSpec.describe FlowMachine::Workflow do
   let(:state_class1) do
     Class.new(FlowMachine::WorkflowState) do
-      def self.state_name; :state1; end
+      def self.state_name
+        :state1
+      end
       event :event1
     end
   end
 
   let(:state_class2) do
     Class.new(FlowMachine::WorkflowState) do
-      def self.state_name; :state2; end
+      def self.state_name
+        :state2
+      end
       event :event2
     end
   end
@@ -23,15 +27,17 @@ RSpec.describe FlowMachine::Workflow do
     workflow_class2.state state_class2
   end
 
-  context 'class1' do
+  context "class1" do
     subject { workflow_class1.new(double) }
-    it { should respond_to 'event1' }
-    it { should_not respond_to 'event2' }
+
+    it { is_expected.to respond_to "event1" }
+    it { is_expected.not_to respond_to "event2" }
   end
 
-  context 'class2' do
+  context "class2" do
     subject { workflow_class2.new(double) }
-    it { should_not respond_to 'event1' }
-    it { should respond_to 'event2' }
+
+    it { is_expected.not_to respond_to "event1" }
+    it { is_expected.to respond_to "event2" }
   end
 end

data/spec/flow_machine/workflow/model_extension_spec.rb

@@ -1,4 +1,4 @@
-require 'ostruct'
+require "ostruct"
 
 RSpec.describe FlowMachine::Workflow::ModelExtension do
   class Test1State < FlowMachine::WorkflowState
@@ -13,8 +13,8 @@ RSpec.describe FlowMachine::Workflow::ModelExtension do
     state Test2State
   end
 
-  describe '.create_scopes_on' do
-    class PersistedModel < Struct.new(:state)
+  describe ".create_scopes_on" do
+    PersistedModel = Struct.new(:state) do
       def self.where(opts)
         [new(opts[:state])]
       end
@@ -22,33 +22,33 @@ RSpec.describe FlowMachine::Workflow::ModelExtension do
       TestWorkflow.create_scopes_on(self)
     end
 
-    class UnPersistedModel < Struct.new(:state)
+    UnPersistedModel = Struct.new(:state) do
       TestWorkflow.create_scopes_on(self)
     end
 
-    it 'adds the predicate model for state 1' do
-      expect(PersistedModel.new('test1')).to be_test1
-      expect(PersistedModel.new('test2')).not_to be_test1
+    it "adds the predicate model for state 1" do
+      expect(PersistedModel.new("test1")).to be_test1
+      expect(PersistedModel.new("test2")).not_to be_test1
     end
 
-    it 'adds the predicate model for state 2' do
-      expect(PersistedModel.new('test1')).not_to be_test2
-      expect(PersistedModel.new('test2')).to be_test2
+    it "adds the predicate model for state 2" do
+      expect(PersistedModel.new("test1")).not_to be_test2
+      expect(PersistedModel.new("test2")).to be_test2
     end
 
-    it 'adds a scope for test1' do
+    it "adds a scope for test1" do
       expect(PersistedModel.test1).to be_an(Array)
       expect(PersistedModel.test1).to be_one
-      expect(PersistedModel.test1.first).to eq(PersistedModel.new('test1'))
+      expect(PersistedModel.test1.first).to eq(PersistedModel.new("test1"))
     end
 
-    it 'adds a scope for test2' do
+    it "adds a scope for test2" do
       expect(PersistedModel.test2).to be_an(Array)
       expect(PersistedModel.test2).to be_one
-      expect(PersistedModel.test2.first).to eq(PersistedModel.new('test2'))
+      expect(PersistedModel.test2.first).to eq(PersistedModel.new("test2"))
     end
 
-    it 'does not add scopes if where is not defined' do
+    it "does not add scopes if where is not defined" do
       expect(UnPersistedModel).not_to respond_to(:test1)
     end
   end

data/spec/flow_machine/workflow_callback_spec.rb

@@ -1,127 +1,131 @@
 RSpec.describe FlowMachine::Callback do
   let(:object) { double }
 
-  describe 'callback with method' do
+  describe "callback with method" do
     let(:callback) { described_class.new(:some_method) }
 
-    it 'calls the method' do
+    it "calls the method" do
       expect(object).to receive(:some_method)
       callback.call(object)
     end
   end
 
-  describe 'callback with block' do
+  describe "callback with block" do
     let(:callback) do
       described_class.new { some_method }
     end
 
-    it 'calls the method' do
+    it "calls the method" do
       expect(object).to receive(:some_method)
       callback.call(object)
     end
-
   end
 
-  describe 'callback with if' do
-    context 'a single if' do
+  describe "callback with if" do
+    context "a single if" do
       let(:callback) { described_class.new(:some_method, if: :if_method?) }
 
-      context 'if method returns true' do
+      context "if method returns true" do
         before { allow(object).to receive(:if_method?).and_return true }
-        it 'calls the method' do
+
+        it "calls the method" do
           expect(object).to receive(:some_method)
           callback.call(object)
         end
       end
 
-      context 'if method returns false' do
+      context "if method returns false" do
         before { allow(object).to receive(:if_method?).and_return false }
-        it 'does not call the method' do
+
+        it "does not call the method" do
           expect(object).not_to receive(:some_method)
           callback.call(object)
         end
       end
     end
 
-    context 'a lambda for if' do
+    context "a lambda for if" do
       let(:callback) do
         described_class.new(:some_method, if: -> { if_method? })
       end
 
-      it 'calls the method when true' do
+      it "calls the method when true" do
         allow(object).to receive(:if_method?).and_return true
         expect(object).to receive(:some_method)
         callback.call(object)
       end
 
-      it 'does not call the method when false' do
+      it "does not call the method when false" do
         allow(object).to receive(:if_method?).and_return false
         expect(object).not_to receive(:some_method)
         callback.call(object)
       end
     end
 
-    context 'an array of ifs' do
-      let(:callback) { described_class.new(:some_method, if: [:if_method?, :if2?]) }
-      context 'both return true' do
-        before :each do
+    context "an array of ifs" do
+      let(:callback) { described_class.new(:some_method, if: %i[if_method? if2?]) }
+
+      context "both return true" do
+        before do
           allow(object).to receive(:if_method?).and_return true
           allow(object).to receive(:if2?).and_return true
         end
-        it 'calls the method' do
+
+        it "calls the method" do
           expect(object).to receive(:some_method)
           callback.call(object)
         end
       end
 
-      context 'one returns false' do
-        before :each do
+      context "one returns false" do
+        before do
           allow(object).to receive(:if_method?).and_return true
           allow(object).to receive(:if2?).and_return false
         end
 
-        it 'does not call the method' do
-          expect(object).to receive(:some_method).never
+        it "does not call the method" do
+          expect(object).not_to receive(:some_method)
           callback.call(object)
         end
       end
     end
   end
 
-  describe 'callback with unless' do
-    context 'a single if' do
+  describe "callback with unless" do
+    context "a single if" do
       let(:callback) { described_class.new(:some_method, unless: :unless_method?) }
 
-      context 'unless method returns false' do
+      context "unless method returns false" do
         before { allow(object).to receive(:unless_method?).and_return false }
 
-        it 'calls the method' do
+        it "calls the method" do
           expect(object).to receive(:some_method)
           callback.call(object)
         end
       end
 
-      context 'unless method returns true' do
-                before { allow(object).to receive(:unless_method?).and_return true }
-        it 'does not call the method' do
-          expect(object).to receive(:some_method).never
+      context "unless method returns true" do
+        before { allow(object).to receive(:unless_method?).and_return true }
+
+        it "does not call the method" do
+          expect(object).not_to receive(:some_method)
           callback.call(object)
         end
       end
     end
 
-    context 'a lambda for unless' do
+    context "a lambda for unless" do
       let(:callback) do
         described_class.new(:some_method, unless: -> { unless_method? })
       end
 
-      it 'calls the method when false' do
+      it "calls the method when false" do
         allow(object).to receive(:unless_method?).and_return false
         expect(object).to receive(:some_method)
         callback.call(object)
       end
 
-      it 'does not call the method when true' do
+      it "does not call the method when true" do
         allow(object).to receive(:unless_method?).and_return true
         expect(object).not_to receive(:some_method)
         callback.call(object)

data/spec/flow_machine/workflow_change_callback_spec.rb

@@ -1,25 +1,28 @@
 RSpec.describe FlowMachine::ChangeCallback do
   subject(:callback) { described_class.new(:field, :method, if: :condition?) }
 
+  before { allow(object).to receive(:run_workflow_method) { |m| object.send(m) } }
+
+  let(:object) { double(condition?: true) }
+
   specify { expect(callback.field).to eq(:field) }
   specify { expect(callback.method).to eq(:method) }
-  specify { expect(callback.options).to eq({ if: :condition? }) }
+  specify { expect(callback.options).to eq(if: :condition?) }
 
-  let(:object) { double(condition?: true) }
-  before { allow(object).to receive(:run_workflow_method) { |m| object.send(m) } }
+  context "the field changes" do
+    let(:changes) { { "field" => %i[old new] } }
 
-  context 'the field changes' do
-    let(:changes) { { 'field' => [:old, :new] } }
-    it 'calls the method' do
+    it "calls the method" do
       expect(object).to receive(:method)
       callback.call(object, changes)
     end
   end
 
-  context 'the field does not change' do
-    let(:changes) { { 'other_field' => [:old, :new] } }
-    it 'does not call the method' do
-      expect(object).to receive(:method).never
+  context "the field does not change" do
+    let(:changes) { { "other_field" => %i[old new] } }
+
+    it "does not call the method" do
+      expect(object).not_to receive(:method)
       callback.call(object, changes)
     end
   end

data/spec/flow_machine/workflow_spec.rb

@@ -1,4 +1,4 @@
-require 'ostruct'
+require "ostruct"
 
 RSpec.describe FlowMachine::Workflow do
   class Test1State < FlowMachine::WorkflowState
@@ -17,179 +17,189 @@ RSpec.describe FlowMachine::Workflow do
     after_save :after_save_callback
     after_transition :after_transition_callback
     def workflow_method; end
+
     def before_save_callback; end
+
     def after_save_callback; end
+
     def after_transition_callback; end
   end
 
-  describe 'state_names' do
-    it 'has the state names' do
-      expect(TestWorkflow.state_names).to eq(['test1', 'test2'])
+  describe "state_names" do
+    it "has the state names" do
+      expect(TestWorkflow.state_names).to eq(%w[test1 test2])
     end
 
-    it 'has the states in a hash keyed by names' do
-      expect(TestWorkflow.states).to eq({ test1: Test1State, test2: Test2State })
+    it "has the states in a hash keyed by names" do
+      expect(TestWorkflow.states).to eq(test1: Test1State, test2: Test2State)
     end
   end
 
-  describe 'reading initial state' do
+  describe "reading initial state" do
     subject(:workflow) { TestWorkflow.new(object) }
-    context 'default state field' do
+
+    context "default state field" do
       let(:object) { double(state: :test1) }
-      it 'has the state' do
+
+      it "has the state" do
         expect(workflow.current_state_name).to eq(:test1)
       end
     end
 
-    context 'with a different state field on the object' do
+    context "with a different state field on the object" do
       before { TestWorkflow.send(:state_attribute, :status) }
       # return to default
+
       after { TestWorkflow.send(:state_attribute, :state) }
 
       let(:object) { double(status: :test2) }
-      it 'has the state' do
+
+      it "has the state" do
         expect(workflow.current_state_name).to eq(:test2)
       end
     end
   end
 
-  describe '#transition' do
+  describe "#transition" do
     subject(:workflow) { TestWorkflow.new(object) }
+
     let(:object) { double(state: :test1) }
 
-    it 'errors on an invalid state' do
+    it "errors on an invalid state" do
       expect { workflow.transition to: :invalid }.to raise_error(ArgumentError)
     end
 
-    it 'changes the state of the object' do
-      expect(object).to receive(:state=).with('test2')
+    it "changes the state of the object" do
+      expect(object).to receive(:state=).with("test2")
       workflow.transition to: :test2
     end
 
-    it 'leaves the state if transitions to itself' do
+    it "leaves the state if transitions to itself" do
       workflow.transition
       expect(workflow.current_state_name).to eq(:test1)
       expect(object.state).to eq(:test1)
     end
   end
 
-  describe 'transition :after hooks' do
+  describe "transition :after hooks" do
     subject(:workflow) { TestWorkflow.new(object) }
+
     let(:object) { OpenStruct.new(state: :test1, changes: {}, save: true, object_method: true) }
 
-    it 'does not call the :after hook before saving' do
+    it "does not call the :after hook before saving" do
       expect(workflow).not_to receive(:workflow_method)
       workflow.transition to: :test2, after: :workflow_method
     end
 
-    it 'does not calls the :after hook on failure' do
+    it "does not calls the :after hook on failure" do
       expect(workflow).not_to receive(:workflow_method)
       workflow.transition to: :test1
       workflow.save
     end
 
-    it 'calls the :after hook on a state method' do
+    it "calls the :after hook on a state method" do
       expect_any_instance_of(Test1State).to receive(:state_method)
       expect_any_instance_of(Test2State).not_to receive(:state_method)
       workflow.transition to: :test2, after: :state_method
       workflow.save
     end
 
-    it 'calls the :after hook on a workflow method' do
+    it "calls the :after hook on a workflow method" do
       expect(workflow).to receive(:workflow_method)
       workflow.transition to: :test2, after: :workflow_method
       workflow.save
     end
 
-    it 'calls the :after hook on an object method' do
+    it "calls the :after hook on an object method" do
       expect(object).to receive(:object_method)
       workflow.transition to: :test2, after: :object_method
       workflow.save
     end
 
-    it 'allows a lambda' do
+    it "allows a lambda" do
       expect_any_instance_of(Test1State).to receive(:state_method)
-      workflow.transition to: :test2, after: ->{ state_method }
+      workflow.transition to: :test2, after: -> { state_method }
       workflow.save
     end
 
-    describe 'after_transition hook' do
-      it 'calls the hook on transition' do
+    describe "after_transition hook" do
+      it "calls the hook on transition" do
         expect(workflow).to receive(:after_transition_callback)
         workflow.transition to: :test2
       end
 
-      it 'does not call for invalid states' do
+      it "does not call for invalid states" do
         expect(workflow).not_to receive(:after_transition_callback)
         expect { workflow.transition to: :invalid_state }.to raise_error(ArgumentError)
       end
 
-      it 'does not call for ending in the same state' do
+      it "does not call for ending in the same state" do
         expect(workflow).not_to receive(:after_transition_callback)
         workflow.transition to: :test1
       end
     end
   end
 
-  describe '#persist' do
+  describe "#persist" do
     subject(:workflow) { TestWorkflow.new(object) }
+
     let(:object) { OpenStruct.new(state: :test1, changes: {}, save: true) }
 
-    context 'success' do
-      it 'saves the object' do
+    context "success" do
+      it "saves the object" do
         expect(workflow.persist).to be true
       end
 
-      it 'runs before and after_change hooks' do
+      it "runs before and after_change hooks" do
         expect(workflow.current_state).to receive(:fire_callbacks).with(:before_change, {})
         expect(workflow.current_state).to receive(:fire_callbacks).with(:after_change, {})
         expect(workflow.persist).to be true
       end
 
       it "runs after_enter hooks if it's in a new state" do
-        allow(object).to receive(:changes).and_return({'state' => ['test1', 'test2']})
-        expect(workflow.current_state).to receive(:fire_callbacks).with(:before_change, { 'state' => ['test1', 'test2'] })
-        expect(workflow.current_state).to receive(:fire_callbacks).with(:after_change, { 'state' => ['test1', 'test2'] })
-        expect(workflow.current_state).to receive(:fire_callbacks).with(:after_enter, { 'state' => ['test1', 'test2'] })
+        allow(object).to receive(:changes).and_return("state" => %w[test1 test2])
+        expect(workflow.current_state).to receive(:fire_callbacks).with(:before_change, "state" => %w[test1 test2])
+        expect(workflow.current_state).to receive(:fire_callbacks).with(:after_change, "state" => %w[test1 test2])
+        expect(workflow.current_state).to receive(:fire_callbacks).with(:after_enter, "state" => %w[test1 test2])
         expect(workflow.persist).to be true
       end
 
-      it 'runs the before_save callback' do
+      it "runs the before_save callback" do
         expect(workflow).to receive(:before_save_callback)
         workflow.persist
       end
 
-      it 'runs the after_save callback' do
+      it "runs the after_save callback" do
         expect(workflow).to receive(:after_save_callback)
         workflow.persist
       end
     end
 
-    context 'failure' do
+    context "failure" do
       before do
         expect(object).to receive(:save).and_return false
       end
 
-      it 'does not save the object' do
+      it "does not save the object" do
         expect(workflow.persist).to be false
       end
 
-      it 'runs the before_change callback' do
+      it "runs the before_change callback" do
         expect(workflow.current_state).to receive(:fire_callbacks).with(:before_change, {})
         expect(workflow.persist).to be false
       end
 
-      it 'runs the before_save callback' do
+      it "runs the before_save callback" do
         expect(workflow).to receive(:before_save_callback)
         workflow.persist
       end
 
-      it 'does not run the after_save callback' do
-        expect(workflow).to_not receive(:after_save_callback)
+      it "does not run the after_save callback" do
+        expect(workflow).not_to receive(:after_save_callback)
         workflow.persist
       end
 
-      it 'reverts to the old state' do
+      it "reverts to the old state" do
         expect(workflow).to be_test1
         workflow.transition to: :test2
         expect(workflow).to be_test2