paper_trail 3.0.6 → 4.2.0

data/spec/models/kitchen/banana_spec.rb

@@ -0,0 +1,14 @@
+require 'rails_helper'
+
+module Kitchen
+  describe Banana, :type => :model do
+    it { is_expected.to be_versioned }
+
+    describe '#versions' do
+      it "returns instances of Kitchen::BananaVersion", :versioning => true do
+        banana = described_class.create!
+        expect(banana.versions.first).to be_a(Kitchen::BananaVersion)
+      end
+    end
+  end
+end

data/spec/models/not_on_update_spec.rb

@@ -0,0 +1,19 @@
+require 'rails_helper'
+
+describe NotOnUpdate, :type => :model do
+  describe "#touch_with_version", :versioning => true do
+    let!(:record) { described_class.create! }
+
+    it "should create a version, regardless" do
+      expect { record.touch_with_version }.to change {
+        PaperTrail::Version.count
+      }.by(+1)
+    end
+
+    it "increments the `:updated_at` timestamp" do
+      before = record.updated_at
+      record.touch_with_version
+      expect(record.updated_at).to be > before
+    end
+  end
+end

data/spec/models/post_with_status_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require 'rails_helper'
 
 # This model is in the test suite soley for the purpose of testing ActiveRecord::Enum,
 # which is available in ActiveRecord4+ only
-describe PostWithStatus do
+describe PostWithStatus, :type => :model do
   if defined?(ActiveRecord::Enum)
     with_versioning do
       let(:post) { PostWithStatus.create!(:status => 'draft') }
@@ -10,7 +10,7 @@ describe PostWithStatus do
       it "should stash the enum value properly in versions" do
         post.published!
         post.archived!
-        post.previous_version.published?.should == true
+        expect(post.previous_version.published?).to be true
       end
     end
   end

data/spec/models/skipper_spec.rb

@@ -0,0 +1,46 @@
+require 'rails_helper'
+
+describe Skipper, :type => :model do
+  with_versioning 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) }
+
+        it "should not create a version" do
+          skipper = Skipper.create!(:another_timestamp => t1)
+          expect {
+            skipper.update_attributes!(:another_timestamp => t2)
+          }.to_not 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) }
+
+        context "without preserve (default)" do
+          it "should have 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 "should preserve 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
+    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

@@ -1,84 +1,235 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe PaperTrail::Version do
+describe PaperTrail::Version, :type => :model do
   it "should include the `VersionConcern` module to get base functionality" do
-    PaperTrail::Version.should include(PaperTrail::VersionConcern)
+    expect(PaperTrail::Version).to include(PaperTrail::VersionConcern)
   end
 
   describe "Attributes" do
-    it { should have_db_column(:item_type).of_type(:string) }
-    it { should have_db_column(:item_id).of_type(:integer) }
-    it { should have_db_column(:event).of_type(:string) }
-    it { should have_db_column(:whodunnit).of_type(:string) }
-    it { should have_db_column(:object).of_type(:text) }
-    it { should have_db_column(:created_at).of_type(:datetime) }
+    it { is_expected.to have_db_column(:item_type).of_type(:string) }
+    it { is_expected.to have_db_column(:item_id).of_type(:integer) }
+    it { is_expected.to have_db_column(:event).of_type(:string) }
+    it { is_expected.to have_db_column(:whodunnit).of_type(:string) }
+    it { is_expected.to have_db_column(:object).of_type(:text) }
+    it { is_expected.to have_db_column(:created_at).of_type(:datetime) }
+
+    describe "object_changes column", :versioning => true do
+      let(:widget) { Widget.create!(:name => 'Dashboard') }
+      let(:value) { widget.versions.last.object_changes }
+
+      context "serializer is YAML" do
+        specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
+
+        it "should store out as a plain hash" do
+          expect(value =~ /HashWithIndifferentAccess/).to be_nil
+        end
+      end
+
+      context "serializer is JSON" do
+        before(:all) { PaperTrail.serializer = PaperTrail::Serializers::JSON }
+
+        it "should store out as a plain hash" do
+          expect(value =~ /HashWithIndifferentAccess/).to be_nil
+        end
+
+        after(:all) { PaperTrail.serializer = PaperTrail::Serializers::YAML }
+      end
+    end
   end
 
   describe "Indexes" do
-    it { should have_db_index([:item_type, :item_id]) }
+    it { is_expected.to have_db_index([:item_type, :item_id]) }
   end
 
   describe "Methods" do
     describe "Instance" do
       subject { PaperTrail::Version.new(attributes) rescue PaperTrail::Version.new }
 
