sequel 3.5.0 → 3.6.0

data/spec/integration/eager_loader_test.rb

@@ -75,13 +75,6 @@ describe "Eagerly loading a tree structure" do
 
   it "#descendants should get all descendants in one call" do
     nodes = Node.filter(:id=>1).eager(:descendants).all
-    sqls_should_be('SELECT * FROM nodes WHERE (id = 1)',
-      'SELECT * FROM nodes WHERE ((parent_id IN (1)) AND (id != parent_id))',
-      'SELECT * FROM nodes WHERE ((parent_id IN (2, 3)) AND (id != parent_id))',
-      'SELECT * FROM nodes WHERE ((parent_id IN (4)) AND (id != parent_id))',
-      'SELECT * FROM nodes WHERE ((parent_id IN (5)) AND (id != parent_id))',
-      'SELECT * FROM nodes WHERE ((parent_id IN (6)) AND (id != parent_id))',
-      'SELECT * FROM nodes WHERE ((parent_id IN (7)) AND (id != parent_id))')
     nodes.length.should == 1
     node = nodes.first
     node.pk.should == 1
@@ -104,17 +97,10 @@ describe "Eagerly loading a tree structure" do
     node.children.length.should == 1
     node.children.first.pk.should == 7
     node.children.first.parent.should == node
-    sqls_should_be
   end
 
   it "#ancestors should get all ancestors in one call" do
     nodes = Node.filter(:id=>[7,3]).order(:id).eager(:ancestors).all
-    sqls_should_be('SELECT * FROM nodes WHERE (id IN (7, 3)) ORDER BY id',
-      'SELECT * FROM nodes WHERE (id IN (1, 6))',
-      'SELECT * FROM nodes WHERE (id IN (5))',
-      'SELECT * FROM nodes WHERE (id IN (4))',
-      'SELECT * FROM nodes WHERE (id IN (2))',
-      'SELECT * FROM nodes WHERE (id IN (1))')
     nodes.length.should == 2
     nodes.collect{|x| x.pk}.should == [3, 7]
     nodes.first.parent.pk.should == 1
@@ -130,7 +116,6 @@ describe "Eagerly loading a tree structure" do
     node = node.parent
     node.parent.pk.should == 1
     node.parent.parent.should == nil
-    sqls_should_be
   end
 end
 
@@ -170,32 +155,19 @@ describe "Association Extensions" do
 
   it "should allow methods to be called on the dataset method" do
     Authorship.count.should == 0
-    sqls_should_be('SELECT COUNT(*) AS \'count\' FROM authorships LIMIT 1')
     authorship = @author.authorships_dataset.find_or_create_by_name('Bob')
-    sqls_should_be("SELECT * FROM authorships WHERE ((authorships.author_id = 1) AND (name = 'Bob')) LIMIT 1",
-      /INSERT INTO authorships \((author_id, name|name, author_id)\) VALUES \((1, 'Bob'|'Bob', 1)\)/,
-      "SELECT * FROM authorships WHERE (id = 1) LIMIT 1")
     Authorship.count.should == 1
     Authorship.first.should == authorship
-    sqls_should_be('SELECT COUNT(*) AS \'count\' FROM authorships LIMIT 1', "SELECT * FROM authorships LIMIT 1")
     authorship.name.should == 'Bob'
     authorship.author_id.should == @author.id
     @author.authorships_dataset.find_or_create_by_name('Bob').should == authorship
-    sqls_should_be("SELECT * FROM authorships WHERE ((authorships.author_id = 1) AND (name = 'Bob')) LIMIT 1")
     Authorship.count.should == 1
-    sqls_should_be('SELECT COUNT(*) AS \'count\' FROM authorships LIMIT 1')
     authorship2 = @author.authorships_dataset.find_or_create(:name=>'Jim')
