sequel 3.34.1 → 3.35.0

data/spec/core/schema_generator_spec.rb

@@ -8,7 +8,7 @@ describe Sequel::Schema::Generator do
       foreign_key :parent_id
       primary_key :id
       check 'price > 100'
-      constraint(:xxx) {:yyy == :zzz}
+      constraint(:xxx) {{:yyy => :zzz}}
       index :title
       index [:title, :body], :unique => true
       foreign_key :node_id, :nodes

data/spec/core/schema_spec.rb

@@ -287,6 +287,13 @@ describe "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_id_index ON cats (id)"]
   end
   
+  specify "should accept inline index definition with a hash of options" do
+    @db.create_table(:cats) do
+      integer :id, :index => {:unique=>true}
+    end
+    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE UNIQUE INDEX cats_id_index ON cats (id)"]
+  end
+  
   specify "should accept inline index definition for foreign keys" do
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_delete => :cascade, :index => true
@@ -295,6 +302,14 @@ describe "DB#create_table" do
       "CREATE INDEX cats_project_id_index ON cats (project_id)"]
   end
   
+  specify "should accept inline index definition for foreign keys with a hash of options" do
+    @db.create_table(:cats) do
+      foreign_key :project_id, :table => :projects, :on_delete => :cascade, :index => {:unique=>true}
+    end
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE CASCADE)",
+      "CREATE UNIQUE INDEX cats_project_id_index ON cats (project_id)"]
+  end
+  
   specify "should accept index definitions" do
     @db.create_table(:cats) do
       integer :id
@@ -535,6 +550,20 @@ describe "DB#create_table" do
     end
     @db.sqls.should == ["CREATE TABLE cats (a integer, b integer, FOREIGN KEY (a, b) REFERENCES abc(x, y) ON DELETE SET NULL ON UPDATE SET NULL)"]
   end
+
+  specify "should accept an :as option to create a table from the results of a dataset" do
+    @db.create_table(:cats, :as=>@db[:a])
+    @db.sqls.should == ['CREATE TABLE cats AS SELECT * FROM a']
+  end
+
+  specify "should accept an :as option to create a table from a SELECT string" do
+    @db.create_table(:cats, :as=>'SELECT * FROM a')
+    @db.sqls.should == ['CREATE TABLE cats AS SELECT * FROM a']
+  end
+
+  specify "should raise an Error if both a block and an :as argument are given" do
+    proc{@db.create_table(:cats, :as=>@db[:a]){}}.should raise_error(Sequel::Error)
+  end
 end
 
 describe "DB#create_table!" do
@@ -1155,6 +1184,28 @@ describe "Schema Parser" do
     proc{@db.schema(:x)}.should raise_error(Sequel::Error)
   end
 
+  specify "should cache data by default" do
+    @db.meta_def(:schema_parse_table) do |t, opts|
+      [[:a, {}]]
+    end
+    @db.schema(:x).should equal(@db.schema(:x))
+  end
+
+  specify "should not cache data if :reload=>true is given" do
+    @db.meta_def(:schema_parse_table) do |t, opts|
+      [[:a, {}]]
+    end
+    @db.schema(:x).should_not equal(@db.schema(:x, :reload=>true))
+  end
+
+  specify "should not cache schema metadata if cache_schema is false" do
+    @db.cache_schema = false
+    @db.meta_def(:schema_parse_table) do |t, opts|
+      [[:a, {}]]
+    end
+    @db.schema(:x).should_not equal(@db.schema(:x))
+  end
+
   specify "should provide options if given a table name" do
     c = nil
     @db.meta_def(:schema_parse_table) do |t, opts|

data/spec/extensions/arbitrary_servers_spec.rb

@@ -1,6 +1,5 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
-if RUBY_VERSION >= '1.8.7'
 describe "arbtirary servers" do
   before do
     @db = Sequel.mock(:servers=>{})
@@ -109,6 +108,3 @@ describe "arbtirary servers" do
       'SELECT * FROM t -- {:host=>"b"}', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t']
   end
 end
