state_machines-audit_trail 1.0.0

data/spec/helpers/active_record.rb

@@ -0,0 +1,222 @@
+require 'active_record'
+
+### Setup test database
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+
+class ARModelStateTransition < ActiveRecord::Base
+  belongs_to :ar_model
+end
+class ARModelNoInitialStateTransition < ActiveRecord::Base
+  belongs_to :ar_model_no_initial
+end
+
+class ARModelWithContextStateTransition < ActiveRecord::Base
+  belongs_to :ar_model_with_context
+end
+
+class ARModelWithMultipleContextStateTransition < ActiveRecord::Base
+  belongs_to :ar_model_with_multiple_context
+end
+
+class ARModelWithMultipleStateMachinesFirstTransition < ActiveRecord::Base
+  belongs_to :ar_model_with_multiple_state_machines
+end
+
+class ARModelWithMultipleStateMachinesSecondTransition < ActiveRecord::Base
+  belongs_to :ar_model_with_multiple_state_machines
+end
+
+class ARModelWithMultipleStateMachinesThirdTransition < ActiveRecord::Base
+  belongs_to :ar_model_with_multiple_state_machines
+end
+
+class ARModel < ActiveRecord::Base
+
+  state_machine :state, initial: :waiting do # log initial state?
+    audit_trail
+
+    event :start do
+      transition [:waiting, :stopped] => :started
+    end
+
+    event :stop do
+      transition :started => :stopped
+    end
+  end
+end
+
+class ARModelNoInitial < ActiveRecord::Base
+
+  state_machine :state, initial: :waiting do # log initial state?
+    audit_trail initial: false
+
+    event :start do
+      transition [:waiting, :stopped] => :started
+    end
+
+    event :stop do
+      transition :started => :stopped
+    end
+  end
+end
+#
+class ARModelWithContext < ActiveRecord::Base
+  state_machine :state, initial: :waiting do # log initial state?
+    audit_trail context: :context
+
+    event :start do
+      transition [:waiting, :stopped] => :started
+    end
+
+    event :stop do
+      transition :started => :stopped
+    end
+  end
+
+  def context
+    'Some context'
+  end
+end
+
+class ARModelWithMultipleContext < ActiveRecord::Base
+  state_machine :state, initial: :waiting do # log initial state?
+    audit_trail context: [:context, :second_context, :context_with_args]
+
+    event :start do
+      transition [:waiting, :stopped] => :started
+    end
+
+    event :stop do
+      transition :started => :stopped
+    end
+  end
+
+  def context
+    'Some context'
+  end
+
+  def second_context
+    'Extra context'
+  end
+
+  def context_with_args(transition)
+    id = transition.args.last.delete(:id) if transition.args.present?
+    id
+  end
+
+end
+
+class ARModelDescendant < ARModel
+end
+
+class ARModelDescendantWithOwnStateMachines < ARModel
+  state_machine :state, :initial => :new do
+    audit_trail
+
+    event :complete do
+      transition [:new] => :completed
+    end
+  end
+end
+
+class ARModelWithMultipleStateMachines < ActiveRecord::Base
+
+  state_machine :first, :initial => :beginning do
+    audit_trail
+
+    event :begin_first do
+      transition :beginning => :end
+    end
+  end
+
+  state_machine :second do
+    audit_trail
+
+    event :begin_second do
+      transition nil => :beginning_second
+    end
+  end
+
+  state_machine :third, :action => nil do
+    audit_trail
+
+    event :begin_third do
+      transition nil => :beginning_third
+    end
+
+    event :end_third do
+      transition :beginning_third => :done_third
+    end
+  end
+end
+
+module SomeNamespace
+  class ARModelStateTransition < ActiveRecord::Base
+    belongs_to :test_model
+  end
+
+  class ARModel < ActiveRecord::Base
+
+    state_machine :state, initial: :waiting do # log initial state?
+      audit_trail
+
+      event :start do
+        transition [:waiting, :stopped] => :started
+      end
+
+      event :stop do
+        transition :started => :stopped
+      end
+    end
+  end
+end
+
+#
+# Generate tables
+#
+def create_model_table(owner_class, multiple_state_machines = false)
+  ActiveRecord::Base.connection.create_table(owner_class.name.tableize) do |t|
+    t.string :state unless multiple_state_machines
+    t.string :type
+
+    if multiple_state_machines
+      t.string :first
+      t.string :second
+      t.string :third
+    end
+
+    t.timestamps null: false
+  end
+end
+
+create_model_table(ARModel)
+create_model_table(ARModelNoInitial)
+create_model_table(ARModelWithContext)
+create_model_table(ARModelWithMultipleContext)
+create_model_table(ARModelWithMultipleStateMachines, true)
+
+
+def create_transition_table(owner_class, state, add_context = false)
+  class_name = "#{owner_class.name}#{state.to_s.camelize}Transition"
+  ActiveRecord::Base.connection.create_table(class_name.tableize) do |t|
+
+    # t.references :"#{owner_class.name.pluralize.demodulize.tableize}"
+    t.integer owner_class.name.foreign_key
+    t.string :event
+    t.string :from
+    t.string :to
+
+    t.string :context if add_context
+    t.string :second_context if add_context
+    t.string :context_with_args if add_context
+    t.datetime :created_at
+  end
+end
+
+create_transition_table(ARModel, :state)
+create_transition_table(ARModelNoInitial, :state)
+create_transition_table(ARModelWithContext, :state, true)
+create_transition_table(ARModelWithMultipleContext, :state, true)
+create_transition_table(ARModelWithMultipleStateMachines, :first)
+create_transition_table(ARModelWithMultipleStateMachines, :second)
+create_transition_table(ARModelWithMultipleStateMachines, :third)

