paper_trail 4.0.0.beta2 → 4.0.0.rc1

data/lib/paper_trail/version_concern.rb

@@ -6,11 +6,20 @@ module PaperTrail
 
     included do
       belongs_to :item, :polymorphic => true
-      has_many :version_associations, :dependent => :destroy
+
+      # Since the test suite has test coverage for this, we want to declare the
+      # association when the test suite is running. This makes it pass
+      # when DB is not initialized prior to test runs such as when we run on
+      # Travis CI (there won't be a db in `test/dummy/db/`)
+      if PaperTrail.config.track_associations?
+        has_many :version_associations, :dependent => :destroy
+      end
 
       validates_presence_of :event
 
-      attr_accessible :item_type, :item_id, :event, :whodunnit, :object, :object_changes, :transaction_id, :created_at if PaperTrail.active_record_protected_attributes?
+      if PaperTrail.active_record_protected_attributes?
+        attr_accessible :item_type, :item_id, :event, :whodunnit, :object, :object_changes, :transaction_id, :created_at
+      end
 
       after_create :enforce_version_limit!
 
@@ -77,12 +86,22 @@ module PaperTrail
       # identically-named method in the serializer being used.
       def where_object(args = {})
         raise ArgumentError, 'expected to receive a Hash' unless args.is_a?(Hash)
-        arel_field = arel_table[:object]
 
-        where_conditions = args.map do |field, value|
-          PaperTrail.serializer.where_object_condition(arel_field, field, value)
-        end.reduce do |condition1, condition2|
-          condition1.and(condition2)
+        if columns_hash['object'].type == :jsonb
+          where_conditions = "object @> '#{args.to_json}'::jsonb"
+        elsif columns_hash['object'].type == :json
+          where_conditions = args.map do |field, value|
+            "object->>'#{field}' = '#{value}'"
+          end
+          where_conditions = where_conditions.join(" AND ")
+        else
+          arel_field = arel_table[:object]
+
+          where_conditions = args.map do |field, value|
+            PaperTrail.serializer.where_object_condition(arel_field, field, value)
+          end.reduce do |condition1, condition2|
+            condition1.and(condition2)
+          end
         end
 
         where(where_conditions)
@@ -90,12 +109,23 @@ module PaperTrail
 
       def where_object_changes(args = {})
         raise ArgumentError, 'expected to receive a Hash' unless args.is_a?(Hash)
-        arel_field = arel_table[:object_changes]
 
-        where_conditions = args.map do |field, value|
-          PaperTrail.serializer.where_object_changes_condition(arel_field, field, value)
-        end.reduce do |condition1, condition2|
-          condition1.and(condition2)
+        if columns_hash['object_changes'].type == :jsonb
+          args.each { |field, value| args[field] = [value] }
+          where_conditions = "object_changes @> '#{args.to_json}'::jsonb"
+        elsif columns_hash['object'].type == :json
+          where_conditions = args.map do |field, value|
+            "((object_changes->>'#{field}' ILIKE '[#{value.to_json},%') OR (object_changes->>'#{field}' ILIKE '[%,#{value.to_json}]%'))"
+          end
+          where_conditions = where_conditions.join(" AND ")
+        else
+          arel_field = arel_table[:object_changes]
+
+          where_conditions = args.map do |field, value|
+            PaperTrail.serializer.where_object_changes_condition(arel_field, field, value)
+          end.reduce do |condition1, condition2|
+            condition1.and(condition2)
+          end
         end
 
         where(where_conditions)
@@ -109,12 +139,12 @@ module PaperTrail
 
       # Returns whether the `object` column is using the `json` type supported by PostgreSQL
       def object_col_is_json?
-        @object_col_is_json ||= columns_hash['object'].type == :json
+        [:json, :jsonb].include?(columns_hash['object'].type)
       end
 
       # Returns whether the `object_changes` column is using the `json` type supported by PostgreSQL
       def object_changes_col_is_json?
-        @object_changes_col_is_json ||= columns_hash['object_changes'].try(:type) == :json
+        [:json, :jsonb].include?(columns_hash['object_changes'].try(:type))
       end
     end
 
@@ -158,7 +188,7 @@ module PaperTrail
         # `item_type` will be the base class, not the actual subclass.
         # If `type` is present but empty, the class is the base class.
 
