audited 4.5.0 → 4.10.0

data/lib/audited/rspec_matchers.rb

@@ -41,12 +41,12 @@ module Audited
       end
 
       def only(*fields)
-        @options[:only] = fields.flatten
+        @options[:only] = fields.flatten.map(&:to_s)
         self
       end
 
       def except(*fields)
-        @options[:except] = fields.flatten
+        @options[:except] = fields.flatten.map(&:to_s)
         self
       end
 
@@ -56,16 +56,13 @@ module Audited
       end
 
       def on(*actions)
-        @options[:on] = actions.flatten
+        @options[:on] = actions.flatten.map(&:to_sym)
         self
       end
 
       def matches?(subject)
         @subject = subject
-        auditing_enabled? &&
-          associated_with_model? &&
-          records_changes_to_specified_fields? &&
-          comment_required_valid?
+        auditing_enabled? && required_checks_for_options_satisfied?
       end
 
       def failure_message
@@ -109,31 +106,83 @@ module Audited
       end
 
       def records_changes_to_specified_fields?
-        if @options[:only] || @options[:except]
-          if @options[:only]
-            except = model_class.column_names - @options[:only].map(&:to_s)
-          else
-            except = model_class.default_ignored_attributes + Audited.ignored_attributes
-            except |= @options[:except].collect(&:to_s) if @options[:except]
-          end
+        ignored_fields = build_ignored_fields_from_options
+
+        expects "non audited columns (#{model_class.non_audited_columns.inspect}) to match (#{ignored_fields})"
+        model_class.non_audited_columns.to_set == ignored_fields.to_set
+      end
+
+      def comment_required_valid?
+        expects "to require audit_comment before #{model_class.audited_options[:on]} when comment required"
+        validate_callbacks_include_presence_of_comment? && destroy_callbacks_include_comment_required?
+      end
 
-          expects "non audited columns (#{model_class.non_audited_columns.inspect}) to match (#{expect})"
-          model_class.non_audited_columns =~ except
+      def only_audit_on_designated_callbacks?
+        {
+          create: [:after, :audit_create],
+          update: [:before, :audit_update],
+          destroy: [:before, :audit_destroy]
+        }.map do |(action, kind_callback)|
+          kind, callback = kind_callback
+          callbacks_for(action, kind: kind).include?(callback) if @options[:on].include?(action)
+        end.compact.all?
+      end
+
+      def validate_callbacks_include_presence_of_comment?
+        if @options[:comment_required] && audited_on_create_or_update?
+          callbacks_for(:validate).include?(:presence_of_audit_comment)
         else
           true
         end
       end
 
-      def comment_required_valid?
-        if @options[:comment_required]
-          @subject.audit_comment = nil
+      def audited_on_create_or_update?
+        model_class.audited_options[:on].include?(:create) || model_class.audited_options[:on].include?(:update)
+      end
 
-          expects "to be invalid when audit_comment is not specified"
-          @subject.valid? == false && @subject.errors.key?(:audit_comment)
+      def destroy_callbacks_include_comment_required?
+        if @options[:comment_required] && model_class.audited_options[:on].include?(:destroy)
+          callbacks_for(:destroy).include?(:require_comment)
         else
           true
         end
       end
+
+      def requires_comment_before_callbacks?
+        [:create, :update, :destroy].map do |action|
+          if @options[:comment_required] && model_class.audited_options[:on].include?(action)
+            callbacks_for(action).include?(:require_comment)
+          end
+        end.compact.all?
+      end
+
+      def callbacks_for(action, kind: :before)
+        model_class.send("_#{action}_callbacks").select { |cb| cb.kind == kind }.map(&:filter)
+      end
+
+      def build_ignored_fields_from_options
+        default_ignored_attributes = model_class.default_ignored_attributes
+
+        if @options[:only].present?
+          (default_ignored_attributes | model_class.column_names) - @options[:only]
+        elsif @options[:except].present?
+          default_ignored_attributes | @options[:except]
+        else
+          default_ignored_attributes
+        end
+      end
+
+      def required_checks_for_options_satisfied?
+        {
+          only: :records_changes_to_specified_fields?,
+          except: :records_changes_to_specified_fields?,
+          comment_required: :comment_required_valid?,
+          associated_with: :associated_with_model?,
+          on: :only_audit_on_designated_callbacks?
+        }.map do |(option, check)|
+          send(check) if @options[option].present?
+        end.compact.all?
+      end
     end
 
     class AssociatedAuditMatcher # :nodoc:

data/lib/audited/version.rb

@@ -1,3 +1,3 @@
 module Audited
-  VERSION = "4.5.0"
+  VERSION = "4.10.0"
 end

data/lib/generators/audited/templates/add_version_to_auditable_index.rb

@@ -0,0 +1,21 @@
+class <%= migration_class_name %> < <%= migration_parent %>
+  def self.up
+    if index_exists?(:audits, [:auditable_type, :auditable_id], name: index_name)
+      remove_index :audits, name: index_name
+      add_index :audits, [:auditable_type, :auditable_id, :version], name: index_name
+    end
+  end
+
+  def self.down
+    if index_exists?(:audits, [:auditable_type, :auditable_id, :version], name: index_name)
+      remove_index :audits, name: index_name
+      add_index :audits, [:auditable_type, :auditable_id], name: index_name
+    end
+  end
+
+  private
+
+  def index_name
+    'auditable_index'
+  end
+end

data/lib/generators/audited/templates/install.rb

@@ -17,8 +17,8 @@ class <%= migration_class_name %> < <%= migration_parent %>
       t.column :created_at, :datetime
     end
 
