houston-vestal_versions 2.0.0

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

data/spec/vestal_versions/reversion_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe VestalVersions::Reversion do
+  subject{ User.new }
+  let(:attributes){ {} }
+  let(:first_version){ attributes.keys.min }
+  let(:last_version){ attributes.keys.max }
+  let(:times){ {} }
+  let(:names){
+    ['Steve Richert', 'Stephen Richert', 'Stephen Jobs', 'Steve Jobs']
+  }
+
+  before do
+    time = names.size.hours.ago
+
+    names.each do |name|
+      subject.update_attribute(:name, name)
+      attributes[subject.version] = subject.attributes
+      time += 1.hour
+
+      subject.versions.last.try(:update_attribute, :created_at, time)
+
+      times[subject.version] = time
+    end
+  end
+
+  it 'returns the new version number' do
+    subject.revert_to(first_version).should == first_version
+  end
+
+  it 'changes the version number when saved' do
+    expect{ subject.revert_to! first_version }.to change{ subject.version }
+  end
+
+  it 'does nothing for a invalid argument' do
+    [nil, :bogus, 'bogus', (1..2)].each do |invalid|
+      expect{ subject.revert_to(invalid) }.to_not change{ subject.version }
+    end
+  end
+
+  it 'is able to target a version number' do
+    subject.revert_to(1)
+    subject.version.should == 1
+  end
+
+  it 'is able to target a date and time' do
+    times.each do |version, time|
+      subject.revert_to(time + 1.second)
+      subject.version.should == version
+    end
+  end
+
+  it 'is able to target a version object' do
+    subject.versions.each do |version|
+      subject.revert_to(version)
+      subject.version.should == version.number
+    end
+  end
+
+  it "correctly rolls back the model's attributes" do
+    except = %w(created_at created_on updated_at updated_on)
+
+    attributes.each do |version, attributes|
+      subject.revert_to!(version)
+      subject.attributes.except(*except).should == attributes.except(*except)
+    end
+  end
+
+  it "stores the reverted_from pointing to the previous version" do
+    subject.revert_to!(1)
+    subject.versions.last.reverted_from.should == 1
+  end
+
+  it "does not store the reverted_from for subsequent saves" do
+    subject.revert_to!(1)
+    subject.update_attributes(:name => 'Bill Gates')
+    subject.versions.last.reverted_from.should be_nil
+  end
+
+  it "stores the reverted_from pointing to the version it was reverted from when save is called later" do
+    subject.revert_to(1)
+    subject.name = "Reverted"
+    subject.save
+    subject.versions.last.reverted_from.should == 1
+  end
+
+  it "does not store the reverted_from for subsequent saves when the revert_to-save is called later" do
+    subject.revert_to(1)
+    subject.name = "Reverted"
+    subject.save
+    subject.update_attributes(:name => 'Bill Gates')
+    subject.versions.last.reverted_from.should be_nil
+  end
+
+  it "clears the reverted_from if the model is reloaded after a revert_to without a save" do
+    subject.revert_to(1)
+    subject.reload
+    subject.update_attributes(:name => 'Bill Gates')
+
+    subject.versions.last.reverted_from.should be_nil
+  end
+
+end

data/spec/vestal_versions/users_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe VestalVersions::Users do
+  let(:updated_by){ User.create(:name => 'Steve Jobs') }
+  let(:user){ User.create(:name => 'Steve Richert') }
+
+  it 'defaults to nil' do
+    user.update_attributes(:first_name => 'Stephen')
+    user.versions.last.user.should be_nil
+  end
+
+  it 'accepts and returns an ActiveRecord user' do
+    user.update_attributes(:first_name => 'Stephen', :updated_by => updated_by)
+    user.versions.last.user.should == updated_by
+  end
+
+  it 'accepts and returns a string user name' do
+    user.update_attributes(:first_name => 'Stephen', :updated_by => updated_by.name)
+    user.versions.last.user.should == updated_by.name
+  end
+end

data/spec/vestal_versions/version_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe VestalVersions::Versions do
+  let(:user){ User.create(:name => 'Stephen Richert') }
+
+  before do
+    user.update_attribute(:name, 'Steve Jobs')
+    user.update_attribute(:last_name, 'Richert')
+    @first_version, @last_version = user.versions.first, user.versions.last
+  end
+
+  it 'is comparable to another version based on version number' do
+    @first_version.should == @first_version
+    @last_version.should == @last_version
+    @first_version.should_not == @last_version
+    @last_version.should_not == @first_version
+    @first_version.should < @last_version
+    @last_version.should > @first_version
+    @first_version.should <= @last_version
+    @last_version.should >= @first_version
+  end
+
+  it "is not equal a separate model's version with the same number" do
+    other = User.create(:name => 'Stephen Richert')
+    other.update_attribute(:name, 'Steve Jobs')
+    other.update_attribute(:last_name, 'Richert')
+    first_version, last_version = other.versions.first, other.versions.last
+
+    @first_version.should_not == first_version
+    @last_version.should_not == last_version
+  end
+
+  it 'defaults to ordering by number when finding through association' do
+    numbers = user.versions.map(&:number)
+    numbers.sort.should == numbers
+  end
+
+  it 'returns true for the "initial?" method when the version number is 1' do
+    version = user.versions.build(:number => 1)
+    version.number.should == 1
+    version.should be_initial
+  end
+  
+  it "sreturn the version number if it is not a revert" do
+    user.version.should == user.versions.last.original_number
+  end
+
+  it "return the reverted_version if it is a revert" do
+    user.revert_to!(1)
+    user.versions.last.original_number.should == 1
+  end
+
+  it "return the original version if it is a double revert" do
+    user.revert_to!(2)
+    version = user.version
+    user.update_attributes(:last_name => 'Gates')
+    user.revert_to!(version)
+    user.versions.last.original_number.should == 2
+  end
+  
+end

data/spec/vestal_versions/version_tagging_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe VestalVersions::VersionTagging do
+  let(:user){ User.create(:name => 'Steve Richert') }
+
+  before do
+    user.update_attribute(:last_name, 'Jobs')
+  end
+
+  context 'an untagged version' do
+    it "updates the version record's tag column" do
+      tag_name = 'TAG'
+      last_version = user.versions.last
+
+      last_version.tag.should_not == tag_name
+      user.tag_version(tag_name)
+      last_version.reload.tag.should == tag_name
+    end
+
+    it 'creates a version record for an initial version' do
+      user.revert_to(1)
+      user.versions.at(1).should be_nil
+
+      user.tag_version('TAG')
+      user.versions.at(1).should_not be_nil
+    end
+  end
+
+  context 'A tagged version' do
+    subject{ user.versions.last }
+
+    before do
+      user.tag_version('TAG')
+    end
+
+    it { should be_tagged }
+  end
+
+end

data/spec/vestal_versions/versioned_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe VestalVersions::Versioned do
+  it 'respond to the "versioned?" method' do
+    ActiveRecord::Base.should respond_to(:versioned?)
+    User.should respond_to(:versioned?)
+  end
+
+  it 'return true for the "versioned?" method if the model is versioned' do
+    User.should be_versioned
+  end
+
+  it 'return false for the "versioned?" method if the model is not versioned' do
+    ActiveRecord::Base.should_not be_versioned
+  end
+end