acts_as_list 0.2.0 → 0.3.0

data/test/shared_zero_based.rb

@@ -1,64 +1,64 @@
 module Shared
   module ZeroBased
     def setup
-       (1..4).each { |counter| ZeroBasedMixin.create! :pos => counter, :parent_id => 5 }
+       (1..4).each { |counter| ZeroBasedMixin.create! pos: counter, parent_id: 5 }
     end
 
     def test_insert
-      new = ZeroBasedMixin.create(:parent_id => 20)
+      new = ZeroBasedMixin.create(parent_id: 20)
       assert_equal 0, new.pos
       assert new.first?
       assert new.last?
 
-      new = ZeroBasedMixin.create(:parent_id => 20)
+      new = ZeroBasedMixin.create(parent_id: 20)
       assert_equal 1, new.pos
       assert !new.first?
       assert new.last?
 
-      new = ZeroBasedMixin.create(:parent_id => 20)
+      new = ZeroBasedMixin.create(parent_id: 20)
       assert_equal 2, new.pos
       assert !new.first?
       assert new.last?
 
-      new = ZeroBasedMixin.create(:parent_id => 0)
+      new = ZeroBasedMixin.create(parent_id: 0)
       assert_equal 0, new.pos
       assert new.first?
       assert new.last?
     end
 
     def test_reordering
