sequel 3.21.0 → 3.39.0

data/spec/extensions/many_to_one_pk_lookup_spec.rb

@@ -0,0 +1,140 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::ManyToOnePkLookup" do
+  before do
+    class ::LookupModel < ::Sequel::Model
+      plugin :many_to_one_pk_lookup
+      columns :id, :caching_model_id, :caching_model_id2
+      many_to_one :caching_model
+      many_to_one :caching_model2, :key=>[:caching_model_id, :caching_model_id2], :class=>:CachingModel
+    end
+    @c = LookupModel
+
+    class ::CachingModel < Sequel::Model
+      columns :id, :id2
+    end
+    @cc = CachingModel
+
+    @db = MODEL_DB
+  end
+  after do
+    Object.send(:remove_const, :CachingModel)
+    Object.send(:remove_const, :LookupModel)
+  end
+
+  shared_examples_for "many_to_one_pk_lookup with composite keys" do
+    it "should use a simple primary key lookup when retrieving many_to_one associated records" do
+      @db.sqls.should == []
+      @c.load(:id=>3, :caching_model_id=>1, :caching_model_id2=>2).caching_model2.should equal(@cm12)
+      @c.load(:id=>3, :caching_model_id=>2, :caching_model_id2=>1).caching_model2.should equal(@cm21)
+      @db.sqls.should == []
+      @c.load(:id=>4, :caching_model_id=>2, :caching_model_id2=>2).caching_model2
+      @db.sqls.should_not == []
+    end
+  end
+
+  shared_examples_for "many_to_one_pk_lookup" do
+    it "should use a simple primary key lookup when retrieving many_to_one associated records via a composite key" do
+      @cc.set_primary_key([:id, :id2])
+      @db.sqls.should == []
+      @c.load(:id=>3, :caching_model_id=>1).caching_model.should equal(@cm1)
+      @c.load(:id=>4, :caching_model_id=>2).caching_model.should equal(@cm2)
+      @db.sqls.should == []
+      @c.load(:id=>4, :caching_model_id=>3).caching_model
+      @db.sqls.should_not == []
+    end
+
+    it "should not use a simple primary key lookup if the assocation has a nil :key option" do
+      @c.many_to_one :caching_model, :key=>nil, :dataset=>proc{CachingModel.filter(:caching_model_id=>caching_model_id)}
+      @c.load(:id=>3, :caching_model_id=>1).caching_model
+      @db.sqls.should_not == []
+    end
+
+    it "should not use a simple primary key lookup if the assocation has a nil :key option" do
+      @c.many_to_one :caching_model, :many_to_one_pk_lookup=>false
+      @c.load(:id=>3, :caching_model_id=>1).caching_model
+      @db.sqls.should_not == []
+    end
+
+    it "should not use a simple primary key lookup if the assocation's :primary_key option doesn't match the primary key of the associated class" do
+      @c.many_to_one :caching_model, :primary_key=>:id2
+      @c.load(:id=>3, :caching_model_id=>1).caching_model
+      @db.sqls.should_not == []
+    end
+
+    it "should not use a simple primary key lookup if the prepared_statements_associations method is being used" do
+      c2 = Class.new(Sequel::Model(:not_caching_model))
+      c2.dataset._fetch = {:id=>1}
+      c = Class.new(Sequel::Model(:lookup_model))
+      c.class_eval do
+        plugin :prepared_statements_associations
+        plugin :many_to_one_pk_lookup
+        columns :id, :caching_model_id
+        many_to_one :caching_model, :class=>c2
+      end
+      c.load(:id=>3, :caching_model_id=>1).caching_model.should == c2.load(:id=>1)
+      @db.sqls.should_not == []
+    end
+
+    it "should use a simple primary key lookup if the prepared_statements_associations method is being used but associated model also uses caching" do
+      c = Class.new(Sequel::Model(:lookup_model))
+      c.class_eval do
+        plugin :prepared_statements_associations
+        plugin :many_to_one_pk_lookup
+        columns :id, :caching_model_id
+        many_to_one :caching_model
+      end
+      c.load(:id=>3, :caching_model_id=>1).caching_model.should equal(@cm1)
+      @db.sqls.should == []
+    end
+  end
+
+  describe "With caching plugin" do
+    before do
+      @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
+      
+      @cc.plugin :caching, @cache
+      @cc.dataset._fetch = {:id=>1}
+      @cm1 = @cc[1]
+      @cm2 = @cc[2]
+      @cm12 = @cc[1, 2]
+      @cm21 = @cc[2, 1]
+
+      @db.reset
+    end
+
+    it_should_behave_like "many_to_one_pk_lookup"
+    it_should_behave_like "many_to_one_pk_lookup with composite keys"
+  end
+
+  describe "With static_cache plugin with single key" do
+    before do
+      @cc.dataset._fetch = [{:id=>1}, {:id=>2}]
+      @cc.plugin :static_cache
+      @cm1 = @cc[1]
+      @cm2 = @cc[2]
+      @db.reset
+    end
+
+    it_should_behave_like "many_to_one_pk_lookup"
+  end
+
+  describe "With static_cache plugin with composite key" do
+    before do
+      @cc.set_primary_key([:id, :id2])
+      @cc.dataset._fetch = [{:id=>1, :id2=>2}, {:id=>2, :id2=>1}]
+      @cc.plugin :static_cache
+      @cm12 = @cc[[1, 2]]
+      @cm21 = @cc[[2, 1]]
+      @db.reset
+    end
+
+    it_should_behave_like "many_to_one_pk_lookup with composite keys"
+  end
+end

