sequel 4.22.0 → 4.23.0

data/spec/integration/spec_helper.rb

@@ -21,70 +21,7 @@ Sequel::Model.cache_associations = false if ENV['SEQUEL_NO_CACHE_ASSOCIATIONS']
 Sequel::Model.use_transactions = false
 Sequel.cache_anonymous_models = false
 
-unless defined?(RSpec)
-  module Spec::Matchers
-    class BeWithin
-      include Spec::Matchers
-      def initialize(delta); @delta = delta; end
-      def of(expected); be_close(expected, @delta); end 
-    end
-    def be_within(delta)
-      BeWithin.new(delta)
-    end
-  end
-end
-
-def Sequel.guarded?(*checked)
-  unless ENV['SEQUEL_NO_PENDING']
-    checked.each do |c|
-      case c
-      when DB.database_type
-        return c
-      when Array
-        case c.length
-        when 1
-          return c if c.first == DB.adapter_scheme
-        when 2
-          if c.first.is_a?(Proc)
-            return c if c.last == DB.database_type && c.first.call(DB)
-          elsif c.last.is_a?(Proc)
-            return c if c.first == DB.adapter_scheme && c.last.call(DB)
-          else
-            return c if c.first == DB.adapter_scheme && c.last == DB.database_type
-          end
-        when 3
-          return c if c[0] == DB.adapter_scheme && c[1] == DB.database_type && c[2].call(DB)
-        end          
-      end
-    end
-  end
-  false
-end
-
-require File.join(File.dirname(File.expand_path(__FILE__)), "../rspec_helper.rb")
-
-RSPEC_EXAMPLE_GROUP.class_eval do
-  def log
-    begin
-      DB.loggers << Logger.new(STDOUT)
-      yield
-    ensure
-     DB.loggers.pop
-    end
-  end
-  
-  def self.cspecify(message, *checked, &block)
-    if pending = Sequel.guarded?(*checked)
-      specify(message) do
-        method = RSPEC_SKIP_PENDING && !ENV['SEQUEL_NO_SKIP_PENDING'] ? :skip : :pending
-        send(method, "Not yet working on #{Array(pending).map{|x| x.is_a?(Proc) ? :proc : x}.join(', ')}")
-        instance_eval(&block)
-      end
-    else
-      specify(message, &block)
-    end
-  end
-end
+require './spec/guards_helper'
 
 unless defined?(DB)
   DB = Sequel.connect(ENV['SEQUEL_INTEGRATION_URL'])

data/spec/integration/timezone_test.rb

@@ -1,16 +1,16 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe "Sequel timezone support" do
-  def test_timezone(timezone=Sequel.application_timezone)
+  def _test_timezone(timezone=Sequel.application_timezone)
     Sequel.datetime_class = Time
     # Tests should cover both DST and non-DST times.
     [Time.now, Time.local(2010,1,1,12), Time.local(2010,6,1,12)].each do |t|
       @db[:t].insert(t)
       t2 = @db[:t].single_value
       t2 = @db.to_application_timestamp(t2.to_s) unless t2.is_a?(Time)
-      (t2 - t).should be_within(2).of(0)
-      t2.utc_offset.should == 0 if timezone == :utc
-      t2.utc_offset.should == t.getlocal.utc_offset if timezone == :local
+      (t2 - t).must_be_close_to 0, 2
+      t2.utc_offset.must_equal 0 if timezone == :utc
+      t2.utc_offset.must_equal t.getlocal.utc_offset if timezone == :local
       @db[:t].delete
     end
 
@@ -21,9 +21,9 @@ describe "Sequel timezone support" do
       @db[:t].insert(dt)
       dt2 = @db[:t].single_value
       dt2 = @db.to_application_timestamp(dt2.to_s) unless dt2.is_a?(DateTime)
-      (dt2 - dt).should be_within(0.00002).of(0)
-      dt2.offset.should == 0 if timezone == :utc
-      dt2.offset.should == dt.offset if timezone == :local
+      (dt2 - dt).must_be_close_to 0, 0.00002
+      dt2.offset.must_equal 0 if timezone == :utc
+      dt2.offset.must_equal dt.offset if timezone == :local
       @db[:t].delete
     end
   end
