paper_trail 6.0.2 → 7.0.0

data/spec/models/joined_version_spec.rb

@@ -15,19 +15,19 @@ describe JoinedVersion, type: :model, versioning: true do
       before { widget } # persist a widget
 
       describe "#subsequent" do
-        it "shouldn't error out when there is a default_scope that joins" 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 "shouldn't error out when there is a default scope that joins" 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 "shouldn't error out when there is a default scope that joins" 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
@@ -38,7 +38,7 @@ describe JoinedVersion, type: :model, versioning: true do
     describe "#index" do
       it { is_expected.to respond_to(:index) }
 
-      it "shouldn't error out when there is a default scope that joins" do
+      it "does not raise error when there is a default scope that joins" do
         widget # persist a widget
         version.index
       end

data/spec/models/json_version_spec.rb

@@ -3,16 +3,15 @@ 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
-    it "should include the `VersionConcern` module to get base functionality" do
-      expect(JsonVersion).to include(PaperTrail::VersionConcern)
+  RSpec.describe JsonVersion, type: :model do
+    it "includes the VersionConcern module" do
+      expect(described_class).to include(PaperTrail::VersionConcern)
     end
 
     describe "Methods" do
       describe "Class" do
         describe "#where_object" do
-          it { expect(JsonVersion).to respond_to(:where_object) }
+          it { expect(described_class).to respond_to(:where_object) }
 
           it "escapes values" do
             f = Fruit.create(name: "Bobby")
@@ -25,9 +24,9 @@ if JsonVersion.table_exists?
           end
 
           context "invalid arguments" do
-            it "should raise an error" do
-              expect { JsonVersion.where_object(:foo) }.to raise_error(ArgumentError)
-              expect { JsonVersion.where_object([]) }.to raise_error(ArgumentError)
+            it "raises an error" do
+              expect { described_class.where_object(:foo) }.to raise_error(ArgumentError)
+              expect { described_class.where_object([]) }.to raise_error(ArgumentError)
             end
           end
 
@@ -43,15 +42,15 @@ if JsonVersion.table_exists?
               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]])
+            it "locates versions according to their `object` contents" do
+              expect(described_class.where_object(name: name)).to eq([fruit.versions[1]])
+              expect(described_class.where_object(color: color)).to eq([fruit.versions[2]])
             end
           end
         end
 
         describe "#where_object_changes" do
-          it { expect(JsonVersion).to respond_to(:where_object_changes) }
+          it { expect(described_class).to respond_to(:where_object_changes) }
 
           it "escapes values" do
             f = Fruit.create(name: "Bobby")
@@ -64,9 +63,9 @@ if JsonVersion.table_exists?
           end
 
           context "invalid arguments" do
-            it "should raise an error" do
-              expect { JsonVersion.where_object_changes(:foo) }.to raise_error(ArgumentError)
-              expect { JsonVersion.where_object_changes([]) }.to raise_error(ArgumentError)
+            it "raises an error" do
+              expect { described_class.where_object_changes(:foo) }.to raise_error(ArgumentError)
+              expect { described_class.where_object_changes([]) }.to raise_error(ArgumentError)
             end
           end
 

data/spec/models/not_on_update_spec.rb

@@ -4,7 +4,7 @@ describe NotOnUpdate, type: :model do
   describe "#touch_with_version", versioning: true do
     let!(:record) { described_class.create! }
 
-    it "should create a version, regardless" do
+    it "creates a version, regardless" do
       expect { record.paper_trail.touch_with_version }.to change {
         PaperTrail::Version.count
       }.by(+1)

data/spec/models/post_with_status_spec.rb

@@ -4,7 +4,7 @@ describe PostWithStatus, type: :model do
   with_versioning do
     let(:post) { described_class.create!(status: "draft") }
 
-    it "should stash the enum value properly in versions" do
+    it "saves the enum value in versions" do
       post.published!
       post.archived!
       expect(post.paper_trail.previous_version.published?).to be true
@@ -23,7 +23,7 @@ describe PostWithStatus, type: :model do
     context "storing enum object_changes" do
       subject { post.versions.last }
 
-      it "should stash the enum value properly in versions object_changes" do
+      it "saves the enum value properly in versions object_changes" do
         post.published!
         post.archived!
         expect(subject.changeset["status"]).to eql %w(published archived)

data/spec/models/skipper_spec.rb

@@ -9,11 +9,11 @@ describe Skipper, type: :model 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
+        it "does not create a version" do
           skipper = Skipper.create!(another_timestamp: t1)
           expect {
             skipper.update_attributes!(another_timestamp: t2)
-          }.to_not change { skipper.versions.length }
+          }.not_to(change { skipper.versions.length })
         end
       end
     end
