jsmestad-audit_trail 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: babb59af06913e7851b42c4dbaa32b06e770dc8a
+  data.tar.gz: ed51a452d6a2d8b5f0de32e84a361d14bd4e8d9f
+SHA512:
+  metadata.gz: 0a5a764ce383d6d6b853c05278bf2abbbba400c61b0334704f36d65ea31e3665840c9eaab6639c616575a5dfa5baf973d39312322ee757e49cfb44c72bef1bdf
+  data.tar.gz: 71376d548bf8b496fdf762f68ebf4b79cf17704d31a3cd468d5a609c25922c3f53bb4fda62e59b8020e4d04082ce2bcd88dd9246d3ba3a9211c7bd059a7b02c8

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+/.bundle
+Gemfile.lock
+pkg/*
+.DS_Store
+*.rbc
+/doc
+.yardoc

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+script: bundle exec rake
+services: mongodb
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - ree
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jesse Storimer & Willem van Bergen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,47 @@
+= StateMachine audit trail
+
+This plugin for the state machine gem (see https://github.com/pluginaweek/state_machine) adds support for keeping an audit trail for any state machine. Having an audit trail gives you a complete history of the state changes in your model. This history allows you to investigate incidents or perform analytics, like: "How long does it take on average to go from state a to state b?", or "What percentage of cases goes from state a to b via state c?"
+
+== ORM support
+
+Note: while the state_machine gem integrates with multiple ORMs, this plugin is currently limited to the following ORM backends:
+
+* ActiveRecord
+* Mongoid
+
+It should be easy to add new backends by looking at the implementation of the current backends. Pull requests are welcome!
+
+== Usage
+
+First, make the gem available by adding it to your <tt>Gemfile</tt>, and run <tt>bundle install</tt>:
+
+  gem 'state_machine-audit_trail'
+
+Create a model/table that holds the audit trail. The table needs to have a foreign key to the original object, an "event" field, a "from" state field, a "to" state field, and a "created_at" timestamp that stores the timestamp of the transition. This gem comes with a Rails 3 generator to create a model and a migration like that.
+
+  rails generate state_machine:audit_trail <model> <state_attribute>
+
+For a model called "Model", and a state attribute "state", this will generate the ModelStateTransition model and an accompanying migration.
+
+Next, tell your state machine you want to store an audit trail:
+
+  class Model < ActiveRecord::Base
+    state_machine :state, :initial => :start do
+      store_audit_trail
+      ...
+
+If your audit trail model does not use the default naming scheme, provide it using the <tt>:to</tt> option:
+
+  class Model < ActiveRecord::Base
+    state_machine :state, :initial => :start do
+      store_audit_trail :to => 'ModelAuditTrail'
+      ...
+
+That's it! The plugin will register an <tt>after_transition</tt> callback that is used to log all transitions. It will also log the initial state if there is one.
+
+If you would like to store additional messages in the audit trail, you can do so with the following:
+    store_audit_trail :context_to_log => :state_message # Will grab the results of the state_message method on the model and store it in a field called state_message on the audit trail model
+
+== About
+
+This plugin is written by Jesse Storimer and Willem van Bergen for Shopify. Mongoid support was contributed by Siddharth (https://github.com/svs). It is released under the MIT license (see LICENSE).

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.pattern = "./spec/**/*_spec.rb"
+  task.rspec_opts = ['--color']
+end
+
+task :default => [:spec]

data/jsmestad-audit_trail.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'state_machine/audit_trail/version'
+
+Gem::Specification.new do |s|
+  s.name        = "jsmestad-audit_trail"
+  s.version     = StateMachine::AuditTrail::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Willem van Bergen", "Jesse Storimer"]
+  s.email       = ["willem@shopify.com", "jesse@shopify.com"]
+  s.homepage    = "https://github.com/wvanbergen/state_machine-audit_trail"
+  s.summary     = %q{Log transitions on a state machine to support auditing and business process analytics.}
+  s.description = %q{Log transitions on a state machine to support auditing and business process analytics.}
+  s.license     = "MIT"
+
+  s.add_runtime_dependency('state_machine')
+
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rspec', '~> 2')
+  s.add_development_dependency('activerecord', '~> 3')
+  s.add_development_dependency('sqlite3')
+  s.add_development_dependency('mongoid', '~> 2')
+  s.add_development_dependency('bson_ext')
+
+  s.files = `git ls-files`.split($/)
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+end

data/lib/state_machine-audit_trail.rb