data/spec/extensions/migration_spec.rb

@@ -129,6 +129,7 @@ describe "Reversible Migrations with Sequel.migration{change{}}" do
         rename_column :e, :g
       end
       create_view(:c, 'SELECT * FROM b')
+      create_join_table(:cat_id=>:cats, :dog_id=>:dogs)
     end
   end
   
@@ -150,13 +151,16 @@ describe "Reversible Migrations with Sequel.migration{change{}}" do
         [:add_spatial_index, :e, {:name=>"e_s"}],
         [:rename_column, :e, :g]]
       ],
-      [:create_view, :c, "SELECT * FROM b"]]
+      [:create_view, :c, "SELECT * FROM b"],
+      [:create_join_table, {:cat_id=>:cats, :dog_id=>:dogs}]]
   end
 
   specify "should execute down with reversing actions in reverse order" do
     p = @p
     Sequel.migration{change(&p)}.apply(@db, :down)
-    @db.actions.should == [[:drop_view, :c],
+    @db.actions.should == [
+      [:drop_join_table, {:cat_id=>:cats, :dog_id=>:dogs}],
+      [:drop_view, :c],
       [:alter_table, [
         [:rename_column, :g, :e],
         [:drop_index, :e, {:name=>"e_s"}],
@@ -195,14 +199,14 @@ end
 
 describe "Sequel::IntegerMigrator" do
   before do
-    dbc = Class.new(MockDatabase) do
+    dbc = Class.new(Sequel::Mock::Database) do
       attr_reader :drops, :tables_created, :columns_created, :versions
       def initialize(*args)
         super
         @drops = []
         @tables_created = []
         @columns_created = []
-        @versions = {}
+        @versions = Hash.new{|h,k| h[k.to_sym]}
       end
   
       def version; versions.values.first || 0; end
@@ -211,8 +215,8 @@ describe "Sequel::IntegerMigrator" do
 
       def create_table(name, opts={}, &block)
         super
-        @columns_created << / \(?(\w+) integer.*\)?\z/.match(sqls.last)[1].to_sym
-        @tables_created << name
+        @columns_created << / \(?(\w+) integer.*\)?\z/.match(@sqls.last)[1].to_sym
+        @tables_created << name.to_sym
       end
       
       def dataset(opts={})
@@ -220,15 +224,15 @@ describe "Sequel::IntegerMigrator" do
         ds.extend(Module.new do
           def count; 1; end
           def columns; db.columns_created end
-          def insert(h); db.versions.merge!(h); db.sqls << insert_sql(h) end
-          def update(h); db.versions.merge!(h); db.sqls << update_sql(h) end
+          def insert(h); db.versions.merge!(h); db.run insert_sql(h) end
+          def update(h); db.versions.merge!(h); db.run update_sql(h) end
           def fetch_rows(sql); db.execute(sql); yield(db.versions) unless db.versions.empty? end
         end)
         ds
       end
 
       def table_exists?(name)
-        @tables_created.include?(name)
+        @tables_created.include?(name.to_sym)
       end
     end
     @db = dbc.new
@@ -250,7 +254,7 @@ describe "Sequel::IntegerMigrator" do
 
   specify "should add a column name if it doesn't already exist in the schema_info table" do
     @db.create_table(:schema_info){Integer :v}
-    @db.should_receive(:alter_table).with(:schema_info)
+    @db.should_receive(:alter_table).with('schema_info')
     Sequel::Migrator.apply(@db, @dirname)
   end
 
@@ -273,8 +277,20 @@ describe "Sequel::IntegerMigrator" do
     @db.creates.should == [1111, 2222, 3333]
     @db.version.should == 3
     @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.should == [1, 2, 3]
+  end
+  
+  specify "should be able to tell whether there are outstanding migrations" do
+    Sequel::Migrator.is_current?(@db, @dirname).should be_false
+    Sequel::Migrator.apply(@db, @dirname)
+    Sequel::Migrator.is_current?(@db, @dirname).should be_true
   end 
 
+  specify "should have #check_current raise an exception if the migrator is not current" do
+    proc{Sequel::Migrator.check_current(@db, @dirname)}.should raise_error(Sequel::Migrator::NotCurrentError)
+    Sequel::Migrator.apply(@db, @dirname)
+    proc{Sequel::Migrator.check_current(@db, @dirname)}.should_not raise_error
+  end
+
   specify "should apply migrations correctly in the up direction with target" do
     Sequel::Migrator.apply(@db, @dirname, 2)
     @db.creates.should == [1111, 2222]
@@ -311,64 +327,106 @@ describe "Sequel::IntegerMigrator" do
     Sequel::Migrator.apply(@db, @dirname, 0).should == 0
     Sequel::Migrator.apply(@db, @dirname).should == 3
   end
+
+  specify "should use IntegerMigrator if IntegerMigrator.apply called, even for timestamped migration directory" do
+    proc{Sequel::IntegerMigrator.apply(@db, "spec/files/timestamped_migrations")}.should raise_error(Sequel::Migrator::Error)
+  end
+
+  specify "should not use transactions by default" do
+    Sequel::Migrator.apply(@db, "spec/files/transaction_unspecified_migrations")
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer DEFAULT 0 NOT NULL)", "SELECT 1 AS one FROM schema_info LIMIT 1", "INSERT INTO schema_info (version) VALUES (0)", "SELECT version FROM schema_info LIMIT 1", "CREATE TABLE sm11111 (smc1 integer)", "UPDATE schema_info SET version = 1", "CREATE TABLE sm (smc1 integer)", "UPDATE schema_info SET version = 2"]
+  end
+
+  specify "should use transactions by default if the database supports transactional ddl" do
+    @db.meta_def(:supports_transactional_ddl?){true}
+    Sequel::Migrator.apply(@db, "spec/files/transaction_unspecified_migrations")
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer DEFAULT 0 NOT NULL)", "SELECT 1 AS one FROM schema_info LIMIT 1", "INSERT INTO schema_info (version) VALUES (0)", "SELECT version FROM schema_info LIMIT 1", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "UPDATE schema_info SET version = 1", "COMMIT", "BEGIN", "CREATE TABLE sm (smc1 integer)", "UPDATE schema_info SET version = 2", "COMMIT"]
+  end
+
+  specify "should respect transaction use on a per migration basis" do
+    @db.meta_def(:supports_transactional_ddl?){true}
+    Sequel::Migrator.apply(@db, "spec/files/transaction_specified_migrations")
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer DEFAULT 0 NOT NULL)", "SELECT 1 AS one FROM schema_info LIMIT 1", "INSERT INTO schema_info (version) VALUES (0)", "SELECT version FROM schema_info LIMIT 1", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "UPDATE schema_info SET version = 1", "COMMIT", "CREATE TABLE sm (smc1 integer)", "UPDATE schema_info SET version = 2"]
+  end
+
+  specify "should force transactions if enabled in the migrator" do
+    Sequel::Migrator.run(@db, "spec/files/transaction_specified_migrations", :use_transactions=>true)
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer DEFAULT 0 NOT NULL)", "SELECT 1 AS one FROM schema_info LIMIT 1", "INSERT INTO schema_info (version) VALUES (0)", "SELECT version FROM schema_info LIMIT 1", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "UPDATE schema_info SET version = 1", "COMMIT", "BEGIN", "CREATE TABLE sm (smc1 integer)", "UPDATE schema_info SET version = 2", "COMMIT"]
+  end
+
+  specify "should not use transactions if disabled in the migrator" do
+    Sequel::Migrator.run(@db, "spec/files/transaction_unspecified_migrations", :use_transactions=>false)
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer DEFAULT 0 NOT NULL)", "SELECT 1 AS one FROM schema_info LIMIT 1", "INSERT INTO schema_info (version) VALUES (0)", "SELECT version FROM schema_info LIMIT 1", "CREATE TABLE sm11111 (smc1 integer)", "UPDATE schema_info SET version = 1", "CREATE TABLE sm (smc1 integer)", "UPDATE schema_info SET version = 2"]
+  end
 end
 
 describe "Sequel::TimestampMigrator" do
   before do