-    sqls_should_be("SELECT * FROM authorships WHERE ((authorships.author_id = 1) AND (name = 'Jim')) LIMIT 1",
-      /INSERT INTO authorships \((author_id, name|name, author_id)\) VALUES \((1, 'Jim'|'Jim', 1)\)/,
-      "SELECT * FROM authorships WHERE (id = 2) LIMIT 1")
     Authorship.count.should == 2
-    sqls_should_be('SELECT COUNT(*) AS \'count\' FROM authorships LIMIT 1')
     Authorship.order(:name).map(:name).should == ['Bob', 'Jim']
-    sqls_should_be('SELECT * FROM authorships ORDER BY name')
     authorship2.name.should == 'Jim'
     authorship2.author_id.should == @author.id
     @author.authorships_dataset.find_or_create(:name=>'Jim').should == authorship2
-    sqls_should_be("SELECT * FROM authorships WHERE ((authorships.author_id = 1) AND (name = 'Jim')) LIMIT 1")
   end
 end
 
@@ -290,19 +262,16 @@ describe "has_many :through has_many and has_one :through belongs_to" do
 
   it "should return has_many :through has_many records for a single object" do
     invs = @firm1.invoices.sort_by{|x| x.pk}
-    sqls_should_be("SELECT invoices.id, invoices.client_id, client.id AS 'client_id_0', client.firm_id FROM invoices LEFT OUTER JOIN clients AS 'client' ON (client.id = invoices.client_id) WHERE (client.firm_id = 1)")
     invs.should == [@invoice1, @invoice2, @invoice3]
     invs[0].client.should == @client1
     invs[1].client.should == @client1
     invs[2].client.should == @client2
     invs.collect{|i| i.firm}.should == [@firm1, @firm1, @firm1]
     invs.collect{|i| i.client.firm}.should == [@firm1, @firm1, @firm1]
-    sqls_should_be
   end
 
   it "should eagerly load has_many :through has_many records for multiple objects" do
     firms = Firm.order(:id).eager(:invoices).all
-    sqls_should_be("SELECT * FROM firms ORDER BY id", "SELECT invoices.id, invoices.client_id, client.id AS 'client_id_0', client.firm_id FROM invoices LEFT OUTER JOIN clients AS 'client' ON (client.id = invoices.client_id) WHERE (client.firm_id IN (1, 2))")
     firms.should == [@firm1, @firm2]
     firm1, firm2 = firms
     invs1 = firm1.invoices.sort_by{|x| x.pk}
@@ -318,22 +287,18 @@ describe "has_many :through has_many and has_one :through belongs_to" do
     invs2.collect{|i| i.firm}.should == [@firm2, @firm2]
     invs1.collect{|i| i.client.firm}.should == [@firm1, @firm1, @firm1]
     invs2.collect{|i| i.client.firm}.should == [@firm2, @firm2]
-    sqls_should_be
   end
 
   it "should return has_one :through belongs_to records for a single object" do
     firm = @invoice1.firm
-    sqls_should_be("SELECT firms.id, clients.id AS 'clients_id', clients.firm_id FROM firms LEFT OUTER JOIN clients ON (clients.firm_id = firms.id) WHERE (clients.id = 1)")
     firm.should == @firm1
     @invoice1.client.should == @client1
     @invoice1.client.firm.should == @firm1
-    sqls_should_be
     firm.associations[:clients].should == nil
   end
 
   it "should eagerly load has_one :through belongs_to records for multiple objects" do
     invs = Invoice.order(:id).eager(:firm).all
-    sqls_should_be("SELECT * FROM invoices ORDER BY id", "SELECT firms.id, clients.id AS 'clients_id', clients.firm_id FROM firms LEFT OUTER JOIN clients ON (clients.firm_id = firms.id) WHERE (clients.id IN (1, 2, 3))")
     invs.should == [@invoice1, @invoice2, @invoice3, @invoice4, @invoice5]
     invs[0].firm.should == @firm1
     invs[0].client.should == @client1
