sequel 1.3 → 1.4.0

data/spec/eager_loading_spec.rb

@@ -0,0 +1,260 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "eager" do
+  before(:each) do
+    MODEL_DB.reset
+    
+    class EagerAlbum < Sequel::Model(:albums)
+      def columns; [:id, :band_id]; end
+      many_to_one :band, :class=>'EagerBand', :key=>:band_id
+      one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id
+      many_to_many :genres, :class=>'EagerGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag
+    end
+
+    class EagerBand < Sequel::Model(:bands)
+      def columns; [:id]; end
+      one_to_many :albums, :class=>'EagerAlbum', :key=>:band_id, :eager=>:tracks
+      many_to_many :members, :class=>'EagerBandMember', :left_key=>:band_id, :right_key=>:member_id, :join_table=>:bm
+    end
+    
+    class EagerTrack < Sequel::Model(:tracks)
+      def columns; [:id, :album_id]; end
+      many_to_one :album, :class=>'EagerAlbum', :key=>:album_id
+    end
+    
+    class EagerGenre < Sequel::Model(:genres)
+      def columns; [:id]; end
+      many_to_many :albums, :class=>'EagerAlbum', :left_key=>:genre_id, :right_key=>:album_id, :join_table=>:ag
+    end
+    
+    class EagerBandMember < Sequel::Model(:members)
+      def columns; [:id]; end
+      many_to_many :bands, :class=>'EagerBand', :left_key=>:member_id, :right_key=>:band_id, :join_table=>:bm, :order =>:id
+    end
+    
+    EagerAlbum.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        h = {:id => 1, :band_id=> 2}
+        h.merge!(:x_foreign_key_x=>4) if sql =~ /ag\.genre_id/
+        @db << sql
+        yield h
+      end
+    })
+
+    EagerBand.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        h = {:id => 2}
+        h.merge!(:x_foreign_key_x=>5) if sql =~ /bm\.member_id/
+        @db << sql
+        yield h
+      end
+    })
+    
+    EagerTrack.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        @db << sql
+        yield({:id => 3, :album_id => 1})
+      end
+    })
+    
+    EagerGenre.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        h = {:id => 4}
+        h.merge!(:x_foreign_key_x=>1) if sql =~ /ag\.album_id/
+        @db << sql
+        yield h
+      end
+    })
+    
+    EagerBandMember.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        h = {:id => 5}
+        h.merge!(:x_foreign_key_x=>2) if sql =~ /bm\.band_id/
+        @db << sql
+        yield h
+      end
+    })
+  end
+  
+  it "should eagerly load a single many_to_one association" do
+    a = EagerAlbum.eager(:band).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM bands WHERE (id IN (2))']
+    a = a.first
+    a.band.should be_a_kind_of(EagerBand)
+    a.band.values.should == {:id => 2}
+    MODEL_DB.sqls.length.should == 2
+  end
+  
+  it "should eagerly load a single one_to_many association" do
+    a = EagerAlbum.eager(:tracks).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (album_id IN (1))']
+    a = a.first
+    a.tracks.should be_a_kind_of(Array)
+    a.tracks.size.should == 1
+    a.tracks.first.should be_a_kind_of(EagerTrack)
+    a.tracks.first.values.should == {:id => 3, :album_id=>1}
+    MODEL_DB.sqls.length.should == 2
+  end
+  
+  it "should eagerly load a single many_to_many association" do
+    a = EagerAlbum.eager(:genres).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls[0].should == 'SELECT * FROM albums'
+    ["SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) AND (ag.album_id IN (1))",
+     "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.album_id IN (1)) AND (ag.genre_id = genres.id)"
+    ].should(include(MODEL_DB.sqls[1]))
+    a = a.first
+    a.genres.should be_a_kind_of(Array)
+    a.genres.size.should == 1
+    a.genres.first.should be_a_kind_of(EagerGenre)
+    a.genres.first.values.should == {:id => 4}
+    MODEL_DB.sqls.length.should == 2
+  end
+  
+  it "should eagerly load multiple associations" do
+    a = EagerAlbum.eager(:genres, :tracks, :band).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    MODEL_DB.sqls.length.should == 4
+    MODEL_DB.sqls[0].should == 'SELECT * FROM albums'
+    MODEL_DB.sqls[1..-1].should(include('SELECT * FROM bands WHERE (id IN (2))'))
+    MODEL_DB.sqls[1..-1].should(include('SELECT * FROM tracks WHERE (album_id IN (1))'))
+    sqls = MODEL_DB.sqls[1..-1] - ['SELECT * FROM bands WHERE (id IN (2))', 'SELECT * FROM tracks WHERE (album_id IN (1))']
+    ["SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) AND (ag.album_id IN (1))",
+     "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.album_id IN (1)) AND (ag.genre_id = genres.id)"
+    ].should(include(sqls[0]))
+    a = a.first
+    a.band.should be_a_kind_of(EagerBand)
+    a.band.values.should == {:id => 2}
+    a.tracks.should be_a_kind_of(Array)
+    a.tracks.size.should == 1
+    a.tracks.first.should be_a_kind_of(EagerTrack)
+    a.tracks.first.values.should == {:id => 3, :album_id=>1}
+    a.genres.should be_a_kind_of(Array)
+    a.genres.size.should == 1
+    a.genres.first.should be_a_kind_of(EagerGenre)
+    a.genres.first.values.should == {:id => 4}
+    MODEL_DB.sqls.length.should == 4
+  end
+  
+  it "should allow cascading of eager loading for associations of associated models" do
+    a = EagerTrack.eager(:album=>{:band=>:members}).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerTrack)
+    a.first.values.should == {:id => 3, :album_id => 1}
+    MODEL_DB.sqls.length.should == 4
+    MODEL_DB.sqls[0...-1].should == ['SELECT * FROM tracks', 
+                             'SELECT * FROM albums WHERE (id IN (1))',
+                             'SELECT * FROM bands WHERE (id IN (2))']
+    ["SELECT members.*, bm.band_id AS x_foreign_key_x FROM members INNER JOIN bm ON (bm.member_id = members.id) AND (bm.band_id IN (2))",
+     "SELECT members.*, bm.band_id AS x_foreign_key_x FROM members INNER JOIN bm ON (bm.band_id IN (2)) AND (bm.member_id = members.id)"
+    ].should(include(MODEL_DB.sqls[-1]))
+    a = a.first
+    a.album.should be_a_kind_of(EagerAlbum)
+    a.album.values.should == {:id => 1, :band_id => 2}
+    a.album.band.should be_a_kind_of(EagerBand)
+    a.album.band.values.should == {:id => 2}
+    a.album.band.members.should be_a_kind_of(Array)
+    a.album.band.members.size.should == 1
+    a.album.band.members.first.should be_a_kind_of(EagerBandMember)
+    a.album.band.members.first.values.should == {:id => 5}
+    MODEL_DB.sqls.length.should == 4
+  end
+  
+  it "should cascade eagerly loading when the :eager association option is used" do
+    a = EagerBand.eager(:albums).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerBand)
+    a.first.values.should == {:id => 2}
+    MODEL_DB.sqls.should == ['SELECT * FROM bands', 
+                             'SELECT * FROM albums WHERE (band_id IN (2))',
+                             'SELECT * FROM tracks WHERE (album_id IN (1))']
+    a = a.first
+    a.albums.should be_a_kind_of(Array)
+    a.albums.size.should == 1
+    a.albums.first.should be_a_kind_of(EagerAlbum)
+    a.albums.first.values.should == {:id => 1, :band_id => 2}
+    a = a.albums.first
+    a.tracks.should be_a_kind_of(Array)
+    a.tracks.size.should == 1
+    a.tracks.first.should be_a_kind_of(EagerTrack)
+    a.tracks.first.values.should == {:id => 3, :album_id => 1}
+    MODEL_DB.sqls.length.should == 3
+  end
+  
+  it "should respect :eager when lazily loading an association" do
+    a = EagerBand.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerBand)
+    a.first.values.should == {:id => 2}
+    MODEL_DB.sqls.should == ['SELECT * FROM bands']
+    a = a.first
+    a.albums.all
+    MODEL_DB.sqls.should == ['SELECT * FROM bands', 
+                             'SELECT * FROM albums WHERE (band_id = 2)',
+                             'SELECT * FROM tracks WHERE (album_id IN (1))']
+    a.albums.should be_a_kind_of(Array)
+    a.albums.size.should == 1
+    a.albums.first.should be_a_kind_of(EagerAlbum)
+    a.albums.first.values.should == {:id => 1, :band_id => 2}
+    a = a.albums.first
+    a.tracks.should be_a_kind_of(Array)
+    a.tracks.size.should == 1
+    a.tracks.first.should be_a_kind_of(EagerTrack)
+    a.tracks.first.values.should == {:id => 3, :album_id => 1}
+    MODEL_DB.sqls.length.should == 3
+  end
+  
+  it "should respect :order when eagerly loading" do
+    a = EagerBandMember.eager(:bands).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerBandMember)
+    a.first.values.should == {:id => 5}
+    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls[0].should == 'SELECT * FROM members'
+    ['SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON (bm.band_id = bands.id) AND (bm.member_id IN (5)) ORDER BY id',
+     'SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON (bm.member_id IN (5)) AND (bm.band_id = bands.id) ORDER BY id'
+    ].should(include(MODEL_DB.sqls[1]))
+    a = a.first
+    a.bands.should be_a_kind_of(Array)
+    a.bands.size.should == 1
+    a.bands.first.should be_a_kind_of(EagerBand)
+    a.bands.first.values.should == {:id => 2}
+    MODEL_DB.sqls.length.should == 2
+  end
+  
+  it "should populate the reciprocal many_to_one association when eagerly loading the one_to_many association" do
+    a = EagerAlbum.eager(:tracks).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (album_id IN (1))']
+    a = a.first
+    a.tracks.should be_a_kind_of(Array)
+    a.tracks.size.should == 1
+    a.tracks.first.should be_a_kind_of(EagerTrack)
+    a.tracks.first.values.should == {:id => 3, :album_id=>1}
+    a.tracks.first.album.should be_a_kind_of(EagerAlbum)
+    a.tracks.first.album.should == a
+    MODEL_DB.sqls.length.should == 2
+  end
+end

