paper_trail 7.1.0 → 7.1.1

data/spec/paper_trail/serializer_spec.rb

@@ -1,85 +0,0 @@
-require "spec_helper"
-require "support/custom_json_serializer"
-
-RSpec.describe(PaperTrail, versioning: true) do
-  context "YAML serializer" do
-    it "saves the expected YAML in the object column" do
-      customer = Customer.create(name: "Some text.")
-      original_attributes = customer.paper_trail.attributes_before_change
-      customer.update(name: "Some more text.")
-      expect(customer.versions.length).to(eq(2))
-      expect(customer.versions[0].reify).to(be_nil)
-      expect(customer.versions[1].reify.name).to(eq("Some text."))
-      expect(YAML.load(customer.versions[1].object)).to(eq(original_attributes))
-      expect(customer.versions[1].object).to(eq(YAML.dump(original_attributes)))
-    end
-  end
-
-  context "JSON Serializer" do
-    before do
-      PaperTrail.configure do |config|
-        config.serializer = PaperTrail::Serializers::JSON
-      end
-    end
-
-    after do
-      PaperTrail.config.serializer = PaperTrail::Serializers::YAML
-    end
-
-    it "reify with JSON serializer" do
-      customer = Customer.create(name: "Some text.")
-      original_attributes = customer.paper_trail.attributes_before_change
-      customer.update(name: "Some more text.")
-      expect(customer.versions.length).to(eq(2))
-      expect(customer.versions[0].reify).to(be_nil)
-      expect(customer.versions[1].reify.name).to(eq("Some text."))
-      expect(ActiveSupport::JSON.decode(customer.versions[1].object)).to(eq(original_attributes))
-      expect(customer.versions[1].object).to(eq(ActiveSupport::JSON.encode(original_attributes)))
-    end
-
-    describe "#changeset" do
-      it "returns the expected hash" do
-        customer = Customer.create(name: "Some text.")
-        customer.update(name: "Some more text.")
-        initial_changeset = { "name" => [nil, "Some text."], "id" => [nil, customer.id] }
-        second_changeset = { "name" => ["Some text.", "Some more text."] }
-        expect(customer.versions[0].changeset).to(eq(initial_changeset))
-        expect(customer.versions[1].changeset).to(eq(second_changeset))
-      end
-    end
-  end
-
-  context "Custom Serializer" do
-    before do
-      PaperTrail.configure { |config| config.serializer = CustomJsonSerializer }
-    end
-
-    after do
-      PaperTrail.config.serializer = PaperTrail::Serializers::YAML
-    end
-
-    it "reify with custom serializer" do
-      customer = Customer.create
-      original_attributes = customer.paper_trail.attributes_before_change.reject { |_k, v| v.nil? }
-      customer.update(name: "Some more text.")
-      expect(customer.versions.length).to(eq(2))
-      expect(customer.versions[0].reify).to(be_nil)
-      expect(customer.versions[1].reify.name).to(be_nil)
-      expect(
-        ActiveSupport::JSON.decode(customer.versions[1].object)
-      ).to eq(original_attributes)
-      expect(
-        customer.versions[1].object
-      ).to eq(ActiveSupport::JSON.encode(original_attributes))
-    end
-
-    describe "#changeset" do
-      it "store object_changes" do
-        customer = Customer.create
-        customer.update(name: "banana")
-        expect(customer.versions[0].changeset).to eq("id" => [nil, customer.id])
-        expect(customer.versions[1].changeset).to eq("name" => [nil, "banana"])
-      end
-    end
-  end
-end

data/spec/paper_trail/serializers/custom_json_serializer_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-require_relative "../../support/custom_json_serializer"
-
-RSpec.describe CustomJsonSerializer do
-  describe ".load" do
-    it "deserializes, removing pairs with blank keys or values" do
-      hash = { "key1" => "banana", "tkey" => nil, "" => "foo" }
-      expect(described_class.load(hash.to_json)).to(eq("key1" => "banana"))
-    end
-  end
-
-  describe ".dump" do
-    it "serializes to JSON, removing pairs with nil values" do
-      hash = { "key1" => "banana", "tkey" => nil, "" => "foo" }
-      expect(described_class.dump(hash)).to(eq('{"key1":"banana","":"foo"}'))
-    end
-  end
-end

data/spec/paper_trail/serializers/custom_yaml_serializer_spec.rb

@@ -1,45 +0,0 @@
-require "spec_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

@@ -1,57 +0,0 @@
-require "spec_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/serializers/yaml_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-
-module PaperTrail
-  module Serializers
-    ::RSpec.describe(YAML, versioning: true) do
-      let(:array) { ::Array.new(10) { ::FFaker::Lorem.word } }
-      let(:hash) {
-        {
-          alice: "bob",
-          binary: 0xdeadbeef,
-          octal_james_bond: 0o7,
-          int: 42,
-          float: 4.2
-        }
-      }
-
-      describe ".load" do
-        it "deserializes YAML to Ruby" do
-          expect(described_class.load(hash.to_yaml)).to eq(hash)
-          expect(described_class.load(array.to_yaml)).to eq(array)
-        end
-      end
-
-      describe ".dump" do
-        it "serializes Ruby to YAML" do
-          expect(described_class.dump(hash)).to eq(hash.to_yaml)
-          expect(described_class.dump(array)).to eq(array.to_yaml)
-        end
-      end
-
-      describe ".where_object" do
-        it "constructs the 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("%\narg1: Val 1\n%")
-        end
-      end
-    end
-  end
-end

