sequel 3.11.0 → 3.12.0

data/spec/extensions/association_pks_spec.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Sequel::Plugins::AssociationPks" do
+  before do
+    @db = MODEL_DB.clone
+    mod = Module.new do
+      def fetch_rows(sql)
+        case sql
+        when "SELECT id FROM albums WHERE (albums.artist_id = 1)"
+          yield({:id=>1})
+          yield({:id=>2})
+          yield({:id=>3})
+        when /SELECT tag_id FROM albums_tags WHERE \(album_id = (\d)\)/
+          yield({:tag_id=>1}) if $1 == '1'
+          yield({:tag_id=>2}) if $1 != '3'
+          yield({:tag_id=>3}) if $1 == '2'
+        end
+      end
+    end
+    @db.meta_def(:dataset) do |*opts|
+      ds = super(*opts)
+      ds.extend mod
+      ds
+    end
+    def @db.transaction(opts)
+      execute('BEGIN')
+      yield
+      execute('COMMIT')
+    end
+    @Artist = Class.new(Sequel::Model(@db[:artists]))
+    @Artist.columns :id
+    @Album= Class.new(Sequel::Model(@db[:albums]))
+    @Album.columns :id, :artist_id
+    @Tag = Class.new(Sequel::Model(@db[:tags]))
+    @Tag.columns :id
+    @Artist.plugin :association_pks
+    @Album.plugin :association_pks
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id
+    @db.reset
+  end
+
+  specify "should return correct associated pks for one_to_many associations" do
+    @Artist.load(:id=>1).album_pks.should == [1,2,3]
+    @Artist.load(:id=>2).album_pks.should == []
+  end
+
+  specify "should return correct associated pks for many_to_many associations" do
+    @Album.load(:id=>1).tag_pks.should == [1, 2]
+    @Album.load(:id=>2).tag_pks.should == [2, 3]
+    @Album.load(:id=>3).tag_pks.should == []
+  end
+
+  specify "should set associated pks correctly for a one_to_many association" do
+    @Artist.load(:id=>1).album_pks = [1, 2]
+    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))"]
+  end
+
+  specify "should set associated pks correctly for a many_to_many association" do
+    @Album.load(:id=>2).tag_pks = [1, 3]
+    @db.sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    @db.sqls[1].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+  end
+
+  specify "should use transactions if the object is configured to use transactions" do
+    artist = @Artist.load(:id=>1)
+    artist.use_transactions = true
+    artist.album_pks = [1, 2]
+    @db.sqls.should == ["BEGIN",
+      "UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))",
+      "COMMIT"]
+    @db.reset
+
+    album = @Album.load(:id=>2)
+    album.use_transactions = true
+    album.tag_pks = [1, 3]
+    @db.sqls[0].should == "BEGIN"
+    @db.sqls[1].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    @db.sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    @db.sqls[3].should == "COMMIT"
+  end
+
+end

data/spec/extensions/hook_class_methods_spec.rb

@@ -135,38 +135,38 @@ describe "Model hooks" do
     $adds.should == ['456']
   end
   
-  specify "should stop processing if a hook returns false" do
+  specify "should stop processing if a before hook returns false" do
     $flag = true
     $adds = []
     
     a = Class.new(Sequel::Model)
     a.class_eval do
-      after_save {$adds << 'blah'; $flag}
-      after_save {$adds << 'cruel'}
+      before_save {$adds << 'cruel'; $flag}
+      before_save {$adds << 'blah'; $flag}
     end
     
-    a.new.after_save
+    a.new.before_save
     $adds.should == ['blah', 'cruel']
 
     # chain should not break on nil
     $adds = []
     $flag = nil
-    a.new.after_save
+    a.new.before_save
     $adds.should == ['blah', 'cruel']
     
     $adds = []
     $flag = false
-    a.new.after_save
+    a.new.before_save
     $adds.should == ['blah']
     
     b = Class.new(a)
     b.class_eval do
-      after_save {$adds << 'mau'}
+      before_save {$adds << 'mau'}
     end
     
     $adds = []
-    b.new.after_save
-    $adds.should == ['blah']
+    b.new.before_save
+    $adds.should == ['mau', 'blah']
   end
 end
 

