better_nested_set 0.1.1

data/test/RUNNING_UNIT_TESTS

@@ -0,0 +1 @@
+See instructions in ../README

data/test/abstract_unit.rb

@@ -0,0 +1,25 @@
+ENV['RAILS_ENV'] = 'test'
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../../config/environment.rb'))
+require 'test_help'
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/debug.log')
+cs = ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'mysql'])
+puts "Using #{cs.config[:adapter]} adapter"
+load(File.dirname(__FILE__) + '/schema.rb')
+
+Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + '/fixtures/'
+$LOAD_PATH.unshift(Test::Unit::TestCase.fixture_path)
+
+class Test::Unit::TestCase #:nodoc:
+  def create_fixtures(*table_names)
+    if block_given?
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) { yield }
+    else
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names)
+    end
+  end
+
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures  = false
+end

data/test/acts_as_nested_set_test.rb

@@ -0,0 +1,1368 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+require File.dirname(__FILE__) + '/fixtures/mixin'
+require 'pp'
+
+class MixinNestedSetTest < Test::Unit::TestCase
+  fixtures :mixins
+  
+  def setup
+    # force so other tests besides test_destroy_dependent aren't affected
+    NestedSetWithStringScope.acts_as_nested_set_options[:dependent] = :delete_all
+  end
+  
+  ##########################################
+  # HIGH LEVEL TESTS
+  ##########################################
+  def test_mixing_in_methods
+    ns = NestedSet.new
+    assert(ns.respond_to?(:all_children)) # test a random method
+    
+    check_method_mixins(ns)
+    check_deprecated_method_mixins(ns) 
+    check_class_method_mixins(NestedSet)
+  end
+  
+  def check_method_mixins(obj)
+    [:<=>, :all_children, :all_children_count, :ancestors, :before_create, :before_destroy, :check_full_tree, 
+    :check_subtree, :children, :children_count, :full_set, :leaves, :leaves_count, :left_col_name, :level, :move_to_child_of, 
+    :move_to_left_of, :move_to_right_of, :parent, :parent_col_name, :renumber_full_tree, :right_col_name, 
+    :root, :roots, :self_and_ancestors, :self_and_siblings, :siblings].each { |symbol| assert(obj.respond_to?(symbol)) }
+  end
+  
+  def check_deprecated_method_mixins(obj)
+    [:add_child, :direct_children, :parent_column, :root?, :child?, :unknown?].each { |symbol| assert(obj.respond_to?(symbol)) }
+  end
+  
+  def check_class_method_mixins(klass)
+    [:root, :roots, :check_all, :renumber_all].each { |symbol| assert(klass.respond_to?(symbol)) }
+  end
+  
+  def test_string_scope
+    ns = NestedSet.new
+    assert_equal("mixins.root_id IS NULL", ns.scope_condition)
+    
+    ns = NestedSetWithStringScope.new
+    ns.root_id = 1
+    assert_equal("mixins.root_id = 1", ns.scope_condition)
+    ns.root_id = 42
+    assert_equal("mixins.root_id = 42", ns.scope_condition)
+    check_method_mixins ns
+  end
+  
+  def test_without_scope_condition
+    ns = NestedSet.new
+    assert_equal("mixins.root_id IS NULL", ns.scope_condition)
+    NestedSet.without_scope_condition do
+      assert_equal("(1 = 1)", ns.scope_condition)
+    end
+    assert_equal("mixins.root_id IS NULL", ns.scope_condition)
+  end
+  
+  def test_symbol_scope
+    ns = NestedSetWithSymbolScope.new
+    ns.root_id = 1
+    assert_equal("mixins.root_id = 1", ns.scope_condition)
+    ns.root_id = 42
+    assert_equal("mixins.root_id = 42", ns.scope_condition)
+    check_method_mixins ns
+  end
+  
+  def test_protected_attributes
+    ns = NestedSet.new(:parent_id => 2, :lft => 3, :rgt => 2)
+    [:parent_id, :lft, :rgt].each {|symbol| assert_equal(nil, ns.send(symbol))}
+  end
+    
+  def test_really_protected_attributes
+    ns = NestedSet.new
+    assert_raise(ActiveRecord::ActiveRecordError) {ns.parent_id = 1}
+    assert_raise(ActiveRecord::ActiveRecordError) {ns.lft = 1}
+    assert_raise(ActiveRecord::ActiveRecordError) {ns.rgt = 1}
+  end
+  
+  ##########################################
+  # CLASS METHOD TESTS
+  ##########################################
+  def test_class_root
+    NestedSetWithStringScope.roots.each {|r| r.destroy unless r.id == 4001}
+    assert_equal([NestedSetWithStringScope.find(4001)], NestedSetWithStringScope.roots)
+    NestedSetWithStringScope.find(4001).destroy
+    assert_equal(nil, NestedSetWithStringScope.root)
+    ns = NestedSetWithStringScope.create(:root_id => 2)
+    assert_equal(ns, NestedSetWithStringScope.root)
+  end
+  
+  def test_class_root_again
+    NestedSetWithStringScope.roots.each {|r| r.destroy unless r.id == 101}
+    assert_equal(NestedSetWithStringScope.find(101), NestedSetWithStringScope.root)
+  end
+  
+  def test_class_roots
+    assert_equal(2, NestedSetWithStringScope.roots.size)
+    assert_equal(10, NestedSet.roots.size) # May change if STI behavior changes
+  end
+  
+  def test_check_all_1
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+    NestedSetWithStringScope.update_all("lft = 3", "id = 103")
+    assert_raise(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_check_all_2
+    NestedSetWithStringScope.update_all("lft = lft + 1", "lft > 11 AND root_id = 101")
+    NestedSetWithStringScope.update_all("rgt = rgt + 1", "lft > 11 AND root_id = 101")
+    assert_raise(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.check_all} 
+  end
+  
+  def test_check_all_3
+    NestedSetWithStringScope.update_all("lft = lft + 2", "lft > 11 AND root_id = 101")
+    NestedSetWithStringScope.update_all("rgt = rgt + 2", "lft > 11 AND root_id = 101")
+    assert_raise(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.check_all} 
+  end
+  
+  def test_check_all_4
+    ns = NestedSetWithStringScope.create(:root_id => 101) # virtual root
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+    NestedSetWithStringScope.update_all("rgt = rgt + 2, lft = lft + 2", "id = #{ns.id}") # create a gap between virtual roots
+    assert_nothing_raised {ns.check_subtree}
+    assert_raise(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.check_all} 
+  end
+  
+  def test_renumber_all
+    NestedSetWithStringScope.update_all("lft = NULL, rgt = NULL")
+    assert_raise(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.check_all}
+    NestedSetWithStringScope.renumber_all    
+    assert_nothing_raised(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.check_all}
+    NestedSetWithStringScope.update_all("lft = 1, rgt = 2")
+    assert_raise(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.check_all}
+    NestedSetWithStringScope.renumber_all    
+    assert_nothing_raised(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_sql_for
+    assert_equal("1 != 1", Category.sql_for([]))
+    c = Category.new
+    assert_equal("1 != 1", Category.sql_for(c))
+    assert_equal("1 != 1", Category.sql_for([c]))
+    c.save
+    assert_equal("((mixins.lft BETWEEN 1 AND 2))", Category.sql_for(c))
+    assert_equal("((mixins.lft BETWEEN 1 AND 2))", Category.sql_for([c]))
+    assert_equal("((mixins.lft BETWEEN 1 AND 20))", NestedSetWithStringScope.sql_for(101))
+    assert_equal("((mixins.lft BETWEEN 1 AND 20) OR (mixins.lft BETWEEN 4 AND 11))", NestedSetWithStringScope.sql_for([101, set2(3)]))
+    assert_equal("((mixins.lft BETWEEN 5 AND 6) OR (mixins.lft BETWEEN 7 AND 8) OR (mixins.lft BETWEEN 9 AND 10))", NestedSetWithStringScope.sql_for(set2(3).children))
+  end
+  
+  
+  ##########################################
+  # CALLBACK TESTS
+  ##########################################
+  # If we change behavior of virtual roots, this test may change
+  def test_before_create
+    ns = NestedSetWithSymbolScope.create(:root_id => 1234)
+    assert_equal(1, ns.lft)
+    assert_equal(2, ns.rgt)
+    ns = NestedSetWithSymbolScope.create(:root_id => 1234)
+    assert_equal(3, ns.lft)
+    assert_equal(4, ns.rgt)
+  end
+  
+  # test pruning a branch. only works if we allow the deletion of nodes with children
+  def test_destroy
+    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_destroy_2
+    assert_nothing_raised {set2(1).check_subtree}
+    assert set2(10).destroy    
+    assert_nothing_raised {set2(1).reload.check_subtree}
+    assert set2(9).children.empty?
+    assert set2(9).destroy
+    assert_equal 15, set2(4).rgt
+    assert_nothing_raised {set2(1).reload.check_subtree}
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_destroy_3
+    assert set2(3).destroy
+    assert_equal(2, set2(1).children.size)
+    assert_equal(0, NestedSetWithStringScope.find(:all, :conditions => "id > 104 and id < 108").size)
+    assert_equal(6, set2(1).full_set.size)
+    assert_equal(3, set2(2).rgt)
+    assert_equal(4, set2(4).lft)
+    assert_equal(12, set2(1).rgt)
+    assert_nothing_raised {set2(1).check_subtree}
+  end
+  
+  def test_destroy_root
+    NestedSetWithStringScope.find(4001).destroy
+    assert_equal(0, NestedSetWithStringScope.count(:conditions => "root_id = 42"))
+  end            
+  
+  def test_destroy_dependent
+    NestedSetWithStringScope.acts_as_nested_set_options[:dependent] = :destroy
+    
+    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
+  
+  ##########################################
+  # QUERY METHOD TESTS
+  ##########################################
+  def set(id) NestedSet.find(3000 + id) end # helper method
+  
+  def set2(id) NestedSetWithStringScope.find(100 + id) end # helper method
+  
+  def test_root?
+    assert NestedSetWithStringScope.find(4001).root?
+    assert !NestedSetWithStringScope.find(4002).root?
+  end
+  
+  def test_child?
+    assert !NestedSetWithStringScope.find(4001).child?
+    assert NestedSetWithStringScope.find(4002).child?    
+  end
+  
+  # Deprecated, delete this test when we nuke the method
+  def test_unknown?
+    assert !NestedSetWithStringScope.find(4001).unknown?
+    assert !NestedSetWithStringScope.find(4002).unknown?        
+  end
+  
+  # Test the <=> method implicitly
+  def test_comparison
+    ar = NestedSetWithStringScope.find(:all, :conditions => "root_id = 42", :order => "lft")
+    ar2 = NestedSetWithStringScope.find(:all, :conditions => "root_id = 42", :order => "rgt")
+    assert_not_equal(ar, ar2)
+    assert_equal(ar, ar2.sort)
+  end
+  
+  def test_root
+    assert_equal(NestedSetWithStringScope.find(4001), NestedSetWithStringScope.find(4007).root)
+    assert_equal(set2(1), set2(8).root)
+    assert_equal(set2(1), set2(1).root)
+    # test virtual roots
+    c1, c2, c3 = Category.create, Category.create, Category.create
+    c3.move_to_child_of(c2)
+    assert_equal(c2, c3.root)
+  end
+  
+  def test_roots
+    assert_equal([set2(1)], set2(8).roots)
+    assert_equal([set2(1)], set2(1).roots)
+    assert_equal(NestedSet.find(:all, :conditions => "id > 3000 AND id < 4000").size, set(1).roots.size)
+  end
+  
+  def test_parent
+    ns = NestedSetWithStringScope.create(:root_id => 45)
+    assert_equal(nil, ns.parent)
+    assert ns.save
+    assert_equal(nil, ns.parent)
+    assert_equal(set2(1), set2(2).parent)
+    assert_equal(set2(3), set2(7).parent)
+  end
+  
+  def test_ancestors
+    assert_equal([], set2(1).ancestors)
+    assert_equal([set2(1), set2(4), set2(9)], set2(10).ancestors)
+  end
+  
+  def test_self_and_ancestors
+    assert_equal([set2(1)], set2(1).self_and_ancestors)
+    assert_equal([set2(1), set2(4), set2(8)], set2(8).self_and_ancestors)
+    assert_equal([set2(1), set2(4), set2(9), set2(10)], set2(10).self_and_ancestors)
+  end
+  
+  def test_siblings
+    assert_equal([], set2(1).siblings)
+    assert_equal([set2(2), set2(4)], set2(3).siblings)
+  end
+  
+  def test_first_sibling
+    assert set2(2).first_sibling?
+    assert_equal(set2(2), set2(2).first_sibling)
+    assert_equal(set2(2), set2(3).first_sibling)
+    assert_equal(set2(2), set2(4).first_sibling)
+  end
+  
+  def test_last_sibling
+    assert set2(4).last_sibling?
+    assert_equal(set2(4), set2(2).last_sibling)
+    assert_equal(set2(4), set2(3).last_sibling)
+    assert_equal(set2(4), set2(4).last_sibling)
+  end
+  
+  def test_previous_siblings
+    assert_equal([], set2(2).previous_siblings)
+    assert_equal([set2(2)], set2(3).previous_siblings)
+    assert_equal([set2(3), set2(2)], set2(4).previous_siblings)
+  end
+  
+  def test_previous_sibling
+    assert_equal(nil, set2(2).previous_sibling)
+    assert_equal(set2(2), set2(3).previous_sibling)
+    assert_equal(set2(3), set2(4).previous_sibling)
+    assert_equal([set2(3), set2(2)], set2(4).previous_sibling(2))
+  end
+  
+  def test_next_siblings
+    assert_equal([], set2(4).next_siblings)
+    assert_equal([set2(4)], set2(3).next_siblings)
+    assert_equal([set2(3), set2(4)], set2(2).next_siblings)
+  end
+  
+  def test_next_sibling
+    assert_equal(nil, set2(4).next_sibling)
+    assert_equal(set2(4), set2(3).next_sibling)
+    assert_equal(set2(3), set2(2).next_sibling)
+    assert_equal([set2(3), set2(4)], set2(2).next_sibling(2))
+  end
+  
+  def test_self_and_siblings
+    assert_equal([set2(1)], set2(1).self_and_siblings)
+    assert_equal([set2(2), set2(3), set2(4)], set2(3).self_and_siblings)    
+  end
+  
+  def test_level
+    assert_equal(0, set2(1).level)
+    assert_equal(1, set2(3).level)
+    assert_equal(3, set2(10).level)
+  end
+  
+  def test_all_children_count
+    assert_equal(0, set2(10).all_children_count)
+    assert_equal(1, set2(3).level)
+    assert_equal(3, set2(10).level)    
+  end
+  
+  def test_full_set
+    assert_equal(NestedSetWithStringScope.find(:all, :conditions => "root_id = 101", :order => "lft"), set2(1).full_set)
+    new_ns = NestedSetWithStringScope.new(:root_id => 101)
+    assert_equal([new_ns], new_ns.full_set)
+    assert_equal([set2(4), set2(8), set2(9), set2(10)], set2(4).full_set)
+    assert_equal([set2(2)], set2(2).full_set)
+    assert_equal([set2(2)], set2(2).full_set(:exclude => nil))
+    assert_equal([set2(2)], set2(2).full_set(:exclude => []))
+    assert_equal([], set2(1).full_set(:exclude => 101))
+    assert_equal([], set2(1).full_set(:exclude => set2(1)))
+    ns = NestedSetWithStringScope.create(:root_id => 234)
+    assert_equal([], ns.full_set(:exclude => ns))
+    assert_equal([set2(4), set2(8), set2(9)], set2(4).full_set(:exclude => set2(10)))
+    assert_equal([set2(4), set2(8)], set2(4).full_set(:exclude => set2(9))) 
+  end
+    
+  def test_all_children
+    assert_equal(NestedSetWithStringScope.find(:all, :conditions => "root_id = 101 AND id > 101", :order => "lft"), set2(1).all_children)
+    assert_equal([], NestedSetWithStringScope.new(:root_id => 101).all_children)
+    assert_equal([set2(8), set2(9), set2(10)], set2(4).all_children)
+    assert_equal([set2(8), set2(9)], set2(4).all_children(:exclude => set2(10)))
+    assert_equal([set2(8)], set2(4).all_children(:exclude => set2(9)))
+    assert_equal([set2(2), set2(4), set2(8)], set2(1).all_children(:exclude => [set2(9), 103]))
+    assert_equal([set2(2), set2(4), set2(8)], set2(1).all_children(:exclude => [set2(9), 103, 106]))
+  end
+  
+  def test_children
+    assert_equal([], set2(10).children) 
+    assert_equal([], set(1).children) 
+    assert_equal([set2(2), set2(3), set2(4)], set2(1).children) 
+    assert_equal([set2(5), set2(6), set2(7)], set2(3).children) 
+    assert_equal([NestedSetWithStringScope.find(4006), NestedSetWithStringScope.find(4007)], NestedSetWithStringScope.find(4005).children) 
+  end
+  
+  def test_children_count
+    assert_equal(0, set2(10).children_count) 
+    assert_equal(3, set2(1).children_count)
+  end
+  
+  def test_leaves
+    assert_equal([set2(10)], set2(9).leaves)
+    assert_equal([set2(10)], set2(10).leaves)
+    assert_equal([set2(2), set2(5), set2(6), set2(7), set2(8), set2(10)], set2(1).leaves)
+  end
+  
+  def test_leaves_count
+    assert_equal(1, set2(10).leaves_count)
+    assert_equal(1, set2(9).leaves_count)
+    assert_equal(6, set2(1).leaves_count)
+  end
+
+  ##########################################
+  # CASTING RESULT TESTS
+  ##########################################
+  
+  def test_recurse_result_set
+    result = []
+    NestedSetWithStringScope.recurse_result_set(set2(1).full_set) do |node, level|
+      result << [level, node.id]
+    end
+    expected = [[0, 101], [1, 102], [1, 103], [2, 105], [2, 106], [2, 107], [1, 104], [2, 108], [2, 109], [3, 110]]
+    assert_equal expected, result
+  end
+  
+  def test_disjointed_result_set
+    result_set = set2(1).full_set(:conditions => { :type => 'NestedSetWithStringScope' })
+    result = []
+    NestedSetWithStringScope.recurse_result_set(result_set) do |node, level|
+      result << [level, node.id]
+    end
+    expected = [[0, 102], [0, 104], [0, 105], [0, 106], [0, 107], [0, 110]]
+    assert_equal expected, result
+  end
+  
+  def test_result_to_array
+    result = NestedSetWithStringScope.result_to_array(set2(1).full_set) do |node, level|
+      { :id => node.id, :level => level }
+    end
+    expected = [{:level=>0, :children=>[{:level=>1, :id=>102}, {:level=>1, 
+      :children=>[{:level=>2, :id=>105}, {:level=>2, :id=>106}, {:level=>2, :id=>107}], :id=>103}, {:level=>1, 
+      :children=>[{:level=>2, :id=>108}, {:level=>2, :children=>[{:level=>3, :id=>110}], :id=>109}], :id=>104}], :id=>101}]
+    assert_equal expected, result
+  end
+  
+  def test_result_to_array_with_method_calls
+    result = NestedSetWithStringScope.result_to_array(set2(1).full_set, :only => [:id], :methods => [:children_count])
+    expected = [{:children=>[{:children_count=>0, :id=>102}, {:children=>[{:children_count=>0, :id=>105}, {:children_count=>0, :id=>106}, 
+      {:children_count=>0, :id=>107}], :children_count=>3, :id=>103}, {:children=>[{:children_count=>0, :id=>108}, {:children=>[{:children_count=>0, :id=>110}], 
+      :children_count=>1, :id=>109}], :children_count=>2, :id=>104}], :children_count=>3, :id=>101}]
+    assert_equal expected, result
+  end
+  
+  def test_disjointed_result_to_array
+    result_set = set2(1).full_set(:conditions => { :type => 'NestedSetWithStringScope' })
+    result = NestedSetWithStringScope.result_to_array(result_set) do |node, level|
+      { :id => node.id, :level => level }
+    end
+    expected = [{:level=>0, :id=>102}, {:level=>0, :id=>104}, {:level=>0, :id=>105}, {:level=>0, :id=>106}, {:level=>0, :id=>107}, {:level=>0, :id=>110}]
+    assert_equal expected, result
+  end
+  
+  def test_result_to_array_flat
+    result = NestedSetWithStringScope.result_to_array(set2(1).full_set, :nested => false) do |node, level|
+      { :id => node.id, :level => level }
+    end
+    expected = [{:level=>0, :id=>101}, {:level=>0, :id=>103}, {:level=>0, :id=>106}, {:level=>0, :id=>104}, {:level=>0, :id=>109}, 
+      {:level=>0, :id=>102}, {:level=>0, :id=>105}, {:level=>0, :id=>107}, {:level=>0, :id=>108}, {:level=>0, :id=>110}]
+    assert_equal expected, result
+  end
+  
+  def test_result_to_xml
+    result = NestedSetWithStringScope.result_to_xml(set2(3).full_set, :record => 'node', :dasherize => false, :only => [:id]) do |options, subnode|
+       options[:builder].tag!('type', subnode[:type])
+    end
+    expected = '<?xml version="1.0" encoding="UTF-8"?>
+<nodes>
+  <node>
+    <id type="integer">103</id>
+    <type>NS2</type>
+    <children>
+      <node>
+        <id type="integer">105</id>
+        <type>NestedSetWithStringScope</type>
+        <children>
+        </children>
+      </node>
+      <node>
+        <id type="integer">106</id>
+        <type>NestedSetWithStringScope</type>
+        <children>
+        </children>
+      </node>
+      <node>
+        <id type="integer">107</id>
+        <type>NestedSetWithStringScope</type>
+        <children>
+        </children>
+      </node>
+    </children>
+  </node>
+</nodes>'
+    assert_equal expected, result.strip
+  end
+  
+  def test_disjointed_result_to_xml
+    result_set = set2(1).full_set(:conditions => ['type IN(?)', ['NestedSetWithStringScope', 'NS2']])
+    result = NestedSetWithStringScope.result_to_xml(result_set, :only => [:id])
+    # note how nesting is preserved where possible; this is not always what you want though, 
+    # so you can force a flattened set with :nested => false instead (see below)
+    expected = '<?xml version="1.0" encoding="UTF-8"?>
+<nodes>
+  <nested-set-with-string-scope>
+    <id type="integer">102</id>
+    <children>
+    </children>
+  </nested-set-with-string-scope>
+  <ns2>
+    <id type="integer">103</id>
+    <children>
+      <nested-set-with-string-scope>
+        <id type="integer">105</id>
+        <children>
+        </children>
+      </nested-set-with-string-scope>
+      <nested-set-with-string-scope>
+        <id type="integer">106</id>
+        <children>
+        </children>
+      </nested-set-with-string-scope>
+      <nested-set-with-string-scope>
+        <id type="integer">107</id>
+        <children>
+        </children>
+      </nested-set-with-string-scope>
+    </children>
+  </ns2>
+  <nested-set-with-string-scope>
+    <id type="integer">104</id>
+    <children>
+      <ns2>
+        <id type="integer">108</id>
+        <children>
+        </children>
+      </ns2>
+    </children>
+  </nested-set-with-string-scope>
+</nodes>'
+    assert_equal expected, result.strip
+  end
+  
+  def test_result_to_xml_flat
+    result = NestedSetWithStringScope.result_to_xml(set2(3).full_set, :record => 'node', :dasherize => false, :only => [:id], :nested => false)
+    expected = '<?xml version="1.0" encoding="UTF-8"?>
+<nodes>
+  <node>
+    <id type="integer">103</id>
+  </node>
+  <node>
+    <id type="integer">105</id>
+  </node>
+  <node>
+    <id type="integer">106</id>
+  </node>
+  <node>
+    <id type="integer">107</id>
+  </node>
+</nodes>'
+    assert_equal expected, result.strip
+  end
+  
+  def test_result_to_attribute_based_xml
+    result = NestedSetWithStringScope.result_to_attributes_xml(set2(1).full_set, :record => 'node', :only => [:id, :parent_id])
+    expected = '<?xml version="1.0" encoding="UTF-8"?>
+<node id="101" parent_id="0">
+  <node id="102" parent_id="101"/>
+  <node id="103" parent_id="101">
+    <node id="105" parent_id="103"/>
+    <node id="106" parent_id="103"/>
+    <node id="107" parent_id="103"/>
+  </node>
+  <node id="104" parent_id="101">
+    <node id="108" parent_id="104"/>
+    <node id="109" parent_id="104">
+      <node id="110" parent_id="109"/>
+    </node>
+  </node>
+</node>'
+    assert_equal expected, result.strip
+  end
+  
+  def test_result_to_attribute_based_xml_flat
+    result = NestedSetWithStringScope.result_to_attributes_xml(set2(1).full_set, :only => [:id], :nested => false, :skip_instruct => true)
+    expected = '<ns1 id="101"/>
+<ns2 id="103"/>
+<nested_set_with_string_scope id="106"/>
+<nested_set_with_string_scope id="104"/>
+<ns1 id="109"/>
+<nested_set_with_string_scope id="102"/>
+<nested_set_with_string_scope id="105"/>
+<nested_set_with_string_scope id="107"/>
+<ns2 id="108"/>
+<nested_set_with_string_scope id="110"/>'
+    assert_equal expected, result.strip
+  end
+  
+  ##########################################
+  # WITH_SCOPE QUERY TESTS
+  ##########################################
+  
+  def test_filtered_full_set
+    result_set = set2(1).full_set(:conditions => { :type => 'NestedSetWithStringScope' })
+    assert_equal [102, 105, 106, 107, 104, 110], result_set.map(&:id)
+  end
+  
+  def test_reverse_result_set
+    result_set = set2(1).full_set(:reverse => true)  
+    assert_equal [101, 104, 109, 110, 108, 103, 107, 106, 105, 102], result_set.map(&:id)
+    # NestedSetWithStringScope.recurse_result_set(result_set) { |node, level| puts "#{'--' * level}#{node.id}" }
+  end
+  
+  def test_reordered_full_set
+    result_set = set2(1).full_set(:order => 'id DESC')
+    assert_equal [110, 109, 108, 107, 106, 105, 104, 103, 102, 101], result_set.map(&:id)
+  end
+  
+  def test_filtered_siblings
+    node = set2(2)
+    result_set = node.siblings(:conditions => { :type => node[:type] })
+    assert_equal [104], result_set.map(&:id)
+  end
+  
+  def test_include_option_with_full_set
+    result_set = set2(3).full_set(:include => :parent_node)
+    assert_equal [[103, 101], [105, 103], [106, 103], [107, 103]], result_set.map { |n| [n.id, n.parent_node.id] }
+  end
+
+  ##########################################
+  # FIND UNTIL/THROUGH METHOD TESTS
+  ##########################################
+
+  def test_ancestors_and_self_through
+    result = set2(10).ancestors_and_self_through(set2(4))
+    assert_equal [104, 109, 110], result.map(&:id)
+    result = set2(10).ancestors_through(set2(4))
+    assert_equal [104, 109], result.map(&:id)
+  end
+  
+  def test_full_set_through
+    result = set2(4).full_set_through(set2(10))
+    assert_equal [104, 108, 109, 110], result.map(&:id)
+  end
+
+  def test_all_children_through
+    result = set2(4).all_children_through(set2(10))
+    assert_equal [108, 109, 110], result.map(&:id)
+  end
+  
+  def test_siblings_through
+    result = set2(5).self_and_siblings_through(set2(7))
+    assert_equal [105, 106, 107], result.map(&:id)
+    result = set2(7).siblings_through(set2(5))
+    assert_equal [105, 106], result.map(&:id)
+  end
+  
+  ##########################################
+  # FIND CHILD BY ID METHOD TESTS
+  ##########################################
+  
+  def test_child_by_id
+    assert_equal set2(6), set2(3).child_by_id(set2(6).id)
+    assert_nil set2(3).child_by_id(set2(8).id)
+  end
+  
+  def test_child_of
+    assert  set2(6).child_of?(set2(3))
+    assert !set2(8).child_of?(set2(3))
+    assert set2(6).child_of?(set2(3), :conditions => '1 = 1')
+  end
+  
+  def test_direct_child_by_id
+    assert_equal set2(9), set2(4).direct_child_by_id(set2(9).id)
+    assert_nil set2(4).direct_child_by_id(set2(10).id)
+  end
+  
+  def test_direct_child_of
+    assert set2(9).direct_child_of?(set2(4))
+    assert !set2(10).direct_child_of?(set2(4))
+    assert set2(9).direct_child_of?(set2(4), :conditions => '1 = 1')
+  end
+  
+  ##########################################
+  # INDEX-CHECKING METHOD TESTS
+  ##########################################
+  def test_check_subtree
+    root = set2(1)
+    assert_nothing_raised {root.check_subtree}
+    # need to use update_all to get around attr_protected
+    NestedSetWithStringScope.update_all("rgt = #{root.lft + 1}", "id = #{root.id}")
+    assert_raise(ActiveRecord::ActiveRecordError) {root.reload.check_subtree}
+    assert_nothing_raised {set2(4).check_subtree}
+    NestedSetWithStringScope.update_all("lft = 17", "id = 110")
+    assert_raise(ActiveRecord::ActiveRecordError) {set2(4).reload.check_subtree}
+    NestedSetWithStringScope.update_all("rgt = 18", "id = 110")
+    assert_nothing_raised {set2(10).check_subtree}
+    NestedSetWithStringScope.update_all("rgt = NULL", "id = 4002")
+    assert_raise(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.find(4001).reload.check_subtree}
+    # this method receives lots of additional testing through tests of check_full_tree and check_all
+  end
+  
+  def test_check_full_tree
+    assert_nothing_raised {set2(1).check_full_tree}
+    assert_nothing_raised {NestedSetWithStringScope.find(4006).check_full_tree}
+    NestedSetWithStringScope.update_all("rgt = NULL", "id = 4002")
+    assert_raise(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.find(4006).check_full_tree}
+    NestedSetWithStringScope.update_all("rgt = 0", "id = 4001")
+    assert_raise(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.find(4006).check_full_tree}
+    NestedSetWithStringScope.update_all("rgt = rgt + 1", "id > 101")
+    NestedSetWithStringScope.update_all("lft = lft + 1", "id > 101")
+    assert_raise(ActiveRecord::ActiveRecordError) {set2(4).check_full_tree}
+  end
+  
+  def test_check_full_tree_orphan
+    assert_raise(ActiveRecord::RecordNotFound) {NestedSetWithStringScope.find(99)} # make sure ID 99 doesn't exist
+    ns = NestedSetWithStringScope.create(:root_id => 101)
+    NestedSetWithStringScope.update_all("parent_id = 99", "id = #{ns.id}")
+    assert_raise(ActiveRecord::ActiveRecordError) {set2(3).check_full_tree}
+  end
+  
+  def test_check_full_tree_endless_loop
+    ns = NestedSetWithStringScope.create(:root_id => 101)
+    NestedSetWithStringScope.update_all("parent_id = #{ns.id}", "id = #{ns.id}")
+    assert_raise(ActiveRecord::ActiveRecordError) {set2(6).check_full_tree}
+  end
+  
+  def test_check_full_tree_virtual_roots
+    a = Category.create    
+    b = Category.create
+    
+    assert_nothing_raised {a.check_full_tree}
+    Category.update_all("rgt = rgt + 2, lft = lft + 2", "id = #{b.id}") # create a gap between virtual roots
+    assert_raise(ActiveRecord::ActiveRecordError) {a.check_full_tree}
+  end
+  
+  # see also the tests of check_all under 'class method tests'
+    
+  ##########################################
+  # INDEX-ALTERING (UPDATE) METHOD TESTS
+  ##########################################
+  def test_move_to_left_of # this method undergoes additional testing elsewhere
+    set2(2).move_to_left_of(set2(3)) # should cause no change
+    assert_equal(2, set2(2).lft)
+    assert_equal(4, set2(3).lft)
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+    set2(3).move_to_left_of(set2(2))
+    assert_equal(9, set2(3).rgt)
+    set2(2).move_to_left_of(set2(3))
+    assert_equal(2, set2(2).lft)
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+    set2(3).move_to_left_of(102) # pass an ID instead
+    assert_equal(2, set2(3).lft)
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_move_to_right_of # this method undergoes additional testing elsewhere
+    set2(3).move_to_right_of(set2(2)) # should cause no change
+    set2(4).move_to_right_of(set2(3)) # should cause no change
+    assert_equal(11, set2(3).rgt)
+    assert_equal(19, set2(4).rgt)
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+    set2(3).move_to_right_of(set2(4))
+    assert_equal(19, set2(3).rgt)
+    set2(4).move_to_right_of(set2(3))
+    assert_equal(4, set2(3).lft)
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+    set2(3).move_to_right_of(104) # pass an ID instead
+    assert_equal(4, set2(4).lft)
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  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 boundaries
+    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).all_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).all_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).all_children_count, 3)
+    assert_equal(set(2).all_children_count, 1)
+    assert_equal(set(3).all_children_count, 0)
+    assert_equal(set(4).all_children_count, 0)
+    
+    set(2).add_child set(5)
+    set(4).add_child set(6)
+    
+    assert_equal(set(2).all_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)
+
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  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)
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_move_to_child_of_1
+    bill = NestedSetWithStringScope.new(:root_id => 101, :pos => 2)
+    assert_raise(ActiveRecord::ActiveRecordError) { bill.move_to_child_of(set2(1)) }    
+    assert_raise(ActiveRecord::ActiveRecordError) { set2(1).move_to_child_of(set2(1)) }    
+    assert_raise(ActiveRecord::ActiveRecordError) { set2(4).move_to_child_of(set2(9)) }    
+    assert bill.save
+    assert_nothing_raised {set2(1).reload.check_subtree}
+    assert bill.move_to_left_of(set2(3))
+    assert_equal set2(1), bill.parent
+    assert_equal 4, bill.lft
+    assert_equal 5, bill.rgt
+    assert_equal 3, set2(2).reload.rgt
+    assert_equal 6, set2(3).reload.lft
+    assert_equal 22, set2(1).reload.rgt
+    assert_nothing_raised {set2(1).reload.check_subtree}
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+    set2(9).move_to_child_of(101) # pass an ID instead
+    assert set2(1).children.include?(set2(9))
+    assert_equal(18, set2(9).lft) # to the right of existing children?
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_move_to_child_of_2
+    bill = NestedSetWithStringScope.new(:root_id => 101)
+    assert_nothing_raised {set2(1).check_subtree}
+    assert bill.save
+    assert bill.move_to_child_of(set2(10))
+    assert_equal set2(10), bill.parent
+    assert_equal 17, bill.lft
+    assert_equal 18, bill.rgt
+    assert_equal 16, set2(10).reload.lft
+    assert_equal 19, set2(10).reload.rgt
+    assert_equal 15, set2(9).reload.lft
+    assert_equal 20, set2(9).reload.rgt
+    assert_equal 21, set2(4).reload.rgt
+    assert_nothing_raised {set2(9).reload.check_subtree}
+    assert_nothing_raised {set2(4).reload.check_subtree}
+    assert_nothing_raised {set2(1).reload.check_subtree}
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_move_to_child_of_3
+    bill = NestedSetWithStringScope.new(:root_id => 101)
+    assert bill.save
+    assert bill.move_to_child_of(set2(3))
+    assert_equal(11, bill.lft) # to the right of existing children?
+    assert_nothing_raised {set2(1).reload.check_subtree}
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_move_1
+    set2(4).move_to_child_of(set2(3))
+    assert_equal(set2(3), set2(4).reload.parent)
+    assert_equal(1, set2(1).reload.lft)
+    assert_equal(20, set2(1).reload.rgt)
+    assert_equal(4, set2(3).reload.lft)
+    assert_equal(19, set2(3).reload.rgt)
+    assert_nothing_raised {set2(1).reload.check_subtree}
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_move_2
+    initial = set2(1).full_set
+    assert_raise(ActiveRecord::ActiveRecordError) { set2(3).move_to_child_of(set2(6)) } # can't set a current child as the parent-- creates a loop
+    assert_raise(ActiveRecord::ActiveRecordError) { set2(3).move_to_child_of(set2(3)) }
+    set2(2).move_to_child_of(set2(5))
+    set2(4).move_to_child_of(set2(2))
+    set2(10).move_to_right_of(set2(3))
+    
+    assert_equal 105, set2(2).parent_id
+    assert_equal 102, set2(4).parent_id
+    assert_equal 101, set2(10).parent_id
+    set2(3).reload
+    set2(10).reload
+    assert_equal 19, set2(10).rgt
+    assert_equal 17, set2(3).rgt
+    assert_equal 2, set2(3).lft
+    set2(1).reload
+    assert_nothing_raised {set2(1).check_subtree}
+    set2(4).move_to_right_of(set2(3))
+    set2(10).move_to_child_of(set2(9))
+    set2(2).move_to_left_of(set2(3))
+    
+    # now everything should be back where it started-- check against initial
+    final = set2(1).reload.full_set
+    assert_equal(initial, final)
+    for i in 0..9
+      assert_equal(initial[i]['parent_id'], final[i]['parent_id'])
+      assert_equal(initial[i]['lft'], final[i]['lft'])
+      assert_equal(initial[i]['rgt'], final[i]['rgt'])
+    end
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_scope_enforcement # prevent moves between trees
+    assert_raise(ActiveRecord::ActiveRecordError) { set(3).move_to_child_of(set2(6)) }
+    ns = NestedSetWithStringScope.create(:root_id => 214)
+    assert_raise(ActiveRecord::ActiveRecordError) { ns.move_to_child_of(set2(1)) }
+  end
+  
+  ##########################################
+  # ACTS_AS_LIST-LIKE BEHAVIOUR TESTS
+  ##########################################  
+  
+  def test_swap
+    set2(5).swap(set2(7))
+    assert_equal [107, 106, 105], set2(3).children.map(&:id)   
+    assert_nothing_raised {set2(3).check_full_tree}
+    assert_raise(ActiveRecord::ActiveRecordError) { set2(3).swap(set2(10)) } # isn't a sibling...
+  end
+  
+  def test_insert_at
+    child = NestedSetWithStringScope.create(:root_id => 101)
+    child.insert_at(set2(3), :last)
+    assert_equal child, set2(3).children.last
+    
+    child = NestedSetWithStringScope.create(:root_id => 101)
+    child.insert_at(set2(3), :first)
+    assert_equal child, set2(3).children.first
+    
+    child = NestedSetWithStringScope.create(:root_id => 101)
+    child.insert_at(set2(3), 2)
+    assert_equal child, set2(3).children[2]
+    
+    child = NestedSetWithStringScope.create(:root_id => 101)
+    child.insert_at(set2(3), 1000)
+    assert_equal child, set2(3).children.last
+    
+    child = NestedSetWithStringScope.create(:root_id => 101)
+    child.insert_at(set2(3), 1)
+    assert_equal child, set2(3).children[1]
+  end
+  
+  def test_move_higher
+    set2(7).move_higher
+    assert_equal [105, 107, 106], set2(3).children.map(&:id)
+    set2(7).move_higher
+    assert_equal [107, 105, 106], set2(3).children.map(&:id)
+    set2(7).move_higher
+    assert_equal [107, 105, 106], set2(3).children.map(&:id)
+  end
+  
+  def test_move_lower
+    set2(5).move_lower
+    assert_equal [106, 105, 107], set2(3).children.map(&:id)
+    set2(5).move_lower
+    assert_equal [106, 107, 105], set2(3).children.map(&:id)
+    set2(5).move_lower
+    assert_equal [106, 107, 105], set2(3).children.map(&:id)
+  end
+  
+  def test_move_to_top
+    set2(7).move_to_top
+    assert_equal [107, 105, 106], set2(3).children.map(&:id)
+  end
+  
+  def test_move_to_bottom
+    set2(5).move_to_bottom
+    assert_equal [106, 107, 105], set2(3).children.map(&:id)
+  end
+  
+  def test_move_to_position
+    set2(7).move_to_position(:first)
+    assert_equal [107, 105, 106], set2(3).children.map(&:id)
+    set2(7).move_to_position(:last)
+    assert_equal [105, 106, 107], set2(3).children.map(&:id)
+  end
+    
+  def test_move_to_position_limits
+    set2(7).move_to_position(0)
+    assert_equal [107, 105, 106], set2(3).children.map(&:id)
+    set2(7).move_to_position(100)
+    assert_equal [105, 106, 107], set2(3).children.map(&:id)
+  end  
+  
+  def test_move_to_position_index
+    set2(7).move_to_position(0)
+    assert_equal [107, 105, 106], set2(3).children.map(&:id)
+    set2(7).move_to_position(1)
+    assert_equal [105, 107, 106], set2(3).children.map(&:id)
+    set2(7).move_to_position(2)
+    assert_equal [105, 106, 107], set2(3).children.map(&:id)
+    set2(5).move_to_position(2)
+    assert_equal [106, 107, 105], set2(3).children.map(&:id)
+  end
+  
+  def test_scoped_move_to_position
+    set2(7).move_to_position(0, :conditions => { :id => [105, 106, 107] })
+    assert_equal [107, 105, 106], set2(3).children.map(&:id)
+    set2(7).move_to_position(1, :conditions => { :id => [105, 107] })
+    assert_equal [105, 107, 106], set2(3).children.map(&:id)
+    set2(7).move_to_position(1, :conditions => { :id => [106, 107] })
+    assert_equal [105, 106, 107], set2(3).children.map(&:id)  
+  end
+  
+  def test_reorder_children     
+    assert_equal [105], set2(3).reorder_children(107, 106, 105).map(&:id)
+    assert_equal [107, 106, 105], set2(3).children.map(&:id)   
+    assert_equal [107, 106], set2(3).reorder_children(106, 105, 107).map(&:id)
+    assert_equal [106, 105, 107], set2(3).children.map(&:id)
+  end
+  
+  def test_reorder_children_with_random_samples
+    10.times do
+      child = NestedSetWithStringScope.create(:root_id => 101)
+      child.move_to_child_of set2(3)
+    end
+    ordered_ids = set2(3).children.map(&:id).sort_by { rand }
+    set2(3).reorder_children(ordered_ids)
+    assert_equal ordered_ids, set2(3).children.map(&:id)
+  end
+
+  def test_reorder_children_with_partial_id_set
+    10.times do
+      child = NestedSetWithStringScope.create(:root_id => 101)
+      child.move_to_child_of set2(3)
+    end
+    child_ids = set2(3).children.map(&:id)
+    set2(3).reorder_children(child_ids.last, child_ids.first)
+    ordered_ids = set2(3).children.map(&:id)
+    assert_equal ordered_ids.first, child_ids.last
+    assert_equal ordered_ids.last, child_ids.first
+    assert_equal child_ids[1, -2], ordered_ids[1, -2]
+  end
+  
+  ##########################################
+  # RENUMBERING TESTS
+  ##########################################
+  # see also class method tests of renumber_all
+  def test_renumber_full_tree_1
+    NestedSetWithStringScope.update_all("lft = NULL, rgt = NULL", "root_id = 101")
+    assert_raise(ActiveRecord::ActiveRecordError) {set2(1).check_full_tree}
+    set2(1).renumber_full_tree
+    set2(1).reload
+    assert_equal 1, set2(1).lft
+    assert_equal 20, set2(1).rgt
+    assert_equal 4, set2(3).lft
+    assert_equal 11, set2(3).rgt
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_renumber_full_tree_2
+    NestedSetWithStringScope.update_all("lft = lft + 1, rgt = rgt + 1", "root_id = 101")
+    assert_raise(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.check_all}
+    set2(1).renumber_full_tree
+    assert_nothing_raised(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.check_all}
+    NestedSetWithStringScope.update_all("rgt = 12", "id = 108")
+    assert_raise(ActiveRecord::ActiveRecordError) {set2(8).check_subtree}
+    set2(8).renumber_full_tree
+    assert_nothing_raised(ActiveRecord::ActiveRecordError) {NestedSetWithStringScope.check_all}
+  end
+  
+  
+  ##########################################
+  # CONCURRENCY TESTS
+  ##########################################
+  # what happens when multiple objects are being manipulated at the same time?
+  def test_concurrent_save
+    c1, c2, c3 = Category.create, Category.create, Category.create
+    c1.move_to_right_of(c3)
+    c2.save
+    assert_nothing_raised {Category.check_all}
+    
+    ns1 = set2(3)
+    ns2 = set2(4)
+    ns2.move_to_left_of(102) # ns1 is now out-of-date
+    ns1.save
+    assert_nothing_raised {set2(1).check_subtree}
+  end
+  
+  def test_concurrent_add_add
+    c1 = Category.new
+    c2 = Category.new
+    c1.save
+    c2.save
+    c3 = Category.new
+    c4 = Category.new
+    c4.save # now in the opposite order
+    c3.save
+    assert_nothing_raised {Category.check_all}
+  end
+  
+  def test_concurrent_add_delete
+    ns = set2(3)
+    new_ns = NestedSetWithStringScope.create(:root_id => 101)
+    ns.destroy
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_concurrent_add_move
+    ns = set2(3)
+    new_ns = NestedSetWithStringScope.create(:root_id => 101)
+    ns.move_to_left_of(102)
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_concurrent_delete_add
+    ns = set2(3)
+    new_ns = NestedSetWithStringScope.new(:root_id => 101)
+    ns.destroy
+    new_ns.save
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_concurrent_delete_delete
+    ns1 = set2(3)
+    ns2 = set2(4)
+    ns1.destroy
+    ns2.destroy
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_concurrent_delete_move
+    ns1 = set2(3)
+    ns2 = set2(4)
+    ns1.destroy
+    ns2.move_to_left_of(102)
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_concurrent_move_add
+    ns = set2(3)
+    new_ns = NestedSetWithStringScope.new(:root_id => 101)
+    ns.move_to_left_of(102)
+    new_ns.save
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_concurrent_move_delete
+    ns1 = set2(3)
+    ns2 = set2(4)
+    ns2.move_to_left_of(102)
+    ns1.destroy
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  def test_concurrent_move_move
+    ns1 = set2(3)
+    ns2 = set2(4)
+    ns1.move_to_left_of(102)
+    ns2.move_to_child_of(102)
+    assert_nothing_raised {NestedSetWithStringScope.check_all}    
+  end
+  
+  ##########################################
+  # CALLBACK TESTS
+  ##########################################
+  # Because the nested set code relies heavily on callbacks, we
+  # want to ensure that we aren't causing problems for user-defined callbacks
+  def test_callbacks    
+    # 1) Do all user-defined callbacks work?
+    $callbacks = []
+    ns = NS2.new(:root_id => 101) # NS2 adds symbols to $callbacks when the callbacks fire
+    assert_equal([], $callbacks)
+    ns.save!
+    assert_equal([:before_save, :before_create, :after_create, :after_save], $callbacks)
+    $callbacks = []
+    ns.pos = 2
+    ns.save!
+    assert_equal([:before_save, :before_update, :after_update, :after_save], $callbacks)
+    $callbacks = []
+    ns.destroy
+    assert_equal([:before_destroy, :after_destroy], $callbacks)
+  end
+  
+  def test_callbacks2
+    # 2) Do our callbacks still work, even when a programmer defines 
+    # their own callbacks in the overwriteable style?
+    # (the NS2 model defines callbacks in the overwritable style)
+    ns = NS2.create(:root_id => 101)
+    assert ns.lft != nil && ns.rgt != nil
+    child_ns = NS2.create(:root_id => 101)
+    child_ns.move_to_child_of(ns)
+    id = child_ns.id
+    ns.destroy
+    assert_equal(nil, NS2.find(:first, :conditions => "id = #{id}"))
+    # lots of implicit testing occurs in other test methods
+  end
+
+  ##########################################
+  # BUG-SPECIFIC TESTS
+  ##########################################
+  def test_ticket_17
+    main = Category.new
+    main.save
+    sub = Category.new
+    sub.save
+    sub.move_to_child_of main
+    sub.save
+    main.save
+    
+    assert_equal(1, main.all_children_count)
+    assert_equal([main, sub], main.full_set)
+    assert_equal([sub], main.all_children)
+    
+    assert_equal(1, main.lft)
+    assert_equal(2, sub.lft)
+    assert_equal(3, sub.rgt)
+    assert_equal(4, main.rgt)
+  end
+  
+  def test_ticket_19
+    # this test currently relies on the fact that objects are reloaded at the beginning of the move_to methods
+    root = Category.create
+    first = Category.create
+    second = Category.create
+    first.move_to_child_of(root)
+    second.move_to_child_of(root)
+    
+    # now we should have the situation described in the ticket
+    assert_nothing_raised {first.move_to_child_of(second)}
+    assert_raise(ActiveRecord::ActiveRecordError) {second.move_to_child_of(first)} # try illegal move
+    first.move_to_child_of(root) # move it back
+    assert_nothing_raised {first.move_to_child_of(second)} # try it the other way-- first is now on the other side of second
+    assert_nothing_raised {Category.check_all}
+  end
+  
+  # Note that single-table inheritance recieves extensive implicit testing,
+  # because one of the fixture trees contains a hodge-podge of classes.
+  def test_ticket_10
+    assert_equal(9, set2(1).all_children.size)
+    NS2.find(103).move_to_right_of(104)
+    assert_equal(4, set2(4).lft)
+    assert_equal(10, set2(9).rgt)
+    NS2.find(103).destroy
+    assert_equal(12, set2(1).rgt)
+    assert_equal(6, NestedSetWithStringScope.count(:conditions => "root_id = 101"))
+    assert_nothing_raised {NestedSetWithStringScope.check_all}
+  end
+  
+  # the next virtual root was not starting with the correct lft value
+  def test_ticket_29
+    first = Category.create
+    second = Category.create
+    Category.renumber_all
+    second.reload
+    assert_equal(3, second.lft)    
+  end
+  
+end
+
+
+
+###################################################################
+## Tests that don't pass yet or haven't been finished
+
+## make #destroy set left & rgt to nil? 
+
+#def test_find_insertion_point
+#  bill = NestedSetWithStringScope.create(:pos => 2, :root_id => 101)
+#  assert_equal 3, bill.find_insertion_point(set2(1))
+#  assert_equal 4, bill.find_insertion_point(set2(3))
+#  aalfred = NestedSetWithStringScope.create(:pos => 0, :root_id => 101)
+#  assert_equal 1, aalfred.find_insertion_point(set2(1))
+#  assert_equal 2, aalfred.find_insertion_point(set2(2))
+#  assert_equal 12, aalfred.find_insertion_point(set2(4))
+#  zed = NestedSetWithStringScope.create(:pos => 99, :root_id => 101)
+#  assert_equal 19, zed.find_insertion_point(set2(1))
+#  assert_equal 17, zed.find_insertion_point(set2(9))
+#  assert_equal 16, zed.find_insertion_point(set2(10))
+#  assert_equal 10, set2(4).find_insertion_point(set2(3))
+#end
+#