@@ -42,45 +42,45 @@ describe "Sequel timezone support" do
   cspecify "should support using UTC for database storage and local time for the application", [:tinytds], [:do, :mysql], [:do, :postgres], [:oracle] do
     Sequel.database_timezone = :utc
     Sequel.application_timezone = :local
-    test_timezone
+    _test_timezone
     Sequel.database_timezone = nil
     @db.timezone = :utc
-    test_timezone
+    _test_timezone
   end
 
   cspecify "should support using local time for database storage and UTC for the application", [:tinytds], [:do, :mysql], [:do, :postgres], [:oracle] do
     Sequel.database_timezone = :local
     Sequel.application_timezone = :utc
-    test_timezone
+    _test_timezone
     Sequel.database_timezone = nil
     @db.timezone = :local
-    test_timezone
+    _test_timezone
   end
 
   cspecify "should support using UTC for both database storage and for application", [:do, :mysql], [:do, :postgres], [:oracle] do
     Sequel.default_timezone = :utc
-    test_timezone
+    _test_timezone
     Sequel.database_timezone = :local
     @db.timezone = :utc
-    test_timezone
+    _test_timezone
   end
 
   cspecify "should support using local time for both database storage and for application", [:do, :postgres], [:oracle] do
     Sequel.default_timezone = :local
-    test_timezone
+    _test_timezone
     Sequel.database_timezone = :utc
     @db.timezone = :local
-    test_timezone
+    _test_timezone
   end
 
-  specify "should allow overriding the database_timezone on a per-database basis" do
+  it "should allow overriding the database_timezone on a per-database basis" do
     Sequel.database_timezone = :utc
     @db.timezone = :local
     t = Time.now
     @db[:t].insert(t)
     s = @db[:t].get(Sequel.cast(:t, String))
     if o = Date._parse(s)[:offset]
-      o.should == t.utc_offset
+      o.must_equal t.utc_offset
     end
   end
 end

data/spec/integration/transaction_test.rb

@@ -13,78 +13,78 @@ describe "Database transactions" do
     @db.drop_table?(:items)
   end
 
-  specify "should support transactions" do
+  it "should support transactions" do
     @db.transaction{@d << {:name => 'abc', :value => 1}}
-    @d.count.should == 1
+    @d.count.must_equal 1
   end
 
-  specify "should have #transaction yield the connection" do
-    @db.transaction{|conn| conn.should_not == nil}
+  it "should have #transaction yield the connection" do
+    @db.transaction{|conn| conn.wont_equal nil}
   end
 
-  specify "should have #in_transaction? work correctly" do
-    @db.in_transaction?.should == false
+  it "should have #in_transaction? work correctly" do
+    @db.in_transaction?.must_equal false
     c = nil
     @db.transaction{c = @db.in_transaction?}
-    c.should == true
+    c.must_equal true
   end
 
-  specify "should correctly rollback transactions" do
+  it "should correctly rollback transactions" do
     proc do
       @db.transaction do
         @d << {:name => 'abc', :value => 1}
         raise Interrupt, 'asdf'
       end
-    end.should raise_error(Interrupt)
+    end.must_raise(Interrupt)
 
     @db.transaction do
       @d << {:name => 'abc', :value => 1}
       raise Sequel::Rollback
-    end.should be_nil
+    end.must_equal nil
 
     proc do
       @db.transaction(:rollback=>:reraise) do
         @d << {:name => 'abc', :value => 1}
         raise Sequel::Rollback
       end
-    end.should raise_error(Sequel::Rollback)
+    end.must_raise(Sequel::Rollback)
 
     @db.transaction(:rollback=>:always) do
       @d << {:name => 'abc', :value => 1}
       2
-    end.should be_nil
+    end.must_equal 2
 
-    @d.count.should == 0
+    @d.count.must_equal 0
   end
 
-  specify "should support nested transactions" do
+  it "should support nested transactions" do
     @db.transaction do
       @db.transaction do
         @d << {:name => 'abc', :value => 1}
       end 
     end 
