paper_trail 6.0.2 → 7.0.0

data/spec/modules/paper_trail_spec.rb

@@ -4,13 +4,13 @@ describe PaperTrail, type: :module, versioning: true do
   describe "#config" do
     it { is_expected.to respond_to(:config) }
 
-    it "should allow for config values to be set" do
+    it "allows for config values to be set" do
       expect(subject.config.enabled).to eq(true)
       subject.config.enabled = false
       expect(subject.config.enabled).to eq(false)
     end
 
-    it "should accept blocks and yield the config instance" do
+    it "accepts blocks and yield the config instance" do
       expect(subject.config.enabled).to eq(true)
       subject.config { |c| c.enabled = false }
       expect(subject.config.enabled).to eq(false)
@@ -20,7 +20,7 @@ describe PaperTrail, type: :module, versioning: true do
   describe "#configure" do
     it { is_expected.to respond_to(:configure) }
 
-    it "should be an alias for the `config` method" do
+    it "is an alias for the `config` method" do
       expect(subject.method(:configure)).to eq(subject.method(:config))
     end
   end

data/spec/modules/version_concern_spec.rb

@@ -18,14 +18,11 @@ describe PaperTrail::VersionConcern do
   end
 
   describe "persistence", versioning: true do
-    before do
-      @foo_doc = Foo::Document.create!(name: "foobar")
-      @bar_doc = Bar::Document.create!(name: "raboof")
-    end
-
-    it "should store versions in the correct corresponding db location" do
-      expect(@foo_doc.versions.first).to be_instance_of(Foo::Version)
-      expect(@bar_doc.versions.first).to be_instance_of(Bar::Version)
+    it "stores versions in the correct corresponding db location" do
+      foo_doc = Foo::Document.create!(name: "foobar")
+      bar_doc = Bar::Document.create!(name: "raboof")
+      expect(foo_doc.versions.first).to be_instance_of(Foo::Version)
+      expect(bar_doc.versions.first).to be_instance_of(Bar::Version)
     end
   end
 end

data/spec/modules/version_number_spec.rb

@@ -1,43 +1,18 @@
 require "spec_helper"
 
