acts_as_list 0.1.4 → 0.2.0

data/test/test_list.rb

@@ -1,12 +1,16 @@
 # NOTE: following now done in helper.rb (better Readability)
-require 'helper.rb'
+require 'helper'
 
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+ActiveRecord::Schema.verbose = false
 
-def setup_db
+def setup_db(position_options = {})
+  # AR caches columns options like defaults etc. Clear them!
+  ActiveRecord::Base.connection.schema_cache.clear!
   ActiveRecord::Schema.define(:version => 1) do
     create_table :mixins do |t|
-      t.column :pos, :integer
+      t.column :pos, :integer, position_options
+      t.column :active, :boolean, :default => true
       t.column :parent_id, :integer
       t.column :parent_type, :string
       t.column :created_at, :datetime
@@ -15,6 +19,10 @@ def setup_db
   end
 end
 
+def setup_db_with_default
+  setup_db :default => 0
+end
+
 # Returns true if ActiveRecord is rails3 version
 def rails_3
   defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::MAJOR >= 3
@@ -27,624 +35,442 @@ def teardown_db
 end
 
 class Mixin < ActiveRecord::Base
+  self.table_name = 'mixins'
+  attr_accessible :active, :parent_id, :parent_type
+end
+
+class ProtectedMixin < ActiveRecord::Base
+  self.table_name = 'mixins'
+  attr_protected :active
+end
+
+class ProtectedListMixin < ProtectedMixin
+  acts_as_list :column => "pos"
+end
+
+class UnProtectedMixin < ActiveRecord::Base
+  self.table_name = 'mixins'
 end
 
+class UnProtectedListMixin < UnProtectedMixin
+  acts_as_list :column => "pos"
+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
+  if rails_3
+    validates :pos, :presence => true
+  else
+    validates_presence_of :pos
+  end
 end
 
-class ListWithStringScopeMixin < ActiveRecord::Base
+class ListWithStringScopeMixin < Mixin
   acts_as_list :column => "pos", :scope => 'parent_id = #{parent_id}'
-
-  def self.table_name() "mixins" end
 end
 
 class ArrayScopeListMixin < Mixin
   acts_as_list :column => "pos", :scope => [:parent_id, :parent_type]
-
-  def self.table_name() "mixins" end
 end
 
-class ZeroBasedMixin < ActiveRecord::Base
+class ZeroBasedMixin < Mixin
   acts_as_list :column => "pos", :top_of_list => 0, :scope => [:parent_id]
+end
 
-  def self.table_name() "mixins" end
+class DefaultScopedMixin < Mixin
+  acts_as_list :column => "pos"
+  default_scope { order('pos ASC') }
 end
 
+class DefaultScopedWhereMixin < Mixin
+  acts_as_list :column => "pos"
+  default_scope { order('pos ASC').where(:active => true) }
+end
 
-class ZeroBasedTest < Test::Unit::TestCase
-   def setup
-    setup_db
-     (1..4).each { |counter| ZeroBasedMixin.create! :pos => counter, :parent_id => 5 }
-  end
+class TopAdditionMixin < Mixin
+  acts_as_list :column => "pos", :add_new_at => :top, :scope => :parent_id
+end
+
+class ActsAsListTestCase < Test::Unit::TestCase
+  # No default test required a this class is abstract.
+  # Need for test/unit.
+  undef_method :default_test if method_defined?(:default_test)
 
   def teardown
     teardown_db
   end
+end
 
-  def test_insert
-    new = ZeroBasedMixin.create(:parent_id => 20)
-    assert_equal 0, new.pos
-    assert new.first?
-    assert new.last?
-
-    new = ZeroBasedMixin.create(:parent_id => 20)
-    assert_equal 1, new.pos
-    assert !new.first?
-    assert new.last?
-
-    new = ZeroBasedMixin.create(:parent_id => 20)
-    assert_equal 2, new.pos
-    assert !new.first?
-    assert new.last?
+class ZeroBasedTest < ActsAsListTestCase
+  include Shared::ZeroBased
 
-    new = ZeroBasedMixin.create(:parent_id => 0)
-    assert_equal 0, new.pos
-    assert new.first?
-    assert new.last?
+  def setup
+    setup_db
+    super
   end
+end
 