-else
-  skip_warn "arbitrary_servers plugin: only works on ruby 1.8.7+"
-end

data/spec/extensions/association_autoreloading_spec.rb

@@ -24,6 +24,23 @@ describe "AssociationAutoreloading plugin" do
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1']
   end
 
+  specify "should handle multiple many_to_one association with the same foreign key" do
+    @Album.many_to_one :artist2, :key=>:artist_id, :class=>@Artist
+    album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
+    album.artist
+    album.artist2
+    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1'] * 2
+
+    album.artist
+    album.artist2
+    MODEL_DB.sqls.should == []
+
+    album.artist_id = 1
+    album.artist
+    album.artist2
+    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1'] * 2
+  end
+
   specify "should not reload when value has not changed" do
     album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
     album.artist

data/spec/extensions/association_proxies_spec.rb

@@ -31,13 +31,13 @@ describe "Sequel::Plugins::AssociationProxies" do
   
   it "should reload the cached association if sent an array method and the reload flag was given" do
     @t.select{|x| false}.should == []
-    Item.db.sqls.length == 1
+    Item.db.sqls.length.should == 1
     @t.select{|x| false}.should == []
-    Item.db.sqls.length == 1
+    Item.db.sqls.length.should == 0
     @i.tags(true).select{|x| false}.should == []
-    Item.db.sqls.length == 2
+    Item.db.sqls.length.should == 1
     @t.filter(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1)) WHERE (a = 1)"
-    Item.db.sqls.length == 2
+    Item.db.sqls.length.should == 0
   end
   
   it "should not return a proxy object for associations that do not return an array" do

data/spec/extensions/core_extensions_spec.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 describe "Sequel core extensions" do
   specify "should not be used inside Sequel, to insure Sequel works without them" do
     usage = []
-    match_re = /(\.(all_two_pairs\?|sql_value_list|sql_array|sql_expr|sql_negate|sql_or|sql_string_join|lit|to_sequel_blob|case|sql_expr_if_all_two_pairs)\W)|:\w+\.(qualify|identifier|as|cast|asc|desc|sql_subscript|\*|sql_function)\W/
+    match_re = /(\.(sql_value_list|sql_array|sql_expr|sql_negate|sql_or|sql_string_join|lit|to_sequel_blob|case)\W)|:\w+\.(qualify|identifier|as|cast|asc|desc|sql_subscript|\*|sql_function)\W/
     comment_re = /^\s*#|# core_sql/
     Dir['lib/sequel/**/*.rb'].each do |f|
       lines = File.read(f).split("\n").grep(match_re).delete_if{|l| l =~ comment_re}
@@ -18,29 +18,6 @@ describe "Sequel core extensions" do
   end
 end
 
-describe "Array#all_two_pairs?" do
-  specify "should return false if empty" do
-    [].all_two_pairs?.should == false
-  end
-
-  specify "should return false if any of the elements is not an array" do
-    [1].all_two_pairs?.should == false
-    [[1,2],1].all_two_pairs?.should == false
-  end
-
-  specify "should return false if any of the elements has a length other than two" do
-    [[1,2],[]].all_two_pairs?.should == false
-    [[1,2],[1]].all_two_pairs?.should == false
-    [[1,2],[1,2,3]].all_two_pairs?.should == false
-  end
-
-  specify "should return true if all of the elements are arrays with a length of two" do
-    [[1,2]].all_two_pairs?.should == true
-    [[1,2],[1,2]].all_two_pairs?.should == true
-    [[1,2],[1,2],[1,2]].all_two_pairs?.should == true
-  end
-end
-  
 describe "Array#case and Hash#case" do
   before do
     @d = Sequel::Dataset.new(nil)

data/spec/extensions/dirty_spec.rb

