sequel 0.4.4.2 → 0.4.5

data/spec/model/schema_spec.rb

@@ -0,0 +1,80 @@
+describe Sequel::Model, "table_exists?" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @model = Class.new(Sequel::Model(:items))
+  end
+
+  it "should get the table name and question the model's db if table_exists?" do
+    @model.should_receive(:table_name).and_return(:items)
+    @model.db.should_receive(:table_exists?)
+    @model.table_exists?
+  end
+
+end
+
+describe Sequel::Model, "create_table" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @model = Class.new(Sequel::Model(:items))
+  end
+
+  it "should get the create table SQL list from the db and execute it line by line" do
+    #db.create_table_sql_list(table_name, *schema.create_info).each {|s| db << s} 
+    @model.should_receive(:table_name).and_return(:items)
+    @model.schema.should_receive(:create_info)
+    @model.db.should_receive(:create_table_sql_list)
+    pending("Finish specing this")
+    @model.create_table
+  end
+
+end
+
+describe Sequel::Model, "drop_table" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @model = Class.new(Sequel::Model(:items))
+  end
+
+  it "should get the drop table SQL for the associated table and then execute the SQL." do
+    @model.should_receive(:table_name).and_return(:items)
+    @model.db.should_receive(:drop_table_sql).with(:items)
+    @model.db.should_receive(:execute).and_return(:true)
+    @model.drop_table
+  end
+
+end
+
+describe Sequel::Model, "create_table!" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @model = Class.new(Sequel::Model(:items))
+  end
+  
+  it "should drop table if it exists and then create the table" do
+    @model.should_receive(:table_exists?).and_return(true)
+    @model.should_receive(:drop_table).and_return(true)
+    @model.should_receive(:create_table).and_return(true)
+
+    @model.create_table!
+  end
+
+end
+
+describe Sequel::Model, "recreate_table" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @model = Class.new(Sequel::Model(:items))
+  end
+
+  it "should raise a depreciation warning and then call create_table!" do
+    @model.should_receive(:warn)
+    @model.should_receive(:create_table!).and_return(true)
+    @model.recreate_table
+  end
+
+end

data/spec/model/validations_spec.rb

@@ -0,0 +1,292 @@
+describe Sequel::Model, "Validations" do
+
+  before(:all) do
+    class Person < Sequel::Model(:people)
+      def columns
+        [:id,:name,:first_name,:last_name,:middle_name,:initials,:age, :terms]
+      end
+    end
+
+    class Smurf < Person
+    end
+    
+    class Cow < Sequel::Model(:cows)
+      def columns
+        [:id, :name, :got_milk]
+      end
+    end
+
+    class User < Sequel::Model(:users)
+      def columns
+        [:id, :username, :password]
+      end
+    end
+    
+    class Address < Sequel::Model(:addresses)
+      def columns
+        [:id, :zip_code]
+      end
+    end
+  end
+  
+  it "should have a hook before validating" do
+    class Person < Sequel::Model(:people)      
+      before_validation do
+        self.name = "default name"
+      end
+      validations.clear
+      validates_presence_of :name
+    end
+
+    @person = Person.new
+    @person.valid?.should be_true
+  end
+  
+  it "should include errors from other models" do
+    pending("Waiting for Wayne's amazing associations!")
+  end
+  
+  it "should validate the acceptance of a column" do
+    class Cow < Sequel::Model(:cows)      
+      validations.clear
+      validates_acceptance_of :got_milk
+    end
+    
+    @cow = Cow.new
+    @cow.valid?.should be_false
+    @cow.errors.on(:got_milk).should == "must be accepted"
+    
+    @cow.got_milk = "true"
+    @cow.valid?.should be_true
+  end
+  
+  it "should validate the confirmation of a column" do
+    class User < Sequel::Model(:users)      
+      def password_confirmation
+        "test"
+      end
+      
+      validations.clear
+      validates_confirmation_of :password
+    end
+    
+    @user = User.new
+    @user.valid?.should be_false
+    @user.errors.on(:password).should == "doesn't match confirmation"
+    
+    @user.password = "test"
+    @user.valid?.should be_true
+  end
+  
+  it "should validate each with logic" do
+    class ZipCodeService; end
+    
+    class Address < Sequel::Model(:addresses)      
+      validations.clear
+      validates_each :zip_code, :logic => lambda { errors.add(:zip_code, "is not valid") unless ZipCodeService.allows(zip_code) }
+    end
+    
+    @address = Address.new :zip_code => "48108"
+    ZipCodeService.should_receive(:allows).with("48108").and_return(false)
+    @address.valid?.should be_false
+    @address.errors.on(:zip_code).should == "is not valid"
+    
+    @address2 = Address.new :zip_code => "48104"
+    ZipCodeService.should_receive(:allows).with("48104").and_return(true)
+    @address2.valid?.should be_true
+  end
+  
+  it "should validate format of column" do
+    class Person < Sequel::Model(:people)  
+      validates_format_of :first_name, :with => /^[a-zA-Z]+$/
+    end
+
+    @person = Person.new :first_name => "Lancelot99"
+    @person.valid?.should be_false
+    @person = Person.new :first_name => "Anita"
+    @person.valid?.should be_true
+  end
+  
+  it "should allow for :with_exactly => /[a-zA-Z/, which wraps the supplied regex with ^<regex>$" do
+    pending("TODO: Add this option to Validatable#validates_format_of")
+  end
+
+  it "should validate length of column" do
+    class Person < Sequel::Model(:people)
+      validations.clear
+      validates_length_of :first_name, :maximum => 30
+      validates_length_of :last_name, :minimum => 30
+      validates_length_of :middle_name, :within => 1..5
+      validates_length_of :initials, :is => 2
+    end
+    
+    @person = Person.new(
+      :first_name => "Anamethatiswaytofreakinglongandwayoverthirtycharacters",
+      :last_name => "Alastnameunderthirtychars",
+      :initials => "LGC",
+      :middle_name => "danger"
+    )
+    
+    @person.valid?.should be_false
+    @person.errors.on(:first_name).should  == "is invalid"
+    @person.errors.on(:last_name).should   == "is invalid"
+    @person.errors.on(:initials).should    == "is invalid"
+    @person.errors.on(:middle_name).should == "is invalid"
+    
+    @person.first_name  = "Lancelot"
+    @person.last_name   = "1234567890123456789012345678901"
+    @person.initials    = "LC"
+    @person.middle_name = "Will"
+    @person.valid?.should be_true
+  end
+  
+  it "should validate numericality of column" do
+    class Person < Sequel::Model(:people)
+      validations.clear
+      validates_numericality_of :age
+    end
+    
+    @person = Person.new :age => "Twenty"
+    @person.valid?.should be_false
+    @person.errors.on(:age).should == "must be a number"
+    
+    @person.age = 20
+    @person.valid?.should be_true
+  end
+  
+  it "should validate the presence of a column" do
+    class Cow < Sequel::Model(:cows)      
+      validations.clear
+      validates_presence_of :name
+    end
+    
+    @cow = Cow.new
+    @cow.valid?.should be_false
+    @cow.errors.on(:name).should == "can't be empty"
+    @cow.errors.full_messages.first.should == "Name can't be empty"
+    
+    @cow.name = "Betsy"
+    @cow.valid?.should be_true
+  end
+  
+  it "should validate true for a column" do
+    class Person < Sequel::Model(:people)
+      validations.clear
+      validates_true_for :first_name, :logic => lambda { first_name == "Alison" }
+    end
+
+    @person = Person.new :first_name => "Nina"
+    @person.valid?.should be_false
+    @person.errors.on(:first_name).should == "is invalid"
+    
+    @person.first_name = "Alison"
+    @person.valid?.should be_true
+  end
+    
+  it "should have a validates block that calls multple validations" do
+    class Person < Sequel::Model(:people)
+      validations.clear
+      validates do
+        format_of :first_name, :with => /^[a-zA-Z]+$/
+        length_of :first_name, :maximum => 30
+      end
+    end
+
+    Person.validations.length.should eql(2)
+    
+    @person = Person.new :first_name => "Lancelot99"
+    @person.valid?.should be_false
+    
+    @person2 = Person.new :first_name => "Wayne"
+    @person2.valid?.should be_true
+  end
+
+  it "should require and include the validatable gem" do
+    Gem.loaded_specs["validatable"].should_not be_nil
+    Sequel::Model.should respond_to(:validates_format_of) # validatable gem
+    Sequel::Model.should respond_to(:validations)         # Validations module
+  end
+  
+  it "should description" do
+    Sequel::Model.should_receive(:require).with("validatable").and_raise(LoadError)
+    STDERR.should_receive(:puts)
+    load File.join(File.dirname(__FILE__), "../../lib/sequel/model/validations.rb")
+  end
+  
+  it "should allow 'longhand' validations direcly within the model." do
+    lambda {
+      class Person < Sequel::Model(:people)
+        validations.clear
+        validates_length_of :first_name, :maximum => 30
+      end
+    }.should_not raise_error
+    Person.validations.length.should eql(1)
+  end
+
+  it "should validates do should allow shorthand method for every longhand validates_* method" do
+    class Person
+      validations.clear
+      validates do
+        format_of       :first_name, :with => /^[a-zA-Z]+$/
+        length_of       :first_name, :maximum => 30
+        presence_of     :first_name
+        numericality_of :age
+        acceptance_of   :terms
+        confirmation_of :password
+        true_for        :first_name, :logic => lambda { first_name == "Alison" }
+        #validates_each :last_name, :logic => lambda { errors.add(:zip_code, "is not valid") unless ZipCodeService.allows(zip_code) }
+        #base
+      end
+      
+      # Now check to make sure that each validation exists in the model's validations.
+    end
+    pending("finish this spec for each case")
+  end
+
+  it "should define a has_validations? method which returns true if the model has validations, false otherwise" do
+    class Person < Sequel::Model(:people)
+      validations.clear
+      validates do
+        format_of :first_name, :with => /\w+/
+        length_of :first_name, :maximum => 30
+      end
+    end
+
+    class Smurf < Person
+      validations.clear
+    end
+
+    Person.should have_validations
+    Smurf.should_not have_validations
+  end
+
+end
+
+describe Sequel::Model, "validates" do
+  
+
+  before(:all) do
+    class Person < Sequel::Model(:people)
+      def columns
+        [:id,:name,:first_name,:last_name,:middle_name,:initials,:age]
+      end
+    end
+  end
+  
+  it "should runs the validations block on the model & store as :default when only a validations block is passed in" do
+    pending
+  end
+
+  it "should store the block under the name passed in when both a name and a validations block are passed in" do
+    pending
+  end
+
+  it "should return the stored validations block corresponding to the name given, if only a name is given (no block)" do
+    pending
+  end
+
+  it "should return true or false based on if validations exist on the model if no arguments are given" do
+    pending
+  end
+
+end

