paper_trail 4.2.0 → 7.1.3

data/spec/models/animal_spec.rb

@@ -1,36 +0,0 @@
-require 'rails_helper'
-
-describe Animal, :type => :model do
-  it { is_expected.to be_versioned }
-
-  describe "STI", :versioning => true do
-    it { expect(Animal.inheritance_column).to eq('species') }
-
-    describe "updates to the `inheritance_column`" do
-      subject { Cat.create!(:name => 'Leo') }
-
-      it "should be allowed" do
-        subject.update_attributes(:name => 'Spike', :species => 'Dog')
-        dog = Animal.find(subject.id)
-        expect(dog).to be_instance_of(Dog)
-      end
-    end
-
-    context 'with callback-methods' do
-      context 'when only has_paper_trail set in super class' do
-        let(:callback_cat) { Cat.create(:name => 'Markus') }
-
-        it 'trails all events' do
-          callback_cat.update_attributes(:name => 'Billie')
-          callback_cat.destroy
-          expect(callback_cat.versions.collect(&:event)).to eq %w(create update destroy)
-        end
-
-        it 'does not break reify' do
-          callback_cat.destroy
-          expect { callback_cat.versions.last.reify }.not_to raise_error
-        end
-      end
-    end
-  end
-end

data/spec/models/boolit_spec.rb

@@ -1,48 +0,0 @@
-require 'rails_helper'
-require Rails.root.join('..', 'custom_json_serializer')
-
-describe Boolit, :type => :model do
-  it { is_expected.to be_versioned }
-
-  it "has a default scope" do
-    expect(subject.default_scopes).to_not be_empty
-  end
-
-  describe "Versioning", :versioning => true do
-    subject { Boolit.create! }
-    before { subject.update_attributes!(:name => Faker::Name.name) }
-
-    it "should have versions" do
-      expect(subject.versions.size).to eq(2)
-    end
-
-    it "should be able to be reified and persisted" do
-      expect { subject.versions.last.reify.save! }.to_not raise_error
-    end
-
-    context "Instance falls out of default scope" do
-      before { subject.update_attributes!(:scoped => false) }
-
-      it "is NOT scoped" do
-        expect(Boolit.first).to be_nil
-      end
-
-      it "should still be able to be reified and persisted" do
-        expect { subject.previous_version.save! }.to_not raise_error
-      end
-
-      context "with `nil` attributes on the live instance" do
-        before do
-          PaperTrail.serializer = CustomJsonSerializer
-          subject.update_attributes!(:name => nil)
-          subject.update_attributes!(:name => Faker::Name.name)
-        end
-        after { PaperTrail.serializer = PaperTrail::Serializers::YAML }
-
-        it "should not overwrite that attribute during the reification process" do
-          expect(subject.previous_version.name).to be_nil
-        end
-      end
-    end
-  end
-end

data/spec/models/callback_modifier_spec.rb

