auditor 1.0.0 → 2.0.0

data/lib/auditor/user.rb

@@ -1,16 +1,15 @@
 module Auditor
   module User
+
     def current_user
-      Thread.current[@@current_user_symbol]
+      Thread.current[:auditor_user]
     end
 
     def current_user=(user)
-      Thread.current[@@current_user_symbol] = user
+      Thread.current[:auditor_user] = user
     end
-    
+
     module_function :current_user, :current_user=
 
-    private
-    @@current_user_symbol = :auditor_current_user
   end
-end
+end

data/lib/auditor/version.rb

@@ -1,3 +1,3 @@
 module Auditor
-  VERSION = "1.0.0"
-end
+  VERSION = "2.0.0"
+end

data/lib/generators/auditor/migration/migration_generator.rb

@@ -5,11 +5,11 @@ module Auditor
   module Generators
     class MigrationGenerator < Rails::Generators::Base
       include Rails::Generators::Migration
-  
+
       desc "Create migration for Auditor audits table"
-  
+
       source_root File.expand_path("../templates", __FILE__)
-  
+
       def self.next_migration_number(dirname)
         if ActiveRecord::Base.timestamped_migrations
           Time.now.utc.strftime("%Y%m%d%H%M%S")
@@ -23,4 +23,4 @@ module Auditor
       end
     end
   end
-end
+end

data/lib/generators/auditor/migration/templates/migration.rb

@@ -3,17 +3,21 @@ class CreateAuditsTable < ActiveRecord::Migration
     create_table :audits, :force => true do |t|
       t.column :auditable_id, :integer, :null => false
       t.column :auditable_type, :string, :null => false
-      t.column :auditable_version, :integer
       t.column :user_id, :integer, :null => false
       t.column :user_type, :string, :null => false
       t.column :action, :string, :null => false
-      t.column :message, :text
-      t.column :edits, :text
+      t.column :audited_changes, :text
+      t.column :version, :integer, :default => 0
+      t.column :comment, :text
       t.column :created_at, :datetime, :null => false
     end
+
+    add_index :audits, [:auditable_id, :auditable_type], :name => 'auditable_index'
+    add_index :audits, [:user_id, :user_type], :name => 'user_index'
+    add_index :audits, :created_at
   end
 
   def self.down
     drop_table :audits
   end
-end
+end

data/spec/audit_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'auditor/audit'
+
+describe Audit do
+  before(:each) do
+    @auditable = Model.create
+    @user = User.create
+  end
+
+  it 'should set the version number on save' do
+    audit = Audit.create(:auditable => @auditable, :user => @user, :action => :create)
+    audit.version.should == 1
+  end
+
+  it 'should provide access to the audited model object' do
+    audit = Audit.create(:auditable => @auditable, :user => @user, :action => :create)
+    audit.auditable.should == @auditable
+  end
+  it 'should provide access to the user associated with the audit' do
+    audit = Audit.create(:auditable => @auditable, :user => @user, :action => :create)
+    audit.user.should == @user
+  end
+
+  it 'should create a snapshot of the audited objects attributes at the time of the audit' do
+    audit1 = Audit.create(:auditable => @auditable, :user => @user, :action => :create)
+    audit2 = Audit.create(:auditable => @auditable, :user => @user, :action => :update, :audited_changes => {'name' => [nil, 'n1'], 'value' => [nil, 'v1']})
+    audit3 = Audit.create(:auditable => @auditable, :user => @user, :action => :find)
+    audit4 = Audit.create(:auditable => @auditable, :user => @user, :action => :update, :audited_changes => {'value' => [nil, 'v2']})
+
+    audit1.attribute_snapshot.should == {}
+    audit2.attribute_snapshot.should == {'name' => 'n1', 'value' => 'v1'}
+    audit3.attribute_snapshot.should == {'name' => 'n1', 'value' => 'v1'}
+    audit4.attribute_snapshot.should == {'name' => 'n1', 'value' => 'v2'}
+  end
+
+  describe 'modifying scope' do
+    it 'should return all audit records that were a result of modifying the audited object attributes' do
+      audit1 = Audit.create(:auditable => @auditable, :user => @user, :action => :create)
+      audit2 = Audit.create(:auditable => @auditable, :user => @user, :action => :update, :audited_changes => {'name' => [nil, 'n1'], 'value' => [nil, 'v1']})
+      audit3 = Audit.create(:auditable => @auditable, :user => @user, :action => :find)
+      audit4 = Audit.create(:auditable => @auditable, :user => @user, :action => :update, :audited_changes => {'value' => [nil, 'v2']})
+
+      Audit.modifying.should include(audit1, audit2, audit4)
+      Audit.modifying.should_not include(audit3)
+    end
+  end
+
+  describe 'predecessors scope' do
+    it 'should return all previous audit records for the same auditable' do
+      auditable2 = Model.create
+      audit1 = Audit.create(:auditable => @auditable, :user => @user, :action => :create)
+      audit2 = Audit.create(:auditable => @auditable, :user => @user, :action => :update, :audited_changes => {'name' => [nil, 'n1'], 'value' => [nil, 'v1']})
+      audit3 = Audit.create(:auditable => auditable2, :user => @user, :action => :find)
+      audit4 = Audit.create(:auditable => @auditable, :user => @user, :action => :update, :audited_changes => {'value' => [nil, 'v2']})
+
+      Audit.trail(audit4).should include(audit1, audit2, audit4)
+      Audit.trail(audit4).should_not include(audit3)
+    end
+  end
+end
+
+class Model < ActiveRecord::Base; end
+class User < ActiveRecord::Base; end