-    $sequel_migration_version = 0
-    $sequel_migration_files = []
-    @dsc = dsc = Class.new(MockDataset) do
+    sequel_migration_version = 0
+    @dsc = dsc = Class.new(Sequel::Mock::Dataset) do
+      self::FILES =[]
+      define_method(:sequel_migration_version){sequel_migration_version}
+      define_method(:sequel_migration_version=){|v| sequel_migration_version = v}
+
       def columns
+        super
         case opts[:from].first
-        when :schema_info
+        when :schema_info, 'schema_info'
           [:version]
-        when :schema_migrations
+        when :schema_migrations, 'schema_migrations'
           [:filename]
-        when :sm
+        when :sm, 'sm'
           [:fn]
         end
       end
 
       def fetch_rows(sql)
+        super
         case opts[:from].first
-        when :schema_info
-          yield({:version=>$sequel_migration_version})
-        when :schema_migrations
-          $sequel_migration_files.sort.each{|f| yield(:filename=>f)}
-        when :sm
-          $sequel_migration_files.sort.each{|f| yield(:fn=>f)}
+        when :schema_info, 'schema_info'
+          yield({:version=>sequel_migration_version})
+        when :schema_migrations, 'schema_migrations'
+          self.class::FILES.sort.each{|f| yield(:filename=>f)}
+        when :sm, 'sm'
+          self.class::FILES.sort.each{|f| yield(:fn=>f)}
         end
       end
 
       def insert(h={})
