vestal_versions 1.0.2 → 2.0.0

data/spec/vestal_versions/control_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe VestalVersions::Control do
+  let(:user){ User.create(:name => 'Steve Richert') }
+  let(:other_user){ User.create(:name => 'Michael Rossin') }
+  before do
+    @count = user.versions.count
+  end
+
+  shared_examples_for 'a version preserver' do |method|
+    it 'creates one version with a model update' do
+      user.send(method){ user.update_attribute(:last_name, 'Jobs') }
+
+      user.versions.count.should == @count
+    end
+
+    it 'creates one version with multiple model updates' do
+      user.send(method) do
+        user.update_attribute(:first_name, 'Stephen')
+        user.update_attribute(:last_name, 'Jobs')
+        user.update_attribute(:first_name, 'Steve')
+      end
+
+      user.versions.count.should == @count
+    end
+
+  end
+
+  shared_examples_for 'a version incrementer' do |method|
+    it 'creates one version with a model update' do
+      user.send(method){ user.update_attribute(:last_name, 'Jobs') }
+
+      user.versions.count.should == @count + 1
+    end
+
+    it 'creates one version with multiple model updates' do
+      user.send(method) do
+        user.update_attribute(:first_name, 'Stephen')
+        user.update_attribute(:last_name, 'Jobs')
+        user.update_attribute(:first_name, 'Steve')
+      end
+
+      user.versions.count.should == @count + 1
+    end
+
+  end
+
+  it_should_behave_like 'a version preserver', :skip_version
+  it_should_behave_like 'a version incrementer', :merge_version
+
+  context "when operating on the class level" do
+    before do
+      @count = user.versions.count
+      @other_user_count = other_user.versions.count
+    end
+    it 'skip_version doesn\' create versions on multiple models' do
+      other_user_count = other_user.versions.count
+
+      User.skip_version do
+        user.update_attribute(:first_name, 'Stephen')
+        user.update_attribute(:last_name, 'Jobs')
+        user.update_attribute(:first_name, 'Steve')
+
+        other_user.update_attribute(:first_name, 'Stephen')
+        other_user.update_attribute(:last_name, 'Jobs')
+        other_user.update_attribute(:first_name, 'Steve')
+      end
+      user.versions.count.should == @count
+      other_user.versions.count.should == @other_user_count
+    end
+
+  end
+
+  context 'within a append_version block' do
+
+    context 'when no versions exist' do
+      it_should_behave_like 'a version incrementer', :append_version
+    end
+
+    context 'when versions exist' do
+      let(:last_version){ user.versions.last }
+
+      before do
+        user.update_attribute(:last_name, 'Jobs')
+        user.update_attribute(:last_name, 'Richert')
+
+        @count = user.versions.count
+      end
+
+      it_should_behave_like 'a version preserver', :append_version
+
+      it "updates the last version with one update" do
+        original_id = last_version.id
+        original_attrs = last_version.attributes
+
+        user.append_version{ user.update_attribute(:last_name, 'Jobs') }
+
+        other_last_version = user.versions(true).last
+        other_last_version.id.should == original_id
+        other_last_version.attributes.should_not == original_attrs
+      end
+
+      it "updates the last version with multiple updates" do
+        original_id = last_version.id
+        original_attrs = last_version.attributes
+
+        user.append_version do
+          user.update_attribute(:first_name, 'Stephen')
+          user.update_attribute(:last_name, 'Jobs')
+          user.update_attribute(:first_name, 'Steve')
+        end
+
+        other_last_version = user.versions(true).last
+        other_last_version.id.should == original_id
+        other_last_version.attributes.should_not == original_attrs
+      end
+
+    end
+  end
+end