data/spec/extensions/migration_spec.rb

@@ -1,152 +1,120 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
-context "Migration classes" do
+context "Migration.descendants" do
   before do
     Sequel::Migration.descendants.clear
   end
 
-  specify "should be registred in Migration.descendants" do
+  specify "should include Migration subclasses" do
     @class = Class.new(Sequel::Migration)
     
     Sequel::Migration.descendants.should == [@class]
   end
   
-  specify "should be registered in the right order" do
+  specify "should include Migration subclasses in order of creation" do
     @c1 = Class.new(Sequel::Migration)
     @c2 = Class.new(Sequel::Migration)
     @c3 = Class.new(Sequel::Migration)
     
     Sequel::Migration.descendants.should == [@c1, @c2, @c3]
   end
+
+  specify "should include SimpleMigration instances created by migration DSL" do
+    i1 = Sequel.migration{}
+    i2 = Sequel.migration{}
+    i3 = Sequel.migration{}
+    
+    Sequel::Migration.descendants.should == [i1, i2, i3]
+  end
 end
 
-context "Migration#apply" do
+context "Migration.apply" do
   before do
     @c = Class.new do
       define_method(:one) {|x| [1111, x]}
       define_method(:two) {|x| [2222, x]}
     end
     @db = @c.new
-    
-    @migration = Class.new(Sequel::Migration) do
-      define_method(:up) {one(3333)}
-      define_method(:down) {two(4444)}
-    end
   end
   
   specify "should raise for an invalid direction" do
-    proc {@migration.apply(@db, :hahaha)}.should raise_error(ArgumentError)
+    proc {Sequel::Migration.apply(@db, :hahaha)}.should raise_error(ArgumentError)
   end
   
-  specify "should apply the up direction correctly" do
-    @migration.apply(@db, :up).should == [1111, 3333]
-  end
-
-  specify "should apply the down direction correctly" do
-    @migration.apply(@db, :down).should == [2222, 4444]
-  end
-end
-
-MIGRATION_001 = %[
-  class CreateSessions < Sequel::Migration
-    def up
-      create(1111)
-    end
-    
-    def down
-      drop(1111)
+  specify "should apply the up and down directions correctly" do
+    m = Class.new(Sequel::Migration) do
+      define_method(:up) {one(3333)}
+      define_method(:down) {two(4444)}
     end
+    m.apply(@db, :up).should == [1111, 3333]
+    m.apply(@db, :down).should == [2222, 4444]
   end
-]
 
-MIGRATION_002 = %[
-  class CreateNodes < Sequel::Migration
-    def up
-      create(2222)
-    end
-    
-    def down
-      drop(2222)
-    end
+  specify "should have default up and down actions that do nothing" do
+    m = Class.new(Sequel::Migration)
+    m.apply(@db, :up).should == nil
+    m.apply(@db, :down).should == nil
   end
-]
+end
 
-MIGRATION_003 = %[
-  class CreateUsers < Sequel::Migration
-    def up
-      create(3333)
-    end
-    
-    def down
-      drop(3333)
+context "SimpleMigration#apply" do
+  before do
+    @c = Class.new do
+      define_method(:one) {|x| [1111, x]}
+      define_method(:two) {|x| [2222, x]}
     end
+    @db = @c.new
   end
-]
-
-MIGRATION_005 = %[
-  class CreateAttributes < Sequel::Migration
-    def up
-      create(5555)
-    end
-    
-    def down
-      drop(5555)
-    end
+  
+  specify "should raise for an invalid direction" do
+    proc {Sequel.migration{}.apply(@db, :hahaha)}.should raise_error(ArgumentError)
   end
-]
-
-ALT_MIGRATION_001 = %[
-  class CreateAltBasic < Sequel::Migration
-    def up
-      create(11111)
-    end
-    
-    def down
-      drop(11111)
+  
+  specify "should apply the up and down directions correctly" do
+    m = Sequel.migration do
+      up{one(3333)}
+      down{two(4444)}
     end
+    m.apply(@db, :up).should == [1111, 3333]
+    m.apply(@db, :down).should == [2222, 4444]
   end
-]
 