@@ -0,0 +1,155 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::Dirty" do
+  before do
+    @db = Sequel.mock(:fetch=>{:initial=>'i', :initial_changed=>'ic'}, :numrows=>1)
+    @c = Class.new(Sequel::Model(@db[:c]))
+    @c.plugin :dirty
+    @c.columns :initial, :initial_changed, :missing, :missing_changed
+  end
+
+  shared_examples_for "dirty plugin" do
+    it "initial_value should be the current value if value has not changed" do
+      @o.initial_value(:initial).should == 'i'
+      @o.initial_value(:missing).should == nil
+    end
+
+    it "initial_value should be the intial value if value has changed" do
+      @o.initial_value(:initial_changed).should == 'ic'
+      @o.initial_value(:missing_changed).should == nil
+    end
+
+    it "initial_value should handle case where initial value is reassigned later" do
+      @o.initial_changed = 'ic'
+      @o.initial_value(:initial_changed).should == 'ic'
+      @o.missing_changed = nil
+      @o.initial_value(:missing_changed).should == nil
+    end
+
+    it "changed_columns should handle case where initial value is reassigned later" do
+      @o.changed_columns.should == [:initial_changed, :missing_changed]
+      @o.initial_changed = 'ic'
+      @o.changed_columns.should == [:missing_changed]
+      @o.missing_changed = nil
+      @o.changed_columns.should == [:missing_changed]
+    end
+
+    it "column_change should give initial and current values if there has been a change made" do
+      @o.column_change(:initial_changed).should == ['ic', 'ic2']
+      @o.column_change(:missing_changed).should == [nil, 'mc2']
+    end
+
+    it "column_change should be nil if no change has been made" do
+      @o.column_change(:initial).should == nil
+      @o.column_change(:missing).should == nil
+    end
+
+    it "column_changed? should return whether the column has changed" do
+      @o.column_changed?(:initial).should == false
+      @o.column_changed?(:initial_changed).should == true
+      @o.column_changed?(:missing).should == false
+      @o.column_changed?(:missing_changed).should == true
+    end
+
+    it "column_changed? should handle case where initial value is reassigned later" do
+      @o.initial_changed = 'ic'
+      @o.column_changed?(:initial_changed).should == false
+      @o.missing_changed = nil
+      @o.column_changed?(:missing_changed).should == false
+    end
+
+    it "changed_columns should handle case where initial value is reassigned later" do
+      @o.changed_columns.should == [:initial_changed, :missing_changed]
+      @o.initial_changed = 'ic'
+      @o.changed_columns.should == [:missing_changed]
+      @o.missing_changed = nil
+      @o.changed_columns.should == [:missing_changed]
+    end
+
+    it "column_changes should give initial and current values" do
+      @o.column_changes.should == {:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2']}
+    end
+
+    it "reset_column should reset the column to its initial value" do
+      @o.reset_column(:initial)
+      @o.initial.should == 'i'
+      @o.reset_column(:initial_changed)
+      @o.initial_changed.should == 'ic'
+      @o.reset_column(:missing)
+      @o.missing.should == nil
+      @o.reset_column(:missing_changed)
+      @o.missing_changed.should == nil
+    end
+
+    it "reset_column should remove missing values from the values" do
+      @o.reset_column(:missing)
+      @o.values.has_key?(:missing).should == false
+      @o.reset_column(:missing_changed)
+      @o.values.has_key?(:missing_changed).should == false
+    end
+    
+    it "refresh should clear the cached initial values" do
+      @o.refresh
+      @o.column_changes.should == {}
+    end
+    
+    it "will_change_column should be used to signal in-place modification to column" do
+      @o.will_change_column(:initial)
+      @o.initial << 'b'
+      @o.column_change(:initial).should == ['i', 'ib']
+      @o.will_change_column(:initial_changed)
+      @o.initial_changed << 'b'
+      @o.column_change(:initial_changed).should == ['ic', 'ic2b']
+      @o.will_change_column(:missing)
+      @o.values[:missing] = 'b'
+      @o.column_change(:missing).should == [nil, 'b']
+      @o.will_change_column(:missing_changed)
+      @o.missing_changed << 'b'
+      @o.column_change(:missing_changed).should == [nil, 'mc2b']
+    end
+
+    it "will_change_column should different types of existing objects" do
+      [nil, true, false, Class.new{undef_method :clone}.new, Class.new{def clone; raise TypeError; end}.new].each do |v|
+        o = @c.new(:initial=>v)
+        o.will_change_column(:initial)
+        o.initial = 'a'
+        o.column_change(:initial).should == [v, 'a']
+      end
+    end
+
+    it "save should clear the cached initial values" do
+      @o.save
+      @o.column_changes.should == {}
+    end
+
+    it "save_changes should clear the cached initial values" do
+      @o.save_changes
+      @o.column_changes.should == {}
+    end
+  end
+
+  describe "with new instance" do
+    before do
+      @o = @c.new(:initial=>'i', :initial_changed=>'ic')
+      @o.initial_changed = 'ic2'
+      @o.missing_changed = 'mc2'
+    end
+
+    it_should_behave_like "dirty plugin"
+  end
+
+  describe "with existing instance" do
+    before do
+      @o = @c[1]
+      @o.initial_changed = 'ic2'
+      @o.missing_changed = 'mc2'
+    end
+
+    it_should_behave_like "dirty plugin"
+
+    it "previous_changes should be the previous changes after saving" do
+      @o.save
+      @o.previous_changes.should == {:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2']}
+    end
+  end
+end

data/spec/extensions/json_serializer_spec.rb

@@ -116,6 +116,19 @@ describe "Sequel::Plugins::JsonSerializer" do
     JSON.parse(ds.to_json).should == [@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}]
   end
 
+  it "should have dataset to_json method respect :array option for the array to use" do
+    a = Album.load(:id=>1, :name=>'RF', :artist_id=>3)
+    JSON.parse(Album.to_json(:array=>[a])).should == [a]
+
+    a.associations[:artist] = artist = Artist.load(:id=>3, :name=>'YJM')
+    JSON.parse(Album.to_json(:array=>[a], :include=>:artist)).first.artist.should == artist
+
+    artist.associations[:albums] = [a]
+    x = JSON.parse(Artist.to_json(:array=>[artist], :include=>:albums))
+    x.should == [artist]
+    x.first.albums.should == [a]
+  end
+
   it "should propagate class default options to instance to_json output" do
     class ::Album2 < Sequel::Model
       attr_accessor :blah

data/spec/extensions/migration_spec.rb

@@ -320,23 +320,30 @@ describe "Sequel::IntegerMigrator" do
     proc{Sequel::IntegerMigrator.apply(@db, "spec/files/timestamped_migrations")}.should raise_error(Sequel::Migrator::Error)
   end
 
-  specify "should use transactions by default" do
-    Sequel::Migrator.apply(@db, "spec/files/transaction_migrations")
+  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 not use transactions for migrations that disable it" do
-    Sequel::Migrator.apply(@db, "spec/files/transactionless_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"]
+  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/transactionless_migrations", :use_transactions=>true)
+    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_migrations", :use_transactions=>false)
+    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
@@ -598,26 +605,32 @@ describe "Sequel::TimestampMigrator" do
 
   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", "BEGIN", "CREATE TABLE sm1111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_sessions.rb')", "COMMIT", "BEGIN", "CREATE TABLE sm2222 (smc2 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_nodes.rb')", "COMMIT", "BEGIN", "CREATE TABLE sm3333 (smc3 integer)", "INSERT INTO schema_migrations (filename) VALUES ('003_3_create_users.rb')", "COMMIT"]
+    @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 use transactions by default" do
-    Sequel::TimestampMigrator.apply(@db, "spec/files/transaction_migrations")
+  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 not use transactions for migrations that disable it" do
-    Sequel::TimestampMigrator.apply(@db, "spec/files/transactionless_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')"]
+  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/transactionless_migrations", :use_transactions=>true)
+    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_migrations", :use_transactions=>false)
+    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

@@ -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