+        super
         case opts[:from].first
-        when :schema_info
-          $sequel_migration_version = h.values.first
-        when :schema_migrations, :sm
-          $sequel_migration_files << h.values.first
+        when :schema_info, 'schema_info'
+          self.sequel_migration_version = h.values.first
+        when :schema_migrations, :sm, 'schema_migrations', 'sm'
+          self.class::FILES << h.values.first
         end
       end
 
       def update(h={})
+        super
         case opts[:from].first
-        when :schema_info
-          $sequel_migration_version = h.values.first
+        when :schema_info, 'schema_info'
+          self.sequel_migration_version = h.values.first
         end
       end
 
       def delete
+        super
         case opts[:from].first
-        when :schema_migrations, :sm
-          $sequel_migration_files.delete(opts[:where].args.last)
+        when :schema_migrations, :sm, 'schema_migrations', 'sm'
+          self.class::FILES.delete(opts[:where].args.last)
         end
       end
     end
-    dbc = Class.new(MockDatabase) do
-      tables = {}
+    dbc = Class.new(Sequel::Mock::Database) do
+      self::Tables = tables= {}
       define_method(:dataset){|*a| dsc.new(self, *a)}
-      define_method(:create_table){|name, *args| tables[name] = true}
-      define_method(:drop_table){|*names| names.each{|n| tables.delete(n)}}
-      define_method(:table_exists?){|name| tables.has_key?(name)}
+      def create_table(name, *args, &block)
+        super
+        self.class::Tables[name.to_sym] = true
+      end
+      define_method(:drop_table){|*names| super(*names); names.each{|n| tables.delete(n.to_sym)}}
+      define_method(:table_exists?){|name| super(name); tables.has_key?(name.to_sym)}
     end
     @db = dbc.new
     @m = Sequel::Migrator
