sequel 3.28.0 → 3.29.0

data/spec/model/hooks_spec.rb

@@ -1,55 +1,47 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Model#after_initialize" do
-  specify "should be called after initialization" do
-    $values1 = nil
-    $reached_after_initialized = false
+  specify "should be called after initialization for both new object and objects retrieved from the database" do
     
-    a = Class.new(Sequel::Model)
-    a.class_eval do
+    a = Class.new(Sequel::Model) do
+      self::Foo = []
       columns :x, :y
       def after_initialize
-        $values1 = @values.clone
-        $reached_after_initialized = true
+        model::Foo << @values.clone
       end
     end
     
     a.new(:x => 1, :y => 2)
-    $values1.should == {:x => 1, :y => 2}
-    $reached_after_initialized.should == true
+    a.call(:x => 1, :y => 3)
+    a::Foo.should == [{:x => 1, :y => 2}, {:x => 1, :y => 3}]
   end
 end
 
 describe "Model#before_create && Model#after_create" do
   before do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
+    @c = Class.new(Sequel::Model(:items)) do
       columns :x
-      no_primary_key
+      set_primary_key :x
+      unrestrict_primary_key
       
       def after_create
         MODEL_DB << "BLAH after"
       end
     end
+    MODEL_DB.reset
   end
   
   specify "should be called around new record creation" do
     @c.send(:define_method, :before_create){MODEL_DB << "BLAH before"}
     @c.create(:x => 2)
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'INSERT INTO items (x) VALUES (2)',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after', 'SELECT * FROM items WHERE (x = 2) LIMIT 1']
   end
 
   specify ".create should cancel the save and raise an error if before_create returns false and raise_on_save_failure is true" do
     @c.send(:define_method, :before_create){false}
-    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
     proc{@c.create(:x => 2)}.should raise_error(Sequel::BeforeHookFailed)
     MODEL_DB.sqls.should == []
+    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
   end
 
   specify ".create should cancel the save and return nil if before_create returns false and raise_on_save_failure is false" do
@@ -62,24 +54,20 @@ end
 
 describe "Model#before_update && Model#after_update" do
   before do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
+    @c = Class.new(Sequel::Model(:items)) do
       columns :id, :x
-      def after_update; MODEL_DB << "BLAH after" end
+      def after_update
+        MODEL_DB << "BLAH after"
+      end
     end
+    MODEL_DB.reset
   end
   
   specify "should be called around record update" do
     @c.send(:define_method, :before_update){MODEL_DB << "BLAH before"}
     m = @c.load(:id => 2233, :x=>123)
     m.save
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'UPDATE items SET x = 123 WHERE (id = 2233)',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
   end
 
   specify "#save should cancel the save and raise an error if before_update returns false and raise_on_save_failure is true" do
@@ -107,35 +95,28 @@ end
 
 describe "Model#before_save && Model#after_save" do
   before do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
+    @c = Class.new(Sequel::Model(:items)) do
       columns :x
-      def after_save; MODEL_DB << "BLAH after" end
+      def after_save
+        MODEL_DB << "BLAH after"
+      end
     end
+    MODEL_DB.reset
   end
   
   specify "should be called around record update" do
     @c.send(:define_method, :before_save){MODEL_DB << "BLAH before"}
     m = @c.load(:id => 2233, :x=>123)
     m.save
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'UPDATE items SET x = 123 WHERE (id = 2233)',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
   end
   
   specify "should be called around record creation" do
     @c.send(:define_method, :before_save){MODEL_DB << "BLAH before"}
-    @c.no_primary_key
+    @c.set_primary_key :x
+    @c.unrestrict_primary_key
     @c.create(:x => 2)
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'INSERT INTO items (x) VALUES (2)',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after', 'SELECT * FROM items WHERE (x = 2) LIMIT 1']
   end
 
   specify "#save should cancel the save and raise an error if before_save returns false and raise_on_save_failure is true" do
@@ -163,27 +144,19 @@ end
 
 describe "Model#before_destroy && Model#after_destroy" do
   before do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
-      def after_destroy; MODEL_DB << "BLAH after"; end
-      
-      def delete
-        MODEL_DB << "DELETE BLAH"
+    @c = Class.new(Sequel::Model(:items)) do
+      def after_destroy
+        MODEL_DB << "BLAH after"
       end
     end