-    add_index :audits, [:auditable_id, :auditable_type], :name => 'auditable_index'
-    add_index :audits, [:associated_id, :associated_type], :name => 'associated_index'
+    add_index :audits, [:auditable_type, :auditable_id, :version], :name => 'auditable_index'
+    add_index :audits, [:associated_type, :associated_id], :name => 'associated_index'
     add_index :audits, [:user_id, :user_type], :name => 'user_index'
     add_index :audits, :request_uuid
     add_index :audits, :created_at

data/lib/generators/audited/templates/revert_polymorphic_indexes_order.rb

@@ -0,0 +1,20 @@
+class <%= migration_class_name %> < <%= migration_parent %>
+  def self.up
+    fix_index_order_for [:associated_id, :associated_type], 'associated_index'
+    fix_index_order_for [:auditable_id, :auditable_type], 'auditable_index'
+  end
+
+  def self.down
+    fix_index_order_for [:associated_type, :associated_id], 'associated_index'
+    fix_index_order_for [:auditable_type, :auditable_id], 'auditable_index'
+  end
+
+  private
+
+  def fix_index_order_for(columns, index_name)
+    if index_exists? :audits, columns, name: index_name
+      remove_index :audits, name: index_name
+      add_index :audits, columns.reverse, name: index_name
+    end
+  end
+end

data/lib/generators/audited/upgrade_generator.rb

@@ -25,6 +25,7 @@ module Audited
       def migrations_to_be_applied
         Audited::Audit.reset_column_information
         columns = Audited::Audit.columns.map(&:name)
+        indexes = Audited::Audit.connection.indexes(Audited::Audit.table_name)
 
         yield :add_comment_to_audits unless columns.include?('comment')
 
@@ -53,6 +54,14 @@ module Audited
         if columns.include?('association_id')
           yield :rename_association_to_associated
         end
+
+        if indexes.any? { |i| i.columns == %w[associated_id associated_type] }
+          yield :revert_polymorphic_indexes_order
+        end
+
+        if indexes.any? { |i| i.columns == %w[auditable_type auditable_id] }
+          yield :add_version_to_auditable_index
+        end
       end
     end
   end

data/spec/audited/audit_spec.rb

@@ -1,5 +1,7 @@
 require "spec_helper"
 
+SingleCov.covered! uncovered: 1 # Rails version check
+
 describe Audited::Audit do
   let(:user) { Models::ActiveRecord::User.new name: "Testing" }
 
@@ -51,8 +53,51 @@ describe Audited::Audit do
     end
   end
 
-  describe "user=" do
+  describe "#audited_changes" do
+    let(:audit) { Audited.audit_class.new }
+
+    it "can unserialize yaml from text columns" do
+      audit.audited_changes = {foo: "bar"}
+      expect(audit.audited_changes).to eq foo: "bar"
+    end
 
+    it "does not unserialize from binary columns" do
+      allow(Audited::YAMLIfTextColumnType).to receive(:text_column?).and_return(false)
+      audit.audited_changes = {foo: "bar"}
+      expect(audit.audited_changes).to eq "{:foo=>\"bar\"}"
+    end
+  end
+
+  describe "#undo" do
+    let(:user) { Models::ActiveRecord::User.create(name: "John") }
+
+    it "undos changes" do
+      user.update_attribute(:name, 'Joe')
+      user.audits.last.undo
+      user.reload
+      expect(user.name).to eq("John")
+    end
+
+    it "undos destroy" do
+      user.destroy
+      user.audits.last.undo
+      user = Models::ActiveRecord::User.find_by(name: "John")
+      expect(user.name).to eq("John")
+    end
+
+    it "undos creation" do
+      user # trigger create
+      expect {user.audits.last.undo}.to change(Models::ActiveRecord::User, :count).by(-1)
+    end
+
+    it "fails when trying to undo unknown" do
+      audit = user.audits.last
+      audit.action = 'oops'
+      expect { audit.undo }.to raise_error("invalid action given oops")
+    end
+  end
+
+  describe "user=" do
     it "should be able to set the user to a model object" do
       subject.user = user
       expect(subject.user).to eq(user)
@@ -88,11 +133,9 @@ describe Audited::Audit do
       subject.user = user
       expect(subject.username).to be_nil
     end
-
   end
 
   describe "revision" do
-
     it "should recreate attributes" do
       user = Models::ActiveRecord::User.create name: "1"
       5.times {|i| user.update_attribute :name, (i + 2).to_s }
@@ -126,6 +169,34 @@ describe Audited::Audit do
     end
   end
 
+  describe ".collection_cache_key" do
+    if ActiveRecord::VERSION::MAJOR >= 5
+      it "uses created at" do
+        Audited::Audit.delete_all
+        audit = Models::ActiveRecord::User.create(name: "John").audits.last
+        audit.update_columns(created_at: Time.zone.parse('2018-01-01'))
+        expect(Audited::Audit.collection_cache_key).to match(/-20180101\d+$/)
+      end
+    else
+      it "is not defined" do
+        expect { Audited::Audit.collection_cache_key }.to raise_error(NoMethodError)
+      end
+    end
+  end
+
+  describe ".assign_revision_attributes" do
+    it "dups when frozen" do
+      user.freeze
+      assigned = Audited::Audit.assign_revision_attributes(user, name: "Bar")
+      expect(assigned.name).to eq "Bar"
+    end
+
+    it "ignores unassignable attributes" do
+      assigned = Audited::Audit.assign_revision_attributes(user, oops: "Bar")
+      expect(assigned.name).to eq "Testing"
+    end
+  end
+
   it "should set the version number on create" do
     user = Models::ActiveRecord::User.create! name: "Set Version Number"
     expect(user.audits.first.version).to eq(1)
