paper_trail 7.0.0 → 7.0.1

data/spec/models/callback_modifier_spec.rb

@@ -1,96 +1,92 @@
 require "rails_helper"
 
-describe CallbackModifier, type: :model do
-  with_versioning do
-    describe "callback-methods", versioning: true do
-      describe "paper_trail_on_destroy" do
-        it "adds :destroy to paper_trail_options[:on]" do
-          modifier = NoArgDestroyModifier.create!(some_content: FFaker::Lorem.sentence)
-          expect(modifier.paper_trail_options[:on]).to eq [:destroy]
-        end
+RSpec.describe CallbackModifier, type: :model, versioning: true do
+  describe "paper_trail_on_destroy" do
+    it "adds :destroy to paper_trail_options[:on]" do
+      modifier = NoArgDestroyModifier.create!(some_content: FFaker::Lorem.sentence)
+      expect(modifier.paper_trail_options[:on]).to eq([:destroy])
+    end
 
-        context "when :before" do
-          it "creates the version before destroy" do
-            modifier = BeforeDestroyModifier.create!(some_content: FFaker::Lorem.sentence)
-            modifier.test_destroy
-            expect(modifier.versions.last.reify).not_to be_flagged_deleted
-          end
-        end
+    context "when :before" do
+      it "creates the version before destroy" do
+        modifier = BeforeDestroyModifier.create!(some_content: FFaker::Lorem.sentence)
+        modifier.test_destroy
+        expect(modifier.versions.last.reify).not_to be_flagged_deleted
+      end
+    end
 
-        context "when :after" do
-          it "creates the version after destroy" do
-            modifier = AfterDestroyModifier.create!(some_content: FFaker::Lorem.sentence)
-            modifier.test_destroy
-            expect(modifier.versions.last.reify).to be_flagged_deleted
-          end
-        end
+    context "when :after" do
+      it "creates the version after destroy" do
+        modifier = AfterDestroyModifier.create!(some_content: FFaker::Lorem.sentence)
+        modifier.test_destroy
+        expect(modifier.versions.last.reify).to be_flagged_deleted
+      end
+    end
 
-        context "when no argument" do
-          it "defaults to before destroy" do
-            modifier = NoArgDestroyModifier.create!(some_content: FFaker::Lorem.sentence)
-            modifier.test_destroy
-            expect(modifier.versions.last.reify).not_to be_flagged_deleted
-          end
-        end
+    context "when no argument" do
+      it "defaults to before destroy" do
+        modifier = NoArgDestroyModifier.create!(some_content: FFaker::Lorem.sentence)
+        modifier.test_destroy
+        expect(modifier.versions.last.reify).not_to be_flagged_deleted
       end
+    end
+  end
 
-      describe "paper_trail_on_update" do
-        it "adds :update to paper_trail_options[:on]" do
-          modifier = UpdateModifier.create!(some_content: FFaker::Lorem.sentence)
-          expect(modifier.paper_trail_options[:on]).to eq [:update]
-        end
+  describe "paper_trail_on_update" do
+    it "adds :update to paper_trail_options[:on]" do
+      modifier = UpdateModifier.create!(some_content: FFaker::Lorem.sentence)
+      expect(modifier.paper_trail_options[:on]).to eq [:update]
+    end
 
-        it "creates a version" do
-          modifier = UpdateModifier.create!(some_content: FFaker::Lorem.sentence)
-          modifier.update_attributes! some_content: "modified"
-          expect(modifier.versions.last.event).to eq "update"
-        end
-      end
+    it "creates a version" do
+      modifier = UpdateModifier.create!(some_content: FFaker::Lorem.sentence)
+      modifier.update_attributes! some_content: "modified"
+      expect(modifier.versions.last.event).to eq "update"
+    end
+  end
 
-      describe "paper_trail_on_create" do
-        it "adds :create to paper_trail_options[:on]" do
-          modifier = CreateModifier.create!(some_content: FFaker::Lorem.sentence)
-          expect(modifier.paper_trail_options[:on]).to eq [:create]
-        end
+  describe "paper_trail_on_create" do
+    it "adds :create to paper_trail_options[:on]" do
+      modifier = CreateModifier.create!(some_content: FFaker::Lorem.sentence)
+      expect(modifier.paper_trail_options[:on]).to eq [:create]
+    end
 