data/spec/model_spec.rb

@@ -1,11 +1,20 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
+require File.join(File.dirname(__FILE__), "spec_helper")
 
 Sequel::Model.db = MODEL_DB = MockDatabase.new
 
+require File.join(File.dirname(__FILE__), "model/base_spec")
+require File.join(File.dirname(__FILE__), "model/caching_spec")
+require File.join(File.dirname(__FILE__), "model/hooks_spec")
+require File.join(File.dirname(__FILE__), "model/record_spec")
+require File.join(File.dirname(__FILE__), "model/schema_spec")
+require File.join(File.dirname(__FILE__), "model/relations_spec")
+require File.join(File.dirname(__FILE__), "model/plugins_spec")
+require File.join(File.dirname(__FILE__), "model/validations_spec")
+
 describe Sequel::Model do
 
   it "should have class method aliased as model" do
-    Sequel::Model.instance_methods.should include('model')
+    Sequel::Model.instance_methods.should include("model")
 
     model_a = Class.new Sequel::Model
     model_a.new.model.should be(model_a)
@@ -13,12 +22,12 @@ 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.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.opts[:from].should == [:bs]
 
@@ -27,190 +36,30 @@ describe Sequel::Model do
 
 end
 
-describe Sequel::Model, 'w/ primary key' do
-  it "should default to ':id'" do
-    model_a = Class.new Sequel::Model
-    model_a.primary_key.should be_equal(:id)
-  end
-
-  it "should be changed through 'set_primary_key'" do
-    model_a = Class.new(Sequel::Model) { set_primary_key :a }
-    model_a.primary_key.should be_equal(:a)
-  end
-
-  it "should support multi argument composite keys" do
-    model_a = Class.new(Sequel::Model) { set_primary_key :a, :b }
-    model_a.primary_key.should be_eql([:a, :b])
-  end
-
-  it "should accept single argument composite keys" do
-    model_a = Class.new(Sequel::Model) { set_primary_key [:a, :b] }
-    model_a.primary_key.should be_eql([:a, :b])
-  end
-end
-
-describe Sequel::Model, 'w/o primary key' do
-  it "should return nil for primary key" do
-    Class.new(Sequel::Model) { no_primary_key }.primary_key.should be_nil
-  end
-
-  it "should raise a Sequel::Error on 'this'" do
-    instance = Class.new(Sequel::Model) { no_primary_key }.new
-    proc { instance.this }.should raise_error(Sequel::Error)
-  end
-end
-
-describe Sequel::Model, 'with this' do
-
-  before { @example = Class.new Sequel::Model(:examples) }
-
-  it "should return a dataset identifying the record" do
-    instance = @example.new :id => 3
-    instance.this.sql.should be_eql("SELECT * FROM examples WHERE (id = 3) LIMIT 1")
-  end
-
-  it "should support arbitary primary keys" do
-    @example.set_primary_key :a
-
-    instance = @example.new :a => 3
-    instance.this.sql.should be_eql("SELECT * FROM examples WHERE (a = 3) LIMIT 1")
-  end
-
-  it "should support composite primary keys" do
-    @example.set_primary_key :x, :y
-    instance = @example.new :x => 4, :y => 5
-
-    parts = ['SELECT * FROM examples WHERE %s LIMIT 1',
-      '(x = 4) AND (y = 5)', '(y = 5) AND (x = 4)'
-    ].map { |expr| Regexp.escape expr }
-    regexp = Regexp.new parts.first % "(?:#{parts[1]}|#{parts[2]})"
-
-    instance.this.sql.should match(regexp)
-  end
-
-end
-
-describe Sequel::Model, 'with hooks' do
-
-  before do
-    MODEL_DB.reset
-    Sequel::Model.hooks.clear
-
-    @hooks = %w{
-      before_save before_create before_update before_destroy
-      after_save after_create after_update after_destroy
-    }.select { |hook| !hook.empty? }
-  end
-
-  it "should have hooks for everything" do
-    Sequel::Model.methods.should include('hooks')
-    Sequel::Model.methods.should include(*@hooks)
-    @hooks.each do |hook|
-      Sequel::Model.hooks[hook.to_sym].should be_an_instance_of(Array)
-    end
-  end
-  it "should be inherited" do
-    pending 'soon'
-
-    @hooks.each do |hook|
-      Sequel::Model.send(hook.to_sym) { nil }
-    end
-
-    model = Class.new Sequel::Model(:models)
-    model.hooks.should == Sequel::Model.hooks
-  end
-
-  it "should run hooks" do
-    pending 'soon'
-
-    test = mock 'Test'
-    test.should_receive(:run).exactly(@hooks.length)
-
-    @hooks.each do |hook|
-      Sequel::Model.send(hook.to_sym) { test.run }
-    end
-
-    model = Class.new Sequel::Model(:models)
-    model.hooks.should == Sequel::Model.hooks
-
-    model_instance = model.new
-    @hooks.each { |hook| model_instance.run_hooks(hook) }
-  end
-  it "should run hooks around save and create" do
-    pending 'test execution'
-  end
-  it "should run hooks around save and update" do
-    pending 'test execution'
-  end
-  it "should run hooks around delete" do
-    pending 'test execution'
-  end
-
-end
-
-context "A new model instance" do
-  setup do
-    @m = Class.new(Sequel::Model) do
-      set_dataset MODEL_DB[:items]
-    end
-  end
-  
-  specify "should be marked as new?" do
-    o = @m.new
-    o.should be_new
-  end
-  
-  specify "should not be marked as new? once it is saved" do
-    o = @m.new(:x => 1)
-    o.should be_new
-    o.save
-    o.should_not be_new
-  end
-  
-  specify "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
-    
-    o = @m.new(:x => 1)
-    o.save
-    o.id.should == 1234
-    
-    o = @m.new(:x => 1, :id => 333)
-    o.save
-    o.id.should == 333
-  end
-end
+describe Sequel::Model, "dataset & schema" do
 