@@ -191,6 +262,25 @@ describe Audited::Audit do
       end
     end
 
+    it "should support nested as_user" do
+      Audited::Audit.as_user("sidekiq") do
+        company = Models::ActiveRecord::Company.create name: "The auditors"
+        company.name = "The Auditors, Inc"
+        company.save
+        expect(company.audits[-1].user).to eq("sidekiq")
+
+        Audited::Audit.as_user(user) do
+          company.name = "NEW Auditors, Inc"
+          company.save
+          expect(company.audits[-1].user).to eq(user)
+        end
+
+        company.name = "LAST Auditors, Inc"
+        company.save
+        expect(company.audits[-1].user).to eq("sidekiq")
+      end
+    end
+
     it "should record usernames" do
       Audited::Audit.as_user(user.name) do
         company = Models::ActiveRecord::Company.create name: "The auditors"
@@ -241,6 +331,5 @@ describe Audited::Audit do
       }.to raise_exception('expected')
       expect(Audited.store[:audited_user]).to be_nil
     end
-
   end
 end

data/spec/audited/auditor_spec.rb

@@ -1,5 +1,7 @@
 require "spec_helper"
 
+SingleCov.covered! uncovered: 13 # not testing proxy_respond_to? hack / 2 methods / deprecation of `version`
+
 describe Audited::Auditor do
 
   describe "configuration" do
@@ -17,6 +19,132 @@ describe Audited::Auditor do
       end
     end
 
+    context "should be configurable which conditions are audited" do
+      subject { ConditionalCompany.new.send(:auditing_enabled) }
+
+      context "when condition method is private" do
+        subject { ConditionalPrivateCompany.new.send(:auditing_enabled) }
+
+        before do
+          class ConditionalPrivateCompany < ::ActiveRecord::Base
+            self.table_name = 'companies'
+
+            audited if: :foo?
+
+            private def foo?
+              true
+            end
+          end
+        end
+
+        it { is_expected.to be_truthy }
+      end
+
+      context "when passing a method name" do
+        before do
+          class ConditionalCompany < ::ActiveRecord::Base
+            self.table_name = 'companies'
+
+            audited if: :public?
+
+            def public?; end
+          end
+        end
+
+        context "when conditions are true" do
+          before { allow_any_instance_of(ConditionalCompany).to receive(:public?).and_return(true) }
+          it     { is_expected.to be_truthy }
+        end
+
+        context "when conditions are false" do
+          before { allow_any_instance_of(ConditionalCompany).to receive(:public?).and_return(false) }
+          it     { is_expected.to be_falsey }
+        end
+      end
+
+      context "when passing a Proc" do
+        context "when conditions are true" do
+          before do
+            class InclusiveCompany < ::ActiveRecord::Base
+              self.table_name = 'companies'
+              audited if: Proc.new { true }
+            end
+          end
+
+          subject { InclusiveCompany.new.send(:auditing_enabled) }
+
+          it { is_expected.to be_truthy }
+        end
+
+        context "when conditions are false" do
+          before do
+            class ExclusiveCompany < ::ActiveRecord::Base
+              self.table_name = 'companies'
+              audited if: Proc.new { false }
+            end
+          end
+          subject { ExclusiveCompany.new.send(:auditing_enabled) }
+          it { is_expected.to be_falsey }
+        end
+      end
+    end
+
+    context "should be configurable which conditions aren't audited" do
+      context "when using a method name" do
+        before do
+          class ExclusionaryCompany < ::ActiveRecord::Base
+            self.table_name = 'companies'
+
+            audited unless: :non_profit?
+
+            def non_profit?; end
+          end
+        end
+
+        subject { ExclusionaryCompany.new.send(:auditing_enabled) }
+
+        context "when conditions are true" do
+          before { allow_any_instance_of(ExclusionaryCompany).to receive(:non_profit?).and_return(true) }
+          it     { is_expected.to be_falsey }
+        end
+
+        context "when conditions are false" do
+          before { allow_any_instance_of(ExclusionaryCompany).to receive(:non_profit?).and_return(false) }
+          it     { is_expected.to be_truthy }
+        end
+      end
+
+      context "when using a proc" do
+        context "when conditions are true" do
+          before do
+            class ExclusionaryCompany < ::ActiveRecord::Base
+              self.table_name = 'companies'
+              audited unless: Proc.new { |c| c.exclusive? }
+
+              def exclusive?
+                true
+              end
+            end
+          end
+
+          subject { ExclusionaryCompany.new.send(:auditing_enabled) }
+          it      { is_expected.to be_falsey }
+        end
+
+        context "when conditions are false" do
+          before do
+            class InclusiveCompany < ::ActiveRecord::Base
+              self.table_name = 'companies'
+              audited unless: Proc.new { false }
+            end
+          end
+
+          subject { InclusiveCompany.new.send(:auditing_enabled) }
+          it      { is_expected.to be_truthy }
+        end
+      end
+    end
+
     it "should be configurable which attributes are not audited via ignored_attributes" do
       Audited.ignored_attributes = ['delta', 'top_secret', 'created_at']
       class Secret < ::ActiveRecord::Base
@@ -36,9 +164,14 @@ describe Audited::Auditor do
     end
 
     it "should not save non-audited columns" do
-      Models::ActiveRecord::User.non_audited_columns = (Models::ActiveRecord::User.non_audited_columns << :favourite_device)
+      previous = Models::ActiveRecord::User.non_audited_columns
+      begin
+        Models::ActiveRecord::User.non_audited_columns += [:favourite_device]
 