-        if item && options[:dup] != true
+        if options[:dup] != true && item
           model = item
           # Look for attributes that exist in the model and not in this version. These attributes should be set to nil.
           (model.attribute_names - attrs.keys).each { |k| attrs[k] = nil }
@@ -166,17 +196,27 @@ module PaperTrail
           inheritance_column_name = item_type.constantize.inheritance_column
           class_name = attrs[inheritance_column_name].blank? ? item_type : attrs[inheritance_column_name]
           klass = class_name.constantize
-          model = klass.new
+          # the `dup` option always returns a new object, otherwise we should attempt
+          # to look for the item outside of default scope(s)
+          if options[:dup] || (_item = klass.unscoped.find_by_id(item_id)).nil?
+            model = klass.new
+          else
+            model = _item
+            # Look for attributes that exist in the model and not in this version. These attributes should be set to nil.
+            (model.attribute_names - attrs.keys).each { |k| attrs[k] = nil }
+          end
         end
 
         if PaperTrail.serialized_attributes?
-          model.class.unserialize_attributes_for_paper_trail attrs
+          model.class.unserialize_attributes_for_paper_trail! attrs
         end
 
         # Set all the attributes in this version on the model
         attrs.each do |k, v|
           if model.has_attribute?(k)
             model[k.to_sym] = v
+          elsif model.respond_to?("#{k}=")
+            model.send("#{k}=", v)
           else
             logger.warn "Attribute #{k} does not exist on #{item_type} (Version id: #{id})."
           end
@@ -204,7 +244,7 @@ module PaperTrail
       _changes = self.class.object_changes_col_is_json? ? object_changes : PaperTrail.serializer.load(object_changes)
       @changeset ||= HashWithIndifferentAccess.new(_changes).tap do |changes|
         if PaperTrail.serialized_attributes?
-          item_type.constantize.unserialize_attribute_changes(changes)
+          item_type.constantize.unserialize_attribute_changes_for_paper_trail!(changes)
         end
       end
     rescue
@@ -212,8 +252,13 @@ module PaperTrail
     end
 
     # Returns who put the item into the state stored in this version.
+    def paper_trail_originator
+      @paper_trail_originator ||= previous.whodunnit rescue nil
+    end
+
     def originator
-      @originator ||= previous.whodunnit rescue nil
+      warn "DEPRECATED: use `paper_trail_originator` instead of `originator`. Support for `originator` will be removed in PaperTrail 4.0"
+      self.paper_trail_originator
     end
 
     # Returns who changed the item from the state it had in this version.

data/lib/paper_trail/version_number.rb

@@ -3,7 +3,7 @@ module PaperTrail
     MAJOR = 4
     MINOR = 0
     TINY  = 0
-    PRE   = 'beta2'
+    PRE   = 'rc1'
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
 

data/lib/paper_trail.rb

@@ -1,3 +1,5 @@
+require 'request_store'
+
 # Require core library
 Dir[File.join(File.dirname(__FILE__), 'paper_trail', '*.rb')].each do |file|
   require File.join('paper_trail', File.basename(file, '.rb'))
@@ -118,16 +120,18 @@ module PaperTrail
   # Thread-safe hash to hold PaperTrail's data.
   # Initializing with needed default values.
   def self.paper_trail_store
-    Thread.current[:paper_trail] ||= { :request_enabled_for_controller => true }
+    RequestStore.store[:paper_trail] ||= { :request_enabled_for_controller => true }
   end
 
   # Returns PaperTrail's configuration object.
   def self.config
     @@config ||= PaperTrail::Config.instance
+    yield @@config if block_given?
+    @@config
   end
 
-  def self.configure
-    yield config
+  class << self
+    alias_method :configure, :config
   end
 end
 

data/paper_trail.gemspec

@@ -21,11 +21,12 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'activerecord', ['>= 3.0', '< 6.0']
   s.add_dependency 'activesupport', ['>= 3.0', '< 6.0']
+  s.add_dependency 'request_store', '~> 1.1.0'
 
   s.add_development_dependency 'rake', '~> 10.1.1'
   s.add_development_dependency 'shoulda', '~> 3.5'
   # s.add_development_dependency 'shoulda-matchers', '~> 1.5' # needed for ActiveRecord < 4
-  s.add_development_dependency 'ffaker',  '>= 1.15'
+  s.add_development_dependency 'ffaker', '<= 1.31.0'
   s.add_development_dependency 'railties', ['>= 3.0', '< 5.0']
   s.add_development_dependency 'sinatra', '~> 1.0'
   s.add_development_dependency 'rack-test', '>= 0.6'

