paper_trail 5.2.3 → 11.0.0

data/spec/models/widget_spec.rb

@@ -1,343 +0,0 @@
-require "rails_helper"
-
-describe Widget, type: :model do
-  describe "`be_versioned` matcher" do
-    it { is_expected.to be_versioned }
-  end
-
-  let(:widget) { Widget.create! name: "Bob", an_integer: 1 }
-
-  describe "`have_a_version_with` matcher", versioning: true do
-    before do
-      widget.update_attributes!(name: "Leonard", an_integer: 1)
-      widget.update_attributes!(name: "Tom")
-      widget.update_attributes!(name: "Bob")
-    end
-
-    it "is possible to do assertions on versions" do
-      expect(widget).to have_a_version_with name: "Leonard", an_integer: 1
-      expect(widget).to have_a_version_with an_integer: 1
-      expect(widget).to have_a_version_with name: "Tom"
-    end
-  end
-
-  describe "versioning option" do
-    context "enabled", versioning: true do
-      it "should enable versioning" do
-        expect(widget.versions.size).to eq(1)
-      end
-    end
-
-    context "disabled (default)" do
-      it "should not enable versioning" do
-        expect(widget.versions.size).to eq(0)
-      end
-    end
-  end
-
-  describe "Callbacks", versioning: true do
-    describe :before_save do
-      context ":on => :update" do
-        before { widget.update_attributes!(name: "Foobar") }
-
-        subject { widget.versions.last.reify }
-
-        it "resets value for timestamp attrs for update so that value gets updated properly" do
-          # Travel 1 second because MySQL lacks sub-second resolution
-          Timecop.travel(1) do
-            expect { subject.save! }.to change(subject, :updated_at)
-          end
-        end
-      end
-    end
-
-    describe :after_create do
-      let(:widget) { Widget.create!(name: "Foobar", created_at: Time.now - 1.week) }
-
-      it "corresponding version should use the widget's `updated_at`" do
-        expect(widget.versions.last.created_at.to_i).to eq(widget.updated_at.to_i)
-      end
-    end
-
-    describe :after_update do
-      before { widget.update_attributes!(name: "Foobar", updated_at: Time.now + 1.week) }
-
-      subject { widget.versions.last.reify }
-
-      it { expect(subject.paper_trail).not_to be_live }
-
-      it "should clear the `versions_association_name` virtual attribute" do
-        subject.save!
-        expect(subject.paper_trail).to be_live
-      end
-
-      it "corresponding version should use the widget updated_at" do
-        expect(widget.versions.last.created_at.to_i).to eq(widget.updated_at.to_i)
-      end
-    end
-
-    describe :after_destroy do
-      it "should create a version for that event" do
-        expect { widget.destroy }.to change(widget.versions, :count).by(1)
-      end
-
-      it "should assign the version into the `versions_association_name`" do
-        expect(widget.version).to be_nil
-        widget.destroy
-        expect(widget.version).not_to be_nil
-        expect(widget.version).to eq(widget.versions.last)
-      end
-    end
-
-    describe :after_rollback do
-      let(:rolled_back_name) { "Big Moo" }
-
-      before do
-        begin
-          widget.transaction do
-            widget.update_attributes!(name: rolled_back_name)
-            widget.update_attributes!(name: Widget::EXCLUDED_NAME)
-          end
-        rescue ActiveRecord::RecordInvalid
-          widget.reload
-          widget.name = nil
-          widget.save
-        end
-      end
-
-      it "does not create an event for changes that did not happen" do
-        widget.versions.map(&:changeset).each do |changeset|
-          expect(changeset.fetch("name", [])).to_not include(rolled_back_name)
-        end
-      end
-
-      it "has not yet loaded the assocation" do
-        expect(widget.versions).to_not be_loaded
-      end
-    end
-  end
-
-  describe "Association", versioning: true do
-    describe "sort order" do
-      it "should sort by the timestamp order from the `VersionConcern`" do
-        expect(widget.versions.to_sql).to eq(
-          widget.versions.reorder(PaperTrail::Version.timestamp_sort_order).to_sql
-        )
-      end
-    end
-  end
-
-  if defined?(ActiveRecord::IdentityMap) && ActiveRecord::IdentityMap.respond_to?(:without)
-    describe "IdentityMap", versioning: true do
-      it "should not clobber the IdentityMap when reifying" do
-        widget.update_attributes name: "Henry", created_at: Time.now - 1.day
-        widget.update_attributes name: "Harry"
-        expect(ActiveRecord::IdentityMap).to receive(:without).once
-        widget.versions.last.reify
-      end
-    end
-  end
-
-  describe "Methods" do
-    describe "Instance", versioning: true do
-      describe "#create" do
-        it "creates a version record" do
-          wordget = Widget.create
-          assert_equal 1, wordget.versions.length
-        end
-      end
-
-      describe "#destroy" do
-        it "creates a version record" do
-          widget = Widget.create
-          assert_equal 1, widget.versions.length
-          widget.destroy
-          versions_for_widget = PaperTrail::Version.with_item_keys("Widget", widget.id)
-          assert_equal 2, versions_for_widget.length
-        end
-
-        it "can have multiple destruction records" do
-          versions = lambda { |widget|
-            # Workaround for AR 3. When we drop AR 3 support, we can simply use
-            # the `widget.versions` association, instead of `with_item_keys`.
-            PaperTrail::Version.with_item_keys("Widget", widget.id)
-          }
-          widget = Widget.create
-          assert_equal 1, widget.versions.length
-          widget.destroy
-          assert_equal 2, versions.call(widget).length
-          widget = widget.version.reify
-          widget.save
-          assert_equal 3, versions.call(widget).length
-          widget.destroy
-          assert_equal 4, versions.call(widget).length
-          assert_equal 2, versions.call(widget).where(event: "destroy").length
-        end
-      end
-
-      describe "#paper_trail.originator" do
-        describe "return value" do
-          let(:orig_name) { FFaker::Name.name }
-          let(:new_name) { FFaker::Name.name }
-          before { PaperTrail.whodunnit = orig_name }
-
-          context "accessed from live model instance" do
-            specify { expect(widget.paper_trail).to be_live }
-
-            it "should return the originator for the model at a given state" do
-              expect(widget.paper_trail.originator).to eq(orig_name)
-              widget.paper_trail.whodunnit(new_name) { |w|
-                w.update_attributes(name: "Elizabeth")
-              }
-              expect(widget.paper_trail.originator).to eq(new_name)
-            end
-          end
-
-          context "accessed from a reified model instance" do
-            before do
-              widget.update_attributes(name: "Andy")
-              PaperTrail.whodunnit = new_name
-              widget.update_attributes(name: "Elizabeth")
-            end
-
-            context "default behavior (no `options[:dup]` option passed in)" do
-              let(:reified_widget) { widget.versions[1].reify }
-
-              it "should return the appropriate originator" do
-                expect(reified_widget.paper_trail.originator).to eq(orig_name)
-              end
-
-              it "should not create a new model instance" do
-                expect(reified_widget).not_to be_new_record
-              end
-            end
-
-            context "creating a new instance (`options[:dup] == true`)" do
-              let(:reified_widget) { widget.versions[1].reify(dup: true) }
-
-              it "should return the appropriate originator" do
-                expect(reified_widget.paper_trail.originator).to eq(orig_name)
-              end
-
-              it "should not create a new model instance" do
-                expect(reified_widget).to be_new_record
-              end
-            end
-          end
-        end
-      end
-
-      describe "#version_at" do
-        context "Timestamp argument is AFTER object has been destroyed" do
-          it "should return `nil`" do
-            widget.update_attribute(:name, "foobar")
-            widget.destroy
-            expect(widget.paper_trail.version_at(Time.now)).to be_nil
-          end
-        end
-      end
-
-      describe "#whodunnit" do
-        it { is_expected.to respond_to(:whodunnit) }
-
-        context "no block given" do
-          it "should raise an error" do
-            expect {
-              widget.paper_trail.whodunnit("Ben")
-            }.to raise_error(ArgumentError, "expected to receive a block")
-          end
-        end
-
-        context "block given" do
-          let(:orig_name) { FFaker::Name.name }
-          let(:new_name) { FFaker::Name.name }
-
-          before do
-            PaperTrail.whodunnit = orig_name
-            expect(widget.versions.last.whodunnit).to eq(orig_name) # persist `widget`
-          end
-
-          it "should modify value of `PaperTrail.whodunnit` while executing the block" do
-            widget.paper_trail.whodunnit(new_name) do
-              expect(PaperTrail.whodunnit).to eq(new_name)
-              widget.update_attributes(name: "Elizabeth")
-            end
-            expect(widget.versions.last.whodunnit).to eq(new_name)
-          end
-
-          context "after executing the block" do
-            it "reverts value of whodunnit to previous value" do
-              widget.paper_trail.whodunnit(new_name) { |w|
-                w.update_attributes(name: "Elizabeth")
-              }
-              expect(PaperTrail.whodunnit).to eq(orig_name)
-            end
-          end
-
-          context "error within block" do
-            it "still reverts the whodunnit value to previous value" do
-              expect {
-                widget.paper_trail.whodunnit(new_name) { raise }
-              }.to raise_error(RuntimeError)
-              expect(PaperTrail.whodunnit).to eq(orig_name)
-            end
-          end
-        end
-      end
-
-      describe "#touch_with_version" do
-        it "creates a version" do
-          count = widget.versions.size
-          # Travel 1 second because MySQL lacks sub-second resolution
-          Timecop.travel(1) do
-            widget.paper_trail.touch_with_version
-          end
-          expect(widget.versions.size).to eq(count + 1)
-        end
-
-        it "increments the `:updated_at` timestamp" do
-          time_was = widget.updated_at
-          # Travel 1 second because MySQL lacks sub-second resolution
-          Timecop.travel(1) do
-            widget.paper_trail.touch_with_version
-          end
-          expect(widget.updated_at).to be > time_was
-        end
-      end
-
-      describe "#update" do
-        it "creates a version record" do
-          widget = Widget.create
-          assert_equal 1, widget.versions.length
-          widget.update_attributes(name: "Bugle")
-          assert_equal 2, widget.versions.length
-        end
-      end
-    end
-
-    describe "Class" do
-      describe ".paper_trail.enabled?" do
-        it "returns true" do
-          expect(Widget.paper_trail.enabled?).to eq(true)
-        end
-      end
-
-      describe ".disable" do
-        it "should set the `paper_trail.enabled?` to `false`" do
-          expect(Widget.paper_trail.enabled?).to eq(true)
-          Widget.paper_trail.disable
-          expect(Widget.paper_trail.enabled?).to eq(false)
-        end
-      end
-
-      describe ".enable" do
-        it "should set the `paper_trail.enabled?` to `true`" do
-          Widget.paper_trail.disable
-          expect(Widget.paper_trail.enabled?).to eq(false)
-          Widget.paper_trail.enable
-          expect(Widget.paper_trail.enabled?).to eq(true)
-        end
-      end
-    end
-  end
-end

