vestal_versions 1.0.2 → 2.0.0

data/test/reload_test.rb

@@ -1,19 +0,0 @@
-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

@@ -1,112 +0,0 @@
-require 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

@@ -1,68 +0,0 @@
-require 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 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

@@ -1,43 +0,0 @@
-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 :changes
-      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

@@ -1,39 +0,0 @@
-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'
-      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

@@ -1,11 +0,0 @@
-$: << 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 'schema'
-begin; require 'redgreen'; rescue LoadError; end

data/test/users_test.rb

@@ -1,25 +0,0 @@
-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

data/test/version_test.rb

@@ -1,43 +0,0 @@
-require 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
-      order = @user.versions.send(:scope, :find)[:order]
-      assert_equal 'versions.number ASC', order
-    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

@@ -1,18 +0,0 @@
-require 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

data/test/versions_test.rb

@@ -1,172 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class VersionsTest < Test::Unit::TestCase
-  context 'A collection of associated versions' do
-    setup do
-      @user, @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)
-        @user.tag_version(@user.version.to_s)
-        time += 1.hour
-        @user.versions.last.update_attribute(:created_at, time)
-        @times[@user.version] = time
-      end
-    end
-
-    should 'be searchable between two valid version values' do
-      @times.keys.each do |number|
-        @times.values.each do |time|
-          assert_kind_of Array, @user.versions.between(number, number)
-          assert_kind_of Array, @user.versions.between(number, time)
-          assert_kind_of Array, @user.versions.between(time, number)
-          assert_kind_of Array, @user.versions.between(time, time)
-          assert !@user.versions.between(number, number).empty?
-          assert !@user.versions.between(number, time).empty?
-          assert !@user.versions.between(time, number).empty?
-          assert !@user.versions.between(time, time).empty?
-        end
-      end
-    end
-
-    should 'return an empty array when searching between a valid and an invalid version value' do
-      @times.each do |number, time|
-        assert_equal [], @user.versions.between(number, nil)
-        assert_equal [], @user.versions.between(time, nil)
-        assert_equal [], @user.versions.between(nil, number)
-        assert_equal [], @user.versions.between(nil, time)
-      end
-    end
-
-    should 'return an empty array when searching between two invalid version values' do
-      assert_equal [], @user.versions.between(nil, nil)
-    end
-
-    should 'be searchable before a valid version value' do
-      @times.sort.each_with_index do |(number, time), i|
-        assert_equal i, @user.versions.before(number).size
-        assert_equal i, @user.versions.before(time).size
-      end
-    end
-
-    should 'return an empty array when searching before an invalid version value' do
-      assert_equal [], @user.versions.before(nil)
-    end
-
-    should 'be searchable after a valid version value' do
-      @times.sort.reverse.each_with_index do |(number, time), i|
-        assert_equal i, @user.versions.after(number).size
-        assert_equal i, @user.versions.after(time).size
-      end
-    end
-
-    should 'return an empty array when searching after an invalid version value' do
-      assert_equal [], @user.versions.after(nil)
-    end
-
-    should 'be fetchable by version number' do
-      @times.keys.each do |number|
-        assert_kind_of VestalVersions::Version, @user.versions.at(number)
-        assert_equal number, @user.versions.at(number).number
-      end
-    end
-
-    should 'be fetchable by tag' do
-      @times.keys.map{|n| [n, n.to_s] }.each do |number, tag|
-        assert_kind_of VestalVersions::Version, @user.versions.at(tag)
-        assert_equal number, @user.versions.at(tag).number
-      end
-    end
-
-    should "be fetchable by the exact time of a version's creation" do
-      @times.each do |number, time|
-        assert_kind_of VestalVersions::Version, @user.versions.at(time)
-        assert_equal number, @user.versions.at(time).number
-      end
-    end
-
-    should "be fetchable by any time after the model's creation" do
-      @times.each do |number, time|
-        assert_kind_of VestalVersions::Version, @user.versions.at(time + 30.minutes)
-        assert_equal number, @user.versions.at(time + 30.minutes).number
-      end
-    end
-
-    should "return nil when fetching a time before the model's creation" do
-      creation = @times.values.min
-      assert_nil @user.versions.at(creation - 1.second)
-    end
-
-    should 'be fetchable by an association extension method' do
-      assert_kind_of VestalVersions::Version, @user.versions.at(:first)
-      assert_kind_of VestalVersions::Version, @user.versions.at(:last)
-      assert_equal @times.keys.min, @user.versions.at(:first).number
-      assert_equal @times.keys.max, @user.versions.at(:last).number
-    end
-
-    should 'be fetchable by a version object' do
-      @times.keys.each do |number|
-        version = @user.versions.at(number)
-        assert_kind_of VestalVersions::Version, version
-        assert_kind_of VestalVersions::Version, @user.versions.at(version)
-        assert_equal number, @user.versions.at(version).number
-      end
-    end
-
-    should 'return nil when fetching an invalid version value' do
-      assert_nil @user.versions.at(nil)
-    end
-
-    should 'provide a version number for any given numeric version value' do
-      @times.keys.each do |number|
-        assert_kind_of Fixnum, @user.versions.number_at(number)
-        assert_kind_of Fixnum, @user.versions.number_at(number + 0.5)
-        assert_equal @user.versions.number_at(number), @user.versions.number_at(number + 0.5)
-      end
-    end
-
-    should 'provide a version number for a valid tag' do
-      @times.keys.map{|n| [n, n.to_s] }.each do |number, tag|
-        assert_kind_of Fixnum, @user.versions.number_at(tag)
-        assert_equal number, @user.versions.number_at(tag)
-      end
-    end
-
-    should 'return nil when providing a version number for an invalid tag' do
-      assert_nil @user.versions.number_at('INVALID')
-    end
-
-    should 'provide a version number of a version corresponding to an association extension method' do
-      assert_kind_of VestalVersions::Version, @user.versions.at(:first)
-      assert_kind_of VestalVersions::Version, @user.versions.at(:last)
-      assert_equal @times.keys.min, @user.versions.number_at(:first)
-      assert_equal @times.keys.max, @user.versions.number_at(:last)
-    end
-
-    should 'return nil when providing a version number for an invalid association extension method' do
-      assert_nil @user.versions.number_at(:INVALID)
-    end
-
-    should "provide a version number for any time after the model's creation" do
-      @times.each do |number, time|
-        assert_kind_of Fixnum, @user.versions.number_at(time + 30.minutes)
-        assert_equal number, @user.versions.number_at(time + 30.minutes)
-      end
-    end
-
-    should "provide a version number of 1 for a time before the model's creation" do
-      creation = @times.values.min
-      assert_equal 1, @user.versions.number_at(creation - 1.second)
-    end
-
-    should 'provide a version number for a given version object' do
-      @times.keys.each do |number|
-        version = @user.versions.at(number)
-        assert_kind_of VestalVersions::Version, version
-        assert_kind_of Fixnum, @user.versions.number_at(version)
-        assert_equal number, @user.versions.number_at(version)
-      end
-    end
-  end
-end