data/spec/auditable_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'auditor/user'
+require 'auditor/status'
+
+describe Auditor::Auditable do
+  include Auditor::Status
+
+  before(:each) do
+    @user = User.create
+    Auditor::User.current_user = @user
+  end
+
+  it 'should audit find' do
+    redefine_model { audit!(:find) }
+    m = without_auditing { Model.create }
+
+    Model.find(m.id)
+
+    verify_audit(Audit.last, m)
+  end
+
+  it 'should audit create' do
+    redefine_model { audit!(:create) }
+
+    m = Model.create(:name => 'new')
+
+    verify_audit(Audit.last, m, { 'name' => [nil, 'new'], 'id' => [nil, m.id] })
+  end
+
+  it 'should audit update' do
+    redefine_model { audit!(:update) }
+    m = without_auditing { Model.create(:name => 'new') }
+
+    m.update_attributes(:name => 'newer')
+
+    verify_audit(Audit.last, m, { 'name' => ['new', 'newer'] })
+  end
+
+  it 'should audit destroy' do
+    redefine_model { audit!(:destroy) }
+    m = without_auditing { Model.create }
+
+    m.destroy
+
+    verify_audit(Audit.last, m)
+  end
+
+  it 'should allow multiple actions to be specified with one audit statment' do
+    redefine_model { audit!(:create, :destroy) }
+
+    m = Model.create
+    m.reload
+    m = Model.find(m.id)
+    m.update_attributes({:name => 'new'})
+    m.destroy
+
+    Audit.count.should == 2
+  end
+
+  it 'should record the comment returned from a comment block' do
+    redefine_model { audit!(:create) { 'comment' } }
+    Model.create
+    Audit.last.comment.should == 'comment'
+  end
+
+  it 'should provide the model object and user as parameters to the comment block' do
+    id = without_auditing { Model.create }.id
+    user = @user
+    redefine_model {
+      audit!(:find) { |model, user|
+        model.id.should == id
+        user.should == user
+      }
+    }
+    Model.find(id)
+  end
+
+  it 'should provide a snapshot of the object attributes at a given date or time' do
+    redefine_model { audit!(:create, :find, :update, :destroy) }
+    m = Model.create(:name => '1')
+    ts1 = Time.now
+    m = Model.find(m.id)
+    ts2 = Time.now
+    m.update_attributes(:name => '2')
+    ts3 = Time.now
+    m.destroy
+    ts4 = Time.now
+
+    m.attributes_at(ts1).should == {'name' => '1', 'id' => m.id}
+    m.attributes_at(ts2).should == {'name' => '1', 'id' => m.id}
+    m.attributes_at(ts3).should == {'name' => '2', 'id' => m.id}
+    m.attributes_at(ts4).should == {'name' => '2', 'id' => m.id}
+  end
+
+  def verify_audit(audit, model, changes=nil)
+    audit.should_not be_nil
+    audit.auditable.should == model unless audit.action == 'destroy'
+    audit.user.should == @user
+    audit.audited_changes.should == changes unless changes.nil?
+  end
+
+  def redefine_model(&blk)
+    clazz = Class.new(ActiveRecord::Base, &blk)
+    Object.send :remove_const, 'Model'
+    Object.send :const_set, 'Model', clazz
+  end
+
+  class ::User < ActiveRecord::Base; end
+  class ::Model < ActiveRecord::Base; end
+
+end