-      assert_equal [1, 2, 3, 4], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+      assert_equal [1, 2, 3, 4], ZeroBasedMixin.where(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.where(id: 2).first.move_lower
+      assert_equal [1, 3, 2, 4], ZeroBasedMixin.where(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.where(id: 2).first.move_higher
+      assert_equal [1, 2, 3, 4], ZeroBasedMixin.where(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.where(id: 1).first.move_to_bottom
+      assert_equal [2, 3, 4, 1], ZeroBasedMixin.where(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.where(id: 1).first.move_to_top
+      assert_equal [1, 2, 3, 4], ZeroBasedMixin.where(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)
+      ListMixin.where(id: 2).first.move_to_bottom
+      assert_equal [1, 3, 4, 2], ZeroBasedMixin.where(parent_id: 5).order('pos').map(&:id)
 
-      ListMixin.find(4).move_to_top
-      assert_equal [4, 1, 3, 2], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+      ListMixin.where(id: 4).first.move_to_top
+      assert_equal [4, 1, 3, 2], ZeroBasedMixin.where(parent_id: 5).order('pos').map(&:id)
     end
 
     def test_insert_at
-      new = ZeroBasedMixin.create(:parent_id => 20)
+      new = ZeroBasedMixin.create(parent_id: 20)
       assert_equal 0, new.pos
 
-      new = ZeroBasedMixin.create(:parent_id => 20)
+      new = ZeroBasedMixin.create(parent_id: 20)
       assert_equal 1, new.pos
 
-      new = ZeroBasedMixin.create(:parent_id => 20)
+      new = ZeroBasedMixin.create(parent_id: 20)
       assert_equal 2, new.pos
 
-      new4 = ZeroBasedMixin.create(:parent_id => 20)
+      new4 = ZeroBasedMixin.create(parent_id: 20)
       assert_equal 3, new4.pos
 
       new4.insert_at(2)
@@ -73,7 +73,7 @@ module Shared
       new4.reload
       assert_equal 3, new4.pos
 
-      new5 = ListMixin.create(:parent_id => 20)
+      new5 = ListMixin.create(parent_id: 20)
       assert_equal 4, new5.pos
 
       new5.insert_at(1)

data/test/test_list.rb

@@ -1,16 +1,16 @@
 # NOTE: following now done in helper.rb (better Readability)
 require 'helper'
 
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
 ActiveRecord::Schema.verbose = false
 
 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
+  ActiveRecord::Schema.define(version: 1) do
     create_table :mixins do |t|
       t.column :pos, :integer, position_options
-      t.column :active, :boolean, :default => true
+      t.column :active, :boolean, default: true
       t.column :parent_id, :integer
       t.column :parent_type, :string
       t.column :created_at, :datetime
@@ -20,10 +20,10 @@ def setup_db(position_options = {})
 end
 
 def setup_db_with_default
-  setup_db :default => 0
+  setup_db default: 0
 end
 
-# Returns true if ActiveRecord is rails3 version
+# Returns true if ActiveRecord is rails3,4 version
 def rails_3
   defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::MAJOR >= 3
 end
@@ -36,29 +36,10 @@ 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
+  acts_as_list column: "pos", scope: :parent
 end
 
 class ListMixinSub1 < ListMixin
@@ -66,36 +47,40 @@ end
 
 class ListMixinSub2 < ListMixin
   if rails_3
-    validates :pos, :presence => true
+    validates :pos, presence: true
   else
     validates_presence_of :pos
   end
 end
 
 class ListWithStringScopeMixin < Mixin
-  acts_as_list :column => "pos", :scope => 'parent_id = #{parent_id}'
+  acts_as_list column: "pos", scope: 'parent_id = #{parent_id}'
 end
 
 class ArrayScopeListMixin < Mixin
-  acts_as_list :column => "pos", :scope => [:parent_id, :parent_type]
+  acts_as_list column: "pos", scope: [:parent_id, :parent_type]
 end
 
 class ZeroBasedMixin < Mixin
-  acts_as_list :column => "pos", :top_of_list => 0, :scope => [:parent_id]
+  acts_as_list column: "pos", top_of_list: 0, scope: [:parent_id]
 end
 
 class DefaultScopedMixin < Mixin
-  acts_as_list :column => "pos"
+  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) }
+  acts_as_list column: "pos"
+  default_scope { order('pos ASC').where(active: true) }
 end
 
 class TopAdditionMixin < Mixin
-  acts_as_list :column => "pos", :add_new_at => :top, :scope => :parent_id
+  acts_as_list column: "pos", add_new_at: :top, scope: :parent_id
+end
+
+class NoAdditionMixin < Mixin
+  acts_as_list column: "pos", add_new_at: nil, scope: :parent_id
 end
 
 class ActsAsListTestCase < Test::Unit::TestCase
@@ -183,7 +168,7 @@ end
 class DefaultScopedTest < ActsAsListTestCase
   def setup
     setup_db
-    (1..4).each { |counter| DefaultScopedMixin.create!({:pos => counter}) }
+    (1..4).each { |counter| DefaultScopedMixin.create!({pos: counter}) }
   end
 
   def test_insert
@@ -204,25 +189,25 @@ class DefaultScopedTest < ActsAsListTestCase
   end
 
   def test_reordering
-    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.all.map(&:id)
 
-    DefaultScopedMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.where(id: 2).first.move_lower
+    assert_equal [1, 3, 2, 4], DefaultScopedMixin.all.map(&:id)
 
-    DefaultScopedMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.where(id: 2).first.move_higher
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.all.map(&:id)
 
-    DefaultScopedMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.where(id: 1).first.move_to_bottom
+    assert_equal [2, 3, 4, 1], DefaultScopedMixin.all.map(&:id)
 
-    DefaultScopedMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.where(id: 1).first.move_to_top
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.all.map(&:id)
 
-    DefaultScopedMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.where(id: 2).first.move_to_bottom
+    assert_equal [1, 3, 4, 2], DefaultScopedMixin.all.map(&:id)
 
-    DefaultScopedMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.where(id: 4).first.move_to_top
+    assert_equal [4, 1, 3, 2], DefaultScopedMixin.all.map(&:id)
   end
 
   def test_insert_at
@@ -261,23 +246,22 @@ class DefaultScopedTest < ActsAsListTestCase
   end
 
   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)
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.all.map(&:id)
+    DefaultScopedMixin.where(id: 2).first.set_list_position(4)
+    assert_equal [1, 3, 4, 2], DefaultScopedMixin.all.map(&:id)
+    DefaultScopedMixin.where(id: 2).first.set_list_position(2)
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.all.map(&:id)
+    DefaultScopedMixin.where(id: 1).first.set_list_position(4)
+    assert_equal [2, 3, 4, 1], DefaultScopedMixin.all.map(&:id)
+    DefaultScopedMixin.where(id: 1).first.set_list_position(1)
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.all.map(&:id)
   end
-
 end
 
 class DefaultScopedWhereTest < ActsAsListTestCase
   def setup
     setup_db
-    (1..4).each { |counter| DefaultScopedWhereMixin.create! :pos => counter, :active => false }
+    (1..4).each { |counter| DefaultScopedWhereMixin.create! pos: counter, active: false }
   end
 
   def test_insert
@@ -298,25 +282,25 @@ class DefaultScopedWhereTest < ActsAsListTestCase
   end
 
   def test_reordering
-    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).map(&:id)
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(active: false).map(&:id)
 