@@ -402,6 +460,22 @@ describe "Sequel::TimestampMigrator" do
     @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb'
   end
 
+  specify "should not be current when there are migrations to apply" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    @m.is_current?(@db, @dir).should be_true
+    @dir = 'spec/files/interleaved_timestamped_migrations'
+    @m.is_current?(@db, @dir).should be_false
+  end
+
+  specify "should raise an exception if the migrator is not current" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    proc{@m.check_current(@db, @dir)}.should_not raise_error
+    @dir = 'spec/files/interleaved_timestamped_migrations'
+    proc{@m.check_current(@db, @dir)}.should raise_error(Sequel::Migrator::NotCurrentError)
+  end
+
   specify "should apply all missing files when migrating up" do
     @dir = 'spec/files/timestamped_migrations'
     @m.apply(@db, @dir)
@@ -556,4 +630,35 @@ describe "Sequel::TimestampMigrator" do
     @m.apply(@db, @dir, 0).should == nil
     @m.apply(@db, @dir).should == nil
   end
+
+  specify "should use TimestampMigrator if TimestampMigrator.apply is called even for integer migrations directory" do
+    Sequel::TimestampMigrator.apply(@db, "spec/files/integer_migrations")
+    @db.sqls.should == ["SELECT NULL FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "CREATE TABLE sm1111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_sessions.rb')", "CREATE TABLE sm2222 (smc2 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_nodes.rb')", "CREATE TABLE sm3333 (smc3 integer)", "INSERT INTO schema_migrations (filename) VALUES ('003_3_create_users.rb')"]
+  end
+
+  specify "should not use transactions by default" do
+    Sequel::TimestampMigrator.apply(@db, "spec/files/transaction_unspecified_migrations")
+    @db.sqls.should == ["SELECT NULL FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "CREATE TABLE sm11111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_alt_basic.rb')", "CREATE TABLE sm (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_basic.rb')"]
+  end
+
+  specify "should use transactions by default if database supports transactional ddl" do
+    @db.meta_def(:supports_transactional_ddl?){true}
+    Sequel::TimestampMigrator.apply(@db, "spec/files/transaction_unspecified_migrations")
+    @db.sqls.should == ["SELECT NULL FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_alt_basic.rb')", "COMMIT", "BEGIN", "CREATE TABLE sm (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_basic.rb')", "COMMIT"]
+  end
+
+  specify "should support transaction use on a per migration basis" do
+    Sequel::TimestampMigrator.apply(@db, "spec/files/transaction_specified_migrations")
+    @db.sqls.should == ["SELECT NULL FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_alt_basic.rb')", "COMMIT", "CREATE TABLE sm (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_basic.rb')"]
+  end
+
+  specify "should force transactions if enabled by the migrator" do
+    Sequel::TimestampMigrator.run(@db, "spec/files/transaction_specified_migrations", :use_transactions=>true)
+    @db.sqls.should == ["SELECT NULL FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "BEGIN", "CREATE TABLE sm11111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_alt_basic.rb')", "COMMIT", "BEGIN", "CREATE TABLE sm (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_basic.rb')", "COMMIT"]
+  end
+
+  specify "should not use transactions if disabled in the migrator" do
+    Sequel::TimestampMigrator.run(@db, "spec/files/transaction_unspecified_migrations", :use_transactions=>false)
+    @db.sqls.should == ["SELECT NULL FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "CREATE TABLE sm11111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_alt_basic.rb')", "CREATE TABLE sm (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_basic.rb')"]
+  end
 end