-describe Sequel::Model do
   before do
     @model = Class.new(Sequel::Model(:items))
   end
-  
+
   it "creates dynamic model subclass with set table name" do
     @model.table_name.should == :items
   end
-  
+
   it "defaults to primary key of id" do
     @model.primary_key.should == :id
   end
-  
+
   it "allow primary key change" do
     @model.set_primary_key :ssn
     @model.primary_key.should == :ssn
   end
-  
+
   it "allows dataset change" do
     @model.set_dataset(MODEL_DB[:foo])
     @model.table_name.should == :foo
   end
-  
+
   it "sets schema with implicit table name" do
     @model.set_schema do
       primary_key :ssn, :string
@@ -218,7 +67,7 @@ describe Sequel::Model do
     @model.primary_key.should == :ssn
     @model.table_name.should == :items
   end
-  
+
   it "sets schema with explicit table name" do
     @model.set_schema :foo do
       primary_key :id
@@ -232,889 +81,158 @@ describe Sequel::Model do
   end
 end
 
-class DummyModelBased < Sequel::Model(:blog)
-end
-
-context "Sequel::Model()" do
-  specify "should allow reopening of descendant classes" do
-    proc do
-      eval "class DummyModelBased < Sequel::Model(:blog); end"
-    end.should_not raise_error
+describe Sequel::Model, "constructor" do
+  
+  before(:each) do
+    @m = Class.new(Sequel::Model)
   end
-end
 
-context "A model class" do
-  setup do
-    MODEL_DB.reset
-    @c = Class.new(Sequel::Model(:items))
+  it "should accept a hash" do
+    m = @m.new(:a => 1, :b => 2)
+    m.values.should == {:a => 1, :b => 2}
+    m.should be_new
   end
   
-  specify "should be able to create rows in the associated table" do
-    o = @c.create(:x => 1)
-    o.class.should == @c
-    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1)',  "SELECT * FROM items WHERE (id IN ('INSERT INTO items (x) VALUES (1)')) LIMIT 1"]
+  it "should accept a block and yield itself to the block" do
+    block_called = false
+    m = @m.new {|i| block_called = true; i.should be_a_kind_of(@m); i.values[:a] = 1}
+    
+    block_called.should be_true
+    m.values[:a].should == 1
   end
   
-  specify "should be able to create rows without any values specified" do
-    o = @c.create
-    o.class.should == @c
-    MODEL_DB.sqls.should == ["INSERT INTO items DEFAULT VALUES", "SELECT * FROM items WHERE (id IN ('INSERT INTO items DEFAULT VALUES')) LIMIT 1"]
-  end
 end
 
-context "A model class without a primary key" do
-  setup do
-    MODEL_DB.reset
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
+describe Sequel::Model, "new" do
+
+  before(:each) do
+    @m = Class.new(Sequel::Model) do
+      set_dataset MODEL_DB[:items]
     end
   end
-  
-  specify "should be able to insert records without selecting them back" do
-    i = nil
-    proc {i = @c.create(:x => 1)}.should_not raise_error
-    i.class.should be(@c)
-    i.values.to_hash.should == {:x => 1}
-    
-    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1)']
-  end
-  
-  specify "should raise when deleting" do
-    o = @c.new
-    proc {o.delete}.should raise_error
+
+  it "should be marked as new?" do
+    o = @m.new
+    o.should be_new
+    o.should be_new_record
   end
 
-  specify "should insert a record when saving" do
-    o = @c.new(:x => 2)
+  it "should not be marked as new? once it is saved" do
+    o = @m.new(:x => 1)
     o.should be_new
     o.save
-    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (2)']
+    o.should_not be_new
+    o.should_not be_new_record
   end
-end
 
-context "Model#serialize" do
-  setup do
-    MODEL_DB.reset
-  end
-  
-  specify "should translate values to YAML when creating records" do
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-      serialize :abc
+  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
 
-    @c.create(:abc => 1)
-    @c.create(:abc => "hello")
-    
-    MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (abc) VALUES ('--- 1\n')", \
-      "INSERT INTO items (abc) VALUES ('--- hello\n')", \
-    ]
-  end
-  
-  specify "should support calling after the class is defined" do
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
+    def d.first
+      {:x => 1, :id => 1234}
     end
-    
-    @c.serialize :def
 