-ALT_MIGRATION_003 = %[
-  class CreateAltAdvanced < Sequel::Migration
-    def up
-      create(33333)
-    end
-    
-    def down
-      drop(33333)
-    end
+  specify "should have default up and down actions that do nothing" do
+    m = Sequel.migration{}
+    m.apply(@db, :up).should == nil
+    m.apply(@db, :down).should == nil
   end
-]
+end
 
-context "Sequel::Migrator" do
+context "Sequel::IntegerMigrator" do
   before do
     dbc = Class.new(MockDatabase) do
-      attr_reader :creates, :drops, :tables_created, :columns_created, :versions
+      attr_reader :drops, :tables_created, :columns_created, :versions
       def initialize(*args)
         super
-        @creates = []
         @drops = []
         @tables_created = []
         @columns_created = []
         @versions = {}
       end
   
-      def create(x); @creates << x; end
-      def drop(x); @drops << x; end
+      def version; versions.values.first || 0; end
+      def creates; @tables_created.map{|x| y = x.to_s; y !~ /\Asm(\d+)/; $1.to_i if $1}.compact; end
+      def drop_table(*a); super; @drops.concat(a.map{|x| y = x.to_s; y !~ /\Asm(\d+)/; $1.to_i if $1}.compact); end
 
       def create_table(name, opts={}, &block)
         super
-        @columns_created << / \(?(\w+) integer\)?\z/.match(sqls.last)[1].to_sym
+        @columns_created << / \(?(\w+) integer.*\)?\z/.match(sqls.last)[1].to_sym
         @tables_created << name
       end
       
       def dataset(opts={})
         ds = super
         ds.extend(Module.new do
+          def count; 1; end
           def columns; db.columns_created end
-          def insert(h); db.versions.merge!(h); super(h) end
-          def update(h); db.versions.merge!(h); super(h) 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 fetch_rows(sql); db.execute(sql); yield(db.versions) unless db.versions.empty? end
         end)
         ds
@@ -158,175 +126,327 @@ context "Sequel::Migrator" do
     end
     @db = dbc.new
     
-    @dirname = "migrate_#{$$}"
-    Dir.mkdir(@dirname)
-    File.open("#{@dirname}/001_create_sessions.rb", 'w') {|f| f << MIGRATION_001}
-    File.open("#{@dirname}/002_create_nodes.rb", 'w') {|f| f << MIGRATION_002}
-    File.open("#{@dirname}/003_create_users.rb", 'w') {|f| f << MIGRATION_003}
-    File.open("#{@dirname}/005_5_create_attributes.rb", 'w') {|f| f << MIGRATION_005}
-    
-    @alt_dirname = "migrate_alt_#{$$}"
-    Dir.mkdir(@alt_dirname)
-    File.open("#{@alt_dirname}/001_create_alt_basic.rb", 'w') {|f| f << ALT_MIGRATION_001}
-    File.open("#{@alt_dirname}/003_create_alt_advanced.rb", 'w') {|f| f << ALT_MIGRATION_003}
+    @dirname = "spec/files/integer_migrations"
   end
   
   after do
     Object.send(:remove_const, "CreateSessions") if Object.const_defined?("CreateSessions")
-    Object.send(:remove_const, "CreateNodes") if Object.const_defined?("CreateNodes")
-    Object.send(:remove_const, "CreateUsers") if Object.const_defined?("CreateUsers")
-    Object.send(:remove_const, "CreateAttributes") if Object.const_defined?("CreateAttributes")
-    Object.send(:remove_const, "CreateAltBasic") if Object.const_defined?("CreateAltBasic")
-    Object.send(:remove_const, "CreateAltAdvanced") if Object.const_defined?("CreateAltAdvanced")
-
-    File.delete("#{@dirname}/001_create_sessions.rb")
-    File.delete("#{@dirname}/002_create_nodes.rb")
-    File.delete("#{@dirname}/003_create_users.rb")
-    File.delete("#{@dirname}/005_5_create_attributes.rb")
-    Dir.rmdir(@dirname)
-    File.delete("#{@alt_dirname}/001_create_alt_basic.rb")
-    File.delete("#{@alt_dirname}/003_create_alt_advanced.rb")
-    Dir.rmdir(@alt_dirname)
   end
   
