paper_trail 3.0.9 → 4.0.0.beta1

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/version_spec.rb

@@ -1,96 +1,72 @@
-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 '#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 { should respond_to(:terminator) }
+        it { is_expected.to respond_to(:terminator) }
 
         let(:attributes) { {:whodunnit => Faker::Name.first_name} }
 
         it "is an alias for the `whodunnit` attribute" do
-          subject.terminator.should == attributes[:whodunnit]
+          expect(subject.whodunnit).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) }
+      describe '#where_object' do
+        it { expect(PaperTrail::Version).to respond_to(:where_object) }
 
         context "invalid arguments" do
           it "should raise an error" do
@@ -111,22 +87,24 @@ describe PaperTrail::Version do
           end
 
           context "`serializer == YAML`" do
-            specify { PaperTrail.serializer == PaperTrail::Serializers::YAML }
+            specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
 
             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]]
+              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 { PaperTrail.serializer = PaperTrail::Serializers::JSON }
-            specify { PaperTrail.serializer == PaperTrail::Serializers::JSON }
+            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
-              PaperTrail::Version.where_object(:name => name).should == [widget.versions[1]]
-              PaperTrail::Version.where_object(:an_integer => 100).should == [widget.versions[2]]
+              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

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 `created_at`" do
+        expect(widget.versions.last.created_at.to_i).to eq(widget.created_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 '#paper_trail_originator' do
-        it { should respond_to(:paper_trail_originator) }
+      describe '#originator' do
+        it { is_expected.to respond_to(: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.paper_trail_originator.should == orig_name
+              expect(widget.originator).to eq(orig_name)
               widget.whodunnit(new_name) { |w| w.update_attributes(:name => 'Elizabeth') }
-              widget.paper_trail_originator.should == new_name
+              expect(widget.originator).to eq(new_name)
             end
           end
 
@@ -96,38 +145,36 @@ 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.paper_trail_originator.should == orig_name
-            end
-          end
-        end
-      end
+            context "default behavior (no `options[:dup]` option passed in)" do
+              let(:reified_widget) { widget.versions[1].reify }
 
-      describe "#originator" do
-        subject { widget }
+              it "should return the appropriate originator" do
+                expect(reified_widget.originator).to eq(orig_name)
+              end
 
-        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 not create a new model instance" do
+                expect(reified_widget).not_to be_new_record
+              end
+            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
+            context "creating a new instance (`options[:dup] == true`)" do
+              let(:reified_widget) { widget.versions[1].reify(:dup => true) }
 
-        it 'should display a deprecation warning' do
-          is_expected.to receive(:warn).with(warning_msg)
-          subject.originator
+              it "should return the appropriate originator" do
+                expect(reified_widget.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) }
+        it { is_expected.to respond_to(:version_at) }
 
         context "Timestamp argument is AFTER object has been destroyed" do
           before do
@@ -136,13 +183,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
@@ -156,44 +203,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
           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
           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
@@ -201,56 +248,62 @@ 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 { expect(subject.paper_trail_enabled_for_model?).to be true }
+      end
+
+      describe '#paper_trail_off!' do
+        it { is_expected.to respond_to(:paper_trail_off!) }
 
         it 'should set the `paper_trail_enabled_for_model?` to `false`' do
-          subject.paper_trail_enabled_for_model?.should == true
+          expect(subject.paper_trail_enabled_for_model?).to be true
           subject.paper_trail_off!
-          subject.paper_trail_enabled_for_model?.should == false
+          expect(subject.paper_trail_enabled_for_model?).to be false
         end
       end
 
-      describe :paper_trail_off do
-        it { should respond_to(:paper_trail_off) }
+      describe '#paper_trail_off' do
+        it { is_expected.to respond_to(:paper_trail_off) }
 
         it 'should set the invoke `paper_trail_off!`' do
-          subject.should_receive(:warn)
-          subject.should_receive(:paper_trail_off!)
+          is_expected.to receive(:warn)
+          is_expected.to receive(:paper_trail_off!)
           subject.paper_trail_off
         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 4.0")
+          is_expected.to receive(:warn).with("DEPRECATED: use `paper_trail_on!` instead of `paper_trail_on`. Support for `paper_trail_on` will be removed in PaperTrail 4.0")
           subject.paper_trail_on
         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
+          expect(subject.paper_trail_enabled_for_model?).to be true
         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 invoke `paper_trail_on!`' do
-          subject.should_receive(:warn)
-          subject.should_receive(:paper_trail_on!)
+          is_expected.to receive(:warn)
+          is_expected.to 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 4.0")
+          is_expected.to receive(:warn).with("DEPRECATED: use `paper_trail_on!` instead of `paper_trail_on`. Support for `paper_trail_on` will be removed in PaperTrail 4.0")
           subject.paper_trail_on
         end
       end