paper_trail 4.2.0 → 7.1.3

data/spec/models/post_with_status_spec.rb

@@ -1,17 +0,0 @@
-require 'rails_helper'
-
-# This model is in the test suite soley for the purpose of testing ActiveRecord::Enum,
-# which is available in ActiveRecord4+ only
-describe PostWithStatus, :type => :model do
-  if defined?(ActiveRecord::Enum)
-    with_versioning do
-      let(:post) { PostWithStatus.create!(:status => 'draft') }
-
-      it "should stash the enum value properly in versions" do
-        post.published!
-        post.archived!
-        expect(post.previous_version.published?).to be true
-      end
-    end
-  end
-end

data/spec/models/skipper_spec.rb

@@ -1,46 +0,0 @@
-require 'rails_helper'
-
-describe Skipper, :type => :model do
-  with_versioning 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 "should not create a version" do
-          skipper = Skipper.create!(:another_timestamp => t1)
-          expect {
-            skipper.update_attributes!(:another_timestamp => t2)
-          }.to_not change { skipper.versions.length }
-        end
-      end
-    end
-
-    describe "reify" do
-      context "reifying a with 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) }
-
-        context "without preserve (default)" do
-          it "should have 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 "should preserve 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
-  end
-end

data/spec/models/thing_spec.rb

@@ -1,11 +0,0 @@
-require 'rails_helper'
-
-describe Thing, :type => :model do
-  it { is_expected.to be_versioned }
-
-  describe "should 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/version_spec.rb

@@ -1,239 +0,0 @@
-require 'rails_helper'
-
-describe PaperTrail::Version, :type => :model do
-  it "should include the `VersionConcern` module to get base functionality" do
-    expect(PaperTrail::Version).to include(PaperTrail::VersionConcern)
-  end
-
-  describe "Attributes" do
-    it { is_expected.to have_db_column(:item_type).of_type(:string) }
-    it { is_expected.to have_db_column(:item_id).of_type(:integer) }
-    it { is_expected.to have_db_column(:event).of_type(:string) }
-    it { is_expected.to have_db_column(:whodunnit).of_type(:string) }
-    it { is_expected.to have_db_column(:object).of_type(:text) }
-    it { is_expected.to have_db_column(:created_at).of_type(:datetime) }
-
-    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 "should 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 "should store out as a plain hash" do
-          expect(value =~ /HashWithIndifferentAccess/).to be_nil
-        end
-
-        after(:all) { PaperTrail.serializer = PaperTrail::Serializers::YAML }
-      end
-    end
-  end
-
-  describe "Indexes" do
-    it { is_expected.to have_db_index([:item_type, :item_id]) }
-  end
-
-  describe "Methods" do
-    describe "Instance" do
-      subject { PaperTrail::Version.new(attributes) rescue 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
-            expect(subject.paper_trail_originator).to be_nil
-          end
-        end
-
-        context "Has previous version", :versioning => true do
-          let(:name) { Faker::Name.name }
-          let(:widget) { Widget.create!(:name => Faker::Name.name) }
-          before do
-            widget.versions.first.update_attributes!(:whodunnit => name)
-            widget.update_attributes!(:name => Faker::Name.first_name)
-          end
-          subject { widget.versions.last }
-
-          specify { expect(subject.previous).to be_instance_of(PaperTrail::Version) }
-
-          it "should 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
-          allow(ActiveSupport::Deprecation).to receive(:warn)
-          is_expected.to receive(:paper_trail_originator)
-          subject.originator
-        end
-
-        it 'should display a deprecation warning' do
-          expect(ActiveSupport::Deprecation).to receive(:warn).
-            with(/Use paper_trail_originator instead of originator/)
-          subject.originator
-        end
-      end
-
-      describe '#terminator' do
-        it { is_expected.to respond_to(:terminator) }
-
-        let(:attributes) { {:whodunnit => Faker::Name.first_name} }
-
-        it "is an alias for the `whodunnit` attribute" do
-          expect(subject.terminator).to eq(attributes[:whodunnit])
-        end
-      end
-
-      describe '#version_author' do
-        it { is_expected.to respond_to(:version_author) }
-
-        it "should be 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.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' 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
-            end
-
-            context "valid arguments", :versioning => true do
-              let(:widget) { Widget.new }
-              let(:name) { Faker::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 => Faker::Name.last_name, :an_integer => 15)
-              end
-
-              context "`serializer == YAML`" do
-                specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
-
-                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 "`serializer == JSON`" do
-                before(:all) { PaperTrail.serializer = PaperTrail::Serializers::JSON }
-                specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON }
-
-                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) { PaperTrail.serializer = PaperTrail::Serializers::YAML }
-              end
-            end
-          end
-
-          describe '#where_object_changes' do
-            it { expect(PaperTrail::Version).to respond_to(:where_object_changes) }
-
-            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
-            end
-
-            context "valid arguments", :versioning => true do
-              let(:widget) { Widget.new }
-              let(:name) { Faker::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 => Faker::Name.last_name, :an_integer => int)
-              end
-
-              context "`serializer == YAML`" do
-                specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
-
-                it "should be able to locate 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 "should be able to handle 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 "`serializer == JSON`" do
-                before(:all) { PaperTrail.serializer = PaperTrail::Serializers::JSON }
-                specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON }
-
-                it "should be able to locate 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 "should be able to handle 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
-end