-  def test_reordering
-    assert_equal [1, 2, 3, 4], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+class ZeroBasedTestWithDefault < ActsAsListTestCase
+  include Shared::ZeroBased
 
-    ListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+  def setup
+    setup_db_with_default
+    super
   end
+end
 
-  def test_insert_at
-    new = ZeroBasedMixin.create(:parent_id => 20)
-    assert_equal 0, new.pos
-
-    new = ZeroBasedMixin.create(:parent_id => 20)
-    assert_equal 1, new.pos
-
-    new = ZeroBasedMixin.create(:parent_id => 20)
-    assert_equal 2, new.pos
-
-    new4 = ZeroBasedMixin.create(:parent_id => 20)
-    assert_equal 3, new4.pos
-
-    new4.insert_at(2)
-    assert_equal 2, new4.pos
-
-    new.reload
-    assert_equal 3, new.pos
-
-    new.insert_at(2)
-    assert_equal 2, new.pos
+class ListTest < ActsAsListTestCase
+  include Shared::List
 
-    new4.reload
-    assert_equal 3, new4.pos
-
-    new5 = ListMixin.create(:parent_id => 20)
-    assert_equal 4, new5.pos
+  def setup
+    setup_db
+    super
+  end
+end
 
-    new5.insert_at(1)
-    assert_equal 1, new5.pos
+class ListTestWithDefault < ActsAsListTestCase
+  include Shared::List
 
-    new4.reload
-    assert_equal 4, new4.pos
+  def setup
+    setup_db_with_default
+    super
   end
-
 end
 
-
-class ListTest < Test::Unit::TestCase
+class ListSubTest < ActsAsListTestCase
+  include Shared::ListSub
 
   def setup
     setup_db
-    (1..4).each { |counter| ListMixin.create! :pos => counter, :parent_id => 5 }
-  end
-
-  def teardown
-    teardown_db
+    super
   end
+end
 
-  def test_reordering
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+class ListSubTestWithDefault < ActsAsListTestCase
+  include Shared::ListSub
 
-    ListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+  def setup
+    setup_db_with_default
+    super
+  end
+end
 
-    ListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+class ArrayScopeListTest < ActsAsListTestCase
+  include Shared::ArrayScopeList
 
-    ListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+  def setup
+    setup_db
+    super
   end
+end
 