@@ -1,96 +0,0 @@
-require 'rails_helper'
-
-describe CallbackModifier, :type => :model do
-  with_versioning do
-    describe 'callback-methods', :versioning => true do
-      describe 'paper_trail_on_destroy' do
-        it 'should add :destroy to paper_trail_options[:on]' do
-          modifier = NoArgDestroyModifier.create!(:some_content => Faker::Lorem.sentence)
-          expect(modifier.paper_trail_options[:on]).to eq [:destroy]
-        end
-
-        context 'when :before' do
-          it 'should create the version before destroy' do
-            modifier = BeforeDestroyModifier.create!(:some_content => Faker::Lorem.sentence)
-            modifier.test_destroy
-            expect(modifier.versions.last.reify).not_to be_flagged_deleted
-          end
-        end
-
-        context 'when :after' do
-          it 'should create the version after destroy' do
-            modifier = AfterDestroyModifier.create!(:some_content => Faker::Lorem.sentence)
-            modifier.test_destroy
-            expect(modifier.versions.last.reify).to be_flagged_deleted
-          end
-        end
-
-        context 'when no argument' do
-          it 'should default to after destroy' do
-            modifier = NoArgDestroyModifier.create!(:some_content => Faker::Lorem.sentence)
-            modifier.test_destroy
-            expect(modifier.versions.last.reify).to be_flagged_deleted
-          end
-        end
-      end
-
-      describe 'paper_trail_on_update' do
-        it 'should add :update to paper_trail_options[:on]' do
-          modifier = UpdateModifier.create!(:some_content => Faker::Lorem.sentence)
-          expect(modifier.paper_trail_options[:on]).to eq [:update]
-        end
-
-        it 'should create a version' do
-          modifier = UpdateModifier.create!(:some_content => Faker::Lorem.sentence)
-          modifier.update_attributes! :some_content => 'modified'
-          expect(modifier.versions.last.event).to eq 'update'
-        end
-      end
-
-      describe 'paper_trail_on_create' do
-        it 'should add :create to paper_trail_options[:on]' do
-          modifier = CreateModifier.create!(:some_content => Faker::Lorem.sentence)
-          expect(modifier.paper_trail_options[:on]).to eq [:create]
-        end
-
-        it 'should create a version' do
-          modifier = CreateModifier.create!(:some_content => Faker::Lorem.sentence)
-          expect(modifier.versions.last.event).to eq 'create'
-        end
-      end
-
-      context 'when no callback-method used' do
-        it 'should set paper_trail_options[:on] to [:create, :update, :destroy]' do
-          modifier = DefaultModifier.create!(:some_content => Faker::Lorem.sentence)
-          expect(modifier.paper_trail_options[:on]).to eq [:create, :update, :destroy]
-        end
-
-        it 'should default to track destroy' do
-          modifier = DefaultModifier.create!(:some_content => Faker::Lorem.sentence)
-          modifier.destroy
-          expect(modifier.versions.last.event).to eq 'destroy'
-        end
-
-        it 'should default to track update' do
-          modifier = DefaultModifier.create!(:some_content => Faker::Lorem.sentence)
-          modifier.update_attributes! :some_content => 'modified'
-          expect(modifier.versions.last.event).to eq 'update'
-        end
-
-        it 'should default to track create' do
-          modifier = DefaultModifier.create!(:some_content => Faker::Lorem.sentence)
-          expect(modifier.versions.last.event).to eq 'create'
-        end
-      end
-
-      context 'when only one callback-method' do
-        it 'does only track the corresponding event' do
-          modifier = CreateModifier.create!(:some_content => Faker::Lorem.sentence)
-          modifier.update_attributes!(:some_content => 'modified')
-          modifier.test_destroy
-          expect(modifier.versions.collect(&:event)).to eq ['create']
-        end
-      end
-    end
-  end
-end

data/spec/models/fluxor_spec.rb

@@ -1,19 +0,0 @@
-require 'rails_helper'
-
-describe Fluxor, :type => :model do
-  describe '`be_versioned` matcher' do
-    it { is_expected.to_not be_versioned }
-  end
-
-  describe "Methods" do
-    describe "Class" do
-      subject { Fluxor }
-
-      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 false }
-      end
-    end
-  end
-end

data/spec/models/gadget_spec.rb

