activerecord 1.13.0 → 1.13.1

data/test/fixtures/db_definitions/firebird2.drop.sql

@@ -0,0 +1,2 @@
+DROP TABLE courses;
+DROP GENERATOR courses_seq;

data/test/fixtures/db_definitions/firebird2.sql

@@ -0,0 +1,6 @@
+CREATE TABLE courses (
+  id BIGINT NOT NULL PRIMARY KEY,
+  name VARCHAR(255) NOT NULL
+);
+CREATE GENERATOR courses_seq;
+SET GENERATOR courses_seq TO 10000;

data/test/fixtures/db_definitions/oci.sql

@@ -261,3 +261,11 @@ create table keyboards (
 );
 create sequence keyboards_seq minvalue 10000;
 
+create table test_oci_defaults (
+  id integer not null primary key,
+  test_char char(1) default 'X' not null,
+  test_string varchar2(20) default 'hello' not null,
+  test_int integer default 3 not null
+);
+create sequence test_oci_defaults_seq minvalue 10000;
+

data/test/fixtures/db_definitions/postgresql.sql

@@ -1,10 +1,11 @@
+CREATE SEQUENCE public.accounts_id_seq START 100;
+
 CREATE TABLE accounts (
-    id serial,
+    id integer DEFAULT nextval('public.accounts_id_seq'),
     firm_id integer,
     credit_limit integer,
     PRIMARY KEY (id)
 );
-SELECT setval('accounts_id_seq', 100);
 
 CREATE SEQUENCE companies_nonstd_seq START 101;
 

data/test/fixtures/developer.rb

@@ -28,3 +28,13 @@ class DeveloperWithAggregate < ActiveRecord::Base
   self.table_name = 'developers'
   composed_of :salary, :class_name => 'DeveloperSalary', :mapping => [%w(salary amount)]
 end
+
+class DeveloperWithBeforeDestroyRaise < ActiveRecord::Base
+  self.table_name = 'developers'
+  has_and_belongs_to_many :projects, :join_table => 'developers_projects', :foreign_key => 'developer_id'
+  before_destroy :raise_if_projects_empty!
+
+  def raise_if_projects_empty!
+    raise if projects.empty?
+  end
+end

data/test/fixtures/mixin.rb

@@ -6,12 +6,22 @@ class TreeMixin < Mixin
     acts_as_tree :foreign_key => "parent_id", :order => "id"
 end
 
+class TreeMixinWithoutOrder < Mixin
+    acts_as_tree :foreign_key => "parent_id"
+end
+
 class ListMixin < Mixin
   acts_as_list :column => "pos", :scope => :parent
 
   def self.table_name() "mixins" end
 end
 
+class ListMixinSub1 < ListMixin
+end
+
+class ListMixinSub2 < ListMixin
+end
+
 
 class ListWithStringScopeMixin < ActiveRecord::Base
   acts_as_list :column => "pos", :scope => 'parent_id = #{parent_id}'
@@ -35,4 +45,4 @@ class NestedSetWithSymbolScope < Mixin
   acts_as_nested_set :scope => :root
   
   def self.table_name() "mixins" end
-end
+end

data/test/fixtures/mixins.yml

@@ -28,7 +28,17 @@ tree3_1:
   id: 1006
   type: TreeMixin
   parent_id:
-  
+
+tree_without_order_1:
+  id: 1101
+  type: TreeMixinWithoutOrder
+  parent_id:
+
+tree_without_order_2:
+  id: 1100
+  type: TreeMixinWithoutOrder
+  parent_id:
+
 # List mixins
 
 <% (1..4).each do |counter| %>  
@@ -68,3 +78,12 @@ tree_<%= set[0] %>:
   root_id: 42
 
 <% end %>
+
+# subclasses of list items
+<% (1..4).each do |i| %>
+list_sub_<%= i %>:
+  id: <%= i + 5000 %>
+  pos: <%= i %>
+  parent_id: 5000
+  type: <%= (i % 2 == 1) ? ListMixinSub1 : ListMixinSub2 %> 
+<% end %>

data/test/fixtures_test.rb

@@ -51,42 +51,44 @@ class FixturesTest < Test::Unit::TestCase
     assert_nil(secondRow["author_email_address"])
   end
 
-  def test_inserts_with_pre_and_suffix
-    ActiveRecord::Base.connection.create_table :prefix_topics_suffix do |t|
-      t.column :title, :string
-      t.column :author_name, :string
-      t.column :author_email_address, :string
-      t.column :written_on, :datetime
-      t.column :bonus_time, :time
-      t.column :last_read, :date
-      t.column :content, :text
-      t.column :approved, :boolean, :default => true
-      t.column :replies_count, :integer, :default => 0
-      t.column :parent_id, :integer
-      t.column :type, :string, :limit => 50
-    end
+  if ActiveRecord::Base.connection.supports_migrations?
+    def test_inserts_with_pre_and_suffix
+      ActiveRecord::Base.connection.create_table :prefix_topics_suffix do |t|
+        t.column :title, :string
+        t.column :author_name, :string
+        t.column :author_email_address, :string
+        t.column :written_on, :datetime
+        t.column :bonus_time, :time
+        t.column :last_read, :date
+        t.column :content, :text
+        t.column :approved, :boolean, :default => true
+        t.column :replies_count, :integer, :default => 0
+        t.column :parent_id, :integer
+        t.column :type, :string, :limit => 50
+      end
 