-      describe :terminator do
-        it { should respond_to(:terminator) }
+      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) }
+
+        it 'should set the invoke `paper_trail_originator`' do
+          allow(ActiveSupport::Deprecation).to receive(:warn)
+          is_expected.to receive(:paper_trail_originator)
+          subject.originator
+        end
+
+        it 'should display a deprecation warning' do
+          expect(ActiveSupport::Deprecation).to receive(:warn).
+            with(/Use paper_trail_originator instead of originator/)
+          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
-          subject.whodunnit.should == attributes[:whodunnit]
+          expect(subject.terminator).to eq(attributes[:whodunnit])
         end
       end
 
-      describe :version_author do
-        it { should respond_to(:version_author) }
+      describe '#version_author' do
+        it { is_expected.to respond_to(:version_author) }
 
         it "should be an alias for the `terminator` method" do
-          subject.method(:version_author).should == subject.method(:terminator)
+          expect(subject.method(:version_author)).to eq(subject.method(:terminator))
         end
       end
     end
 
     describe "Class" do
-      describe :where_object do
-        it { PaperTrail::Version.should 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)
+            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
 
-          context "`serializer == YAML`" do
-            specify { PaperTrail.serializer == PaperTrail::Serializers::YAML }
+          describe '#where_object' do
+            it { expect(PaperTrail::Version).to respond_to(:where_object) }
 
-            it "should be able to locate versions according to their `object` contents" do
-              PaperTrail::Version.where_object(:name => name).should == [widget.versions[1]]
-              PaperTrail::Version.where_object(:an_integer => 100).should == [widget.versions[2]]
+            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 }
+
+              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 { PaperTrail.serializer = PaperTrail::Serializers::JSON }
-            specify { PaperTrail.serializer == PaperTrail::Serializers::JSON }
+          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
 
