mongoid-ancestry-fixes 0.0.1

data/spec/lib/mongoid-ancestry/class_methods_spec.rb

@@ -0,0 +1,300 @@
+require 'spec_helper'
+
+describe MongoidAncestry do
+
+  subject { MongoidAncestry }
+
+  it "should have scopes" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      # Roots assertion
+      model.roots.all.to_a.should eql(roots.map(&:first))
+
+      model.all.each do |test_node|
+        # Assertions for ancestors_of named scope
+        model.ancestors_of(test_node).all.should == test_node.ancestors.all
+        model.ancestors_of(test_node.id).all.to_a.should eql(test_node.ancestors.all.to_a)
+        # Assertions for children_of named scope
+        model.children_of(test_node).all.to_a.should eql(test_node.children.all.to_a)
+        model.children_of(test_node.id).all.to_a.should eql(test_node.children.all.to_a)
+        # Assertions for descendants_of named scope
+        model.descendants_of(test_node).all.should == (test_node.descendants.all)
+        model.descendants_of(test_node.id).all.to_a.should eql(test_node.descendants.all.to_a)
+        # Assertions for subtree_of named scope
+        model.subtree_of(test_node).all.to_a.should eql(test_node.subtree.all.to_a)
+        model.subtree_of(test_node.id).all.to_a.should eql(test_node.subtree.all.to_a)
+        # Assertions for siblings_of named scope
+        model.siblings_of(test_node).all.to_a.should eql(test_node.siblings.all.to_a)
+        model.siblings_of(test_node.id).all.to_a.should eql(test_node.siblings.all.to_a)
+      end
+    end
+  end
+
+  it "should be arranged" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      id_sorter = Proc.new {|a, b|; a.to_param <=> b.to_param }
+      arranged_nodes = model.arrange
+      arranged_nodes.size.should eql(3)
+      arranged_nodes.each do |node, children|
+        children.keys.sort(&id_sorter).should eql(node.children.sort(&id_sorter))
+        children.each do |node, children|
+          children.keys.sort(&id_sorter).should eql(node.children.sort(&id_sorter))
+          children.each do |node, children|
+            children.size.should eql(0)
+          end
+        end
+      end
+    end
+  end
+
+  it "should have arrange order option" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      descending_nodes_lvl0 = model.arrange :order => [:_id, :desc]
+      ascending_nodes_lvl0 = model.arrange :order => [:_id, :asc]
+
+      descending_nodes_lvl0.keys.zip(ascending_nodes_lvl0.keys.reverse).each do |descending_node, ascending_node|
+        ascending_node.should eql(descending_node)
+        descending_nodes_lvl1 = descending_nodes_lvl0[descending_node]
+        ascending_nodes_lvl1 = ascending_nodes_lvl0[ascending_node]
+        descending_nodes_lvl1.keys.zip(ascending_nodes_lvl1.keys.reverse).each do |descending_node, ascending_node|
+          ascending_node.should eql(descending_node)
+          descending_nodes_lvl2 = descending_nodes_lvl1[descending_node]
+          ascending_nodes_lvl2 = ascending_nodes_lvl1[ascending_node]
+          descending_nodes_lvl2.keys.zip(ascending_nodes_lvl2.keys.reverse).each do |descending_node, ascending_node|
+            ascending_node.should eql(descending_node)
+            descending_nodes_lvl3 = descending_nodes_lvl2[descending_node]
+            ascending_nodes_lvl3 = ascending_nodes_lvl2[ascending_node]
+            descending_nodes_lvl3.keys.zip(ascending_nodes_lvl3.keys.reverse).each do |descending_node, ascending_node|
+              ascending_node.should eql(descending_node)
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  it "should have valid orphan rootify strategy" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      model.orphan_strategy = :rootify
+      root = roots.first.first
+      children = root.children.all
+      root.destroy
+      children.each do |child|
+        child.reload
+        child.is_root?.should be_true
+        child.children.size.should eql(3)
+      end
+    end
+  end
+
+  it "should have valid orphan destroy strategy" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      model.orphan_strategy = :destroy
+      root = roots.first.first
+      expect { root.destroy }.to change(model, :count).by(-root.subtree.size)
+      node = model.roots.first.children.first
+      expect { node.destroy }.to change(model, :count).by(-node.subtree.size)
+    end
+  end
+
+  it "should have valid orphan restrict strategy" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      model.orphan_strategy = :restrict
+      root = roots.first.first
+      expect { root.destroy }.to raise_error Mongoid::Ancestry::Error
+      expect { root.children.first.children.first.destroy }.to_not raise_error Mongoid::Ancestry::Error
+    end
+  end
+
+  it "should check that there are no errors on a valid tree" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      expect { model.check_ancestry_integrity! }.to_not raise_error(Mongoid::Ancestry::Error)
+      model.check_ancestry_integrity!(:report => :list).size.should eql(0)
+    end
+  end
+
+  it "should check detection of invalid format for ancestry field" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      roots.first.first.update_attribute model.ancestry_field, 'invalid_ancestry'
+      expect { model.check_ancestry_integrity! }.to raise_error(Mongoid::Ancestry::IntegrityError)
+      model.check_ancestry_integrity!(:report => :list).size.should eql(1)
+    end
+  end
+
+  it "should check detection of non-existent ancestor" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      node = roots.first.first
+      node.without_ancestry_callbacks do
+       node.update_attribute model.ancestry_field, 35
+      end
+      expect { model.check_ancestry_integrity! }.to raise_error(Mongoid::Ancestry::IntegrityError)
+      model.check_ancestry_integrity!(:report => :list).size.should eql(1)
+    end
+  end
+
+  it "should check detection of cyclic ancestry" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      node = roots.first.first
+      node.update_attribute model.ancestry_field, node.id
+      expect { model.check_ancestry_integrity! }.to raise_error(Mongoid::Ancestry::IntegrityError)
+      model.check_ancestry_integrity!(:report => :list).size.should eql(1)
+    end
+  end
+
+  it "should check detection of conflicting parent id" do
+    subject.with_model do |model|
+      model.destroy_all
+      model.create!(model.ancestry_field => model.create!(model.ancestry_field => model.create!(model.ancestry_field => nil).id).id)
+      expect { model.check_ancestry_integrity! }.to raise_error(Mongoid::Ancestry::IntegrityError)
+      model.check_ancestry_integrity!(:report => :list).size.should eql(1)
+    end
+  end
+
+  def assert_integrity_restoration model
+    expect { model.check_ancestry_integrity! }.to raise_error(Mongoid::Ancestry::IntegrityError)
+    model.restore_ancestry_integrity!
+    expect { model.check_ancestry_integrity! }.to_not raise_error(Mongoid::Ancestry::IntegrityError)
+  end
+
+  it "should check that integrity is restored for invalid format for ancestry field" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      roots.first.first.update_attribute model.ancestry_field, 'invalid_ancestry'
+      assert_integrity_restoration model
+    end
+  end
+
+  it "should check that integrity is restored for non-existent ancestor" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      roots.first.first.update_attribute model.ancestry_field, 35
+      assert_integrity_restoration model
+    end
+  end
+
+  it "should check that integrity is restored for cyclic ancestry" do
+    subject.with_model :width => 3, :depth => 3 do |model, roots|
+      node = roots.first.first
+      node.update_attribute model.ancestry_field, node.id
+      assert_integrity_restoration model
+    end
+  end
+
+  it "should check that integrity is restored for conflicting parent id" do
+    subject.with_model do |model|
+      model.destroy_all
+      model.create!(model.ancestry_field => model.create!(model.ancestry_field => model.create!(model.ancestry_field => nil).id).id)
+      assert_integrity_restoration model
+    end
+  end
+
+  it "should create node through scope" do
+    subject.with_model do |model|
+      node = model.create!
+      child = node.children.create # doesn't pass with .create!
+      child.parent.should eql(node)
+
+      other_child = child.siblings.create # doesn't pass with .create!
+      other_child.parent.should eql(node)
+
+      grandchild = model.children_of(child).build # doesn't pass with .new
+      grandchild.save
+      grandchild.parent.should eql(child)
+
+      other_grandchild = model.siblings_of(grandchild).build # doesn't pass with .new
+      other_grandchild.save!
+      other_grandchild.parent.should eql(child)
+    end
+  end
+
+  it "should have depth scopes" do
+    subject.with_model :depth => 4, :width => 2, :cache_depth => true do |model, roots|
+      model.before_depth(2).all? { |node| node.depth < 2 }.should be_true
+      model.to_depth(2).all?     { |node| node.depth <= 2 }.should be_true
+      model.at_depth(2).all?     { |node| node.depth == 2 }.should be_true
+      model.from_depth(2).all?   { |node| node.depth >= 2 }.should be_true
+      model.after_depth(2).all?  { |node| node.depth > 2 }.should be_true
+    end
+  end
+
+  it "should raise error on invalid scopes" do
+    subject.with_model do |model|
+      expect { model.before_depth(1) } .to raise_error(Mongoid::Ancestry::Error)
+      expect { model.to_depth(1)     } .to raise_error(Mongoid::Ancestry::Error)
+      expect { model.at_depth(1)     } .to raise_error(Mongoid::Ancestry::Error)
+      expect { model.from_depth(1)   } .to raise_error(Mongoid::Ancestry::Error)
+      expect { model.after_depth(1)  } .to raise_error(Mongoid::Ancestry::Error)
+    end
+  end
+
+  it "should raise error on invalid has_ancestry options" do
+    subject.with_model do |model|
+      expect { model.has_ancestry :this_option_doesnt_exist => 42 }.to raise_error(Mongoid::Ancestry::Error)
+      expect { model.has_ancestry :not_a_hash                     }.to raise_error(Mongoid::Ancestry::Error)
+    end
+  end
+
+  it "should build ancestry from parent ids" do
+    subject.with_model :skip_ancestry => true, :extra_columns => {:parent_id => :integer} do |model|
+      [model.create!].each do |parent1|
+        (Array.new(5) { model.create :parent_id => parent1.id }).each do |parent2|
+          (Array.new(5) { model.create :parent_id => parent2.id }).each do |parent3|
+            (Array.new(5) { model.create :parent_id => parent3.id })
+          end
+        end
+      end
+
+      # Assert all nodes where created
+      model.count.should eql((0..3).map { |n| 5 ** n }.sum)
+    end
+
+    subject.with_model do |model|
+
+      model.build_ancestry_from_parent_ids!
+
+      # Assert ancestry integrity
+      model.check_ancestry_integrity!
+
+      roots = model.roots.all
+      ## Assert single root node
+      roots.size.should eql(1)
+
+      ## Assert it has 5 children
+      roots.each do |parent|
+        parent.children.count.should eql(5)
+        parent.children.each do |parent|
+          parent.children.count.should eql(5)
+          parent.children.each do |parent|
+            parent.children.count.should eql(5)
+            parent.children.each do |parent|
+              parent.children.count.should eql(0)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  it "should rebuild depth cache" do
+    subject.with_model :depth => 3, :width => 3, :cache_depth => true, :depth_cache_field => :depth_cache do |model, roots|
+      model.update_all(:depth_cache => nil)
+
+      # Assert cache was emptied correctly
+      model.all.each do |test_node|
+        test_node.depth_cache.should eql(nil)
+      end
+
+      # Rebuild cache
+      model.rebuild_depth_cache!
+
+      # Assert cache was rebuild correctly
+      model.all.each do |test_node|
+        test_node.depth_cache.should eql(test_node.depth)
+      end
+    end
+  end
+
+  it "should raise exception when rebuilding depth cache for model without depth caching" do
+    subject.with_model do |model|
+      expect { model.rebuild_depth_cache! }.to raise_error(Mongoid::Ancestry::Error)
+    end
+  end
+
+end