+    MODEL_DB.reset
   end
   
   specify "should be called around record destruction" do
     @c.send(:define_method, :before_destroy){MODEL_DB << "BLAH before"}
     m = @c.load(:id => 2233)
     m.destroy
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'DELETE BLAH',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', 'DELETE FROM items WHERE (id = 2233)', 'BLAH after']
   end
 
   specify "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do
@@ -209,16 +182,15 @@ end
 
 describe "Model#before_validation && Model#after_validation" do
   before do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
-      def after_validation; MODEL_DB << "BLAH after" end
+    @c = Class.new(Sequel::Model(:items)) do
+      columns :id
+      def after_validation
+        MODEL_DB << "BLAH after"
+      end
 
       def validate
         errors.add(:id, 'not valid') unless id == 2233
       end
-      columns :id
     end
   end
   
@@ -228,7 +200,6 @@ describe "Model#before_validation && Model#after_validation" do
     m.should be_valid
     MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
 
-    MODEL_DB.sqls.clear
     m = @c.load(:id => 22)
     m.should_not be_valid
     MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
@@ -240,7 +211,6 @@ describe "Model#before_validation && Model#after_validation" do
     m.save.should == m
     MODEL_DB.sqls.should == ['BLAH before', 'BLAH after', 'UPDATE items SET x = 123 WHERE (id = 2233)']
 
-    MODEL_DB.sqls.clear
     m = @c.load(:id => 22)
     m.raise_on_save_failure = false
     m.save.should == nil
@@ -277,13 +247,10 @@ end
 
 describe "Model around filters" do
   before do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
+    @c = Class.new(Sequel::Model(:items)) do
       columns :id, :x
-      def _save_refresh(*a) end
     end
+    MODEL_DB.reset
   end
   
   specify "around_create should be called around new record creation" do
@@ -295,7 +262,7 @@ describe "Model around filters" do
       end
     end
     @c.create(:x => 2)
