paper_trail 5.2.3 → 11.0.0

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: FFaker::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,102 +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) { FFaker::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: FFaker::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,22 +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.paper_trail.touch_with_version }.to change {
-        PaperTrail::Version.count
-      }.by(+1)
-    end
-
-    it "increments the `:updated_at` timestamp" do
-      before = record.updated_at
-      # Travel 1 second because MySQL lacks sub-second resolution
-      Timecop.travel(1) do
-        record.paper_trail.touch_with_version
-      end
-      expect(record.updated_at).to be > before
-    end
-  end
-end

data/spec/models/post_with_status_spec.rb

@@ -1,50 +0,0 @@
-require "rails_helper"
-
-# This model tests ActiveRecord::Enum, which was added in AR 4.1
-# http://edgeguides.rubyonrails.org/4_1_release_notes.html#active-record-enums
-describe PostWithStatus, type: :model do
-  if defined?(ActiveRecord::Enum)
-    with_versioning do
-      let(:post) { described_class.create!(status: "draft") }
-
-      it "should stash the enum value properly 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 "should stash 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
-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/truck_spec.rb

@@ -1,5 +0,0 @@
-require "rails_helper"
-
-describe Truck, type: :model do
-  it { is_expected.to_not be_versioned }
-end

data/spec/models/vehicle_spec.rb

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

data/spec/models/version_spec.rb

@@ -1,272 +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
-    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 "Methods" do
-    describe "Instance" do
-      subject { 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) { FFaker::Name.name }
-          let(:widget) { Widget.create!(name: FFaker::Name.name) }
-          before do
-            widget.versions.first.update_attributes!(whodunnit: name)
-            widget.update_attributes!(name: FFaker::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
-        let(:attributes) { { whodunnit: FFaker::Name.first_name } }
-        subject { PaperTrail::Version.new attributes }
-
-        it { is_expected.to respond_to(:terminator) }
-
-        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) { 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
-
-              context "`serializer == YAML`" do
-                specify do
-                  expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML
-                end
-
-                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 "JSON serializer" do
-                before(:all) do
-                  PaperTrail.serializer = PaperTrail::Serializers::JSON
-                end
-
-                specify do
-                  expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON
-                end
-
-                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) do
-                  PaperTrail.serializer = PaperTrail::Serializers::YAML
-                end
-              end
-            end
-          end
-
-          describe "#where_object_changes" do
-            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) { 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
-
-              context "YAML serializer" do
-                specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
-
-                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 }
-                specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON }
-
-                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
-end