-    # Store existing prefix/suffix
-    old_prefix = ActiveRecord::Base.table_name_prefix
-    old_suffix = ActiveRecord::Base.table_name_suffix
+      # Store existing prefix/suffix
+      old_prefix = ActiveRecord::Base.table_name_prefix
+      old_suffix = ActiveRecord::Base.table_name_suffix
 
-    # Set a prefix/suffix we can test against
-    ActiveRecord::Base.table_name_prefix = 'prefix_'
-    ActiveRecord::Base.table_name_suffix = '_suffix'
+      # Set a prefix/suffix we can test against
+      ActiveRecord::Base.table_name_prefix = 'prefix_'
+      ActiveRecord::Base.table_name_suffix = '_suffix'
 
-    topics = create_fixtures("topics")
+      topics = create_fixtures("topics")
 
-    # Restore prefix/suffix to its previous values
-    ActiveRecord::Base.table_name_prefix = old_prefix 
-    ActiveRecord::Base.table_name_suffix = old_suffix 
+      # Restore prefix/suffix to its previous values
+      ActiveRecord::Base.table_name_prefix = old_prefix 
+      ActiveRecord::Base.table_name_suffix = old_suffix 
 
-    firstRow = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'David'")
-    assert_equal("The First Topic", firstRow["title"])
+      firstRow = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'David'")
+      assert_equal("The First Topic", firstRow["title"])
 
-    secondRow = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'Mary'")
-    assert_nil(secondRow["author_email_address"])        
-  ensure
-    ActiveRecord::Base.connection.drop_table :prefix_topics_suffix rescue nil
+      secondRow = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'Mary'")
+      assert_nil(secondRow["author_email_address"])        
+    ensure
+      ActiveRecord::Base.connection.drop_table :prefix_topics_suffix rescue nil
+    end
   end
 
   def test_insert_with_datetime
@@ -173,27 +175,45 @@ end
 if Account.connection.respond_to?(:reset_pk_sequence!)
   class FixturesResetPkSequenceTest < Test::Unit::TestCase
     fixtures :accounts
+    fixtures :companies
+
+    def setup
+      @instances = [Account.new(:credit_limit => 50), Company.new(:name => 'RoR Consulting')]
+    end
 
-    def test_resets_to_min_pk
-      Account.delete_all
-      Account.connection.reset_pk_sequence!(Account.table_name)
+    def test_resets_to_min_pk_with_specified_pk_and_sequence
+      @instances.each do |instance|
+        model = instance.class
+        model.delete_all
+        model.connection.reset_pk_sequence!(model.table_name, model.primary_key, model.sequence_name)
 
-      one = Account.new(:credit_limit => 50)
-      one.save!
-      assert_equal 1, one.id
+        instance.save!
+        assert_equal 1, instance.id, "Sequence reset for #{model.table_name} failed."
+      end
     end
 
-    def test_create_fixtures_resets_sequences
-      # create_fixtures performs reset_pk_sequence!
-      max_id = create_fixtures('accounts').inject(0) do |max_id, (name, fixture)|
-        fixture_id = fixture['id'].to_i
-        fixture_id > max_id ? fixture_id : max_id
+    def test_resets_to_min_pk_with_default_pk_and_sequence
+      @instances.each do |instance|
+        model = instance.class
+        model.delete_all
+        model.connection.reset_pk_sequence!(model.table_name)
+
+        instance.save!
+        assert_equal 1, instance.id, "Sequence reset for #{model.table_name} failed."
       end
+    end
 
-      # Clone the last fixture to check that it gets the next greatest id.
-      another = Account.new(:credit_limit => 1200)
-      another.save!
-      assert_equal max_id + 1, another.id
+    def test_create_fixtures_resets_sequences
+      @instances.each do |instance|
+        max_id = create_fixtures(instance.class.table_name).inject(0) do |max_id, (name, fixture)|
+          fixture_id = fixture['id'].to_i
+          fixture_id > max_id ? fixture_id : max_id
+        end
+
+        # Clone the last fixture to check that it gets the next greatest id.
+        instance.save!
+        assert_equal max_id + 1, instance.id, "Sequence reset for #{instance.class.table_name} failed."
+      end
     end
   end
 end

data/test/inheritance_test.rb

@@ -11,7 +11,7 @@ class InheritanceTest < Test::Unit::TestCase
     if current_adapter?(:SQLServerAdapter)
       Company.connection.execute "SET IDENTITY_INSERT companies ON"
     end