-    @c.create(:def => 1)
-    @c.create(:def => "hello")
-    
-    MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (def) VALUES ('--- 1\n')", \
-      "INSERT INTO items (def) VALUES ('--- hello\n')", \
-    ]
-  end
-  
-  specify "should support using the Marshal format" do
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-      serialize :abc, :format => :marshal
-    end
+    o = @m.new(:x => 1)
+    o.save
+    o.id.should == 1234
 
-    @c.create(:abc => 1)
-    @c.create(:abc => "hello")
-    
-    MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (abc) VALUES ('\004\bi\006')", \
-      "INSERT INTO items (abc) VALUES ('\004\b\"\nhello')", \
-    ]
+    o = @m.new(:x => 1, :id => 333)
+    o.save
+    o.id.should == 333
   end
-  
-  specify "should translate values to and from YAML using accessor methods" do
-    @c = Class.new(Sequel::Model(:items)) do
-      serialize :abc, :def
-    end
-    
-    ds = @c.dataset
-    ds.extend(Module.new {
-      attr_accessor :raw
-      
-      def fetch_rows(sql, &block)
-        block.call(@raw)
-      end
-      
-      @@sqls = nil
-      
-      def insert(*args)
-        @@sqls = insert_sql(*args)
-      end
 
-      def update(*args)
-        @@sqls = update_sql(*args)
-      end
-      
-      def sqls
-        @@sqls
-      end
-      
-      def columns
-        [:id, :abc, :def]
-      end
-    })
-      
-    ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
-    o = @c.first
-    o.id.should == 1
-    o.abc.should == 1
-    o.def.should == "hello"
-    
-    o.set(:abc => 23)
-    ds.sqls.should == "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)"
-    
-    ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
-    o = @c.create(:abc => [1, 2, 3])
-    ds.sqls.should == "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"
-  end
 end
 
-context "Model attribute accessors" do
-  setup do
+describe Sequel::Model, ".subset" do
+
+  before(:each) do
     MODEL_DB.reset
 
-    @c = Class.new(Sequel::Model(:items)) do
-      def columns
-        [:id, :x, :y]
-      end
-    end
-  end
-  
-  specify "should be created dynamically" do
-    o = @c.new
-    
-    o.should_not be_respond_to(:x)
-    o.x.should be_nil
-    o.should be_respond_to(:x)
-    
-    o.should_not be_respond_to(:x=)
-    o.x = 34
-    o.x.should == 34
-    o.should be_respond_to(:x=)
+    @c = Class.new(Sequel::Model(:items))
   end
-  
-  specify "should raise for a column that doesn't exist in the dataset" do
-    o = @c.new
-    
-    proc {o.x}.should_not raise_error
-    proc {o.xx}.should raise_error(Sequel::Error)
-    
-    proc {o.x = 3}.should_not raise_error
-    proc {o.yy = 4}.should raise_error(Sequel::Error)
 
-    proc {o.yy?}.should raise_error(NoMethodError)
-  end
-  
-  specify "should not raise for a column not in the dataset, but for which there's a value" do
-    o = @c.new
-    
-    proc {o.xx}.should raise_error(Sequel::Error)
-    proc {o.yy}.should raise_error(Sequel::Error)
+  it "should create a filter on the underlying dataset" do
+    proc {@c.new_only}.should raise_error(NoMethodError)
     
-    o.values[:xx] = 123
-    o.values[:yy] = nil
+    @c.subset(:new_only) {:age == 'new'}
     
-    proc {o.xx; o.yy}.should_not raise_error(Sequel::Error)
+    @c.new_only.sql.should == "SELECT * FROM items WHERE (age = 'new')"
+    @c.dataset.new_only.sql.should == "SELECT * FROM items WHERE (age = 'new')"
     
-    o.xx.should == 123
-    o.yy.should == nil
+    @c.subset(:pricey) {:price > 100}
     