-        it "creates a version" do
-          modifier = CreateModifier.create!(some_content: FFaker::Lorem.sentence)
-          expect(modifier.versions.last.event).to eq "create"
-        end
-      end
+    it "creates a version" do
+      modifier = CreateModifier.create!(some_content: FFaker::Lorem.sentence)
+      expect(modifier.versions.last.event).to eq "create"
+    end
+  end
 
-      context "when no callback-method used" do
-        it "sets paper_trail_options[:on] to [:create, :update, :destroy]" do
-          modifier = DefaultModifier.create!(some_content: FFaker::Lorem.sentence)
-          expect(modifier.paper_trail_options[:on]).to eq %i(create update destroy)
-        end
+  context "when no callback-method used" do
+    it "sets paper_trail_options[:on] to [:create, :update, :destroy]" do
+      modifier = DefaultModifier.create!(some_content: FFaker::Lorem.sentence)
+      expect(modifier.paper_trail_options[:on]).to eq %i(create update destroy)
+    end
 
-        it "tracks destroy" do
-          modifier = DefaultModifier.create!(some_content: FFaker::Lorem.sentence)
-          modifier.destroy
-          expect(modifier.versions.last.event).to eq "destroy"
-        end
+    it "tracks destroy" do
+      modifier = DefaultModifier.create!(some_content: FFaker::Lorem.sentence)
+      modifier.destroy
+      expect(modifier.versions.last.event).to eq "destroy"
+    end
 
-        it "tracks update" do
-          modifier = DefaultModifier.create!(some_content: FFaker::Lorem.sentence)
-          modifier.update_attributes! some_content: "modified"
-          expect(modifier.versions.last.event).to eq "update"
-        end
+    it "tracks update" do
+      modifier = DefaultModifier.create!(some_content: FFaker::Lorem.sentence)
+      modifier.update_attributes! some_content: "modified"
+      expect(modifier.versions.last.event).to eq "update"
+    end
 
-        it "tracks create" do
-          modifier = DefaultModifier.create!(some_content: FFaker::Lorem.sentence)
-          expect(modifier.versions.last.event).to eq "create"
-        end
-      end
+    it "tracks create" do
+      modifier = DefaultModifier.create!(some_content: FFaker::Lorem.sentence)
+      expect(modifier.versions.last.event).to eq "create"
+    end
+  end
 
-      context "when only one callback-method" do
-        it "does only track the corresponding event" do
-          modifier = CreateModifier.create!(some_content: FFaker::Lorem.sentence)
-          modifier.update_attributes!(some_content: "modified")
-          modifier.test_destroy
-          expect(modifier.versions.collect(&:event)).to eq ["create"]
-        end
-      end
+  context "when only one callback-method" do
+    it "does only track the corresponding event" do
+      modifier = CreateModifier.create!(some_content: FFaker::Lorem.sentence)
+      modifier.update_attributes!(some_content: "modified")
+      modifier.test_destroy
+      expect(modifier.versions.collect(&:event)).to eq ["create"]
     end
   end
 end

data/spec/models/gadget_spec.rb

@@ -23,41 +23,40 @@ describe Gadget, type: :model do
   end
 
   describe "#changed_notably?", versioning: true do
-    subject { Gadget.new(created_at: Time.now) }
-
-    context "create events" do
+    context "new record" do
       it "returns true" do
-        expect(subject.paper_trail.changed_notably?).to eq(true)
+        g = Gadget.new(created_at: Time.now)
+        expect(g.paper_trail.changed_notably?).to eq(true)
       end
     end
 
-    context "update events" do
-      before { subject.save! }
-
-      context "without update timestamps" do
-        it "only acknowledges non-ignored attrs" do
-          subject.name = "Wrench"
-          expect(subject.paper_trail.changed_notably?).to be true
-        end
+    context "persisted record without update timestamps" do
+      it "only acknowledges non-ignored attrs" do
+        subject = Gadget.create!(created_at: Time.now)
+        subject.name = "Wrench"
+        expect(subject.paper_trail.changed_notably?).to be true
+      end
 