-    @d.count.should == 1
+    @d.count.must_equal 1
 
     @d.delete
-    proc {@db.transaction do
+    @db.transaction do
       @d << {:name => 'abc', :value => 1}
       @db.transaction do
         raise Sequel::Rollback
       end 
-    end}.should_not raise_error
-    @d.count.should == 0
+    end
+    @d.count.must_equal 0
 
     proc {@db.transaction do
       @d << {:name => 'abc', :value => 1}
       @db.transaction do
         raise Interrupt, 'asdf'
       end 
-    end}.should raise_error(Interrupt)
-    @d.count.should == 0
+    end}.must_raise(Interrupt)
+    @d.count.must_equal 0
   end 
   
   if DB.supports_savepoints?
-    specify "should support nested transactions through savepoints using the savepoint option" do
+    it "should support nested transactions through savepoints using the savepoint option" do
       @db.transaction do
         @d << {:name => '1'}
         @db.transaction(:savepoint=>true) do
@@ -105,10 +105,10 @@ describe "Database transactions" do
         @d << {:name => '5'}
       end
 
-      @d.order(:name).map(:name).should == %w{1 4 5 6}
+      @d.order(:name).map(:name).must_equal %w{1 4 5 6}
     end
 
-    specify "should support nested transactions through savepoints using the auto_savepoint option" do
+    it "should support nested transactions through savepoints using the auto_savepoint option" do
       @db.transaction(:auto_savepoint=>true) do
         @d << {:name => '1'}
         @db.transaction do
@@ -129,11 +129,11 @@ describe "Database transactions" do
         @d << {:name => '5'}
       end
 
-      @d.order(:name).map(:name).should == %w{1 4 5 6}
+      @d.order(:name).map(:name).must_equal %w{1 4 5 6}
     end
   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[:items] << {:name => 'abc'}
@@ -141,143 +141,143 @@ describe "Database transactions" do
       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 Interrupt, 'asdf'
       end
-    end.should raise_error(Interrupt)
+    end.must_raise(Interrupt)
 
-    @d.count.should == 2
+    @d.count.must_equal 2
   end
 
   if DB.supports_prepared_transactions?
-    specify "should allow saving and destroying of model objects" do
+    it "should allow saving and destroying of model objects" do
       c = Class.new(Sequel::Model(@d))
       c.set_primary_key :name
       c.unrestrict_primary_key
       c.use_after_commit_rollback = false
       @db.transaction(:prepare=>'XYZ'){c.create(:name => '1'); c.create(:name => '2').destroy}
       @db.commit_prepared_transaction('XYZ')
-      @d.select_order_map(:name).should == ['1']
+      @d.select_order_map(:name).must_equal ['1']
     end
 
-    specify "should commit prepared transactions using commit_prepared_transaction" do
+    it "should commit prepared transactions using commit_prepared_transaction" do
       @db.transaction(:prepare=>'XYZ'){@d << {:name => '1'}}
       @db.commit_prepared_transaction('XYZ')
-      @d.select_order_map(:name).should == ['1']
+      @d.select_order_map(:name).must_equal ['1']
     end
 
-    specify "should rollback prepared transactions using rollback_prepared_transaction" do
+    it "should rollback prepared transactions using rollback_prepared_transaction" do
       @db.transaction(:prepare=>'XYZ'){@d << {:name => '1'}}
       @db.rollback_prepared_transaction('XYZ')
-      @d.select_order_map(:name).should == []
+      @d.select_order_map(:name).must_equal []
     end
 
     if DB.supports_savepoints_in_prepared_transactions?
-      specify "should support savepoints when using prepared transactions" do
+      it "should support savepoints when using prepared transactions" do
         @db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@d << {:name => '1'}}}
         @db.commit_prepared_transaction('XYZ')
-        @d.select_order_map(:name).should == ['1']
+        @d.select_order_map(:name).must_equal ['1']
       end
     end
   end
 
