bitfluent-vestal_versions 1.1.0

data/test/options_test.rb

@@ -0,0 +1,52 @@
+require File.expand_path(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.expand_path(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,112 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class ResetTest < Test::Unit::TestCase
+  context 'Resetting a model' do
+    setup do
+      @original_dependent = User.reflect_on_association(:versions).options[:dependent]
+      @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 do |version|
+        @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.reflect_on_association(:versions).options[:dependent] = :delete_all
+      end
+
+      should 'delete all versions after the target version' do
+        @versions.reverse.each do |version|
+          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 do |version|
+          assert_nothing_raised do
+            @user.reset_to!(version)
+          end
+        end
+      end
+    end
+
+    context 'with the :dependent option as :destroy' do
+      setup do
+        User.reflect_on_association(:versions).options[:dependent] = :destroy
+      end
+
+      should 'delete all versions after the target version' do
+        @versions.reverse.each do |version|
+          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 do |version|
+          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.reflect_on_association(:versions).options[:dependent] = :nullify
+      end
+
+      should 'leave all versions after the target version' do
+        @versions.reverse.each do |version|
+          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
+
+    teardown do
+      User.reflect_on_association(:versions).options[:dependent] = @original_dependent
+    end
+  end
+end

data/test/reversion_test.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class ReversionTest < Test::Unit::TestCase
+  context 'A model reversion' do
+    setup do
+      @user, @attributes, @times = User.new, {}, {}
+      names = ['Steve Richert', 'Stephen Richert', 'Stephen Jobs', 'Steve Jobs']
+      time = names.size.hours.ago
+      names.each do |name|
+        @user.update_attribute(:name, name)
+        @attributes[@user.version] = @user.attributes
+        time += 1.hour
+        if last_version = @user.versions.last
+          last_version.update_attribute(:created_at, time)
+        end
+        @times[@user.version] = time
+      end
+      @user.reload.versions.reload
+      @first_version, @last_version = @attributes.keys.min, @attributes.keys.max
+    end
+
+    should 'return the new version number' do
+      new_version = @user.revert_to(@first_version)
+      assert_equal @first_version, new_version
+    end
+
+    should 'change the version number when saved' do
+      current_version = @user.version
+      @user.revert_to!(@first_version)
+      assert_not_equal current_version, @user.version
+    end
+
+    should 'do nothing for a invalid argument' do
+      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
+      @user.revert_to(1)
+      assert_equal 1, @user.version
+    end
+
+    should 'be able to target a date and time' do
+      @times.each do |version, time|
+        @user.revert_to(time + 1.second)
+        assert_equal version, @user.version
+      end
+    end
+
+    should 'be able to target a version object' do
+      @user.versions.each do |version|
+        @user.revert_to(version)
+        assert_equal version.number, @user.version
+      end
+    end
+
+    should "correctly roll back the model's attributes" do
+      timestamps = %w(created_at created_on updated_at updated_on)
+      @attributes.each do |version, attributes|
+        @user.revert_to!(version)
+        assert_equal attributes.except(*timestamps), @user.attributes.except(*timestamps)
+      end
+    end
+  end
+end

data/test/schema.rb

@@ -0,0 +1,43 @@
+ActiveRecord::Base.establish_connection(
+  :adapter => defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby' ? 'jdbcsqlite3' : 'sqlite3',
+  :database => File.join(File.dirname(__FILE__), 'test.db')
+)
+
+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.string :tag
+      t.timestamps
+    end
+  end
+end
+
+CreateSchema.suppress_messages do
+  CreateSchema.migrate(:up)
+end
+
+class User < ActiveRecord::Base
+  versioned
+
+  def name
+    [first_name, last_name].compact.join(' ')
+  end
+
+  def name=(names)
+    self[:first_name], self[:last_name] = names.split(' ', 2)
+  end
+end
+
+class MyCustomVersion < VestalVersions::Version
+end

data/test/tagging_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path(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'
+      last_version = @user.versions.last
+      assert_not_equal tag_name, last_version.tag
+      @user.tag_version(tag_name)
+      assert_equal tag_name, last_version.reload.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

@@ -0,0 +1,12 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+$: << File.dirname(__FILE__)
+
+require 'rubygems'
+require 'test/unit'
+require 'active_record'
+require 'shoulda'
+require 'mocha'
+# require 'vestal_versions'
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/vestal_versions'))
+require 'schema'
+begin; require 'redgreen'; rescue LoadError; end

data/test/users_test.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '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

data/test/version_test.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class VersionTest < Test::Unit::TestCase
+  context 'Versions' do
+    setup do
+      @user = User.create(:name => 'Stephen Richert')
+      @user.update_attribute(:name, 'Steve Jobs')
+      @user.update_attribute(:last_name, 'Richert')
+      @first_version, @last_version = @user.versions.first, @user.versions.last
+    end
+
+    should 'be comparable to another version based on version number' do
+      assert @first_version == @first_version
+      assert @last_version == @last_version
+      assert @first_version != @last_version
+      assert @last_version != @first_version
+      assert @first_version < @last_version
+      assert @last_version > @first_version
+      assert @first_version <= @last_version
+      assert @last_version >= @first_version
+    end
+
+    should "not equal a separate model's version with the same number" do
+      user = User.create(:name => 'Stephen Richert')
+      user.update_attribute(:name, 'Steve Jobs')
+      user.update_attribute(:last_name, 'Richert')
+      first_version, last_version = user.versions.first, user.versions.last
+      assert_not_equal @first_version, first_version
+      assert_not_equal @last_version, last_version
+    end
+
+    should 'default to ordering by number when finding through association' do
+      numbers = @user.versions.map(&:number)
+      assert_equal numbers.sort, numbers
+    end
+
+    should 'return true for the "initial?" method when the version number is 1' do
+      version = @user.versions.build(:number => 1)
+      assert_equal 1, version.number
+      assert_equal true, version.initial?
+    end
+  end
+end

data/test/versioned_test.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class VersionedTest < Test::Unit::TestCase
+  context 'ActiveRecord models' do
+    should 'respond to the "versioned?" method' do
+      assert ActiveRecord::Base.respond_to?(:versioned?)
+      assert User.respond_to?(:versioned?)
+    end
+
+    should 'return true for the "versioned?" method if the model is versioned' do
+      assert_equal true, User.versioned?
+    end
+
+    should 'return false for the "versioned?" method if the model is not versioned' do
+      assert_equal false, ActiveRecord::Base.versioned?
+    end
+  end
+end