data/spec/vestal_versions/creation_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe VestalVersions::Creation do
+  let(:name){ 'Steve Richert' }
+  subject{ User.create(:name => name) }
+
+  context 'the number of versions' do
+
+    its('versions.count'){ should == 0 }
+
+    context 'with :initial_version option' do
+      before do
+        User.prepare_versioned_options(:initial_version => true)
+      end
+
+      its('versions.count'){ should == 1 }
+    end
+
+    it 'does not increase when no changes are made in an update' do
+      expect {
+        subject.update_attribute(:name, name)
+      }.to change{ subject.versions.count }.by(0)
+    end
+
+    it 'does not increase when no changes are made before a save' do
+      expect{ subject.save }.to change{ subject.versions.count }.by(0)
+    end
+
+    it 'increases by one after an update' do
+      expect{
+        subject.update_attribute(:last_name, 'Jobs')
+      }.to change{ subject.versions.count }.by(1)
+    end
+
+    it 'increases multiple times after multiple updates' do
+      expect{
+        subject.update_attribute(:last_name, 'Jobs')
+        subject.update_attribute(:first_name, 'Brian')
+      }.to change{ subject.versions.count }.by(2)
+    end
+
+  end
+
+  context "a created version's changes" do
+    before do
+      subject.update_attribute(:last_name, 'Jobs')
+    end
+
+    it 'does not contain Rails timestamps' do
+      %w(created_at created_on updated_at updated_on).each do |timestamp|
+        subject.versions.last.changes.keys.should_not include(timestamp)
+      end
+    end
+
+    it 'allows the columns tracked to be restricted via :only' do
+      User.prepare_versioned_options(:only => [:first_name])
+      subject.update_attribute(:name, 'Steven Tyler')
+
+      subject.versions.last.changes.keys.should == ['first_name']
+    end
+
+    it 'allows specific columns to be excluded via :except' do
+      User.prepare_versioned_options(:except => [:first_name])
+      subject.update_attribute(:name, 'Steven Tyler')
+
+      subject.versions.last.changes.keys.should_not include('first_name')
+    end
+
+    it "prefers :only to :except" do
+      User.prepare_versioned_options(:only => [:first_name],
+        :except => [:first_name])
+      subject.update_attribute(:name, 'Steven Tyler')
+
+      subject.versions.last.changes.keys.should == ['first_name']
+    end
+  end
+
+  context 'first version' do
+    it 'is number 2 after an update' do
+      subject.update_attribute(:last_name, 'Jobs')
+      subject.versions.first.number.should == 2
+    end
+
+    it "is number 1 if :initial_version is true" do
+      User.prepare_versioned_options(:initial_version => true)
+      subject.versions.first.number.should == 1
+    end
+  end
+
+end

data/spec/vestal_versions/deletion_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe VestalVersions::Deletion do
+  let(:name){ 'Steve Richert' }
+  subject{ DeletedUser.create(:first_name => 'Steve', :last_name => 'Richert') }
+
+  context "a deleted version's changes" do
+
+    before do
+      subject.update_attribute(:last_name, 'Jobs')
+    end
+
+    it "removes the original record" do
+      subject.destroy
+
+      DeletedUser.find_by_id(subject.id).should be_nil
+    end
+
+    it "creates another version record" do
+      expect{ subject.destroy }.to change{ VestalVersions::Version.count }.by(1)
+    end
+
+    it "creates a version with a tag 'deleted'" do
+      subject.destroy
+      VestalVersions::Version.last.tag.should == 'deleted'
+    end
+
+  end
+
+  context "deleted versions" do
+    let(:last_version){ VestalVersions::Version.last }
+    before do
+      subject.update_attribute(:last_name, 'Jobs')
+      subject.destroy
+    end
+
+    context "restoring a record with a bang" do
+      it "is able to restore the user record" do
+        last_version.restore!
+
+        last_version.versioned.should == subject
+      end
+
+      it "removes the last versioned entry" do
+        expect{
+          last_version.restore!
+        }.to change{ VestalVersions::Version.count }.by(-1)
+      end
+
+      it "works properly even if it's not on the proper version" do
+        another_version = VestalVersions::Version.where(
+          :versioned_id   => last_version.versioned_id,
+          :versioned_type => last_version.versioned_type
+        ).first
+
+        another_version.should_not == last_version
+
+        another_version.restore!.should == subject
+      end
+
+      it "restores even if the schema has changed" do
+        new_mods = last_version.modifications.merge(:old_column => 'old')
+        last_version.update_attributes(:modifications => new_mods)
+
+        last_version.restore.should == subject
+      end
+    end
+
+    context "restoring a record without a save" do
+      it "does not save the DeletedUser when restoring" do
+        last_version.restore.should be_new_record
+      end
+
+      it "restores the user object properly" do
+        last_version.restore.should == subject
+      end
+
+      it "does not decrement the versions table" do
+        expect{
+          last_version.restore
+        }.to change{ VestalVersions::Version.count }.by(0)
+      end
+    end
+  end
+
+end