-      expect(create_user.audits.first.audited_changes.keys.any? { |col| ['favourite_device', 'created_at', 'updated_at', 'password'].include?( col ) }).to eq(false)
+        expect(create_user.audits.first.audited_changes.keys.any? { |col| ['favourite_device', 'created_at', 'updated_at', 'password'].include?( col ) }).to eq(false)
+      ensure
+        Models::ActiveRecord::User.non_audited_columns = previous
+      end
     end
 
     it "should not save other columns than specified in 'only' option" do
@@ -60,16 +193,68 @@ describe Audited::Auditor do
       expect(user.audits.last.audited_changes.keys).to eq(%w{password})
     end
 
-    if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' && Rails.version >= "4.2.0.0" # Postgres json and jsonb support was added in Rails 4.2
+    it "should save attributes not specified in 'except' option" do
+      user = Models::ActiveRecord::User.create
+      user.instance_eval do
+        def non_column_attr
+          @non_column_attr
+        end
+
+        def non_column_attr=(val)
+          attribute_will_change!("non_column_attr")
+          @non_column_attr = val
+        end
+      end
+
+      user.password = "password"
+      user.non_column_attr = "some value"
+      user.save!
+      expect(user.audits.last.audited_changes.keys).to eq(%w{non_column_attr})
+    end
+
+    it "should redact columns specified in 'redacted' option" do
+      redacted = Audited::Auditor::AuditedInstanceMethods::REDACTED
+      user = Models::ActiveRecord::UserRedactedPassword.create(password: "password")
+      user.save!
+      expect(user.audits.last.audited_changes['password']).to eq(redacted)
+      user.password = "new_password"
+      user.save!
+      expect(user.audits.last.audited_changes['password']).to eq([redacted, redacted])
+    end
+
+    it "should redact columns specified in 'redacted' option when there are multiple specified" do
+      redacted = Audited::Auditor::AuditedInstanceMethods::REDACTED
+      user =
+        Models::ActiveRecord::UserMultipleRedactedAttributes.create(
+          password: "password",
+          ssn: 123456789
+        )
+      user.save!
+      expect(user.audits.last.audited_changes['password']).to eq(redacted)
+      expect(user.audits.last.audited_changes['ssn']).to eq(redacted)
+      user.password = "new_password"
+      user.ssn = 987654321
+      user.save!
+      expect(user.audits.last.audited_changes['password']).to eq([redacted, redacted])
+      expect(user.audits.last.audited_changes['ssn']).to eq([redacted, redacted])
+    end
+
+    it "should redact columns in 'redacted' column with custom option" do
+      user = Models::ActiveRecord::UserRedactedPasswordCustomRedaction.create(password: "password")
+      user.save!
+      expect(user.audits.last.audited_changes['password']).to eq(["My", "Custom", "Value", 7])
+    end
+
+    if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       describe "'json' and 'jsonb' audited_changes column type" do
         let(:migrations_path) { SPEC_ROOT.join("support/active_record/postgres") }
 
         after do
-          ActiveRecord::Migrator.rollback([migrations_path])
+          run_migrations(:down, migrations_path)
         end
 
         it "should work if column type is 'json'" do
-          ActiveRecord::Migrator.up([migrations_path], 1)
+          run_migrations(:up, migrations_path, 1)
           Audited::Audit.reset_column_information
           expect(Audited::Audit.columns_hash["audited_changes"].sql_type).to eq("json")
 
@@ -80,7 +265,7 @@ describe Audited::Auditor do
         end
 
         it "should work if column type is 'jsonb'" do
-          ActiveRecord::Migrator.up([migrations_path], 2)
+          run_migrations(:up, migrations_path, 2)
           Audited::Audit.reset_column_information
           expect(Audited::Audit.columns_hash["audited_changes"].sql_type).to eq("jsonb")
 
@@ -114,7 +299,7 @@ describe Audited::Auditor do
   end
 
   describe "on create" do
