vestal_versions 0.8.3 → 1.0.0

data/test/creation_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require File.join(File.dirname(__FILE__), 'test_helper')
 
 class CreationTest < Test::Unit::TestCase
   context 'The number of versions' do
@@ -8,8 +8,8 @@ class CreationTest < Test::Unit::TestCase
       @count = @user.versions.count
     end
 
-    should 'initially equal one' do
-      assert_equal 1, @count
+    should 'initially equal zero' do
+      assert_equal 0, @count
     end
 
     should 'not increase when no changes are made in an update' do
@@ -22,48 +22,88 @@ class CreationTest < Test::Unit::TestCase
       assert_equal @count, @user.versions.count
     end
 
-    should 'not increase when reverting to the current version' do
-      @user.revert_to!(@user.version)
-      assert_equal @count, @user.versions.count
-    end
-
     context 'after an update' do
       setup do
-        @initial_count = @count
-        @name = 'Steve Jobs'
-        @user.update_attribute(:name, @name)
-        @count = @user.versions.count
+        @user.update_attribute(:last_name, 'Jobs')
       end
 
       should 'increase by one' do
-        assert_equal @initial_count + 1, @count
+        assert_equal @count + 1, @user.versions.count
       end
+    end
 
-      should 'increase by one when reverted' do
-        @user.revert_to!(:first)
-        assert_equal @count + 1, @user.versions.count
+    context 'after multiple updates' do
+      setup do
+        @user.update_attribute(:last_name, 'Jobs')
+        @user.update_attribute(:last_name, 'Richert')
       end
 
-      should 'not increase until a revert is saved' do
-        @user.revert_to(:first)
-        assert_equal @count, @user.versions.count
-        @user.save
-        assert_not_equal @count, @user.versions.count
+      should 'increase multiple times' do
+        assert_operator @count + 1, :<, @user.versions.count
       end
     end
+  end
 
-    context 'after multiple updates' do
+  context "A created version's changes" do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+      @user.update_attribute(:last_name, 'Jobs')
+    end
+
+    should 'not contain Rails timestamps' do
+      %w(created_at created_on updated_at updated_on).each do |timestamp|
+        assert_does_not_contain @user.versions.last.changes.keys, timestamp
+      end
+    end
+
+    context '(with :only options)' do
+      setup do
+        @only = %w(first_name)
+        User.prepare_versioned_options(:only => @only)
+        @user.update_attribute(:name, 'Steven Tyler')
+      end
+
+      should 'only contain the specified columns' do
+        assert_equal @only, @user.versions.last.changes.keys
+      end
+
+      teardown do
+        User.prepare_versioned_options(:only => nil)
+      end
+    end
+
+    context '(with :except options)' do
       setup do
-        @initial_count = @count
-        @new_name = 'Steve Jobs'
-        @user.update_attribute(:name, @new_name)
-        @user.update_attribute(:name, @name)
-        @count = @user.versions.count
+        @except = %w(first_name)
+        User.prepare_versioned_options(:except => @except)
+        @user.update_attribute(:name, 'Steven Tyler')
+      end
+
+      should 'not contain the specified columns' do
+        @except.each do |column|
+          assert_does_not_contain @user.versions.last.changes.keys, column
+        end
+      end
+
+      teardown do
+        User.prepare_versioned_options(:except => nil)
+      end
+    end
+
+    context '(with both :only and :except options)' do
+      setup do
+        @only = %w(first_name)
+        @except = @only
+        User.prepare_versioned_options(:only => @only, :except => @except)
+        @user.update_attribute(:name, 'Steven Tyler')
+      end
+
+      should 'respect only the :only options' do
+        assert_equal @only, @user.versions.last.changes.keys
       end
 
-      should 'not increase when reverting to an identical version' do
-        @user.revert_to!(:first)
-        assert_equal @count, @user.versions.count
+      teardown do
+        User.prepare_versioned_options(:only => nil, :except => nil)
       end
     end
   end