-    DefaultScopedWhereMixin.where(:active => false).find(2).move_lower
-    assert_equal [1, 3, 2, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+    DefaultScopedWhereMixin.where(active: false).where(id: 2).first.move_lower
+    assert_equal [1, 3, 2, 4], DefaultScopedWhereMixin.where(active: false).map(&:id)
 
-    DefaultScopedWhereMixin.where(:active => false).find(2).move_higher
-    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+    DefaultScopedWhereMixin.where(active: false).where(id: 2).first.move_higher
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(active: false).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)
+    DefaultScopedWhereMixin.where(active: false).where(id: 1).first.move_to_bottom
+    assert_equal [2, 3, 4, 1], DefaultScopedWhereMixin.where(active: false).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)
+    DefaultScopedWhereMixin.where(active: false).where(id: 1).first.move_to_top
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(active: false).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)
+    DefaultScopedWhereMixin.where(active: false).where(id: 2).first.move_to_bottom
+    assert_equal [1, 3, 4, 2], DefaultScopedWhereMixin.where(active: false).map(&:id)
 
-    DefaultScopedWhereMixin.where(:active => false).find(4).move_to_top
-    assert_equal [4, 1, 3, 2], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+    DefaultScopedWhereMixin.where(active: false).where(id: 4).first.move_to_top
+    assert_equal [4, 1, 3, 2], DefaultScopedWhereMixin.where(active: false).map(&:id)
   end
 
   def test_insert_at
@@ -355,15 +339,15 @@ class DefaultScopedWhereTest < ActsAsListTestCase
   end
 
   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)
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(active: false).map(&:id)
+    DefaultScopedWhereMixin.where(active: false).where(id: 2).first.set_list_position(4)
+    assert_equal [1, 3, 4, 2], DefaultScopedWhereMixin.where(active: false).map(&:id)
+    DefaultScopedWhereMixin.where(active: false).where(id: 2).first.set_list_position(2)
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(active: false).map(&:id)
+    DefaultScopedWhereMixin.where(active: false).where(id: 1).first.set_list_position(4)
+    assert_equal [2, 3, 4, 1], DefaultScopedWhereMixin.where(active: false).map(&:id)
+    DefaultScopedWhereMixin.where(active: false).where(id: 1).first.set_list_position(1)
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(active: false).map(&:id)
   end
 
 end
@@ -377,13 +361,13 @@ class MultiDestroyTest < ActsAsListTestCase
   # example:
   #
   #   class TodoList < ActiveRecord::Base
-  #     has_many :todo_items, :order => "position"
-  #     accepts_nested_attributes_for :todo_items, :allow_destroy => true
+  #     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
+  #     acts_as_list scope: :todo_list
   #   end
   #
   # Assume that there are three items.
@@ -424,7 +408,6 @@ class TopAdditionTest < ActsAsListTestCase
   end
 end
 
-
 class TopAdditionTestWithDefault < ActsAsListTestCase
   include Shared::TopAddition
 
@@ -434,43 +417,92 @@ class TopAdditionTestWithDefault < ActsAsListTestCase
   end
 end
 
-class RespectMixinProtection < ActsAsListTestCase
+class NoAdditionTest < ActsAsListTestCase
+  include Shared::NoAddition
+
   def setup
-    setup_db_with_default
+    setup_db
     super
   end
+end
 
-  # 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
+class MultipleListsTest < ActsAsListTestCase
+  def setup
+    setup_db
+    (1..4).each { |counter| ListMixin.create! :pos => counter, :parent_id => 1}
+    (1..4).each { |counter| ListMixin.create! :pos => counter, :parent_id => 2}
   end
 
-  # 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
+  def test_check_scope_order
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 1).order(:pos).map(&:id)
+    assert_equal [5, 6, 7, 8], ListMixin.where(:parent_id => 2).order(:pos).map(&:id)
+    ListMixin.find(4).update_attributes(:parent_id => 2, :pos => 2)
+    assert_equal [1, 2, 3], ListMixin.where(:parent_id => 1).order(:pos).map(&:id)
+    assert_equal [5, 4, 6, 7, 8], ListMixin.where(:parent_id => 2).order(:pos).map(&:id)
   end
 
