sequel 0.1.7 → 0.1.8

data/spec/connection_pool_spec.rb

@@ -0,0 +1,270 @@
+require File.join(File.dirname(__FILE__), '../lib/sequel')
+
+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.2
+    
+    # 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.2
+    
+    #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 simulatneously 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

data/spec/core_ext_spec.rb

@@ -0,0 +1,127 @@
+require File.join(File.dirname(__FILE__), '../lib/sequel')
+
+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 "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#expr" do
+  specify "should return an ExpressionString object" do
+    'xyz'.expr.should be_a_kind_of(Sequel::ExpressionString)
+    'xyz'.expr.to_s.should == 'xyz'
+  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 "Symbol#DESC" do
+  specify "should append the symbol with DESC" do
+    :hey.DESC.should == 'hey DESC'
+  end
+  
+  specify "should support qualified symbol notation" do
+    :abc__def.DESC.should == 'abc.def DESC'
+  end
+end
+
+context "Symbol#AS" do
+  specify "should append an AS clause" do
+    :hey.AS(:ho).should == 'hey AS ho'
+  end
+  
+  specify "should support qualified symbol notation" do
+    :abc__def.AS(:x).should == 'abc.def AS x'
+  end
+end
+
+context "Symbol#ALL" do
+  specify "should format a qualified wildcard" do
+    :xyz.ALL.should == 'xyz.*'
+  end
+end
+
+context "Symbol#to_field_name" do
+  specify "should convert qualified symbol notation into dot notation" do
+    :abc__def.to_field_name.should == 'abc.def'
+  end
+  
+  specify "should convert AS symbol notation into SQL AS notation" do
+    :xyz___x.to_field_name.should == 'xyz AS x'
+    :abc__def___x.to_field_name.should == 'abc.def AS x'
+  end
+end
+
+context "Symbol" do
+  specify "should support MIN for specifying min function" do
+    :abc__def.MIN.should == 'min(abc.def)'
+  end
+
+  specify "should support MAX for specifying max function" do
+    :abc__def.MAX.should == 'max(abc.def)'
+  end
+
+  specify "should support SUM for specifying sum function" do
+    :abc__def.SUM.should == 'sum(abc.def)'
+  end
+
+  specify "should support AVG for specifying avg function" do
+    :abc__def.AVG.should == 'avg(abc.def)'
+  end
+end

data/spec/database_spec.rb