data/test/options_test.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class OptionsTest < Test::Unit::TestCase
+  context 'Configuration options' do
+    setup do
+      @options = {:dependent => :destroy}
+      @configuration = {:class_name => 'MyCustomVersion'}
+
+      VestalVersions::Configuration.options.clear
+      @configuration.each{|k,v| VestalVersions::Configuration.send("#{k}=", v) }
+
+      @prepared_options = User.prepare_versioned_options(@options.dup)
+    end
+
+    should 'have symbolized keys' do
+      assert User.vestal_versions_options.keys.all?{|k| k.is_a?(Symbol) }
+    end
+
+    should 'combine class-level and global configuration options' do
+      combined_keys = (@options.keys + @configuration.keys).map(&:to_sym).uniq
+      combined_options = @configuration.symbolize_keys.merge(@options.symbolize_keys)
+      assert_equal @prepared_options.slice(*combined_keys), combined_options
+    end
+
+    teardown do
+      VestalVersions::Configuration.options.clear
+      User.prepare_versioned_options({})
+    end
+  end
+
+  context 'Given no options, configuration options' do
+    setup do
+      @prepared_options = User.prepare_versioned_options({})
+    end
+
+    should 'default to "VestalVersions::Version" for :class_name' do
+      assert_equal 'VestalVersions::Version', @prepared_options[:class_name]
+    end
+
+    should 'default to :delete_all for :dependent' do
+      assert_equal :delete_all, @prepared_options[:dependent]
+    end
+
+    should 'force the :as option value to :versioned' do
+      assert_equal :versioned, @prepared_options[:as]
+    end
+
+    should 'default to [VestalVersions::Versions] for :extend' do
+      assert_equal [VestalVersions::Versions], @prepared_options[:extend]
+    end
+  end
+end

data/test/reload_test.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ReloadTest < Test::Unit::TestCase
+  context 'Reloading a reverted model' do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+      first_version = @user.version
+      @user.update_attribute(:last_name, 'Jobs')
+      @last_version = @user.version
+      @user.revert_to(first_version)
+    end
+
+    should 'reset the version number to the most recent version' do
+      assert_not_equal @last_version, @user.version
+      @user.reload
+      assert_equal @last_version, @user.version
+    end
+  end
+end

data/test/reset_test.rb

@@ -0,0 +1,107 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ResetTest < Test::Unit::TestCase
+  context 'Resetting a model' do
+    setup do
+      @user, @versions = User.new, []
+      @names = ['Steve Richert', 'Stephen Richert', 'Stephen Jobs', 'Steve Jobs']
+      @names.each do |name|
+        @user.update_attribute(:name, name)
+        @versions << @user.version
+      end
+    end
+
+    should "properly revert the model's attributes" do
+      @versions.reverse.each_with_index do |version, i|
+        @user.reset_to!(version)
+        assert_equal @names.reverse[i], @user.name
+      end
+    end
+
+    should 'dissociate all versions after the target' do
+      @versions.reverse.each_with_index do |version, i|
+        @user.reset_to!(version)
+        assert_equal 0, @user.versions(true).after(version).count
+      end
+    end
+
+    context 'with the :dependent option as :delete_all' do
+      setup do
+        User.prepare_versioned_options(:dependent => :delete_all)
+      end
+
+      should 'delete all versions after the target version' do
+        @versions.reverse.each_with_index do |version, i|
+          later_versions = @user.versions.after(version)
+          @user.reset_to!(version)
+          later_versions.each do |later_version|
+            assert_raise ActiveRecord::RecordNotFound do
+              later_version.reload
+            end
+          end
+        end
+      end
+
+      should 'not destroy all versions after the target version' do
+        VestalVersions::Version.any_instance.stubs(:destroy).raises(RuntimeError)
+        @versions.reverse.each_with_index do |version, i|
+          assert_nothing_raised do
+            @user.reset_to!(version)
+          end
+        end
+      end
+    end
+
+    context 'with the :dependent option as :destroy' do
+      setup do
+        User.prepare_versioned_options(:dependent => :destroy)
+      end
+
+      should 'delete all versions after the target version' do
+        @versions.reverse.each_with_index do |version, i|
+          later_versions = @user.versions.after(version)
+          @user.reset_to!(version)
+          later_versions.each do |later_version|
+            assert_raise ActiveRecord::RecordNotFound do
+              later_version.reload
+            end
+          end
+        end
+      end
+
+      should 'destroy all versions after the target version' do
+        VestalVersions::Version.any_instance.stubs(:destroy).raises(RuntimeError)
+        @versions.reverse.each_with_index do |version, i|
+          later_versions = @user.versions.after(version)
+          if later_versions.empty?
+            assert_nothing_raised do
+              @user.reset_to!(version)
+            end
+          else
+            assert_raise RuntimeError do
+              @user.reset_to!(version)
+            end
+          end
+        end
+      end
+    end
+
+    context 'with the :dependent option as :nullify' do
+      setup do
+        User.prepare_versioned_options(:dependent => :nullify)
+      end
+
+      should 'leave all versions after the target version' do
+        @versions.reverse.each_with_index do |version, i|
+          later_versions = @user.versions.after(version)
+          @user.reset_to!(version)
+          later_versions.each do |later_version|
+            assert_nothing_raised do
+              later_version.reload
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/{revert_test.rb → reversion_test.rb}