-    proc {o.xx = 3}.should raise_error(Sequel::Error)
-  end
-end
-
-context "Model attribute setters" do
-  setup do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items)) do
-      def columns
-        [:id, :x, :y]
-      end
-    end
-  end
-  
-  specify "should mark the column value as changed" do
-    o = @c.new
-    o.changed_columns.should == []
-
-    o.x = 2
-    o.changed_columns.should == [:x]
-    
-    o.y = 3
-    o.changed_columns.should == [:x, :y]
-    
-    o.changed_columns.clear
-    
-    o[:x] = 2
-    o.changed_columns.should == [:x]
-    
-    o[:y] = 3
-    o.changed_columns.should == [:x, :y]
-  end
-end
-
-context "Model#save" do
-  setup do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items)) do
-      def columns
-        [:id, :x, :y]
-      end
-    end
-  end
-  
-  specify "should insert a record for a new model instance" do
-    o = @c.new(:x => 1)
-    o.save
-    
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
-  end
-
-  specify "should update a record for an existing model instance" do
-    o = @c.new(:id => 3, :x => 1)
-    o.save
-    
-    MODEL_DB.sqls.first.should =~ 
-      /UPDATE items SET (id = 3, x = 1|x = 1, id = 3) WHERE \(id = 3\)/
-  end
-  
-  specify "should update only the given columns if given" do
-    o = @c.new(:id => 3, :x => 1, :y => nil)
-    o.save(:y)
-    
-    MODEL_DB.sqls.first.should == "UPDATE items SET y = NULL WHERE (id = 3)"
-  end
-  
-  specify "should mark saved columns as not changed" do
-    o = @c.new(:id => 3, :x => 1, :y => nil)
-    o[:y] = 4
-    o.changed_columns.should == [:y]
-    o.save(:x)
-    o.changed_columns.should == [:y]
-    o.save(:y)
-    o.changed_columns.should == []
-  end
-end
-
-context "Model#save_changes" do
-  setup do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items)) do
-      def columns
-        [:id, :x, :y]
-      end
-    end
-  end
-  
-  specify "should do nothing if no changed columns" do
-    o = @c.new(:id => 3, :x => 1, :y => nil)
-    o.save_changes
-    
-    MODEL_DB.sqls.should be_empty
-  end
-  
-  specify "should update only changed columns" do
-    o = @c.new(:id => 3, :x => 1, :y => nil)
-    o.x = 2
-
-    o.save_changes
-    MODEL_DB.sqls.should == ["UPDATE items SET x = 2 WHERE (id = 3)"]
-    o.save_changes
-    o.save_changes
-    MODEL_DB.sqls.should == ["UPDATE items SET x = 2 WHERE (id = 3)"]
-    MODEL_DB.reset
-
-    o.y = 4
-    o.save_changes
-    MODEL_DB.sqls.should == ["UPDATE items SET y = 4 WHERE (id = 3)"]
-    o.save_changes
-    o.save_changes
-    MODEL_DB.sqls.should == ["UPDATE items SET y = 4 WHERE (id = 3)"]
-  end
-end
-
-context "Model#new?" do
-  setup do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items)) do
-    end
-  end
-  
-  specify "should be true for a new instance" do
-    n = @c.new(:x => 1)
-    n.should be_new
-  end
-  
-  specify "should be false after saving" do
-    n = @c.new(:x => 1)
-    n.save
-    n.should_not be_new
-  end
-end
-
-context "Model.after_create" do
-  setup do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items)) do
-      def columns
-        [:id, :x, :y]
-      end
-    end
-    
-    ds = @c.dataset
-    def ds.insert(*args)
-      super(*args)
-      1
-    end
-  end
-
-  specify "should be called after creation" do
-    s = []
-    
-    @c.after_create do
-      s = MODEL_DB.sqls.dup
-    end
-    
-    n = @c.create(:x => 1)
-    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
-    s.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
-  end
-  
-  specify "should allow calling save in the hook" do
-    @c.after_create do
-      values.delete(:x)
-      self.id = 2
-      save
-    end
-    
-    n = @c.create(:id => 1)
-    MODEL_DB.sqls.should == ["INSERT INTO items (id) VALUES (1)", "SELECT * FROM items WHERE (id = 1) LIMIT 1", "UPDATE items SET id = 2 WHERE (id = 1)"]
-  end
-end
-
-context "Model.subset" do
-  setup do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items))
-  end
-
-  specify "should create a filter on the underlying dataset" do
-    proc {@c.new_only}.should raise_error(NoMethodError)
-    
-    @c.subset(:new_only) {:age == 'new'}
-    
-    @c.new_only.sql.should == "SELECT * FROM items WHERE (age = 'new')"
-    @c.dataset.new_only.sql.should == "SELECT * FROM items WHERE (age = 'new')"
-    
-    @c.subset(:pricey) {:price > 100}
-    
-    @c.pricey.sql.should == "SELECT * FROM items WHERE (price > 100)"
-    @c.dataset.pricey.sql.should == "SELECT * FROM items WHERE (price > 100)"
-    
-    # check if subsets are composable
-    @c.pricey.new_only.sql.should == "SELECT * FROM items WHERE (price > 100) AND (age = 'new')"
-    @c.new_only.pricey.sql.should == "SELECT * FROM items WHERE (age = 'new') AND (price > 100)"
-  end
-end
-
-context "Model.find" do
-  setup do
-    MODEL_DB.reset
-    
-    @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
-    })
-  end
-  
-  specify "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"
-
-    @c.find {"name LIKE 'abc%'".lit}.should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE name LIKE 'abc%' LIMIT 1"
-  end
-  
-  specify "should accept filter blocks" do
-    @c.find {:id == 1}.should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (id = 1) LIMIT 1"
-
-    @c.find {:x > 1 && :y < 2}.should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE ((x > 1) AND (y < 2)) LIMIT 1"
-  end
-end
-
-context "Model.[]" do
-  setup do
-    MODEL_DB.reset
-    
-    @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
-    })
-  end
-  
-  specify "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"
-  end
-  
-  specify "should raise for boolean argument (mistaken comparison)" do
-    # This in order to prevent stuff like Model[:a == 'b']
-    proc {@c[:a == 1]}.should raise_error(Sequel::Error)
-    proc {@c[:a != 1]}.should raise_error(Sequel::Error)
-  end
-  
-  specify "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"
-  end
-  
-  specify "should work correctly for composite primary key" 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$/
-  end
-  
-  specify "should act as shortcut to find if a hash is given" do
-    @c[:id => 1].should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (id = 1) LIMIT 1"
-    
-    @c[:name => ['abc', 'def']].should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (name IN ('abc', 'def')) LIMIT 1"
-  end
-end
-
-context "Model.fetch" do
-
-  setup do
-    MODEL_DB.reset
-    @c = Class.new(Sequel::Model(:items))
-  end
-  
-  specify "should return instances of Model" do
-    @c.fetch("SELECT * FROM items").first.should be_a_kind_of(@c)
-  end
-
-  specify "should return true for .empty? and not raise an error on empty selection" do
-    rows = @c.fetch("SELECT * FROM items WHERE FALSE")
-    @c.class_def(:fetch_rows) {|sql| yield({:count => 0})}
-    proc {rows.empty?}.should_not raise_error
-  end
-end
-
-context "A cached model" do
-  setup do
-    MODEL_DB.reset
-    
-    @cache_class = Class.new(Hash) do
-      attr_accessor :ttl
-      def set(k, v, ttl); self[k] = v; @ttl = ttl; end
-      def get(k); self[k]; end
-    end
-    cache = @cache_class.new
-    @cache = cache
-    
-    @c = Class.new(Sequel::Model(:items)) do
-      set_cache cache
-      
-      def self.columns
-        [:name, :id]
-      end
-    end
-    
-    $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
-      
-      def update(values)
-        $sqls << update_sql(values)
-        $cache_dataset_row.merge!(values)
-      end
-      
-      def delete
-        $sqls << delete_sql
-      end
-    })
-  end
-  
-  specify "should set the model's cache store" do
-    @c.cache_store.should be(@cache)
-  end
-  
-  specify "should have a default ttl of 3600" do
-    @c.cache_ttl.should == 3600
-  end
-  
-  specify "should take a ttl option" do
-    @c.set_cache @cache, :ttl => 1234
-    @c.cache_ttl.should == 1234
-  end
-  
-  specify "should offer a set_cache_ttl method for setting the ttl" do
-    @c.cache_ttl.should == 3600
-    @c.set_cache_ttl 1234
-    @c.cache_ttl.should == 1234
-  end
-  
-  specify "should generate a cache key appropriate to the class" do
-    m = @c.new
-    m.values[:id] = 1
-    m.cache_key.should == "#{m.class}:1"
-    
-    # custom primary key
-    @c.set_primary_key :ttt
-    m = @c.new
-    m.values[:ttt] = 333
-    m.cache_key.should == "#{m.class}:333"
-    
-    # composite primary key
-    @c.set_primary_key [:a, :b, :c]
-    m = @c.new
-    m.values[:a] = 123
-    m.values[:c] = 456
-    m.values[:b] = 789
-    m.cache_key.should == "#{m.class}:123,789,456"
-  end
-  
-  specify "should raise error if attempting to generate cache_key and primary key value is null" do
-    m = @c.new
-    proc {m.cache_key}.should raise_error(Sequel::Error)
-    
-    m.values[:id] = 1
-    proc {m.cache_key}.should_not raise_error(Sequel::Error)
-  end
-  
-  specify "should set the cache when reading from the database" do
-    $sqls.should == []
-    @cache.should be_empty
-    
-    m = @c[1]
-    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
-    m.values.should == $cache_dataset_row
-    @cache[m.cache_key].should == m
-    
-    # read from cache
-    m2 = @c[1]
-    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
-    m2.should == m
-    m2.values.should == $cache_dataset_row
-  end
-  
-  specify "should delete the cache when writing to the database" do
-    # fill the cache
-    m = @c[1]
-    @cache[m.cache_key].should == m
-    
-    m.set(:name => 'tutu')
-    @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "UPDATE items SET name = 'tutu' WHERE (id = 1)"
-    
-    m = @c[1]
-    @cache[m.cache_key].should == m
-    m.name = 'hey'
-    m.save
-    @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
-  end
-  
-  specify "should delete the cache when deleting the record" do
-    # fill the cache
-    m = @c[1]
-    @cache[m.cache_key].should == m
-    
-    m.delete
-    @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "DELETE FROM items WHERE (id = 1)"
-  end
-  
-  specify "should support #[] as a shortcut to #find with hash" do
-    m = @c[:id => 3]
-    @cache[m.cache_key].should be_nil
-    $sqls.last.should == "SELECT * FROM items WHERE (id = 3) LIMIT 1"
-    
-    m = @c[1]
-    @cache[m.cache_key].should == m
-    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
-    
-    @c[:id => 4]
-    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
-  end
-end
-
-context "Model.one_to_one" do
-  setup do
-    MODEL_DB.reset
-    
-    @c1 = Class.new(Sequel::Model(:attributes)) do
-    end
-
-    @c2 = Class.new(Sequel::Model(:nodes)) do
-    end
-    
-    @dataset = @c2.dataset
-
-    $sqls = []
-    @dataset.extend(Module.new {
-      def fetch_rows(sql)
-        $sqls << sql
-        yield({:hey => 1})
-      end
-      
-      def update(values)
-        $sqls << update_sql(values)
-      end
-    })
-  end
-  
-  specify "should use implicit key if omitted" do
-    @c2.one_to_one :parent, :from => @c2
-    
-    d = @c2.new(:id => 1, :parent_id => 234)
-    p = d.parent
-    p.class.should == @c2
-    p.values.should == {:hey => 1}
-    
-    $sqls.should == ["SELECT * FROM nodes WHERE (id = 234) LIMIT 1"]
-  end
-  
-  specify "should use explicit key if given" do
-    @c2.one_to_one :parent, :from => @c2, :key => :blah
-    
-    d = @c2.new(:id => 1, :blah => 567)
-    p = d.parent
-    p.class.should == @c2
-    p.values.should == {:hey => 1}
-    
-    $sqls.should == ["SELECT * FROM nodes WHERE (id = 567) LIMIT 1"]
-  end
-  
-  specify "should support plain dataset in the from option" do
-    @c2.one_to_one :parent, :from => MODEL_DB[:xyz]
-
-    d = @c2.new(:id => 1, :parent_id => 789)
-    p = d.parent
-    p.class.should == Hash
-    
-    MODEL_DB.sqls.should == ["SELECT * FROM xyz WHERE (id = 789) LIMIT 1"]
-  end
-
-  specify "should support table name in the from option" do
-    @c2.one_to_one :parent, :from => :abc
-
-    d = @c2.new(:id => 1, :parent_id => 789)
-    p = d.parent
-    p.class.should == Hash
-    
-    MODEL_DB.sqls.should == ["SELECT * FROM abc WHERE (id = 789) LIMIT 1"]
-  end
-  
-  specify "should return nil if key value is nil" do
-    @c2.one_to_one :parent, :from => @c2
-    
-    d = @c2.new(:id => 1)
-    d.parent.should == nil
-  end
-  
-  specify "should define a setter method" do
-    @c2.one_to_one :parent, :from => @c2
-    
-    d = @c2.new(:id => 1)
-    d.parent = {:id => 4321}
-    d.values.should == {:id => 1, :parent_id => 4321}
-    $sqls.last.should == "UPDATE nodes SET parent_id = 4321 WHERE (id = 1)"
-    
-    d.parent = nil
-    d.values.should == {:id => 1, :parent_id => nil}
-    $sqls.last.should == "UPDATE nodes SET parent_id = NULL WHERE (id = 1)"
-    
-    e = @c2.new(:id => 6677)
-    d.parent = e
-    d.values.should == {:id => 1, :parent_id => 6677}
-    $sqls.last.should == "UPDATE nodes SET parent_id = 6677 WHERE (id = 1)"
-  end
-end
-
-context "Model.one_to_many" do
-  setup do
-    MODEL_DB.reset
-    
-    @c1 = Class.new(Sequel::Model(:attributes)) do
-    end
-
-    @c2 = Class.new(Sequel::Model(:nodes)) do
-    end
-  end
-  
-  specify "should define a getter method" do
-    @c2.one_to_many :attributes, :from => @c1, :key => :node_id
-    
-    n = @c2.new(:id => 1234)
-    a = n.attributes
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT * FROM attributes WHERE (node_id = 1234)'
-  end
-  
-  specify "should support plain dataset in the from option" do
-    @c2.one_to_many :attributes, :from => MODEL_DB[:xyz], :key => :node_id
+    @c.pricey.sql.should == "SELECT * FROM items WHERE (price > 100)"
+    @c.dataset.pricey.sql.should == "SELECT * FROM items WHERE (price > 100)"
     