data/spec/hooks_spec.rb

@@ -0,0 +1,269 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Model hooks" do
+  before do
+    MODEL_DB.reset
+
+    @hooks = [
+      :after_initialize,
+      :before_create,
+      :after_create,
+      :before_update,
+      :after_update,
+      :before_save,
+      :after_save,
+      :before_destroy,
+      :after_destroy
+    ]
+    
+    # @hooks.each {|h| Sequel::Model.class_def(h) {}}
+  end
+  
+  specify "should be definable using def <hook name>" do
+    c = Class.new(Sequel::Model) do
+      def before_save
+        "hi there"
+      end
+    end
+    
+    c.new.before_save.should == 'hi there'
+  end
+  
+  specify "should be definable using a block" do
+    $adds = []
+    c = Class.new(Sequel::Model) do
+      before_save {$adds << 'hi'}
+    end
+    
+    c.new.before_save
+    $adds.should == ['hi']
+  end
+  
+  specify "should be definable using a method name" do
+    $adds = []
+    c = Class.new(Sequel::Model) do
+      def bye; $adds << 'bye'; end
+      before_save :bye
+    end
+    
+    c.new.before_save
+    $adds.should == ['bye']
+  end
+  
+  specify "should be additive" do
+    $adds = []
+    c = Class.new(Sequel::Model) do
+      before_save {$adds << 'hyiyie'}
+      before_save {$adds << 'byiyie'}
+    end
+    
+    c.new.before_save
+    $adds.should == ['hyiyie', 'byiyie']
+  end
+  
+  specify "should be inheritable" do
+    # pending
+    
+    $adds = []
+    a = Class.new(Sequel::Model) do
+      before_save {$adds << '123'}
+    end
+    
+    b = Class.new(a) do
+      before_save {$adds << '456'}
+      before_save {$adds << '789'}
+    end
+    
+    b.new.before_save
+    $adds.should == ['123', '456', '789']
+  end
+  
+  specify "should be overridable in descendant classes" do
+    $adds = []
+    a = Class.new(Sequel::Model) do
+      before_save {$adds << '123'}
+    end
+    
+    b = Class.new(a) do
+      def before_save; $adds << '456'; end
+    end
+    
+    a.new.before_save
+    $adds.should == ['123']
+    $adds = []
+    b.new.before_save
+    $adds.should == ['456']
+  end
+  
+  specify "should stop processing if a hook returns false" do
+    $flag = true
+    $adds = []
+    
+    a = Class.new(Sequel::Model) do
+      before_save {$adds << 'blah'; $flag}
+      before_save {$adds << 'cruel'}
+    end
+    
+    a.new.before_save
+    $adds.should == ['blah', 'cruel']
+
+    # chain should not break on nil
+    $adds = []
+    $flag = nil
+    a.new.before_save
+    $adds.should == ['blah', 'cruel']
+    
+    $adds = []
+    $flag = false
+    a.new.before_save
+    $adds.should == ['blah']
+    
+    b = Class.new(a) do
+      before_save {$adds << 'mau'}
+    end
+    
+    $adds = []
+    b.new.before_save
+    $adds.should == ['blah']
+  end
+end
+
+describe "Model#after_initialize" do
+  specify "should be called after initialization" do
+    $values1 = nil
+    
+    a = Class.new(Sequel::Model) do
+      after_initialize do
+        $values1 = @values.clone
+        raise Sequel::Error if @values[:blow]
+      end
+    end
+    
+    a.new(:x => 1, :y => 2)
+    $values1.should == {:x => 1, :y => 2}
+    
+    proc {a.new(:blow => true)}.should raise_error(Sequel::Error)
+  end
+end
+
+describe "Model#before_create && Model#after_create" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      no_primary_key
+      
+      before_create {MODEL_DB << "BLAH before"}
+      after_create {MODEL_DB << "BLAH after"}
+    end
+  end
+  
+  specify "should be called around new record creation" do
+    @c.create(:x => 2)
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'INSERT INTO items (x) VALUES (2)',
+      'BLAH after'
+    ]
+  end
+end
+
+describe "Model#before_update && Model#after_update" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      before_update {MODEL_DB << "BLAH before"}
+      after_update {MODEL_DB << "BLAH after"}
+    end
+  end
+  
+  specify "should be called around record update" do
+    m = @c.load(:id => 2233)
+    m.save
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'UPDATE items SET id = 2233 WHERE (id = 2233)',
+      'BLAH after'
+    ]
+  end
+end
+
+describe "Model#before_save && Model#after_save" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      before_save {MODEL_DB << "BLAH before"}
+      after_save {MODEL_DB << "BLAH after"}
+    end
+  end
+  
+  specify "should be called around record update" do
+    m = @c.load(:id => 2233)
+    m.save
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'UPDATE items SET id = 2233 WHERE (id = 2233)',
+      'BLAH after'
+    ]
+  end
+  
+  specify "should be called around record creation" do
+    @c.no_primary_key
+    @c.create(:x => 2)
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'INSERT INTO items (x) VALUES (2)',
+      'BLAH after'
+    ]
+  end
+end
+
+describe "Model#before_destroy && Model#after_destroy" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      before_destroy {MODEL_DB << "BLAH before"}
+      after_destroy {MODEL_DB << "BLAH after"}
+      
+      def delete
+        MODEL_DB << "DELETE BLAH"
+      end
+    end
+  end
+  
+  specify "should be called around record update" do
+    m = @c.new(:id => 2233)
+    m.destroy
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'DELETE BLAH',
+      'BLAH after'
+    ]
+  end
+end
+
+describe "Model#has_hooks?" do
+  setup do
+    @c = Class.new(Sequel::Model)
+  end
+  
+  specify "should return false if no hooks are defined" do
+    @c.has_hooks?(:before_save).should be_false
+  end
+  
+  specify "should return true if hooks are defined" do
+    @c.before_save {'blah'}
+    @c.has_hooks?(:before_save).should be_true
+  end
+  
+  specify "should return true if hooks are inherited" do
+    @d = Class.new(@c)
+    @d.has_hooks?(:before_save).should be_false
+    
+    @c.before_save :blah
+    @d.has_hooks?(:before_save).should be_true
+  end
+end