-        it "does not acknowledge ignored attr (brand)" do
-          subject.brand = "Acme"
-          expect(subject.paper_trail.changed_notably?).to be false
-        end
+      it "does not acknowledge ignored attr (brand)" do
+        subject = Gadget.create!(created_at: Time.now)
+        subject.brand = "Acme"
+        expect(subject.paper_trail.changed_notably?).to be false
       end
+    end
 
-      context "with update timestamps" do
-        it "only acknowledges non-ignored attrs" do
-          subject.name = "Wrench"
-          subject.updated_at = Time.now
-          expect(subject.paper_trail.changed_notably?).to be true
-        end
+    context "persisted record with update timestamps" do
+      it "only acknowledges non-ignored attrs" do
+        subject = Gadget.create!(created_at: Time.now)
+        subject.name = "Wrench"
+        subject.updated_at = Time.now
+        expect(subject.paper_trail.changed_notably?).to be true
+      end
 
-        it "does not acknowledge ignored attrs and timestamps only" do
-          subject.brand = "Acme"
-          subject.updated_at = Time.now
-          expect(subject.paper_trail.changed_notably?).to be false
-        end
+      it "does not acknowledge ignored attrs and timestamps only" do
+        subject = Gadget.create!(created_at: Time.now)
+        subject.brand = "Acme"
+        subject.updated_at = Time.now
+        expect(subject.paper_trail.changed_notably?).to be false
       end
     end
   end

data/spec/models/joined_version_spec.rb

@@ -1,47 +1,41 @@
 require "rails_helper"
 
-describe JoinedVersion, type: :model, versioning: true do
-  it { expect(JoinedVersion.superclass).to be PaperTrail::Version }
-
+RSpec.describe JoinedVersion, type: :model, versioning: true do
   let(:widget) { Widget.create!(name: FFaker::Name.name) }
   let(:version) { JoinedVersion.first }
 
-  describe "Scopes" do
-    describe "default_scope" do
-      it { expect(JoinedVersion.default_scopes).not_to be_empty }
-    end
+  describe "default_scope" do
+    it { expect(JoinedVersion.default_scopes).not_to be_empty }
+  end
 
-    describe "VersionConcern::ClassMethods" do
-      before { widget } # persist a widget
+  describe "VersionConcern::ClassMethods" do
+    before { widget } # persist a widget
 
-      describe "#subsequent" do
-        it "does not raise error when there is a default_scope that joins" do
-          JoinedVersion.subsequent(version).first
-        end
+    describe "#subsequent" do
+      it "does not raise error when there is a default_scope that joins" do
+        JoinedVersion.subsequent(version).first
       end
+    end
 
-      describe "#preceding" do
-        it "does not raise error when there is a default scope that joins" do
-          JoinedVersion.preceding(version).first
-        end
+    describe "#preceding" do
+      it "does not raise error when there is a default scope that joins" do
+        JoinedVersion.preceding(version).first
       end
+    end
 
-      describe "#between" do
-        it "does not raise error when there is a default scope that joins" do
-          JoinedVersion.between(Time.now, 1.minute.from_now).first
-        end
+    describe "#between" do
+      it "does not raise error when there is a default scope that joins" do
+        JoinedVersion.between(Time.now, 1.minute.from_now).first
       end
     end
   end
 
-  describe "Methods" do
-    describe "#index" do
-      it { is_expected.to respond_to(:index) }
+  describe "#index" do
+    it { is_expected.to respond_to(:index) }
 
-      it "does not raise error when there is a default scope that joins" do
-        widget # persist a widget
-        version.index
-      end
+    it "does not raise error when there is a default scope that joins" do
+      widget # persist a widget
+      version.index
     end
   end
 end

data/spec/models/skipper_spec.rb

@@ -1,45 +1,41 @@
 require "rails_helper"
 
-describe Skipper, type: :model do
-  with_versioning do
-    it { is_expected.to be_versioned }
+RSpec.describe Skipper, type: :model, versioning: true do
+  it { is_expected.to be_versioned }
 