-describe PaperTrail::VERSION do
-  describe "Constants" do
-    subject { PaperTrail::VERSION }
-
-    describe :MAJOR do
-      it { is_expected.to be_const_defined(:MAJOR) }
-      it { expect(subject::MAJOR).to be_a(Integer) }
-    end
-    describe :MINOR do
-      it { is_expected.to be_const_defined(:MINOR) }
-      it { expect(subject::MINOR).to be_a(Integer) }
-    end
-    describe :TINY do
-      it { is_expected.to be_const_defined(:TINY) }
-      it { expect(subject::TINY).to be_a(Integer) }
-    end
-    describe :PRE do
-      it { is_expected.to be_const_defined(:PRE) }
-      if PaperTrail::VERSION::PRE
-        it { expect(subject::PRE).to be_instance_of(String) }
-      end
-    end
-    describe :STRING do
-      it { is_expected.to be_const_defined(:STRING) }
-      it { expect(subject::STRING).to be_instance_of(String) }
-
-      it "should join the numbers into a period separated string" do
-        expect(subject::STRING).to eq(
-          [subject::MAJOR, subject::MINOR, subject::TINY, subject::PRE].compact.join(".")
+module PaperTrail
+  RSpec.describe VERSION do
+    describe "STRING" do
+      it "joins the numbers into a period separated string" do
+        expect(described_class::STRING).to eq(
+          [
+            described_class::MAJOR,
+            described_class::MINOR,
+            described_class::TINY,
+            described_class::PRE
+          ].compact.join(".")
         )
       end
     end
   end
 end
-
-describe PaperTrail do
-  describe "#version" do
-    it { is_expected.to respond_to(:version) }
-    it { expect(subject.version).to eq(PaperTrail::VERSION::STRING) }
-  end
-end

data/spec/paper_trail/cleaner_spec.rb

@@ -0,0 +1,152 @@
+require "rails_helper"
+
+module PaperTrail
+  RSpec.describe Cleaner, versioning: true do
+    describe "clean_versions!" do
+      let(:animal) { ::Animal.new }
+      let(:dog) { ::Dog.new }
+      let(:cat) { ::Cat.new }
+      let(:animals) { [animal, dog, cat] }
+
+      before do
+        animals.each do |animal|
+          3.times do
+            animal.update_attribute(:name, FFaker::Name.name)
+          end
+        end
+      end
+
+      it "baseline test setup" do
+        expect(PaperTrail::Version.count).to(eq(9))
+        animals.each { |animal| expect(animal.versions.size).to(eq(3)) }
+      end
+
+      context "no options provided" do
+        it "removes extra versions for each item" do
+          PaperTrail.clean_versions!
+          expect(PaperTrail::Version.count).to(eq(3))
+          animals.each { |animal| expect(animal.versions.size).to(eq(1)) }
+        end
+
+        it "removes the earliest version(s)" do
+          before = animals.map { |animal| animal.versions.last.reify.name }
+          PaperTrail.clean_versions!
+          after = animals.map { |animal| animal.versions.last.reify.name }
+          expect(after).to(eq(before))
+        end
+      end
+
+      context "keeping 2" do
+        it "keeps two records, instead of the usual one" do
+          PaperTrail.clean_versions!(keeping: 2)
+          expect(PaperTrail::Version.all.count).to(eq(6))
+          animals.each { |animal| expect(animal.versions.size).to(eq(2)) }
+        end
+      end
+
+      context "with the :date option" do
+        it "only deletes versions created on the given date" do
+          animal.versions.each do |ver|
+            ver.update_attribute(:created_at, (ver.created_at - 1.day))
+          end
+          date = animal.versions.first.created_at.to_date
+          animal.update_attribute(:name, FFaker::Name.name)
+          expect(PaperTrail::Version.count).to(eq(10))
+          expect(animal.versions.size).to(eq(4))
+          expect(animal.paper_trail.versions_between(date, (date + 1.day)).size).to(eq(3))
+          PaperTrail.clean_versions!(date: date)
+          expect(PaperTrail::Version.count).to(eq(8))
+          expect(animal.versions.reload.size).to(eq(2))
+          expect(animal.versions.first.created_at.to_date).to(eq(date))
+          # Why use `equal?` here instead of something less strict?
+          # Doesn't `to_date` always produce a new date object?
+          expect(date.equal?(animal.versions.last.created_at.to_date)).to eq(false)
+        end
+      end
+
+      context "with the :item_id option" do
+        context "single ID received" do
+          it "only deletes the versions for the Item with that ID" do
+            PaperTrail.clean_versions!(item_id: animal.id)
+            expect(animal.versions.size).to(eq(1))
+            expect(PaperTrail::Version.count).to(eq(7))
+          end
+        end
+
+        context "collection of IDs received" do
+          it "only deletes versions for the Item(s) with those IDs" do
+            PaperTrail.clean_versions!(item_id: [animal.id, dog.id])
+            expect(animal.versions.size).to(eq(1))
+            expect(dog.versions.size).to(eq(1))
+            expect(PaperTrail::Version.count).to(eq(5))
+          end
+        end
+      end
+
+      context "options combinations" do
+        context ":date" do
+          before do
+            [animal, dog].each do |animal|
+              animal.versions.each do |ver|
+                ver.update_attribute(:created_at, (ver.created_at - 1.day))
+              end
+              animal.update_attribute(:name, FFaker::Name.name)
+            end
+          end
+
+          it "baseline test setup" do
+            date = animal.versions.first.created_at.to_date
+            expect(PaperTrail::Version.count).to(eq(11))
+            [animal, dog].each do |animal|
+              expect(animal.versions.size).to(eq(4))
+              expect(animal.versions.between(date, (date + 1.day)).size).to(eq(3))
+            end
+          end
+
+          context "and :keeping" do
+            it "restrict cleaning properly" do
+              date = animal.versions.first.created_at.to_date
+              PaperTrail.clean_versions!(date: date, keeping: 2)
+              [animal, dog].each do |animal|
+                animal.versions.reload
+                expect(animal.versions.size).to(eq(3))
+                expect(animal.versions.between(date, (date + 1.day)).size).to(eq(2))
+              end
+              expect(PaperTrail::Version.count).to(eq(9))
+            end
+          end
+
+          context "and :item_id" do
+            it "restrict cleaning properly" do
+              date = animal.versions.first.created_at.to_date
+              PaperTrail.clean_versions!(date: date, item_id: dog.id)
+              dog.versions.reload
+              expect(dog.versions.size).to(eq(2))
+              expect(dog.versions.between(date, (date + 1.day)).size).to(eq(1))
+              expect(PaperTrail::Version.count).to(eq(9))
+            end
+          end
+
+          context ", :item_id, and :keeping" do
+            it "restrict cleaning properly" do
+              date = animal.versions.first.created_at.to_date
+              PaperTrail.clean_versions!(date: date, item_id: dog.id, keeping: 2)
+              dog.versions.reload
+              expect(dog.versions.size).to(eq(3))
+              expect(dog.versions.between(date, (date + 1.day)).size).to(eq(2))
+              expect(PaperTrail::Version.count).to(eq(10))
+            end
+          end
+        end
+
+        context ":keeping and :item_id" do
+          it "restrict cleaning properly" do
+            PaperTrail.clean_versions!(keeping: 2, item_id: animal.id)
+            expect(animal.versions.size).to(eq(2))
+            expect(PaperTrail::Version.count).to(eq(8))
+          end
+        end
+      end
+    end
+  end
+end

data/spec/paper_trail/config_spec.rb

@@ -4,7 +4,7 @@ module PaperTrail
   RSpec.describe Config do
     describe ".instance" do
       it "returns the singleton instance" do
-        expect { described_class.instance }.to_not raise_error
+        expect { described_class.instance }.not_to raise_error
       end
     end
 

data/spec/paper_trail/serializers/custom_yaml_serializer_spec.rb

@@ -0,0 +1,45 @@
+require "rails_helper"
+
+module CustomYamlSerializer
+  extend PaperTrail::Serializers::YAML
+
+  def self.load(string)
+    parsed_value = super(string)
+    if parsed_value.is_a?(Hash)
+      parsed_value.reject { |k, v| (k.blank? || v.blank?) }
+    else
+      parsed_value
+    end
+  end
+
+  def self.dump(object)
+    object.is_a?(Hash) ? super(object.reject { |_k, v| v.nil? }) : super
+  end
+end
+
+RSpec.describe CustomYamlSerializer do
+  let(:word_hash) {
+    {
+      "key1" => ::FFaker::Lorem.word,
+      "key2" => nil,
+      "tkey" => nil,
+      "" => "foo"
+    }
+  }
+
+  context(".load") do
+    it("deserializes YAML to Ruby, removing pairs with blank keys or values") do
+      expect(described_class.load(word_hash.to_yaml)).to eq(
+        word_hash.reject { |k, v| (k.blank? || v.blank?) }
+      )
+    end
+  end
+
+  context(".dump") do
+    it("serializes Ruby to YAML, removing pairs with nil values") do
+      expect(described_class.dump(word_hash)).to eq(
+        word_hash.reject { |_k, v| v.nil? }.to_yaml
+      )
+    end
+  end
+end

data/spec/paper_trail/serializers/json_spec.rb

@@ -0,0 +1,57 @@
+require "rails_helper"
+
+module PaperTrail
+  module Serializers
+    RSpec.describe JSON do
+      let(:word_hash) {
+        (1..4).each_with_object({}) { |i, a| a["key#{i}"] = ::FFaker::Lorem.word }
+      }
+      let(:word_array) { [].fill(0, rand(5) + 4) { ::FFaker::Lorem.word } }
+
+      describe ".load" do
+        it "deserialize JSON to Ruby" do
+          expect(described_class.load(word_hash.to_json)).to eq(word_hash)
+          expect(described_class.load(word_array.to_json)).to eq(word_array)
+        end
+      end
+
+      describe ".dump" do
+        it "serializes Ruby to JSON" do
+          expect(described_class.dump(word_hash)).to eq(word_hash.to_json)
+          expect(described_class.dump(word_array)).to eq(word_array.to_json)
+        end
+      end
+
+      describe ".where_object_condition" do
+        context "when value is a string" do
+          it "construct correct WHERE query" do
+            matches = described_class.
+              where_object_condition(PaperTrail::Version.arel_table[:object], :arg1, "Val 1")
+            expect(matches.instance_of?(Arel::Nodes::Matches)).to(eq(true))
+            expect(matches.right.val).to eq("%\"arg1\":\"Val 1\"%")
+          end
+        end
+
+        context "when value is null" do
+          it "construct correct WHERE query" do
+            matches = described_class.
+              where_object_condition(PaperTrail::Version.arel_table[:object], :arg1, nil)
+            expect(matches.instance_of?(Arel::Nodes::Matches)).to(eq(true))
+            expect(matches.right.val).to(eq("%\"arg1\":null%"))
+          end
+        end
+
+        context "when value is a number" do
+          it "construct correct WHERE query" do
+            grouping = described_class.
+              where_object_condition(PaperTrail::Version.arel_table[:object], :arg1, -3.5)
+            expect(grouping.instance_of?(Arel::Nodes::Grouping)).to(eq(true))
+            matches = grouping.select { |v| v.instance_of?(Arel::Nodes::Matches) }
+            expect(matches.first.right.val).to eq("%\"arg1\":-3.5,%")
+            expect(matches.last.right.val).to eq("%\"arg1\":-3.5}%")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/paper_trail/version_limit_spec.rb

@@ -0,0 +1,55 @@
+require "rails_helper"
+
+module PaperTrail
+  RSpec.describe Cleaner, versioning: true do
+    after do
+      PaperTrail.config.version_limit = nil
+    end
+
+    it "cleans up old versions" do
+      PaperTrail.config.version_limit = 10
+      widget = Widget.create
+
+      100.times do |i|
+        widget.update_attributes(name: "Name #{i}")
+        expect(Widget.find(widget.id).versions.count).to be <= 11
+        # 11 versions = 10 updates + 1 create.
+      end
+    end
+
+    it "deletes oldest versions, when the database returns them in a different order" do
+      epoch = DateTime.new(2017, 1, 1)
+
+      widget = Timecop.freeze(epoch) { Widget.create }
+
+      # Sometimes a database will returns records in a different order than
+      # they were inserted. That's hard to get the database to do, so we'll
+      # just create them out-of-order:
+      (1..5).to_a.shuffle.each do |n|
+        Timecop.freeze(epoch + n.hours) do
+          PaperTrail::Version.create!(
+            item: widget,
+            event: "update",
+            object: { "id" => widget.id, "name" => "Name #{n}" }.to_yaml
+          )
+        end
+      end
+      expect(Widget.find(widget.id).versions.count).to eq(6) # 1 create + 5 updates
+
+      # Now, we've recreated the scenario where we can accidentally clean up
+      # the wrong versions. Re-enable the version_limit, and trigger the
+      # clean-up:
+      PaperTrail.config.version_limit = 3
+      widget.versions.last.send(:enforce_version_limit!)
+
+      # Verify that we have fewer versions:
+      expect(widget.reload.versions.count).to eq(4) # 1 create + 4 updates
+
+      # Exclude the create, because the create will return nil for `#reify`.
+      last_names = widget.versions.not_creates.map(&:reify).map(&:name)
+      expect(last_names).to eq(["Name 3", "Name 4", "Name 5"])
+      # No matter what order the version records are returned it, we should
+      # always keep the most-recent changes.
+    end
+  end
+end

data/spec/paper_trail_spec.rb

@@ -1,79 +1,92 @@
 require "rails_helper"
 
-describe PaperTrail do
+RSpec.describe PaperTrail do
+  describe ".gem_version" do
+    it "returns a Gem::Version" do
+      v = described_class.gem_version
+      expect(v).to be_a(::Gem::Version)
+      expect(v.to_s).to eq(::PaperTrail::VERSION::STRING)
+    end
+  end
+
   context "when enabled" do
     it "affects all threads" do
-      Thread.new { PaperTrail.enabled = false }.join
-      assert_equal false, PaperTrail.enabled?
+      Thread.new { described_class.enabled = false }.join
+      assert_equal false, described_class.enabled?
     end
 
     after do
-      PaperTrail.enabled = true
+      described_class.enabled = true
     end
   end
 
   context "default" do
-    it "should have versioning off by default" do
-      expect(PaperTrail).not_to be_enabled
+    it "has versioning off by default" do
+      expect(described_class).not_to be_enabled
     end
 
-    it "should turn versioning on in a `with_versioning` block" do
-      expect(PaperTrail).not_to be_enabled
+    it "has versioning on in a `with_versioning` block" do
+      expect(described_class).not_to be_enabled
       with_versioning do
-        expect(PaperTrail).to be_enabled
+        expect(described_class).to be_enabled
       end
-      expect(PaperTrail).not_to be_enabled
+      expect(described_class).not_to be_enabled
     end
 
     context "error within `with_versioning` block" do
-      it "should revert the value of `PaperTrail.enabled?` to it's previous state" do
-        expect(PaperTrail).not_to be_enabled
+      it "reverts the value of `PaperTrail.enabled?` to its previous state" do
+        expect(described_class).not_to be_enabled
         expect { with_versioning { raise } }.to raise_error(RuntimeError)
-        expect(PaperTrail).not_to be_enabled
+        expect(described_class).not_to be_enabled
       end
     end
   end
 
   context "`versioning: true`", versioning: true do
-    it "should have versioning on by default" do
-      expect(PaperTrail).to be_enabled
+    it "has versioning on by default" do
+      expect(described_class).to be_enabled
     end
 
-    it "should keep versioning on after a with_versioning block" do
-      expect(PaperTrail).to be_enabled
+    it "keeps versioning on after a with_versioning block" do
+      expect(described_class).to be_enabled
       with_versioning do
-        expect(PaperTrail).to be_enabled
+        expect(described_class).to be_enabled
       end
-      expect(PaperTrail).to be_enabled
+      expect(described_class).to be_enabled
     end
   end
 
   context "`with_versioning` block at class level" do
-    it { expect(PaperTrail).not_to be_enabled }
+    it { expect(described_class).not_to be_enabled }
 
     with_versioning do
-      it "should have versioning on by default" do
-        expect(PaperTrail).to be_enabled
+      it "has versioning on by default" do
+        expect(described_class).to be_enabled
       end
     end
-    it "should not leak the `enabled?` state into successive tests" do
-      expect(PaperTrail).not_to be_enabled
+    it "does not leak the `enabled?` state into successive tests" do
+      expect(described_class).not_to be_enabled
     end
   end
 
-  describe :whodunnit do
-    before(:all) { PaperTrail.whodunnit = "foobar" }
+  describe ".version" do
+    it { expect(described_class).to respond_to(:version) }
+    it { expect(described_class.version).to eq(described_class::VERSION::STRING) }
+  end
+
+  describe ".whodunnit" do
+    before(:all) { described_class.whodunnit = "foobar" }
 
-    it "should get set to `nil` by default" do
-      expect(PaperTrail.whodunnit).to be_nil
+    it "is nil by default" do
+      expect(described_class.whodunnit).to be_nil
     end
   end
 
-  describe :controller_info do
-    before(:all) { ::PaperTrail.controller_info = { foo: "bar" } }
+  describe ".controller_info" do
+    before(:all) { described_class.controller_info = { foo: "bar" } }
 
-    it "should get set to an empty hash before each test" do
-      expect(PaperTrail.controller_info).to eq({})
+    it "is set to an empty hash before each test" do
+      expect(described_class.controller_info).to eq({})
     end
   end
 end