-  specify "#migration_files should return the list of files for a specified version range" do
-    Sequel::Migrator.migration_files(@dirname, 1..1).map{|f| File.basename(f)}.should == ['001_create_sessions.rb']
-    Sequel::Migrator.migration_files(@dirname, 1..3).map{|f| File.basename(f)}.should == ['001_create_sessions.rb', '002_create_nodes.rb', '003_create_users.rb']
-    Sequel::Migrator.migration_files(@dirname, 3..6).map{|f| File.basename(f)}.should == ['003_create_users.rb', '005_5_create_attributes.rb']
-    Sequel::Migrator.migration_files(@dirname, 7..8).map{|f| File.basename(f)}.should == []
-    Sequel::Migrator.migration_files(@alt_dirname, 1..1).map{|f| File.basename(f)}.should == ['001_create_alt_basic.rb']
-    Sequel::Migrator.migration_files(@alt_dirname, 1..3).map{|f| File.basename(f)}.should == ['001_create_alt_basic.rb','003_create_alt_advanced.rb']
+  specify "should raise and error if there is a missing integer migration version" do
+    proc{Sequel::Migrator.apply(@db, "spec/files/missing_integer_migrations")}.should raise_error(Sequel::Migrator::Error)
   end
-  
-  specify "#latest_migration_version should return the latest version available" do
-    Sequel::Migrator.latest_migration_version(@dirname).should == 5
-    Sequel::Migrator.latest_migration_version(@alt_dirname).should == 3
+
+  specify "should raise and error if there is a duplicate integer migration version" do
+    proc{Sequel::Migrator.apply(@db, "spec/files/duplicate_integer_migrations")}.should raise_error(Sequel::Migrator::Error)
   end
-  
-  specify "#migration_classes should load the migration classes for the specified range for the up direction" do
-    Sequel::Migrator.migration_classes(@dirname, 3, 0, :up).should == [CreateSessions, CreateNodes, CreateUsers]
-    Sequel::Migrator.migration_classes(@alt_dirname, 3, 0, :up).should == [CreateAltBasic, CreateAltAdvanced]
+
+  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)
+    Sequel::Migrator.apply(@db, @dirname)
   end
-  
-  specify "#migration_classes should load the migration classes for the specified range for the down direction" do
-    Sequel::Migrator.migration_classes(@dirname, 0, 5, :down).should == [CreateAttributes, CreateUsers, CreateNodes, CreateSessions]
-    Sequel::Migrator.migration_classes(@alt_dirname, 0, 3, :down).should == [CreateAltAdvanced, CreateAltBasic]
+
+  specify "should automatically create the schema_info table with the version column" do
+    @db.table_exists?(:schema_info).should be_false
+    Sequel::Migrator.run(@db, @dirname, :target=>0)
+    @db.table_exists?(:schema_info).should be_true
+    @db.dataset.columns.should == [:version]
   end
-  
-  specify "#migration_classes should start from current + 1 for the up direction" do
-    Sequel::Migrator.migration_classes(@dirname, 3, 1, :up).should == [CreateNodes, CreateUsers]
-    Sequel::Migrator.migration_classes(@alt_dirname, 3, 2, :up).should == [CreateAltAdvanced]
+
+  specify "should allow specifying the table and columns" do
+    @db.table_exists?(:si).should be_false
+    Sequel::Migrator.run(@db, @dirname, :target=>0, :table=>:si, :column=>:sic)
+    @db.table_exists?(:si).should be_true
+    @db.dataset.columns.should == [:sic]
   end
   
-  specify "#migration_classes should end on current + 1 for the down direction" do
-    Sequel::Migrator.migration_classes(@dirname, 2, 5, :down).should == [CreateAttributes, CreateUsers]
-    Sequel::Migrator.migration_classes(@alt_dirname, 2, 4, :down).should == [CreateAltAdvanced]
+  specify "should apply migrations correctly in the up direction if no target is given" do
+    Sequel::Migrator.apply(@db, @dirname)
+    @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 apply migrations correctly in the up direction with target" do
+    Sequel::Migrator.apply(@db, @dirname, 2)
+    @db.creates.should == [1111, 2222]
+    @db.version.should == 2
+    @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.should == [1, 2]
   end
   