@@ -1,70 +0,0 @@
-require 'rails_helper'
-
-describe Gadget, :type => :model do
-  it { is_expected.to be_versioned }
-
-  let(:gadget) { Gadget.create!(:name => 'Wrench', :brand => 'Acme') }
-
-  describe "updates", :versioning => true do
-    it "should generate a version for updates to `name` attribute" do
-      expect { gadget.update_attribute(:name, 'Hammer').to change{gadget.versions.size}.by(1) }
-    end
-
-    it "should ignore for updates to `brand` attribute" do
-      expect { gadget.update_attribute(:brand, 'Stanley') }.to_not change{gadget.versions.size}
-    end
-
-    it "should still generate a version when only the `updated_at` attribute is updated" do
-      expect { gadget.update_attribute(:updated_at, Time.now) }.to change{gadget.versions.size}.by(1)
-    end
-  end
-
-  describe "Methods" do
-    describe "Instance", :versioning => true do
-      describe "private" do
-        describe '#changed_notably?' do
-          subject { Gadget.new(:created_at => Time.now) }
-
-          # apparently the private methods list in Ruby18 is different than in Ruby19+
-          if RUBY_VERSION >= '1.9'
-            it { expect(subject.private_methods).to include(:changed_notably?) }
-          else
-            it { expect(subject.private_methods).to include('changed_notably?') }
-          end
-
-          context "create events" do
-            it { expect(subject.send(:changed_notably?)).to be true }
-          end
-
-          context "update events" do
-            before { subject.save! }
-
-            context "without update timestamps" do
-              it "should only acknowledge non-ignored attrs" do
-                subject.name = 'Wrench'
-                expect(subject.send(:changed_notably?)).to be true
-              end
-
-              it "should not acknowledge ignored attr (brand)" do
-                subject.brand = 'Acme'
-                expect(subject.send(:changed_notably?)).to be false
-              end
-            end
-
-            context "with update timestamps" do
-              it "should only acknowledge non-ignored attrs" do
-                subject.name, subject.updated_at = 'Wrench', Time.now
-                expect(subject.send(:changed_notably?)).to be true
-              end
-
-              it "should not acknowledge ignored attrs and timestamps only" do
-                subject.brand, subject.updated_at = 'Acme', Time.now
-                expect(subject.send(:changed_notably?)).to be false
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/models/joined_version_spec.rb

@@ -1,47 +0,0 @@
-require 'rails_helper'
-
-describe JoinedVersion, :type => :model, :versioning => true do
-  it { expect(JoinedVersion.superclass).to be PaperTrail::Version }
-
-  let(:widget) { Widget.create!(:name => Faker::Name.name) }
-  let(:version) { JoinedVersion.first }
-
-  describe "Scopes" do
-    describe "default_scope" do
-      it { expect(JoinedVersion.default_scopes).not_to be_empty }
-    end
-
-    describe "VersionConcern::ClassMethods" do
-      before { widget } # persist a widget
-
-      describe '#subsequent' do
-        it "shouldn't error out when there is a default_scope that joins" do
-          JoinedVersion.subsequent(version).first
-        end
-      end
-
-      describe '#preceding' do
-        it "shouldn't error out when there is a default scope that joins" do
-          JoinedVersion.preceding(version).first
-        end
-      end
-
-      describe '#between' do
-        it "shouldn't error out when there is a default scope that joins" do
-          JoinedVersion.between(Time.now, 1.minute.from_now).first
-        end
-      end
-    end
-  end
-
-  describe "Methods" do
-    describe '#index' do
-      it { is_expected.to respond_to(:index) }
-
-      it "shouldn't error out when there is a default scope that joins" do
-        widget # persist a widget
-        version.index
-      end
-    end
-  end
-end

data/spec/models/json_version_spec.rb

