paper_trail 7.1.0 → 7.1.1

data/spec/models/on/update_spec.rb

@@ -1,27 +0,0 @@
-require "spec_helper"
-require_dependency "on/update"
-
-module On
-  RSpec.describe Update, type: :model, versioning: true do
-    describe "#versions" do
-      it "only creates one version record, for the update event" do
-        record = described_class.create(name: "Alice")
-        record.update_attributes(name: "blah")
-        record.destroy
-        expect(record.versions.length).to(eq(1))
-        expect(record.versions.last.event).to(eq("update"))
-      end
-    end
-
-    context "#paper_trail_event" do
-      it "rembembers the custom event name" do
-        record = described_class.create(name: "Alice")
-        record.paper_trail_event = "banana"
-        record.update_attributes(name: "blah")
-        record.destroy
-        expect(record.versions.length).to(eq(1))
-        expect(record.versions.last.event).to(eq("banana"))
-      end
-    end
-  end
-end

data/spec/models/post_with_status_spec.rb

@@ -1,46 +0,0 @@
-require "spec_helper"
-
-RSpec.describe PostWithStatus, type: :model do
-  with_versioning do
-    let(:post) { described_class.create!(status: "draft") }
-
-    it "saves the enum value in versions" do
-      post.published!
-      post.archived!
-      expect(post.paper_trail.previous_version.published?).to be true
-    end
-
-    it "can read enums in version records written by PT 4" do
-      post = described_class.create(status: "draft")
-      post.published!
-      version = post.versions.last
-      # Simulate behavior PT 4, which used to save the string version of
-      # enums to `object_changes`
-      version.update(object_changes: "---\nid:\n- \n- 1\nstatus:\n- draft\n- published\n")
-      assert_equal %w[draft published], version.changeset["status"]
-    end
-
-    context "storing enum object_changes" do
-      subject { post.versions.last }
-
-      it "saves the enum value properly in versions object_changes" do
-        post.published!
-        post.archived!
-        expect(subject.changeset["status"]).to eql %w[published archived]
-      end
-    end
-
-    describe "#touch_with_version" do
-      it "preserves the enum value (and all other attributes)" do
-        post = described_class.create(status: :draft)
-        expect(post.versions.count).to eq(1)
-        expect(post.status).to eq("draft")
-        Timecop.travel 1.second.since # because MySQL lacks fractional seconds precision
-        post.paper_trail.touch_with_version
-        expect(post.versions.count).to eq(2)
-        expect(post.versions.last[:object]).to include("status: 0")
-        expect(post.paper_trail.previous_version.status).to eq("draft")
-      end
-    end
-  end
-end

data/spec/models/skipper_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Skipper, type: :model, versioning: true do
-  it { is_expected.to be_versioned }
-
-  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 "does not create a version" do
-        skipper = Skipper.create!(another_timestamp: t1)
-        expect {
-          skipper.update_attributes!(another_timestamp: t2)
-        }.not_to(change { skipper.versions.length })
-      end
-    end
-  end
-
-  describe "#reify" do
-    let(:t1) { Time.zone.local(2015, 7, 15, 20, 34, 0) }
-    let(:t2) { Time.zone.local(2015, 7, 15, 20, 34, 30) }
-
-    context "without preserve (default)" 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
-        expect(skipper.another_timestamp).to be(nil)
-      end
-    end
-
-    context "with preserve" 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)
-        expect(skipper.another_timestamp).to eq(t2)
-      end
-    end
-  end
-end

data/spec/models/thing_spec.rb

@@ -1,11 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Thing, type: :model do
-  it { is_expected.to be_versioned }
-
-  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 }
-  end
-end

data/spec/models/translation_spec.rb

@@ -1,70 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Translation, type: :model, versioning: true do
-  context "for non-US translations" do
-    it "not change the number of versions" do
-      described_class.create!(headline: "Headline")
-      expect(PaperTrail::Version.count).to(eq(0))
-    end
-
-    context "after update" do
-      it "not change the number of versions" do
-        translation = described_class.create!(headline: "Headline")
-        translation.update_attributes(content: "Content")
-        expect(PaperTrail::Version.count).to(eq(0))
-      end
-    end
-
-    context "after destroy" do
-      it "not change the number of versions" do
-        translation = described_class.create!(headline: "Headline")
-        translation.destroy
-        expect(PaperTrail::Version.count).to(eq(0))
-      end
-    end
-  end
-
-  context "for US translations" do
-    context "that are drafts" do
-      it "creation does not change the number of versions" do
-        translation = described_class.new(headline: "Headline")
-        translation.language_code = "US"
-        translation.type = "DRAFT"
-        translation.save!
-        expect(PaperTrail::Version.count).to(eq(0))
-      end
-
-      it "update does not change the number of versions" do
-        translation = described_class.new(headline: "Headline")
-        translation.language_code = "US"
-        translation.type = "DRAFT"
-        translation.save!
-        translation.update_attributes(content: "Content")
-        expect(PaperTrail::Version.count).to(eq(0))
-      end
-    end
-
-    context "that are not drafts" do
-      it "create changes the number of versions" do
-        described_class.create!(headline: "Headline", language_code: "US")
-        expect(PaperTrail::Version.count).to(eq(1))
-      end
-
-      it "update does not change the number of versions" do
-        translation = described_class.create!(headline: "Headline", language_code: "US")
-        translation.update_attributes(content: "Content")
-        expect(PaperTrail::Version.count).to(eq(2))
-        expect(translation.versions.size).to(eq(2))
-      end
-
-      it "destroy does not change the number of versions" do
-        translation = described_class.new(headline: "Headline")
-        translation.language_code = "US"
-        translation.save!
-        translation.destroy
-        expect(PaperTrail::Version.count).to(eq(2))
-        expect(translation.versions.size).to(eq(2))
-      end
-    end
-  end
-end