data/spec/modules/paper_trail_spec.rb

@@ -1,27 +0,0 @@
-require "rails_helper"
-
-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
-      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
-      expect(subject.config.enabled).to eq(true)
-      subject.config { |c| c.enabled = false }
-      expect(subject.config.enabled).to eq(false)
-    end
-  end
-
-  describe "#configure" do
-    it { is_expected.to respond_to(:configure) }
-
-    it "should be an alias for the `config` method" do
-      expect(subject.method(:configure)).to eq(subject.method(:config))
-    end
-  end
-end

data/spec/modules/version_concern_spec.rb

@@ -1,31 +0,0 @@
-require "rails_helper"
-
-describe PaperTrail::VersionConcern do
-  before(:all) { require "support/alt_db_init" }
-
-  it "allows included class to have different connections" do
-    expect(Foo::Version.connection).not_to eq(Bar::Version.connection)
-  end
-
-  it "allows custom version class to share connection with superclass" do
-    expect(Foo::Version.connection).to eq(Foo::Document.connection)
-    expect(Bar::Version.connection).to eq(Bar::Document.connection)
-  end
-
-  it "can be used with class_name option" do
-    expect(Foo::Document.version_class_name).to eq("Foo::Version")
-    expect(Bar::Document.version_class_name).to eq("Bar::Version")
-  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)
-    end
-  end
-end

data/spec/modules/version_number_spec.rb

@@ -1,43 +0,0 @@
-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(".")
-        )
-      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/config_spec.rb

@@ -1,33 +0,0 @@
-require "rails_helper"
-
-module PaperTrail
-  RSpec.describe Config do
-    describe ".instance" do
-      it "returns the singleton instance" do
-        expect { described_class.instance }.to_not raise_error
-      end
-    end
-
-    describe ".new" do
-      it "raises NoMethodError" do
-        expect { described_class.new }.to raise_error(NoMethodError)
-      end
-    end
-
-    describe "track_associations?" do
-      context "@track_associations is nil" do
-        after do
-          PaperTrail.config.track_associations = true
-        end
-
-        it "returns false and prints a deprecation warning" do
-          config = described_class.instance
-          config.track_associations = nil
-          expect {
-            expect(config.track_associations?).to eq(false)
-          }.to output(/DEPRECATION WARNING/).to_stderr
-        end
-      end
-    end
-  end
-end