data/spec/config_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'auditor/config'
+
+describe Auditor::Config do
+  
+  describe 'Configuration' do
+    it "should parse actions and options from a config array" do
+      config = Auditor::Config.new(:create, 'update', {:only => :username})
+      config.actions.should_not be_nil
+      config.options.should_not be_nil
+      config.actions.should have(2).items
+      config.actions.should =~ [:create, :update]
+      config.options.should == {:only => ["username"], :except => []}
+    end
+
+    it "should parse actions and options from a config array when options are absent" do
+      config = Auditor::Config.new(:create, 'update')
+      config.actions.should_not be_nil
+      config.actions.should have(2).items
+      config.actions.should =~ [:create, :update]
+      config.options.should == {:only => [], :except => []}
+    end
+
+    it "should parse actions" do
+      config = Auditor::Config.new(:create)
+      config.actions.should_not be_nil
+      config.actions.should have(1).item
+      config.actions.should =~ [:create]
+      config.options.should == {:only => [], :except => []}
+    end
+
+  end
+
+  describe 'Configuration Validation' do
+    it "should raise a Auditor::Error if no action is specified" do
+      lambda {
+        Auditor::Config.new
+      }.should raise_error(Auditor::Error)
+    end
+
+    it "should raise a Auditor::Error if an invalid action is specified" do
+      lambda {
+        Auditor::Config.new(:create, :view)
+      }.should raise_error(Auditor::Error)
+    end
+
+  end
+
+end

data/spec/recorder_spec.rb

@@ -1,120 +1,86 @@
 require File.dirname(__FILE__) + '/spec_helper'
-require 'auditor'
+require 'auditor/user'
 
-describe Auditor::Recorder do  
+describe Auditor::Recorder do
   before(:each) do
-    @user = Auditor::User.current_user = new_model(7)
+    @user = Auditor::User.current_user = User.create
   end
-  
-  it 'should create and save a new audit record' do
-    model = new_model(42, {'first_name' => ['old','new']})
-    
-    auditor = Auditor::Recorder.new(:create, model, {:except => [], :only => []})  { |m, u| "Model: #{m.id} User: #{u.id}" }
-    
-    audit = do_callbacks(auditor, model)
-    
-    audit.saved.should be_true
-    audit.action.should == 'create'
-    audit.edits.to_a.should =~ [['first_name', ['old', 'new']]]
-    audit.auditable_id.should == 42
+
+  it 'should create an audit record for create actions' do
+    verify_action(:create)
+  end
+
+  it 'should create an audit record for find actions' do
+    verify_action(:find)
+  end
+
+  it 'should create an audit record for update actions' do
+    verify_action(:update)
+  end
+
+  it 'should create an audit record for destroy actions' do
+    verify_action(:destroy)
+  end
+
+  def verify_action(action)
+    model = Model.create
+    model.reload
+    model.name = 'changed'
+    config = Auditor::Config.new(action)
+
+    recorder = Auditor::Recorder.new(config.options) { 'comment' }
+    recorder.send "after_#{action}", model
+    audit = Audit.last
+
+    audit.action.should == action.to_s
+    audit.auditable_id.should == model.id
     audit.auditable_type.should == model.class.to_s
     audit.user_id.should == @user.id
     audit.user_type.should == @user.class.to_s
