sequel 4.22.0 → 4.23.0

data/lib/sequel/plugins/validate_associated.rb

@@ -0,0 +1,55 @@
+module Sequel
+  module Plugins
+    # The validates_associated plugin allows you to validate associated
+    # objects.  It also offers the ability to delay the validation of
+    # associated objects until the current object is validated.
+    # If the associated object is invalid, validation error messages
+    # from the associated object will be added to the current object's
+    # validation errors.
+    #
+    # Usage:
+    #
+    #   # Make all model subclass support validating associated objects
+    #   Sequel::Model.plugin :validate_associated
+    #
+    #   # Make the Album class support validating associated objects
+    #   Album.plugin :validate_associated
+    module ValidateAssociated
+      # Depend on the instance_hooks plugin.
+      def self.apply(mod)
+        mod.plugin :instance_hooks
+      end
+
+      module InstanceMethods
+        private
+
+        # Delay validating the associated object until validating the current object.
+        def delay_validate_associated_object(reflection, obj)
+          after_validation_hook{validate_associated_object(reflection, obj)}
+        end
+
+        # Validate the given associated object, adding any validation error messages from the
+        # given object to the parent object.
+        def validate_associated_object(reflection, obj)
+          return if reflection[:validate] == false
+          association = reflection[:name]
+          if (reflection[:type] == :one_to_many || reflection[:type] == :one_to_one) && (key = reflection[:key]).is_a?(Symbol) && !(pk_val = obj.values[key])
+            # There could be a presence validation on the foreign key in the associated model,
+            # which will fail if we validate before saving the current object.  If there is
+            # no value for the foreign key, set it to the current primary key value, or a dummy
+            # value of 0 if we haven't saved the current object.
+            p_key = pk unless pk.is_a?(Array)
+            obj.values[key] = p_key || 0
+            key = nil if p_key
+          end
+          obj.errors.full_messages.each{|m| errors.add(association, m)} unless obj.valid?
+          if key && !pk_val
+            # If we used a dummy value of 0, remove it so it doesn't accidently remain.
+            obj.values.delete(key)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 22
+  MINOR = 23
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/db2_spec.rb

@@ -17,14 +17,14 @@ describe Sequel::Database do
     @db.drop_table(:test)
   end
   
-  specify "should provide disconnect functionality after preparing a connection" do
+  it "should provide disconnect functionality after preparing a connection" do
     @ds.prepare(:first, :a).call
     @db.disconnect
-    @db.pool.size.should == 0
+    @db.pool.size.must_equal 0
   end
 
-  specify "should return version correctly" do
-    @db.db2_version.should match(/DB2 v/i)
+  it "should return version correctly" do
+    @db.db2_version.must_match(/DB2 v/i)
   end
 end
 
@@ -47,15 +47,15 @@ describe "Simple Dataset operations" do
     DB.drop_table(:items)
   end
 
-  specify "should insert with a primary key specified" do
+  it "should insert with a primary key specified" do
     @ds.insert(:id => 1,   :number => 10)
     @ds.insert(:id => 100, :number => 20)
-    @ds.select_hash(:id, :number).should == {1 => 10, 100 => 20}
+    @ds.select_hash(:id, :number).must_equal(1 => 10, 100 => 20)
   end
 
-  specify "should insert into binary columns" do
+  it "should insert into binary columns" do
     @ds.insert(:id => 1, :bin_string => Sequel.blob("\1"), :bin_clob => Sequel.blob("\2"))
-    @ds.select(:bin_string, :bin_clob).first.should == {:bin_string => "\1", :bin_clob => "\2"}
+    @ds.select(:bin_string, :bin_clob).first.must_equal(:bin_string => "\1", :bin_clob => "\2")
   end
 end
 
@@ -66,13 +66,13 @@ describe Sequel::Database do
   after do
     @db.drop_table(:items)
   end
-  specify "should parse primary keys from the schema properly" do
+  it "should parse primary keys from the schema properly" do
     @db.create_table!(:items){Integer :number}
-    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == []
+    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.must_equal []
     @db.create_table!(:items){primary_key :number}
-    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number]
+    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.must_equal [:number]
     @db.create_table!(:items){Integer :number1, :null => false; Integer :number2, :null => false; primary_key [:number1, :number2]}
-    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number1, :number2]
+    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.must_equal [:number1, :number2]
   end
 end
 
@@ -87,42 +87,42 @@ describe "Sequel::IBMDB.convert_smallint_to_bool" do
     @db.drop_table(:booltest)
   end
   