-  specify "#schema_info_dataset should automatically create the schema_info table" do
-    @db.table_exists?(:schema_info).should be_false
-    Sequel::Migrator.schema_info_dataset(@db)
-    @db.table_exists?(:schema_info).should be_true
-    @db.sqls.should == ["CREATE TABLE schema_info (version integer)"]
+  specify "should apply migrations correctly in the up direction with target and existing" do
+    Sequel::Migrator.apply(@db, @dirname, 2, 1)
+    @db.creates.should == [2222]
+    @db.version.should == 2
+    @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.should == [2]
   end
 
-  specify "should automatically create new APP_version column in schema_info" do
-    @db.table_exists?(:schema_info).should be_false
-    Sequel::Migrator.schema_info_dataset(@db, :column => :alt_version)
-    @db.table_exists?(:schema_info).should be_true
-    @db.sqls.should == ["CREATE TABLE schema_info (alt_version integer)"]
+  specify "should apply migrations correctly in the down direction with target" do
+    @db.create_table(:schema_info){Integer :version, :default=>0}
+    @db[:schema_info].insert(:version=>3)
+    @db.version.should == 3
+    Sequel::Migrator.apply(@db, @dirname, 0)
+    @db.drops.should == [3333, 2222, 1111]
+    @db.version.should == 0
+    @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.should == [2, 1, 0]
   end
   
-  specify "should automatically create new APP_version column in schema_info" do
-    @db.table_exists?(:alt_table).should be_false
-    Sequel::Migrator.schema_info_dataset(@db, :table => :alt_table)
-    @db.table_exists?(:alt_table).should be_true
-    Sequel::Migrator.schema_info_dataset(@db, :table => :alt_table, :column=>:alt_version)
-    @db.sqls.should == ["CREATE TABLE alt_table (version integer)",
-      "ALTER TABLE alt_table ADD COLUMN alt_version integer"]
+  specify "should apply migrations correctly in the down direction with target and existing" do
+    Sequel::Migrator.apply(@db, @dirname, 1, 2)
+    @db.drops.should == [2222]
+    @db.version.should == 1
+    @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.should == [1]
   end
   
-  specify "should return a dataset for the correct table" do
-    Sequel::Migrator.schema_info_dataset(@db).first_source_alias.should == :schema_info
-    Sequel::Migrator.schema_info_dataset(@db, :table=>:blah).first_source_alias.should == :blah
+  specify "should return the target version" do
+    Sequel::Migrator.apply(@db, @dirname, 3, 2).should == 3
+    Sequel::Migrator.apply(@db, @dirname, 0).should == 0
+    Sequel::Migrator.apply(@db, @dirname).should == 3
   end
-  
-  specify "should assume a migration version of 0 if no migration information exists in the database" do
-    Sequel::Migrator.get_current_migration_version(@db).should == 0
-    @db.sqls.should == ["CREATE TABLE schema_info (version integer)", "SELECT * FROM schema_info LIMIT 1"]
+end
+
+context "Sequel::TimestampMigrator" do
+  before do
+    $sequel_migration_version = 0
+    $sequel_migration_files = []
+    @dsc = dsc = Class.new(MockDataset) do
+      def columns
+        case opts[:from].first
+        when :schema_info
+          [:version]
+        when :schema_migrations
+          [:filename]
+        when :sm
+          [:fn]
+        end
+      end
+
+      def fetch_rows(sql)
+        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)}
+        end
+      end
+
+      def insert(h={})
+        case opts[:from].first
+        when :schema_info
+          $sequel_migration_version = h.values.first
+        when :schema_migrations, :sm
+          $sequel_migration_files << h.values.first
+        end
+      end
+
+      def update(h={})
+        case opts[:from].first
+        when :schema_info
+          $sequel_migration_version = h.values.first
+        end
+      end
+
+      def delete
+        case opts[:from].first
+        when :schema_migrations, :sm
+          $sequel_migration_files.delete(opts[:where].args.last)
+        end
+      end
+    end
+    dbc = Class.new(MockDatabase) do
+      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)}
+    end
+    @db = dbc.new
+    @m = Sequel::Migrator
   end