@@ -24,7 +24,7 @@ describe Skipper, type: :model do
         let(:t2) { Time.zone.local(2015, 7, 15, 20, 34, 30) }
 
         context "without preserve (default)" do
-          it "should have no timestamp" 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
@@ -33,7 +33,7 @@ describe Skipper, type: :model do
         end
 
         context "with preserve" do
-          it "should preserve its timestamp" 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)

data/spec/models/thing_spec.rb

@@ -3,7 +3,7 @@ require "rails_helper"
 describe Thing, type: :model do
   it { is_expected.to be_versioned }
 
-  describe "should not store object_changes", versioning: true do
+  describe "does not store object_changes", versioning: true do
     let(:thing) { Thing.create(name: "pencil") }
 
     it { expect(thing.versions.last.object_changes).to be_nil }

data/spec/models/truck_spec.rb

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

data/spec/models/vehicle_spec.rb

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

data/spec/models/version_spec.rb

@@ -1,7 +1,7 @@
 require "rails_helper"
 
 describe PaperTrail::Version, type: :model do
-  it "should include the `VersionConcern` module to get base functionality" do
+  it "includes the VersionConcern module" do
     expect(PaperTrail::Version).to include(PaperTrail::VersionConcern)
   end
 
@@ -13,7 +13,7 @@ describe PaperTrail::Version, type: :model do
       context "serializer is YAML" do
         specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
 
-        it "should store out as a plain hash" do
+        it "store out as a plain hash" do
           expect(value =~ /HashWithIndifferentAccess/).to be_nil
         end
       end
@@ -21,7 +21,7 @@ describe PaperTrail::Version, type: :model do
       context "serializer is JSON" do
         before(:all) { PaperTrail.serializer = PaperTrail::Serializers::JSON }
 
-        it "should store out as a plain hash" do
+        it "store out as a plain hash" do
           expect(value =~ /HashWithIndifferentAccess/).to be_nil
         end
 
@@ -35,43 +35,41 @@ describe PaperTrail::Version, type: :model do
       subject { 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
+          it "return nil" do
             expect(subject.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
-          subject { widget.versions.last }
 
           specify { expect(subject.previous).to be_instance_of(PaperTrail::Version) }
 
-          it "should return nil" do
+          it "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
+        it "sets 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 "displays a deprecation warning" do
           expect(ActiveSupport::Deprecation).to receive(:warn).
             with(/Use paper_trail_originator instead of originator/)
           subject.originator
@@ -79,10 +77,9 @@ describe PaperTrail::Version, type: :model do
       end
 
       describe "#terminator" do
-        let(:attributes) { { whodunnit: FFaker::Name.first_name } }
         subject { PaperTrail::Version.new attributes }
 
-        it { is_expected.to respond_to(:terminator) }
+        let(:attributes) { { whodunnit: FFaker::Name.first_name } }
 
         it "is an alias for the `whodunnit` attribute" do
           expect(subject.terminator).to eq(attributes[:whodunnit])
@@ -90,180 +87,167 @@ describe PaperTrail::Version, type: :model do
       end
 
       describe "#version_author" do
-        it { is_expected.to respond_to(:version_author) }
-
-        it "should be an alias for the `terminator` method" do
+        it "is an alias for the `terminator` method" do
           expect(subject.method(:version_author)).to eq(subject.method(:terminator))
         end
       end
     end
 
-    describe "Class" 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 = [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
+          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 "#where_object", versioning: true do
+          let(:widget) { Widget.new }
+          let(:name) { FFaker::Name.first_name }
+          let(:int) { rand(10) + 1 }
 
-      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
+            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
+            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
-          after do
-            if override
-              ActiveRecord::Base.connection.execute("ROLLBACK TO SAVEPOINT pgtest;")
-              PaperTrail::Version.reset_column_information
+
+          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
+
+        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)
           end
 
-          describe "#where_object" do
-            it { expect(PaperTrail::Version).to respond_to(:where_object) }
-
-            context "invalid arguments" do
-              it "should raise an error" do
-                expect {
-                  PaperTrail::Version.where_object(:foo)
-                }.to raise_error(ArgumentError)
-                expect {
-                  PaperTrail::Version.where_object([])
-                }.to raise_error(ArgumentError)
-              end
+          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
+
+          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
 
-            context "valid arguments", versioning: true do
-              let(:widget) { Widget.new }
-              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: FFaker::Name.last_name, an_integer: 15)
-              end
-
-              context "`serializer == YAML`" do
-                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]])
-                end
-              end
-
-              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]])
-                end
-
-                after(:all) do
-                  PaperTrail.serializer = PaperTrail::Serializers::YAML
-                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])
             end
           end
 
-          describe "#where_object_changes" do
-            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
+          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
 
-            context "valid arguments", 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)
-              end
-
-              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
-
-              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
+            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
         end
       end