sequel 3.9.0 → 3.10.0

data/spec/extensions/schema_dumper_spec.rb

@@ -82,6 +82,8 @@ describe "Sequel::Database dump methods" do
         [[:c1, {:db_type=>'blahblah', :allow_null=>true}]]
       when :t6
         [[:c1, {:db_type=>'bigint', :primary_key=>true, :allow_null=>true}]]
+      when :t7
+        [[:c1, {:db_type=>'somedbspecifictype', :primary_key=>true, :allow_null=>false}]]
       end
     end
   end
@@ -94,6 +96,10 @@ describe "Sequel::Database dump methods" do
     @d.dump_table_schema(:t6).should == "create_table(:t6) do\n  primary_key :c1, :type=>Bignum\nend"
   end
 
+  it "should dump primary key columns with explicit :type equal to the database type when :same_db option is passed" do
+    @d.dump_table_schema(:t7, :same_db => true).should == "create_table(:t7) do\n  primary_key :c1, :type=>\"somedbspecifictype\"\nend"
+  end
+
   it "should use a composite primary_key calls if there is a composite primary key" do
     @d.dump_table_schema(:t2).should == "create_table(:t2) do\n  Integer :c1, :null=>false\n  BigDecimal :c2, :null=>false\n  \n  primary_key [:c1, :c2]\nend"
   end

data/spec/extensions/spec_helper.rb

@@ -45,6 +45,12 @@ class MockDatabase < Sequel::Database
     @sqls ||= []
     @sqls << sql
   end
+  
+  def new_sqls
+    s = sqls
+    reset
+    s
+  end
 
   def reset
     @sqls = []

data/spec/extensions/typecast_on_load_spec.rb

@@ -7,6 +7,7 @@ describe Sequel::Model, "TypecastOnLoad plugin" do
       [[:id, {}], [:y, {:type=>:boolean, :db_type=>'tinyint(1)'}], [:b, {:type=>:integer, :db_type=>'integer'}]]
     end
     @c = Class.new(Sequel::Model(@db[:items])) do
+      include(Module.new{def _refresh(ds); values[:b] = b.to_s; self; end})
       attr_accessor :bset
       def b=(x)
         self.bset = true
@@ -26,6 +27,14 @@ describe Sequel::Model, "TypecastOnLoad plugin" do
     o.bset.should == true
   end
 
+  specify "should call setter method with value when reloading the object, for all given columns" do
+    @c.plugin :typecast_on_load, :b
+    o = @c.new({:id=>1, :b=>"1", :y=>"0"}, true)
+    o.refresh
+    o.values.should == {:id=>1, :b=>1, :y=>"0"}
+    o.bset.should == true
+  end
+
   specify "should allowing setting columns separately via add_typecast_on_load_columns" do
     @c.plugin :typecast_on_load
     @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>"1", :y=>"0"}

data/spec/extensions/validation_helpers_spec.rb

@@ -377,7 +377,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
 
     @user = @c.load(:id=>1, :username => "0records", :password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE (((username = '0records') AND (password = 'anothertest')) AND (id != 1)) LIMIT 1"
+    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest') AND (id != 1)) LIMIT 1"
     @user = @c.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
     MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"
@@ -398,7 +398,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @c.new(:username => "0records", :password => "anothertest").should be_valid
     @c.load(:id=>3, :username => "0records", :password => "anothertest").should be_valid
     MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND active) LIMIT 1",
-                    "SELECT COUNT(*) AS count FROM items WHERE (((username = '0records') AND active) AND (id != 3)) LIMIT 1"]
+                    "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND active AND (id != 3)) LIMIT 1"]
   end
 
   it "should support :only_if_modified option for validates_unique, and not check uniqueness for existing records if values haven't changed" do
@@ -423,16 +423,16 @@ describe "Sequel::Plugins::ValidationHelpers" do
 
     m.username = '1'
     m.should be_valid
-    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE (((username = '1') AND (password = 'anothertest')) AND (id != 3)) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '1') AND (password = 'anothertest') AND (id != 3)) LIMIT 1"]
 
     m = @c.load(:id=>3, :username => "0records", :password => "anothertest")
     MODEL_DB.reset
     m.password = '1'
     m.should be_valid
-    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE (((username = '0records') AND (password = '1')) AND (id != 3)) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = '1') AND (id != 3)) LIMIT 1"]
     MODEL_DB.reset
     m.username = '2'
     m.should be_valid