-    describe "#update_attributes!", versioning: true do
-      context "updating a skipped attribute" do
-        let(:t1) { Time.zone.local(2015, 7, 15, 20, 34, 0) }
-        let(:t2) { Time.zone.local(2015, 7, 15, 20, 34, 30) }
+  describe "#update_attributes!", versioning: true do
+    context "updating a skipped attribute" do
+      let(:t1) { Time.zone.local(2015, 7, 15, 20, 34, 0) }
+      let(:t2) { Time.zone.local(2015, 7, 15, 20, 34, 30) }
 
-        it "does not create a version" do
-          skipper = Skipper.create!(another_timestamp: t1)
-          expect {
-            skipper.update_attributes!(another_timestamp: t2)
-          }.not_to(change { skipper.versions.length })
-        end
+      it "does not create a version" do
+        skipper = Skipper.create!(another_timestamp: t1)
+        expect {
+          skipper.update_attributes!(another_timestamp: t2)
+        }.not_to(change { skipper.versions.length })
       end
     end
+  end
 
-    describe "reify" do
-      context "reifying a with a skipped attribute" do
-        let(:t1) { Time.zone.local(2015, 7, 15, 20, 34, 0) }
-        let(:t2) { Time.zone.local(2015, 7, 15, 20, 34, 30) }
+  describe "#reify" do
+    let(:t1) { Time.zone.local(2015, 7, 15, 20, 34, 0) }
+    let(:t2) { Time.zone.local(2015, 7, 15, 20, 34, 30) }
 
-        context "without preserve (default)" do
-          it "has no timestamp" do
-            skipper = Skipper.create!(another_timestamp: t1)
-            skipper.update_attributes!(another_timestamp: t2, name: "Foobar")
-            skipper = skipper.versions.last.reify
-            expect(skipper.another_timestamp).to be(nil)
-          end
-        end
+    context "without preserve (default)" do
+      it "has no timestamp" do
+        skipper = Skipper.create!(another_timestamp: t1)
+        skipper.update_attributes!(another_timestamp: t2, name: "Foobar")
+        skipper = skipper.versions.last.reify
+        expect(skipper.another_timestamp).to be(nil)
+      end
+    end
 
-        context "with preserve" do
-          it "preserves its timestamp" do
-            skipper = Skipper.create!(another_timestamp: t1)
-            skipper.update_attributes!(another_timestamp: t2, name: "Foobar")
-            skipper = skipper.versions.last.reify(unversioned_attributes: :preserve)
-            expect(skipper.another_timestamp).to eq(t2)
-          end
-        end
+    context "with preserve" do
+      it "preserves its timestamp" do
+        skipper = Skipper.create!(another_timestamp: t1)
+        skipper.update_attributes!(another_timestamp: t2, name: "Foobar")
+        skipper = skipper.versions.last.reify(unversioned_attributes: :preserve)
+        expect(skipper.another_timestamp).to eq(t2)
       end
     end
   end

data/spec/models/version_spec.rb

@@ -1,11 +1,7 @@
 require "rails_helper"
 
-describe PaperTrail::Version, type: :model do
-  it "includes the VersionConcern module" do
-    expect(PaperTrail::Version).to include(PaperTrail::VersionConcern)
-  end
-
-  describe "Attributes" do
+module PaperTrail
+  describe Version, type: :model do
     describe "object_changes column", versioning: true do
       let(:widget) { Widget.create!(name: "Dashboard") }
       let(:value) { widget.versions.last.object_changes }
@@ -28,226 +24,231 @@ describe PaperTrail::Version, type: :model do
         after(:all) { PaperTrail.serializer = PaperTrail::Serializers::YAML }
       end
     end
-  end
 
-  describe "Methods" do
-    describe "Instance" do
-      subject { PaperTrail::Version.new }
-
-      describe "#paper_trail_originator" do
-        context "No previous versions" do
-          specify { expect(subject.previous).to be_nil }
-
-          it "return nil" do
-            expect(subject.paper_trail_originator).to be_nil
-          end
+    describe "#paper_trail_originator" do
+      context "no previous versions" do
+        it "returns nil" do
+          expect(PaperTrail::Version.new.paper_trail_originator).to be_nil
         end