-    n = @c2.new(:id => 1234)
-    a = n.attributes
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT * FROM xyz WHERE (node_id = 1234)'
+    # check if subsets are composable
+    @c.pricey.new_only.sql.should == "SELECT * FROM items WHERE (price > 100) AND (age = 'new')"
+    @c.new_only.pricey.sql.should == "SELECT * FROM items WHERE (age = 'new') AND (price > 100)"
   end
 
-  specify "should support table name in the from option" do
-    @c2.one_to_many :attributes, :from => :abc, :key => :node_id
-    
-    n = @c2.new(:id => 1234)
-    a = n.attributes
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT * FROM abc WHERE (node_id = 1234)'
-  end
 end
 
-context "Model#pk" do
-  setup do
-    @m = Class.new(Sequel::Model)
-  end
-  
-  specify "should be default return the value of the :id column" do
-    m = @m.new(:id => 111, :x => 2, :y => 3)
-    m.pk.should == 111
-  end
-
-  specify "should be return the primary key value for custom primary key" do
-    @m.set_primary_key :x
-    m = @m.new(:id => 111, :x => 2, :y => 3)
-    m.pk.should == 2
-  end
-
-  specify "should be return the primary key value for composite primary key" do
-    @m.set_primary_key [:y, :x]
-    m = @m.new(:id => 111, :x => 2, :y => 3)
-    m.pk.should == [3, 2]
-  end
-
-  specify "should raise if no primary key" do
-    @m.set_primary_key nil
-    m = @m.new(:id => 111, :x => 2, :y => 3)
-    proc {m.pk}.should raise_error(Sequel::Error)
+describe Sequel::Model, ".find" do
 
-    @m.no_primary_key
-    m = @m.new(:id => 111, :x => 2, :y => 3)
-    proc {m.pk}.should raise_error(Sequel::Error)
+  before(:each) do
+    MODEL_DB.reset
+    
+    @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
+    })
   end
-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"
 
-context "Model#pk_hash" do
-  setup do
-    @m = Class.new(Sequel::Model)
+    @c.find {"name LIKE 'abc%'".lit}.should be_a_kind_of(@c)
+    $sqls.last.should == "SELECT * FROM items WHERE name LIKE 'abc%' LIMIT 1"
   end
   