-    let( :user ) { create_user audit_comment: "Create" }
+    let( :user ) { create_user status: :reliable, audit_comment: "Create" }
 
     it "should change the audit count" do
       expect {
@@ -138,6 +323,10 @@ describe Audited::Auditor do
       expect(user.audits.first.audited_changes).to eq(user.audited_attributes)
     end
 
+    it "should store enum value" do
+      expect(user.audits.first.audited_changes["status"]).to eq(1)
+    end
+
     it "should store comment" do
       expect(user.audits.first.comment).to eq('Create')
     end
@@ -156,7 +345,7 @@ describe Audited::Auditor do
 
   describe "on update" do
     before do
-      @user = create_user( name: 'Brandon', audit_comment: 'Update' )
+      @user = create_user( name: 'Brandon', status: :active, audit_comment: 'Update' )
     end
 
     it "should save an audit" do
@@ -169,17 +358,22 @@ describe Audited::Auditor do
     end
 
     it "should set the action to 'update'" do
-      @user.update_attributes name: 'Changed'
+      @user.update! name: 'Changed'
       expect(@user.audits.last.action).to eq('update')
       expect(Audited::Audit.updates.order(:id).last).to eq(@user.audits.last)
       expect(@user.audits.updates.last).to eq(@user.audits.last)
     end
 
     it "should store the changed attributes" do
-      @user.update_attributes name: 'Changed'
+      @user.update! name: 'Changed'
       expect(@user.audits.last.audited_changes).to eq({ 'name' => ['Brandon', 'Changed'] })
     end
 
+    it "should store changed enum values" do
+      @user.update! status: 1
+      expect(@user.audits.last.audited_changes["status"]).to eq([0, 1])
+    end
+
     it "should store audit comment" do
       expect(@user.audits.last.comment).to eq('Update')
     end
@@ -187,12 +381,12 @@ describe Audited::Auditor do
     it "should not save an audit if only specified on create/destroy" do
       on_create_destroy = Models::ActiveRecord::OnCreateDestroy.create( name: 'Bart' )
       expect {
-        on_create_destroy.update_attributes name: 'Changed'
+        on_create_destroy.update! name: 'Changed'
       }.to_not change( Audited::Audit, :count )
     end
 
     it "should not save an audit if the value doesn't change after type casting" do
-      @user.update_attributes! logins: 0, activated: true
+      @user.update! logins: 0, activated: true
       expect { @user.update_attribute :logins, '0' }.to_not change( Audited::Audit, :count )
       expect { @user.update_attribute :activated, 1 }.to_not change( Audited::Audit, :count )
       expect { @user.update_attribute :activated, '1' }.to_not change( Audited::Audit, :count )
@@ -216,7 +410,7 @@ describe Audited::Auditor do
 
   describe "on destroy" do
     before do
-      @user = create_user
+      @user = create_user(status: :active)
     end
 
     it "should save an audit" do
@@ -241,6 +435,11 @@ describe Audited::Auditor do
       expect(@user.audits.last.audited_changes).to eq(@user.audited_attributes)
     end
 
+    it "should store enum value" do
+      @user.destroy
+      expect(@user.audits.last.audited_changes["status"]).to eq(0)
+    end
+
     it "should be able to reconstruct a destroyed record without history" do
       @user.audits.delete_all
       @user.destroy
@@ -310,6 +509,77 @@ describe Audited::Auditor do
     end
   end
 
+  describe "max_audits" do
+    it "should respect global setting" do
+      stub_global_max_audits(10) do
+        expect(Models::ActiveRecord::User.audited_options[:max_audits]).to eq(10)
+      end
+    end
+
+    it "should respect per model setting" do
+      stub_global_max_audits(10) do
+        expect(Models::ActiveRecord::MaxAuditsUser.audited_options[:max_audits]).to eq(5)
+      end
+    end
+
+    it "should delete old audits when keeped amount exceeded" do
+      stub_global_max_audits(2) do
+        user = create_versions(2)
+        user.update(name: 'John')
+        expect(user.audits.pluck(:version)).to eq([2, 3])
+      end
+    end
+
+    it "should not delete old audits when keeped amount not exceeded" do
+      stub_global_max_audits(3) do
+        user = create_versions(2)
+        user.update(name: 'John')
+        expect(user.audits.pluck(:version)).to eq([1, 2, 3])
+      end
+    end
+
+    it "should delete old extra audits after introducing limit" do
+      stub_global_max_audits(nil) do
+        user = Models::ActiveRecord::User.create!(name: 'Brandon', username: 'brandon')
+        user.update!(name: 'Foobar')
+        user.update!(name: 'Awesome', username: 'keepers')
+        user.update!(activated: true)
+
+        Audited.max_audits = 3
+        Models::ActiveRecord::User.send(:normalize_audited_options)
+        user.update!(favourite_device: 'Android Phone')
+        audits = user.audits
+
+        expect(audits.count).to eq(3)
+        expect(audits[0].audited_changes).to include({'name' => ['Foobar', 'Awesome'], 'username' => ['brandon', 'keepers']})
+        expect(audits[1].audited_changes).to eq({'activated' => [nil, true]})
+        expect(audits[2].audited_changes).to eq({'favourite_device' => [nil, 'Android Phone']})
+      end
+    end
+
+    it "should add comment line for combined audit" do
+      stub_global_max_audits(2) do
+        user = Models::ActiveRecord::User.create!(name: 'Foobar 1')
+        user.update(name: 'Foobar 2', audit_comment: 'First audit comment')
+        user.update(name: 'Foobar 3', audit_comment: 'Second audit comment')
+        expect(user.audits.first.comment).to match(/First audit comment.+is the result of multiple/m)
+      end
+    end
+
+    def stub_global_max_audits(max_audits)
+      previous_max_audits = Audited.max_audits
+      previous_user_audited_options = Models::ActiveRecord::User.audited_options.dup
+      begin
+        Audited.max_audits = max_audits
+        Models::ActiveRecord::User.send(:normalize_audited_options) # reloads audited_options
+        yield
+      ensure
+        Audited.max_audits = previous_max_audits
+        Models::ActiveRecord::User.audited_options = previous_user_audited_options
+      end
+    end
+  end
+
   describe "revisions" do
     let( :user ) { create_versions }
 
@@ -328,8 +598,8 @@ describe Audited::Auditor do
 
     it "should set the attributes for each revision" do
       u = Models::ActiveRecord::User.create(name: 'Brandon', username: 'brandon')
-      u.update_attributes name: 'Foobar'
-      u.update_attributes name: 'Awesome', username: 'keepers'
+      u.update! name: 'Foobar'
+      u.update! name: 'Awesome', username: 'keepers'
 
       expect(u.revisions.size).to eql(3)
 
@@ -345,8 +615,8 @@ describe Audited::Auditor do
 
     it "access to only recent revisions" do
       u = Models::ActiveRecord::User.create(name: 'Brandon', username: 'brandon')
-      u.update_attributes name: 'Foobar'
-      u.update_attributes name: 'Awesome', username: 'keepers'
+      u.update! name: 'Foobar'
+      u.update! name: 'Awesome', username: 'keepers'
 
       expect(u.revisions(2).size).to eq(2)
 
@@ -363,7 +633,7 @@ describe Audited::Auditor do
     end
 
     it "should ignore attributes that have been deleted" do
-      user.audits.last.update_attributes audited_changes: {old_attribute: 'old value'}
+      user.audits.last.update! audited_changes: {old_attribute: 'old value'}
       expect { user.revisions }.to_not raise_error
     end
   end
@@ -378,21 +648,21 @@ describe Audited::Auditor do
     it "should find the given revision" do
       revision = user.revision(3)
       expect(revision).to be_a_kind_of( Models::ActiveRecord::User )
-      expect(revision.version).to eq(3)
+      expect(revision.audit_version).to eq(3)
       expect(revision.name).to eq('Foobar 3')
     end
 
     it "should find the previous revision with :previous" do
       revision = user.revision(:previous)
-      expect(revision.version).to eq(4)
+      expect(revision.audit_version).to eq(4)
       #expect(revision).to eq(user.revision(4))
       expect(revision.attributes).to eq(user.revision(4).attributes)
     end
 
     it "should be able to get the previous revision repeatedly" do
       previous = user.revision(:previous)
-      expect(previous.version).to eq(4)
-      expect(previous.revision(:previous).version).to eq(3)
+      expect(previous.audit_version).to eq(4)
+      expect(previous.revision(:previous).audit_version).to eq(3)
     end
 
     it "should be able to set protected attributes" do
@@ -412,8 +682,8 @@ describe Audited::Auditor do
 
     it "should set the attributes for each revision" do
       u = Models::ActiveRecord::User.create(name: 'Brandon', username: 'brandon')
-      u.update_attributes name: 'Foobar'
-      u.update_attributes name: 'Awesome', username: 'keepers'
+      u.update! name: 'Foobar'
+      u.update! name: 'Awesome', username: 'keepers'
 
       expect(u.revision(3).name).to eq('Awesome')
       expect(u.revision(3).username).to eq('keepers')
@@ -425,6 +695,16 @@ describe Audited::Auditor do
       expect(u.revision(1).username).to eq('brandon')
     end
 
+    it "should correctly restore revision with enum" do
+      u = Models::ActiveRecord::User.create(status: :active)
+      u.update_attribute(:status, :reliable)
+      u.update_attribute(:status, :banned)
+
+      expect(u.revision(3)).to be_banned
+      expect(u.revision(2)).to be_reliable
+      expect(u.revision(1)).to be_active
+    end
+
     it "should be able to get time for first revision" do
       suspended_at = Time.zone.now
       u = Models::ActiveRecord::User.create(suspended_at: suspended_at)
@@ -452,6 +732,10 @@ describe Audited::Auditor do
         user.revision(1).save!
       }.to change( Models::ActiveRecord::User, :count ).by(1)
     end