@@ -355,7 +320,6 @@ describe "has_many :through has_many and has_one :through belongs_to" do
     invs[4].client.should == @client3
     invs[4].client.firm.should == @firm2
     invs[4].firm.associations[:clients].should == nil
-    sqls_should_be
   end
 end
 
@@ -468,22 +432,18 @@ describe "Polymorphic Associations" do
   it "should load the correct associated object for a single object" do
     @asset1.attachable.should == @post
     @asset2.attachable.should == @note
-    sqls_should_be("SELECT * FROM posts WHERE (id = 1) LIMIT 1", "SELECT * FROM notes WHERE (id = 2) LIMIT 1")
   end
 
   it "should eagerly load the correct associated object for a group of objects" do
     assets = Asset.order(:id).eager(:attachable).all
-    sqls_should_be("SELECT * FROM assets ORDER BY id", "SELECT * FROM posts WHERE (id IN (1))", "SELECT * FROM notes WHERE (id IN (2))")
     assets.should == [@asset1, @asset2]
     assets[0].attachable.should == @post
     assets[1].attachable.should == @note
-    sqls_should_be
   end
 
   it "should set items correctly" do
     @asset1.attachable = @note
     @asset2.attachable = @post
-    sqls_should_be("SELECT * FROM posts WHERE (id = 1) LIMIT 1", "SELECT * FROM notes WHERE (id = 2) LIMIT 1")
     @asset1.attachable.should == @note
     @asset1.attachable_id.should == @note.pk
     @asset1.attachable_type.should == 'Note'
@@ -494,38 +454,29 @@ describe "Polymorphic Associations" do
     @asset1.attachable.should == nil
     @asset1.attachable_id.should == nil
     @asset1.attachable_type.should == nil
-    sqls_should_be
   end
 
   it "should add items correctly" do
     @post.assets.should == [@asset1]
-    sqls_should_be("SELECT * FROM assets WHERE ((assets.attachable_id = 1) AND (attachable_type = 'Post'))")
     @post.add_asset(@asset2)
-    sqls_should_be(/UPDATE assets SET ((attachable_id = 1|attachable_type = 'Post'|id = 2)(, )?){3} WHERE \(id = 2\)/)
     @post.assets.should == [@asset1, @asset2]
     @asset2.attachable.should == @post
     @asset2.attachable_id.should == @post.pk
     @asset2.attachable_type.should == 'Post'
-    sqls_should_be
   end
 
   it "should remove items correctly" do
     @note.assets.should == [@asset2]
-    sqls_should_be("SELECT * FROM assets WHERE ((assets.attachable_id = 2) AND (attachable_type = 'Note'))")
     @note.remove_asset(@asset2)
-    sqls_should_be(/UPDATE assets SET ((attachable_id = NULL|attachable_type = NULL|id = 2)(, )?){3} WHERE \(id = 2\)/)
     @note.assets.should == []
     @asset2.attachable.should == nil
     @asset2.attachable_id.should == nil
     @asset2.attachable_type.should == nil
-    sqls_should_be
   end
 
   it "should remove all items correctly" do
     @post.remove_all_assets
     @note.remove_all_assets
-    sqls_should_be(/UPDATE assets SET attachable_(id|type) = NULL, attachable_(type|id) = NULL WHERE \(\(attachable_(id|type) = (1|'Post')\) AND \(attachable_(type|id) = ('Post'|1)\)\)/,
-      /UPDATE assets SET attachable_(id|type) = NULL, attachable_(type|id) = NULL WHERE \(\(attachable_(id|type) = (2|'Note')\) AND \(attachable_(type|id) = ('Note'|2)\)\)/)
     @asset1.reload.attachable.should == nil
     @asset2.reload.attachable.should == nil
   end
@@ -604,77 +555,61 @@ describe "many_to_one/one_to_many not referencing primary key" do
 
   it "should load all associated one_to_many objects for a single object" do
     invs = @client1.invoices