-    Company.connection.insert "INSERT INTO companies (id, type, name) VALUES(100, 'bad_class!', 'Not happening')"
+    Company.connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')"
 
     #We then need to turn it back Off before continuing.
     if current_adapter?(:SQLServerAdapter)

data/test/migration_test.rb

@@ -362,6 +362,9 @@ if ActiveRecord::Base.connection.supports_migrations?
       ActiveRecord::Base.table_name_suffix = ""
       Reminder.reset_table_name
       assert_equal "schema_info", ActiveRecord::Migrator.schema_info_table_name
+    ensure
+      ActiveRecord::Base.table_name_prefix = ""
+      ActiveRecord::Base.table_name_suffix = ""
     end
   
     def test_proper_table_name
@@ -398,17 +401,20 @@ if ActiveRecord::Base.connection.supports_migrations?
       ActiveRecord::Base.table_name_prefix = 'prefix_'
       ActiveRecord::Base.table_name_suffix = '_suffix'
       Reminder.reset_table_name
+      Reminder.reset_sequence_name
       WeNeedReminders.up
       assert Reminder.create("content" => "hello world", "remind_at" => Time.now)
       assert_equal "hello world", Reminder.find(:first).content
 
       WeNeedReminders.down
       assert_raises(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
+    ensure
       ActiveRecord::Base.table_name_prefix = ''
       ActiveRecord::Base.table_name_suffix = ''
       Reminder.reset_table_name
+      Reminder.reset_sequence_name
     end
-    
+
     def test_migrator_with_duplicates
       assert_raises(ActiveRecord::DuplicateMigrationVersionError) do
         ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations_with_duplicate/', nil)

data/test/mixin_test.rb

@@ -6,96 +6,95 @@ require 'fixtures/mixin'
 
 class ListTest < Test::Unit::TestCase
   fixtures :mixins
- 
+
   def test_reordering
-    
-    assert_equal [mixins(:list_1), 
-                  mixins(:list_2), 
-                  mixins(:list_3), 
-                  mixins(:list_4)], 
+    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)], 
+
+    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)], 
+    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)], 
+    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), 
+    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), 
+
+    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), 
+    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)], 
+    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)], 
+    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  
-  
+  end
+
   def test_insert
     new = ListMixin.create("parent_id"=>20)
     assert_equal 1, new.pos
@@ -106,37 +105,37 @@ class ListTest < Test::Unit::TestCase
     assert_equal 2, new.pos
     assert !new.first?
     assert new.last?
-    
+
     new = ListMixin.create("parent_id"=>20)
-    assert_equal 3, new.pos    
+    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    
+  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
+    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 = ListMixin.create("parent_id" => 20)
-	 assert_equal 4, new4.pos
+    new4.insert_at(3)
+    assert_equal 3, new4.pos
 
-	 new4.insert_at(3)
-	 assert_equal 3, new4.pos
+    new.reload
+    assert_equal 4, new.pos
 
-	 new.reload
-	 assert_equal 4, new.pos
-    
     new.insert_at(2)
     assert_equal 2, new.pos
 
@@ -152,54 +151,54 @@ class ListTest < Test::Unit::TestCase
     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)], 
+    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)], 
+
+    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)], 
+    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  
+
+  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 
+  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_equal true, mixins(:tree_1).has_children?
     assert_equal true, mixins(:tree_2).has_children?
@@ -226,7 +225,7 @@ class TreeTest < Test::Unit::TestCase
     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
@@ -238,9 +237,9 @@ class TreeTest < Test::Unit::TestCase
 
   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
@@ -257,7 +256,7 @@ class TreeTest < Test::Unit::TestCase
     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
@@ -266,7 +265,7 @@ class TreeTest < Test::Unit::TestCase
     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                                                                  
+  end
 
   def test_roots
     assert_equal [mixins(:tree_1), mixins(:tree2_1), mixins(:tree3_1)], TreeMixin.roots
@@ -291,40 +290,50 @@ class TreeTest < Test::Unit::TestCase
   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 test_update
-    
-    stamped = Mixin.new 
-      
+    stamped = Mixin.new
+
     assert_nil stamped.updated_at
     assert_nil stamped.created_at
     stamped.save
     assert_not_nil stamped.updated_at
     assert_not_nil stamped.created_at
-  end  
+  end
 
   def test_create
     @obj = Mixin.create
     assert_not_nil @obj.updated_at
     assert_not_nil @obj.created_at
-  end  
+  end
 
   def test_many_updates
-
-    stamped = Mixin.new 
+    stamped = Mixin.new
 
     assert_nil stamped.updated_at
     assert_nil stamped.created_at
     stamped.save
     assert_not_nil stamped.created_at
     assert_not_nil stamped.updated_at
-    
+
     old_updated_at = stamped.updated_at
 
     sleep 1
-    stamped.save    
+    stamped.save
     assert_not_equal stamped.created_at, stamped.updated_at
     assert_not_equal old_updated_at, stamped.updated_at
 
@@ -341,3 +350,163 @@ class TouchTest < Test::Unit::TestCase
   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
+