@@ -0,0 +1,2 @@
+# To keep Rails happy
+require 'state_machine/audit_trail'

data/lib/state_machine/audit_trail.rb

@@ -0,0 +1,15 @@
+require 'state_machine'
+
+module StateMachine::AuditTrail
+    
+  def self.setup
+    StateMachine::Machine.send(:include, StateMachine::AuditTrail::TransitionAuditing)
+  end
+end
+
+require 'state_machine/audit_trail/version'
+require 'state_machine/audit_trail/transition_auditing'
+require 'state_machine/audit_trail/backend'
+require 'state_machine/audit_trail/railtie' if defined?(::Rails)
+
+StateMachine::AuditTrail.setup

data/lib/state_machine/audit_trail/backend.rb

@@ -0,0 +1,28 @@
+class StateMachine::AuditTrail::Backend < Struct.new(:transition_class, :owner_class)
+
+  autoload :Mongoid,      'state_machine/audit_trail/backend/mongoid'
+  autoload :ActiveRecord, 'state_machine/audit_trail/backend/active_record'
+
+  def log(object, event, from, to, timestamp = Time.now)
+    raise NotImplemented, "Implement in a subclass."
+  end
+  
+  # Public creates an instance of the class which does the actual logging
+  #
+  # transition_class: the Class which holds the audit trail
+  #
+  # in order to adda new ORM here, copy audit_trail/mongoid.rb to whatever you want to call the new file and implement the #log function there
+  # then, return from here the appropriate object based on which ORM the transition_class is using  
+  def self.create_for_transition_class(transition_class, owner_class, context_to_log = nil)
+    if Object.const_defined?('ActiveRecord') && transition_class.ancestors.include?(::ActiveRecord::Base)
+      return StateMachine::AuditTrail::Backend::ActiveRecord.new(transition_class, owner_class, context_to_log)
+    elsif Object.const_defined?('Mongoid') && transition_class.ancestors.include?(::Mongoid::Document)
+      # Mongoid implementation doesn't yet support additional context fields
+      raise NotImplemented, "Mongoid does not support additional context fields" if context_to_log.present?
+
+      return StateMachine::AuditTrail::Backend::Mongoid.new(transition_class, owner_class)
+    else
+      raise NotImplemented, "Only support for ActiveRecord and Mongoid is included at this time"
+    end
+  end
+end

data/lib/state_machine/audit_trail/backend/active_record.rb

@@ -0,0 +1,18 @@
+class StateMachine::AuditTrail::Backend::ActiveRecord < StateMachine::AuditTrail::Backend
+  attr_accessor :context_to_log
+
+  def initialize(transition_class, owner_class, context_to_log = nil)
+    self.context_to_log = context_to_log
+    @association = transition_class.to_s.tableize.to_sym
+    super transition_class
+    owner_class.has_many @association
+  end
+
+  def log(object, event, from, to, timestamp = Time.now)
+    # Let ActiveRecord manage the timestamp for us so it does the
+    # right thing with regards to timezones.
+    params = {:event => event, :from_state => from, :to_state => to}
+    params[self.context_to_log] = object.send(self.context_to_log) unless self.context_to_log.nil?
+    object.send(@association).create(params)
+  end
+end

data/lib/state_machine/audit_trail/backend/mongoid.rb

@@ -0,0 +1,19 @@
+# This is the class that does the actual logging.
+# We need one of these per ORM
+
+class StateMachine::AuditTrail::Backend::Mongoid < StateMachine::AuditTrail::Backend
+
+  # Public writes the log to the database
+  #
+  # object: the object being watched by the state_machine observer
+  # event:  the event being observed by the state machine
+  # from:   the state of the object prior to the event
+  # to:     the state of the object after the event
+  def log(object, event, from, to, timestamp = Time.now)
+    tc = transition_class
+    foreign_key_field = tc.relations.keys.first
+    transition_class.create(foreign_key_field => object, :event => event, :from => from, :to => to, :create_at => timestamp)
+  end
+
+
+end

data/lib/state_machine/audit_trail/railtie.rb

@@ -0,0 +1,5 @@
+class StateMachine::AuditTrail::Railtie < ::Rails::Railtie
+  generators do
+    require 'state_machine/audit_trail_generator'
+  end
+end

data/lib/state_machine/audit_trail/transition_auditing.rb