@@ -0,0 +1,366 @@
+require File.join(File.dirname(__FILE__), '../lib/sequel')
+
+context "A new Database" do
+  setup do
+    @db = Sequel::Database.new(1 => 2, :logger => 3)
+  end
+  
+  specify "should receive options" do
+    @db.opts.should == {1 => 2, :logger => 3}  
+  end
+  
+  specify "should set the logger from opts[:logger]" do
+    @db.logger.should == 3
+  end
+  
+  specify "should create a connection pool" do
+    @db.pool.should be_a_kind_of(Sequel::ConnectionPool)
+    @db.pool.max_size.should == 4
+    
+    Sequel::Database.new(:max_connections => 10).pool.max_size.should == 10
+  end
+  
+  specify "should pass the supplied block to the connection pool" do
+    cc = nil
+    d = Sequel::Database.new {1234}
+    d.synchronize {|c| cc = c}
+    cc.should == 1234
+  end
+end
+
+context "Database#connect" do
+  specify "should raise NotImplementedError" do
+    proc {Sequel::Database.new.connect}.should raise_error(NotImplementedError)
+  end
+end
+
+context "Database#uri" do
+  setup do
+    @c = Class.new(Sequel::Database) do
+      set_adapter_scheme :mau
+    end
+    
+    @db = Sequel('mau://user:pass@localhost:9876/maumau')
+  end
+  
+  specify "should return the connection URI for the database" do
+    @db.uri.should == 'mau://user:pass@localhost:9876/maumau'
+  end
+end
+
+context "Database.adapter_scheme" do
+  specify "should return the database schema" do
+    Sequel::Database.adapter_scheme.should be_nil
+
+    @c = Class.new(Sequel::Database) do
+      set_adapter_scheme :mau
+    end
+    
+    @c.adapter_scheme.should == :mau
+  end
+end
+
+context "Database#dataset" do
+  setup do
+    @db = Sequel::Database.new
+    @ds = @db.dataset
+  end
+  
+  specify "should provide a blank dataset through #dataset" do
+    @ds.should be_a_kind_of(Sequel::Dataset)
+    @ds.opts.should == {}
+    @ds.db.should be(@db)
+  end
+  
+  specify "should provide a #from dataset" do
+    d = @db.from(:mau)
+    d.should be_a_kind_of(Sequel::Dataset)
+    d.sql.should == 'SELECT * FROM mau'
+    
+    e = @db[:miu]
+    e.should be_a_kind_of(Sequel::Dataset)
+    e.sql.should == 'SELECT * FROM miu'
+  end
+  
+  specify "should provide a #select dataset" do
+    d = @db.select(:a, :b, :c).from(:mau)
+    d.should be_a_kind_of(Sequel::Dataset)
+    d.sql.should == 'SELECT a, b, c FROM mau'
+  end
+end
+
+context "Database#execute" do
+  specify "should raise NotImplementedError" do
+    proc {Sequel::Database.new.execute('blah blah')}.should raise_error(NotImplementedError)
+    proc {Sequel::Database.new << 'blah blah'}.should raise_error(NotImplementedError)
+  end
+end
+
+context "Database#<<" do
+  setup do
+    @c = Class.new(Sequel::Database) do
+      define_method(:execute) {|sql| sql}
+    end
+    @db = @c.new({})
+  end
+  
+  specify "should pass the supplied sql to #execute" do
+    (@db << "DELETE FROM items").should == "DELETE FROM items"
+  end
+  
+  specify "should accept an array and convert it to SQL" do
+    a = %[
+      --
+      CREATE TABLE items (a integer, /*b integer*/
+        b text, c integer);
+      DROP TABLE old_items;
+    ].split($/)
+    (@db << a).should == 
+      "CREATE TABLE items (a integer, b text, c integer); DROP TABLE old_items;"
+  end
+  
+  specify "should remove comments and whitespace from strings as well" do
+    s = %[
+      --
+      CREATE TABLE items (a integer, /*b integer*/
+        b text, c integer); \r\n
+      DROP TABLE old_items;
+    ]
+    (@db << s).should == 
+      "CREATE TABLE items (a integer, b text, c integer); DROP TABLE old_items;"
+  end
+end
+
+context "Database#synchronize" do
+  setup do
+    @db = Sequel::Database.new(:max_connections => 1)
+    @db.pool.connection_proc = proc {12345}
+  end
+  
+  specify "should wrap the supplied block in pool.hold" do
+    stop = false
+    c1, c2 = nil
+    t1 = Thread.new {@db.synchronize {|c| c1 = c; while !stop;sleep 0.1;end}}
+    while !c1;end
+    c1.should == 12345
+    t2 = Thread.new {@db.synchronize {|c| c2 = c}}
+    sleep 0.2
+    @db.pool.available_connections.should be_empty
+    c2.should be_nil
+    stop = true
+    t1.join
+    sleep 0.1
+    c2.should == 12345
+    t2.join
+  end
+end
+
+context "Database#test_connection" do
+  setup do
+    @db = Sequel::Database.new
+    @test = nil
+    @db.pool.connection_proc = proc {@test = rand(100)}
+  end
+  
+  specify "should call pool#hold" do
+    @db.test_connection
+    @test.should_not be_nil
+  end
+  
+  specify "should return true if successful" do
+    @db.test_connection.should be_true
+  end
+end
+
+class DummyDataset < Sequel::Dataset
+  def first
+    raise if @opts[:from] == [:a]
+    true
+  end
+end
+
+class DummyDatabase < Sequel::Database
+  attr_reader :sql
+  def execute(sql); @sql = sql; end
+
+  def dataset
+    DummyDataset.new(self)
+  end
+end
+
+context "Database#create_table" do
+  setup do
+    @db = DummyDatabase.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.create_table :test do
+      primary_key :id, :integer, :null => false
+      column :name, :text
+      index :name, :unique => true
+    end
+    @db.sql.should == 
+      'CREATE TABLE test (id integer NOT NULL PRIMARY KEY, name text);CREATE UNIQUE INDEX test_name_index ON test (name);'
+  end
+end
+
+class Dummy2Database < Sequel::Database
+  attr_reader :sql
+  def execute(sql); @sql = sql; end
+  def transaction; yield; end
+end
+
+context "Database#drop_table" do
+  setup do
+    @db = Dummy2Database.new
+  end
+  
+  specify "should construct proper SQL" do
+    @db.drop_table :test
+    @db.sql.should == 
+      'DROP TABLE test CASCADE;'
+  end
+  
+  specify "should accept multiple table names" do
+    @db.drop_table :a, :bb, :ccc
+    @db.sql.should ==
+      'DROP TABLE a CASCADE;DROP TABLE bb CASCADE;DROP TABLE ccc CASCADE;'
+  end
+end
+
+context "Database#table_exists?" do
+  setup do
+    @db = DummyDatabase.new
+    @db.stub!(:tables).and_return([:a, :b])
+    @db2 = DummyDatabase.new
+    Sequel::Dataset.stub!(:first).and_return(nil)
+  end
+  
+  specify "should use Database#tables if available" do
+    @db.table_exists?(:a).should be_true
+    @db.table_exists?(:b).should be_true
+    @db.table_exists?(:c).should be_false
+  end
+  
+  specify "should otherise try to select the first record from the table's dataset" do
+    @db2.table_exists?(:a).should be_false
+    @db2.table_exists?(:b).should be_true
+  end
+end
+
+
+class Dummy3Database < Sequel::Database
+  attr_reader :sql, :transactions
+  def execute(sql); @sql ||= []; @sql << sql; end
+
+  class DummyConnection
+    def initialize(db); @db = db; end
+    def execute(sql); @db.execute(sql); end
+  end
+end
+
+context "Database#transaction" do
+  setup do
+    @db = Dummy3Database.new
+    @db.pool.connection_proc = proc {Dummy3Database::DummyConnection.new(@db)}
+  end
+  
+  specify "should wrap the supplied block with BEGIN + COMMIT statements" do
+    @db.transaction {@db.execute 'DROP TABLE test;'}
+    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
+  end
+  
+  specify "should issue ROLLBACK if an exception is raised, and re-raise" do
+    @db.transaction {@db.execute 'DROP TABLE test;'; raise RuntimeError} rescue nil
+    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'ROLLBACK']
+    
+    proc {@db.transaction {raise RuntimeError}}.should raise_error(RuntimeError)
+  end
+  
+  specify "should be re-entrant" do
+    stop = false
+    cc = nil
+    t = Thread.new do
+      @db.transaction {@db.transaction {@db.transaction {|c|
+        cc = c
+        while !stop; sleep 0.1; end
+      }}}
+    end
+    while cc.nil?; sleep 0.1; end
+    cc.should be_a_kind_of(Dummy3Database::DummyConnection)
+    @db.transactions.should == [t]
+    stop = true
+    t.join
+    @db.transactions.should be_empty
+  end
+end
+
+class Sequel::Database
+  def self.get_adapters; @@adapters; end
+end
+
+context "A Database adapter with a scheme" do
+  setup do
+    class CCC < Sequel::Database
+      set_adapter_scheme :ccc
+    end
+  end
+
+  specify "should be registered in adapters" do
+    Sequel::Database.get_adapters[:ccc].should == CCC
+  end
+  
+  specify "should be instantiated when its scheme is specified" do
+    c = Sequel::Database.connect('ccc://localhost/db')
+    c.should be_a_kind_of(CCC)
+    c.opts[:host].should == 'localhost'
+    c.opts[:database].should == 'db'
+  end
+  
+  specify "should be accessible through Sequel.connect" do
+    c = Sequel.connect 'ccc://localhost/db'
+    c.should be_a_kind_of(CCC)
+    c.opts[:host].should == 'localhost'
+    c.opts[:database].should == 'db'
+  end
+
+  specify "should be accessible through Sequel.open" do
+    c = Sequel.open 'ccc://localhost/db'
+    c.should be_a_kind_of(CCC)
+    c.opts[:host].should == 'localhost'
+    c.opts[:database].should == 'db'
+  end
+
+  specify "should be accessible through Sequel()" do
+    c = Sequel('ccc://localhost/db')
+    c.should be_a_kind_of(CCC)
+    c.opts[:host].should == 'localhost'
+    c.opts[:database].should == 'db'
+  end
+
+end
+
+context "An unknown database scheme" do
+  specify "should raise an exception in Sequel::Database.connect" do
+    proc {Sequel::Database.connect('ddd://localhost/db')}.should raise_error(SequelError)
+  end
+
+  specify "should raise an exception in Sequel.connect" do
+    proc {Sequel.connect('ddd://localhost/db')}.should raise_error(SequelError)
+  end
+
+  specify "should raise an exception in Sequel.open" do
+    proc {Sequel.open('ddd://localhost/db')}.should raise_error(SequelError)
+  end
+end
+
+context "Database#uri_to_options" do
+  specify "should convert a URI to an options hash" do
+    h = Sequel::Database.uri_to_options(URI.parse('ttt://uuu:ppp@192.168.60.1:1234/blah'))
+    h[:user].should == 'uuu'
+    h[:password].should == 'ppp'
+    h[:host].should == '192.168.60.1'
+    h[:port].should == 1234
+    h[:database].should == 'blah'
+  end
+end