@@ -1,6 +1,6 @@
-require 'test_helper'
+require File.join(File.dirname(__FILE__), 'test_helper')
 
-class RevertTest < Test::Unit::TestCase
+class ReversionTest < Test::Unit::TestCase
   context 'A model reversion' do
     setup do
       @user, @attributes, @times = User.new, {}, {}
@@ -10,19 +10,13 @@ class RevertTest < Test::Unit::TestCase
         @user.update_attribute(:name, name)
         @attributes[@user.version] = @user.attributes
         time += 1.hour
-        @user.versions.last.update_attribute(:created_at, time)
+        @user.versions.last.try(:update_attribute, :created_at, time)
         @times[@user.version] = time
       end
       @user.reload.versions.reload
       @first_version, @last_version = @attributes.keys.min, @attributes.keys.max
     end
 
-    should 'do nothing for a non-existent version' do
-      attributes = @user.attributes
-      @user.revert_to!(nil)
-      assert_equal attributes, @user.attributes
-    end
-
     should 'return the new version number' do
       new_version = @user.revert_to(@first_version)
       assert_equal @first_version, new_version
@@ -34,20 +28,12 @@ class RevertTest < Test::Unit::TestCase
       assert_not_equal current_version, @user.version
     end
 
-    should 'be able to target the first version' do
-      @user.revert_to(:first)
-      assert_equal @first_version, @user.version
-    end
-
-    should 'be able to target the last version' do
-      @user.revert_to(:last)
-      assert_equal @last_version, @user.version
-    end
-
-    should 'do nothing for a non-existent method name' do
+    should 'do nothing for a invalid argument' do
       current_version = @user.version
-      @user.revert_to(:bogus)
-      assert_equal current_version, @user.version
+      [nil, :bogus, 'bogus', (1..2)].each do |invalid|
+        @user.revert_to(invalid)
+        assert_equal current_version, @user.version
+      end
     end
 
     should 'be able to target a version number' do

data/test/schema.rb

@@ -13,9 +13,12 @@ class CreateSchema < ActiveRecord::Migration
 
     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 :changes
       t.integer :number
-      t.datetime :created_at
+      t.string :tag
+      t.timestamps
     end
   end
 end

data/test/tagging_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class TaggingTest < Test::Unit::TestCase
+  context 'Tagging a version' do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+      @user.update_attribute(:last_name, 'Jobs')
+    end
+
+    should "update the version record's tag column" do
+      tag_name = 'TAG'
+      assert_not_equal tag_name, @user.versions.last.tag
+      @user.tag_version(tag_name)
+      assert_equal tag_name, @user.versions.last.tag
+    end
+
+    should 'create a version record for an initial version' do
+      @user.revert_to(1)
+      assert_nil @user.versions.at(1)
+      @user.tag_version('TAG')
+      assert_not_nil @user.versions.at(1)
+    end
+  end
+
+  context 'A tagged version' do
+    setup do
+      user = User.create(:name => 'Steve Richert')
+      user.update_attribute(:last_name, 'Jobs')
+      user.tag_version('TAG')
+      @version = user.versions.last
+    end
+
+    should 'return true for the "tagged?" method' do
+      assert @version.respond_to?(:tagged?)
+      assert_equal true, @version.tagged?
+    end
+  end
+end

data/test/test_helper.rb

@@ -3,8 +3,9 @@ $: << File.dirname(__FILE__)
 
 require 'rubygems'
 require 'test/unit'
-require 'activerecord'
+require 'active_record'
 require 'shoulda'
+require 'mocha'
 require 'vestal_versions'
 require 'schema'
 begin; require 'redgreen'; rescue LoadError; end

data/test/users_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class UsersTest < Test::Unit::TestCase
+  context 'The user responsible for an update' do
+    setup do
+      @updated_by = User.create(:name => 'Steve Jobs')
+      @user = User.create(:name => 'Steve Richert')
+    end
+
+    should 'default to nil' do
+      @user.update_attributes(:first_name => 'Stephen')
+      assert_nil @user.versions.last.user
+    end
+
+    should 'accept and return an ActiveRecord user' do
+      @user.update_attributes(:first_name => 'Stephen', :updated_by => @updated_by)
+      assert_equal @updated_by, @user.versions.last.user
+    end
+
+    should 'accept and return a string user name' do
+      @user.update_attributes(:first_name => 'Stephen', :updated_by => @updated_by.name)
+      assert_equal @updated_by.name, @user.versions.last.user
+    end
+  end
+end