@@ -0,0 +1,41 @@
+# this class inserts the appropriate hooks into the state machine.
+# it also contains functions to instantiate an object of the "transition_class"
+# the transition_class is the class for the model which holds the audit_trail
+
+module StateMachine::AuditTrail::TransitionAuditing
+  attr_accessor :transition_class_name
+
+  # Public tells the state machine to hook in the appropriate before / after behaviour
+  #
+  # options: a Hash of options. keys that are used are :to => CustomTransitionClass,
+  #   :context_to_log => method(s) to call on object and store in transitions
+  def store_audit_trail(options = {})
+    state_machine = self
+    state_machine.transition_class_name = (options[:to] || default_transition_class_name).to_s
+    state_machine.after_transition do |object, transition|
+      state_machine.audit_trail(options[:context_to_log]).log(object, transition.event, transition.from, transition.to)
+    end
+
+    state_machine.owner_class.after_create do |object|
+      if !object.send(state_machine.attribute).nil?
+        state_machine.audit_trail(options[:context_to_log]).log(object, nil, nil, object.send(state_machine.attribute))
+      end
+    end
+  end
+
+  # Public returns an instance of the class which does the actual audit trail logging
+  def audit_trail(context_to_log = nil)
+    @transition_auditor ||= StateMachine::AuditTrail::Backend.create_for_transition_class(transition_class, self.owner_class, context_to_log)
+  end
+
+  private
+
+  def transition_class
+    @transition_class ||= transition_class_name.constantize
+  end
+
+  def default_transition_class_name
+    owner_class_or_base_class = owner_class.respond_to?(:base_class) ? owner_class.base_class : owner_class
+    "#{owner_class_or_base_class.name}#{attribute.to_s.camelize}Transition"
+  end
+end

data/lib/state_machine/audit_trail/version.rb

@@ -0,0 +1,5 @@
+module StateMachine
+  module AuditTrail
+    VERSION = "0.1.5"
+  end
+end

data/lib/state_machine/audit_trail_generator.rb

@@ -0,0 +1,21 @@
+require 'rails/generators'
+
+class StateMachine::AuditTrailGenerator < ::Rails::Generators::Base
+
+  source_root File.join(File.dirname(__FILE__), 'templates')
+
+  argument :source_model
+  argument :state_attribute,  :default => 'state'
+  argument :transition_model, :default => ''
+
+
+  def create_model
+    Rails::Generators.invoke('model', [transition_class_name, "#{source_model.tableize.singularize}:references", "event:string", "from_state:string", "to_state:string", "created_at:timestamp", '--no-timestamps', '--fixture=false'])
+  end
+
+  protected
+
+  def transition_class_name
+    transition_model.blank? ? "#{source_model.camelize}#{state_attribute.camelize}Transition" : transition_model
+  end
+end

data/spec/helpers/active_record.rb

@@ -0,0 +1,122 @@
+require 'active_record'
+
+### Setup test database
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+
+ActiveRecord::Base.connection.create_table(:active_record_test_models) do |t|
+  t.string :state
+  t.string :type
+  t.timestamps
+end
+
+ActiveRecord::Base.connection.create_table(:active_record_test_model_with_contexts) do |t|
+  t.string :state
+  t.string :type
+  t.timestamps
+end
+
+ActiveRecord::Base.connection.create_table(:active_record_test_model_with_multiple_state_machines) do |t|
+  t.string :first
+  t.string :second
+  t.timestamps
+end
+
+# We probably want to provide a generator for this model and the accompanying migration.
+class ActiveRecordTestModelStateTransition < ActiveRecord::Base
+  belongs_to :test_model
+end
+
+class ActiveRecordTestModelWithContextStateTransition < ActiveRecord::Base
+  belongs_to :test_model
+end
+
+class ActiveRecordTestModelWithMultipleStateMachinesFirstTransition < ActiveRecord::Base
+  belongs_to :test_model
+end
+
+class ActiveRecordTestModelWithMultipleStateMachinesSecondTransition < ActiveRecord::Base
+  belongs_to :test_model
+end
+
+class ActiveRecordTestModel < ActiveRecord::Base
+
+  state_machine :state, :initial => :waiting do # log initial state?
+    store_audit_trail
+
+    event :start do
+      transition [:waiting, :stopped] => :started
+    end
+
+    event :stop do
+      transition :started => :stopped
+    end
+  end
+end
+
+class ActiveRecordTestModelWithContext < ActiveRecord::Base
+  state_machine :state, :initial => :waiting do # log initial state?
+    store_audit_trail :context_to_log => :context
+
+    event :start do
+      transition [:waiting, :stopped] => :started
+    end
+
+    event :stop do
+      transition :started => :stopped
+    end
+  end
+
+  def context
+    "Some context"
+  end
+end
+
+class ActiveRecordTestModelDescendant < ActiveRecordTestModel
+end
+
+class ActiveRecordTestModelDescendantWithOwnStateMachine < ActiveRecordTestModel
+  state_machine :state, :initial => :new do
+    store_audit_trail
+
+    event :complete do
+      transition [:new] => :completed
+    end
+  end
+end
+
+class ActiveRecordTestModelWithMultipleStateMachines < ActiveRecord::Base
+
+  state_machine :first, :initial => :beginning do
+    store_audit_trail
+
+    event :begin_first do
+      transition :beginning => :end
+    end
+  end
+
+  state_machine :second do
+    store_audit_trail
+
+    event :begin_second do
+      transition nil => :beginning_second
+    end
+  end
+end
+
+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.integer owner_class.name.foreign_key
+    t.string :event
+    t.string :from_state
+    t.string :to_state
+    t.string :context if add_context
+    t.datetime :created_at
+  end
+end
+
+create_transition_table(ActiveRecordTestModel, :state)
+create_transition_table(ActiveRecordTestModelWithContext, :state, true)
+create_transition_table(ActiveRecordTestModelWithMultipleStateMachines, :first)
+create_transition_table(ActiveRecordTestModelWithMultipleStateMachines, :second)