-    audit.auditable_version.should be_nil
-    audit.message.should == 'Model: 42 User: 7'
-  end
-  
-  it 'should capture the new id of a created record' do
-    model = new_model
-    
-    auditor = Auditor::Recorder.new(:create, model, {:except => [], :only => []})
-    
-    audit = do_callbacks(auditor, model)
-    
-    audit.saved.should be_true
-    audit.auditable_id.should == 42
-    audit.auditable_type.should == model.class.to_s
+    audit.comment.should == 'comment'
+    audit.audited_changes.should == {'name' => [nil, 'changed'] } if [:create, :update].include?(action)
+
+    audit.user.should == @user
+    audit.auditable.should == model
   end
-  
-  it 'should set message details to nil if they are not given' do
-    model = new_model
-    auditor = Auditor::Recorder.new(:create, model, {:except => [], :only => []})
-    
-    audit = do_callbacks(auditor, model)
-    
-    audit.saved.should be_true
-    audit.message.should be_nil
+
+  it 'should set comment details to nil if they are not given' do
+    model = Model.create
+    config = Auditor::Config.new(:create)
+
+    recorder = Auditor::Recorder.new(config.options)
+    recorder.after_create(model)
+    audit = Audit.last
+
+    audit.comment.should be_nil
   end
-  
+
   it 'should not save change details for excepted attributes' do
-    model = new_model(42, {'first_name' => ['old','new'], 'last_name' => ['old','new']})
-    
-    auditor = Auditor::Recorder.new(:create, model, {:except => ['last_name'], :only => []})
-    
-    audit = do_callbacks(auditor, model)
-    
-    audit.saved.should be_true
-    audit.edits.to_a.should =~ [['first_name', ['old', 'new']]]    
+    model = Model.create
+    model.name = 'changed'
+    model.value = 'newval'
+    config = Auditor::Config.new(:create, :except => :name)
+
+    recorder = Auditor::Recorder.new(config.options)
+    recorder.after_create(model)
+    audit = Audit.last
+
+    audit.audited_changes.should == {'value' => [nil, 'newval'] }
   end
-  
+
   it 'should only save change details for onlyed attributes' do
-    model = new_model(42, {'first_name' => ['old','new'], 'last_name' => ['old','new']})
-    
-    auditor = Auditor::Recorder.new(:create, model, {:except => [], :only => ['last_name']})
-    
-    audit = do_callbacks(auditor, model)
-    
-    audit.saved.should be_true
-    audit.edits.to_a.should =~ [['last_name', ['old', 'new']]]    
-  end
-  
-  it 'should not save attributes listed in both the only and except options' do
-    model = new_model(42, {'first_name' => ['old','new'], 'last_name' => ['old','new']})
-    
-    auditor = Auditor::Recorder.new(:create, model, {:except => ['last_name'], :only => ['last_name']})
-    
-    audit = do_callbacks(auditor, model)
-    
-    audit.saved.should be_true
-    audit.edits.should be_nil
-  end
-  
-  def do_callbacks(auditor, model)
-    auditor.audit_before
-    audit = auditor.instance_variable_get(:@audit)
-    audit.saved.should be_false
-
-    model.changes = nil
-    model.id = 42 if model.id.nil?    
-    
-    auditor.audit_after
-    auditor.instance_variable_get(:@audit)
-  end
-  
-  def new_model(id = nil, changes = {})
-    model = (Class.new do; attr_accessor :id, :changes; end).new
-    model.id, model.changes = id, changes
-    model
-  end
-  
-  class Audit
-    attr_accessor :edits, :saved
-    attr_accessor :action, :auditable_id, :auditable_type, :user_id, :user_type, :auditable_version, :message
-    
-    def initialize(attrs={})
-      @edits = attrs.delete(:edits)      
-      @saved = false
-      raise "You can only set the edits field in this class" unless attrs.empty?
-    end
-    
-    def attributes=(attrs={})
-      attrs.each_pair do |key, val|
-        self.send("#{key}=".to_sym, val)
-      end
-    end
-    
-    def save
-      @saved = true
-    end
+    model = Model.create
+    model.name = 'changed'
+    model.value = 'newval'
+    config = Auditor::Config.new(:create, :only => :name)
+
+    recorder = Auditor::Recorder.new(config.options)
+    recorder.after_create(model)
+    audit = Audit.last
+
+    audit.audited_changes.should == {'name' => [nil, 'changed'] }
   end
-end
+
+  class Model < ActiveRecord::Base; end
+  class User < ActiveRecord::Base; end
+end