radiant 0.5.2 → 0.6.0

data/vendor/rails/activerecord/test/migration_test_firebird.rb

@@ -0,0 +1,124 @@
+require 'abstract_unit'
+require 'fixtures/course'
+
+class FirebirdMigrationTest < Test::Unit::TestCase
+  self.use_transactional_fixtures = false
+
+  def setup
+    # using Course connection for tests -- need a db that doesn't already have a BOOLEAN domain
+    @connection = Course.connection
+    @fireruby_connection = @connection.instance_variable_get(:@connection)
+  end
+
+  def teardown
+    @connection.drop_table :foo rescue nil
+    @connection.execute("DROP DOMAIN D_BOOLEAN") rescue nil
+  end
+
+  def test_create_table_with_custom_sequence_name
+    assert_nothing_raised do
+      @connection.create_table(:foo, :sequence => 'foo_custom_seq') do |f|
+        f.column :bar, :string
+      end
+    end
+    assert !sequence_exists?('foo_seq')
+    assert sequence_exists?('foo_custom_seq')
+
+    assert_nothing_raised { @connection.drop_table(:foo, :sequence => 'foo_custom_seq') }
+    assert !sequence_exists?('foo_custom_seq')
+  ensure
+    FireRuby::Generator.new('foo_custom_seq', @fireruby_connection).drop rescue nil
+  end
+
+  def test_create_table_without_sequence
+    assert_nothing_raised do
+      @connection.create_table(:foo, :sequence => false) do |f|
+        f.column :bar, :string
+      end
+    end
+    assert !sequence_exists?('foo_seq')
+    assert_nothing_raised { @connection.drop_table :foo }
+
+    assert_nothing_raised do
+      @connection.create_table(:foo, :id => false) do |f|
+        f.column :bar, :string
+      end
+    end
+    assert !sequence_exists?('foo_seq')
+    assert_nothing_raised { @connection.drop_table :foo }
+  end
+
+  def test_create_table_with_boolean_column
+    assert !boolean_domain_exists?
+    assert_nothing_raised do
+      @connection.create_table :foo do |f|
+        f.column :bar, :string
+        f.column :baz, :boolean
+      end
+    end
+    assert boolean_domain_exists?
+  end
+
+  def test_add_boolean_column
+    assert !boolean_domain_exists?
+    @connection.create_table :foo do |f|
+      f.column :bar, :string
+    end
+
+    assert_nothing_raised { @connection.add_column :foo, :baz, :boolean }
+    assert boolean_domain_exists?
+    assert_equal :boolean, @connection.columns(:foo).find { |c| c.name == "baz" }.type
+  end
+
+  def test_change_column_to_boolean
+    assert !boolean_domain_exists?
+    # Manually create table with a SMALLINT column, which can be changed to a BOOLEAN
+    @connection.execute "CREATE TABLE foo (bar SMALLINT)"
+    assert_equal :integer, @connection.columns(:foo).find { |c| c.name == "bar" }.type
+
+    assert_nothing_raised { @connection.change_column :foo, :bar, :boolean }
+    assert boolean_domain_exists?
+    assert_equal :boolean, @connection.columns(:foo).find { |c| c.name == "bar" }.type
+  end
+
+  def test_rename_table_with_data_and_index
+    @connection.create_table :foo do |f|
+      f.column :baz, :string, :limit => 50
+    end
+    100.times { |i| @connection.execute "INSERT INTO foo VALUES (GEN_ID(foo_seq, 1), 'record #{i+1}')" }
+    @connection.add_index :foo, :baz
+
+    assert_nothing_raised { @connection.rename_table :foo, :bar }
+    assert !@connection.tables.include?("foo")
+    assert @connection.tables.include?("bar")
+    assert_equal "index_bar_on_baz", @connection.indexes("bar").first.name
+    assert_equal 100, FireRuby::Generator.new("bar_seq", @fireruby_connection).last
+    assert_equal 100, @connection.select_one("SELECT COUNT(*) FROM bar")["count"]
+  ensure
+    @connection.drop_table :bar rescue nil
+  end
+
+  def test_renaming_table_with_fk_constraint_raises_error
+    @connection.create_table :parent do |p|
+      p.column :name, :string
+    end
+    @connection.create_table :child do |c|
+      c.column :parent_id, :integer
+    end
+    @connection.execute "ALTER TABLE child ADD CONSTRAINT fk_child_parent FOREIGN KEY(parent_id) REFERENCES parent(id)"
+    assert_raise(ActiveRecord::ActiveRecordError) { @connection.rename_table :child, :descendant }
+  ensure
+    @connection.drop_table :child rescue nil
+    @connection.drop_table :descendant rescue nil
+    @connection.drop_table :parent rescue nil
+  end
+
+  private
+    def boolean_domain_exists?
+      !@connection.select_one("SELECT 1 FROM rdb$fields WHERE rdb$field_name = 'D_BOOLEAN'").nil?
+    end
+
+    def sequence_exists?(sequence_name)
+      FireRuby::Generator.exists?(sequence_name, @fireruby_connection)
+    end
+end