data/spec/lib/mongoid-ancestry/instance_methods_spec.rb

@@ -0,0 +1,241 @@
+require 'spec_helper'
+
+describe MongoidAncestry do
+
+  subject { MongoidAncestry }
+
+  it "should have tree navigation" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      roots.each do |lvl0_node, lvl0_children|
+        # Ancestors assertions
+        lvl0_node.ancestor_ids.should eql([])
+        lvl0_node.ancestors.to_a.should eql([])
+        lvl0_node.path_ids.should eql([lvl0_node.id])
+        lvl0_node.path.to_a.should eql([lvl0_node])
+        lvl0_node.depth.should eql(0)
+        # Parent assertions
+        lvl0_node.parent_id.should be_nil
+        lvl0_node.parent.should be_nil
+        # Root assertions
+        lvl0_node.root_id.should eql(lvl0_node.id)
+        lvl0_node.root.should eql(lvl0_node)
+        lvl0_node.is_root?.should be_true
+        # Children assertions
+        lvl0_node.child_ids.should eql(lvl0_children.map(&:first).map(&:id))
+        lvl0_node.children.to_a.should eql(lvl0_children.map(&:first))
+        lvl0_node.has_children?.should be_true
+        lvl0_node.is_childless?.should be_false
+        # Siblings assertions
+        lvl0_node.sibling_ids.should eql(roots.map(&:first).map(&:id))
+        lvl0_node.siblings.to_a.should eql(roots.map(&:first))
+        lvl0_node.has_siblings?.should be_true
+        lvl0_node.is_only_child?.should be_false
+        # Descendants assertions
+        descendants = model.all.find_all do |node|
+          node.ancestor_ids.include?(lvl0_node.id)
+        end
+        lvl0_node.descendant_ids.should eql(descendants.map(&:id))
+        lvl0_node.descendants.to_a.should eql(descendants)
+        lvl0_node.subtree.to_a.should eql([lvl0_node] + descendants)
+
+        lvl0_children.each do |lvl1_node, lvl1_children|
+          # Ancestors assertions
+          lvl1_node.ancestor_ids.should eql([lvl0_node.id])
+          lvl1_node.ancestors.to_a.should eql([lvl0_node])
+          lvl1_node.path_ids.should eql([lvl0_node.id, lvl1_node.id])
+          lvl1_node.path.to_a.should eql([lvl0_node, lvl1_node])
+          lvl1_node.depth.should eql(1)
+          # Parent assertions
+          lvl1_node.parent_id.should eql(lvl0_node.id)
+          lvl1_node.parent.should eql(lvl0_node)
+          # Root assertions
+          lvl1_node.root_id.should eql(lvl0_node.id)
+          lvl1_node.root.should eql(lvl0_node)
+          lvl1_node.is_root?.should be_false
+          # Children assertions
+          lvl1_node.child_ids.should eql(lvl1_children.map(&:first).map(&:id))
+          lvl1_node.children.to_a.should eql(lvl1_children.map(&:first))
+          lvl1_node.has_children?.should be_true
+          lvl1_node.is_childless?.should be_false
+          # Siblings assertions
+          lvl1_node.sibling_ids.should eql(lvl0_children.map(&:first).map(&:id))
+          lvl1_node.siblings.to_a.should eql(lvl0_children.map(&:first))
+          lvl1_node.has_siblings?.should be_true
+          lvl1_node.is_only_child?.should be_false
+          # Descendants assertions
+          descendants = model.all.find_all do |node|
+            node.ancestor_ids.include? lvl1_node.id
+          end
+
+          lvl1_node.descendant_ids.should eql(descendants.map(&:id))
+          lvl1_node.descendants.to_a.should eql(descendants)
+          lvl1_node.subtree.to_a.should eql([lvl1_node] + descendants)
+
+          lvl1_children.each do |lvl2_node, lvl2_children|
+            # Ancestors assertions
+            lvl2_node.ancestor_ids.should eql([lvl0_node.id, lvl1_node.id])
+            lvl2_node.ancestors.to_a.should eql([lvl0_node, lvl1_node])
+            lvl2_node.path_ids.should eql([lvl0_node.id, lvl1_node.id, lvl2_node.id])
+            lvl2_node.path.to_a.should eql([lvl0_node, lvl1_node, lvl2_node])
+            lvl2_node.depth.should eql(2)
+            # Parent assertions
+            lvl2_node.parent_id.should eql(lvl1_node.id)
+            lvl2_node.parent.should eql(lvl1_node)
+            # Root assertions
+            lvl2_node.root_id.should eql(lvl0_node.id)
+            lvl2_node.root.should eql(lvl0_node)
+            lvl2_node.is_root?.should be_false
+            # Children assertions
+            lvl2_node.child_ids.should eql([])
+            lvl2_node.children.to_a.should eql([])
+            lvl2_node.has_children?.should be_false
+            lvl2_node.is_childless?.should be_true
+            # Siblings assertions
+            lvl2_node.sibling_ids.should eql(lvl1_children.map(&:first).map(&:id))
+            lvl2_node.siblings.to_a.should eql(lvl1_children.map(&:first))
+            lvl2_node.has_siblings?.should be_true
+            lvl2_node.is_only_child?.should be_false
+            # Descendants assertions
+            descendants = model.all.find_all do |node|
+              node.ancestor_ids.include? lvl2_node.id
+            end
+            lvl2_node.descendant_ids.should eql(descendants.map(&:id))
+            lvl2_node.descendants.to_a.should eql(descendants)
+            lvl2_node.subtree.to_a.should eql([lvl2_node] + descendants)
+          end
+        end
+      end
+    end
+  end
+
+  it "should validate ancestry field" do
+    subject.with_model do |model|
+      node = model.create
+      ['3', '10/2', '1/4/30', nil].each do |value|
+        node.send :write_attribute, model.ancestry_field, value
+        node.should be_valid
+        node.errors[model.ancestry_field].blank?.should be_true
+      end
+      ['1/3/', '/2/3', 'A/b', '-34', '/54'].each do |value|
+        node.send :write_attribute, model.ancestry_field, value
+        node.should_not be_valid
+        node.errors[model.ancestry_field].blank?.should be_false
+      end
+    end
+  end
+
+  it "should move descendants with node" do
+    subject.with_model :depth => 3, :width => 3 do |model, roots|
+      root1, root2, root3 = roots.map(&:first)
+
+      descendants = root1.descendants.asc(:_id).map(&:to_param)
+      expect {
+        root1.parent = root2
+        root1.save!
+        root1.descendants.asc(:_id).map(&:to_param).should eql(descendants)
+      }.to change(root2.descendants, 'size').by(root1.subtree.size)
+
+      descendants = root2.descendants.asc(:_id).map(&:to_param)
+      expect {
+        root2.parent = root3
+        root2.save!
+        root2.descendants.asc(:_id).map(&:to_param).should eql(descendants)
+      }.to change(root3.descendants, 'size').by(root2.subtree.size)
+
+      descendants = root1.descendants.asc(:_id).map(&:to_param)
+      expect {
+        expect {
+          root1.parent = nil
+          root1.save!
+          root1.descendants.asc(:_id).map(&:to_param).should eql(descendants)
+        }.to change(root3.descendants, 'size').by(-root1.subtree.size)
+      }.to change(root2.descendants, 'size').by(-root1.subtree.size)
+    end
+  end
+
+  it "should validate ancestry exclude self" do
+    subject.with_model do |model|
+      parent = model.create!
+      child = parent.children.create
+      expect { parent.update_attributes! :parent => child }.to raise_error(Mongoid::Errors::Validations)
+    end
+  end
+
+  it "should have depth caching" do 
+    subject.with_model :depth => 3, :width => 3, :cache_depth => true, :depth_cache_field => :depth_cache do |model, roots|
+      roots.each do |lvl0_node, lvl0_children|
+        lvl0_node.depth_cache.should eql(0)
+        lvl0_children.each do |lvl1_node, lvl1_children|
+          lvl1_node.depth_cache.should eql(1)
+          lvl1_children.each do |lvl2_node, lvl2_children|
+            lvl2_node.depth_cache.should eql(2)
+          end
+        end
+      end
+    end
+  end
+
+  it "should have descendants with depth constraints" do
+    subject.with_model :depth => 4, :width => 4, :cache_depth => true do |model, roots|
+      model.roots.first.descendants(:before_depth => 2).count.should eql(4)
+      model.roots.first.descendants(:to_depth => 2).count.should eql(20)
+      model.roots.first.descendants(:at_depth => 2).count.should eql(16)
+      model.roots.first.descendants(:from_depth => 2).count.should eql(80)
+      model.roots.first.descendants(:after_depth => 2).count.should eql(64)
+    end
+  end
+
+  it "should have subtree with depth constraints" do
+    subject.with_model :depth => 4, :width => 4, :cache_depth => true do |model, roots|
+      model.roots.first.subtree(:before_depth => 2).count.should eql(5)
+      model.roots.first.subtree(:to_depth => 2).count.should eql(21)
+      model.roots.first.subtree(:at_depth => 2).count.should eql(16)
+      model.roots.first.subtree(:from_depth => 2).count.should eql(80)
+      model.roots.first.subtree(:after_depth => 2).count.should eql(64)
+    end
+  end
+
+  it "should have ancestors with depth constraints" do
+    subject.with_model :cache_depth => true do |model|
+      node1 = model.create!
+      node2 = node1.children.create
+      node3 = node2.children.create
+      node4 = node3.children.create
+      node5 = node4.children.create
+      leaf  = node5.children.create
+
+      leaf.ancestors(:before_depth => -2).to_a.should eql([node1, node2, node3])
+      leaf.ancestors(:to_depth => -2).to_a.should eql([node1, node2, node3, node4])
+      leaf.ancestors(:at_depth => -2).to_a.should eql([node4])
+      leaf.ancestors(:from_depth => -2).to_a.should eql([node4, node5])
+      leaf.ancestors(:after_depth => -2).to_a.should eql([node5])
+    end
+  end
+
+  it "should have path with depth constraints" do
+    subject.with_model :cache_depth => true do |model|
+      node1 = model.create!
+      node2 = node1.children.create
+      node3 = node2.children.create
+      node4 = node3.children.create
+      node5 = node4.children.create
+      leaf  = node5.children.create
+
+      leaf.path(:before_depth => -2).to_a.should eql([node1, node2, node3])
+      leaf.path(:to_depth => -2).to_a.should eql([node1, node2, node3, node4])
+      leaf.path(:at_depth => -2).to_a.should eql([node4])
+      leaf.path(:from_depth => -2).to_a.should eql([node4, node5, leaf])
+      leaf.path(:after_depth => -2).to_a.should eql([node5, leaf])
+    end
+  end
+
+  it "should raise exception on unknown depth field" do
+    subject.with_model :cache_depth => true do |model|
+      expect {
+        model.create!.subtree(:this_is_not_a_valid_depth_option => 42)
+      }.to raise_error(Mongoid::Ancestry::Error)
+    end
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'mongoid'
+require 'rspec'
+
+require 'mongoid-ancestry'
+
+Mongoid.configure do |config|
+  logger = Logger.new('log/test.log')
+  config.master = Mongo::Connection.new('localhost', 27017,
+    :logger => logger).db('ancestry_test')
+  config.logger = logger
+end
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.after :each do
+    Mongoid.master.collections.reject { |c| c.name =~ /^system\./ }.each(&:drop)
+  end
+end