-    sqls_should_be("SELECT * FROM invoices WHERE (client_name = 'X')")
     invs.should == [@invoice1, @invoice2]
     invs[0].client.should == @client1
     invs[1].client.should == @client1
-    sqls_should_be
   end
 
   it "should load the associated many_to_one object for a single object" do
     client = @invoice1.client
-    sqls_should_be("SELECT * FROM clients WHERE (name = 'X') LIMIT 1")
     client.should == @client1
   end
 
   it "should eagerly load all associated one_to_many objects for a group of objects" do
     clients = Client.order(:id).eager(:invoices).all
-    sqls_should_be("SELECT * FROM clients ORDER BY id", "SELECT * FROM invoices WHERE (client_name IN ('X', 'Y'))")
     clients.should == [@client1, @client2]
     clients[1].invoices.should == []
     invs = clients[0].invoices.sort_by{|x| x.pk}
     invs.should == [@invoice1, @invoice2]
     invs[0].client.should == @client1
     invs[1].client.should == @client1
-    sqls_should_be
   end
 
   it "should eagerly load the associated many_to_one object for a group of objects" do
     invoices = Invoice.order(:id).eager(:client).all
-    sqls_should_be("SELECT * FROM invoices ORDER BY id", "SELECT * FROM clients WHERE (name IN ('X'))")
     invoices.should == [@invoice1, @invoice2]
     invoices[0].client.should == @client1
     invoices[1].client.should == @client1
-    sqls_should_be
   end
 
   it "should set the associated object correctly" do
     @invoice1.client = @client2
-    sqls_should_be("SELECT * FROM clients WHERE (name = 'X') LIMIT 1")
     @invoice1.client.should == @client2
     @invoice1.client_name.should == 'Y'
     @invoice1.client = nil
     @invoice1.client_name.should == nil
-    sqls_should_be
   end
 
   it "should add the associated object correctly" do
     @client2.invoices.should == []
-    sqls_should_be("SELECT * FROM invoices WHERE (client_name = 'Y')")
     @client2.add_invoice(@invoice1)
-    sqls_should_be(/UPDATE invoices SET (client_name = 'Y'|id = 1), (client_name = 'Y'|id = 1) WHERE \(id = 1\)/)
     @client2.invoices.should == [@invoice1]
     @invoice1.client_name.should == 'Y'
     @invoice1.client = nil
     @invoice1.client_name.should == nil
-    sqls_should_be
   end
 
   it "should remove the associated object correctly" do
     invs = @client1.invoices.sort_by{|x| x.pk}
-    sqls_should_be("SELECT * FROM invoices WHERE (client_name = 'X')")
     invs.should == [@invoice1, @invoice2]
     @client1.remove_invoice(@invoice1)
-    sqls_should_be(/UPDATE invoices SET (client_name = NULL|id = 1), (client_name = NULL|id = 1) WHERE \(id = 1\)/)
     @client1.invoices.should == [@invoice2]
     @invoice1.client_name.should == nil
     @invoice1.client.should == nil
-    sqls_should_be
   end
 
   it "should remove all associated objects correctly" do
     invs = @client1.remove_all_invoices
-    sqls_should_be("UPDATE invoices SET client_name = NULL WHERE (client_name = 'X')")
     @invoice1.refresh.client.should == nil
     @invoice1.client_name.should == nil
     @invoice2.refresh.client.should == nil