data/vendor/rails/activerecord/test/mixin_nested_set_test.rb

@@ -0,0 +1,196 @@
+require 'abstract_unit'
+require 'active_record/acts/nested_set'
+require 'fixtures/mixin'
+require 'pp'
+
+class MixinNestedSetTest < Test::Unit::TestCase
+	fixtures :mixins
+                             
+	def test_mixing_in_methods
+	  ns = NestedSet.new
+		assert( ns.respond_to?( :all_children ) )
+		assert_equal( ns.scope_condition, "root_id IS NULL" )
+		
+		check_method_mixins ns
+	end
+	
+	def test_string_scope
+	  ns = NestedSetWithStringScope.new
+	  
+	  ns.root_id = 1
+	  assert_equal( ns.scope_condition, "root_id = 1" )
+	  ns.root_id = 42
+	  assert_equal( ns.scope_condition, "root_id = 42" )
+	  check_method_mixins ns
+  end
+  
+  def test_symbol_scope
+    ns = NestedSetWithSymbolScope.new
+    ns.root_id = 1
+    assert_equal( ns.scope_condition, "root_id = 1" )
+    ns.root_id = 42
+    assert_equal( ns.scope_condition, "root_id = 42" )
+    check_method_mixins ns
+  end
+  
+  def check_method_mixins( obj )
+    [:scope_condition, :left_col_name, :right_col_name, :parent_column, :root?, :add_child,
+    :children_count, :full_set, :all_children, :direct_children].each { |symbol| assert( obj.respond_to?(symbol)) }
+  end
+
+  def set( id )
+    NestedSet.find( 3000 + id )
+  end
+  
+  def test_adding_children
+    assert( set(1).unknown? )
+    assert( set(2).unknown? )
+    set(1).add_child set(2)
+    
+    # Did we maintain adding the parent_ids?
+    assert( set(1).root? )
+    assert( set(2).child? )
+    assert( set(2).parent_id == set(1).id )
+    
+    # Check boundies
+    assert_equal( set(1).lft, 1 )
+    assert_equal( set(2).lft, 2 )
+    assert_equal( set(2).rgt, 3 )
+    assert_equal( set(1).rgt, 4 )
+    
+    # Check children cound
+    assert_equal( set(1).children_count, 1 )
+    
+    set(1).add_child set(3)
+    
+    #check boundries
+    assert_equal( set(1).lft, 1 )
+    assert_equal( set(2).lft, 2 )
+    assert_equal( set(2).rgt, 3 )
+    assert_equal( set(3).lft, 4 )
+    assert_equal( set(3).rgt, 5 )
+    assert_equal( set(1).rgt, 6 )
+    
+    # How is the count looking?
+    assert_equal( set(1).children_count, 2 )
+
+    set(2).add_child set(4)
+
+    # boundries
+    assert_equal( set(1).lft, 1 )
+    assert_equal( set(2).lft, 2 )
+    assert_equal( set(4).lft, 3 )
+    assert_equal( set(4).rgt, 4 )
+    assert_equal( set(2).rgt, 5 )
+    assert_equal( set(3).lft, 6 )
+    assert_equal( set(3).rgt, 7 )
+    assert_equal( set(1).rgt, 8 )
+    
+    # Children count
+    assert_equal( set(1).children_count, 3 )
+    assert_equal( set(2).children_count, 1 )
+    assert_equal( set(3).children_count, 0 )
+    assert_equal( set(4).children_count, 0 )
+    
+    set(2).add_child set(5)
+    set(4).add_child set(6)
+    
+    assert_equal( set(2).children_count, 3 )
+
+
+    # Children accessors
+    assert_equal( set(1).full_set.length, 6 )
+    assert_equal( set(2).full_set.length, 4 )
+    assert_equal( set(4).full_set.length, 2 )
+    
+    assert_equal( set(1).all_children.length, 5 )
+    assert_equal( set(6).all_children.length, 0 )
+    
+    assert_equal( set(1).direct_children.length, 2 )
+    
+  end
+
+  def test_snipping_tree
+    big_tree = NestedSetWithStringScope.find( 4001 )
+    
+    # Make sure we have the right one
+    assert_equal( 3, big_tree.direct_children.length )
+    assert_equal( 10, big_tree.full_set.length )
+    
+    NestedSetWithStringScope.find( 4005 ).destroy
+
+    big_tree = NestedSetWithStringScope.find( 4001 )
+    
+    assert_equal( 7, big_tree.full_set.length )
+    assert_equal( 2, big_tree.direct_children.length )
+    
+    assert_equal( 1, NestedSetWithStringScope.find(4001).lft )
+    assert_equal( 2, NestedSetWithStringScope.find(4002).lft )
+    assert_equal( 3, NestedSetWithStringScope.find(4003).lft )
+    assert_equal( 4, NestedSetWithStringScope.find(4003).rgt )
+    assert_equal( 5, NestedSetWithStringScope.find(4004).lft )
+    assert_equal( 6, NestedSetWithStringScope.find(4004).rgt )
+    assert_equal( 7, NestedSetWithStringScope.find(4002).rgt )
+    assert_equal( 8, NestedSetWithStringScope.find(4008).lft )
+    assert_equal( 9, NestedSetWithStringScope.find(4009).lft )
+    assert_equal(10, NestedSetWithStringScope.find(4009).rgt )
+    assert_equal(11, NestedSetWithStringScope.find(4010).lft )
+    assert_equal(12, NestedSetWithStringScope.find(4010).rgt )
+    assert_equal(13, NestedSetWithStringScope.find(4008).rgt )
+    assert_equal(14, NestedSetWithStringScope.find(4001).rgt )
+  end
+  
+  def test_deleting_root
+    NestedSetWithStringScope.find(4001).destroy
+    
+    assert( NestedSetWithStringScope.count == 0 )
+  end            
+                               
+  def test_common_usage
+    mixins(:set_1).add_child( mixins(:set_2) )
+    assert_equal( 1, mixins(:set_1).direct_children.length )
+
+    mixins(:set_2).add_child( mixins(:set_3) )                      
+    assert_equal( 1, mixins(:set_1).direct_children.length )     
+    
+    # Local cache is now out of date!
+    # Problem: the update_alls update all objects up the tree
+    mixins(:set_1).reload
+    assert_equal( 2, mixins(:set_1).all_children.length )              
+    
+    assert_equal( 1, mixins(:set_1).lft )
+    assert_equal( 2, mixins(:set_2).lft )
+    assert_equal( 3, mixins(:set_3).lft )
+    assert_equal( 4, mixins(:set_3).rgt )
+    assert_equal( 5, mixins(:set_2).rgt )
+    assert_equal( 6, mixins(:set_1).rgt )
+          
+    assert( mixins(:set_1).root? )
+                  
+    begin
+      mixins(:set_4).add_child( mixins(:set_1) )
+      fail
+    rescue
+    end
+    
+    assert_equal( 2, mixins(:set_1).all_children.length )
+    
+    mixins(:set_1).add_child mixins(:set_4)
+
+    assert_equal( 3, mixins(:set_1).all_children.length )
+  end
+  
+  def test_inheritance
+    parent = mixins(:sti_set_3100)
+    child = mixins(:sti_set_3101)
+    grandchild = mixins(:sti_set_3102)
+    assert_equal 5, parent.full_set.size
+    assert_equal 2, child.full_set.size
+    assert_equal 4, parent.all_children.size
+    assert_equal 1, child.all_children.size
+    assert_equal 2, parent.direct_children.size
+    assert_equal 1, child.direct_children.size
+    child.destroy
+    assert_equal 3, parent.full_set.size
+  end
+end