data/spec/vestal_versions/options_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe VestalVersions::Options do
+  context 'with explicit configuration' do
+    let(:options){ {:dependent => :destroy} }
+    let(:prepared_options){ User.prepare_versioned_options(options.dup) }
+
+    before do
+      VestalVersions::Version.config.clear
+      VestalVersions::Version.config.class_name = 'MyCustomVersion'
+    end
+
+    it 'has symbolized keys' do
+      User.vestal_versions_options.keys.all?{|k| k.is_a?(Symbol) }
+    end
+
+    it 'combines class-level and global configuration options' do
+      prepared_options.slice(:dependent, :class_name).should == {
+        :dependent  => :destroy,
+        :class_name => 'MyCustomVersion'
+      }
+    end
+
+  end
+
+  context 'default configuration options' do
+    subject { User.prepare_versioned_options({}) }
+
+    it 'defaults to "VestalVersions::Version" for :class_name' do
+      subject[:class_name].should == 'VestalVersions::Version'
+    end
+
+    it 'defaults to :delete_all for :dependent' do
+      subject[:dependent].should == :delete_all
+    end
+
+    it 'forces the :as option value to :versioned' do
+      subject[:as].should == :versioned
+    end
+
+    it 'defaults to [VestalVersions::Versions] for :extend' do
+      subject[:extend].should == [VestalVersions::Versions]
+    end
+  end
+end

data/spec/vestal_versions/reload_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe VestalVersions::Reload do
+  let(:user){ User.create(:name => 'Steve Richert') }
+
+  before do
+    first_version = user.version
+    user.update_attribute(:last_name, 'Jobs')
+    @last_version = user.version
+    user.revert_to(first_version)
+  end
+
+  it 'resets the version number to the most recent version' do
+    user.version.should_not == @last_version
+    user.reload
+    user.version.should == @last_version
+  end
+end

data/spec/vestal_versions/reset_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe VestalVersions::Reset do
+  let(:names){
+    ['Steve Richert', 'Stephen Richert', 'Stephen Jobs', 'Steve Jobs']
+  }
+
+  subject{ User.new }
+  let(:versions){ names.map{ |name|
+    subject.update_attribute :name, name
+    subject.version
+  } }
+
+  before do
+    @dependent = User.reflect_on_association(:versions).options[:dependent]
+  end
+
+  after do
+    User.reflect_on_association(:versions).options[:dependent] = @dependent
+  end
+
+  it "properly reverts the model's attributes" do
+    versions.reverse.each_with_index do |version, i|
+      subject.reset_to!(version)
+      subject.name.should == names.reverse[i]
+    end
+  end
+
+  it 'dissociates all versions after the target' do
+    versions.reverse.each do |version|
+      subject.reset_to!(version)
+      subject.versions(true).after(version).count.should == 0
+    end
+  end
+
+  context 'with the :dependent option as :delete_all' do
+    before do
+      User.reflect_on_association(:versions).options[:dependent] = :delete_all
+    end
+
+    it 'deletes all versions after the target version' do
+      versions.reverse.each do |version|
+        later_versions = subject.versions.after(version)
+        subject.reset_to!(version)
+
+        later_versions.each do |later_version|
+          expect{
+            later_version.reload
+          }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
+    end
+
+    it 'does not destroy all versions after the target version' do
+      expect {
+        versions.reverse.each do |version|
+          subject.reset_to! version
+        end
+      }.to_not change{ VestalVersions::Version.count }
+    end
+  end
+
+  context 'with the :dependent option as :destroy' do
+    before do
+      User.reflect_on_association(:versions).options[:dependent] = :destroy
+    end
+
+    it 'deletes all versions after the target version' do
+      versions.reverse.each do |version|
+        later_versions = subject.versions.after(version)
+        subject.reset_to!(version)
+
+        later_versions.each do |later_version|
+          expect{
+            later_version.reload
+          }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
+    end
+
+    it 'destroys all versions after the target version' do
+      expect {
+        versions.reverse.each do |version|
+          later_versions = subject.versions.after(version)
+
+          subject.reset_to!(version)
+        end
+      }.to change{ VestalVersions::Version.count }.by(-versions.size + 1)
+    end
+  end
+
+  context 'with the :dependent option as :nullify' do
+    before do
+      User.reflect_on_association(:versions).options[:dependent] = :nullify
+    end
+
+    it 'leaves all versions after the target version' do
+      versions.reverse.each do |version|
+        later_versions = subject.versions.after(version)
+        subject.reset_to!(version)
+
+        later_versions.each do |later_version|
+          expect{
+            later_version.reload
+          }.to_not raise_error
+        end
+      end
+    end
+  end
+
+end