-  specify "should consider smallint datatypes as boolean if set, but not larger smallints" do
-    @db.schema(:booltest, :reload=>true).first.last[:type].should == :boolean
-    @db.schema(:booltest, :reload=>true).first.last[:db_type].should match /smallint/i
+  it "should consider smallint datatypes as boolean if set, but not larger smallints" do
+    @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :boolean
+    @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
     Sequel::IBMDB.convert_smallint_to_bool = false
-    @db.schema(:booltest, :reload=>true).first.last[:type].should == :integer
-    @db.schema(:booltest, :reload=>true).first.last[:db_type].should match /smallint/i
+    @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :integer
+    @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
   end
   
-  specify "should return smallints as bools and integers as integers when set" do
+  it "should return smallints as bools and integers as integers when set" do
     Sequel::IBMDB.convert_smallint_to_bool = true
     @ds.delete
     @ds << {:b=>true, :i=>10}
-    @ds.all.should == [{:b=>true, :i=>10}]
+    @ds.all.must_equal [{:b=>true, :i=>10}]
     @ds.delete
     @ds << {:b=>false, :i=>0}
-    @ds.all.should == [{:b=>false, :i=>0}]
+    @ds.all.must_equal [{:b=>false, :i=>0}]
     @ds.delete
     @ds << {:b=>true, :i=>1}
-    @ds.all.should == [{:b=>true, :i=>1}]
+    @ds.all.must_equal [{:b=>true, :i=>1}]
   end
 
-  specify "should return all smallints as integers when unset" do
+  it "should return all smallints as integers when unset" do
     Sequel::IBMDB.convert_smallint_to_bool = false
     @ds.delete
     @ds << {:b=>true, :i=>10}
-    @ds.all.should == [{:b=>1, :i=>10}]
+    @ds.all.must_equal [{:b=>1, :i=>10}]
     @ds.delete
     @ds << {:b=>false, :i=>0}
-    @ds.all.should == [{:b=>0, :i=>0}]
+    @ds.all.must_equal [{:b=>0, :i=>0}]
     
     @ds.delete
     @ds << {:b=>1, :i=>10}
-    @ds.all.should == [{:b=>1, :i=>10}]
+    @ds.all.must_equal [{:b=>1, :i=>10}]
     @ds.delete
     @ds << {:b=>0, :i=>0}
-    @ds.all.should == [{:b=>0, :i=>0}]
+    @ds.all.must_equal [{:b=>0, :i=>0}]
   end
 end if DB.adapter_scheme == :ibmdb
 
@@ -138,11 +138,11 @@ describe "Simple Dataset operations in transactions" do
     DB.drop_table(:items_insert_in_transaction)
   end
 
-  specify "should insert correctly with a primary key specified inside a transaction" do
+  it "should insert correctly with a primary key specified inside a transaction" do
     DB.transaction do
       @ds.insert(:id=>100, :number=>20)
-      @ds.count.should == 1
-      @ds.order(:id).all.should == [{:id=>100, :number=>20}]
+      @ds.count.must_equal 1
+      @ds.order(:id).all.must_equal [{:id=>100, :number=>20}]
     end
   end
 end

data/spec/adapters/firebird_spec.rb

@@ -44,15 +44,15 @@ describe "A Firebird database" do
     @db = DB
   end
 
-  specify "should provide disconnect functionality" do
+  it "should provide disconnect functionality" do
     @db.tables
-    @db.pool.size.should == 1
+    @db.pool.size.must_equal 1
     @db.disconnect
-    @db.pool.size.should == 0
+    @db.pool.size.must_equal 0
   end
 
-  specify "should raise Sequel::Error on error" do
-    proc{@db << "SELECT 1 + 'a'"}.should raise_error(Sequel::Error)
+  it "should raise Sequel::Error on error" do
+    proc{@db << "SELECT 1 + 'a'"}.must_raise(Sequel::Error)
   end
 end
 
@@ -63,28 +63,28 @@ describe "A Firebird dataset" do
     @d.quote_identifiers = true
   end
 
-  specify "should return the correct record count" do
-    @d.count.should == 0
+  it "should return the correct record count" do
+    @d.count.must_equal 0
     @d << {:name => 'abc', :val => 123}
     @d << {:name => 'abc', :val  => 456}
     @d << {:name => 'def', :val => 789}
-    @d.count.should == 3
+    @d.count.must_equal 3
   end
 