-    MODEL_DB.sqls.should == [ 'ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after' ]
+    MODEL_DB.sqls.should == ['ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
   specify "around_delete should be called around record destruction" do
@@ -307,7 +274,7 @@ describe "Model around filters" do
       end
     end
     @c.load(:id=>1, :x => 2).destroy
-    MODEL_DB.sqls.should == [ 'ad_before', 'DELETE FROM items WHERE (id = 1)', 'ad_after' ]
+    MODEL_DB.sqls.should == ['ad_before', 'DELETE FROM items WHERE (id = 1)', 'ad_after']
   end
   
   specify "around_update should be called around updating existing records" do
@@ -319,10 +286,10 @@ describe "Model around filters" do
       end
     end
     @c.load(:id=>1, :x => 2).save
-    MODEL_DB.sqls.should == [ 'au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after' ]
+    MODEL_DB.sqls.should == ['au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after']
   end
 
-  specify "around_update should be called around saving both new and existing records, around either after_create and after_update" do
+  specify "around_save should be called around saving both new and existing records, around either after_create and after_update" do
     @c.class_eval do
       def around_update
         MODEL_DB << 'au_before'
@@ -341,10 +308,9 @@ describe "Model around filters" do
       end
     end
     @c.create(:x => 2)
-    MODEL_DB.sqls.should == [ 'as_before', 'ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', 'as_after' ]
-    MODEL_DB.sqls.clear
+    MODEL_DB.sqls.should == ['as_before', 'ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', 'as_after', "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
     @c.load(:id=>1, :x => 2).save
-    MODEL_DB.sqls.should == [ 'as_before', 'au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after', 'as_after' ]
+    MODEL_DB.sqls.should == ['as_before', 'au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after', 'as_after']
   end
 
   specify "around_validation should be called around validating records" do
@@ -428,5 +394,120 @@ describe "Model around filters" do
     o.meta_def(:around_validation){}
     o.save.should == nil
   end
+end
+
+describe "Model#after_commit and #after_rollback" do
+  before do
+    @db = Sequel.mock(:servers=>{:test=>{}})
+    @m = Class.new(Sequel::Model(@db[:items])) do
+      attr_accessor :rb
+      def _delete
+      end
+      def after_save
+        db.execute('as')
+        raise Sequel::Rollback if rb
+      end
+      def after_commit
+        db.execute('ac')
+      end
+      def after_rollback
+        db.execute('ar')
+      end
+      def after_destroy
+        db.execute('ad')
+        raise Sequel::Rollback if rb
+      end
+      def after_destroy_commit
+        db.execute('adc')
+      end
+      def after_destroy_rollback
+        db.execute('adr')
+      end
+    end
+    @m.use_transactions = true
+    @o = @m.load({})
+    @db.sqls
+  end
+
+  specify "should call after_commit for save after the transaction commits if it commits" do
+    @o.save
+    @db.sqls.should == ['BEGIN', 'as', 'COMMIT', 'ac']
+  end
 
+  specify "should call after_rollback for save after the transaction rolls back if it rolls back" do
+    @o.rb = true
+    @o.save
+    @db.sqls.should == ['BEGIN', 'as', 'ROLLBACK', 'ar']
+  end
+
+  specify "should have after_commit respect any surrounding transactions" do
+    @db.transaction do
+      @o.save
+    end
+    @db.sqls.should == ['BEGIN', 'as', 'COMMIT', 'ac']
+  end
+
+  specify "should have after_rollback respect any surrounding transactions" do
+    @db.transaction do
+      @o.rb = true
+      @o.save
+    end
+    @db.sqls.should == ['BEGIN', 'as', 'ROLLBACK', 'ar']
+  end
+
+  specify "should have after_commit work with surrounding transactions and sharding" do
+    @db.transaction(:server=>:test) do
+      @o.save
+    end
+    @db.sqls.should == ['BEGIN -- test', 'BEGIN', 'as', 'COMMIT', 'ac', 'COMMIT -- test']
+  end
+
+  specify "should have after_rollback work with surrounding transactions and sharding" do
+    @db.transaction(:server=>:test) do
+      @o.rb = true
+      @o.save
+    end
+    @db.sqls.should == ['BEGIN -- test', 'BEGIN', 'as', 'ROLLBACK', 'ar', 'COMMIT -- test']
+  end
+
+  specify "should call after_destroy_commit for destroy after the transaction commits if it commits" do
+    @o.destroy
+    @db.sqls.should == ['BEGIN', 'ad', 'COMMIT', 'adc']
+  end
+
+  specify "should call after_destroy_rollback for destroy after the transaction rolls back if it rolls back" do
+    @o.rb = true
+    @o.destroy
+    @db.sqls.should == ['BEGIN', 'ad', 'ROLLBACK', 'adr']
+  end
+
+  specify "should have after_destroy_commit respect any surrounding transactions" do
+    @db.transaction do
+      @o.destroy
+    end
+    @db.sqls.should == ['BEGIN', 'ad', 'COMMIT', 'adc']
+  end
+
+  specify "should have after_destroy_rollback respect any surrounding transactions" do
+    @db.transaction do
+      @o.rb = true
+      @o.destroy
+    end
+    @db.sqls.should == ['BEGIN', 'ad', 'ROLLBACK', 'adr']
+  end
+
+  specify "should have after_destroy commit work with surrounding transactions and sharding" do
+    @db.transaction(:server=>:test) do
+      @o.destroy
+    end
+    @db.sqls.should == ['BEGIN -- test', 'BEGIN', 'ad', 'COMMIT', 'adc', 'COMMIT -- test']
+  end
+
+  specify "should have after_destroy_rollback work with surrounding transactions and sharding" do
+    @db.transaction(:server=>:test) do
+      @o.rb = true
+      @o.destroy
+    end
+    @db.sqls.should == ['BEGIN -- test', 'BEGIN', 'ad', 'ROLLBACK', 'adr', 'COMMIT -- test']
+  end
 end

data/spec/model/model_spec.rb

@@ -99,6 +99,13 @@ describe "Sequel::Model()" do
       end.should_not raise_error
     end
 
+    it "should work without raising an exception with an LiteralString" do
+      proc do
+        class ::Album < Sequel::Model('table'.lit); end
+        class ::Album < Sequel::Model('table'.lit); end
+      end.should_not raise_error
+    end
+
     it "should work without raising an exception with a database" do
       proc do
         class ::Album < Sequel::Model(@db); end
@@ -133,17 +140,16 @@ describe Sequel::Model do
   it "should be associated with a dataset" do
     model_a = Class.new(Sequel::Model) { set_dataset MODEL_DB[:as] }
 
-    model_a.dataset.should be_a_kind_of(MockDataset)
+    model_a.dataset.should be_a_kind_of(Sequel::Mock::Dataset)
     model_a.dataset.opts[:from].should == [:as]
 
     model_b = Class.new(Sequel::Model) { set_dataset MODEL_DB[:bs] }
 
-    model_b.dataset.should be_a_kind_of(MockDataset)
+    model_b.dataset.should be_a_kind_of(Sequel::Mock::Dataset)
     model_b.dataset.opts[:from].should == [:bs]
 
     model_a.dataset.opts[:from].should == [:as]
   end
-
 end
 
 describe Sequel::Model, "dataset & schema" do
@@ -217,7 +223,7 @@ describe Sequel::Model, "dataset & schema" do
 
   it "should raise an error on set_dataset if there is an error connecting to the database" do
     @model.meta_def(:columns){raise Sequel::DatabaseConnectionError}
-    proc{@model.set_dataset(MODEL_DB[:foo].join(:blah))}.should raise_error
+    proc{@model.set_dataset(Sequel::Database.new[:foo].join(:blah))}.should raise_error
   end
 
   it "should not raise an error if there is a problem getting the columns for a dataset" do
@@ -236,9 +242,8 @@ describe Sequel::Model, "dataset & schema" do
   end
 end
 
-describe Sequel::Model, "constructor" do
-  
-  before(:each) do
+describe Sequel::Model, "constructors" do
+  before do
     @m = Class.new(Sequel::Model)
     @m.columns :a, :b
   end
@@ -257,11 +262,38 @@ describe Sequel::Model, "constructor" do
     m.values[:a].should == 1
   end
   
+  it "should have dataset row_proc create an existing object" do
+    @m.dataset = Sequel::Dataset.new(nil)
+    o = @m.dataset.row_proc.call(:a=>1)
+    o.should be_a_kind_of(@m)
+    o.values.should == {:a=>1}
+    o.new?.should be_false
+  end
+  
+  it "should have .call create an existing object" do
+    o = @m.call(:a=>1)
+    o.should be_a_kind_of(@m)
+    o.values.should == {:a=>1}
+    o.new?.should be_false
+  end
+  
+  it "should have .load create an existing object" do
+    o = @m.load(:a=>1)
+    o.should be_a_kind_of(@m)
+    o.values.should == {:a=>1}
+    o.new?.should be_false
+  end
+  
+  it "should have .new with a second true argument create an existing object" do
+    o = @m.new({:a=>1}, true)
+    o.should be_a_kind_of(@m)
+    o.values.should == {:a=>1}
+    o.new?.should be_false
+  end
 end
 
 describe Sequel::Model, "new" do
-
-  before(:each) do
+  before do
     @m = Class.new(Sequel::Model) do
       set_dataset MODEL_DB[:items]
       columns :x, :id
@@ -281,15 +313,8 @@ describe Sequel::Model, "new" do
   end
 
   it "should use the last inserted id as primary key if not in values" do
-    d = @m.dataset
-    def d.insert(*args)
-      super
-      1234
-    end
-
-    def d.first
-      {:x => 1, :id => 1234}
-    end
+    @m.dataset._fetch = {:x => 1, :id => 1234}
+    @m.dataset.autoid = 1234
 
     o = @m.new(:x => 1)
     o.save
@@ -299,14 +324,12 @@ describe Sequel::Model, "new" do
     o.save
     o.id.should == 333
   end
-
 end
 
 describe Sequel::Model, ".subset" do
   before do
-    MODEL_DB.reset
-
     @c = Class.new(Sequel::Model(:items))
+    MODEL_DB.reset
   end
 
   specify "should create a filter on the underlying dataset" do
@@ -334,44 +357,31 @@ describe Sequel::Model, ".subset" do
 end
 
 describe Sequel::Model, ".find" do
-
-  before(:each) do
-    MODEL_DB.reset
-    
+  before do
     @c = Class.new(Sequel::Model(:items))
-    
-    $cache_dataset_row = {:name => 'sharon', :id => 1}
-    @dataset = @c.dataset
-    $sqls = []
-    @dataset.extend(Module.new {
-      def fetch_rows(sql)
-        $sqls << sql
-        yield $cache_dataset_row
-      end
-    })
+    @c.dataset._fetch = {:name => 'sharon', :id => 1}
+    MODEL_DB.reset
   end
   
   it "should return the first record matching the given filter" do
     @c.find(:name => 'sharon').should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"]
 
     @c.find(:name.like('abc%')).should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (name LIKE 'abc%') LIMIT 1"
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (name LIKE 'abc%') LIMIT 1"]
   end
   
   specify "should accept filter blocks" do
     @c.find{:id.sql_number > 1}.should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (id > 1) LIMIT 1"
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (id > 1) LIMIT 1"]
 
     @c.find {(:x.sql_number > 1) & (:y.sql_number < 2)}.should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE ((x > 1) AND (y < 2)) LIMIT 1"
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE ((x > 1) AND (y < 2)) LIMIT 1"]
   end
-
 end
 
 describe Sequel::Model, ".fetch" do
-
-  before(:each) do
+  before do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items))
   end
