audited 4.8.0 → 4.9.0

data/lib/audited/audit.rb

@@ -97,7 +97,7 @@ module Audited
         auditable_type.constantize.create!(audited_changes)
       when 'update'
         # changes back attributes
-        auditable.update_attributes!(audited_changes.transform_values(&:first))
+        auditable.update!(audited_changes.transform_values(&:first))
       else
         raise StandardError, "invalid action given #{action}"
       end
@@ -130,7 +130,7 @@ module Audited
     # All audits made during the block called will be recorded as made
     # by +user+. This method is hopefully threadsafe, making it ideal
     # for background operations that require audit information.
-    def self.as_user(user, &block)
+    def self.as_user(user)
       last_audited_user = ::Audited.store[:audited_user] 
       ::Audited.store[:audited_user] = user
       yield
@@ -140,13 +140,11 @@ module Audited
 
     # @private
     def self.reconstruct_attributes(audits)
-      attributes = {}
-      result = audits.collect do |audit|
-        attributes.merge!(audit.new_attributes)[:audit_version] = audit.version
-        yield attributes if block_given?
-      end
-      block_given? ? result : attributes
-   end
+      audits.each_with_object({}) do |audit, all|
+        all.merge!(audit.new_attributes)
+        all[:audit_version] = audit.version
+     end
+    end
 
     # @private
     def self.assign_revision_attributes(record, attributes)
@@ -163,7 +161,7 @@ module Audited
     end
 
     # use created_at as timestamp cache key
-    def self.collection_cache_key(collection = all, timestamp_column = :created_at)
+    def self.collection_cache_key(collection = all, *)
       super(collection, :created_at)
     end
 

data/lib/audited/auditor.rb

@@ -115,6 +115,21 @@ module Audited
         self.class.without_auditing(&block)
       end
 
+      # Temporarily turns on auditing while saving.
+      def save_with_auditing
+        with_auditing { save }
+      end
+
+      # Executes the block with the auditing callbacks enabled.
+      #
+      #   @foo.with_auditing do
+      #     @foo.save
+      #   end
+      #
+      def with_auditing(&block)
+        self.class.with_auditing(&block)
+      end
+
       # Gets an array of the revisions available
       #
       #   user.revisions.each do |revision|
@@ -152,7 +167,8 @@ module Audited
 
       # List of attributes that are audited.
       def audited_attributes
-        attributes.except(*non_audited_columns)
+        audited_attributes = attributes.except(*self.class.non_audited_columns)
+        normalize_enum_changes(audited_attributes)
       end
 
       # Returns a list combined of record audits and associated audits.
@@ -177,18 +193,9 @@ module Audited
 
       protected
 
-      def non_audited_columns
-        self.class.non_audited_columns
-      end
-
-      def audited_columns
-        self.class.audited_columns
-      end
-
       def revision_with(attributes)
         dup.tap do |revision|
           revision.id = id
-          revision.send :instance_variable_set, '@attributes', self.attributes if rails_below?('4.2.0')
           revision.send :instance_variable_set, '@new_record', destroyed?
           revision.send :instance_variable_set, '@persisted', !destroyed?
           revision.send :instance_variable_set, '@readonly', false
@@ -211,19 +218,39 @@ module Audited
         end
       end
 
-      def rails_below?(rails_version)
-        Gem::Version.new(Rails::VERSION::STRING) < Gem::Version.new(rails_version)
-      end
-
       private
 
       def audited_changes
         all_changes = respond_to?(:changes_to_save) ? changes_to_save : changes
-        if audited_options[:only].present?
-          all_changes.slice(*audited_columns)
-        else
-          all_changes.except(*non_audited_columns)
+        filtered_changes = \
+          if audited_options[:only].present?
+            all_changes.slice(*self.class.audited_columns)
+          else
+            all_changes.except(*self.class.non_audited_columns)
+          end
+
+        filtered_changes = normalize_enum_changes(filtered_changes)
+        filtered_changes.to_hash
+      end
+
+      def normalize_enum_changes(changes)
+        self.class.defined_enums.each do |name, values|
+          if changes.has_key?(name)
+            changes[name] = \
+              if changes[name].is_a?(Array)
+                changes[name].map { |v| values[v] }
+              elsif rails_below?('5.0')
+                changes[name]
+              else
+                values[changes[name]]
+              end
+          end
         end
+        changes
+      end
+
+      def rails_below?(rails_version)
+        Gem::Version.new(Rails::VERSION::STRING) < Gem::Version.new(rails_version)
       end
 
       def audits_to(version = nil)
@@ -244,7 +271,7 @@ module Audited
       end
 
       def audit_update
-        unless (changes = audited_changes).empty? && audit_comment.blank?
+        unless (changes = audited_changes).empty? && (audit_comment.blank? || audited_options[:update_with_comment_only] == false)
           write_audit(action: 'update', audited_changes: changes,
                       comment: audit_comment)
         end
@@ -314,10 +341,6 @@ module Audited
         true
       end
 