data/spec/models/animal_spec.rb

@@ -0,0 +1,19 @@
+require 'rails_helper'
+
+describe Animal, :type => :model do
+  it { is_expected.to be_versioned }
+
+  describe "STI", :versioning => true do
+    it { expect(Animal.inheritance_column).to eq('species') }
+
+    describe "updates to the `inheritance_column`" do
+      subject { Cat.create!(:name => 'Leo') }
+
+      it "should be allowed" do
+        subject.update_attributes(:name => 'Spike', :species => 'Dog')
+        dog = Animal.find(subject.id)
+        expect(dog).to be_instance_of(Dog)
+      end
+    end
+  end
+end

data/spec/models/boolit_spec.rb

@@ -0,0 +1,48 @@
+require 'rails_helper'
+require Rails.root.join('..', 'custom_json_serializer')
+
+describe Boolit, :type => :model do
+  it { is_expected.to be_versioned }
+
+  it "has a default scope" do
+    expect(subject.default_scopes).to_not be_empty
+  end
+
+  describe "Versioning", :versioning => true do
+    subject { Boolit.create! }
+    before { subject.update_attributes!(:name => Faker::Name.name) }
+
+    it "should have versions" do
+      expect(subject.versions.size).to eq(2)
+    end
+
+    it "should be able to be reified and persisted" do
+      expect { subject.versions.last.reify.save! }.to_not raise_error
+    end
+
+    context "Instance falls out of default scope" do
+      before { subject.update_attributes!(:scoped => false) }
+
+      it "is NOT scoped" do
+        expect(Boolit.first).to be_nil
+      end
+
+      it "should still be able to be reified and persisted" do
+        expect { subject.previous_version.save! }.to_not raise_error
+      end
+
+      context "with `nil` attributes on the live instance" do
+        before do
+          PaperTrail.serializer = CustomJsonSerializer
+          subject.update_attributes!(:name => nil)
+          subject.update_attributes!(:name => Faker::Name.name)
+        end
+        after { PaperTrail.serializer = PaperTrail::Serializers::YAML }
+
+        it "should not overwrite that attribute during the reification process" do
+          expect(subject.previous_version.name).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/models/json_version_spec.rb

@@ -0,0 +1,80 @@
+if JsonVersion.table_exists?
+
+  require 'rails_helper'
+
+  describe JsonVersion, :type => :model do
+    it "should include the `VersionConcern` module to get base functionality" do
+      expect(JsonVersion).to include(PaperTrail::VersionConcern)
+    end
+
+    describe "Methods" do
+      describe "Class" do
+
+        describe '#where_object' do
+          it { expect(JsonVersion).to respond_to(:where_object) }
+
+          context "invalid arguments" do
+            it "should raise an error" do
+              expect { JsonVersion.where_object(:foo) }.to raise_error(ArgumentError)
+              expect { JsonVersion.where_object([]) }.to raise_error(ArgumentError)
+            end
+          end
+
+          context "valid arguments", :versioning => true do
+            let(:fruit_names) { %w(apple orange lemon banana lime coconut strawberry blueberry) }
+            let(:fruit) { Fruit.new }
+            let(:name) { 'pomegranate' }
+            let(:color) { Faker::Color.name }
+
+            before do
+              fruit.update_attributes!(:name => name)
+              fruit.update_attributes!(:name => fruit_names.sample, :color => color)
+              fruit.update_attributes!(:name => fruit_names.sample, :color => Faker::Color.name)
+            end
+
+            it "should be able to locate versions according to their `object` contents" do
+              expect(JsonVersion.where_object(:name => name)).to eq([fruit.versions[1]])
+              expect(JsonVersion.where_object(:color => color)).to eq([fruit.versions[2]])
+            end
+          end
+        end
+
+        describe '#where_object_changes' do
+          it { expect(JsonVersion).to respond_to(:where_object_changes) }
+
+          context "invalid arguments" do
+            it "should raise an error" do
+              expect { JsonVersion.where_object_changes(:foo) }.to raise_error(ArgumentError)
+              expect { JsonVersion.where_object_changes([]) }.to raise_error(ArgumentError)
+            end
+          end
+
+          context "valid arguments", :versioning => true do
+            let(:fruit_names) { %w(apple orange lemon banana lime strawberry blueberry) }
+            let(:tropical_fruit_names) { %w(coconut pineapple kiwi mango melon) }
+            let(:fruit) { Fruit.new }
+            let(:name) { 'pomegranate' }
+            let(:color) { Faker::Color.name }
+
+            before do
+              fruit.update_attributes!(:name => name)
+              fruit.update_attributes!(:name => tropical_fruit_names.sample, :color => color)
+              fruit.update_attributes!(:name => fruit_names.sample, :color => Faker::Color.name)
+            end
+
+            it "should be able to locate versions according to their `object_changes` contents" do
+              expect(fruit.versions.where_object_changes(:name => name)).to eq(fruit.versions[0..1])
+              expect(fruit.versions.where_object_changes(:color => color)).to eq(fruit.versions[1..2])
+            end
+
+            it "should be able to handle queries for multiple attributes" do
+              expect(fruit.versions.where_object_changes(:color => color, :name => name)).to eq([fruit.versions[1]])
+            end
+          end
+        end
+      end
+
+    end
+  end
+
+end