-  specify "should be default return the value of the :id column" do
-    m = @m.new(:id => 111, :x => 2, :y => 3)
-    m.pk_hash.should == {:id => 111}
-  end
+  it "should accept filter blocks" do
+    @c.find {:id == 1}.should be_a_kind_of(@c)
+    $sqls.last.should == "SELECT * FROM items WHERE (id = 1) LIMIT 1"
 
-  specify "should be return the primary key value for custom primary key" do
-    @m.set_primary_key :x
-    m = @m.new(:id => 111, :x => 2, :y => 3)
-    m.pk_hash.should == {:x => 2}
+    @c.find {:x > 1 && :y < 2}.should be_a_kind_of(@c)
+    $sqls.last.should == "SELECT * FROM items WHERE ((x > 1) AND (y < 2)) LIMIT 1"
   end
 
-  specify "should be return the primary key value for composite primary key" do
-    @m.set_primary_key [:y, :x]
-    m = @m.new(:id => 111, :x => 2, :y => 3)
-    m.pk_hash.should == {:y => 3, :x => 2}
-  end
+end
 
-  specify "should raise if no primary key" do
-    @m.set_primary_key nil
-    m = @m.new(:id => 111, :x => 2, :y => 3)
-    proc {m.pk_hash}.should raise_error(Sequel::Error)
+describe Sequel::Model, ".fetch" do
 
-    @m.no_primary_key
-    m = @m.new(:id => 111, :x => 2, :y => 3)
-    proc {m.pk_hash}.should raise_error(Sequel::Error)
+  before(:each) do
+    MODEL_DB.reset
+    @c = Class.new(Sequel::Model(:items))
   end
-end
-
-context "A Model constructor" do
-  setup do
-    @m = Class.new(Sequel::Model)
+  
+  it "should return instances of Model" do
+    @c.fetch("SELECT * FROM items").first.should be_a_kind_of(@c)
   end
 
-  specify "should accept a hash" do
-    m = @m.new(:a => 1, :b => 2)
-    m.values.should == {:a => 1, :b => 2}
-    m.should be_new
+  it "should return true for .empty? and not raise an error on empty selection" do
+    rows = @c.fetch("SELECT * FROM items WHERE FALSE")
+    @c.class_def(:fetch_rows) {|sql| yield({:count => 0})}
+    proc {rows.empty?}.should_not raise_error
   end
   
-  specify "should accept a block and yield itself to the block" do
-    block_called = false
-    m = @m.new {|i| block_called = true; i.should be_a_kind_of(@m); i.values[:a] = 1}
-    
-    block_called.should be_true
-    m.values[:a].should == 1
-  end
 end
 
-context "Model magic methods" do
-  setup do
+describe Sequel::Model, "magic methods" do
+
+  before(:each) do
     @c = Class.new(Sequel::Dataset) do
       @@sqls = []
     
@@ -1129,27 +247,27 @@ context "Model magic methods" do
     @m = Class.new(Sequel::Model(@c.new(nil).from(:items)))
   end
   
-  specify "should support order_by_xxx" do
+  it "should support order_by_xxx" do
     @m.order_by_name.should be_a_kind_of(@c)
     @m.order_by_name.sql.should == "SELECT * FROM items ORDER BY name"
   end
 
-  specify "should support group_by_xxx" do
+  it "should support group_by_xxx" do
     @m.group_by_name.should be_a_kind_of(@c)
     @m.group_by_name.sql.should == "SELECT * FROM items GROUP BY name"
   end
 
-  specify "should support count_by_xxx" do
+  it "should support count_by_xxx" do
     @m.count_by_name.should be_a_kind_of(@c)
     @m.count_by_name.sql.should == "SELECT name, count(name) AS count FROM items GROUP BY name ORDER BY count"
   end
 
-  specify "should support filter_by_xxx" do
+  it "should support filter_by_xxx" do
     @m.filter_by_name('sharon').should be_a_kind_of(@c)
     @m.filter_by_name('sharon').sql.should == "SELECT * FROM items WHERE (name = 'sharon')"
   end
   
-  specify "should support all_by_xxx" do
+  it "should support all_by_xxx" do
     all = @m.all_by_name('sharon')
     all.class.should == Array
     all.size.should == 1
@@ -1158,120 +276,43 @@ context "Model magic methods" do
     @c.sqls.should == ["SELECT * FROM items WHERE (name = 'sharon')"]
   end
   
-  specify "should support find_by_xxx" do
+  it "should support find_by_xxx" do
     @m.find_by_name('sharon').should be_a_kind_of(@m)
     @m.find_by_name('sharon').values.should == {:id => 123, :name => 'hey'}
     @c.sqls.should == ["SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"] * 2
   end
 
-  specify "should support first_by_xxx" do
+  it "should support first_by_xxx" do
     @m.first_by_name('sharon').should be_a_kind_of(@m)
     @m.first_by_name('sharon').values.should == {:id => 123, :name => 'hey'}
     @c.sqls.should == ["SELECT * FROM items ORDER BY name LIMIT 1"] * 2
   end
 
-  specify "should support last_by_xxx" do
+  it "should support last_by_xxx" do
     @m.last_by_name('sharon').should be_a_kind_of(@m)
     @m.last_by_name('sharon').values.should == {:id => 123, :name => 'hey'}
     @c.sqls.should == ["SELECT * FROM items ORDER BY name DESC LIMIT 1"] * 2
   end
-end
-
-module Sequel::Plugins
-  module Timestamped
-    def self.apply(m, opts)
-      m.class_def(:get_stamp) {@values[:stamp]}
-      m.meta_def(:stamp_opts) {opts}
-      m.before_save {@values[:stamp] = Time.now}
-    end
-    
-    module InstanceMethods
-      def abc; timestamped_opts; end
-    end
-    
-    module ClassMethods
-      def deff; timestamped_opts; end
-    end
-  end
-end
-
-context "A model using a plugin" do
-  specify "should fail if the plugin is not found" do
-    proc do
-      c = Class.new(Sequel::Model) do
-        is :something_or_other
-      end
-    end.should raise_error(LoadError)
-  end
   
-  specify "should apply the plugin to the class" do
-    c = nil
-    proc do
-      c = Class.new(Sequel::Model) do
-        is :timestamped, :a => 1, :b => 2
-      end
-    end.should_not raise_error(LoadError)
-    
-    c.should respond_to(:stamp_opts)
-    c.stamp_opts.should == {:a => 1, :b => 2}
-    
-    m = c.new
-    m.should respond_to(:get_stamp)
-    m.should respond_to(:abc)
-    m.abc.should == {:a => 1, :b => 2}
-    t = Time.now
-    m[:stamp] = t
-    m.get_stamp.should == t
-    
-    c.should respond_to(:deff)
-    c.deff.should == {:a => 1, :b => 2}
-  end
 end
 