-            it "should be able to locate versions according to their `object` contents" do
-              PaperTrail::Version.where_object(:name => name).should == [widget.versions[1]]
-              PaperTrail::Version.where_object(:an_integer => 100).should == [widget.versions[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
           end
         end

data/spec/models/widget_spec.rb

@@ -1,22 +1,36 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Widget do
+describe Widget, :type => :model do
   describe '`be_versioned` matcher' do
-    it { should be_versioned }
+    it { is_expected.to be_versioned }
   end
 
   let(:widget) { Widget.create! :name => 'Bob', :an_integer => 1 }
 
+  describe '`have_a_version_with` matcher', :versioning => true do
+    before do
+      widget.update_attributes!(:name => 'Leonard', :an_integer => 1 )
+      widget.update_attributes!(:name => 'Tom')
+      widget.update_attributes!(:name => 'Bob')
+    end
+
+    it "is possible to do assertions on versions" do
+       expect(widget).to have_a_version_with :name => 'Leonard', :an_integer => 1
+       expect(widget).to have_a_version_with :an_integer => 1
+       expect(widget).to have_a_version_with :name => 'Tom'
+    end
+  end
+
   describe "`versioning` option" do
     context :enabled, :versioning => true do
       it 'should enable versioning for models wrapped within a block' do
-        widget.versions.size.should == 1
+        expect(widget.versions.size).to eq(1)
       end
     end
 
     context '`disabled` (default)' do
       it 'should not enable versioning for models wrapped within a block not marked to used versioning' do
-        widget.versions.size.should == 0
+        expect(widget.versions.size).to eq(0)
       end
     end
   end
@@ -34,16 +48,28 @@ describe Widget do
       end
     end
 
+    describe :after_create do
+      let(:widget) { Widget.create!(:name => 'Foobar', :created_at => Time.now - 1.week) }
+
+      it "corresponding version should use the widget's `updated_at`" do
+        expect(widget.versions.last.created_at.to_i).to eq(widget.updated_at.to_i)
+      end
+    end
+
     describe :after_update do
-      before { widget.update_attributes!(:name => 'Foobar') }
+      before { widget.update_attributes!(:name => 'Foobar', :updated_at => Time.now + 1.week) }
 
       subject { widget.versions.last.reify }
 
-      it { subject.should_not be_live }
+      it { expect(subject).not_to be_live }
 
       it "should clear the `versions_association_name` virtual attribute" do
         subject.save!
-        subject.should be_live
+        expect(subject).to be_live
+      end
+
+      it "corresponding version should use the widget updated_at" do
+        expect(widget.versions.last.created_at.to_i).to eq(widget.updated_at.to_i)
       end
     end
 
@@ -53,10 +79,33 @@ describe Widget do
       end
 
       it "should assign the version into the `versions_association_name`" do
-        widget.version.should be_nil
+        expect(widget.version).to be_nil
         widget.destroy
-        widget.version.should_not be_nil
-        widget.version.should == widget.versions.last
+        expect(widget.version).not_to be_nil
+        expect(widget.version).to eq(widget.versions.last)
+      end
+    end
+
+    describe :after_rollback do
+      let(:rolled_back_name) { 'Big Moo' }
+
+      before do
+        begin
+          widget.transaction do
+            widget.update_attributes!(:name => rolled_back_name)
+            widget.update_attributes!(:name => Widget::EXCLUDED_NAME)
+          end
+        rescue ActiveRecord::RecordInvalid
+          widget.reload
+          widget.name = nil
+          widget.save
+        end
+      end
+
+      it 'does not create an event for changes that did not happen' do
+        widget.versions.map(&:changeset).each do |changeset|
+          expect(changeset.fetch('name', [])).to_not include(rolled_back_name)
+        end
       end
     end
   end
@@ -64,16 +113,16 @@ describe Widget do
   describe "Association", :versioning => true do
     describe "sort order" do
       it "should sort by the timestamp order from the `VersionConcern`" do
-        widget.versions.to_sql.should ==
-          widget.versions.reorder(PaperTrail::Version.timestamp_sort_order).to_sql
+        expect(widget.versions.to_sql).to eq(
+          widget.versions.reorder(PaperTrail::Version.timestamp_sort_order).to_sql)
       end
     end
   end
 
   describe "Methods" do
     describe "Instance", :versioning => true do
-      describe :originator do
-        it { should respond_to(:originator) }
+      describe '#paper_trail_originator' do
+        it { is_expected.to respond_to(:paper_trail_originator) }
 
         describe "return value" do
           let(:orig_name) { Faker::Name.name }
@@ -81,12 +130,12 @@ describe Widget do
           before { PaperTrail.whodunnit = orig_name }
 
           context "accessed from live model instance" do
-            specify { widget.should be_live }
+            specify { expect(widget).to be_live }
 
             it "should return the originator for the model at a given state" do
-              widget.originator.should == orig_name
+              expect(widget.paper_trail_originator).to eq(orig_name)
               widget.whodunnit(new_name) { |w| w.update_attributes(:name => 'Elizabeth') }
-              widget.originator.should == new_name
+              expect(widget.paper_trail_originator).to eq(new_name)
             end
           end
 
@@ -96,17 +145,54 @@ describe Widget do
               PaperTrail.whodunnit = new_name
               widget.update_attributes(:name => 'Elizabeth')
             end
-            let(:reified_widget) { widget.versions[1].reify }
 
-            it "should return the appropriate originator" do
-              reified_widget.originator.should == orig_name
+            context "default behavior (no `options[:dup]` option passed in)" do
+              let(:reified_widget) { widget.versions[1].reify }
+
+              it "should return the appropriate originator" do
+                expect(reified_widget.paper_trail_originator).to eq(orig_name)
+              end
+
+              it "should not create a new model instance" do
+                expect(reified_widget).not_to be_new_record
+              end
+            end
+
+            context "creating a new instance (`options[:dup] == true`)" do
+              let(:reified_widget) { widget.versions[1].reify(:dup => true) }
+
+              it "should return the appropriate originator" do
+                expect(reified_widget.paper_trail_originator).to eq(orig_name)
+              end
+
+              it "should not create a new model instance" do
+                expect(reified_widget).to be_new_record
+              end
             end
           end
         end
       end
 
-      describe :version_at do
-        it { should respond_to(:version_at) }
+      describe "#originator" do
+        subject { widget }
+
+        it { is_expected.to respond_to(:originator) }
+
+        it 'should set the invoke `paper_trail_originator`' do
+          allow(::ActiveSupport::Deprecation).to receive(:warn)
+          is_expected.to receive(:paper_trail_originator)
+          subject.originator
+        end
+
+        it 'should display a deprecation warning' do
+          expect(::ActiveSupport::Deprecation).to receive(:warn).
+            with(/Use paper_trail_originator instead of originator/)
+          subject.originator
+        end
+      end
+
+      describe '#version_at' do
+        it { is_expected.to respond_to(:version_at) }
 
         context "Timestamp argument is AFTER object has been destroyed" do
           before do
@@ -115,13 +201,13 @@ describe Widget do
           end
 
           it "should return `nil`" do
-            widget.version_at(Time.now).should be_nil
+            expect(widget.version_at(Time.now)).to be_nil
           end
         end
       end
 
-      describe :whodunnit do
-        it { should respond_to(:whodunnit) }
+      describe '#whodunnit' do
+        it { is_expected.to respond_to(:whodunnit) }
 
         context "no block given" do
           it "should raise an error" do
@@ -135,44 +221,44 @@ describe Widget do
 
           before do
             PaperTrail.whodunnit = orig_name
-            widget.versions.last.whodunnit.should == orig_name # persist `widget`
+            expect(widget.versions.last.whodunnit).to eq(orig_name) # persist `widget`
           end
 
           it "should modify value of `PaperTrail.whodunnit` while executing the block" do
             widget.whodunnit(new_name) do
-              PaperTrail.whodunnit.should == new_name
+              expect(PaperTrail.whodunnit).to eq(new_name)
               widget.update_attributes(:name => 'Elizabeth')
             end
-            widget.versions.last.whodunnit.should == new_name
+            expect(widget.versions.last.whodunnit).to eq(new_name)
           end
 
           it "should revert the value of `PaperTrail.whodunnit` to it's previous value after executing the block" do
             widget.whodunnit(new_name) { |w| w.update_attributes(:name => 'Elizabeth') }
-            PaperTrail.whodunnit.should == orig_name
+            expect(PaperTrail.whodunnit).to eq(orig_name)
           end
 
           context "error within block" do
             it "should ensure that the whodunnit value still reverts to it's previous value" do
               expect { widget.whodunnit(new_name) { raise } }.to raise_error
-              PaperTrail.whodunnit.should == orig_name
+              expect(PaperTrail.whodunnit).to eq(orig_name)
             end
           end
         end
       end
 
-      describe :touch_with_version do
-        it { should respond_to(:touch_with_version) }
+      describe '#touch_with_version' do
+        it { is_expected.to respond_to(:touch_with_version) }
 
-        it "should generate a version" do
+        it "creates a version" do
           count = widget.versions.size
           widget.touch_with_version
-          widget.versions.size.should == count + 1
+          expect(widget.versions.size).to eq(count + 1)
         end
 
-        it "should increment the `:updated_at` timestamp" do
+        it "increments the `:updated_at` timestamp" do
           time_was = widget.updated_at
           widget.touch_with_version
-          widget.updated_at.should > time_was
+          expect(widget.updated_at).to be > time_was
         end
       end
     end
@@ -180,57 +266,31 @@ describe Widget do
     describe "Class" do
       subject { Widget }
 
-      describe :paper_trail_off! do
-        it { should respond_to(:paper_trail_off!) }
+      describe "#paper_trail_enabled_for_model?" do
+        it { is_expected.to respond_to(:paper_trail_enabled_for_model?) }
 
-        it 'should set the `paper_trail_enabled_for_model?` to `false`' do
-          subject.paper_trail_enabled_for_model?.should == true
-          subject.paper_trail_off!
-          subject.paper_trail_enabled_for_model?.should == false
-        end
+        it { expect(subject.paper_trail_enabled_for_model?).to be true }
       end
 
-      describe :paper_trail_off do
-        it { should respond_to(:paper_trail_off) }
-
-        it 'should set the invoke `paper_trail_off!`' do
-          subject.should_receive(:warn)
-          subject.should_receive(:paper_trail_off!)
-          subject.paper_trail_off
-        end
+      describe '#paper_trail_off!' do
+        it { is_expected.to respond_to(:paper_trail_off!) }
 
-        it 'should display a deprecation warning' do
-          subject.should_receive(:warn).with("DEPRECATED: use `paper_trail_on!` instead of `paper_trail_on`. Support for `paper_trail_on` will be removed in PaperTrail 3.1")
-          subject.paper_trail_on
+        it 'should set the `paper_trail_enabled_for_model?` to `false`' do
+          expect(subject.paper_trail_enabled_for_model?).to be true
+          subject.paper_trail_off!
+          expect(subject.paper_trail_enabled_for_model?).to be false
         end
       end
 
-      describe :paper_trail_on! do
+      describe '#paper_trail_on!' do
         before { subject.paper_trail_off! }
 
-        it { should respond_to(:paper_trail_on!) }
+        it { is_expected.to respond_to(:paper_trail_on!) }
 
         it 'should set the `paper_trail_enabled_for_model?` to `true`' do
-          subject.paper_trail_enabled_for_model?.should == false
+          expect(subject.paper_trail_enabled_for_model?).to be false
           subject.paper_trail_on!
-          subject.paper_trail_enabled_for_model?.should == true
-        end
-      end
-
-      describe :paper_trail_on do
-        before { subject.paper_trail_off! }
-
-        it { should respond_to(:paper_trail_on) }
-
-        it 'should set the invoke `paper_trail_on!`' do
-          subject.should_receive(:warn)
-          subject.should_receive(:paper_trail_on!)
-          subject.paper_trail_on
-        end
-
-        it 'should display a deprecation warning' do
-          subject.should_receive(:warn).with("DEPRECATED: use `paper_trail_on!` instead of `paper_trail_on`. Support for `paper_trail_on` will be removed in PaperTrail 3.1")
-          subject.paper_trail_on
+          expect(subject.paper_trail_enabled_for_model?).to be true
         end
       end
     end