-  specify "should use the migration version stored in the database" do
-    Sequel::Migrator.schema_info_dataset(@db).insert(:version => 4321)
-    Sequel::Migrator.get_current_migration_version(@db).should == 4321
-    @db.sqls.should == ["CREATE TABLE schema_info (version integer)", "INSERT INTO schema_info (version) VALUES (4321)", "SELECT * FROM schema_info LIMIT 1"]
+
+  after do
+    Object.send(:remove_const, "CreateSessions") if Object.const_defined?("CreateSessions")
+    Object.send(:remove_const, "CreateArtists") if Object.const_defined?("CreateArtists")
+    Object.send(:remove_const, "CreateAlbums") if Object.const_defined?("CreateAlbums")
   end
   
-  specify "should set the migration version stored in the database" do
-    Sequel::Migrator.set_current_migration_version(@db, 6666)
-    Sequel::Migrator.get_current_migration_version(@db).should == 6666
-    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
-      "SELECT * FROM schema_info LIMIT 1",
-      "INSERT INTO schema_info (version) VALUES (6666)",
-      "SELECT * FROM schema_info LIMIT 1"]
+  specify "should handle migrating up or down all the way" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    [:schema_migrations, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_true}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253851_create_nodes.rb 1273253853_3_create_users.rb'
+    @m.apply(@db, @dir, 0)
+    [:sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_false}
+    @db[:schema_migrations].select_order_map(:filename).should == []
   end
-  
-  specify "should apply migrations correctly in the up direction" do
-    Sequel::Migrator.apply(@db, @dirname, 3, 2)
-    @db.creates.should == [3333]
-    
-    Sequel::Migrator.get_current_migration_version(@db).should == 3
 
-    Sequel::Migrator.apply(@db, @dirname, 5)
-    @db.creates.should == [3333, 5555]
+  specify "should handle migrating up or down to specific timestamps" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir, 1273253851)
+    [:schema_migrations, :sm1111, :sm2222].each{|n| @db.table_exists?(n).should be_true}
+    @db.table_exists?(:sm3333).should be_false
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253851_create_nodes.rb'
+    @m.apply(@db, @dir, 1273253849)
+    [:sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_false}
+    @db.table_exists?(:sm1111).should be_true
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb'
+  end
 
-    Sequel::Migrator.get_current_migration_version(@db).should == 5
-    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
-      "SELECT * FROM schema_info LIMIT 1",
-      "INSERT INTO schema_info (version) VALUES (3)",
-      "SELECT * FROM schema_info LIMIT 1",
-      "SELECT * FROM schema_info LIMIT 1",
-      "SELECT * FROM schema_info LIMIT 1",
-      "UPDATE schema_info SET version = 5",
-      "SELECT * FROM schema_info LIMIT 1"]
+  specify "should apply all missing files when migrating up" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    @dir = 'spec/files/interleaved_timestamped_migrations'
+    @m.apply(@db, @dir)
+    [:schema_migrations, :sm1111, :sm1122, :sm2222, :sm2233, :sm3333].each{|n| @db.table_exists?(n).should be_true}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253850_create_artists.rb 1273253851_create_nodes.rb 1273253852_create_albums.rb 1273253853_3_create_users.rb'
   end
-  
-  specify "should apply migrations correctly in the down direction" do
-    Sequel::Migrator.apply(@db, @dirname, 1, 5)
-    @db.drops.should == [5555, 3333, 2222]
 
-    Sequel::Migrator.get_current_migration_version(@db).should == 1
-    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
-      "SELECT * FROM schema_info LIMIT 1",
-      "INSERT INTO schema_info (version) VALUES (1)",
-      "SELECT * FROM schema_info LIMIT 1"]
+  specify "should not apply down action to migrations where up action hasn't been applied" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    @dir = 'spec/files/interleaved_timestamped_migrations'
+    @m.apply(@db, @dir, 0)
+    [:sm1111, :sm1122, :sm2222, :sm2233, :sm3333].each{|n| @db.table_exists?(n).should be_false}
+    @db[:schema_migrations].select_order_map(:filename).should == []
   end
 