data/vendor/rails/activerecord/test/mixin_test.rb

@@ -0,0 +1,550 @@
+require 'abstract_unit'
+require 'active_record/acts/tree'
+require 'active_record/acts/list'
+require 'active_record/acts/nested_set'
+require 'fixtures/mixin'
+
+# Let us control what Time.now returns for the TouchTest suite
+class Time
+  @@forced_now_time = nil
+  cattr_accessor :forced_now_time
+  
+  class << self
+    def now_with_forcing
+      if @@forced_now_time
+        @@forced_now_time
+      else
+        now_without_forcing
+      end
+    end
+    alias_method_chain :now, :forcing
+  end
+end
+
+class ListTest < Test::Unit::TestCase
+  fixtures :mixins
+
+  def test_reordering
+    assert_equal [mixins(:list_1),
+                  mixins(:list_2),
+                  mixins(:list_3),
+                  mixins(:list_4)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+
+    mixins(:list_2).move_lower
+
+    assert_equal [mixins(:list_1),
+                  mixins(:list_3),
+                  mixins(:list_2),
+                  mixins(:list_4)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+
+    mixins(:list_2).move_higher
+
+    assert_equal [mixins(:list_1),
+                  mixins(:list_2),
+                  mixins(:list_3),
+                  mixins(:list_4)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+
+    mixins(:list_1).move_to_bottom
+
+    assert_equal [mixins(:list_2),
+                  mixins(:list_3),
+                  mixins(:list_4),
+                  mixins(:list_1)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+
+    mixins(:list_1).move_to_top
+
+    assert_equal [mixins(:list_1),
+                  mixins(:list_2),
+                  mixins(:list_3),
+                  mixins(:list_4)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+
+
+    mixins(:list_2).move_to_bottom
+
+    assert_equal [mixins(:list_1),
+                  mixins(:list_3),
+                  mixins(:list_4),
+                  mixins(:list_2)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+
+    mixins(:list_4).move_to_top
+
+    assert_equal [mixins(:list_4),
+                  mixins(:list_1),
+                  mixins(:list_3),
+                  mixins(:list_2)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+
+  end
+
+  def test_move_to_bottom_with_next_to_last_item
+    assert_equal [mixins(:list_1),
+                  mixins(:list_2),
+                  mixins(:list_3),
+                  mixins(:list_4)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+
+    mixins(:list_3).move_to_bottom
+
+    assert_equal [mixins(:list_1),
+                  mixins(:list_2),
+                  mixins(:list_4),
+                  mixins(:list_3)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+  end
+
+  def test_next_prev
+    assert_equal mixins(:list_2), mixins(:list_1).lower_item
+    assert_nil mixins(:list_1).higher_item
+    assert_equal mixins(:list_3), mixins(:list_4).higher_item
+    assert_nil mixins(:list_4).lower_item
+  end
+
+
+  def test_injection
+    item = ListMixin.new("parent_id"=>1)
+    assert_equal "parent_id = 1", item.scope_condition
+    assert_equal "pos", item.position_column
+  end
+
+  def test_insert
+    new = ListMixin.create("parent_id"=>20)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+
+    new = ListMixin.create("parent_id"=>20)
+    assert_equal 2, new.pos
+    assert !new.first?
+    assert new.last?
+
+    new = ListMixin.create("parent_id"=>20)
+    assert_equal 3, new.pos
+    assert !new.first?
+    assert new.last?
+
+    new = ListMixin.create("parent_id"=>0)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+  end
+
+  def test_insert_at
+    new = ListMixin.create("parent_id" => 20)
+    assert_equal 1, new.pos
+
+    new = ListMixin.create("parent_id" => 20)
+    assert_equal 2, new.pos
+
+    new = ListMixin.create("parent_id" => 20)
+    assert_equal 3, new.pos
+
+    new4 = ListMixin.create("parent_id" => 20)
+    assert_equal 4, new4.pos
+
+    new4.insert_at(3)
+    assert_equal 3, new4.pos
+
+    new.reload
+    assert_equal 4, new.pos
+
+    new.insert_at(2)
+    assert_equal 2, new.pos
+
+    new4.reload
+    assert_equal 4, new4.pos
+
+    new5 = ListMixin.create("parent_id" => 20)
+    assert_equal 5, new5.pos
+
+    new5.insert_at(1)
+    assert_equal 1, new5.pos
+
+    new4.reload
+    assert_equal 5, new4.pos
+  end
+
+  def test_delete_middle
+    assert_equal [mixins(:list_1),
+                  mixins(:list_2),
+                  mixins(:list_3),
+                  mixins(:list_4)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+
+    mixins(:list_2).destroy
+
+    assert_equal [mixins(:list_1, :reload),
+                  mixins(:list_3, :reload),
+                  mixins(:list_4, :reload)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+
+    assert_equal 1, mixins(:list_1).pos
+    assert_equal 2, mixins(:list_3).pos
+    assert_equal 3, mixins(:list_4).pos
+
+    mixins(:list_1).destroy
+
+    assert_equal [mixins(:list_3, :reload),
+                  mixins(:list_4, :reload)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+
+    assert_equal 1, mixins(:list_3).pos
+    assert_equal 2, mixins(:list_4).pos
+
+  end
+
+  def test_with_string_based_scope
+    new = ListWithStringScopeMixin.create("parent_id"=>500)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+  end
+
+  def test_nil_scope
+    new1, new2, new3 = ListMixin.create, ListMixin.create, ListMixin.create
+    new2.move_higher
+    assert_equal [new2, new1, new3], ListMixin.find(:all, :conditions => 'parent_id IS NULL', :order => 'pos')
+  end
+
+end
+
+class TreeTest < Test::Unit::TestCase
+  fixtures :mixins
+
+  def test_has_child
+    assert_deprecated 'has_children?' do
+      assert_equal true, mixins(:tree_1).has_children?
+      assert_equal true, mixins(:tree_2).has_children?
+      assert_equal false, mixins(:tree_3).has_children?
+      assert_equal false, mixins(:tree_4).has_children?
+    end
+  end
+
+  def test_children
+    assert_equal mixins(:tree_1).children, [mixins(:tree_2), mixins(:tree_4)]
+    assert_equal mixins(:tree_2).children, [mixins(:tree_3)]
+    assert_equal mixins(:tree_3).children, []
+    assert_equal mixins(:tree_4).children, []
+  end
+
+  def test_has_parent
+    assert_deprecated 'has_parent?' do
+      assert_equal false, mixins(:tree_1).has_parent?
+      assert_equal true, mixins(:tree_2).has_parent?
+      assert_equal true, mixins(:tree_3).has_parent?
+      assert_equal true, mixins(:tree_4).has_parent?
+    end
+  end
+
+  def test_parent
+    assert_equal mixins(:tree_2).parent, mixins(:tree_1)
+    assert_equal mixins(:tree_2).parent, mixins(:tree_4).parent
+    assert_nil mixins(:tree_1).parent
+  end
+
+  def test_delete
+    assert_equal 6, TreeMixin.count
+    mixins(:tree_1).destroy
+    assert_equal 2, TreeMixin.count
+    mixins(:tree2_1).destroy
+    mixins(:tree3_1).destroy
+    assert_equal 0, TreeMixin.count
+  end
+
+  def test_insert
+    @extra = mixins(:tree_1).children.create
+
+    assert @extra
+
+    assert_equal @extra.parent, mixins(:tree_1)
+
+    assert_equal 3, mixins(:tree_1).children.size
+    assert mixins(:tree_1).children.include?(@extra)
+    assert mixins(:tree_1).children.include?(mixins(:tree_2))
+    assert mixins(:tree_1).children.include?(mixins(:tree_4))
+  end
+
+  def test_ancestors
+    assert_equal [], mixins(:tree_1).ancestors
+    assert_equal [mixins(:tree_1)], mixins(:tree_2).ancestors
+    assert_equal [mixins(:tree_2), mixins(:tree_1)], mixins(:tree_3).ancestors
+    assert_equal [mixins(:tree_1)], mixins(:tree_4).ancestors
+    assert_equal [], mixins(:tree2_1).ancestors
+    assert_equal [], mixins(:tree3_1).ancestors
+  end
+
+  def test_root
+    assert_equal mixins(:tree_1), TreeMixin.root
+    assert_equal mixins(:tree_1), mixins(:tree_1).root
+    assert_equal mixins(:tree_1), mixins(:tree_2).root
+    assert_equal mixins(:tree_1), mixins(:tree_3).root
+    assert_equal mixins(:tree_1), mixins(:tree_4).root
+    assert_equal mixins(:tree2_1), mixins(:tree2_1).root
+    assert_equal mixins(:tree3_1), mixins(:tree3_1).root
+  end
+
+  def test_roots
+    assert_equal [mixins(:tree_1), mixins(:tree2_1), mixins(:tree3_1)], TreeMixin.roots
+  end
+
+  def test_siblings
+    assert_equal [mixins(:tree2_1), mixins(:tree3_1)], mixins(:tree_1).siblings
+    assert_equal [mixins(:tree_4)], mixins(:tree_2).siblings
+    assert_equal [], mixins(:tree_3).siblings
+    assert_equal [mixins(:tree_2)], mixins(:tree_4).siblings
+    assert_equal [mixins(:tree_1), mixins(:tree3_1)], mixins(:tree2_1).siblings
+    assert_equal [mixins(:tree_1), mixins(:tree2_1)], mixins(:tree3_1).siblings
+  end
+
+  def test_self_and_siblings
+    assert_equal [mixins(:tree_1), mixins(:tree2_1), mixins(:tree3_1)], mixins(:tree_1).self_and_siblings
+    assert_equal [mixins(:tree_2), mixins(:tree_4)], mixins(:tree_2).self_and_siblings
+    assert_equal [mixins(:tree_3)], mixins(:tree_3).self_and_siblings
+    assert_equal [mixins(:tree_2), mixins(:tree_4)], mixins(:tree_4).self_and_siblings
+    assert_equal [mixins(:tree_1), mixins(:tree2_1), mixins(:tree3_1)], mixins(:tree2_1).self_and_siblings
+    assert_equal [mixins(:tree_1), mixins(:tree2_1), mixins(:tree3_1)], mixins(:tree3_1).self_and_siblings
+  end
+end
+
+class TreeTestWithoutOrder < Test::Unit::TestCase
+  fixtures :mixins
+
+  def test_root
+    assert [mixins(:tree_without_order_1), mixins(:tree_without_order_2)].include?(TreeMixinWithoutOrder.root)
+  end
+
+  def test_roots
+    assert_equal [], [mixins(:tree_without_order_1), mixins(:tree_without_order_2)] - TreeMixinWithoutOrder.roots
+  end
+end
+
+class TouchTest < Test::Unit::TestCase
+  fixtures :mixins
+  
+  def setup
+    Time.forced_now_time = Time.now
+  end
+  
+  def teardown
+    Time.forced_now_time = nil
+  end
+
+  def test_time_mocking
+    five_minutes_ago = 5.minutes.ago
+    Time.forced_now_time = five_minutes_ago
+    assert_equal five_minutes_ago, Time.now
+    
+    Time.forced_now_time = nil
+    assert_not_equal five_minutes_ago, Time.now
+  end
+
+  def test_update
+    stamped = Mixin.new
+
+    assert_nil stamped.updated_at
+    assert_nil stamped.created_at
+    stamped.save
+    assert_equal Time.now, stamped.updated_at
+    assert_equal Time.now, stamped.created_at
+  end
+
+  def test_create
+    obj = Mixin.create
+    assert_equal Time.now, obj.updated_at
+    assert_equal Time.now, obj.created_at
+  end
+
+  def test_many_updates
+    stamped = Mixin.new
+
+    assert_nil stamped.updated_at
+    assert_nil stamped.created_at
+    stamped.save
+    assert_equal Time.now, stamped.created_at
+    assert_equal Time.now, stamped.updated_at
+
+    old_updated_at = stamped.updated_at
+
+    Time.forced_now_time = 5.minutes.from_now
+    stamped.save
+
+    assert_equal Time.now, stamped.updated_at
+    assert_equal old_updated_at, stamped.created_at
+  end
+
+  def test_create_turned_off
+    Mixin.record_timestamps = false
+
+    assert_nil mixins(:tree_1).updated_at
+    mixins(:tree_1).save
+    assert_nil mixins(:tree_1).updated_at
+
+    Mixin.record_timestamps = true
+  end
+
+end
+
+
+class ListSubTest < Test::Unit::TestCase
+  fixtures :mixins
+
+  def test_reordering
+    assert_equal [mixins(:list_sub_1),
+                  mixins(:list_sub_2),
+                  mixins(:list_sub_3),
+                  mixins(:list_sub_4)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos')
+
+    mixins(:list_sub_2).move_lower
+
+    assert_equal [mixins(:list_sub_1),
+                  mixins(:list_sub_3),
+                  mixins(:list_sub_2),
+                  mixins(:list_sub_4)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos')
+
+    mixins(:list_sub_2).move_higher
+
+    assert_equal [mixins(:list_sub_1),
+                  mixins(:list_sub_2),
+                  mixins(:list_sub_3),
+                  mixins(:list_sub_4)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos')
+
+    mixins(:list_sub_1).move_to_bottom
+
+    assert_equal [mixins(:list_sub_2),
+                  mixins(:list_sub_3),
+                  mixins(:list_sub_4),
+                  mixins(:list_sub_1)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos')
+
+    mixins(:list_sub_1).move_to_top
+
+    assert_equal [mixins(:list_sub_1),
+                  mixins(:list_sub_2),
+                  mixins(:list_sub_3),
+                  mixins(:list_sub_4)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos')
+
+
+    mixins(:list_sub_2).move_to_bottom
+
+    assert_equal [mixins(:list_sub_1),
+                  mixins(:list_sub_3),
+                  mixins(:list_sub_4),
+                  mixins(:list_sub_2)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos')
+
+    mixins(:list_sub_4).move_to_top
+
+    assert_equal [mixins(:list_sub_4),
+                  mixins(:list_sub_1),
+                  mixins(:list_sub_3),
+                  mixins(:list_sub_2)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos')
+
+  end
+
+  def test_move_to_bottom_with_next_to_last_item
+    assert_equal [mixins(:list_sub_1),
+                  mixins(:list_sub_2),
+                  mixins(:list_sub_3),
+                  mixins(:list_sub_4)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos')
+
+    mixins(:list_sub_3).move_to_bottom
+
+    assert_equal [mixins(:list_sub_1),
+                  mixins(:list_sub_2),
+                  mixins(:list_sub_4),
+                  mixins(:list_sub_3)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos')
+  end
+
+  def test_next_prev
+    assert_equal mixins(:list_sub_2), mixins(:list_sub_1).lower_item
+    assert_nil mixins(:list_sub_1).higher_item
+    assert_equal mixins(:list_sub_3), mixins(:list_sub_4).higher_item
+    assert_nil mixins(:list_sub_4).lower_item
+  end
+
+
+  def test_injection
+    item = ListMixin.new("parent_id"=>1)
+    assert_equal "parent_id = 1", item.scope_condition
+    assert_equal "pos", item.position_column
+  end
+
+
+  def test_insert_at
+    new = ListMixin.create("parent_id" => 20)
+    assert_equal 1, new.pos
+
+    new = ListMixinSub1.create("parent_id" => 20)
+    assert_equal 2, new.pos
+
+    new = ListMixinSub2.create("parent_id" => 20)
+    assert_equal 3, new.pos
+
+    new4 = ListMixin.create("parent_id" => 20)
+    assert_equal 4, new4.pos
+
+    new4.insert_at(3)
+    assert_equal 3, new4.pos
+
+    new.reload
+    assert_equal 4, new.pos
+
+    new.insert_at(2)
+    assert_equal 2, new.pos
+
+    new4.reload
+    assert_equal 4, new4.pos
+
+    new5 = ListMixinSub1.create("parent_id" => 20)
+    assert_equal 5, new5.pos
+
+    new5.insert_at(1)
+    assert_equal 1, new5.pos
+
+    new4.reload
+    assert_equal 5, new4.pos
+  end
+
+  def test_delete_middle
+    assert_equal [mixins(:list_sub_1),
+                  mixins(:list_sub_2),
+                  mixins(:list_sub_3),
+                  mixins(:list_sub_4)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos')
+
+    mixins(:list_sub_2).destroy
+
+    assert_equal [mixins(:list_sub_1, :reload),
+                  mixins(:list_sub_3, :reload),
+                  mixins(:list_sub_4, :reload)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos')
+
+    assert_equal 1, mixins(:list_sub_1).pos
+    assert_equal 2, mixins(:list_sub_3).pos
+    assert_equal 3, mixins(:list_sub_4).pos
+
+    mixins(:list_sub_1).destroy
+
+    assert_equal [mixins(:list_sub_3, :reload),
+                  mixins(:list_sub_4, :reload)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos')
+
+    assert_equal 1, mixins(:list_sub_3).pos
+    assert_equal 2, mixins(:list_sub_4).pos
+
+  end
+
+end
+