data/spec/helpers/mongoid.rb

@@ -0,0 +1,72 @@
+require 'mongoid'
+
+### Setup test database
+
+Mongoid.configure do |config|
+  config.master = Mongo::Connection.new.db("sm_audit_trail")
+end
+
+
+
+# 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
+end
+
+class MongoidTestModelWithMultipleStateMachinesFirstTransition
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  belongs_to :mongoid_test_model
+end
+
+class MongoidTestModelWithMultipleStateMachinesSecondTransition
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  belongs_to :mongoid_test_model
+end
+
+class MongoidTestModel
+  
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  
+  state_machine :state, :initial => :waiting do # log initial state?
+    store_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
+    store_audit_trail 
+
+    event :begin_first do
+      transition :beginning => :end
+    end
+  end
+  
+  state_machine :second do
+    store_audit_trail 
+
+    event :begin_second do
+      transition nil => :beginning_second
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rspec'
+require 'state_machine/audit_trail'
+
+RSpec.configure do |config|
+end

data/spec/state_machine/active_record_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'helpers/active_record'
+
+describe StateMachine::AuditTrail::Backend::ActiveRecord do
+
+  it "should create an ActiveRecord backend" do
+    backend = StateMachine::AuditTrail::Backend.create_for_transition_class(ActiveRecordTestModelStateTransition, ActiveRecordTestModel)
+    backend.should be_instance_of(StateMachine::AuditTrail::Backend::ActiveRecord)
+  end
+
+  it "should create a has many association on the state machine owner" do
+    backend = StateMachine::AuditTrail::Backend.create_for_transition_class(ActiveRecordTestModelStateTransition, ActiveRecordTestModel)
+    ActiveRecordTestModel.reflect_on_association(:active_record_test_model_state_transitions).collection?.should be_true
+  end
+
+  context 'on an object with a single state machine' do
+    let!(:state_machine) { ActiveRecordTestModel.create! }
+
+    it "should log an event with all fields set correctly" do
+      state_machine.start!
+      last_transition = ActiveRecordTestModelStateTransition.where(:active_record_test_model_id => state_machine.id).last
+
+      last_transition.event.to_s.should == 'start'
+      last_transition.from_state.should == 'waiting'
+      last_transition.to_state.should == 'started'
+      #last_transition.context.should_not be_nil
+      last_transition.created_at.should be_within(10.seconds).of(Time.now.utc)
+    end
+
+    it "should log multiple events" do
+      lambda { state_machine.start && state_machine.stop && state_machine.start }.should change(ActiveRecordTestModelStateTransition, :count).by(3)
+    end
+
+    it "should do nothing when the transition is not executed successfully" do
+      lambda { state_machine.stop }.should_not change(ActiveRecordTestModelStateTransition, :count)
+    end
+  end
+
+  context 'on an object with a single state machine that wants to log a single context' do
+    before do
+      backend = StateMachine::AuditTrail::Backend.create_for_transition_class(ActiveRecordTestModelWithContextStateTransition, ActiveRecordTestModelWithContext, :context)
+    end
+
+    let!(:state_machine) { ActiveRecordTestModelWithContext.create! }
+
+    it "should log an event with all fields set correctly" do
+      state_machine.start!
+      last_transition = ActiveRecordTestModelWithContextStateTransition.where(:active_record_test_model_with_context_id => state_machine.id).last
+      last_transition.context.should == state_machine.context
+    end
+  end
+
+  context 'on an object with multiple state machines' do
+    let!(:state_machine) { ActiveRecordTestModelWithMultipleStateMachines.create! }
+
+    it "should log a state transition for the affected state machine" do
+      lambda { state_machine.begin_first! }.should change(ActiveRecordTestModelWithMultipleStateMachinesFirstTransition, :count).by(1)
+    end
+
+    it "should not log a state transition for the unaffected state machine" do
+      lambda { state_machine.begin_first! }.should_not change(ActiveRecordTestModelWithMultipleStateMachinesSecondTransition, :count)
+    end
+  end
+
+  context 'on an object with a state machine having an initial state' do
+    let(:state_machine_class) { ActiveRecordTestModelWithMultipleStateMachines }
+    let(:state_transition_class) { ActiveRecordTestModelWithMultipleStateMachinesFirstTransition }
+
+    it "should log a state transition for the inital state" do
+      lambda { state_machine_class.create! }.should change(state_transition_class, :count).by(1)
+    end
+
+    it "should only set the :to state for the initial transition" do
+      state_machine_class.create!
+      initial_transition = state_transition_class.last
+      initial_transition.event.should be_nil
+      initial_transition.from_state.should be_nil
+      initial_transition.to_state.should == 'beginning'
+      initial_transition.created_at.should be_within(10.seconds).of(Time.now.utc)
+    end
+  end
+
+  context 'on an object with a state machine not having an initial state' do
+    let(:state_machine_class) { ActiveRecordTestModelWithMultipleStateMachines }
+    let(:state_transition_class) { ActiveRecordTestModelWithMultipleStateMachinesSecondTransition }
+
+    it "should not log a transition when the object is created" do
+      lambda { state_machine_class.create! }.should_not change(state_transition_class, :count)
+    end
+
+    it "should log a transition for the first event" do
+      lambda { state_machine_class.create.begin_second! }.should change(state_transition_class, :count).by(1)
+    end
+
+    it "should not set a value for the :from state on the first transition" do
+      state_machine_class.create.begin_second!
+      first_transition = state_transition_class.last
+      first_transition.event.to_s.should == 'begin_second'
+      first_transition.from_state.should be_nil
+      first_transition.to_state.should == 'beginning_second'
+      first_transition.created_at.should be_within(10.seconds).of(Time.now.utc)
+    end
+  end
+
+  context 'on a class using STI' do
+    it "should properly grab the class name from STI models" do
+      m = ActiveRecordTestModelDescendant.create!
+      lambda { m.start! }.should_not raise_error
+    end
+  end
+
+  context 'on a class using STI with own state machine' do
+    it "should properly grab the class name from STI models" do
+      m = ActiveRecordTestModelDescendantWithOwnStateMachine.create!
+      lambda { m.complete! }.should_not raise_error
+    end
+  end
+end