data/spec/models/thing_spec.rb

@@ -0,0 +1,11 @@
+require 'rails_helper'
+
+describe Thing, :type => :model do
+  it { is_expected.to be_versioned }
+
+  describe "should not store object_changes", :versioning => true do
+    let(:thing) { Thing.create(:name =>"pencil") }
+
+    it { expect(thing.versions.last.object_changes).to be_nil }
+  end
+end

data/spec/models/version_spec.rb

@@ -45,13 +45,60 @@ describe PaperTrail::Version, :type => :model do
     describe "Instance" do
       subject { PaperTrail::Version.new(attributes) rescue PaperTrail::Version.new }
 
+      describe '#paper_trail_originator' do
+        it { is_expected.to respond_to(:paper_trail_originator) }
+
+        context "No previous versions" do
+          specify { expect(subject.previous).to be_nil }
+
+          it "should return nil" do
+            expect(subject.paper_trail_originator).to be_nil
+          end
+        end
+
+        context "Has previous version", :versioning => true do
+          let(:name) { Faker::Name.name }
+          let(:widget) { Widget.create!(name: Faker::Name.name) }
+          before do
+            widget.versions.first.update_attributes!(:whodunnit => name)
+            widget.update_attributes!(name: Faker::Name.first_name)
+          end
+          subject { widget.versions.last }
+
+          specify { expect(subject.previous).to be_instance_of(PaperTrail::Version) }
+
+          it "should return nil" do
+            expect(subject.paper_trail_originator).to eq(name)
+          end
+        end
+      end
+
+      describe "#originator" do
+        it { is_expected.to respond_to(:originator) }
+        let(:warning_msg) do
+          "DEPRECATED: use `paper_trail_originator` instead of `originator`." +
+          " Support for `originator` will be removed in PaperTrail 4.0"
+        end
+
+        it 'should set the invoke `paper_trail_originator`' do
+          is_expected.to receive(:warn)
+          is_expected.to receive(:paper_trail_originator)
+          subject.originator
+        end
+
+        it 'should display a deprecation warning' do
+          is_expected.to receive(:warn).with(warning_msg)
+          subject.originator
+        end
+      end
+
       describe '#terminator' do
         it { is_expected.to respond_to(:terminator) }
 
         let(:attributes) { {:whodunnit => Faker::Name.first_name} }
 
         it "is an alias for the `whodunnit` attribute" do
-          expect(subject.whodunnit).to eq(attributes[:whodunnit])
+          expect(subject.terminator).to eq(attributes[:whodunnit])
         end
       end
 
@@ -65,100 +112,128 @@ describe PaperTrail::Version, :type => :model do
     end
 
     describe "Class" do
-      describe '#where_object' do
-        it { expect(PaperTrail::Version).to respond_to(:where_object) }
-
-        context "invalid arguments" do
-          it "should raise an error" do
-            expect { PaperTrail::Version.where_object(:foo) }.to raise_error(ArgumentError)
-            expect { PaperTrail::Version.where_object([]) }.to raise_error(ArgumentError)
-          end
-        end
-
-        context "valid arguments", :versioning => true do
-          let(:widget) { Widget.new }
-          let(:name) { Faker::Name.first_name }
-          let(:int) { rand(10) + 1 }
+      column_overrides = [false]
+      if ENV['DB'] == 'postgres' && ::ActiveRecord::VERSION::MAJOR >= 4
+        column_overrides << 'json'
+        # 'jsonb' column types are only supported for ActiveRecord 4.2+
+        column_overrides << 'jsonb' if ::ActiveRecord::VERSION::STRING >= '4.2'
+      end
 