+      end
 
-        context "Has previous version", versioning: true do
-          subject { widget.versions.last }
-
-          let(:name) { FFaker::Name.name }
-          let(:widget) { Widget.create!(name: FFaker::Name.name) }
-
-          before do
-            widget.versions.first.update_attributes!(whodunnit: name)
-            widget.update_attributes!(name: FFaker::Name.first_name)
-          end
-
-          specify { expect(subject.previous).to be_instance_of(PaperTrail::Version) }
-
-          it "return nil" do
-            expect(subject.paper_trail_originator).to eq(name)
-          end
+      context "has previous version", versioning: true do
+        it "returns name of whodunnit" do
+          name = FFaker::Name.name
+          widget = Widget.create!(name: FFaker::Name.name)
+          widget.versions.first.update_attributes!(whodunnit: name)
+          widget.update_attributes!(name: FFaker::Name.first_name)
+          expect(widget.versions.last.paper_trail_originator).to eq(name)
         end
       end
+    end
 
-      describe "#originator" do
-        it "sets the invoke `paper_trail_originator`" do
-          allow(ActiveSupport::Deprecation).to receive(:warn)
-          is_expected.to receive(:paper_trail_originator)
-          subject.originator
+    describe "#previous" do
+      context "no previous versions" do
+        it "returns nil" do
+          expect(PaperTrail::Version.new.previous).to be_nil
         end
+      end
 
-        it "displays a deprecation warning" do
-          expect(ActiveSupport::Deprecation).to receive(:warn).
-            with(/Use paper_trail_originator instead of originator/)
-          subject.originator
+      context "has previous version", versioning: true do
+        it "returns a PaperTrail::Version" do
+          name = FFaker::Name.name
+          widget = Widget.create!(name: FFaker::Name.name)
+          widget.versions.first.update_attributes!(whodunnit: name)
+          widget.update_attributes!(name: FFaker::Name.first_name)
+          expect(widget.versions.last.previous).to be_instance_of(PaperTrail::Version)
         end
       end
+    end
 
-      describe "#terminator" do
-        subject { PaperTrail::Version.new attributes }
-
-        let(:attributes) { { whodunnit: FFaker::Name.first_name } }
-
-        it "is an alias for the `whodunnit` attribute" do
-          expect(subject.terminator).to eq(attributes[:whodunnit])
-        end
+    describe "#originator" do
+      it "sets the invoke `paper_trail_originator`" do
+        allow(ActiveSupport::Deprecation).to receive(:warn)
+        subject = PaperTrail::Version.new
+        expect(subject).to receive(:paper_trail_originator)
+        subject.originator
       end
 
-      describe "#version_author" do
-        it "is an alias for the `terminator` method" do
-          expect(subject.method(:version_author)).to eq(subject.method(:terminator))
-        end
+      it "displays a deprecation warning" do
+        expect(ActiveSupport::Deprecation).to receive(:warn).
+          with(/Use paper_trail_originator instead of originator/)
+        subject = PaperTrail::Version.new
+        subject.originator
       end
     end
 
-    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"
+    describe "#terminator" do
+      it "is an alias for the `whodunnit` attribute" do
+        attributes = { whodunnit: FFaker::Name.first_name }
+        subject = PaperTrail::Version.new(attributes)
+        expect(subject.terminator).to eq(attributes[:whodunnit])
+      end
     end
 
-    column_overrides.shuffle.each do |override|
-      context "with a #{override || 'text'} column" do
-        before do
-          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
-
-        after do
-          if override
-            ActiveRecord::Base.connection.execute("ROLLBACK TO SAVEPOINT pgtest;")
-            PaperTrail::Version.reset_column_information
-          end
-        end
+    describe "#version_author" do
+      it "is an alias for the `terminator` method" do
+        subject = PaperTrail::Version.new
+        expect(subject.method(:version_author)).to eq(subject.method(:terminator))
+      end
+    end
 