-  specify "should apply migrations up to the latest version if no target is given" do
-    Sequel::Migrator.apply(@db, @dirname)
-    @db.creates.should == [1111, 2222, 3333, 5555]
+  specify "should handle updating to a specific timestamp when interleaving migrations" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    @dir = 'spec/files/interleaved_timestamped_migrations'
+    @m.apply(@db, @dir, 1273253851)
+    [:schema_migrations, :sm1111, :sm1122, :sm2222].each{|n| @db.table_exists?(n).should be_true}
+    [:sm2233, :sm3333].each{|n| @db.table_exists?(n).should be_false}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253850_create_artists.rb 1273253851_create_nodes.rb'
+  end
+
+  specify "should correctly update schema_migrations table when an error occurs when migrating up or down" do
+    @dir = 'spec/files/bad_timestamped_migrations'
+    proc{@m.apply(@db, @dir)}.should raise_error
+    [:schema_migrations, :sm1111, :sm2222].each{|n| @db.table_exists?(n).should be_true}
+    @db.table_exists?(:sm3333).should be_false
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253851_create_nodes.rb'
+    proc{@m.apply(@db, @dir, 0)}.should raise_error
+    [:sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_false}
+    @db.table_exists?(:sm1111).should be_true
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb'
+  end
+
+  specify "should handle multiple migrations with the same timestamp correctly" do
+    @dir = 'spec/files/duplicate_timestamped_migrations'
+    @m.apply(@db, @dir)
+    [:schema_migrations, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_true}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253853_create_nodes.rb 1273253853_create_users.rb'
+    @m.apply(@db, @dir, 1273253853)
+    [:sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_true}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253853_create_nodes.rb 1273253853_create_users.rb'
+    @m.apply(@db, @dir, 1273253849)
+    [:sm1111].each{|n| @db.table_exists?(n).should be_true}
+    [:sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_false}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb'
+    @m.apply(@db, @dir, 1273253848)
+    [:sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_false}
+    @db[:schema_migrations].select_order_map(:filename).should == []
+  end
+
+  specify "should convert schema_info table to schema_migrations table" do
+    @dir = 'spec/files/integer_migrations'
+    @m.apply(@db, @dir)
+    [:schema_info, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_true}
+    [:schema_migrations, :sm1122, :sm2233].each{|n| @db.table_exists?(n).should be_false}
+
+    @dir = 'spec/files/convert_to_timestamp_migrations'
+    @m.apply(@db, @dir)
+    [:schema_info, :sm1111, :sm2222, :sm3333, :schema_migrations, :sm1122, :sm2233].each{|n| @db.table_exists?(n).should be_true}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'001_create_sessions.rb 002_create_nodes.rb 003_3_create_users.rb 1273253850_create_artists.rb 1273253852_create_albums.rb'
+
+    @m.apply(@db, @dir, 4)
+    [:schema_info, :schema_migrations, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_true}
+    [:sm1122, :sm2233].each{|n| @db.table_exists?(n).should be_false}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'001_create_sessions.rb 002_create_nodes.rb 003_3_create_users.rb'
 
-    Sequel::Migrator.get_current_migration_version(@db).should == 5
-    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
-      "SELECT * FROM schema_info LIMIT 1",
-      "SELECT * FROM schema_info LIMIT 1",
-      "INSERT INTO schema_info (version) VALUES (5)",
-      "SELECT * FROM schema_info LIMIT 1"]
+    @m.apply(@db, @dir, 0)
+    [:schema_info, :schema_migrations].each{|n| @db.table_exists?(n).should be_true}
+    [:sm1111, :sm2222, :sm3333, :sm1122, :sm2233].each{|n| @db.table_exists?(n).should be_false}
+    @db[:schema_migrations].select_order_map(:filename).should == []
   end
 
-  specify "should apply migrations down to 0 version correctly" do
-    Sequel::Migrator.apply(@db, @dirname, 0, 5)
-    @db.drops.should == [5555, 3333, 2222, 1111]
+  specify "should handle unapplied migrations when migrating schema_info table to schema_migrations table" do
+    @dir = 'spec/files/integer_migrations'
+    @m.apply(@db, @dir, 2)
+    [:schema_info, :sm1111, :sm2222].each{|n| @db.table_exists?(n).should be_true}
+    [:schema_migrations, :sm3333, :sm1122, :sm2233].each{|n| @db.table_exists?(n).should be_false}
 