@@ -388,80 +398,53 @@ describe Sequel::Model, ".fetch" do
 end
 
 describe Sequel::Model, ".find_or_create" do
-
-  before(:each) do
-    MODEL_DB.reset
+  before do
     @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
+      set_primary_key :id
       columns :x
     end
+    MODEL_DB.reset
   end
 
   it "should find the record" do
-    @c.find_or_create(:x => 1)
+    @c.find_or_create(:x => 1).should == @c.load(:x=>1, :id=>1)
     MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (x = 1) LIMIT 1"]
-    
-    MODEL_DB.reset
   end
   
   it "should create the record if not found" do
-    @c.meta_def(:find) do |*args|
-      dataset.filter(*args).first
-      nil
-    end
-    
-    @c.find_or_create(:x => 1)
-    MODEL_DB.sqls.should == [
-      "SELECT * FROM items WHERE (x = 1) LIMIT 1",
-      "INSERT INTO items (x) VALUES (1)"
-    ]
+    @c.dataset._fetch = [[], {:x=>1, :id=>1}]
+    @c.dataset.autoid = 1
+    @c.find_or_create(:x => 1).should == @c.load(:x=>1, :id=>1)
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (x = 1) LIMIT 1",
+      "INSERT INTO items (x) VALUES (1)",
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
   end
 
   it "should pass the new record to be created to the block if no record is found" do