+      column_overrides.shuffle.each do |override|
+        context "with a #{override || 'text'} column" do
           before do
-            widget.update_attributes!(:name => name, :an_integer => int)
-            widget.update_attributes!(:name => 'foobar', :an_integer => 100)
-            widget.update_attributes!(:name => Faker::Name.last_name, :an_integer => 15)
-          end
-
-          context "`serializer == YAML`" do
-            specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
-
-            it "should be able to locate versions according to their `object` contents" do
-              expect(PaperTrail::Version.where_object(:name => name)).to eq([widget.versions[1]])
-              expect(PaperTrail::Version.where_object(:an_integer => 100)).to eq([widget.versions[2]])
+            if override
+              ActiveRecord::Base.connection.execute("SAVEPOINT pgtest;")
+              %w[object object_changes].each do |column|
+                ActiveRecord::Base.connection.execute("ALTER TABLE versions DROP COLUMN #{column};")
+                ActiveRecord::Base.connection.execute("ALTER TABLE versions ADD COLUMN #{column} #{override};")
+              end
+              PaperTrail::Version.reset_column_information
             end
           end
-
-          context "`serializer == JSON`" do
-            before(:all) { PaperTrail.serializer = PaperTrail::Serializers::JSON }
-            specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON }
-
-            it "should be able to locate versions according to their `object` contents" do
-              expect(PaperTrail::Version.where_object(:name => name)).to eq([widget.versions[1]])
-              expect(PaperTrail::Version.where_object(:an_integer => 100)).to eq([widget.versions[2]])
+          after do
+            if override
+              ActiveRecord::Base.connection.execute("ROLLBACK TO SAVEPOINT pgtest;")
+              PaperTrail::Version.reset_column_information
             end
-
-            after(:all) { PaperTrail.serializer = PaperTrail::Serializers::YAML }
           end
-        end
-      end
-
-      describe '#where_object_changes' do
-        it { expect(PaperTrail::Version).to respond_to(:where_object_changes) }
-
-        context "invalid arguments" do
-          it "should raise an error" do
-            expect { PaperTrail::Version.where_object_changes(:foo) }.to raise_error(ArgumentError)
-            expect { PaperTrail::Version.where_object_changes([]) }.to raise_error(ArgumentError)
-          end
-        end
 
-        context "valid arguments", :versioning => true do
-          let(:widget) { Widget.new }
-          let(:name) { Faker::Name.first_name }
-          let(:int) { rand(5) + 2 }
+          describe '#where_object' do
+            it { expect(PaperTrail::Version).to respond_to(:where_object) }
 
-          before do
-            widget.update_attributes!(:name => name, :an_integer => 0)
-            widget.update_attributes!(:name => 'foobar', :an_integer => 77)
-            widget.update_attributes!(:name => Faker::Name.last_name, :an_integer => int)
-          end
-
-          context "`serializer == YAML`" do
-            specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
-
-            it "should be able to locate versions according to their `object_changes` contents" do
-              expect(widget.versions.where_object_changes(:name => name)).to eq(widget.versions[0..1])
-              expect(widget.versions.where_object_changes(:an_integer => 77)).to eq(widget.versions[1..2])
-              expect(widget.versions.where_object_changes(:an_integer => int)).to eq([widget.versions.last])
+            context "invalid arguments" do
+              it "should raise an error" do
+                expect { PaperTrail::Version.where_object(:foo) }.to raise_error(ArgumentError)
+                expect { PaperTrail::Version.where_object([]) }.to raise_error(ArgumentError)
+              end
             end
 