data/spec/models/widget_spec.rb

@@ -1,298 +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 for models wrapped within a block' do
-        expect(widget.versions.size).to eq(1)
-      end
-    end
-
-    context '`disabled` (default)' do
-      it 'should not enable versioning for models wrapped within a block not marked to used 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 "should reset the value for the timestamp attrs for update so that value gets updated properly" do
-          expect { subject.save! }.to change(subject, :updated_at)
-        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).not_to be_live }
-
-      it "should clear the `versions_association_name` virtual attribute" do
-        subject.save!
-        expect(subject).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
-    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
-
-  describe "Methods" do
-    describe "Instance", :versioning => true do
-      describe '#paper_trail_originator' do
-        it { is_expected.to respond_to(:paper_trail_originator) }
-
-        describe "return value" do
-          let(:orig_name) { Faker::Name.name }
-          let(:new_name) { Faker::Name.name }
-          before { PaperTrail.whodunnit = orig_name }
-
-          context "accessed from live model instance" do
-            specify { expect(widget).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.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 "#originator" do
-        subject { widget }
-
-        it { is_expected.to respond_to(:originator) }
-
-        it 'should set 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
-          expect(::ActiveSupport::Deprecation).to receive(:warn).
-            with(/Use paper_trail_originator instead of originator/)
-          subject.originator
-        end
-      end
-
-      describe '#version_at' do
-        it { is_expected.to respond_to(:version_at) }
-
-        context "Timestamp argument is AFTER object has been destroyed" do
-          before do
-            widget.update_attribute(:name, 'foobar')
-            widget.destroy
-          end
-
-          it "should return `nil`" do
-            expect(widget.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.whodunnit('Ben') }.to raise_error(ArgumentError, 'expected to receive a block')
-          end
-        end
-
-        context "block given" do
-          let(:orig_name) { Faker::Name.name }
-          let(:new_name) { Faker::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.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
-
-          it "should revert the value of `PaperTrail.whodunnit` to it's previous value after executing the block" do
-            widget.whodunnit(new_name) { |w| w.update_attributes(:name => 'Elizabeth') }
-            expect(PaperTrail.whodunnit).to eq(orig_name)
-          end
-
-          context "error within block" do
-            it "should ensure that the whodunnit value still reverts to it's previous value" do
-              expect { widget.whodunnit(new_name) { raise } }.to raise_error
-              expect(PaperTrail.whodunnit).to eq(orig_name)
-            end
-          end
-        end
-      end
-
-      describe '#touch_with_version' do
-        it { is_expected.to respond_to(:touch_with_version) }
-
-        it "creates a version" do
-          count = widget.versions.size
-          widget.touch_with_version
-          expect(widget.versions.size).to eq(count + 1)
-        end
-
-        it "increments the `:updated_at` timestamp" do
-          time_was = widget.updated_at
-          widget.touch_with_version
-          expect(widget.updated_at).to be > time_was
-        end
-      end
-    end
-
-    describe "Class" do
-      subject { Widget }
-
-      describe "#paper_trail_enabled_for_model?" do
-        it { is_expected.to respond_to(:paper_trail_enabled_for_model?) }
-
-        it { expect(subject.paper_trail_enabled_for_model?).to be true }
-      end
-
-      describe '#paper_trail_off!' do
-        it { is_expected.to respond_to(:paper_trail_off!) }
-
-        it 'should set the `paper_trail_enabled_for_model?` to `false`' do
-          expect(subject.paper_trail_enabled_for_model?).to be true
-          subject.paper_trail_off!
-          expect(subject.paper_trail_enabled_for_model?).to be false
-        end
-      end
-
-      describe '#paper_trail_on!' do
-        before { subject.paper_trail_off! }
-
-        it { is_expected.to respond_to(:paper_trail_on!) }
-
-        it 'should set the `paper_trail_enabled_for_model?` to `true`' do
-          expect(subject.paper_trail_enabled_for_model?).to be false
-          subject.paper_trail_on!
-          expect(subject.paper_trail_enabled_for_model?).to be true
-        end
-      end
-    end
-  end
-end