-    @c.meta_def(:find){|*|} 
-    @c.find_or_create(:x => 1){|x| x[:y] = 2}
-    ["INSERT INTO items (x, y) VALUES (1, 2)", "INSERT INTO items (y, x) VALUES (2, 1)"].should include(MODEL_DB.sqls.first)
+    @c.dataset._fetch = [[], {:x=>1, :id=>1}]
+    @c.dataset.autoid = 1
+    @c.find_or_create(:x => 1){|x| x[:y] = 2}.should == @c.load(:x=>1, :id=>1)
+    sqls = MODEL_DB.sqls
+    sqls.first.should == "SELECT * FROM items WHERE (x = 1) LIMIT 1"
+    ["INSERT INTO items (x, y) VALUES (1, 2)", "INSERT INTO items (y, x) VALUES (2, 1)"].should include(sqls[1])
+    sqls.last.should == "SELECT * FROM items WHERE (id = 1) LIMIT 1"
   end
 end
 
 describe Sequel::Model, ".all" do
-  
-  before(:each) do
-    MODEL_DB.reset
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-    end
-    
-    @c.dataset.meta_def(:all) {1234}
-  end
-  
   it "should return all records in the dataset" do
-    @c.all.should == 1234
-  end
-  
-end
-
-class DummyModelBased < Sequel::Model(:blog)
-end
-
-describe Sequel::Model, "(:tablename)" do
-
-  it "should allow reopening of descendant classes" do
-    proc do
-      eval "class DummyModelBased < Sequel::Model(:blog); end"
-    end.should_not raise_error
+    c = Class.new(Sequel::Model(:items))
+    c.all.should == [c.load(:x=>1, :id=>1)]
   end