-    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE (((username = '2') AND (password = '1')) AND (id != 3)) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '2') AND (password = '1') AND (id != 3)) LIMIT 1"]
   end
 end 

data/spec/integration/dataset_test.rb

@@ -266,6 +266,10 @@ describe "Simple Dataset operations in transactions" do
       @ds.order(:id).all.should == [{:id=>1, :number=>20}]
     end
   end
+  
+  specify "should support for_update" do
+    INTEGRATION_DB.transaction{@ds.for_update.all.should == []}
+  end
 end
 
 describe "Dataset UNION, EXCEPT, and INTERSECT" do
@@ -536,23 +540,23 @@ describe "Sequel::Dataset convenience methods" do
   end
   
   it "#group_and_count should return a grouping by count" do
-    @ds.group_and_count(:a).all.should == []
+    @ds.group_and_count(:a).order(:count).all.should == []
     @ds.insert(20, 10)
-    @ds.group_and_count(:a).all.each{|h| h[:count] = h[:count].to_i}.should == [{:a=>20, :count=>1}]
+    @ds.group_and_count(:a).order(:count).all.each{|h| h[:count] = h[:count].to_i}.should == [{:a=>20, :count=>1}]
     @ds.insert(20, 30)
-    @ds.group_and_count(:a).all.each{|h| h[:count] = h[:count].to_i}.should == [{:a=>20, :count=>2}]
+    @ds.group_and_count(:a).order(:count).all.each{|h| h[:count] = h[:count].to_i}.should == [{:a=>20, :count=>2}]
     @ds.insert(30, 30)
-    @ds.group_and_count(:a).all.each{|h| h[:count] = h[:count].to_i}.should == [{:a=>30, :count=>1}, {:a=>20, :count=>2}]
+    @ds.group_and_count(:a).order(:count).all.each{|h| h[:count] = h[:count].to_i}.should == [{:a=>30, :count=>1}, {:a=>20, :count=>2}]
   end
   
   it "#group_and_count should support column aliases" do
-    @ds.group_and_count(:a___c).all.should == []
+    @ds.group_and_count(:a___c).order(:count).all.should == []
     @ds.insert(20, 10)
-    @ds.group_and_count(:a___c).all.each{|h| h[:count] = h[:count].to_i}.should == [{:c=>20, :count=>1}]
+    @ds.group_and_count(:a___c).order(:count).all.each{|h| h[:count] = h[:count].to_i}.should == [{:c=>20, :count=>1}]
     @ds.insert(20, 30)
-    @ds.group_and_count(:a___c).all.each{|h| h[:count] = h[:count].to_i}.should == [{:c=>20, :count=>2}]
+    @ds.group_and_count(:a___c).order(:count).all.each{|h| h[:count] = h[:count].to_i}.should == [{:c=>20, :count=>2}]
     @ds.insert(30, 30)
-    @ds.group_and_count(:a___c).all.each{|h| h[:count] = h[:count].to_i}.should == [{:c=>30, :count=>1}, {:c=>20, :count=>2}]
+    @ds.group_and_count(:a___c).order(:count).all.each{|h| h[:count] = h[:count].to_i}.should == [{:c=>30, :count=>1}, {:c=>20, :count=>2}]
   end
   
   cspecify "#range should return the range between the maximum and minimum values", :sqlite do
@@ -596,7 +600,7 @@ describe "Sequel::Dataset main SQL methods" do
     @ds.filter("b < ?", 15).invert.all.should == [{:a=>20, :b=>30}]
   end
   
-  it "#and and #or should work with placeholder strings" do
+  it "#and and #or should work correctly" do
     @ds.insert(20, 30)
     @ds.filter(:a=>20).and(:b=>30).all.should == [{:a=>20, :b=>30}]
     @ds.filter(:a=>20).and(:b=>15).all.should == []

data/spec/integration/eager_loader_test.rb

@@ -624,7 +624,7 @@ describe "statistics associations" do
       String :name
     end
     class ::Project < Sequel::Model