data/spec/extensions/named_timezones_spec.rb

@@ -12,7 +12,7 @@ describe "Sequel named_timezones extension" do
   before do
     @tz_in = TZInfo::Timezone.get('America/Los_Angeles')
     @tz_out = TZInfo::Timezone.get('America/New_York')
-    @db = MockDatabase.new
+    @db = Sequel.mock
     @dt = DateTime.civil(2009,6,1,10,20,30,0)
     Sequel.application_timezone = 'America/Los_Angeles'
     Sequel.database_timezone = 'America/New_York'
@@ -35,14 +35,12 @@ describe "Sequel named_timezones extension" do
     Sequel.database_timezone.should == @tz_out
   end
     
-  unless RUBY_VERSION == '1.8.6' && RUBY_PLATFORM =~ /win/
-    it "should convert datetimes going into the database to named database_timezone" do
-      ds = @db[:a]
-      def ds.supports_timestamp_timezones?; true; end
-      def ds.supports_timestamp_usecs?; false; end
-      ds.insert([@dt, DateTime.civil(2009,6,1,3,20,30,-7/24.0), DateTime.civil(2009,6,1,6,20,30,-1/6.0)])
-      @db.sqls.should == ["INSERT INTO a VALUES ('2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400')"]
-    end
+  it "should convert datetimes going into the database to named database_timezone" do
+    ds = @db[:a]
+    def ds.supports_timestamp_timezones?; true; end
+    def ds.supports_timestamp_usecs?; false; end
+    ds.insert([@dt, DateTime.civil(2009,6,1,3,20,30,-7/24.0), DateTime.civil(2009,6,1,6,20,30,-1/6.0)])
+    @db.sqls.should == ["INSERT INTO a VALUES ('2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400')"]
   end
   
   it "should convert datetimes coming out of the database from database_timezone to application_timezone" do
@@ -66,8 +64,28 @@ describe "Sequel named_timezones extension" do
   end
   
   it "should work with the thread_local_timezones extension" do
-    [Thread.new{Sequel.thread_application_timezone = 'America/New_York'; sleep 0.03; Sequel.application_timezone.should == @tz_out},
-     Thread.new{sleep 0.01; Sequel.thread_application_timezone = 'America/Los_Angeles'; sleep 0.01; Sequel.application_timezone.should == @tz_in}].each{|x| x.join}
+    q, q1, q2 = Queue.new, Queue.new, Queue.new
+    tz1, tz2 = nil, nil
+    t1 = Thread.new do
+      Sequel.thread_application_timezone = 'America/New_York'
+      q2.push nil
+      q.pop
+      tz1 = Sequel.application_timezone
+    end
+    t2 = Thread.new do
+      Sequel.thread_application_timezone = 'America/Los_Angeles'
+      q2.push nil
+      q1.pop
+      tz2 = Sequel.application_timezone
+    end
+    q2.pop
+    q2.pop
+    q.push nil
+    q1.push nil
+    t1.join
+    t2.join
+    tz1.should == @tz_out
+    tz2.should == @tz_in
   end
 end
 end