-  def test_move_to_bottom_with_next_to_last_item
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-    ListMixin.find(3).move_to_bottom
-    assert_equal [1, 2, 4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-  end
+class ArrayScopeListTestWithDefault < ActsAsListTestCase
+  include Shared::ArrayScopeList
 
-  def test_next_prev
-    assert_equal ListMixin.find(2), ListMixin.find(1).lower_item
-    assert_nil ListMixin.find(1).higher_item
-    assert_equal ListMixin.find(3), ListMixin.find(4).higher_item
-    assert_nil ListMixin.find(4).lower_item
+  def setup
+    setup_db_with_default
+    super
   end
+end
 
-  def test_injection
-    item = ListMixin.new(:parent_id => 1)
-    assert_equal '"mixins"."parent_id" = 1', item.scope_condition
-    assert_equal "pos", item.position_column
+class DefaultScopedTest < ActsAsListTestCase
+  def setup
+    setup_db
+    (1..4).each { |counter| DefaultScopedMixin.create!({:pos => counter}) }
   end
 
   def test_insert
-    new = ListMixin.create(:parent_id => 20)
-    assert_equal 1, new.pos
-    assert new.first?
+    new = DefaultScopedMixin.create
+    assert_equal 5, new.pos
+    assert !new.first?
     assert new.last?
 
-    new = ListMixin.create(:parent_id => 20)
-    assert_equal 2, new.pos
+    new = DefaultScopedMixin.create
+    assert_equal 6, new.pos
     assert !new.first?
     assert new.last?
 
-    new = ListMixin.create(:parent_id => 20)
-    assert_equal 3, new.pos
+    new = DefaultScopedMixin.create
+    assert_equal 7, new.pos
     assert !new.first?
     assert new.last?
+  end
 
-    new = ListMixin.create(:parent_id => 0)
-    assert_equal 1, new.pos
-    assert new.first?
-    assert new.last?
+  def test_reordering
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+
+    DefaultScopedMixin.find(2).move_lower
+    assert_equal [1, 3, 2, 4], DefaultScopedMixin.find(:all).map(&:id)
+
+    DefaultScopedMixin.find(2).move_higher
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+
+    DefaultScopedMixin.find(1).move_to_bottom
+    assert_equal [2, 3, 4, 1], DefaultScopedMixin.find(:all).map(&:id)
+
+    DefaultScopedMixin.find(1).move_to_top
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+
+    DefaultScopedMixin.find(2).move_to_bottom
+    assert_equal [1, 3, 4, 2], DefaultScopedMixin.find(:all).map(&:id)
+
+    DefaultScopedMixin.find(4).move_to_top
+    assert_equal [4, 1, 3, 2], DefaultScopedMixin.find(:all).map(&:id)
   end
 
   def test_insert_at
-    new = ListMixin.create(:parent_id => 20)
-    assert_equal 1, new.pos
+    new = DefaultScopedMixin.create
+    assert_equal 5, new.pos
 
-    new = ListMixin.create(:parent_id => 20)
-    assert_equal 2, new.pos
+    new = DefaultScopedMixin.create
+    assert_equal 6, new.pos
 
-    new = ListMixin.create(:parent_id => 20)
-    assert_equal 3, new.pos
+    new = DefaultScopedMixin.create
+    assert_equal 7, new.pos
 
-    new4 = ListMixin.create(:parent_id => 20)
-    assert_equal 4, new4.pos
+    new4 = DefaultScopedMixin.create
+    assert_equal 8, new4.pos
 
-    new4.insert_at(3)
-    assert_equal 3, new4.pos
+    new4.insert_at(2)
+    assert_equal 2, new4.pos
 
     new.reload
-    assert_equal 4, new.pos
+    assert_equal 8, new.pos
 
     new.insert_at(2)
     assert_equal 2, new.pos
 
     new4.reload
-    assert_equal 4, new4.pos
+    assert_equal 3, new4.pos
 
-    new5 = ListMixin.create(:parent_id => 20)
-    assert_equal 5, new5.pos
+    new5 = DefaultScopedMixin.create
+    assert_equal 9, 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 [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).destroy
-
-    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    assert_equal 1, ListMixin.find(1).pos
-    assert_equal 2, ListMixin.find(3).pos
-    assert_equal 3, ListMixin.find(4).pos
-
-    ListMixin.find(1).destroy
-
-    assert_equal [3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    assert_equal 1, ListMixin.find(3).pos
-    assert_equal 2, ListMixin.find(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
-
-  def test_remove_from_list_should_then_fail_in_list?
-    assert_equal true, ListMixin.find(1).in_list?
-    ListMixin.find(1).remove_from_list
-    assert_equal false, ListMixin.find(1).in_list?
-  end
-
-  def test_remove_from_list_should_set_position_to_nil
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).remove_from_list
-
-    assert_equal [2, 1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    assert_equal 1,   ListMixin.find(1).pos
-    assert_equal nil, ListMixin.find(2).pos
-    assert_equal 2,   ListMixin.find(3).pos
-    assert_equal 3,   ListMixin.find(4).pos
+    assert_equal 4, new4.pos
   end
 
-  def test_remove_before_destroy_does_not_shift_lower_items_twice
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).remove_from_list
-    ListMixin.find(2).destroy
-
-    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    assert_equal 1, ListMixin.find(1).pos
-    assert_equal 2, ListMixin.find(3).pos
-    assert_equal 3, ListMixin.find(4).pos
+  def test_update_position
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.find(2).set_list_position(4)
+    assert_equal [1, 3, 4, 2], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.find(2).set_list_position(2)
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.find(1).set_list_position(4)
+    assert_equal [2, 3, 4, 1], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.find(1).set_list_position(1)
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
   end
 
-  def test_before_destroy_callbacks_do_not_update_position_to_nil_before_deleting_the_record
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    # We need to trigger all the before_destroy callbacks without actually
-    # destroying the record so we can see the affect the callbacks have on
-    # the record.
-    # NOTE: Hotfix for rails3 ActiveRecord
-    list = ListMixin.find(2)
-    if list.respond_to?(:run_callbacks)
-      # Refactored to work according to Rails3 ActiveRSupport Callbacks <http://api.rubyonrails.org/classes/ActiveSupport/Callbacks.html>
-      list.run_callbacks :destroy, :before if rails_3
-      list.run_callbacks(:before_destroy) if !rails_3
-    else
-      list.send(:callback, :before_destroy)
-    end
-
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+end
 
-    assert_equal 1, ListMixin.find(1).pos
-    assert_equal 2, ListMixin.find(2).pos
-    assert_equal 2, ListMixin.find(3).pos
-    assert_equal 3, ListMixin.find(4).pos
+class DefaultScopedWhereTest < ActsAsListTestCase
+  def setup
+    setup_db
+    (1..4).each { |counter| DefaultScopedWhereMixin.create! :pos => counter, :active => false }
   end
 
-  def test_before_create_callback_adds_to_bottom
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    new = ListMixin.create(:parent_id => 5)
+  def test_insert
+    new = DefaultScopedWhereMixin.create
     assert_equal 5, new.pos
     assert !new.first?
     assert new.last?
 
-    assert_equal [1, 2, 3, 4, 5], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-  end
-
-  def test_before_create_callback_adds_to_given_position
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    new = ListMixin.create(:pos => 1, :parent_id => 5)
-    assert_equal 1, new.pos
-    assert new.first?
-    assert !new.last?
-
-    assert_equal [5, 1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-    new = ListMixin.create(:pos => 3, :parent_id => 5)
-    assert_equal 3, new.pos
+    new = DefaultScopedWhereMixin.create
+    assert_equal 6, new.pos
     assert !new.first?
-    assert !new.last?
-
-    assert_equal [5, 1, 6, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-  end
-end
-
-class ListSubTest < Test::Unit::TestCase
-
-  def setup
-    setup_db
-    (1..4).each { |i| ((i % 2 == 1) ? ListMixinSub1 : ListMixinSub2).create! :pos => i, :parent_id => 5000 }
-  end
+    assert new.last?
 
-  def teardown
-    teardown_db
+    new = DefaultScopedWhereMixin.create
+    assert_equal 7, new.pos
+    assert !new.first?
+    assert new.last?
   end
 
   def test_reordering
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).map(&:id)
 
-    ListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    DefaultScopedWhereMixin.where(:active => false).find(2).move_lower
+    assert_equal [1, 3, 2, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
 
-    ListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    DefaultScopedWhereMixin.where(:active => false).find(2).move_higher
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
 
-    ListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    DefaultScopedWhereMixin.where(:active => false).find(1).move_to_bottom
+    assert_equal [2, 3, 4, 1], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
 
-    ListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    DefaultScopedWhereMixin.where(:active => false).find(1).move_to_top
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
 
-    ListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    DefaultScopedWhereMixin.where(:active => false).find(2).move_to_bottom
+    assert_equal [1, 3, 4, 2], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
 
-    ListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-  end
-
-  def test_move_to_bottom_with_next_to_last_item
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-    ListMixin.find(3).move_to_bottom
-    assert_equal [1, 2, 4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-  end
-
-  def test_next_prev
-    assert_equal ListMixin.find(2), ListMixin.find(1).lower_item
-    assert_nil ListMixin.find(1).higher_item
-    assert_equal ListMixin.find(3), ListMixin.find(4).higher_item
-    assert_nil ListMixin.find(4).lower_item
-  end
-
-  def test_injection
-    item = ListMixin.new("parent_id"=>1)
-    assert_equal '"mixins"."parent_id" = 1', item.scope_condition
-    assert_equal "pos", item.position_column
+    DefaultScopedWhereMixin.where(:active => false).find(4).move_to_top
+    assert_equal [4, 1, 3, 2], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
   end
 
   def test_insert_at
-    new = ListMixin.create("parent_id" => 20)
-    assert_equal 1, new.pos
+    new = DefaultScopedWhereMixin.create
+    assert_equal 5, new.pos
 
-    new = ListMixinSub1.create("parent_id" => 20)
-    assert_equal 2, new.pos
+    new = DefaultScopedWhereMixin.create
+    assert_equal 6, new.pos
 
-    new = ListMixinSub2.create("parent_id" => 20)
-    assert_equal 3, new.pos
+    new = DefaultScopedWhereMixin.create
+    assert_equal 7, new.pos
 
-    new4 = ListMixin.create("parent_id" => 20)
-    assert_equal 4, new4.pos
+    new4 = DefaultScopedWhereMixin.create
+    assert_equal 8, new4.pos
 
-    new4.insert_at(3)
-    assert_equal 3, new4.pos
+    new4.insert_at(2)
+    assert_equal 2, new4.pos
 
     new.reload
-    assert_equal 4, new.pos
+    assert_equal 8, new.pos
 
     new.insert_at(2)
     assert_equal 2, new.pos
 
     new4.reload
-    assert_equal 4, new4.pos
+    assert_equal 3, new4.pos
 
-    new5 = ListMixinSub1.create("parent_id" => 20)
-    assert_equal 5, new5.pos
+    new5 = DefaultScopedWhereMixin.create
+    assert_equal 9, new5.pos
 
     new5.insert_at(1)
     assert_equal 1, new5.pos
 
     new4.reload
-    assert_equal 5, new4.pos
+    assert_equal 4, new4.pos
   end
 
-  def test_delete_middle
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-
-    ListMixin.find(2).destroy
-
-    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-
-    assert_equal 1, ListMixin.find(1).pos
-    assert_equal 2, ListMixin.find(3).pos
-    assert_equal 3, ListMixin.find(4).pos
-
-    ListMixin.find(1).destroy
-
-    assert_equal [3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
-
-    assert_equal 1, ListMixin.find(3).pos
-    assert_equal 2, ListMixin.find(4).pos
+  def test_update_position
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+    DefaultScopedWhereMixin.where(:active => false).find(2).set_list_position(4)
+    assert_equal [1, 3, 4, 2], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+    DefaultScopedWhereMixin.where(:active => false).find(2).set_list_position(2)
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+    DefaultScopedWhereMixin.where(:active => false).find(1).set_list_position(4)
+    assert_equal [2, 3, 4, 1], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+    DefaultScopedWhereMixin.where(:active => false).find(1).set_list_position(1)
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
   end
 
 end
 
-class ArrayScopeListTest < Test::Unit::TestCase
+class MultiDestroyTest < ActsAsListTestCase
 
   def setup
     setup_db
-    (1..4).each { |counter| ArrayScopeListMixin.create! :pos => counter, :parent_id => 5, :parent_type => 'ParentClass' }
-  end
-
-  def teardown
-    teardown_db
   end
 
-  def test_reordering
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-
-    ArrayScopeListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-
-    ArrayScopeListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-
-    ArrayScopeListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-
-    ArrayScopeListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-
-    ArrayScopeListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-
-    ArrayScopeListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+  # example:
+  #
+  #   class TodoList < ActiveRecord::Base
+  #     has_many :todo_items, :order => "position"
+  #     accepts_nested_attributes_for :todo_items, :allow_destroy => true
+  #   end
+  #
+  #   class TodoItem < ActiveRecord::Base
+  #     belongs_to :todo_list
+  #     acts_as_list :scope => :todo_list
+  #   end
+  #
+  # Assume that there are three items.
+  # The user mark two items as deleted, click save button, form will be post:
+  #
+  # todo_list.todo_items_attributes = [
+  #   {id: 1, _destroy: true},
+  #   {id: 2, _destroy: true}
+  # ]
+  #
+  # Save toto_list, the position of item #3 should eql 1.
+  #
+  def test_destroy
+    new1 = DefaultScopedMixin.create
+    assert_equal 1, new1.pos
+
+    new2 = DefaultScopedMixin.create
+    assert_equal 2, new2.pos
+
+    new3 = DefaultScopedMixin.create
+    assert_equal 3, new3.pos
+
+    new1.destroy
+    new2.destroy
+    new3.reload
+    assert_equal 1, new3.pos
   end
+end
 
-  def test_move_to_bottom_with_next_to_last_item
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-    ArrayScopeListMixin.find(3).move_to_bottom
-    assert_equal [1, 2, 4, 3], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-  end
+#class TopAdditionMixin < Mixin
 
-  def test_next_prev
-    assert_equal ArrayScopeListMixin.find(2), ArrayScopeListMixin.find(1).lower_item
-    assert_nil ArrayScopeListMixin.find(1).higher_item
-    assert_equal ArrayScopeListMixin.find(3), ArrayScopeListMixin.find(4).higher_item
-    assert_nil ArrayScopeListMixin.find(4).lower_item
-  end
+class TopAdditionTest < ActsAsListTestCase
+  include Shared::TopAddition
 
-  def test_injection
-    item = ArrayScopeListMixin.new(:parent_id => 1, :parent_type => 'ParentClass')
-    assert_equal '"mixins"."parent_id" = 1 AND "mixins"."parent_type" = \'ParentClass\'', item.scope_condition
-    assert_equal "pos", item.position_column
+  def setup
+    setup_db
+    super
   end
+end
 
-  def test_insert
-    new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
-    assert_equal 1, new.pos
-    assert new.first?
-    assert new.last?
-
-    new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
-    assert_equal 2, new.pos
-    assert !new.first?
-    assert new.last?
 
-    new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
-    assert_equal 3, new.pos
-    assert !new.first?
-    assert new.last?
+class TopAdditionTestWithDefault < ActsAsListTestCase
+  include Shared::TopAddition
 
-    new = ArrayScopeListMixin.create(:parent_id => 0, :parent_type => 'ParentClass')
-    assert_equal 1, new.pos
-    assert new.first?
-    assert new.last?
+  def setup
+    setup_db_with_default
+    super
   end
+end
 
-  def test_insert_at
-    new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
-    assert_equal 1, new.pos
-
-    new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
-    assert_equal 2, new.pos
-
-    new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
-    assert_equal 3, new.pos
-
-    new4 = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
-    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 = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
-    assert_equal 5, new5.pos
-
-    new5.insert_at(1)
-    assert_equal 1, new5.pos
-
-    new4.reload
-    assert_equal 5, new4.pos
+class RespectMixinProtection < ActsAsListTestCase
+  def setup
+    setup_db_with_default
+    super
   end
 
-  def test_delete_middle
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-
-    ArrayScopeListMixin.find(2).destroy
-
-    assert_equal [1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-
-    assert_equal 1, ArrayScopeListMixin.find(1).pos
-    assert_equal 2, ArrayScopeListMixin.find(3).pos
-    assert_equal 3, ArrayScopeListMixin.find(4).pos
-
-    ArrayScopeListMixin.find(1).destroy
-
-    assert_equal [3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-
-    assert_equal 1, ArrayScopeListMixin.find(3).pos
-    assert_equal 2, ArrayScopeListMixin.find(4).pos
+  # if an attribute is set attr_protected
+  # it should be unchanged by update_attributes
+  def test_unmodified_protection
+    a = ProtectedMixin.new
+    a.update_attributes({:active => false})
+    assert_equal true, a.active
   end
 
-  def test_remove_from_list_should_then_fail_in_list?
-    assert_equal true, ArrayScopeListMixin.find(1).in_list?
-    ArrayScopeListMixin.find(1).remove_from_list
-    assert_equal false, ArrayScopeListMixin.find(1).in_list?
+  # even after the acts_as_list mixin is joined
+  # that protection should continue to exist
+  def test_still_protected
+    b = ProtectedListMixin.new
+    b.update_attributes({:active => false})
+    assert_equal true, b.active
   end
 
-  def test_remove_from_list_should_set_position_to_nil
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-
-    ArrayScopeListMixin.find(2).remove_from_list
-
-    assert_equal [2, 1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-
-    assert_equal 1,   ArrayScopeListMixin.find(1).pos
-    assert_equal nil, ArrayScopeListMixin.find(2).pos
-    assert_equal 2,   ArrayScopeListMixin.find(3).pos
-    assert_equal 3,   ArrayScopeListMixin.find(4).pos
+  # similarly, if a class lacks mass_assignment protection
+  # it should be able to be changed
+  def test_unprotected
+    a = UnProtectedMixin.new
+    a.update_attributes({:active => false})
+    assert_equal false, a.active
   end
 
-  def test_remove_before_destroy_does_not_shift_lower_items_twice
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-
-    ArrayScopeListMixin.find(2).remove_from_list
-    ArrayScopeListMixin.find(2).destroy
-
-    assert_equal [1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-
-    assert_equal 1, ArrayScopeListMixin.find(1).pos
-    assert_equal 2, ArrayScopeListMixin.find(3).pos
-    assert_equal 3, ArrayScopeListMixin.find(4).pos
+  # and it should continue to be mutable by mass_assignment
+  # even after the acts_as_list plugin has been joined
+  def test_still_unprotected_mixin
+    b = UnProtectedListMixin.new
+    b.assign_attributes({:active => false})
+    # p UnProtectedListMixin.accessible_attributes.length
+    assert_equal false, b.active
   end
 
 end