-      def auditing_enabled=(val)
-        self.class.auditing_enabled = val
-      end
-
       def reconstruct_attributes(audits)
         attributes = {}
         audits.each { |audit| attributes.merge!(audit.new_attributes) }
@@ -355,6 +378,20 @@ module Audited
         enable_auditing if auditing_was_enabled
       end
 
+      # Executes the block with auditing enabled.
+      #
+      #   Foo.with_auditing do
+      #     @foo.save
+      #   end
+      #
+      def with_auditing
+        auditing_was_enabled = auditing_enabled
+        enable_auditing
+        yield
+      ensure
+        disable_auditing unless auditing_was_enabled
+      end
+
       def disable_auditing
         self.auditing_enabled = false
       end

data/lib/audited/version.rb

@@ -1,3 +1,3 @@
 module Audited
-  VERSION = "4.8.0"
+  VERSION = "4.9.0"
 end

data/spec/audited/audit_spec.rb

@@ -1,5 +1,7 @@
 require "spec_helper"
 
+SingleCov.covered!
+
 describe Audited::Audit do
   let(:user) { Models::ActiveRecord::User.new name: "Testing" }
 
@@ -38,43 +40,64 @@ describe Audited::Audit do
       end
     end
 
-    it "should undo changes" do
-      user = Models::ActiveRecord::User.create(name: "John")
+    context "when a custom audit class is not configured" do
+      it "should default to #{described_class}" do
+        TempModel.audited
+
+        record = TempModel.create
+
+        audit = record.audits.first
+        expect(audit).to be_a Audited::Audit
+        expect(audit.respond_to?(:custom_method)).to be false
+      end
+    end
+  end
+
+  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.audit_class.columns_hash["audited_changes"]).to receive(:type).and_return("foo")
+      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 "should undo destroyed model" do
-      user = Models::ActiveRecord::User.create(name: "John")
+    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 "should undo created model" do
-      user = Models::ActiveRecord::User.create(name: "John")
+    it "undos creation" do
+      user # trigger create
       expect {user.audits.last.undo}.to change(Models::ActiveRecord::User, :count).by(-1)
     end
 
-    context "when a custom audit class is not configured" do
-      it "should default to #{described_class}" do
-        TempModel.audited
-
-        record = TempModel.create
-
-        audit = record.audits.first
-        expect(audit).to be_a Audited::Audit
-        expect(audit.respond_to?(:custom_method)).to be false
-      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)
@@ -110,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 }
@@ -148,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.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)
@@ -282,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
@@ -210,7 +212,7 @@ describe Audited::Auditor do
       expect(user.audits.last.audited_changes.keys).to eq(%w{non_column_attr})
     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
+    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") }
 
@@ -264,7 +266,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 {
@@ -288,6 +290,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
@@ -306,7 +312,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
@@ -319,17 +325,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
@@ -337,12 +348,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 )
@@ -366,7 +377,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
@@ -391,6 +402,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
@@ -492,13 +508,13 @@ describe Audited::Auditor do
     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_attributes(name: 'Foobar')
-        user.update_attributes(name: 'Awesome', username: 'keepers')
-        user.update_attributes(activated: true)
+        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_attributes(favourite_device: 'Android Phone')
+        user.update!(favourite_device: 'Android Phone')
         audits = user.audits
 
         expect(audits.count).to eq(3)
@@ -549,8 +565,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)
 
@@ -566,8 +582,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)
 
@@ -584,7 +600,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
@@ -633,8 +649,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')
@@ -646,6 +662,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)
@@ -686,7 +712,7 @@ describe Audited::Auditor do
       audit = user.audits.first
       audit.created_at = 1.hour.ago
       audit.save!
-      user.update_attributes name: 'updated'
+      user.update! name: 'updated'
       expect(user.revision_at( 2.minutes.ago ).audit_version).to eq(1)
     end
 
@@ -702,7 +728,7 @@ describe Audited::Auditor do
       company.update!(name: "Collective Idea")
 
       other_owner = Models::ActiveRecord::Owner.create!
-      other_company = other_owner.companies.create!
+      other_owner.companies.create!
 
       expect(owner.own_and_associated_audits).to match_array(owner.audits + company.audits)
     end
@@ -778,8 +804,67 @@ describe Audited::Auditor do
       Audited.auditing_enabled = true
       expect(Models::ActiveRecord::User.auditing_enabled).to eq(true)
 
-      user.update_attributes(name: 'Test')
+      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
+
+    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)
+        end
+        expect(Models::ActiveRecord::User.auditing_enabled).to eq(false)
+        Models::ActiveRecord::User.enable_auditing
+      end
+
+      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
 
@@ -816,21 +901,21 @@ describe Audited::Auditor do
       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_attributes(name: 'Test')).to eq(true)
-        expect(on_destroy_user.update_attributes(name: 'Test')).to eq(true)
+        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
@@ -863,6 +948,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
@@ -884,7 +979,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)
@@ -895,7 +990,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)
@@ -905,7 +1000,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
@@ -915,7 +1010,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
@@ -930,7 +1025,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