paper_trail 4.2.0 → 5.0.0

data/spec/models/joined_version_spec.rb

@@ -1,9 +1,9 @@
-require 'rails_helper'
+require "rails_helper"
 
-describe JoinedVersion, :type => :model, :versioning => true do
+describe JoinedVersion, type: :model, versioning: true do
   it { expect(JoinedVersion.superclass).to be PaperTrail::Version }
 
-  let(:widget) { Widget.create!(:name => Faker::Name.name) }
+  let(:widget) { Widget.create!(name: FFaker::Name.name) }
   let(:version) { JoinedVersion.first }
 
   describe "Scopes" do

data/spec/models/json_version_spec.rb

@@ -1,26 +1,25 @@
-require 'rails_helper'
+require "rails_helper"
 
 # The `json_versions` table tests postgres' `json` data type. So, that
 # table is only created when testing against postgres and ActiveRecord >= 4.
 if JsonVersion.table_exists?
 
-  describe JsonVersion, :type => :model do
+  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) }
 
           it "escapes values" do
-            f = Fruit.create(:name => 'Bobby')
+            f = Fruit.create(name: "Bobby")
             expect(
               f.
                 versions.
-                where_object(:name => "Robert'; DROP TABLE Students;--").
+                where_object(name: "Robert'; DROP TABLE Students;--").
                 count
             ).to eq(0)
           end
@@ -32,21 +31,21 @@ if JsonVersion.table_exists?
             end
           end
 
-          context "valid arguments", :versioning => true do
+          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 }
+            let(:name) { "pomegranate" }
+            let(:color) { FFaker::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)
+              fruit.update_attributes!(name: name)
+              fruit.update_attributes!(name: fruit_names.sample, color: color)
+              fruit.update_attributes!(name: fruit_names.sample, color: FFaker::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]])
+              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
@@ -55,11 +54,11 @@ if JsonVersion.table_exists?
           it { expect(JsonVersion).to respond_to(:where_object_changes) }
 
           it "escapes values" do
-            f = Fruit.create(:name => 'Bobby')
+            f = Fruit.create(name: "Bobby")
             expect(
               f.
                 versions.
-                where_object_changes(:name => "Robert'; DROP TABLE Students;--").
+                where_object_changes(name: "Robert'; DROP TABLE Students;--").
                 count
             ).to eq(0)
           end
@@ -71,28 +70,28 @@ if JsonVersion.table_exists?
             end
           end
 
-          context "valid arguments", :versioning => true do
-            let(:color) { %w[red green] }
-            let(:fruit) { Fruit.create!(:name => name[0]) }
-            let(:name) { %w[banana kiwi mango] }
+          context "valid arguments", versioning: true do
+            let(:color) { %w(red green) }
+            let(:fruit) { Fruit.create!(name: name[0]) }
+            let(:name) { %w(banana kiwi mango) }
 
             before do
-              fruit.update_attributes!(:name => name[1], :color => color[0])
-              fruit.update_attributes!(:name => name[2], :color => color[1])
+              fruit.update_attributes!(name: name[1], color: color[0])
+              fruit.update_attributes!(name: name[2], color: color[1])
             end
 
             it "finds versions according to their `object_changes` contents" do
               expect(
-                fruit.versions.where_object_changes(:name => name[0])
+                fruit.versions.where_object_changes(name: name[0])
               ).to match_array(fruit.versions[0..1])
               expect(
-                fruit.versions.where_object_changes(:color => color[0])
+                fruit.versions.where_object_changes(color: color[0])
               ).to match_array(fruit.versions[1..2])
             end
 
             it "finds versions with multiple attributes changed" do
               expect(
-                fruit.versions.where_object_changes(:color => color[0], :name => name[0])
+                fruit.versions.where_object_changes(color: color[0], name: name[0])
               ).to match_array([fruit.versions[1]])
             end
           end

data/spec/models/kitchen/banana_spec.rb

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

data/spec/models/not_on_update_spec.rb

@@ -1,7 +1,7 @@
-require 'rails_helper'
+require "rails_helper"
 
-describe NotOnUpdate, :type => :model do
-  describe "#touch_with_version", :versioning => true do
+describe NotOnUpdate, type: :model do
+  describe "#touch_with_version", versioning: true do
     let!(:record) { described_class.create! }
 
     it "should create a version, regardless" do
@@ -12,7 +12,10 @@ describe NotOnUpdate, :type => :model do
 
     it "increments the `:updated_at` timestamp" do
       before = record.updated_at
-      record.touch_with_version
+      # Travel 1 second because MySQL lacks sub-second resolution
+      Timecop.travel(1) do
+        record.touch_with_version
+      end
       expect(record.updated_at).to be > before
     end
   end

data/spec/models/post_with_status_spec.rb

@@ -1,17 +1,27 @@
-require 'rails_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, :type => :model do
+describe PostWithStatus, type: :model do
   if defined?(ActiveRecord::Enum)
     with_versioning do
-      let(:post) { PostWithStatus.create!(:status => 'draft') }
+      let(:post) { PostWithStatus.create!(status: "draft") }
 
       it "should stash the enum value properly in versions" do
         post.published!
         post.archived!
         expect(post.previous_version.published?).to be true
       end
+
+      context "storing enum object_changes" do
+        subject { post.versions.last }
+
+        it "should stash the enum value properly in versions object_changes" do
+          post.published!
+          post.archived!
+          expect(subject.changeset["status"]).to eql %w(published archived)
+        end
+      end
     end
   end
 end