-
 end
 
 describe Sequel::Model, "A model class without a primary key" do
-
-  before(:each) do
-    MODEL_DB.reset
+  before do
     @c = Class.new(Sequel::Model(:items)) do
       columns :x
       no_primary_key
     end
+    MODEL_DB.reset
   end
 
   it "should be able to insert records without selecting them back" do
@@ -474,8 +457,11 @@ describe Sequel::Model, "A model class without a primary key" do
   end
 
   it "should raise when deleting" do
-    o = @c.new
-    proc {o.delete}.should raise_error
+    proc{@c.load(:x=>1).delete}.should raise_error
+  end
+
+  it "should raise when updating" do
+    proc{@c.load(:x=>1).update(:x=>2)}.should raise_error
   end
 
   it "should insert a record when saving" do
@@ -484,24 +470,17 @@ describe Sequel::Model, "A model class without a primary key" do
     o.save
     MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (2)']
   end
-
 end
 
 describe Sequel::Model, "attribute accessors" do
   before do
-    MODEL_DB.reset
-    @dataset = Sequel::Dataset.new(MODEL_DB)
-    def @dataset.columns; [:x, :y]; end
-    @c = Class.new(Sequel::Model) do
-      def self.db_schema
-         set_columns(Array(@columns))
-        @db_schema = {:x=>{:type=>:integer}, :y=>{:type=>:integer}}
-      end
-      def self.set_dataset(ds, opts={}) 
-        @columns = ds.columns
-        db_schema
-      end
+    db = Sequel.mock
+    def db.schema(*)
+      [[:x, {:type=>:integer}], [:y, {:type=>:integer}]]
     end
+    @dataset = db[:items].columns(:x, :y)
+    @c = Class.new(Sequel::Model)
+    MODEL_DB.reset
   end
 
   it "should be created on set_dataset" do
@@ -533,7 +512,7 @@ describe Sequel::Model, "attribute accessors" do
   end
 
   it "should have a working typecasting setter even if the column is not selected" do
-    @c.set_dataset(@dataset.select(:y))
+    @c.set_dataset(@dataset.select(:y).columns(:y))
     o = @c.new
 
     o.x = '34'
@@ -541,7 +520,7 @@ describe Sequel::Model, "attribute accessors" do
   end
 
   it "should typecast if the new value is the same as the existing but has a different class" do
-    @c.set_dataset(@dataset.select(:y))
+    @c.set_dataset(@dataset.select(:y).columns(:y))
     o = @c.new
 
     o.x = 34
@@ -553,58 +532,51 @@ describe Sequel::Model, "attribute accessors" do
 end
 
 describe Sequel::Model, ".[]" do
-
-  before(:each) do
-    MODEL_DB.reset
-
+  before do
     @c = Class.new(Sequel::Model(:items))
-
-    $cache_dataset_row = {:name => 'sharon', :id => 1}
-    @dataset = @c.dataset
-    $sqls = []
-    @dataset.extend(Module.new {
-      def fetch_rows(sql)
-        $sqls << sql
-        yield $cache_dataset_row
-      end
-    })
+    @c.dataset._fetch = {:name => 'sharon', :id => 1}
+    MODEL_DB.reset
   end
 
   it "should return the first record for the given pk" do
-    @c[1].should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (id = 1) LIMIT 1"
-    @c[9999].should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (id = 9999) LIMIT 1"
+    @c[1].should == @c.load(:name => 'sharon', :id => 1)
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE id = 1"]
+    @c[9999].should == @c.load(:name => 'sharon', :id => 1)
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE id = 9999"]
   end
 
   it "should work correctly for custom primary key" do
     @c.set_primary_key :name
-    @c['sharon'].should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"
+    @c['sharon'].should == @c.load(:name => 'sharon', :id => 1)
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE name = 'sharon'"]
+  end
+
+  it "should return the first record for the given pk for a filtered dataset" do
+    @c.dataset = @c.dataset.filter(:active=>true)
+    @c[1].should == @c.load(:name => 'sharon', :id => 1)
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE ((active IS TRUE) AND (id = 1)) LIMIT 1"]
   end
 
   it "should work correctly for composite primary key specified as array" do
     @c.set_primary_key [:node_id, :kind]
     @c[3921, 201].should be_a_kind_of(@c)