-  specify "should support all transaction isolation levels" do
+  it "should support all transaction isolation levels" do
     [:uncommitted, :committed, :repeatable, :serializable].each_with_index do |l, i|
       @db.transaction(:isolation=>l){@d << {:name => 'abc', :value => 1}}
-      @d.count.should == i + 1
+      @d.count.must_equal i + 1
     end
   end
 
-  specify "should support after_commit outside transactions" do
+  it "should support after_commit outside transactions" do
     c = nil
     @db.after_commit{c = 1}
-    c.should == 1
+    c.must_equal 1
   end
 
-  specify "should support after_rollback outside transactions" do
+  it "should support after_rollback outside transactions" do
     c = nil
     @db.after_rollback{c = 1}
-    c.should be_nil
+    c.must_equal nil
   end
 
-  specify "should support after_commit inside transactions" do
+  it "should support after_commit inside transactions" do
     c = nil
-    @db.transaction{@db.after_commit{c = 1}; c.should be_nil}
-    c.should == 1
+    @db.transaction{@db.after_commit{c = 1}; c.must_equal nil}
+    c.must_equal 1
   end
 
-  specify "should support after_rollback inside transactions" do
+  it "should support after_rollback inside transactions" do
     c = nil
-    @db.transaction{@db.after_rollback{c = 1}; c.should be_nil}
-    c.should be_nil
+    @db.transaction{@db.after_rollback{c = 1}; c.must_equal nil}
+    c.must_equal nil
   end
 
-  specify "should not call after_commit if the transaction rolls back" do
+  it "should not call after_commit if the transaction rolls back" do
     c = nil
-    @db.transaction{@db.after_commit{c = 1}; c.should be_nil; raise Sequel::Rollback}
-    c.should be_nil
+    @db.transaction{@db.after_commit{c = 1}; c.must_equal nil; raise Sequel::Rollback}
+    c.must_equal nil
   end
 
-  specify "should call after_rollback if the transaction rolls back" do
+  it "should call after_rollback if the transaction rolls back" do
     c = nil
-    @db.transaction{@db.after_rollback{c = 1}; c.should be_nil; raise Sequel::Rollback}
-    c.should == 1
+    @db.transaction{@db.after_rollback{c = 1}; c.must_equal nil; raise Sequel::Rollback}
+    c.must_equal 1
   end
 
-  specify "should support multiple after_commit blocks inside transactions" do
+  it "should support multiple after_commit blocks inside transactions" do
     c = []
-    @db.transaction{@db.after_commit{c << 1}; @db.after_commit{c << 2}; c.should == []}
-    c.should == [1, 2]
+    @db.transaction{@db.after_commit{c << 1}; @db.after_commit{c << 2}; c.must_equal []}
+    c.must_equal [1, 2]
   end
 
-  specify "should support multiple after_rollback blocks inside transactions" do
+  it "should support multiple after_rollback blocks inside transactions" do
     c = []
-    @db.transaction{@db.after_rollback{c << 1}; @db.after_rollback{c << 2}; c.should == []; raise Sequel::Rollback}
-    c.should == [1, 2]
+    @db.transaction{@db.after_rollback{c << 1}; @db.after_rollback{c << 2}; c.must_equal []; raise Sequel::Rollback}
+    c.must_equal [1, 2]
   end
 
-  specify "should support after_commit inside nested transactions" do
+  it "should support after_commit inside nested transactions" do
     c = nil
-    @db.transaction{@db.transaction{@db.after_commit{c = 1}}; c.should be_nil}
-    c.should == 1
+    @db.transaction{@db.transaction{@db.after_commit{c = 1}}; c.must_equal nil}
+    c.must_equal 1
   end
 
-  specify "should support after_rollback inside nested transactions" do
+  it "should support after_rollback inside nested transactions" do
     c = nil
-    @db.transaction{@db.transaction{@db.after_rollback{c = 1}}; c.should be_nil; raise Sequel::Rollback}
-    c.should == 1
+    @db.transaction{@db.transaction{@db.after_rollback{c = 1}}; c.must_equal nil; raise Sequel::Rollback}
+    c.must_equal 1
   end
 
   if DB.supports_savepoints?