+
+    it "should return nil for values greater than the number of revisions" do
+      expect(user.revision(user.revisions.count + 1)).to be_nil
+    end
   end
 
   describe "revision_at" do
@@ -461,8 +745,8 @@ describe Audited::Auditor do
       audit = user.audits.first
       audit.created_at = 1.hour.ago
       audit.save!
-      user.update_attributes name: 'updated'
-      expect(user.revision_at( 2.minutes.ago ).version).to eq(1)
+      user.update! name: 'updated'
+      expect(user.revision_at( 2.minutes.ago ).audit_version).to eq(1)
     end
 
     it "should be nil if given a time before audits" do
@@ -470,6 +754,33 @@ describe Audited::Auditor do
     end
   end
 
+  describe "own_and_associated_audits" do
+    it "should return audits for self and associated audits" do
+      owner = Models::ActiveRecord::Owner.create!
+      company = owner.companies.create!
+      company.update!(name: "Collective Idea")
+
+      other_owner = Models::ActiveRecord::Owner.create!
+      other_owner.companies.create!
+
+      expect(owner.own_and_associated_audits).to match_array(owner.audits + company.audits)
+    end
+
+    it "should order audits by creation time" do
+      owner = Models::ActiveRecord::Owner.create!
+      first_audit = owner.audits.first
+      first_audit.update_column(:created_at, 1.year.ago)
+
+      company = owner.companies.create!
+      second_audit = company.audits.first
+      second_audit.update_column(:created_at, 1.month.ago)
+
+      company.update!(name: "Collective Idea")
+      third_audit = company.audits.last
+      expect(owner.own_and_associated_audits.to_a).to eq([third_audit, second_audit, first_audit])
+    end
+  end
+
   describe "without auditing" do
     it "should not save an audit when calling #save_without_auditing" do
       expect {
@@ -490,72 +801,162 @@ describe Audited::Auditor do
     end
 
     it "should be thread safe using a #without_auditing block" do
-      begin
-        t1 = Thread.new do
-          expect(Models::ActiveRecord::User.auditing_enabled).to eq(true)
-          Models::ActiveRecord::User.without_auditing do
-            expect(Models::ActiveRecord::User.auditing_enabled).to eq(false)
-            Models::ActiveRecord::User.create!( name: 'Bart' )
-            sleep 1
-            expect(Models::ActiveRecord::User.auditing_enabled).to eq(false)
-          end
-          expect(Models::ActiveRecord::User.auditing_enabled).to eq(true)
+      skip if Models::ActiveRecord::User.connection.class.name.include?("SQLite")
+
+      t1 = Thread.new do
+        expect(Models::ActiveRecord::User.auditing_enabled).to eq(true)
+        Models::ActiveRecord::User.without_auditing do
+          expect(Models::ActiveRecord::User.auditing_enabled).to eq(false)
+          Models::ActiveRecord::User.create!( name: 'Bart' )
+          sleep 1
+          expect(Models::ActiveRecord::User.auditing_enabled).to eq(false)
         end
+        expect(Models::ActiveRecord::User.auditing_enabled).to eq(true)
+      end
+
+      t2 = Thread.new do
+        sleep 0.5
+        expect(Models::ActiveRecord::User.auditing_enabled).to eq(true)
+        Models::ActiveRecord::User.create!( name: 'Lisa' )
+      end
+      t1.join
+      t2.join
+
+      expect(Models::ActiveRecord::User.find_by_name('Bart').audits.count).to eq(0)
+      expect(Models::ActiveRecord::User.find_by_name('Lisa').audits.count).to eq(1)
+    end
+
+    it "should not save an audit when auditing is globally disabled" do
+      expect(Audited.auditing_enabled).to eq(true)
+      Audited.auditing_enabled = false
+      expect(Models::ActiveRecord::User.auditing_enabled).to eq(false)
+
+      user = create_user
+      expect(user.audits.count).to eq(0)
+
+      Audited.auditing_enabled = true
+      expect(Models::ActiveRecord::User.auditing_enabled).to eq(true)
+
+      user.update!(name: 'Test')
+      expect(user.audits.count).to eq(1)
+      Models::ActiveRecord::User.enable_auditing
+    end
+  end
+
+  describe "with auditing" do
+    it "should save an audit when calling #save_with_auditing" do
+      expect {
+        u = Models::ActiveRecord::User.new(name: 'Brandon')
+        Models::ActiveRecord::User.auditing_enabled = false
+        expect(u.save_with_auditing).to eq(true)
+        Models::ActiveRecord::User.auditing_enabled = true
+      }.to change( Audited::Audit, :count ).by(1)
+    end
+
+    it "should save an audit inside of the #with_auditing block" do
+      expect {
+        Models::ActiveRecord::User.auditing_enabled = false
+        Models::ActiveRecord::User.with_auditing { Models::ActiveRecord::User.create!( name: 'Brandon' ) }
+        Models::ActiveRecord::User.auditing_enabled = true
+      }.to change( Audited::Audit, :count ).by(1)
+    end
 
-        t2 = Thread.new do
-          sleep 0.5
+    it "should reset auditing status even it raises an exception" do
+      Models::ActiveRecord::User.disable_auditing
+      Models::ActiveRecord::User.with_auditing { raise } rescue nil
+      expect(Models::ActiveRecord::User.auditing_enabled).to eq(false)
+      Models::ActiveRecord::User.enable_auditing
+    end
+
+    it "should be thread safe using a #with_auditing block" do
+      skip if Models::ActiveRecord::User.connection.class.name.include?("SQLite")
+
+      t1 = Thread.new do
+        Models::ActiveRecord::User.disable_auditing
+        expect(Models::ActiveRecord::User.auditing_enabled).to eq(false)
+        Models::ActiveRecord::User.with_auditing do
+          expect(Models::ActiveRecord::User.auditing_enabled).to eq(true)
+
+          Models::ActiveRecord::User.create!( name: 'Shaggy' )
+          sleep 1
           expect(Models::ActiveRecord::User.auditing_enabled).to eq(true)
-          Models::ActiveRecord::User.create!( name: 'Lisa' )
         end
-        t1.join
-        t2.join
+        expect(Models::ActiveRecord::User.auditing_enabled).to eq(false)
+        Models::ActiveRecord::User.enable_auditing
+      end
 
-        expect(Models::ActiveRecord::User.find_by_name('Bart').audits.count).to eq(0)
-        expect(Models::ActiveRecord::User.find_by_name('Lisa').audits.count).to eq(1)
-      rescue ActiveRecord::StatementInvalid
-        STDERR.puts "Thread safety tests cannot be run with SQLite"
+      t2 = Thread.new do
+        sleep 0.5
+        Models::ActiveRecord::User.disable_auditing
+        expect(Models::ActiveRecord::User.auditing_enabled).to eq(false)
+        Models::ActiveRecord::User.create!( name: 'Scooby' )
+        Models::ActiveRecord::User.enable_auditing
       end
+      t1.join
+      t2.join
+
+      Models::ActiveRecord::User.enable_auditing
+      expect(Models::ActiveRecord::User.find_by_name('Shaggy').audits.count).to eq(1)
+      expect(Models::ActiveRecord::User.find_by_name('Scooby').audits.count).to eq(0)
     end
   end
 
   describe "comment required" do
 
     describe "on create" do
-      it "should not validate when audit_comment is not supplied" do
-        expect(Models::ActiveRecord::CommentRequiredUser.new).not_to be_valid
+      it "should not validate when audit_comment is not supplied when initialized" do
+        expect(Models::ActiveRecord::CommentRequiredUser.new(name: 'Foo')).not_to be_valid
+      end
+
+      it "should not validate when audit_comment is not supplied trying to create" do
+        expect(Models::ActiveRecord::CommentRequiredUser.create(name: 'Foo')).not_to be_valid
       end
 
       it "should validate when audit_comment is supplied" do
-        expect(Models::ActiveRecord::CommentRequiredUser.new( audit_comment: 'Create')).to be_valid
+        expect(Models::ActiveRecord::CommentRequiredUser.create(name: 'Foo', audit_comment: 'Create')).to be_valid
+      end
+
+      it "should validate when audit_comment is not supplied, and creating is not being audited" do
+        expect(Models::ActiveRecord::OnUpdateCommentRequiredUser.create(name: 'Foo')).to be_valid
+        expect(Models::ActiveRecord::OnDestroyCommentRequiredUser.create(name: 'Foo')).to be_valid
       end
 
       it "should validate when audit_comment is not supplied, and auditing is disabled" do
         Models::ActiveRecord::CommentRequiredUser.disable_auditing
-        expect(Models::ActiveRecord::CommentRequiredUser.new).to be_valid
+        expect(Models::ActiveRecord::CommentRequiredUser.create(name: 'Foo')).to be_valid
         Models::ActiveRecord::CommentRequiredUser.enable_auditing
       end
     end
 
     describe "on update" do
       let( :user ) { Models::ActiveRecord::CommentRequiredUser.create!( audit_comment: 'Create' ) }
+      let( :on_create_user ) { Models::ActiveRecord::OnDestroyCommentRequiredUser.create }
+      let( :on_destroy_user ) { Models::ActiveRecord::OnDestroyCommentRequiredUser.create }
 
       it "should not validate when audit_comment is not supplied" do
-        expect(user.update_attributes(name: 'Test')).to eq(false)
+        expect(user.update(name: 'Test')).to eq(false)
+      end
+
+      it "should validate when audit_comment is not supplied, and updating is not being audited" do
+        expect(on_create_user.update(name: 'Test')).to eq(true)
+        expect(on_destroy_user.update(name: 'Test')).to eq(true)
       end
 
       it "should validate when audit_comment is supplied" do
-        expect(user.update_attributes(name: 'Test', audit_comment: 'Update')).to eq(true)
+        expect(user.update(name: 'Test', audit_comment: 'Update')).to eq(true)
       end
 
       it "should validate when audit_comment is not supplied, and auditing is disabled" do
         Models::ActiveRecord::CommentRequiredUser.disable_auditing
-        expect(user.update_attributes(name: 'Test')).to eq(true)
+        expect(user.update(name: 'Test')).to eq(true)
         Models::ActiveRecord::CommentRequiredUser.enable_auditing
       end
     end
 
     describe "on destroy" do
       let( :user ) { Models::ActiveRecord::CommentRequiredUser.create!( audit_comment: 'Create' )}
+      let( :on_create_user ) { Models::ActiveRecord::OnCreateCommentRequiredUser.create!( audit_comment: 'Create' ) }
+      let( :on_update_user ) { Models::ActiveRecord::OnUpdateCommentRequiredUser.create }
 
       it "should not validate when audit_comment is not supplied" do
         expect(user.destroy).to eq(false)
@@ -566,6 +967,11 @@ describe Audited::Auditor do
         expect(user.destroy).to eq(user)
       end
 
+      it "should validate when audit_comment is not supplied, and destroying is not being audited" do
+        expect(on_create_user.destroy).to eq(on_create_user)
+        expect(on_update_user.destroy).to eq(on_update_user)
+      end
+
       it "should validate when audit_comment is not supplied, and auditing is disabled" do
         Models::ActiveRecord::CommentRequiredUser.disable_auditing
         expect(user.destroy).to eq(user)
@@ -575,6 +981,16 @@ describe Audited::Auditor do
 
   end
 
+  describe "no update with comment only" do
+    let( :user ) { Models::ActiveRecord::NoUpdateWithCommentOnlyUser.create }
+
+    it "does not create an audit when only an audit_comment is present" do
+      user.audit_comment = "Comment"
+      expect { user.save! }.to_not change( Audited::Audit, :count )
+    end
+
+  end
+
   describe "attr_protected and attr_accessible" do
 
     it "should not raise error when attr_accessible is set and protected is false" do
@@ -596,7 +1012,7 @@ describe Audited::Auditor do
     it "should record user objects" do
       Models::ActiveRecord::Company.audit_as( user ) do
         company = Models::ActiveRecord::Company.create name: 'The auditors'
-        company.update_attributes name: 'The Auditors'
+        company.update! name: 'The Auditors'
 
         company.audits.each do |audit|
           expect(audit.user).to eq(user)
@@ -607,7 +1023,7 @@ describe Audited::Auditor do
     it "should record usernames" do
       Models::ActiveRecord::Company.audit_as( user.name ) do
         company = Models::ActiveRecord::Company.create name: 'The auditors'
-        company.update_attributes name: 'The Auditors'
+        company.update! name: 'The Auditors'
 
         company.audits.each do |audit|
           expect(audit.user).to eq(user.name)
@@ -617,7 +1033,7 @@ describe Audited::Auditor do
   end
 
   describe "after_audit" do
-    let( :user ) { user = Models::ActiveRecord::UserWithAfterAudit.new }
+    let( :user ) { Models::ActiveRecord::UserWithAfterAudit.new }
 
     it "should invoke after_audit callback on create" do
       expect(user.bogus_attr).to be_nil
@@ -627,7 +1043,7 @@ describe Audited::Auditor do
   end
 
   describe "around_audit" do
-    let( :user ) { user = Models::ActiveRecord::UserWithAfterAudit.new }
+    let( :user ) { Models::ActiveRecord::UserWithAfterAudit.new }
 
     it "should invoke around_audit callback on create" do
       expect(user.around_attr).to be_nil
@@ -642,7 +1058,7 @@ describe Audited::Auditor do
       expect(company.type).to eq("Models::ActiveRecord::Company::STICompany")
       expect {
         Models::ActiveRecord::Company.auditing_enabled = false
-        company.update_attributes name: 'STI auditors'
+        company.update! name: 'STI auditors'
         Models::ActiveRecord::Company.auditing_enabled = true
       }.to_not change( Audited::Audit, :count )
     end