audited 4.8.0 → 4.10.0

data/lib/audited/auditor.rb

@@ -34,6 +34,16 @@ module Audited
       # * +require_comment+ - Ensures that audit_comment is supplied before
       #   any create, update or destroy operation.
       # * +max_audits+ - Limits the number of stored audits.
+
+      # * +redacted+ - Changes to these fields will be logged, but the values
+      #   will not. This is useful, for example, if you wish to audit when a
+      #   password is changed, without saving the actual password in the log.
+      #   To store values as something other than '[REDACTED]', pass an argument
+      #   to the redaction_value option.
+      #
+      #     class User < ActiveRecord::Base
+      #       audited redacted: :password, redaction_value: SecureRandom.uuid
+      #     end
       #
       # * +if+ - Only audit the model when the given function returns true
       # * +unless+ - Only audit the model when the given function returns false
@@ -90,16 +100,8 @@ module Audited
     end
 
     module AuditedInstanceMethods
-      # Deprecate version attribute in favor of audit_version attribute – preparing for eventual removal.
-      def method_missing(method_name, *args, &block)
-        if method_name == :version
-          ActiveSupport::Deprecation.warn("`version` attribute has been changed to `audit_version`. This attribute will be removed.")
-          audit_version
-        else
-          super
-        end
-      end
-
+      REDACTED = '[REDACTED]'
+      
       # Temporarily turns off auditing while saving.
       def save_without_auditing
         without_auditing { save }
@@ -115,6 +117,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 +169,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 +195,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 +220,56 @@ 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 = redact_values(filtered_changes)
+        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 redact_values(filtered_changes)
+        [audited_options[:redacted]].flatten.compact.each do |option|
+          changes = filtered_changes[option.to_s]
+          new_value = audited_options[:redaction_value] || REDACTED
+          if changes.is_a? Array
+            values = changes.map { new_value }
+          else
+            values = new_value
+          end
+          hash = Hash[option.to_s, values]
+          filtered_changes.merge!(hash)
+        end
+
+        filtered_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 +290,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 +360,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 +397,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.10.0"
 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" }
 
@@ -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::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 "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.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)
@@ -282,6 +331,5 @@ describe Audited::Audit do
       }.to raise_exception('expected')
       expect(Audited.store[:audited_user]).to be_nil
     end
-
   end
 end