-        describe "#where_object", versioning: true do
-          let(:widget) { Widget.new }
-          let(:name) { FFaker::Name.first_name }
-          let(:int) { rand(10) + 1 }
+    describe "Methods" do
+      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: FFaker::Name.last_name, an_integer: 15)
-          end
-
-          it "requires its argument to be a Hash" do
-            expect {
-              PaperTrail::Version.where_object(:foo)
-            }.to raise_error(ArgumentError)
-            expect {
-              PaperTrail::Version.where_object([])
-            }.to raise_error(ArgumentError)
-          end
-
-          context "`serializer == YAML`" do
-            specify do
-              expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML
+            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
 
-            it "locates 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
           end
 
-          context "JSON serializer" do
-            before(:all) do
-              PaperTrail.serializer = PaperTrail::Serializers::JSON
-            end
+          describe "#where_object", versioning: true do
+            let(:widget) { Widget.new }
+            let(:name) { FFaker::Name.first_name }
+            let(:int) { rand(10) + 1 }
 
-            specify do
-              expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON
+            before do
+              widget.update_attributes!(name: name, an_integer: int)
+              widget.update_attributes!(name: "foobar", an_integer: 100)
+              widget.update_attributes!(name: FFaker::Name.last_name, an_integer: 15)
             end
 
-            it "locates 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]])
+            it "requires its argument to be a Hash" do
+              expect {
+                PaperTrail::Version.where_object(:foo)
+              }.to raise_error(ArgumentError)
+              expect {
+                PaperTrail::Version.where_object([])
+              }.to raise_error(ArgumentError)
             end
 
-            after(:all) do
-              PaperTrail.serializer = PaperTrail::Serializers::YAML
+            context "`serializer == YAML`" do
+              specify do
+                expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML
+              end
+
+              it "locates 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
-          end
-        end
-
-        describe "#where_object_changes", versioning: true do
-          let(:widget) { Widget.new }
-          let(:name) { FFaker::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: FFaker::Name.last_name, an_integer: int)
+            context "JSON serializer" do
+              before(:all) do
+                PaperTrail.serializer = PaperTrail::Serializers::JSON
+              end
+
+              specify do
+                expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON
+              end
+
+              it "locates 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) do
+                PaperTrail.serializer = PaperTrail::Serializers::YAML
+              end
+            end
           end
 
-          it "requires its argument to be a Hash" do
-            expect {
-              PaperTrail::Version.where_object_changes(:foo)
-            }.to raise_error(ArgumentError)
-            expect {
-              PaperTrail::Version.where_object_changes([])
-            }.to raise_error(ArgumentError)
-          end
+          describe "#where_object_changes", versioning: true do
+            let(:widget) { Widget.new }
+            let(:name) { FFaker::Name.first_name }
+            let(:int) { rand(5) + 2 }
 
-          context "YAML serializer" do
-            specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
-
-            it "locates 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])
+            before do
+              widget.update_attributes!(name: name, an_integer: 0)
+              widget.update_attributes!(name: "foobar", an_integer: 77)
+              widget.update_attributes!(name: FFaker::Name.last_name, an_integer: int)
             end
 
-            it "handles queries for multiple attributes" do
-              expect(
-                widget.versions.where_object_changes(an_integer: 77, name: "foobar")
-              ).to eq(widget.versions[1..2])
+            it "requires its argument to be a Hash" 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 "JSON serializer" do
-            before(:all) { PaperTrail.serializer = PaperTrail::Serializers::JSON }
-            specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON }
-
-            it "locates 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 "YAML serializer" do
+              specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
+
+              it "locates 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 "handles queries for multiple attributes" do
+                expect(
+                  widget.versions.where_object_changes(an_integer: 77, name: "foobar")
+                ).to eq(widget.versions[1..2])
+              end
             end
 
-            it "handles queries for multiple attributes" do
-              expect(
-                widget.versions.where_object_changes(an_integer: 77, name: "foobar")
-              ).to eq(widget.versions[1..2])
+            context "JSON serializer" do
+              before(:all) { PaperTrail.serializer = PaperTrail::Serializers::JSON }
+              specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON }
+
+              it "locates 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 "handles 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
-
-            after(:all) { PaperTrail.serializer = PaperTrail::Serializers::YAML }
           end
         end
       end