data/spec/models/vehicle_spec.rb

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

data/spec/models/version_spec.rb

@@ -1,282 +0,0 @@
-require "spec_helper"
-
-module PaperTrail
-  ::RSpec.describe Version, type: :model do
-    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 "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 "store out as a plain hash" do
-          expect(value =~ /HashWithIndifferentAccess/).to be_nil
-        end
-
-        after(:all) { PaperTrail.serializer = PaperTrail::Serializers::YAML }
-      end
-    end
-
-    describe "#paper_trail_originator" do
-      context "no previous versions" do
-        it "returns nil" do
-          expect(PaperTrail::Version.new.paper_trail_originator).to be_nil
-        end
-      end
-
-      context "has previous version", versioning: true do
-        it "returns name of whodunnit" do
-          name = FFaker::Name.name
-          widget = Widget.create!(name: FFaker::Name.name)
-          widget.versions.first.update_attributes!(whodunnit: name)
-          widget.update_attributes!(name: FFaker::Name.first_name)
-          expect(widget.versions.last.paper_trail_originator).to eq(name)
-        end
-      end
-    end
-
-    describe "#previous" do
-      context "no previous versions" do
-        it "returns nil" do
-          expect(PaperTrail::Version.new.previous).to be_nil
-        end
-      end
-
-      context "has previous version", versioning: true do
-        it "returns a PaperTrail::Version" do
-          name = FFaker::Name.name
-          widget = Widget.create!(name: FFaker::Name.name)
-          widget.versions.first.update_attributes!(whodunnit: name)
-          widget.update_attributes!(name: FFaker::Name.first_name)
-          expect(widget.versions.last.previous).to be_instance_of(PaperTrail::Version)
-        end
-      end
-    end
-
-    describe "#originator" do
-      it "sets the invoke `paper_trail_originator`" do
-        allow(ActiveSupport::Deprecation).to receive(:warn)
-        subject = PaperTrail::Version.new
-        expect(subject).to receive(:paper_trail_originator)
-        subject.originator
-      end
-
-      it "displays a deprecation warning" do
-        expect(ActiveSupport::Deprecation).to receive(:warn).
-          with(/Use paper_trail_originator instead of originator/)
-        subject = PaperTrail::Version.new
-        subject.originator
-      end
-    end
-
-    describe "#terminator" do
-      it "is an alias for the `whodunnit` attribute" do
-        attributes = { whodunnit: FFaker::Name.first_name }
-        subject = PaperTrail::Version.new(attributes)
-        expect(subject.terminator).to eq(attributes[:whodunnit])
-      end
-    end
-
-    describe "#version_author" do
-      it "is an alias for the `terminator` method" do
-        subject = PaperTrail::Version.new
-        expect(subject.method(:version_author)).to eq(subject.method(:terminator))
-      end
-    end
-
-    describe "Methods" do
-      # TODO: Changing the data type of these database columns in the middle
-      # of the test suite adds a fair amount of complication. Is there a better
-      # way? We already have a `json_versions` table in our tests, maybe we
-      # could use that and add a `jsonb_versions` table?
-      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
-              # In rails < 5, we use truncation, ie. there is no transaction
-              # around the tests, so we can't use a savepoint.
-              if active_record_gem_version >= ::Gem::Version.new("5")
-                ActiveRecord::Base.connection.execute("SAVEPOINT pgtest;")
-              end
-              %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
-              # In rails < 5, we use truncation, ie. there is no transaction
-              # around the tests, so we can't use a savepoint.
-              if active_record_gem_version >= ::Gem::Version.new("5")
-                ActiveRecord::Base.connection.execute("ROLLBACK TO SAVEPOINT pgtest;")
-              else
-                %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} text;"
-                  )
-                end
-              end
-              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 }
-
-            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
-
-            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
-
-            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
-
-            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
-              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 }
-              before do
-                unless override
-                  expect(::ActiveSupport::Deprecation).to(
-                    receive(:warn).at_least(:once).with(/^where_object_changes/)
-                  )
-                end
-              end
-
-              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
-          end
-        end
-      end
-    end
-  end
-end