sequel 0.5.0.2 → 1.0

data/spec/connection_pool_spec.rb

@@ -1,356 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-context "An empty ConnectionPool" do
-  setup do
-    @cpool = Sequel::ConnectionPool.new
-  end
-
-  specify "should have no available connections" do
-    @cpool.available_connections.should == []
-  end
-
-  specify "should have no allocated connections" do
-    @cpool.allocated.should == {}
-  end
-
-  specify "should have a created_count of zero" do
-    @cpool.created_count.should == 0
-  end
-end
-
-context "A connection pool handling connections" do
-  setup do
-    @max_size = 2
-    @cpool = Sequel::ConnectionPool.new(@max_size) {:got_connection}
-  end
-
-  specify "#hold should increment #created_count" do
-    @cpool.hold do
-      @cpool.created_count.should == 1
-      @cpool.hold {@cpool.created_count.should == 1}
-    end
-  end
-
-  specify "#hold should add the connection to the #allocated hash" do
-    @cpool.hold do
-      @cpool.allocated.size.should == 1
-  
-      @cpool.allocated.values.should == [:got_connection]
-    end
-  end
-
-  specify "#hold should yield a new connection" do
-    @cpool.hold {|conn| conn.should == :got_connection}
-  end
-
-  specify "a connection should be de-allocated after it has been used in #hold" do
-    @cpool.hold {}
-    @cpool.allocated.size.should == 0
-  end
-
-  specify "#hold should return the value of its block" do
-    @cpool.hold {:block_return}.should == :block_return
-  end
-
-  specify "#make_new should not make more than max_size connections" do
-    @cpool.send(:make_new).should == :got_connection
-    @cpool.send(:make_new).should == :got_connection
-    @cpool.send(:make_new).should == nil
-    @cpool.created_count.should == 2
-  end
-end
-
-class DummyConnection
-  @@value = 0
-  def initialize
-    @@value += 1
-  end
-  
-  def value
-    @@value
-  end
-end
-
-context "ConnectionPool#hold" do
-  setup do
-    @pool = Sequel::ConnectionPool.new {DummyConnection.new}
-  end
-  
-  specify "should pass the result of the connection maker proc to the supplied block" do
-    res = nil
-    @pool.hold {|c| res = c}
-    res.should be_a_kind_of(DummyConnection)
-    res.value.should == 1
-    @pool.hold {|c| res = c}
-    res.should be_a_kind_of(DummyConnection)
-    res.value.should == 1 # the connection maker is invoked only once
-  end
-  
-  specify "should be re-entrant by the same thread" do
-    cc = nil
-    @pool.hold {|c| @pool.hold {|c| @pool.hold {|c| cc = c}}}
-    cc.should be_a_kind_of(DummyConnection)
-  end
-  
-  specify "should catch exceptions and reraise them" do
-    proc {@pool.hold {|c| c.foobar}}.should raise_error(NoMethodError)
-  end
-  
-  specify "should handle Exception errors (normally not caught be rescue)" do
-    begin
-      @pool.hold {raise Exception}
-    rescue => e
-      e.should be_a_kind_of(RuntimeError)
-    end
-  end
-end
-
-context "ConnectionPool#connection_proc" do
-  setup do
-    @pool = Sequel::ConnectionPool.new
-  end
-  
-  specify "should be nil if no block is supplied to the pool" do
-    @pool.connection_proc.should be_nil
-    proc {@pool.hold {}}.should raise_error
-  end
-  
-  specify "should be mutable" do
-    @pool.connection_proc = proc {'herro'}
-    res = nil
-    proc {@pool.hold {|c| res = c}}.should_not raise_error
-    res.should == 'herro'
-  end
-end
-
-context "A connection pool with a max size of 1" do
-  setup do
-    @invoked_count = 0
-    @pool = Sequel::ConnectionPool.new(1) {@invoked_count += 1; 'herro'}
-  end
-  
-  specify "should let only one thread access the connection at any time" do
-    cc,c1, c2 = nil
-    
-    t1 = Thread.new {@pool.hold {|c| cc = c; c1 = c.dup; while c == 'herro';sleep 0.1;end}}
-    sleep 0.2
-    cc.should == 'herro'
-    c1.should == 'herro'
-    
-    t2 = Thread.new {@pool.hold {|c| c2 = c.dup; while c == 'hello';sleep 0.1;end}}
-    sleep 0.2
-    
-    # connection held by t1
-    t1.should be_alive
-    t2.should be_alive
-    
-    cc.should == 'herro'
-    c1.should == 'herro'
-    c2.should be_nil
-    
-    @pool.available_connections.should be_empty
-    @pool.allocated.should == {t1 => cc}
-    
-    cc.gsub!('rr', 'll')
-    sleep 0.5
-    
-    # connection held by t2
-    t1.should_not be_alive
-    t2.should be_alive
-
-    c2.should == 'hello'
-
-    @pool.available_connections.should be_empty
-    @pool.allocated.should == {t2 => cc}
-    
-    cc.gsub!('ll', 'rr')
-    sleep 0.5
-    
-    #connection released
-    t2.should_not be_alive
-    
-    cc.should == 'herro'
-    
-    @invoked_count.should == 1
-    @pool.size.should == 1
-    @pool.available_connections.should == [cc]
-    @pool.allocated.should be_empty
-  end
-  
-  specify "should let the same thread reenter #hold" do
-    c1, c2, c3 = nil
-    @pool.hold do |c|
-      c1 = c
-      @pool.hold do |c|
-        c2 = c
-        @pool.hold do |c|
-          c3 = c
-        end
-      end
-    end
-    c1.should == 'herro'
-    c2.should == 'herro'
-    c3.should == 'herro'
-    
-    @invoked_count.should == 1
-    @pool.size.should == 1
-    @pool.available_connections.size.should == 1
-    @pool.allocated.should be_empty
-  end
-end
-
-context "A connection pool with a max size of 5" do
-  setup do
-    @invoked_count = 0
-    @pool = Sequel::ConnectionPool.new(5) {@invoked_count += 1}
-  end
-  
-  specify "should let five threads simultaneously access separate connections" do
-    cc = {}
-    threads = []
-    stop = nil
-    
-    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.1;end}}; sleep 0.1}
-    sleep 0.2
-    threads.each {|t| t.should be_alive}
-    cc.size.should == 5
-    @invoked_count.should == 5
-    @pool.size.should == 5
-    @pool.available_connections.should be_empty
-    @pool.allocated.should == {threads[0] => 1, threads[1] => 2, threads[2] => 3,
-      threads[3] => 4, threads[4] => 5}
-    
-    threads[0].raise "your'e dead"
-    sleep 0.1
-    threads[3].raise "your'e dead too"
-    
-    sleep 0.1
-    
-    @pool.available_connections.should == [1, 4]
-    @pool.allocated.should == {threads[1] => 2, threads[2] => 3, threads[4] => 5}
-    
-    stop = true
-    sleep 0.2
-    
-    @pool.available_connections.size.should == 5
-    @pool.allocated.should be_empty
-  end
-  
-  specify "should block threads until a connection becomes available" do
-    cc = {}
-    threads = []
-    stop = nil
-    
-    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.1;end}}; sleep 0.1}
-    sleep 0.2
-    threads.each {|t| t.should be_alive}
-    @pool.available_connections.should be_empty
-
-    3.times {|i| threads << Thread.new {@pool.hold {|c| cc[i + 5] = c}}}
-    
-    sleep 0.2
-    threads[5].should be_alive
-    threads[6].should be_alive
-    threads[7].should be_alive
-    cc.size.should == 5
-    cc[5].should be_nil
-    cc[6].should be_nil
-    cc[7].should be_nil
-    
-    stop = true
-    sleep 0.3
-    
-    threads.each {|t| t.should_not be_alive}
-    
-    @pool.size.should == 5
-    @invoked_count.should == 5
-    @pool.available_connections.size.should == 5
-    @pool.allocated.should be_empty
-  end
-end
-
-context "ConnectionPool#disconnect" do
-  setup do
-    @count = 0
-    @pool = Sequel::ConnectionPool.new(5) {{:id => @count += 1}}
-  end
-  
-  specify "should invoke the given block for each available connection" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
-    while @pool.size < 5
-      sleep 0.2
-    end
-    stop = true
-    sleep 1
-    threads.each {|t| t.join}
-    
-    @pool.size.should == 5
-    @pool.available_connections.size.should == 5
-    @pool.available_connections.each {|c| c[:id].should_not be_nil}
-    conns = []
-    @pool.disconnect {|c| conns << c}
-    conns.size.should == 5
-  end
-  
-  specify "should remove all available connections" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
-    while @pool.size < 5
-      sleep 0.2
-    end
-    stop = true
-    sleep 1
-    threads.each {|t| t.join}
-    
-    @pool.size.should == 5
-    @pool.disconnect
-    @pool.size.should == 0
-  end
-
-  specify "should not touch connections in use" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
-    while @pool.size < 5
-      sleep 0.2
-    end
-    stop = true
-    sleep 1
-    threads.each {|t| t.join}
-    
-    @pool.size.should == 5
-    
-    @pool.hold do |conn|
-      @pool.available_connections.size.should == 4
-      @pool.available_connections.each {|c| c.should_not be(conn)}
-      conns = []
-      @pool.disconnect {|c| conns << c}
-      conns.size.should == 4
-    end
-    @pool.size.should == 1
-  end
-end
-
-context "SingleThreadedPool" do
-  setup do
-    @pool = Sequel::SingleThreadedPool.new {1234}
-  end
-  
-  specify "should provide a #hold method" do
-    conn = nil
-    @pool.hold {|c| conn = c}
-    conn.should == 1234
-  end
-  
-  specify "should provide a #disconnect method" do
-    @pool.hold {|c|}
-    @pool.conn.should == 1234
-    conn = nil
-    @pool.disconnect {|c| conn = c}
-    conn.should == 1234
-    @pool.conn.should be_nil
-  end
-end