data/spec/state_machine/audit_trail_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe StateMachine::AuditTrail do
+  
+  it "should have a VERSION constant" do
+    StateMachine::AuditTrail.const_defined?('VERSION').should be_true
+  end
+  
+  it "should include the auditing module into StateMachine::Machine" do
+    StateMachine::Machine.included_modules.should include(StateMachine::AuditTrail::TransitionAuditing)
+  end
+end

data/spec/state_machine/mongoid_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'helpers/mongoid'
+
+describe StateMachine::AuditTrail::Backend::Mongoid do
+
+  it "should create a Mongoid backend" do
+    backend = StateMachine::AuditTrail::Backend.create_for_transition_class(MongoidTestModelStateTransition, MongoidTestModel)
+    backend.should be_instance_of(StateMachine::AuditTrail::Backend::Mongoid)
+  end
+  
+  context 'on an object with a single state machine' do
+    let!(:state_machine) { MongoidTestModel.create! }
+        
+    it "should log an event with all fields set correctly" do
+      state_machine.start!
+      last_transition = MongoidTestModelStateTransition.where(:mongoid_test_model_id => state_machine.id).last
+
+      last_transition.event.to_s.should == 'start'
+      last_transition.from.should == 'waiting'
+      last_transition.to.should == 'started'
+      last_transition.created_at.should be_within(10.seconds).of(Time.now.utc)
+    end
+    
+    it "should log multiple events" do
+      lambda { state_machine.start && state_machine.stop && state_machine.start }.should change(MongoidTestModelStateTransition, :count).by(3)
+    end
+    
+    it "should do nothing when the transition is not exectuted successfully" do
+      lambda { state_machine.stop }.should_not change(MongoidTestModelStateTransition, :count)
+    end
+  end
+  
+  context 'on an object with multiple state machines' do
+    let!(:state_machine) { MongoidTestModelWithMultipleStateMachines.create! }
+    
+    it "should log a state transition for the affected state machine" do
+      lambda { state_machine.begin_first! }.should change(MongoidTestModelWithMultipleStateMachinesFirstTransition, :count).by(1)
+    end
+
+    it "should not log a state transition for the unaffected state machine" do
+      lambda { state_machine.begin_first! }.should_not change(MongoidTestModelWithMultipleStateMachinesSecondTransition, :count)
+    end
+  end
+  
+  context 'on an object with a state machine having an initial state' do
+    let(:state_machine_class) { MongoidTestModelWithMultipleStateMachines }
+    let(:state_transition_class) { MongoidTestModelWithMultipleStateMachinesFirstTransition }
+    
+    it "should log a state transition for the inital state" do
+      lambda { state_machine_class.create! }.should change(state_transition_class, :count).by(1)
+    end
+    
+    it "should only set the :to state for the initial transition" do
+      state_machine_class.create!
+      initial_transition = state_transition_class.last
+      initial_transition.event.should be_nil
+      initial_transition.from.should be_nil
+      initial_transition.to.should == 'beginning'
+      initial_transition.created_at.should be_within(10.seconds).of(Time.now.utc)
+    end
+  end
+  
+  context 'on an object with a state machine not having an initial state' do
+    let(:state_machine_class) { MongoidTestModelWithMultipleStateMachines }
+    let(:state_transition_class) { MongoidTestModelWithMultipleStateMachinesSecondTransition }
+    
+    it "should not log a transition when the object is created" do
+      lambda { state_machine_class.create! }.should_not change(state_transition_class, :count)
+    end
+
+    it "should log a transition for the first event" do
+      lambda { state_machine_class.create.begin_second! }.should change(state_transition_class, :count).by(1)
+    end
+
+    it "should not set a value for the :from state on the first transition" do
+      state_machine_class.create.begin_second!
+      first_transition = state_transition_class.last
+      first_transition.event.to_s.should == 'begin_second'
+      first_transition.from.should be_nil
+      first_transition.to.should == 'beginning_second'
+      first_transition.created_at.should be_within(10.seconds).of(Time.now.utc)
+    end
+  end
+
+  context 'on a class using STI' do
+    it "should properly grab the class name from STI models" do
+      m = MongoidTestModelDescendant.create!
+      lambda { m.start! }.should_not raise_error
+    end
+  end
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: jsmestad-audit_trail
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+platform: ruby
+authors:
+- Willem van Bergen
+- Jesse Storimer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: state_machine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Log transitions on a state machine to support auditing and business process
+  analytics.
+email:
+- willem@shopify.com
+- jesse@shopify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- jsmestad-audit_trail.gemspec
+- lib/state_machine-audit_trail.rb
+- lib/state_machine/audit_trail.rb
+- lib/state_machine/audit_trail/backend.rb
+- lib/state_machine/audit_trail/backend/active_record.rb
+- lib/state_machine/audit_trail/backend/mongoid.rb
+- lib/state_machine/audit_trail/railtie.rb
+- lib/state_machine/audit_trail/transition_auditing.rb
+- lib/state_machine/audit_trail/version.rb
+- lib/state_machine/audit_trail_generator.rb
+- spec/helpers/active_record.rb
+- spec/helpers/mongoid.rb
+- spec/spec_helper.rb
+- spec/state_machine/active_record_spec.rb
+- spec/state_machine/audit_trail_spec.rb
+- spec/state_machine/mongoid_spec.rb
+homepage: https://github.com/wvanbergen/state_machine-audit_trail
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Log transitions on a state machine to support auditing and business process
+  analytics.
+test_files:
+- spec/helpers/active_record.rb
+- spec/helpers/mongoid.rb
+- spec/spec_helper.rb
+- spec/state_machine/active_record_spec.rb
+- spec/state_machine/audit_trail_spec.rb
+- spec/state_machine/mongoid_spec.rb
+has_rdoc: