set_vestal_versions 1.2.2

data/spec/support/schema.rb

@@ -0,0 +1,25 @@
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'sqlite3',
+  :database => File.expand_path('../../test.db', __FILE__)
+)
+
+class CreateSchema < ActiveRecord::Migration
+  def self.up
+    create_table :users, :force => true do |t|
+      t.string :first_name
+      t.string :last_name
+      t.timestamps
+    end
+
+    create_table :versions, :force => true do |t|
+      t.belongs_to :versioned, :polymorphic => true
+      t.belongs_to :user, :polymorphic => true
+      t.string :user_name
+      t.text :modifications
+      t.integer :number
+      t.integer :reverted_from
+      t.string :tag
+      t.timestamps
+    end
+  end
+end

data/spec/vestal_versions/changes_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe VestalVersions::Changes do
+  context "a version's changes" do
+    let(:user){ User.create(:name => 'Steve Richert') }
+    subject{ user.versions.last.changes }
+
+    before do
+      user.update_attribute(:last_name, 'Jobs')
+    end
+
+    it { should be_a(Hash) }
+    it { should_not be_empty }
+
+    it 'has string keys' do
+      subject.keys.each{ |key| key.should be_a(String) }
+    end
+
+    it 'has two-element array values' do
+      subject.values.each do |key|
+        key.should be_a(Array)
+        key.size.should == 2
+      end
+    end
+
+    it 'has unique-element values' do
+      subject.values.each{ |v| v.uniq.should == v }
+    end
+
+    it "equals the model's changes" do
+      user.first_name = 'Stephen'
+      model_changes = user.changes
+      user.save
+      changes = user.versions.last.changes
+
+      model_changes.should == changes
+    end
+  end
+
+  context 'a hash of changes' do
+    let(:changes){ {'first_name' => ['Steve', 'Stephen']} }
+    let(:other){ {'first_name' => ['Catie', 'Catherine']} }
+
+    it 'properly appends other changes' do
+      expected = {'first_name' => ['Steve', 'Catherine']}
+
+      changes.append_changes(other).should == expected
+
+      changes.append_changes!(other)
+      changes.should == expected
+    end
+
+    it 'properly prepends other changes' do
+      expected = {'first_name' => ['Catie', 'Stephen']}
+
+      changes.prepend_changes(other).should == expected
+
+      changes.prepend_changes!(other)
+      changes.should == expected
+    end
+
+    it 'is reversible' do
+      expected = {'first_name' => ['Stephen', 'Steve']}
+
+      changes.reverse_changes.should == expected
+
+      changes.reverse_changes!
+      changes.should == expected
+    end
+  end
+
+  context 'the changes between two versions' do
+    let(:name){ 'Steve Richert' }
+    let(:user){ User.create(:name => name) }          # 1
+    let(:version){ user.version }
+
+    before do
+      user.update_attribute(:last_name, 'Jobs')       # 2
+      user.update_attribute(:first_name, 'Stephen')   # 3
+      user.update_attribute(:last_name, 'Richert')    # 4
+      user.update_attribute(:name, name)              # 5
+    end
+
+    it 'is a hash' do
+      1.upto(version) do |i|
+        1.upto(version) do |j|
+          user.changes_between(i, j).should be_a(Hash)
+        end
+      end
+    end
+
+    it 'has string keys' do
+      1.upto(version) do |i|
+        1.upto(version) do |j|
+          user.changes_between(i, j).keys.each{ |key| key.should be_a(String) }
+        end
+      end
+    end
+
+    it 'has two-element arrays with unique values' do
+      1.upto(version) do |i|
+        1.upto(version) do |j|
+          user.changes_between(i, j).values.each do |value|
+            value.should be_a(Array)
+            value.size.should == 2
+            value.uniq.should == value
+          end
+        end
+      end
+    end
+
+    it 'is empty between identical versions' do
+      user.changes_between(1, version).should be_empty
+      user.changes_between(version, 1).should be_empty
+    end
+
+    it 'is should reverse with direction' do
+      1.upto(version) do |i|
+        i.upto(version) do |j|
+          up    = user.changes_between(i, j)
+          down  = user.changes_between(j, i)
+          up.should == down.reverse_changes
+        end
+      end
+    end
+
+    it 'is empty with invalid arguments' do
+      1.upto(version) do |i|
+        user.changes_between(i, nil).should be_blank
+        user.changes_between(nil, i).should be_blank
+      end
+    end
+  end
+end

data/spec/vestal_versions/conditions_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe VestalVersions::Conditions do
+  shared_examples_for 'a conditional option' do |option|
+    before do
+      User.class_eval do
+        def true; true; end
+      end
+    end
+
+    it 'is an array' do
+      User.vestal_versions_options[option].should be_a(Array)
+      User.prepare_versioned_options(option => :true)
+      User.vestal_versions_options[option].should be_a(Array)
+    end
+
+    it 'has proc values' do
+      User.prepare_versioned_options(option => :true)
+      User.vestal_versions_options[option].each{|i| i.should be_a(Proc) }
+    end
+  end
+
+  it_should_behave_like 'a conditional option', :if
+  it_should_behave_like 'a conditional option', :unless
+
+  context 'a new version' do
+    subject{ User.create(:name => 'Steve Richert') }
+    let(:count){ subject.versions.count }
+
+    before do
+      User.class_eval do
+        def true; true; end
+        def false; false; end
+      end
+      count # memoize this value
+    end
+
+    after do
+      User.prepare_versioned_options(:if => [], :unless => [])
+    end
+
+    context 'with :if conditions' do
+      context 'that pass' do
+        before do
+          User.prepare_versioned_options(:if => [:true])
+          subject.update_attribute(:last_name, 'Jobs')
+        end
+
+        its('versions.count'){ should == count + 1 }
+      end
+
+      context 'that fail' do
+        before do
+          User.prepare_versioned_options(:if => [:false])
+          subject.update_attribute(:last_name, 'Jobs')
+        end
+
+        its('versions.count'){ should == count }
+      end
+    end
+
+    context 'with :unless conditions' do
+      context 'that pass' do
+        before do
+          User.prepare_versioned_options(:unless => [:true])
+          subject.update_attribute(:last_name, 'Jobs')
+        end
+
+        its('versions.count'){ should == count }
+      end
+
+      context 'that fail' do
+        before do
+          User.prepare_versioned_options(:unless => [:false])
+          subject.update_attribute(:last_name, 'Jobs')
+        end
+
+        its('versions.count'){ should == count + 1 }
+      end
+    end
+
+    context 'with :if and :unless conditions' do
+      context 'that pass' do
+        before do
+          User.prepare_versioned_options(:if => [:true], :unless => [:true])
+          subject.update_attribute(:last_name, 'Jobs')
+        end
+
+        its('versions.count'){ should == count }
+      end
+
+      context 'that fail' do
+        before do
+          User.prepare_versioned_options(:if => [:false], :unless => [:false])
+          subject.update_attribute(:last_name, 'Jobs')
+        end
+
+        its('versions.count'){ should == count }
+      end
+    end
+
+  end
+end

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