data/spec/core_ext_spec.rb

@@ -1,67 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-context "Enumerable#send_each" do
-  specify "should send the supplied method to each item" do
-    a = ['abbc', 'bbccdd', 'hebtre']
-    a.send_each(:gsub!, 'b', '_')
-    a.should == ['a__c', '__ccdd', 'he_tre']
-  end
-end
-
-context "Range#interval" do
-  specify "should return the interval between the beginning and end of the range" do
-    (1..10).interval.should == 9
-    
-    r = rand(100000) + 10
-    t1 = Time.now; t2 = t1 + r
-    (t1..t2).interval.should == r
-  end
-end
-
-context "Numeric extensions" do
-  setup do
-    Sequel::NumericExtensions.enable
-  end
-  
-  specify "should support conversion of minutes to seconds" do
-    1.minute.should == 60
-    3.minutes.should == 180
-  end
-  
-  specify "should support conversion of hours to seconds" do
-    1.hour.should == 3600
-    3.hours.should == 3600 * 3
-  end
-
-  specify "should support conversion of days to seconds" do
-    1.day.should == 86400
-    3.days.should == 86400 * 3
-  end
-
-  specify "should support conversion of weeks to seconds" do
-    1.week.should == 86400 * 7
-    3.weeks.should == 86400 * 7 * 3
-  end
-  
-  specify "should provide #ago functionality" do
-    t1 = Time.now
-    t2 = 1.day.ago
-    t1.should > t2
-    ((t1 - t2).to_i - 86400).abs.should < 2
-    
-    t1 = Time.now
-    t2 = 1.day.before(t1)
-    t2.should == t1 - 1.day
-  end
-
-  specify "should provide #from_now functionality" do
-    t1 = Time.now
-    t2 = 1.day.from_now
-    t1.should < t2
-    ((t2 - t1).to_i - 86400).abs.should < 2
-    
-    t1 = Time.now
-    t2 = 1.day.since(t1)
-    t2.should == t1 + 1.day
-  end
-end