-  # 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
+  def test_check_scope_position
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 1).map(&:pos)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 2).map(&:pos)
+    ListMixin.find(4).update_attributes(:parent_id => 2, :pos => 2)
+    assert_equal [1, 2, 3], ListMixin.where(:parent_id => 1).order(:pos).map(&:pos)
+    assert_equal [1, 2, 3, 4, 5], ListMixin.where(:parent_id => 2).order(:pos).map(&:pos)
   end
+end
 
-  # 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
+class MultipleListsArrayScopeTest < ActsAsListTestCase
+  def setup
+    setup_db
+    (1..4).each { |counter| ArrayScopeListMixin.create! :pos => counter,:parent_id => 1, :parent_type => 'anything'}
+    (1..4).each { |counter| ArrayScopeListMixin.create! :pos => counter,:parent_id => 2, :parent_type => 'something'}
+    (1..4).each { |counter| ArrayScopeListMixin.create! :pos => counter,:parent_id => 3, :parent_type => 'anything'}
+  end
+
+  def test_order_after_all_scope_properties_are_changed
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order(:pos).map(&:id)
+    assert_equal [5, 6, 7, 8], ArrayScopeListMixin.where(:parent_id => 2, :parent_type => 'something').order(:pos).map(&:id)
+    ArrayScopeListMixin.find(2).update_attributes(:parent_id => 2, :pos => 2,:parent_type => 'something')
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(:parent_id => 1,:parent_type => 'anything').order(:pos).map(&:id)
+    assert_equal [5, 2, 6, 7, 8], ArrayScopeListMixin.where(:parent_id => 2,:parent_type => 'something').order(:pos).map(&:id)
   end
 
+  def test_position_after_all_scope_properties_are_changed
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').map(&:pos)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 2, :parent_type => 'something').map(&:pos)
+    ArrayScopeListMixin.find(4).update_attributes(:parent_id => 2, :pos => 2, :parent_type => 'something')
+    assert_equal [1, 2, 3], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order(:pos).map(&:pos)
+    assert_equal [1, 2, 3, 4, 5], ArrayScopeListMixin.where(:parent_id => 2, :parent_type => 'something').order(:pos).map(&:pos)
+  end
+
+  def test_order_after_one_scope_property_is_changed
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order(:pos).map(&:id)
+    assert_equal [9, 10, 11, 12], ArrayScopeListMixin.where(:parent_id => 3, :parent_type => 'anything').order(:pos).map(&:id)
+    ArrayScopeListMixin.find(2).update_attributes(:parent_id => 3, :pos => 2)
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(:parent_id => 1,:parent_type => 'anything').order(:pos).map(&:id)
+    assert_equal [9, 2, 10, 11, 12], ArrayScopeListMixin.where(:parent_id => 3,:parent_type => 'anything').order(:pos).map(&:id)
+  end
+
+  def test_position_after_one_scope_property_is_changed
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').map(&:pos)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 3, :parent_type => 'anything').map(&:pos)
+    ArrayScopeListMixin.find(4).update_attributes(:parent_id => 3, :pos => 2)
+    assert_equal [1, 2, 3], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order(:pos).map(&:pos)
+    assert_equal [1, 2, 3, 4, 5], ArrayScopeListMixin.where(:parent_id => 3, :parent_type => 'anything').order(:pos).map(&:pos)
+  end
+
+  def test_order_after_moving_to_empty_list
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order(:pos).map(&:id)
+    assert_equal [], ArrayScopeListMixin.where(:parent_id => 4, :parent_type => 'anything').order(:pos).map(&:id)
+    ArrayScopeListMixin.find(2).update_attributes(:parent_id => 4, :pos => 1)
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(:parent_id => 1,:parent_type => 'anything').order(:pos).map(&:id)
+    assert_equal [2], ArrayScopeListMixin.where(:parent_id => 4,:parent_type => 'anything').order(:pos).map(&:id)
+  end
+
+  def test_position_after_moving_to_empty_list
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').map(&:pos)
+    assert_equal [], ArrayScopeListMixin.where(:parent_id => 4, :parent_type => 'anything').map(&:pos)
+    ArrayScopeListMixin.find(2).update_attributes(:parent_id => 4, :pos => 1)
+    assert_equal [1, 2, 3], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order(:pos).map(&:pos)
+    assert_equal [1], ArrayScopeListMixin.where(:parent_id => 4, :parent_type => 'anything').order(:pos).map(&:pos)
+  end
 end