data/spec/models/skipper_spec.rb

@@ -1,18 +1,18 @@
-require 'rails_helper'
+require "rails_helper"
 
-describe Skipper, :type => :model do
+describe Skipper, type: :model do
   with_versioning do
     it { is_expected.to be_versioned }
 
-    describe "#update_attributes!", :versioning => true do
+    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)
+          skipper = Skipper.create!(another_timestamp: t1)
           expect {
-            skipper.update_attributes!(:another_timestamp => t2)
+            skipper.update_attributes!(another_timestamp: t2)
           }.to_not change { skipper.versions.length }
         end
       end
@@ -25,8 +25,8 @@ describe Skipper, :type => :model do
 
         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.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
@@ -34,9 +34,9 @@ describe Skipper, :type => :model do
 
         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)
+            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

data/spec/models/thing_spec.rb

@@ -1,10 +1,10 @@
-require 'rails_helper'
+require "rails_helper"
 
-describe Thing, :type => :model do
+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") }
+  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

data/spec/models/truck_spec.rb

@@ -0,0 +1,5 @@
+require "rails_helper"
+
+describe Truck, type: :model do
+  it { is_expected.to_not be_versioned }
+end

data/spec/models/vehicle_spec.rb

@@ -0,0 +1,5 @@
+require "rails_helper"
+
+describe Vehicle, type: :model do
+  it { is_expected.to_not be_versioned }
+end

data/spec/models/version_spec.rb

@@ -1,6 +1,6 @@
-require 'rails_helper'
+require "rails_helper"
 
-describe PaperTrail::Version, :type => :model do
+describe PaperTrail::Version, type: :model do
   it "should include the `VersionConcern` module to get base functionality" do
     expect(PaperTrail::Version).to include(PaperTrail::VersionConcern)
   end
@@ -13,8 +13,8 @@ describe PaperTrail::Version, :type => :model do
     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') }
+    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
@@ -43,7 +43,7 @@ describe PaperTrail::Version, :type => :model do
 
   describe "Methods" do
     describe "Instance" do
-      subject { PaperTrail::Version.new(attributes) rescue PaperTrail::Version.new }
+      subject { PaperTrail::Version.new }
 
       describe '#paper_trail_originator' do
         it { is_expected.to respond_to(:paper_trail_originator) }
@@ -56,12 +56,12 @@ describe PaperTrail::Version, :type => :model do
           end
         end
 
-        context "Has previous version", :versioning => true do
-          let(:name) { Faker::Name.name }
-          let(:widget) { Widget.create!(:name => Faker::Name.name) }
+        context "Has previous version", versioning: true do
+          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 => Faker::Name.first_name)
+            widget.versions.first.update_attributes!(whodunnit: name)
+            widget.update_attributes!(name: FFaker::Name.first_name)
           end
           subject { widget.versions.last }
 
@@ -76,13 +76,13 @@ describe PaperTrail::Version, :type => :model do
       describe "#originator" do
         it { is_expected.to respond_to(:originator) }
 
-        it 'should set the invoke `paper_trail_originator`' do
+        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
+        it "should display a deprecation warning" do
           expect(ActiveSupport::Deprecation).to receive(:warn).
             with(/Use paper_trail_originator instead of originator/)
           subject.originator
@@ -90,9 +90,10 @@ describe PaperTrail::Version, :type => :model do
       end
 
       describe '#terminator' do
-        it { is_expected.to respond_to(:terminator) }
+        let(:attributes) { { whodunnit: FFaker::Name.first_name } }
+        subject { PaperTrail::Version.new attributes }
 
-        let(:attributes) { {:whodunnit => Faker::Name.first_name} }
+        it { is_expected.to respond_to(:terminator) }
 
         it "is an alias for the `whodunnit` attribute" do
           expect(subject.terminator).to eq(attributes[:whodunnit])
@@ -110,10 +111,10 @@ describe PaperTrail::Version, :type => :model do
 
     describe "Class" do
       column_overrides = [false]
-      if ENV['DB'] == 'postgres' && ::ActiveRecord::VERSION::MAJOR >= 4
-        column_overrides << 'json'
+      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'
+        column_overrides << "jsonb" if ::ActiveRecord::VERSION::STRING >= "4.2"
       end
 
       column_overrides.shuffle.each do |override|
@@ -121,9 +122,13 @@ describe PaperTrail::Version, :type => :model 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};")
+              %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
@@ -140,92 +145,131 @@ describe PaperTrail::Version, :type => :model do
 
             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)
+                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
+            context "valid arguments", versioning: true do
               let(:widget) { Widget.new }
-              let(:name) { Faker::Name.first_name }
+              let(:name) { FFaker::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)
+                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
 
               context "`serializer == YAML`" do
-                specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
+                specify do
+                  expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML
+                end
 
                 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]])
+                  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 }
+              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 "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]])
+                  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 }
+                after(:all) do
+                  PaperTrail.serializer = PaperTrail::Serializers::YAML
+                end
               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)
+                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
+            context "valid arguments", versioning: true do
               let(:widget) { Widget.new }
-              let(:name) { Faker::Name.first_name }
+              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 => Faker::Name.last_name, :an_integer => int)
+                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
 
-              context "`serializer == YAML`" do
+              context "YAML serializer" 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])
+                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 "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])
+                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
 
-              context "`serializer == JSON`" do
+              context "JSON serializer" 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])
+                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 "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])
+                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 }