data/spec/core_sql_spec.rb

@@ -1,301 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-context "Array#to_sql" do
-  specify "should concatenate multiple lines into a single string" do
-    "SELECT * \r\nFROM items\r\n WHERE a = 1".split.to_sql. \
-      should == 'SELECT * FROM items WHERE a = 1'
-  end
-  
-  specify "should remove superfluous white space and line breaks" do
-    "\tSELECT * \n FROM items    ".split.to_sql. \
-      should == 'SELECT * FROM items'
-  end
-  
-  specify "should remove ANSI SQL comments" do
-    "SELECT *   --comment\r\n  FROM items\r\n  --comment".split.to_sql. \
-      should == 'SELECT * FROM items'
-  end
-  
-  specify "should remove C-style comments" do
-    "SELECT * \r\n /* comment comment\r\n comment\r\n FROM items */\r\n FROM items\r\n--comment".split.to_sql. \
-      should == 'SELECT * FROM items'
-  end
-end
-
-context "String#to_sql" do
-  specify "should concatenate multiple lines into a single string" do
-    "SELECT * \r\nFROM items\r\nWHERE a = 1".to_sql. \
-      should == 'SELECT * FROM items WHERE a = 1'
-  end
-  
-  specify "should remove superfluous white space and line breaks" do
-    "\tSELECT * \r\n FROM items    ".to_sql. \
-      should == 'SELECT * FROM items'
-  end
-  
-  specify "should remove ANSI SQL comments" do
-    "SELECT *   --comment \r\n FROM items\r\n  --comment".to_sql. \
-      should == 'SELECT * FROM items'
-  end
-  
-  specify "should remove C-style comments" do
-    "SELECT * \r\n/* comment comment\r\ncomment\r\nFROM items */\r\nFROM items\r\n--comment".to_sql. \
-      should == 'SELECT * FROM items'
-  end
-end
-
-context "String#lit" do
-  specify "should return an LiteralString object" do
-    'xyz'.lit.should be_a_kind_of(Sequel::LiteralString)
-    'xyz'.lit.to_s.should == 'xyz'
-  end
-  
-  specify "should inhibit string literalization" do
-    db = Sequel::Database.new
-    ds = db[:t]
-    
-    ds.update_sql(:stamp => "NOW()".lit).should == \
-      "UPDATE t SET stamp = NOW()"
-  end
-end
-
-context "String#expr" do
-  specify "should return an LiteralString object" do
-    'xyz'.expr.should be_a_kind_of(Sequel::LiteralString)
-    'xyz'.expr.to_s.should == 'xyz'
-  end
-
-  specify "should inhibit string literalization" do
-    db = Sequel::Database.new
-    ds = db[:t]
-    
-    ds.update_sql(:stamp => "NOW()".expr).should == \
-      "UPDATE t SET stamp = NOW()"
-  end
-end
-
-context "String#split_sql" do
-  specify "should split a string containing multiple statements" do
-    "DROP TABLE a; DROP TABLE c".split_sql.should == \
-      ['DROP TABLE a', 'DROP TABLE c']
-  end
-  
-  specify "should remove comments from the string" do
-    "DROP TABLE a;/* DROP TABLE b; DROP TABLE c;*/DROP TABLE d".split_sql.should == \
-      ['DROP TABLE a', 'DROP TABLE d']
-  end
-end
-
-context "#DESC/#desc" do
-  setup do
-    @ds = Sequel::Dataset.new(nil)
-  end
-  
-  specify "should format a DESC clause for a column ref" do
-    :test.DESC.to_s(@ds).should == 'test DESC'
-    :test.desc.to_s(@ds).should == 'test DESC'
-    
-    :items__price.DESC.to_s(@ds).should == 'items.price DESC'
-    :items__price.desc.to_s(@ds).should == 'items.price DESC'
-  end
-
-  specify "should format a DESC clause for a function" do
-    :avg[:test].DESC.to_s(@ds).should == 'avg(test) DESC'
-    :avg[:test].desc.to_s(@ds).should == 'avg(test) DESC'
-  end
-  
-  specify "should format a DESC clause for a literal value" do
-    1.DESC.to_s(@ds).should == '1 DESC'
-    'abc'.desc.to_s(@ds).should == "'abc' DESC"
-  end
-end
-
-context "#ASC/#asc" do
-  setup do
-    @ds = Sequel::Dataset.new(nil)
-  end
-  
-  specify "should format a ASC clause for a column ref" do
-    :test.ASC.to_s(@ds).should == 'test ASC'
-    :test.asc.to_s(@ds).should == 'test ASC'
-    
-    :items__price.ASC.to_s(@ds).should == 'items.price ASC'
-    :items__price.asc.to_s(@ds).should == 'items.price ASC'
-  end
-
-  specify "should format a ASC clause for a function" do
-    :avg[:test].ASC.to_s(@ds).should == 'avg(test) ASC'
-    :avg[:test].asc.to_s(@ds).should == 'avg(test) ASC'
-  end
-  
-  specify "should format a ASC clause for a literal value" do
-    1.ASC.to_s(@ds).should == '1 ASC'
-    'abc'.asc.to_s(@ds).should == "'abc' ASC"
-  end
-end
-
-context "#AS/#as" do
-  setup do
-    @ds = Sequel::Dataset.new(nil)
-  end
-  
-  specify "should format a AS clause for a column ref" do
-    :test.AS(:t).to_s(@ds).should == 'test AS t'
-    :test.as(:t).to_s(@ds).should == 'test AS t'
-    
-    :items__price.AS(:p).to_s(@ds).should == 'items.price AS p'
-    :items__price.as(:p).to_s(@ds).should == 'items.price AS p'
-  end
-
-  specify "should format a AS clause for a function" do
-    :avg[:test].AS(:avg).to_s(@ds).should == 'avg(test) AS avg'
-    :avg[:test].as(:avg).to_s(@ds).should == 'avg(test) AS avg'
-  end
-  
-  specify "should format a AS clause for a literal value" do
-    1.AS(:one).to_s(@ds).should == '1 AS one'
-    'abc'.as(:abc).to_s(@ds).should == "'abc' AS abc"
-  end
-end
-
-context "Column references" do
-  setup do
-    @c = Class.new(Sequel::Dataset) do
-      def quote_column_ref(c); "`#{c}`"; end
-    end
-    @ds = @c.new(nil)
-  end
-  
-  specify "should be quoted properly" do
-    @ds.literal(:xyz).should == "`xyz`"
-    @ds.literal(:xyz__abc).should == "xyz.`abc`"
-
-    @ds.literal(:xyz.as(:x)).should == "`xyz` AS `x`"
-    @ds.literal(:xyz__abc.as(:x)).should == "xyz.`abc` AS `x`"
-
-    @ds.literal(:xyz___x).should == "`xyz` AS `x`"
-    @ds.literal(:xyz__abc___x).should == "xyz.`abc` AS `x`"
-  end
-  
-  specify "should be quoted properly in SQL functions" do
-    @ds.literal(:avg[:xyz]).should == "avg(`xyz`)"
-    @ds.literal(:avg[:xyz, 1]).should == "avg(`xyz`, 1)"
-    @ds.literal(:avg[:xyz].as(:a)).should == "avg(`xyz`) AS `a`"
-  end
-
-  specify "should be quoted properly in ASC/DESC clauses" do
-    @ds.literal(:xyz.ASC).should == "`xyz` ASC"
-    @ds.literal(:avg[:xyz, 1].desc).should == "avg(`xyz`, 1) DESC"
-  end
-  
-  specify "should be quoted properly in a cast function" do
-    @ds.literal(:x.cast_as(:integer)).should == "cast(`x` AS integer)"
-    @ds.literal(:x__y.cast_as(:varchar[20])).should == "cast(x.`y` AS varchar(20))"
-  end
-end
-
-context "Symbol#ALL/#all" do
-  setup do
-    @ds = Sequel::Dataset.new(nil)
-  end
-  
-  specify "should format a qualified wildcard" do
-    :xyz.ALL.to_s(@ds).should == 'xyz.*'
-    :abc.all.to_s(@ds).should == 'abc.*'
-  end
-end
-
-context "Symbol#to_column_ref" do
-  setup do
-    @ds = Sequel::Dataset.new(nil)
-  end
-  
-  specify "should convert qualified symbol notation into dot notation" do
-    :abc__def.to_column_ref(@ds).should == 'abc.def'
-  end
-  
-  specify "should convert AS symbol notation into SQL AS notation" do
-    :xyz___x.to_column_ref(@ds).should == 'xyz AS x'
-    :abc__def___x.to_column_ref(@ds).should == 'abc.def AS x'
-  end
-  
-  specify "should support names with digits" do
-    :abc2.to_column_ref(@ds).should == 'abc2'
-    :xx__yy3.to_column_ref(@ds).should == 'xx.yy3'
-    :ab34__temp3_4ax.to_column_ref(@ds).should == 'ab34.temp3_4ax'
-    :x1___y2.to_column_ref(@ds).should == 'x1 AS y2'
-    :abc2__def3___ggg4.to_column_ref(@ds).should == 'abc2.def3 AS ggg4'
-  end
-  
-  specify "should support upper case and lower case" do
-    :ABC.to_column_ref(@ds).should == 'ABC'
-    :Zvashtoy__aBcD.to_column_ref(@ds).should == 'Zvashtoy.aBcD'
-  end
-end
-
-context "Symbol" do
-  setup do
-    @ds = Sequel::Dataset.new(nil)
-  end
-  
-  specify "should support MIN for specifying min function" do
-    :abc__def.MIN.to_s(@ds).should == 'min(abc.def)'
-  end
-
-  specify "should support MAX for specifying max function" do
-    :abc__def.MAX.to_s(@ds).should == 'max(abc.def)'
-  end
-
-  specify "should support SUM for specifying sum function" do
-    :abc__def.SUM.to_s(@ds).should == 'sum(abc.def)'
-  end
-
-  specify "should support AVG for specifying avg function" do
-    :abc__def.AVG.to_s(@ds).should == 'avg(abc.def)'
-  end
-  
-  specify "should support COUNT for specifying count function" do
-    :abc__def.COUNT.to_s(@ds).should == 'count(abc.def)'
-  end
-  
-  specify "should support any other function using upper case letters" do
-    :abc__def.DADA.to_s(@ds).should == 'dada(abc.def)'
-  end
-  
-  specify "should support upper case outer functions" do
-    :COUNT['1'].to_s(@ds).should == "COUNT('1')"
-  end
-  
-  specify "should inhibit string literalization" do
-    db = Sequel::Database.new
-    ds = db[:t]
-    ds.select(:COUNT['1']).sql.should == "SELECT COUNT('1') FROM t"
-  end
-  
-  specify "should support cast function" do
-    :abc.cast_as(:integer).to_s(@ds).should == "cast(abc AS integer)"
-  end
-  
-  specify "should raise NoMethodError for non-uppercase invalid methods" do
-    proc {:abc.dfaxs}.should raise_error(NoMethodError)
-  end
-  
-  specify "should support subscript access using | operator" do
-    (:abc|1).to_s(@ds).should == 'abc[1]'
-    (:abc|[1]).to_s(@ds).should == 'abc[1]'
-    (:abc|[1, 2]).to_s(@ds).should == 'abc[1, 2]'
-    (:abc|1|2).to_s(@ds).should == 'abc[1, 2]'
-  end
-end
-
-context "String#to_time" do
-  specify "should convert the string into a Time object" do
-    "2007-07-11".to_time.should == Time.parse("2007-07-11")
-    "06:30".to_time.should == Time.parse("06:30")
-  end
-  
-  specify "should raise Error::InvalidValue for an invalid time" do
-    proc {'0000-00-00'.to_time}.should raise_error(Sequel::Error::InvalidValue)
-  end
-end
-