-      many_to_one :ticket_hours, :read_only=>true, :key=>:id,
+      many_to_one :ticket_hours, :read_only=>true, :key=>:id, :class=>:Ticket,
        :dataset=>proc{Ticket.filter(:project_id=>id).select{sum(hours).as(hours)}},
        :eager_loader=>(proc do |kh, projects, a|
         projects.each{|p| p.associations[:ticket_hours] = nil}
@@ -677,3 +677,58 @@ describe "statistics associations" do
     p2.ticket_hours.to_i.should == 22
   end
 end
+
+describe "one to one associations" do
+  before do
+    INTEGRATION_DB.create_table!(:books) do
+      primary_key :id
+    end
+    class ::Book < Sequel::Model
+      one_to_one :first_page, :class=>:Page, :conditions=>{:page_number=>1}
+      one_to_one :second_page, :class=>:Page, :conditions=>{:page_number=>2}
+    end
+
+    INTEGRATION_DB.create_table!(:pages) do
+      primary_key :id
+      foreign_key :book_id, :books
+      Integer :page_number
+    end
+    class ::Page < Sequel::Model
+      many_to_one :book
+    end
+
+    @book1 = Book.create
+    @book2 = Book.create
+    @page1 = Page.create(:book=>@book1, :page_number=>1)
+    @page2 = Page.create(:book=>@book1, :page_number=>2)
+    @page3 = Page.create(:book=>@book2, :page_number=>1)
+    @page4 = Page.create(:book=>@book2, :page_number=>2)
+    clear_sqls
+  end
+
+  after do
+    INTEGRATION_DB.drop_table :pages, :books
+    Object.send(:remove_const, :Book)
+    Object.send(:remove_const, :Page)
+  end
+
+  it "should be eager loadable" do
+    bk1, bk2 = Book.filter(:books__id=>[1,2]).eager(:first_page).all
+    bk1.first_page.should == @page1
+    bk2.first_page.should == @page3
+  end
+
+  it "should be eager graphable" do
+    bk1, bk2 = Book.filter(:books__id=>[1,2]).eager_graph(:first_page).all
+    bk1.first_page.should == @page1
+    bk2.first_page.should == @page3
+  end
+
+  it "should be eager graphable two at once" do
+    bk1, bk2 = Book.filter(:books__id=>[1,2]).eager_graph(:first_page, :second_page).all
+    bk1.first_page.should == @page1
+    bk1.second_page.should == @page2
+    bk2.first_page.should == @page3
+    bk2.second_page.should == @page4
+  end
+end

data/spec/integration/model_test.rb

@@ -107,4 +107,12 @@ describe "Sequel::Model basic support" do
     proc{i2 = Marshal.load(s)}.should_not raise_error
     i2.should == i
   end
+  
+  specify "#lock! should lock records" do
+    Item.db.transaction do
+      i = Item.create(:name=>'J')
+      i.lock!
+      i.update(:name=>'K')
+    end
+  end
 end

data/spec/integration/plugin_test.rb

@@ -482,3 +482,273 @@ describe "OptimisticLocking plugin" do
     proc{p1.update(:name=>'Bob')}.should_not raise_error
   end
 end
+
+describe "Composition plugin" do 
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:events) do
+      primary_key :id
+      Integer :year
+      Integer :month
+      Integer :day
+    end
+    class ::Event < Sequel::Model(@db)
+      plugin :composition
+      composition :date, :composer=>proc{Date.new(year, month, day) if year && month && day}, :decomposer=>(proc do
+          if date
+            self.year = date.year
+            self.month = date.month
+            self.day = date.day
+          else
+            self.year, self.month, self.day = nil
+          end
+        end)
+      composition :date, :mapping=>[:year, :month, :day]
+    end
+    @e1 = Event.create(:year=>2010, :month=>2, :day=>15)
+    @e2 = Event.create({})
+  end
+  after do
+    @db.drop_table(:events)
+    Object.send(:remove_const, :Event)
+  end
+
+  specify "should return a composed object if the underlying columns have a value" do
+    @e1.date.should == Date.civil(2010, 2, 15)
+    @e2.date.should == nil
+  end
+
+  specify "should decompose the object when saving the record" do
+    @e1.date = Date.civil(2009, 1, 2)
+    @e1.save
+    @e1.year.should == 2009
+    @e1.month.should == 1
+    @e1.day.should == 2
+  end
+
+  specify "should save all columns when saving changes" do
+    @e2.date = Date.civil(2009, 10, 2)
+    @e2.save_changes
+    @e2.reload
+    @e2.year.should == 2009
+    @e2.month.should == 10
+    @e2.day.should == 2
+  end
+end
+
+if INTEGRATION_DB.dataset.supports_cte?
+  describe "RcteTree Plugin" do
+    before do
+      @db = INTEGRATION_DB
+      @db.create_table!(:nodes) do
+        primary_key :id
+        Integer :parent_id
+        String :name
+      end
+      class ::Node < Sequel::Model(@db)
+        plugin :rcte_tree, :order=>:name
+      end
+      
+      @a = Node.create(:name=>'a')
+      @b = Node.create(:name=>'b')
+      @aa = Node.create(:name=>'aa', :parent=>@a)
+      @ab = Node.create(:name=>'ab', :parent=>@a)
+      @ba = Node.create(:name=>'ba', :parent=>@b)
+      @bb = Node.create(:name=>'bb', :parent=>@b)
+      @aaa = Node.create(:name=>'aaa', :parent=>@aa)
+      @aab = Node.create(:name=>'aab', :parent=>@aa)
+      @aba = Node.create(:name=>'aba', :parent=>@ab)
+      @abb = Node.create(:name=>'abb', :parent=>@ab)
+      @aaaa = Node.create(:name=>'aaaa', :parent=>@aaa)
+      @aaab = Node.create(:name=>'aaab', :parent=>@aaa)
+      @aaaaa = Node.create(:name=>'aaaaa', :parent=>@aaaa)
+    end
+    after do
+      @db.drop_table :nodes
+      Object.send(:remove_const, :Node)
+    end
+    
+    specify "should load all standard (not-CTE) methods correctly" do
+      @a.children.should == [@aa, @ab]
+      @b.children.should == [@ba, @bb]
+      @aa.children.should == [@aaa, @aab]
+      @ab.children.should == [@aba, @abb]
+      @ba.children.should == []
+      @bb.children.should == []
+      @aaa.children.should == [@aaaa, @aaab]
+      @aab.children.should == []
+      @aba.children.should == []
+      @abb.children.should == []
+      @aaaa.children.should == [@aaaaa]
+      @aaab.children.should == []
+      @aaaaa.children.should == []
+      
+      @a.parent.should == nil
+      @b.parent.should == nil
+      @aa.parent.should == @a
+      @ab.parent.should == @a
+      @ba.parent.should == @b
+      @bb.parent.should == @b
+      @aaa.parent.should == @aa
+      @aab.parent.should == @aa
+      @aba.parent.should == @ab
+      @abb.parent.should == @ab
+      @aaaa.parent.should == @aaa
+      @aaab.parent.should == @aaa
+      @aaaaa.parent.should == @aaaa
+    end
+    
+    specify "should load all ancestors and descendants lazily for a given instance" do
+      @a.descendants.should == [@aa, @aaa, @aaaa, @aaaaa, @aaab, @aab, @ab, @aba, @abb]
+      @b.descendants.should == [@ba, @bb]
+      @aa.descendants.should == [@aaa, @aaaa, @aaaaa, @aaab, @aab]
+      @ab.descendants.should == [@aba, @abb]
+      @ba.descendants.should == []
+      @bb.descendants.should == []
+      @aaa.descendants.should == [@aaaa, @aaaaa, @aaab]
+      @aab.descendants.should == []
+      @aba.descendants.should == []
+      @abb.descendants.should == []
+      @aaaa.descendants.should == [@aaaaa]
+      @aaab.descendants.should == []
+      @aaaaa.descendants.should == []
+      
+      @a.ancestors.should == []
+      @b.ancestors.should == []
+      @aa.ancestors.should == [@a]
+      @ab.ancestors.should == [@a]
+      @ba.ancestors.should == [@b]
+      @bb.ancestors.should == [@b]
+      @aaa.ancestors.should == [@a, @aa]
+      @aab.ancestors.should == [@a, @aa]
+      @aba.ancestors.should == [@a, @ab]
+      @abb.ancestors.should == [@a, @ab]
+      @aaaa.ancestors.should == [@a, @aa, @aaa]
+      @aaab.ancestors.should == [@a, @aa, @aaa]
+      @aaaaa.ancestors.should == [@a, @aa, @aaa, @aaaa]
+    end
+    
+    specify "should eagerly load all ancestors and descendants for a dataset" do
+      nodes = Node.filter(:id=>[@a.id, @b.id, @aaa.id]).order(:name).eager(:ancestors, :descendants).all
+      nodes.should == [@a, @aaa, @b]
+      nodes[0].descendants.should == [@aa, @aaa, @aaaa, @aaaaa, @aaab, @aab, @ab, @aba, @abb]
+      nodes[1].descendants.should == [@aaaa, @aaaaa, @aaab]
+      nodes[2].descendants.should == [@ba, @bb]
+      nodes[0].ancestors.should == []
+      nodes[1].ancestors.should == [@a, @aa]
+      nodes[2].ancestors.should == []
+    end
+    
+    specify "should eagerly load descendants to a given level" do
+      nodes = Node.filter(:id=>[@a.id, @b.id, @aaa.id]).order(:name).eager(:descendants=>1).all
+      nodes.should == [@a, @aaa, @b]
+      nodes[0].descendants.should == [@aa, @ab]
+      nodes[1].descendants.should == [@aaaa, @aaab]
+      nodes[2].descendants.should == [@ba, @bb]
+      
+      nodes = Node.filter(:id=>[@a.id, @b.id, @aaa.id]).order(:name).eager(:descendants=>2).all
+      nodes.should == [@a, @aaa, @b]
+      nodes[0].descendants.should == [@aa, @aaa, @aab, @ab, @aba, @abb]
+      nodes[1].descendants.should == [@aaaa, @aaaaa, @aaab]
+      nodes[2].descendants.should == [@ba, @bb]
+    end
+    
+    specify "should populate all :children associations when eagerly loading descendants for a dataset" do
+      nodes = Node.filter(:id=>[@a.id, @b.id, @aaa.id]).order(:name).eager(:descendants).all
+      nodes[0].associations[:children].should == [@aa, @ab]
+      nodes[1].associations[:children].should == [@aaaa, @aaab]
+      nodes[2].associations[:children].should == [@ba, @bb]
+      nodes[0].associations[:children].map{|c1| c1.associations[:children]}.should == [[@aaa, @aab], [@aba, @abb]]
+      nodes[1].associations[:children].map{|c1| c1.associations[:children]}.should == [[@aaaaa], []]
+      nodes[2].associations[:children].map{|c1| c1.associations[:children]}.should == [[], []]
+      nodes[0].associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children]}}.should == [[[@aaaa, @aaab], []], [[], []]]
+      nodes[1].associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children]}}.should == [[[]], []]
+      nodes[0].associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children].map{|c3| c3.associations[:children]}}}.should == [[[[@aaaaa], []], []], [[], []]]
+      nodes[0].associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children].map{|c3| c3.associations[:children].map{|c4| c4.associations[:children]}}}}.should == [[[[[]], []], []], [[], []]]
+    end
+    
+    specify "should not populate :children associations for final level when loading descendants to a given level" do
+      nodes = Node.filter(:id=>[@a.id, @b.id, @aaa.id]).order(:name).eager(:descendants=>1).all
+      nodes[0].associations[:children].should == [@aa, @ab]
+      nodes[0].associations[:children].map{|c1| c1.associations[:children]}.should == [nil, nil]
+      nodes[1].associations[:children].should == [@aaaa, @aaab]
+      nodes[1].associations[:children].map{|c1| c1.associations[:children]}.should == [nil, nil]
+      nodes[2].associations[:children].should == [@ba, @bb]
+      nodes[2].associations[:children].map{|c1| c1.associations[:children]}.should == [nil, nil]
+      
+      nodes[0].associations[:children].map{|c1| c1.children}.should == [[@aaa, @aab], [@aba, @abb]]
+      nodes[1].associations[:children].map{|c1| c1.children}.should == [[@aaaaa], []]
+      nodes[2].associations[:children].map{|c1| c1.children}.should == [[], []]
+      
+      nodes = Node.filter(:id=>[@a.id, @b.id, @aaa.id]).order(:name).eager(:descendants=>2).all
+      nodes[0].associations[:children].should == [@aa, @ab]
+      nodes[0].associations[:children].map{|c1| c1.associations[:children]}.should == [[@aaa, @aab], [@aba, @abb]]
+      nodes[0].associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children]}}.should == [[[@aaaa, @aaab], nil], [nil, nil]]
+      nodes[0].associations[:children].map{|c1| c1.associations[:children].map{|c2| (cc2 = c2.associations[:children]) ? cc2.map{|c3| c3.associations[:children]} : nil}}.should == [[[[@aaaaa], []], nil], [nil, nil]]
+      nodes[0].associations[:children].map{|c1| c1.associations[:children].map{|c2| (cc2 = c2.associations[:children]) ? cc2.map{|c3| (cc3 = c3.associations[:children]) ? cc3.map{|c4| c4.associations[:children]} : nil} : nil}}.should == [[[[nil], []], nil], [nil, nil]]
+      
+      nodes[1].associations[:children].should == [@aaaa, @aaab]
+      nodes[1].associations[:children].map{|c1| c1.associations[:children]}.should == [[@aaaaa], []]
+      nodes[1].associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children]}}.should == [[nil], []]
+      
+      nodes[2].associations[:children].should == [@ba, @bb]
+      nodes[2].associations[:children].map{|c1| c1.associations[:children]}.should == [[], []]
+      
+      nodes[0].associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.children}}.should == [[[@aaaa, @aaab], []], [[], []]]
+      nodes[0].associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.children.map{|c3| c3.children}}}.should == [[[[@aaaaa], []], []], [[], []]]
+      nodes[0].associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.children.map{|c3| c3.children.map{|c4| c4.children}}}}.should == [[[[[]], []], []], [[], []]]
+      nodes[1].associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.children}}.should == [[[]], []]
+    end
+    
+    specify "should populate all :children associations when lazily loading descendants" do
+      @a.descendants
+      @a.associations[:children].should == [@aa, @ab]
+      @a.associations[:children].map{|c1| c1.associations[:children]}.should == [[@aaa, @aab], [@aba, @abb]]
+      @a.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children]}}.should == [[[@aaaa, @aaab], []], [[], []]]
+      @a.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children].map{|c3| c3.associations[:children]}}}.should == [[[[@aaaaa], []], []], [[], []]]
+      @a.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children].map{|c3| c3.associations[:children].map{|c4| c4.associations[:children]}}}}.should == [[[[[]], []], []], [[], []]]
+      
+      @b.descendants
+      @b.associations[:children].should == [@ba, @bb]
+      @b.associations[:children].map{|c1| c1.associations[:children]}.should == [[], []]
+      
+      @aaa.descendants
+      @aaa.associations[:children].map{|c1| c1.associations[:children]}.should == [[@aaaaa], []]
+      @aaa.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children]}}.should == [[[]], []]
+    end
+    
+    specify "should populate all :parent associations when eagerly loading ancestors for a dataset" do
+      nodes = Node.filter(:id=>[@a.id, @ba.id, @aaa.id, @aaaaa.id]).order(:name).eager(:ancestors).all
+      nodes[0].associations.fetch(:parent, 1).should == nil
+      nodes[1].associations[:parent].should == @aa
+      nodes[1].associations[:parent].associations[:parent].should == @a
+      nodes[1].associations[:parent].associations[:parent].associations.fetch(:parent, 1) == nil
+      nodes[2].associations[:parent].should == @aaaa
+      nodes[2].associations[:parent].associations[:parent].should == @aaa
+      nodes[2].associations[:parent].associations[:parent].associations[:parent].should == @aa
+      nodes[2].associations[:parent].associations[:parent].associations[:parent].associations[:parent].should == @a
+      nodes[2].associations[:parent].associations[:parent].associations[:parent].associations[:parent].associations.fetch(:parent, 1).should == nil
+      nodes[3].associations[:parent].should == @b
+      nodes[3].associations[:parent].associations.fetch(:parent, 1).should == nil
+    end
+    
+    specify "should populate all :parent associations when lazily loading ancestors" do
+      @a.reload
+      @a.ancestors
+      @a.associations[:parent].should == nil
+      
+      @ba.reload
+      @ba.ancestors
+      @ba.associations[:parent].should == @b
+      @ba.associations[:parent].associations.fetch(:parent, 1).should == nil
+      
+      @ba.reload
+      @aaaaa.ancestors
+      @aaaaa.associations[:parent].should == @aaaa
+      @aaaaa.associations[:parent].associations[:parent].should == @aaa
+      @aaaaa.associations[:parent].associations[:parent].associations[:parent].should == @aa
+      @aaaaa.associations[:parent].associations[:parent].associations[:parent].associations[:parent].should == @a
+      @aaaaa.associations[:parent].associations[:parent].associations[:parent].associations[:parent].associations.fetch(:parent, 1).should == nil
+    end
+  end
+end