-    specify "should support after_commit inside savepoints" do
+    it "should support after_commit inside savepoints" do
       c = nil
-      @db.transaction{@db.transaction(:savepoint=>true){@db.after_commit{c = 1}}; c.should be_nil}
-      c.should == 1
+      @db.transaction{@db.transaction(:savepoint=>true){@db.after_commit{c = 1}}; c.must_equal nil}
+      c.must_equal 1
     end
 
-    specify "should support after_rollback inside savepoints" do
+    it "should support after_rollback inside savepoints" do
       c = nil
-      @db.transaction{@db.transaction(:savepoint=>true){@db.after_rollback{c = 1}}; c.should be_nil; raise Sequel::Rollback}
-      c.should == 1
+      @db.transaction{@db.transaction(:savepoint=>true){@db.after_rollback{c = 1}}; c.must_equal nil; raise Sequel::Rollback}
+      c.must_equal 1
     end
   end
 
   if DB.supports_prepared_transactions?
-    specify "should raise an error if you attempt to use after_commit or after_rollback inside a prepared transaction" do
-      proc{@db.transaction(:prepare=>'XYZ'){@db.after_commit{}}}.should raise_error(Sequel::Error)
-      proc{@db.transaction(:prepare=>'XYZ'){@db.after_rollback{}}}.should raise_error(Sequel::Error)
+    it "should raise an error if you attempt to use after_commit or after_rollback inside a prepared transaction" do
+      proc{@db.transaction(:prepare=>'XYZ'){@db.after_commit{}}}.must_raise(Sequel::Error)
+      proc{@db.transaction(:prepare=>'XYZ'){@db.after_rollback{}}}.must_raise(Sequel::Error)
     end
 
     if DB.supports_savepoints_in_prepared_transactions?
-      specify "should raise an error if you attempt to use after_commit or after rollback inside a savepoint in a prepared transaction" do
-        proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_commit{}}}}.should raise_error(Sequel::Error)
-        proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_rollback{}}}}.should raise_error(Sequel::Error)
+      it "should raise an error if you attempt to use after_commit or after rollback inside a savepoint in a prepared transaction" do
+        proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_commit{}}}}.must_raise(Sequel::Error)
+        proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_rollback{}}}}.must_raise(Sequel::Error)
       end
     end
   end
@@ -294,7 +294,7 @@ if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or (RUBY_ENGINE == 'rbx' &&
       @db.drop_table?(:items)
     end
 
-    specify "should handle transactions inside threads" do
+    it "should handle transactions inside threads" do
       q = Queue.new
       q1 = Queue.new
       t = Thread.new do
@@ -307,11 +307,11 @@ if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or (RUBY_ENGINE == 'rbx' &&
       end
       q1.pop
       t.kill
-      @d.count.should == 0
+      @d.count.must_equal 0
     end
 
     if DB.supports_savepoints?
-      specify "should handle transactions with savepoints inside threads" do
+      it "should handle transactions with savepoints inside threads" do
         q = Queue.new
         q1 = Queue.new
         t = Thread.new do
@@ -328,7 +328,7 @@ if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or (RUBY_ENGINE == 'rbx' &&
         end
         q1.pop
         t.kill
-        @d.count.should == 0
+        @d.count.must_equal 0
       end
     end
   end
@@ -355,7 +355,7 @@ describe "Database transaction retrying" do
       s = s.succ
       @d.insert(s)
     end
-    @d.select_order_map(:a).should == %w'b c d'
+    @d.select_order_map(:a).must_equal %w'b c d'
   end
 
   cspecify "should limit number of retries via the :num_retries option", [:db2] do
@@ -367,8 +367,8 @@ describe "Database transaction retrying" do
         s = s.succ
         @d.insert(s)
       end
-    end.should raise_error(Sequel::ConstraintViolation)
-    @d.select_order_map(:a).should == %w'b c'
+    end.must_raise(Sequel::UniqueConstraintViolation, Sequel::ConstraintViolation)
+    @d.select_order_map(:a).must_equal %w'b c'
   end
 end