data/spec/integration/model_test.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe "Sequel::Model basic support" do 
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:items) do
+      primary_key :id
+      String :name
+    end
+    class ::Item < Sequel::Model(@db)
+    end
+  end
+  after do
+    @db.drop_table(:items)
+    Object.send(:remove_const, :Item)
+  end
+
+  specify ".find should return first matching item" do
+    Item.all.should == []
+    Item.find(:name=>'J').should == nil
+    Item.create(:name=>'J')
+    Item.find(:name=>'J').should == Item.load(:id=>1, :name=>'J')
+  end
+  
+  specify ".find_or_create should return first matching item, or create it if it doesn't exist" do
+    Item.all.should == []
+    Item.find_or_create(:name=>'J').should == Item.load(:id=>1, :name=>'J')
+    Item.all.should == [Item.load(:id=>1, :name=>'J')]
+    Item.find_or_create(:name=>'J').should == Item.load(:id=>1, :name=>'J')
+    Item.all.should == [Item.load(:id=>1, :name=>'J')]
+  end
+
+  specify "should not raise an error if the implied database table doesn't exist " do
+    class ::Item::Thing < Sequel::Model(@db)
+      set_dataset :items
+    end
+    Item.create(:name=>'J')
+    Item::Thing.first.should == Item::Thing.load(:id=>1, :name=>'J')
+  end
+
+  specify "should work correctly when a dataset restricts the colums it selects" do
+    class ::Item::Thing < Sequel::Model(@db[:items].select(:name))
+    end
+    Item.create(:name=>'J')
+    Item::Thing.first.should == Item::Thing.load(:name=>'J')
+  end
+
+  specify "#delete should delete items correctly" do
+    i = Item.create(:name=>'J')
+    Item.count.should == 1
+    i.delete
+    Item.count.should == 0
+  end
+
+  specify "#exists? should return whether the item is still in the database" do
+    i = Item.create(:name=>'J')
+    i.exists?.should == true
+    Item.delete
+    i.exists?.should == false
+  end
+
+  specify "#save should only update specified columns when saving" do
+    @db.create_table!(:items) do
+      primary_key :id
+      String :name
+      Integer :num
+    end
+    Item.dataset = Item.dataset
+    i = Item.create(:name=>'J', :num=>1)
+    Item.all.should == [Item.load(:id=>1, :name=>'J', :num=>1)]
+    i.set(:name=>'K', :num=>2)
+    i.save(:name)
+    Item.all.should == [Item.load(:id=>1, :name=>'K', :num=>1)]
+    i.set(:name=>'L')
+    i.save(:num)
+    Item.all.should == [Item.load(:id=>1, :name=>'K', :num=>2)]
+  end
+
+  specify ".to_hash should return a hash keyed on primary key if no argument provided" do
+    i = Item.create(:name=>'J')
+    Item.to_hash.should == {1=>Item.load(:id=>1, :name=>'J')}
+  end
+  
+  specify ".to_hash should return a hash keyed on argument if one argument provided" do
+    i = Item.create(:name=>'J')
+    Item.to_hash(:name).should == {'J'=>Item.load(:id=>1, :name=>'J')}
+  end
+  
+  specify "should be marshallable before and after saving if marshallable! is called" do
+    i = Item.new(:name=>'J')
+    s = nil
+    i2 = nil
+    i.marshallable!
+    proc{s = Marshal.dump(i)}.should_not raise_error
+    proc{i2 = Marshal.load(s)}.should_not raise_error
+    i2.should == i
+
+    i.save
+    i.marshallable!
+    proc{s = Marshal.dump(i)}.should_not raise_error
+    proc{i2 = Marshal.load(s)}.should_not raise_error
+    i2.should == i
+
+    i.save
+    i.marshallable!
+    proc{s = Marshal.dump(i)}.should_not raise_error
+    proc{i2 = Marshal.load(s)}.should_not raise_error
+    i2.should == i
+  end
+end

data/spec/integration/plugin_test.rb

@@ -137,3 +137,309 @@ describe "Class Table Inheritance Plugin" do
   end
 end
 end