data/spec/support/models.rb

@@ -0,0 +1,40 @@
+class MongoidAncestry
+
+  def self.with_model options = {}
+    depth         = options.delete(:depth) || 0
+    width         = options.delete(:width) || 0
+    extra_columns = options.delete(:extra_columns)
+    skip_ancestry = options.delete(:skip_ancestry)
+
+    begin
+      model = Class.new
+      (class << model; self; end).send :define_method, :model_name do; Struct.new(:human, :underscore, :i18n_key).new 'TestNode', 'test_node', 'key'; end
+      const_set 'TestNode', model
+      TestNode.send(:include, Mongoid::Document)
+      TestNode.send(:include, Mongoid::Ancestry) unless skip_ancestry
+
+      extra_columns.each do |name, type|
+        TestNode.send :field, name, :type => type.to_s.capitalize.constantize
+      end unless extra_columns.nil?
+
+      TestNode.has_ancestry options unless skip_ancestry
+
+      if depth > 0
+        yield TestNode, create_test_nodes(TestNode, depth, width)
+      else
+        yield TestNode
+      end
+    ensure
+      remove_const "TestNode"
+    end
+  end
+
+  def self.create_test_nodes model, depth, width, parent = nil
+    unless depth == 0
+      Array.new width do
+        node = model.create!(:parent => parent)
+        [node, create_test_nodes(model, depth - 1, width, node)]
+      end
+    else; []; end
+  end
+end