-    Sequel::Migrator.get_current_migration_version(@db).should == 0
-    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
-      "SELECT * FROM schema_info LIMIT 1",
-      "INSERT INTO schema_info (version) VALUES (0)",
-      "SELECT * FROM schema_info LIMIT 1"]
+    @dir = 'spec/files/convert_to_timestamp_migrations'
+    @m.apply(@db, @dir, 1273253850)
+    [:schema_info, :sm1111, :sm2222, :sm3333, :schema_migrations, :sm1122].each{|n| @db.table_exists?(n).should be_true}
+    [:sm2233].each{|n| @db.table_exists?(n).should be_false}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'001_create_sessions.rb 002_create_nodes.rb 003_3_create_users.rb 1273253850_create_artists.rb'
+  end
+
+  specify "should handle unapplied migrations when migrating schema_info table to schema_migrations table and target is less than last integer migration version" do
+    @dir = 'spec/files/integer_migrations'
+    @m.apply(@db, @dir, 1)
+    [:schema_info, :sm1111].each{|n| @db.table_exists?(n).should be_true}
+    [:schema_migrations, :sm2222, :sm3333, :sm1122, :sm2233].each{|n| @db.table_exists?(n).should be_false}
+
+    @dir = 'spec/files/convert_to_timestamp_migrations'
+    @m.apply(@db, @dir, 2)
+    [:schema_info, :sm1111, :sm2222, :schema_migrations].each{|n| @db.table_exists?(n).should be_true}
+    [:sm3333, :sm1122, :sm2233].each{|n| @db.table_exists?(n).should be_false}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'001_create_sessions.rb 002_create_nodes.rb'
+
+    @m.apply(@db, @dir)
+    [:schema_info, :sm1111, :sm2222, :schema_migrations, :sm3333, :sm1122, :sm2233].each{|n| @db.table_exists?(n).should be_true}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'001_create_sessions.rb 002_create_nodes.rb 003_3_create_users.rb 1273253850_create_artists.rb 1273253852_create_albums.rb'
+  end
+
+  specify "should raise error for applied migrations not in file system" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    [:schema_migrations, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_true}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253851_create_nodes.rb 1273253853_3_create_users.rb'
+
+    @dir = 'spec/files/missing_timestamped_migrations'
+    proc{@m.apply(@db, @dir, 0)}.should raise_error(Sequel::Migrator::Error)
+    [:schema_migrations, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_true}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253851_create_nodes.rb 1273253853_3_create_users.rb'
   end
   
-  specify "should return the target version" do
-    Sequel::Migrator.apply(@db, @dirname, 3, 2).should == 3
-    Sequel::Migrator.apply(@db, @dirname, 0).should == 0
-    Sequel::Migrator.apply(@db, @dirname).should == 5
+  specify "should raise error missing column name in existing schema_migrations table" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    proc{@m.run(@db, @dir, :column=>:fn)}.should raise_error(Sequel::Migrator::Error)
+  end
+  
+  specify "should handle migration filenames in a case insensitive manner" do
+    @dir = 'spec/files/uppercase_timestamped_migrations'
+    @m.apply(@db, @dir)
+    [:schema_migrations, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_true}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253851_create_nodes.rb 1273253853_3_create_users.rb'
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir, 0)
+    [:sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_false}
+    @db[:schema_migrations].select_order_map(:filename).should == []
+  end
+
+  specify "should :table and :column options" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.run(@db, @dir, :table=>:sm, :column=>:fn)
+    [:sm, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_true}
+    @db[:sm].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253851_create_nodes.rb 1273253853_3_create_users.rb'
+    @m.run(@db, @dir, :target=>0, :table=>:sm, :column=>:fn)
+    [:sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_false}
+    @db[:sm].select_order_map(:fn).should == []
+  end
+
+  specify "should return nil" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir, 1273253850).should == nil
+    @m.apply(@db, @dir, 0).should == nil
+    @m.apply(@db, @dir).should == nil
   end
 end