data/spec/helpers/mongoid.rb

@@ -0,0 +1,79 @@
+require 'mongoid'
+
+### Setup test database
+Mongoid.load!(File.expand_path('../mongoid.yml', __FILE__), :test)
+
+# We probably want to provide a generator for this model and the accompanying migration.
+class MongoidTestModelStateTransition
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  belongs_to :mongoid_test_model
+
+  field :event, type: String
+  field :from,  type: String
+  field :to,    type: String
+end
+
+class MongoidTestModelWithMultipleStateMachinesFirstTransition
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  belongs_to :mongoid_test_model
+
+  field :event, type: String
+  field :from,  type: String
+  field :to,    type: String
+end
+
+class MongoidTestModelWithMultipleStateMachinesSecondTransition
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  belongs_to :mongoid_test_model
+
+  field :event, type: String
+  field :from,  type: String
+  field :to,    type: String
+end
+
+class MongoidTestModel
+  
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  
+  state_machine :state, initial: :waiting do # log initial state?
+    audit_trail :orm => :mongoid
+
+    event :start do
+      transition [:waiting, :stopped] => :started
+    end
+    
+    event :stop do
+      transition :started => :stopped
+    end
+  end
+end
+
+class MongoidTestModelDescendant < MongoidTestModel
+  include Mongoid::Timestamps
+end
+
+class MongoidTestModelWithMultipleStateMachines
+  
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  state_machine :first, initial: :beginning do
+    audit_trail
+
+    event :begin_first do
+      transition :beginning => :end
+    end
+  end
+  
+  state_machine :second do
+    audit_trail
+
+    event :begin_second do
+      transition nil => :beginning_second
+    end
+  end
+end

data/spec/helpers/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: sm_audit_trail
+      hosts:
+        - localhost:27017

data/spec/lib/state_machines/audit_trail/backend/active_record_spec.rb