-            it "should be able to handle queries for multiple attributes" do
-              expect(widget.versions.where_object_changes(:an_integer => 77, :name => 'foobar')).to eq(widget.versions[1..2])
+            context "valid arguments", :versioning => true do
+              let(:widget) { Widget.new }
+              let(:name) { Faker::Name.first_name }
+              let(:int) { rand(10) + 1 }
+
+              before do
+                widget.update_attributes!(:name => name, :an_integer => int)
+                widget.update_attributes!(:name => 'foobar', :an_integer => 100)
+                widget.update_attributes!(:name => Faker::Name.last_name, :an_integer => 15)
+              end
+
+              context "`serializer == YAML`" do
+                specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
+
+                it "should be able to locate versions according to their `object` contents" do
+                  expect(PaperTrail::Version.where_object(:name => name)).to eq([widget.versions[1]])
+                  expect(PaperTrail::Version.where_object(:an_integer => 100)).to eq([widget.versions[2]])
+                end
+              end
+
+              context "`serializer == JSON`" do
+                before(:all) { PaperTrail.serializer = PaperTrail::Serializers::JSON }
+                specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON }
+
+                it "should be able to locate versions according to their `object` contents" do
+                  expect(PaperTrail::Version.where_object(:name => name)).to eq([widget.versions[1]])
+                  expect(PaperTrail::Version.where_object(:an_integer => 100)).to eq([widget.versions[2]])
+                end
+
+                after(:all) { PaperTrail.serializer = PaperTrail::Serializers::YAML }
+              end
             end
           end
 
-          context "`serializer == JSON`" do
-            before(:all) { PaperTrail.serializer = PaperTrail::Serializers::JSON }
-            specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON }
+          describe '#where_object_changes' do
+            it { expect(PaperTrail::Version).to respond_to(:where_object_changes) }
 
-            it "should be able to locate versions according to their `object_changes` contents" do
-              expect(widget.versions.where_object_changes(:name => name)).to eq(widget.versions[0..1])
-              expect(widget.versions.where_object_changes(:an_integer => 77)).to eq(widget.versions[1..2])
-              expect(widget.versions.where_object_changes(:an_integer => int)).to eq([widget.versions.last])
+            context "invalid arguments" do
+              it "should raise an error" do
+                expect { PaperTrail::Version.where_object_changes(:foo) }.to raise_error(ArgumentError)
+                expect { PaperTrail::Version.where_object_changes([]) }.to raise_error(ArgumentError)
+              end
             end
 
-            it "should be able to handle queries for multiple attributes" do
-              expect(widget.versions.where_object_changes(:an_integer => 77, :name => 'foobar')).to eq(widget.versions[1..2])
+            context "valid arguments", :versioning => true do
+              let(:widget) { Widget.new }
+              let(:name) { Faker::Name.first_name }
+              let(:int) { rand(5) + 2 }
+
+              before do
+                widget.update_attributes!(:name => name, :an_integer => 0)
+                widget.update_attributes!(:name => 'foobar', :an_integer => 77)
+                widget.update_attributes!(:name => Faker::Name.last_name, :an_integer => int)
+              end
+
+              context "`serializer == YAML`" do
+                specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
+
+                it "should be able to locate versions according to their `object_changes` contents" do
+                  expect(widget.versions.where_object_changes(:name => name)).to eq(widget.versions[0..1])
+                  expect(widget.versions.where_object_changes(:an_integer => 77)).to eq(widget.versions[1..2])
+                  expect(widget.versions.where_object_changes(:an_integer => int)).to eq([widget.versions.last])
+                end
+
+                it "should be able to handle queries for multiple attributes" do
+                  expect(widget.versions.where_object_changes(:an_integer => 77, :name => 'foobar')).to eq(widget.versions[1..2])
+                end
+              end
+
+              context "`serializer == JSON`" do
+                before(:all) { PaperTrail.serializer = PaperTrail::Serializers::JSON }
+                specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON }
+
+                it "should be able to locate versions according to their `object_changes` contents" do
+                  expect(widget.versions.where_object_changes(:name => name)).to eq(widget.versions[0..1])
+                  expect(widget.versions.where_object_changes(:an_integer => 77)).to eq(widget.versions[1..2])
+                  expect(widget.versions.where_object_changes(:an_integer => int)).to eq([widget.versions.last])
+                end
+
+                it "should be able to handle queries for multiple attributes" do
+                  expect(widget.versions.where_object_changes(:an_integer => 77, :name => 'foobar')).to eq(widget.versions[1..2])
+                end
+
+                after(:all) { PaperTrail.serializer = PaperTrail::Serializers::YAML }
+              end
             end
-
-            after(:all) { PaperTrail.serializer = PaperTrail::Serializers::YAML }
           end
         end
       end