@@ -1,103 +0,0 @@
-require 'rails_helper'
-
-# The `json_versions` table tests postgres' `json` data type. So, that
-# table is only created when testing against postgres and ActiveRecord >= 4.
-if JsonVersion.table_exists?
-
-  describe JsonVersion, :type => :model do
-    it "should include the `VersionConcern` module to get base functionality" do
-      expect(JsonVersion).to include(PaperTrail::VersionConcern)
-    end
-
-    describe "Methods" do
-      describe "Class" do
-
-        describe '#where_object' do
-          it { expect(JsonVersion).to respond_to(:where_object) }
-
-          it "escapes values" do
-            f = Fruit.create(:name => 'Bobby')
-            expect(
-              f.
-                versions.
-                where_object(:name => "Robert'; DROP TABLE Students;--").
-                count
-            ).to eq(0)
-          end
-
-          context "invalid arguments" do
-            it "should raise an error" do
-              expect { JsonVersion.where_object(:foo) }.to raise_error(ArgumentError)
-              expect { JsonVersion.where_object([]) }.to raise_error(ArgumentError)
-            end
-          end
-
-          context "valid arguments", :versioning => true do
-            let(:fruit_names) { %w(apple orange lemon banana lime coconut strawberry blueberry) }
-            let(:fruit) { Fruit.new }
-            let(:name) { 'pomegranate' }
-            let(:color) { Faker::Color.name }
-
-            before do
-              fruit.update_attributes!(:name => name)
-              fruit.update_attributes!(:name => fruit_names.sample, :color => color)
-              fruit.update_attributes!(:name => fruit_names.sample, :color => Faker::Color.name)
-            end
-
-            it "should be able to locate versions according to their `object` contents" do
-              expect(JsonVersion.where_object(:name => name)).to eq([fruit.versions[1]])
-              expect(JsonVersion.where_object(:color => color)).to eq([fruit.versions[2]])
-            end
-          end
-        end
-
-        describe '#where_object_changes' do
-          it { expect(JsonVersion).to respond_to(:where_object_changes) }
-
-          it "escapes values" do
-            f = Fruit.create(:name => 'Bobby')
-            expect(
-              f.
-                versions.
-                where_object_changes(:name => "Robert'; DROP TABLE Students;--").
-                count
-            ).to eq(0)
-          end
-
-          context "invalid arguments" do
-            it "should raise an error" do
-              expect { JsonVersion.where_object_changes(:foo) }.to raise_error(ArgumentError)
-              expect { JsonVersion.where_object_changes([]) }.to raise_error(ArgumentError)
-            end
-          end
-
-          context "valid arguments", :versioning => true do
-            let(:color) { %w[red green] }
-            let(:fruit) { Fruit.create!(:name => name[0]) }
-            let(:name) { %w[banana kiwi mango] }
-
-            before do
-              fruit.update_attributes!(:name => name[1], :color => color[0])
-              fruit.update_attributes!(:name => name[2], :color => color[1])
-            end
-
-            it "finds versions according to their `object_changes` contents" do
-              expect(
-                fruit.versions.where_object_changes(:name => name[0])
-              ).to match_array(fruit.versions[0..1])
-              expect(
-                fruit.versions.where_object_changes(:color => color[0])
-              ).to match_array(fruit.versions[1..2])
-            end
-
-            it "finds versions with multiple attributes changed" do
-              expect(
-                fruit.versions.where_object_changes(:color => color[0], :name => name[0])
-              ).to match_array([fruit.versions[1]])
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/models/kitchen/banana_spec.rb

@@ -1,14 +0,0 @@
-require 'rails_helper'
-
-module Kitchen
-  describe Banana, :type => :model do
-    it { is_expected.to be_versioned }
-
-    describe '#versions' do
-      it "returns instances of Kitchen::BananaVersion", :versioning => true do
-        banana = described_class.create!
-        expect(banana.versions.first).to be_a(Kitchen::BananaVersion)
-      end
-    end
-  end
-end

data/spec/models/not_on_update_spec.rb

@@ -1,19 +0,0 @@
-require 'rails_helper'
-
-describe NotOnUpdate, :type => :model do
-  describe "#touch_with_version", :versioning => true do
-    let!(:record) { described_class.create! }
-
-    it "should create a version, regardless" do
-      expect { record.touch_with_version }.to change {
-        PaperTrail::Version.count
-      }.by(+1)
-    end
-
-    it "increments the `:updated_at` timestamp" do
-      before = record.updated_at
-      record.touch_with_version
-      expect(record.updated_at).to be > before
-    end
-  end
-end