@@ -0,0 +1,225 @@
+# reset integrations so that something like Mongoid is not loaded and conflicting
+require 'state_machines'
+StateMachines::Integrations.reset
+
+require 'spec_helper'
+require 'state_machines-activerecord'
+require 'helpers/active_record'
+
+describe StateMachines::AuditTrail::Backend::ActiveRecord do
+
+  context ':initial option' do
+    it 'default logs' do
+      target = ARModel.new
+      # initial transition is built but not saved
+      expect(target.new_record?).to be_truthy
+      expect(target.ar_model_state_transitions.count).to eq 0
+      target.save!
+
+      # initial transition is saved and should be present
+      expect(target.new_record?).to be_falsey
+      expect(target.ar_model_state_transitions.count).to eq 1
+      state_transition = target.ar_model_state_transitions.first
+      expect(state_transition.from).to be_nil
+      expect(state_transition.to).to eq 'waiting'
+      expect(state_transition.event).to be_nil
+    end
+
+    it 'false skips log' do
+      target = ARModelNoInitial.new
+      # initial transition is not-built
+      expect(target.new_record?).to be_truthy
+      expect(target.ar_model_no_initial_state_transitions.count).to eq 0
+      target.save!
+
+      # after save, initial transition is not-saved
+      expect(target.new_record?).to be_falsey
+      expect(target.ar_model_no_initial_state_transitions.count).to eq 0
+    end
+  end
+
+  context '#create_for' do
+    it 'should be Backend::ActiveRecord' do
+      backend = StateMachines::AuditTrail::Backend.create_for(ARModelWithContextStateTransition, ARModel)
+      expect(backend).to be_instance_of(StateMachines::AuditTrail::Backend::ActiveRecord)
+    end
+
+    it 'should create a has many association on the state machine owner' do
+      StateMachines::AuditTrail::Backend.create_for(ARModelWithContextStateTransition, ARModel)
+      expect(ARModel.reflect_on_association(:ar_model_state_transitions).collection?).to be_truthy
+    end
+
+    it 'should handle namespaced models' do
+      StateMachines::AuditTrail::Backend.create_for(ARModelWithContextStateTransition, SomeNamespace::ARModel)
+      expect(SomeNamespace::ARModel.reflect_on_association(:ar_model_state_transitions).collection?).to be_truthy
+    end
+
+    it 'should handle namespaced state transition model' do
+      StateMachines::AuditTrail::Backend.create_for(SomeNamespace::ARModelStateTransition, ARModel)
+      expect(ARModel.reflect_on_association(:ar_model_state_transitions).collection?).to be_truthy
+    end
+  end
+
+  context 'single state machine' do
+    shared_examples 'audit trail with context' do
+      it 'should populate all fields' do
+
+        # state_transition =target.state_transitions.first
+        # expect(state_transition.from).to be_nil
+
+        expect(target.state_name).to eq :waiting
+        target.start!
+        expect(target.state_name).to eq :started
+
+        last_transition = ARModelWithContextStateTransition.where(:ar_model_with_context_id => target.id).last
+
+        expect(last_transition).not_to be_nil
+        expect(last_transition.event).to eq 'start'
+        expect(last_transition.from).to eq 'waiting'
+        expect(last_transition.to).to eq 'started'
+        expect(last_transition.context).not_to be_nil
+        expect(last_transition.created_at).to be_within(10.seconds).of(Time.now.utc)
+      end
+
+      it 'do nothing on failed transition' do
+        expect { target.stop }.not_to change(ARModelWithContextStateTransition, :count)
+      end
+    end
+
+    context 'on created model' do
+      let!(:target) { ARModelWithContext.create! }
+      include_examples 'audit trail with context'
+
+      it 'should log multiple events' do
+        expect { target.start && target.stop && target.start }.to change(ARModelWithContextStateTransition, :count).by(3)
+      end
+    end
+
+    context 'on new model' do
+      let!(:target) { ARModelWithContext.new }
+      include_examples 'audit trail with context'
+
+      it 'should log multiple events including the first event from save' do
+        expect { target.start && target.stop && target.start }.to change(ARModelWithContextStateTransition, :count).by(4)
+      end
+    end
+
+    context 'wants to log a single context' do
+      before(:each) do
+        StateMachines::AuditTrail::Backend.create_for(ARModelWithContextStateTransition, ARModelWithContext, :context)
+      end
+
+      let!(:target) { ARModelWithContext.create! }
+
+      it 'should populate all fields' do
+        target.start!
+        last_transition = ARModelWithContextStateTransition.where(:ar_model_with_context_id => target.id).last
+        expect(last_transition.context).to eq target.context
+      end
+    end
+
+    context 'wants to log multiple context fields' do
+      before(:each) do
+        StateMachines::AuditTrail::Backend.create_for(ARModelWithMultipleContextStateTransition, ARModelWithMultipleContext, [:context, :second_context, :context_with_args])
+      end
+
+      let!(:target) { ARModelWithMultipleContext.create! }
+
+      it 'should populate all fields' do
+        target.start!
+        last_transition = ARModelWithMultipleContextStateTransition.where(:ar_model_with_multiple_context_id => target.id).last
+        expect(last_transition.context).to eq target.context
+        expect(last_transition.second_context).to eq target.second_context
+      end
+
+      it 'should log an event with passed arguments' do
+        target.start!('one', 'two', 'three', 'for', id: 1)
+        last_transition = ARModelWithMultipleContextStateTransition.where(:ar_model_with_multiple_context_id => target.id).last
+        expect(last_transition.context_with_args).to eq '1'
+      end
+    end
+
+  end
+
+
+  context 'multiple state machines' do
+    let!(:target) { ARModelWithMultipleStateMachines.create! }
+
+    it 'should log a state transition for the affected state machine' do
+      expect { target.begin_first! }.to change(ARModelWithMultipleStateMachinesFirstTransition, :count).by(1)
+    end
+
+    it 'should not log a state transition for the unaffected state machine' do
+      expect { target.begin_first! }.not_to change(ARModelWithMultipleStateMachinesSecondTransition, :count)
+    end
+  end
+
+  context 'with an initial state' do
+    let(:target_class) { ARModelWithMultipleStateMachines }
+    let(:state_transition_class) { ARModelWithMultipleStateMachinesFirstTransition }
+
+    it 'should log a state transition for the inital state' do
+      expect { target_class.create! }.to change(state_transition_class, :count).by(1)
+    end
+
+    it 'should only set the :to state for the initial transition' do
+      target_class.create!
+      initial_transition = state_transition_class.last
+      expect(initial_transition.event).to be_nil
+      expect(initial_transition.from).to be_nil
+      expect(initial_transition.to).to eq 'beginning'
+      expect(initial_transition.created_at).to be_within(10.seconds).of(Time.now.utc)
+    end
+  end
+
+  context 'without an initial state' do
+    let(:target_class) { ARModelWithMultipleStateMachines }
+    let(:state_transition_class) { ARModelWithMultipleStateMachinesSecondTransition }
+
+    it 'should not log a transition when the object is created' do
+      expect { target_class.create! }.not_to change(state_transition_class, :count)
+    end
+
+    it 'should log a transition for the first event' do
+      expect { target_class.create.begin_second! }.to change(state_transition_class, :count).by(1)
+    end
+
+    it 'should not set a value for the :from state on the first transition' do
+      target_class.create.begin_second!
+      first_transition = state_transition_class.last
+      expect(first_transition.event).to eq 'begin_second'
+      expect(first_transition.from).to be_nil
+      expect(first_transition.to).to eq 'beginning_second'
+      expect(first_transition.created_at).to be_within(10.seconds).of(Time.now.utc)
+    end
+
+    it 'should be fine transitioning before saved on an :action => nil state machine' do
+      expect {
+        machine = target_class.new
+        machine.begin_third
+        machine.save!
+      }.to change(ARModelWithMultipleStateMachinesThirdTransition, :count).by(1)
+    end
+
+    it 'should queue up transitions to be saved before being saved on an :action => nil state machine' do
+      expect {
+        machine = target_class.new
+        machine.begin_third
+        machine.end_third
+        machine.save!
+      }.to change(ARModelWithMultipleStateMachinesThirdTransition, :count).by(2)
+    end
+  end
+
+  context 'STI' do
+    it 'resolve class name' do
+      m = ARModelDescendant.create!
+      expect { m.start! }.not_to raise_error
+    end
+
+    it 'resolve class name on own state machine' do
+      m = ARModelDescendantWithOwnStateMachines.create!
+      expect { m.complete! }.not_to raise_error
+    end
+  end
+end