-context "Model#create_with_params" do
-  setup do
-    MODEL_DB.reset
-    
-    @c = Class.new(Sequel::Model(:items)) do
-      def self.columns; [:x, :y]; end
-    end
-  end
-  
-  specify "should filter the given params using the model columns" do
-    @c.create_with_params(:x => 1, :z => 2)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
-
-    MODEL_DB.reset
-    @c.create_with_params(:y => 1, :abc => 2)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (y) VALUES (1)"
-  end
-  
-  specify "should be aliased by create_with" do
-    @c.create_with(:x => 1, :z => 2)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
-
-    MODEL_DB.reset
-    @c.create_with(:y => 1, :abc => 2)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (y) VALUES (1)"
-  end
-end
+describe Sequel::Model, ".find_or_create" do
 
-context "Model.find_or_create" do
-  setup do
+  before(:each) do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
       no_primary_key
     end
   end
 
-  specify "should find the record" do
+  it "should find the record" do
     @c.find_or_create(:x => 1)
     MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (x = 1) LIMIT 1"]
     
     MODEL_DB.reset
   end
   
-  specify "should create the record if not found" do
+  it "should create the record if not found" do
     @c.meta_def(:find) do |*args|
       dataset.filter(*args).first
       nil
@@ -1285,8 +326,9 @@ context "Model.find_or_create" do
   end
 end
 
-context "Model.delete_all" do
-  setup do
+describe Sequel::Model, ".delete_all" do
+
+  before(:each) do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
       no_primary_key
@@ -1295,14 +337,16 @@ context "Model.delete_all" do
     @c.dataset.meta_def(:delete) {MODEL_DB << delete_sql}
   end
 
-  specify "should delete all records in the dataset" do
+  it "should delete all records in the dataset" do
     @c.delete_all
     MODEL_DB.sqls.should == ["DELETE FROM items"]
   end
+
 end
 
-context "Model.destroy_all" do
-  setup do
+describe Sequel::Model, ".destroy_all" do
+
+  before(:each) do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
       no_primary_key
@@ -1311,28 +355,45 @@ context "Model.destroy_all" do
     @c.dataset.meta_def(:delete) {MODEL_DB << delete_sql}
   end
 
-  specify "should delete all records in the dataset" do
+  it "should delete all records in the dataset" do
     @c.destroy_all
     MODEL_DB.sqls.should == ["DELETE FROM items"]
   end
+  
+  it "should call dataset destroy method if *_destroy hooks exist" do
+    @c.dataset.stub!(:destroy).and_return(true)
+    @c.should_receive(:has_hooks?).with(:before_destroy).and_return(true)
+    @c.destroy_all
+  end
+  
+  it "should call dataset delete method if no hooks are present" do
+    @c.dataset.stub!(:delete).and_return(true)
+    @c.should_receive(:has_hooks?).with(:before_destroy).and_return(false)
+    @c.should_receive(:has_hooks?).with(:after_destroy).and_return(false)
+    @c.destroy_all
+  end
+
 end
 
-context "Model.join" do
-  setup do
-    MODEL_DB.reset
+describe Sequel::Model, ".join" do
+
+  before(:each) do
+    MODEL_DB.reset  
     @c = Class.new(Sequel::Model(:items)) do
       no_primary_key
     end
   end
   
-  specify "should format proper SQL" do
+  it "should format proper SQL" do
     @c.join(:atts, :item_id => :id).sql.should == \
       "SELECT items.* FROM items INNER JOIN atts ON (atts.item_id = items.id)"
   end
+  
 end
 
-context "Model.all" do
-  setup do
+describe Sequel::Model, ".all" do
+  
+  before(:each) do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
       no_primary_key
@@ -1341,7 +402,175 @@ context "Model.all" do
     @c.dataset.meta_def(:all) {1234}
   end
   
-  specify "should return all records in the dataset" do
+  it "should return all records in the dataset" do
     @c.all.should == 1234
   end
-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
+  end
+
+end
+
+describe Sequel::Model, ".create" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @c = Class.new(Sequel::Model(:items))
+  end
+
+  it "should be able to create rows in the associated table" do
+    o = @c.create(:x => 1)
+    o.class.should == @c
+    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1)',  "SELECT * FROM items WHERE (id IN ('INSERT INTO items (x) VALUES (1)')) LIMIT 1"]
+  end
+
+  it "should be able to create rows without any values specified" do
+    o = @c.create
+    o.class.should == @c
+    MODEL_DB.sqls.should == ["INSERT INTO items DEFAULT VALUES", "SELECT * FROM items WHERE (id IN ('INSERT INTO items DEFAULT VALUES')) LIMIT 1"]
+  end
+
+end
+
+describe Sequel::Model, "A model class without a primary key" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @c = Class.new(Sequel::Model(:items)) do
+      no_primary_key
+    end
+  end
+
+  it "should be able to insert records without selecting them back" do
+    i = nil
+    proc {i = @c.create(:x => 1)}.should_not raise_error
+    i.class.should be(@c)
+    i.values.to_hash.should == {:x => 1}
+
+    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1)']
+  end
+
+  it "should raise when deleting" do
+    o = @c.new
+    proc {o.delete}.should raise_error
+  end
+
+  it "should insert a record when saving" do
+    o = @c.new(:x => 2)
+    o.should be_new
+    o.save
+    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (2)']
+  end
+
+end
+
+describe Sequel::Model, "attribute accessors" do
+
+  before(:each) do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      def columns
+        [:id, :x, :y]
+      end
+    end
+  end
+
+  it "should be created dynamically" do
+    o = @c.new
+
+    o.should_not be_respond_to(:x)
+    o.x.should be_nil
+    o.should be_respond_to(:x)
+
+    o.should_not be_respond_to(:x=)
+    o.x = 34
+    o.x.should == 34
+    o.should be_respond_to(:x=)
+  end
+
+  it "should raise for a column that doesn't exist in the dataset" do
+    o = @c.new
+
+    proc {o.x}.should_not raise_error
+    proc {o.xx}.should raise_error(Sequel::Error)
+
+    proc {o.x = 3}.should_not raise_error
+    proc {o.yy = 4}.should raise_error(Sequel::Error)
+
+    proc {o.yy?}.should raise_error(NoMethodError)
+  end
+
+  it "should not raise for a column not in the dataset, but for which there's a value" do
+    o = @c.new
+
+    proc {o.xx}.should raise_error(Sequel::Error)
+    proc {o.yy}.should raise_error(Sequel::Error)
+
+    o.values[:xx] = 123
+    o.values[:yy] = nil
+
+    proc {o.xx; o.yy}.should_not raise_error(Sequel::Error)
+
+    o.xx.should == 123
+    o.yy.should == nil
+
+    proc {o.xx = 3}.should raise_error(Sequel::Error)
+  end
+
+end
+
+describe Sequel::Model, ".[]" do
+
+  before(:each) do
+    MODEL_DB.reset
+
+    @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
+    })
+  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"
+  end
+
+  it "should raise for boolean argument (mistaken comparison)" do
+    # This in order to prevent stuff like Model[:a == 'b']
+    proc {@c[:a == 1]}.should raise_error(Sequel::Error)
+    proc {@c[:a != 1]}.should raise_error(Sequel::Error)
+  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"
+  end
+
+  it "should work correctly for composite primary key" 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$/
+  end
+end