data/spec/paper_trail/thread_safety_spec.rb

@@ -1,44 +0,0 @@
-require "spec_helper"
-
-RSpec.describe PaperTrail do
-  describe "#set_paper_trail_whodunnit" do
-    it "is thread-safe" do
-      blocked = true
-      slow_thread = Thread.new do
-        controller = TestController.new
-        controller.send(:set_paper_trail_whodunnit)
-        sleep(0.001) while blocked
-        described_class.whodunnit
-      end
-      fast_thread = Thread.new do
-        controller = TestController.new
-        controller.send(:set_paper_trail_whodunnit)
-        who = described_class.whodunnit
-        blocked = false
-        who
-      end
-      expect(fast_thread.value).not_to(eq(slow_thread.value))
-    end
-  end
-
-  describe "#without_versioning" do
-    it "is thread-safe" do
-      enabled = nil
-      slow_thread = Thread.new do
-        Widget.new.paper_trail.without_versioning do
-          sleep(0.01)
-          enabled = Widget.paper_trail.enabled?
-          sleep(0.01)
-        end
-        enabled
-      end
-      fast_thread = Thread.new do
-        sleep(0.005)
-        Widget.paper_trail.enabled?
-      end
-      expect(fast_thread.value).not_to(eq(slow_thread.value))
-      expect(Widget.paper_trail.enabled?).to(eq(true))
-      expect(described_class.enabled_for_model?(Widget)).to(eq(true))
-    end
-  end
-end

data/spec/paper_trail/version_limit_spec.rb

@@ -1,55 +0,0 @@
-require "spec_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/version_spec.rb

@@ -1,96 +0,0 @@
-require "spec_helper"
-
-module PaperTrail
-  ::RSpec.describe(Version, versioning: true) do
-    describe ".creates" do
-      it "returns only create events" do
-        animal = Animal.create(name: "Foo")
-        animal.update_attributes(name: "Bar")
-        expect(described_class.creates.pluck(:event)).to eq(["create"])
-      end
-    end
-
-    describe ".updates" do
-      it "returns only update events" do
-        animal = Animal.create
-        animal.update_attributes(name: "Animal")
-        expect(described_class.updates.pluck(:event)).to eq(["update"])
-      end
-    end
-
-    describe ".destroys" do
-      it "returns only destroy events" do
-        animal = Animal.create
-        animal.destroy
-        expect(described_class.destroys.pluck(:event)).to eq(["destroy"])
-      end
-    end
-
-    describe ".not_creates" do
-      it "returns all versions except create events" do
-        animal = Animal.create
-        animal.update_attributes(name: "Animal")
-        animal.destroy
-        expect(
-          described_class.not_creates.pluck(:event)
-        ).to match_array(%w[update destroy])
-      end
-    end
-
-    describe ".subsequent" do
-      context "given a timestamp" do
-        it "returns all versions that were created after the timestamp" do
-          animal = Animal.create
-          2.times do
-            animal.update_attributes(name: FFaker::Lorem.word)
-          end
-          value = described_class.subsequent(1.hour.ago, true)
-          expect(value).to eq(animal.versions.to_a)
-          expect(value.to_sql).to match(
-            /ORDER BY #{described_class.arel_table[:created_at].asc.to_sql}/
-          )
-        end
-      end
-
-      context "given a Version" do
-        it "grab the timestamp from the version and use that as the value" do
-          animal = Animal.create
-          2.times do
-            animal.update_attributes(name: FFaker::Lorem.word)
-          end
-          expect(described_class.subsequent(animal.versions.first)).to eq(
-            animal.versions.to_a.drop(1)
-          )
-        end
-      end
-    end
-
-    describe ".preceding" do
-      context "given a timestamp" do
-        it "returns all versions that were created before the timestamp" do
-          animal = Animal.create
-          2.times do
-            animal.update_attributes(name: FFaker::Lorem.word)
-          end
-          value = described_class.preceding(5.seconds.from_now, true)
-          expect(value).to eq(animal.versions.reverse)
-          expect(value.to_sql).to match(
-            /ORDER BY #{described_class.arel_table[:created_at].desc.to_sql}/
-          )
-        end
-      end
-
-      context "given a Version" do
-        it "grab the timestamp from the version and use that as the value" do
-          animal = Animal.create
-          2.times do
-            animal.update_attributes(name: FFaker::Lorem.word)
-          end
-          expect(described_class.preceding(animal.versions.last)).to eq(
-            animal.versions.to_a.tap(&:pop).reverse
-          )
-        end
-      end
-    end
-  end
-end