-  specify "should return the correct records" do
-    @d.to_a.should == []
+  it "should return the correct records" do
+    @d.to_a.must_equal []
     @d << {:name => 'abc', :val => 123}
     @d << {:name => 'abc', :val => 456}
     @d << {:name => 'def', :val => 789}
 
-    @d.order(:val).to_a.should == [
+    @d.order(:val).to_a.must_equal [
       {:name => 'abc', :val => 123},
       {:name => 'abc', :val => 456},
       {:name => 'def', :val => 789}
     ]
   end
 
-  specify "should update records correctly" do
+  it "should update records correctly" do
     @d << {:name => 'abc', :val => 123}
     @d << {:name => 'abc', :val => 456}
     @d << {:name => 'def', :val => 789}
@@ -92,111 +92,111 @@ describe "A Firebird dataset" do
 
     # the third record should stay the same
     # floating-point precision bullshit
-    @d[:name => 'def'][:val].should == 789
-    @d.filter(:val => 530).count.should == 2
+    @d[:name => 'def'][:val].must_equal 789
+    @d.filter(:val => 530).count.must_equal 2
   end
 
-  specify "should delete records correctly" do
+  it "should delete records correctly" do
     @d << {:name => 'abc', :val => 123}
     @d << {:name => 'abc', :val => 456}
     @d << {:name => 'def', :val => 789}
     @d.filter(:name => 'abc').delete
 
-    @d.count.should == 1
-    @d.first[:name].should == 'def'
+    @d.count.must_equal 1
+    @d.first[:name].must_equal 'def'
   end
 
-  specify "should be able to literalize booleans" do
-    proc {@d.literal(true)}.should_not raise_error
-    proc {@d.literal(false)}.should_not raise_error
+  it "should be able to literalize booleans" do
+    @d.literal(true)
+    @d.literal(false)
   end
 
-  specify "should quote columns and tables using double quotes if quoting identifiers" do
+  it "should quote columns and tables using double quotes if quoting identifiers" do
     @d.quote_identifiers = true
-    @d.select(:name).sql.should == \
+    @d.select(:name).sql.must_equal \
       'SELECT "NAME" FROM "TEST"'
 
-    @d.select('COUNT(*)'.lit).sql.should == \
+    @d.select('COUNT(*)'.lit).sql.must_equal \
       'SELECT COUNT(*) FROM "TEST"'
 
-    @d.select(:max[:val]).sql.should == \
+    @d.select(:max[:val]).sql.must_equal \
       'SELECT max("VAL") FROM "TEST"'
 
-    @d.select(:now[]).sql.should == \
+    @d.select(:now[]).sql.must_equal \
     'SELECT now() FROM "TEST"'
 
-    @d.select(:max[:items__val]).sql.should == \
+    @d.select(:max[:items__val]).sql.must_equal \
       'SELECT max("ITEMS"."VAL") FROM "TEST"'
 
-    @d.order(:name.desc).sql.should == \
+    @d.order(:name.desc).sql.must_equal \
       'SELECT * FROM "TEST" ORDER BY "NAME" DESC'
 
-    @d.select('TEST.NAME AS item_:name'.lit).sql.should == \
+    @d.select('TEST.NAME AS item_:name'.lit).sql.must_equal \
       'SELECT TEST.NAME AS item_:name FROM "TEST"'
 
-    @d.select('"NAME"'.lit).sql.should == \
+    @d.select('"NAME"'.lit).sql.must_equal \
       'SELECT "NAME" FROM "TEST"'
 
-    @d.select('max(TEST."NAME") AS "max_:name"'.lit).sql.should == \
+    @d.select('max(TEST."NAME") AS "max_:name"'.lit).sql.must_equal \
       'SELECT max(TEST."NAME") AS "max_:name" FROM "TEST"'
 
-    @d.select(:test[:ABC, 'hello']).sql.should == \
+    @d.select(:test[:ABC, 'hello']).sql.must_equal \
       "SELECT test(\"ABC\", 'hello') FROM \"TEST\""
 
-    @d.select(:test[:ABC__DEF, 'hello']).sql.should == \
+    @d.select(:test[:ABC__DEF, 'hello']).sql.must_equal \
       "SELECT test(\"ABC\".\"DEF\", 'hello') FROM \"TEST\""
 
-    @d.select(:test[:ABC__DEF, 'hello'].as(:X2)).sql.should == \
+    @d.select(:test[:ABC__DEF, 'hello'].as(:X2)).sql.must_equal \
       "SELECT test(\"ABC\".\"DEF\", 'hello') AS \"X2\" FROM \"TEST\""
 
-    @d.insert_sql(:val => 333).should =~ \
+    @d.insert_sql(:val => 333).must_match \
       /\AINSERT INTO "TEST" \("VAL"\) VALUES \(333\)( RETURNING NULL)?\z/
 
-    @d.insert_sql(:X => :Y).should =~ \
+    @d.insert_sql(:X => :Y).must_match \
       /\AINSERT INTO "TEST" \("X"\) VALUES \("Y"\)( RETURNING NULL)?\z/
   end
 
-  specify "should quote fields correctly when reversing the order if quoting identifiers" do
+  it "should quote fields correctly when reversing the order if quoting identifiers" do
     @d.quote_identifiers = true
-    @d.reverse_order(:name).sql.should == \
+    @d.reverse_order(:name).sql.must_equal \
       'SELECT * FROM "TEST" ORDER BY "NAME" DESC'
 
-    @d.reverse_order(:name.desc).sql.should == \
+    @d.reverse_order(:name.desc).sql.must_equal \
       'SELECT * FROM "TEST" ORDER BY "NAME" ASC'
 
-    @d.reverse_order(:name, :test.desc).sql.should == \
+    @d.reverse_order(:name, :test.desc).sql.must_equal \
       'SELECT * FROM "TEST" ORDER BY "NAME" DESC, "TEST" ASC'
 
-    @d.reverse_order(:name.desc, :test).sql.should == \
+    @d.reverse_order(:name.desc, :test).sql.must_equal \
       'SELECT * FROM "TEST" ORDER BY "NAME" ASC, "TEST" DESC'
   end
 
-  specify "should support transactions" do
+  it "should support transactions" do
     DB.transaction do
       @d << {:name => 'abc', :val => 1}
     end
 
-    @d.count.should == 1
+    @d.count.must_equal 1
   end
 
-  specify "should have #transaction yield the connection" do
+  it "should have #transaction yield the connection" do
     DB.transaction do |conn|
-      conn.should_not == nil
+      conn.wont_equal nil
     end
   end
 
-  specify "should correctly rollback transactions" do
+  it "should correctly rollback transactions" do
     proc do
       DB.transaction do
         @d << {:name => 'abc', :val => 1}
         raise RuntimeError, 'asdf'
       end
-    end.should raise_error(RuntimeError)
+    end.must_raise(RuntimeError)
 
-    @d.count.should == 0
+    @d.count.must_equal 0
   end
 
-  specify "should handle returning inside of the block by committing" do
+  it "should handle returning inside of the block by committing" do
     def DB.ret_commit
       transaction do
         self[:test] << {:name => 'abc'}
@@ -204,24 +204,24 @@ describe "A Firebird dataset" do
         self[:test] << {:name => 'd'}
       end
     end
-    @d.count.should == 0
+    @d.count.must_equal 0
     DB.ret_commit
-    @d.count.should == 1
+    @d.count.must_equal 1
     DB.ret_commit
-    @d.count.should == 2
+    @d.count.must_equal 2
     proc do
       DB.transaction do
         raise RuntimeError, 'asdf'
       end
-    end.should raise_error(RuntimeError)
+    end.must_raise(RuntimeError)
 
-    @d.count.should == 2
+    @d.count.must_equal 2
   end
 
-  specify "should quote and upcase reserved keywords" do
+  it "should quote and upcase reserved keywords" do
     @d = DB[:testing]
     @d.quote_identifiers = true
-    @d.select(:select).sql.should == \
+    @d.select(:select).sql.must_equal \
       'SELECT "SELECT" FROM "TESTING"'
   end
 end
@@ -232,11 +232,11 @@ describe "A Firebird dataset with a timestamp field" do
     @d.delete
   end
 
-  specify "should store milliseconds in time fields" do
+  it "should store milliseconds in time fields" do
     t = Time.now
     @d << {:val=>1, :time_stamp=>t}
-    @d.literal(@d[:val =>'1'][:time_stamp]).should == @d.literal(t)
-    @d[:val=>'1'][:time_stamp].usec.should == t.usec - t.usec % 100
+    @d.literal(@d[:val =>'1'][:time_stamp]).must_equal @d.literal(t)
+    @d[:val=>'1'][:time_stamp].usec.must_equal t.usec - t.usec % 100
   end
 end
 
@@ -247,10 +247,10 @@ describe "A Firebird database" do
     @db.sqls.clear
   end
 
-  specify "should allow us to name the sequences" do
+  it "should allow us to name the sequences" do
     @db.create_table(:posts){primary_key :id, :sequence_name => "seq_test"}
     check_sqls do
-      @db.sqls.should == [
+      @db.sqls.must_equal [
         "DROP SEQUENCE SEQ_TEST",
         "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
         "CREATE SEQUENCE SEQ_TEST",
@@ -259,10 +259,10 @@ describe "A Firebird database" do
     end
   end
 
-  specify "should allow us to set the starting position for the sequences" do
+  it "should allow us to set the starting position for the sequences" do
     @db.create_table(:posts){primary_key :id, :sequence_start_position => 999}
     check_sqls do
-      @db.sqls.should == [
+      @db.sqls.must_equal [
         "DROP SEQUENCE SEQ_POSTS_ID",
         "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
         "CREATE SEQUENCE SEQ_POSTS_ID",
@@ -272,10 +272,10 @@ describe "A Firebird database" do
     end
   end
 
-  specify "should allow us to name and set the starting position for the sequences" do
+  it "should allow us to name and set the starting position for the sequences" do
     @db.create_table(:posts){primary_key :id, :sequence_name => "seq_test", :sequence_start_position => 999}
     check_sqls do
-      @db.sqls.should == [
+      @db.sqls.must_equal [
         "DROP SEQUENCE SEQ_TEST",
         "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
         "CREATE SEQUENCE SEQ_TEST",
@@ -285,10 +285,10 @@ describe "A Firebird database" do
     end
   end
 
-  specify "should allow us to name the triggers" do
+  it "should allow us to name the triggers" do
     @db.create_table(:posts){primary_key :id, :trigger_name => "trig_test"}
     check_sqls do
-      @db.sqls.should == [
+      @db.sqls.must_equal [
         "DROP SEQUENCE SEQ_POSTS_ID",
         "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
         "CREATE SEQUENCE SEQ_POSTS_ID",
@@ -297,20 +297,20 @@ describe "A Firebird database" do
     end
   end
 
-  specify "should allow us to not create the sequence" do
+  it "should allow us to not create the sequence" do
     @db.create_table(:posts){primary_key :id, :create_sequence => false}
     check_sqls do
-      @db.sqls.should == [
+      @db.sqls.must_equal [
         "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
         "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
       ]
     end
   end
 
-  specify "should allow us to not create the trigger" do
+  it "should allow us to not create the trigger" do
     @db.create_table(:posts){primary_key :id, :create_trigger => false}
     check_sqls do
-      @db.sqls.should == [
+      @db.sqls.must_equal [
         "DROP SEQUENCE SEQ_POSTS_ID",
         "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
         "CREATE SEQUENCE SEQ_POSTS_ID",
@@ -318,48 +318,48 @@ describe "A Firebird database" do
     end
   end
 
-  specify "should allow us to not create either the sequence nor the trigger" do
+  it "should allow us to not create either the sequence nor the trigger" do
     @db.create_table(:posts){primary_key :id, :create_sequence => false, :create_trigger => false}
     check_sqls do
-      @db.sqls.should == [
+      @db.sqls.must_equal [
         "CREATE TABLE POSTS (ID integer PRIMARY KEY )"
       ]
     end
   end
 
-  specify "should support column operations" do
+  it "should support column operations" do
     @db.create_table!(:test2){varchar :name, :size => 50; integer :val}
     @db[:test2] << {}
-    @db[:test2].columns.should == [:name, :val]
+    @db[:test2].columns.must_equal [:name, :val]
 
     @db.add_column :test2, :xyz, :varchar, :size => 50
-    @db[:test2].columns.should == [:name, :val, :xyz]
+    @db[:test2].columns.must_equal [:name, :val, :xyz]
 
-    @db[:test2].columns.should == [:name, :val, :xyz]
+    @db[:test2].columns.must_equal [:name, :val, :xyz]
     @db.drop_column :test2, :xyz
 
-    @db[:test2].columns.should == [:name, :val]
+    @db[:test2].columns.must_equal [:name, :val]
 
     @db[:test2].delete
     @db.add_column :test2, :xyz, :varchar, :default => '000', :size => 50#, :create_domain => 'xyz_varchar'
     @db[:test2] << {:name => 'mmm', :val => 111, :xyz => 'qqqq'}
 
-    @db[:test2].columns.should == [:name, :val, :xyz]
+    @db[:test2].columns.must_equal [:name, :val, :xyz]
     @db.rename_column :test2, :xyz, :zyx
-    @db[:test2].columns.should == [:name, :val, :zyx]
-    @db[:test2].first[:zyx].should == 'qqqq'
+    @db[:test2].columns.must_equal [:name, :val, :zyx]
+    @db[:test2].first[:zyx].must_equal 'qqqq'
 
     @db.add_column :test2, :xyz, :decimal, :elements => [12, 2]
     @db[:test2].delete
     @db[:test2] << {:name => 'mmm', :val => 111, :xyz => 56.4}
     @db.set_column_type :test2, :xyz, :varchar, :size => 50
 
-    @db[:test2].first[:xyz].should == "56.40"
+    @db[:test2].first[:xyz].must_equal "56.40"
   end
 
-  specify "should allow us to retrieve the primary key for a table" do
+  it "should allow us to retrieve the primary key for a table" do
     @db.create_table!(:test2){primary_key :id}
-    @db.primary_key(:test2).should == ["id"]
+    @db.primary_key(:test2).must_equal ["id"]
   end
 end
 
@@ -369,31 +369,25 @@ describe "Postgres::Dataset#insert" do
     @ds.delete
   end
 
-  specify "should using call insert_returning_sql" do
-#    @ds.should_receive(:single_value).once.with(:sql=>'INSERT INTO TEST5 (VAL) VALUES (10) RETURNING XID', :server=> :default)
-    @ds.should_receive(:single_value).once
-    @ds.insert(:val=>10)
+  it "should have insert_returning_sql use the RETURNING keyword" do
+    @ds.insert_returning_sql(:XID, :val=>10).must_equal "INSERT INTO TEST5 (VAL) VALUES (10) RETURNING XID"
+    @ds.insert_returning_sql('*'.lit, :val=>10).must_equal "INSERT INTO TEST5 (VAL) VALUES (10) RETURNING *"
+    @ds.insert_returning_sql('NULL'.lit, :val=>10).must_equal "INSERT INTO TEST5 (VAL) VALUES (10) RETURNING NULL"
   end
 
-  specify "should have insert_returning_sql use the RETURNING keyword" do
-    @ds.insert_returning_sql(:XID, :val=>10).should == "INSERT INTO TEST5 (VAL) VALUES (10) RETURNING XID"
-    @ds.insert_returning_sql('*'.lit, :val=>10).should == "INSERT INTO TEST5 (VAL) VALUES (10) RETURNING *"
-    @ds.insert_returning_sql('NULL'.lit, :val=>10).should == "INSERT INTO TEST5 (VAL) VALUES (10) RETURNING NULL"
-  end
-
-  specify "should correctly return the inserted record's primary key value" do
+  it "should correctly return the inserted record's primary key value" do
     value1 = 10
     id1 = @ds.insert(:val=>value1)
-    @ds.first(:XID=>id1)[:val].should == value1
+    @ds.first(:XID=>id1)[:val].must_equal value1
     value2 = 20
     id2 = @ds.insert(:val=>value2)
-    @ds.first(:XID=>id2)[:val].should == value2
+    @ds.first(:XID=>id2)[:val].must_equal value2
   end
 
-  specify "should return nil if the table has no primary key" do
+  it "should return nil if the table has no primary key" do
     ds = DB[:test]
     ds.delete
-    ds.insert(:name=>'a').should == nil
+    ds.insert(:name=>'a').must_equal nil
   end
 end
 
@@ -403,15 +397,15 @@ describe "Postgres::Dataset#insert" do
     @ds.delete
   end
 
-  specify "should insert and retrieve a blob successfully" do
+  it "should insert and retrieve a blob successfully" do
     value1 = "\1\2\2\2\2222\2\2\2"
     value2 = "abcd"
     value3 = "efgh"
     value4 = "ijkl"
     id1 = @ds.insert(:val=>value1, :val2=>value2, :val3=>value3, :val4=>value4)
-    @ds.first(:XID=>id1)[:val].should == value1
-    @ds.first(:XID=>id1)[:val2].should == value2
-    @ds.first(:XID=>id1)[:val3].should == value3
-    @ds.first(:XID=>id1)[:val4].should == value4
+    @ds.first(:XID=>id1)[:val].must_equal value1
+    @ds.first(:XID=>id1)[:val2].must_equal value2
+    @ds.first(:XID=>id1)[:val3].must_equal value3
+    @ds.first(:XID=>id1)[:val4].must_equal value4
   end
 end