+
+describe "Many Through Many Plugin" do
+  before do
+    @db = INTEGRATION_DB
+    @db.instance_variable_set(:@schemas, {})
+    @db.create_table!(:albums) do
+      primary_key :id
+      String :name
+    end
+    @db.create_table!(:artists) do
+      primary_key :id
+      String :name
+    end
+    @db.create_table!(:albums_artists) do
+      foreign_key :album_id, :albums
+      foreign_key :artist_id, :artists
+    end
+    class ::Album < Sequel::Model(@db)
+      many_to_many :artists
+    end 
+    class ::Artist < Sequel::Model(@db)
+      plugin :many_through_many
+    end 
+    
+    @artist1 = Artist.create(:name=>'1')
+    @artist2 = Artist.create(:name=>'2')
+    @artist3 = Artist.create(:name=>'3')
+    @artist4 = Artist.create(:name=>'4')
+    @album1 = Album.create(:name=>'A')
+    @album1.add_artist(@artist1)
+    @album1.add_artist(@artist2)
+    @album2 = Album.create(:name=>'B')
+    @album2.add_artist(@artist3)
+    @album2.add_artist(@artist4)
+    @album3 = Album.create(:name=>'C')
+    @album3.add_artist(@artist2)
+    @album3.add_artist(@artist3)
+    @album4 = Album.create(:name=>'D')
+    @album4.add_artist(@artist1)
+    @album4.add_artist(@artist4)
+    
+    clear_sqls
+  end
+  after do
+    @db.drop_table :albums_artists, :albums, :artists
+    [:Album, :Artist].each{|s| Object.send(:remove_const, s)}
+  end
+  
+  specify "should handle super simple case with 1 join table" do
+    Artist.many_through_many :albums, [[:albums_artists, :artist_id, :album_id]]
+    Artist[1].albums.map{|x| x.name}.sort.should == %w'A D'
+    Artist[2].albums.map{|x| x.name}.sort.should == %w'A C'
+    Artist[3].albums.map{|x| x.name}.sort.should == %w'B C'
+    Artist[4].albums.map{|x| x.name}.sort.should == %w'B D'
+    
+    Artist.filter(:id=>1).eager(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'A D'
+    Artist.filter(:id=>2).eager(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'A C'
+    Artist.filter(:id=>3).eager(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'B C'
+    Artist.filter(:id=>4).eager(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'B D'
+    
+    Artist.filter(:artists__id=>1).eager_graph(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'A D'
+    Artist.filter(:artists__id=>2).eager_graph(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'A C'
+    Artist.filter(:artists__id=>3).eager_graph(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'B C'
+    Artist.filter(:artists__id=>4).eager_graph(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'B D'
+  end
+
+  specify "should handle typical case with 3 join tables" do
+    Artist.many_through_many :related_artists, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_artists, :album_id, :artist_id]], :class=>Artist, :distinct=>true
+    Artist[1].related_artists.map{|x| x.name}.sort.should == %w'1 2 4'
+    Artist[2].related_artists.map{|x| x.name}.sort.should == %w'1 2 3'
+    Artist[3].related_artists.map{|x| x.name}.sort.should == %w'2 3 4'
+    Artist[4].related_artists.map{|x| x.name}.sort.should == %w'1 3 4'
+    
+    Artist.filter(:id=>1).eager(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 2 4'
+    Artist.filter(:id=>2).eager(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 2 3'
+    Artist.filter(:id=>3).eager(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'2 3 4'
+    Artist.filter(:id=>4).eager(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 3 4'
+    
+    Artist.filter(:artists__id=>1).eager_graph(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 2 4'
+    Artist.filter(:artists__id=>2).eager_graph(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 2 3'
+    Artist.filter(:artists__id=>3).eager_graph(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'2 3 4'
+    Artist.filter(:artists__id=>4).eager_graph(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 3 4'
+  end
+
+  specify "should handle extreme case with 5 join tables" do
+    Artist.many_through_many :related_albums, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_artists, :album_id, :artist_id], [:artists, :id, :id], [:albums_artists, :artist_id, :album_id]], :class=>Album, :distinct=>true
+    @db[:albums_artists].delete
+    @album1.add_artist(@artist1)
+    @album1.add_artist(@artist2)
+    @album2.add_artist(@artist2)
+    @album2.add_artist(@artist3)
+    @album3.add_artist(@artist1)
+    @album4.add_artist(@artist3)
+    @album4.add_artist(@artist4)
+    
+    Artist[1].related_albums.map{|x| x.name}.sort.should == %w'A B C'
+    Artist[2].related_albums.map{|x| x.name}.sort.should == %w'A B C D'
+    Artist[3].related_albums.map{|x| x.name}.sort.should == %w'A B D'
+    Artist[4].related_albums.map{|x| x.name}.sort.should == %w'B D'
+    
+    Artist.filter(:id=>1).eager(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B C'
+    Artist.filter(:id=>2).eager(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B C D'
+    Artist.filter(:id=>3).eager(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B D'
+    Artist.filter(:id=>4).eager(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'B D'
+    
+    Artist.filter(:artists__id=>1).eager_graph(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B C'
+    Artist.filter(:artists__id=>2).eager_graph(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B C D'
+    Artist.filter(:artists__id=>3).eager_graph(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B D'
+    Artist.filter(:artists__id=>4).eager_graph(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'B D'
+  end
+end
+
+describe "Lazy Attributes plugin" do 
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:items) do
+      primary_key :id
+      String :name
+      Integer :num
+    end
+    class ::Item < Sequel::Model(@db)
+      plugin :lazy_attributes, :num
+    end
+    Item.create(:name=>'J', :num=>1)
+  end
+  after do
+    @db.drop_table(:items)
+    Object.send(:remove_const, :Item)
+  end
+  
+  specify "should not include lazy attribute columns by default" do
+    Item.first.should == Item.load(:id=>1, :name=>'J')
+  end
+  
+  specify "should load lazy attribute on access" do
+    Item.first.num.should == 1
+  end
+  
+  specify "should load lazy attribute for all items returned when accessing any item if using identity map " do
+    Item.create(:name=>'K', :num=>2)
+    Item.with_identity_map do
+      a = Item.order(:name).all
+      a.should == [Item.load(:id=>1, :name=>'J'), Item.load(:id=>2, :name=>'K')]
+      a.map{|x| x[:num]}.should == [nil, nil]
+      a.first.num.should == 1
+      a.map{|x| x[:num]}.should == [1, 2]
+      a.last.num.should == 2
+    end
+  end
+end
+
+describe "Tactical Eager Loading Plugin" do
+  before do
+    @db = INTEGRATION_DB
+    @db.instance_variable_set(:@schemas, {})
+    @db.create_table!(:artists) do
+      primary_key :id
+      String :name
+    end
+    @db.create_table!(:albums) do
+      primary_key :id
+      String :name
+      foreign_key :artist_id, :artists
+    end
+    class ::Album < Sequel::Model(@db)
+      plugin :tactical_eager_loading
+      many_to_one :artist
+    end
+    class ::Artist < Sequel::Model(@db)
+      plugin :tactical_eager_loading
+      one_to_many :albums, :order=>:name
+    end 
+    
+    @artist1 = Artist.create(:name=>'1')
+    @artist2 = Artist.create(:name=>'2')
+    @artist3 = Artist.create(:name=>'3')
+    @artist4 = Artist.create(:name=>'4')
+    @album1 = Album.create(:name=>'A', :artist=>@artist1)
+    @album2 = Album.create(:name=>'B', :artist=>@artist1)
+    @album3 = Album.create(:name=>'C', :artist=>@artist2)
+    @album4 = Album.create(:name=>'D', :artist=>@artist3)
+    
+    clear_sqls
+  end
+  after do
+    @db.drop_table :albums, :artists
+    [:Album, :Artist].each{|s| Object.send(:remove_const, s)}
+  end
+
+  specify "should eagerly load associations for all items when accessing any item" do
+    a = Artist.order(:name).all
+    a.map{|x| x.associations}.should == [{}, {}, {}, {}]
+    a.first.albums.should == [@album1, @album2]
+    a.map{|x| x.associations}.should == [{:albums=>[@album1, @album2]}, {:albums=>[@album3]}, {:albums=>[@album4]}, {:albums=>[]}]
+    
+    a = Album.order(:name).all
+    a.map{|x| x.associations}.should == [{}, {}, {}, {}]
+    a.first.artist.should == @artist1
+    a.map{|x| x.associations}.should == [{:artist=>@artist1}, {:artist=>@artist1}, {:artist=>@artist2}, {:artist=>@artist3}]
+  end
+end
+
+describe "Identity Map plugin" do 
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:items) do
+      primary_key :id
+      String :name
+      Integer :num
+    end
+    class ::Item < Sequel::Model(@db)
+      plugin :identity_map
+    end
+    Item.create(:name=>'J', :num=>3)
+  end
+  after do
+    @db.drop_table(:items)
+    Object.send(:remove_const, :Item)
+  end
+
+  specify "should return the same instance if retrieved more than once" do
+    Item.with_identity_map{Item.first.object_id.should == Item.first.object_id}
+  end
+  
+  specify "should merge attributes that don't exist in the model" do
+    Item.with_identity_map do 
+      i = Item.select(:id, :name).first
+      i.values.should == {:id=>1, :name=>'J'}
+      Item.first
+      i.values.should == {:id=>1, :name=>'J', :num=>3}
+    end
+  end
+end
+
+describe "Touch plugin" do
+  before do
+    @db = INTEGRATION_DB
+    @db.instance_variable_set(:@schemas, {})
+    @db.create_table!(:artists) do
+      primary_key :id
+      String :name
+      DateTime :updated_at
+    end
+    @db.create_table!(:albums) do
+      primary_key :id
+      String :name
+      foreign_key :artist_id, :artists
+      DateTime :updated_at
+    end
+    class ::Album < Sequel::Model(@db)
+      many_to_one :artist
+      plugin :touch, :associations=>:artist
+    end
+    class ::Artist < Sequel::Model(@db)
+    end 
+    
+    @artist = Artist.create(:name=>'1')
+    @album = Album.create(:name=>'A', :artist=>@artist)
+  end
+  after do
+    @db.drop_table :albums, :artists
+    [:Album, :Artist].each{|s| Object.send(:remove_const, s)}
+  end
+
+  specify "should update the timestamp column when touching the record" do
+    @album.updated_at.should == nil
+    @album.touch
+    @album.updated_at.to_i.should be_close(Time.now.to_i, 2)
+  end
+  
+  cspecify "should update the timestamp column for associated records when the record is updated or destroyed", [:do], [:jdbc, :sqlite] do
+    @artist.updated_at.should == nil
+    @album.update(:name=>'B')
+    @artist.reload.updated_at.to_i.should be_close(Time.now.to_i, 2)
+    @artist.update(:updated_at=>nil)
+    @album.destroy
+    @artist.reload.updated_at.to_i.should be_close(Time.now.to_i, 2)
+  end
+end
+
+describe "Serialization plugin" do 
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:items) do
+      primary_key :id
+      String :stuff
+    end
+    class ::Item < Sequel::Model(@db)
+      plugin :serialization, :marshal, :stuff
+    end
+  end
+  after do
+    @db.drop_table(:items)
+    Object.send(:remove_const, :Item)
+  end
+
+  specify "should serialize and deserialize items as needed" do
+    i = Item.create(:stuff=>{:a=>1})
+    i.stuff.should == {:a=>1}
+    i.stuff = [1, 2, 3]
+    i.save
+    Item.first.stuff.should == [1, 2, 3]
+    i.update(:stuff=>Item.new)
+    Item.first.stuff.should == Item.new
+  end
+end