-    $sqls.last.should =~ \
-    /^SELECT \* FROM items WHERE \((\(node_id = 3921\) AND \(kind = 201\))|(\(kind = 201\) AND \(node_id = 3921\))\) LIMIT 1$/
+    sqls = MODEL_DB.sqls
+    sqls.length.should == 1
+    sqls.first.should =~ /^SELECT \* FROM items WHERE \((\(node_id = 3921\) AND \(kind = 201\))|(\(kind = 201\) AND \(node_id = 3921\))\) LIMIT 1$/
   end
   
   it "should work correctly for composite primary key specified as separate arguments" do
     @c.set_primary_key :node_id, :kind
     @c[3921, 201].should be_a_kind_of(@c)
-    $sqls.last.should =~ \
-    /^SELECT \* FROM items WHERE \((\(node_id = 3921\) AND \(kind = 201\))|(\(kind = 201\) AND \(node_id = 3921\))\) LIMIT 1$/
+    sqls = MODEL_DB.sqls
+    sqls.length.should == 1
+    sqls.first.should =~ /^SELECT \* FROM items WHERE \((\(node_id = 3921\) AND \(kind = 201\))|(\(kind = 201\) AND \(node_id = 3921\))\) LIMIT 1$/
   end
 end
 
 describe "Model#inspect" do
-  before do
-    @o = Sequel::Model.load(:x => 333)
-  end
-  
   specify "should include the class name and the values" do
-    @o.inspect.should == '#<Sequel::Model @values={:x=>333}>'
+    Sequel::Model.load(:x => 333).inspect.should == '#<Sequel::Model @values={:x=>333}>'
   end
 end
 
@@ -613,16 +585,13 @@ describe "Model.db_schema" do
     @c = Class.new(Sequel::Model(:items)) do
       def self.columns; orig_columns; end
     end
-    @dataset = Sequel::Dataset.new(nil).from(:items)
-    @dataset.meta_def(:db){@db ||= Sequel::Database.new}
-    def @dataset.naked; self; end
-    def @dataset.columns; []; end
-    def @dataset.def_mutation_method(*names);  end
+    @db = Sequel.mock
+    @dataset = @db[:items]
   end
   
   specify "should use the database's schema_for_table and set the columns and dataset columns" do
     d = @dataset.db
-    def d.schema(table, opts = {})
+    def @db.schema(table, opts = {})
       [[:x, {:type=>:integer}], [:y, {:type=>:string}]]
     end
     @c.dataset = @dataset
@@ -632,36 +601,20 @@ describe "Model.db_schema" do
   end
 
   specify "should not restrict the schema for datasets with a :select option" do
-    ds = @dataset.select(:x, :y___z)
-    d = ds.db
-    def d.schema(table, opts = {})
+    def @c.columns; [:x, :z]; end
+    def @db.schema(table, opts = {})
       [[:x, {:type=>:integer}], [:y, {:type=>:string}]]
     end
-    def @c.columns; [:x, :z]; end
-    @c.dataset = ds
+    @c.dataset = @dataset.select(:x, :y___z)
     @c.db_schema.should == {:x=>{:type=>:integer}, :z=>{}, :y=>{:type=>:string}}
   end
 
-  specify "should not use schema if the dataset uses multiple tables or custom sql" do
-    ds = @dataset.join(:x, :id)
-    d = ds.db
-    e = false
-    d.meta_def(:schema){|table, *opts| e = true}
-    def @c.columns; [:x]; end
-    @c.dataset = ds
-    @c.db_schema.should == {:x=>{}}
-    e.should == false
-  end
-
   specify "should fallback to fetching records if schema raises an error" do
-    ds = @dataset.join(:x, :id)
-    d = ds.db
-    def d.schema(table, opts={})
-      raise StandardError
+    def @db.schema(table, opts={})
+      raise Sequel::Error
     end
-    def @c.columns; [:x]; end
-    @c.dataset = ds
-    @c.db_schema.should == {:x=>{}}
+    @c.dataset = @dataset.join(:x, :id).columns(:id, :x)
+    @c.db_schema.should == {:x=>{}, :id=>{}}
   end
   
   specify "should automatically set a singular primary key based on the schema" do