sequel 0.5.0.2 → 1.0

data/spec/migration_spec.rb

@@ -1,261 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-context "Migration classes" do
-  setup do
-    Sequel::Migration.descendants.clear
-  end
-
-  specify "should be registred in Migration.descendants" do
-    @class = Class.new(Sequel::Migration)
-    
-    Sequel::Migration.descendants.should == [@class]
-  end
-  
-  specify "should be registered in the right order" do
-    @c1 = Class.new(Sequel::Migration)
-    @c2 = Class.new(Sequel::Migration)
-    @c3 = Class.new(Sequel::Migration)
-    
-    Sequel::Migration.descendants.should == [@c1, @c2, @c3]
-  end
-end
-
-context "Migration#apply" do
-  setup 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)
-  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
-
-class DummyMigrationDataset
-  attr_reader :from
-  
-  def initialize(x); @from = x; end
-  
-  @@version = nil
-  
-  def version; @@version; end
-  def version=(x); @@version = x; end
-  def first; @@version ? {:version => @@version} : nil; end
-  def update(h); @@version = h[:version]; end
-  def <<(h); @@version = h[:version]; end
-end
-
-class DummyMigrationDB
-  attr_reader :creates, :drops, :table_created
-  
-  def initialize
-    @creates = []
-    @drops = []
-  end
-  
-  def create(x); @creates << x; end
-  def drop(x); @drops << x; end
-  
-  def [](x); DummyMigrationDataset.new(x); end
-  
-  def create_table(x); raise if @table_created == x; @table_created = x; end
-  def table_exists?(x); @table_created == x; end
-  
-  def transaction; yield; end
-end
-
-MIGRATION_001 = %[
-  class CreateSessions < Sequel::Migration
-    def up
-      create(1111)
-    end
-    
-    def down
-      drop(1111)
-    end
-  end
-]
-
-MIGRATION_002 = %[
-  class CreateNodes < Sequel::Migration
-    def up
-      create(2222)
-    end
-    
-    def down
-      drop(2222)
-    end
-  end
-]
-
-MIGRATION_003 = %[
-  class CreateUsers < Sequel::Migration
-    def up
-      create(3333)
-    end
-    
-    def down
-      drop(3333)
-    end
-  end
-]
-
-MIGRATION_005 = %[
-  class CreateAttributes < Sequel::Migration
-    def up
-      create(5555)
-    end
-    
-    def down
-      drop(5555)
-    end
-  end
-]
-
-context "Sequel::Migrator" do
-  setup do
-    @db = DummyMigrationDB.new
-    
-    File.open('001_create_sessions.rb', 'w') {|f| f << MIGRATION_001}
-    File.open('002_create_nodes.rb', 'w') {|f| f << MIGRATION_002}
-    File.open('003_create_users.rb', 'w') {|f| f << MIGRATION_003}
-    File.open('005_create_attributes.rb', 'w') {|f| f << MIGRATION_005}
-    
-    @db[:schema_info].version = nil
-  end
-  
-  teardown 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")
-
-    FileUtils.rm('001_create_sessions.rb')
-    FileUtils.rm('002_create_nodes.rb')
-    FileUtils.rm('003_create_users.rb')
-    FileUtils.rm('005_create_attributes.rb')
-  end
-  
-  specify "should return the list of files for a specified version range" do
-    Sequel::Migrator.migration_files('.', 1..1).should == \
-      ['./001_create_sessions.rb']
-
-    Sequel::Migrator.migration_files('.', 1..3).should == \
-      ['./001_create_sessions.rb', './002_create_nodes.rb', './003_create_users.rb']
-
-    Sequel::Migrator.migration_files('.', 3..5).should == \
-      ['./003_create_users.rb', './005_create_attributes.rb']
-      
-    Sequel::Migrator.migration_files('.', 7..8).should == []
-  end
-  
-  specify "should return the latest version available" do
-    Sequel::Migrator.latest_migration_version('.').should == 5
-  end
-  
-  specify "should load the migration classes for the specified range" do
-    Sequel::Migrator.migration_classes('.', 3, 0, :up).should == \
-      [CreateSessions, CreateNodes, CreateUsers]
-  end
-  
-  specify "should load the migration classes for the specified range" do
-    Sequel::Migrator.migration_classes('.', 0, 5, :down).should == \
-      [CreateAttributes, CreateUsers, CreateNodes, CreateSessions]
-  end
-  
-  specify "should start from current + 1 for the up direction" do
-    Sequel::Migrator.migration_classes('.', 3, 1, :up).should == \
-      [CreateNodes, CreateUsers]
-  end
-  
-  specify "should end on current + 1 for the down direction" do
-    Sequel::Migrator.migration_classes('.', 2, 5, :down).should == \
-      [CreateAttributes, CreateUsers]
-  end
-  
-  specify "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
-    
-    # should not raise if table already exists
-    proc {Sequel::Migrator.schema_info_dataset(@db)}.should_not raise_error
-  end
-  
-  specify "should return a dataset for the schema_info table" do
-    d = Sequel::Migrator.schema_info_dataset(@db)
-    d.from.should == :schema_info
-  end
-  
-  specify "should get the migration version stored in the database" do
-    # default is 0
-    Sequel::Migrator.get_current_migration_version(@db).should == 0
-    
-    Sequel::Migrator.schema_info_dataset(@db) << {:version => 4321}
-
-    Sequel::Migrator.get_current_migration_version(@db).should == 4321
-  end
-  
-  specify "should set the migration version stored in the database" do
-    Sequel::Migrator.get_current_migration_version(@db).should == 0
-    Sequel::Migrator.set_current_migration_version(@db, 6666)
-    Sequel::Migrator.get_current_migration_version(@db).should == 6666
-  end
-  
-  specify "should apply migrations correctly in the up direction" do
-    Sequel::Migrator.apply(@db, '.', 3, 2)
-    @db.creates.should == [3333]
-    
-    Sequel::Migrator.get_current_migration_version(@db).should == 3
-
-    Sequel::Migrator.apply(@db, '.', 5)
-    @db.creates.should == [3333, 5555]
-
-    Sequel::Migrator.get_current_migration_version(@db).should == 5
-  end
-  
-  specify "should apply migrations correctly in the down direction" do
-    Sequel::Migrator.apply(@db, '.', 1, 5)
-    @db.drops.should == [5555, 3333, 2222]
-
-    Sequel::Migrator.get_current_migration_version(@db).should == 1
-  end
-
-  specify "should apply migrations up to the latest version if no target is given" do
-    Sequel::Migrator.apply(@db, '.')
-    @db.creates.should == [1111, 2222, 3333, 5555]
-
-    Sequel::Migrator.get_current_migration_version(@db).should == 5
-  end
-
-  specify "should apply migrations down to 0 version correctly" do
-    Sequel::Migrator.apply(@db, '.', 0, 5)
-    @db.drops.should == [5555, 3333, 2222, 1111]
-
-    Sequel::Migrator.get_current_migration_version(@db).should == 0
-  end
-  
-  specify "should return the target version" do
-    Sequel::Migrator.apply(@db, '.', 3, 2).should == 3
-
-    Sequel::Migrator.apply(@db, '.', 0).should == 0
-
-    Sequel::Migrator.apply(@db, '.').should == 5
-  end
-end

data/spec/pretty_table_spec.rb

@@ -1,66 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-require 'stringio'
-
-context "PrettyTable" do
-  setup do
-    @data1 = [
-      {:x => 3, :y => 4}
-    ]
-    
-    @data2 = [
-      {:a => 23, :b => 45},
-      {:a => 45, :b => 2377}
-    ]
-
-    @data3 = [
-      {:aaa => 1},
-      {:bb => 2},
-      {:c => 3}
-    ]
-
-    @output = StringIO.new
-    @orig_stdout = $stdout
-    $stdout = @output
-  end
-
-  teardown do
-    $stdout = @orig_stdout
-  end
-  
-  specify "should infer the columns if not given" do
-    Sequel::PrettyTable.print(@data1)
-    @output.rewind
-    @output.read.should =~ \
-      /\n(\|x\|y\|)|(\|y\|x\|)\n/
-  end
-  
-  specify "should infer columns from array with keys" do
-    a = [1, 2, 3]
-	  a.keys = [:a, :b, :c]
-	  Sequel::PrettyTable.print([a])
-    @output.rewind
-    @output.read.should =~ /\n\|a\|b\|c\|\n/
-  end
-  
-  specify "should calculate the maximum width of each column correctly" do
-    Sequel::PrettyTable.print(@data2, [:a, :b])
-    @output.rewind
-    @output.read.should == \
-      "+--+----+\n|a |b   |\n+--+----+\n|23|  45|\n|45|2377|\n+--+----+\n"
-  end
-
-  specify "should also take header width into account" do
-    Sequel::PrettyTable.print(@data3, [:aaa, :bb, :c])
-    @output.rewind
-    @output.read.should == \
-      "+---+--+-+\n|aaa|bb|c|\n+---+--+-+\n|  1|  | |\n|   | 2| |\n|   |  |3|\n+---+--+-+\n"
-  end
-  
-  specify "should print only the specified columns" do
-    Sequel::PrettyTable.print(@data2, [:a])
-    @output.rewind
-    @output.read.should == \
-      "+--+\n|a |\n+--+\n|23|\n|45|\n+--+\n"
-  end
-end

data/spec/rcov.opts

@@ -1,4 +0,0 @@
---exclude
-gems
---exclude
-spec

data/spec/schema_generator_spec.rb

@@ -1,86 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe Sequel::Schema::Generator do
-  before :all do
-    @generator = Sequel::Schema::Generator.new(SchemaDummyDatabase.new) do
-      string :title
-      column :body, :text
-      foreign_key :parent_id
-      primary_key :id
-      index :title
-      index [:title, :body]
-    end
-    @columns, @indexes = @generator.create_info
-  end
-  
-  {:name => :id, :primary_key => true}.each do |column, expected|
-    it "uses default primary key #{column}" do
-      @columns.first[column].should == expected
-    end
-  end
-  
-  it "counts primary key as column" do
-    @columns.size.should == 4
-  end
-  
-  it "places primary key first" do
-    @columns[0][:primary_key].should     be_true
-    @columns[1][:primary_key].should_not be_true
-    @columns[2][:primary_key].should_not be_true
-  end
-
-  it "retrieves primary key name" do
-    @generator.primary_key_name.should == :id
-  end
-
-  it "keeps columns in order" do
-    @columns[1][:name].should == :title
-    @columns[1][:type].should == :string
-    @columns[2][:name].should == :body
-    @columns[2][:type].should == :text
-  end
-  
-  it "creates foreign key column" do
-    @columns[3][:name].should == :parent_id
-    @columns[3][:type].should == :integer
-  end
-  
-  it "finds columns" do
-    [:title, :body, :parent_id, :id].each do |col|
-      @generator.has_column?(col).should be_true
-    end
-    @generator.has_column?(:foo).should_not be_true
-  end
-  
-  it "creates indexes" do
-    @indexes[0][:columns].should include(:title)
-    @indexes[1][:columns].should include(:title)
-    @indexes[1][:columns].should include(:body)
-  end
-end
-
-describe Sequel::Schema::AlterTableGenerator do
-  before :all do
-    @generator = Sequel::Schema::AlterTableGenerator.new(SchemaDummyDatabase.new) do
-      add_column :aaa, :text
-      drop_column :bbb
-      rename_column :ccc, :ho
-      set_column_type :ddd, :float
-      set_column_default :eee, 1
-      add_index [:fff, :ggg]
-      drop_index :hhh
-    end
-  end
-  
-  specify "should generate operation records" do
-    @generator.operations.should == [
-      {:op => :add_column, :name => :aaa, :type => :text},
-      {:op => :drop_column, :name => :bbb},
-      {:op => :rename_column, :name => :ccc, :new_name => :ho},
-      {:op => :set_column_type, :name => :ddd, :type => :float},
-      {:op => :set_column_default, :name => :eee, :default => 1},
-      {:op => :add_index, :columns => [:fff, :ggg]},
-      {:op => :drop_index, :columns => [:hhh]}
-    ]
-  end
-end

data/spec/schema_spec.rb

@@ -1,230 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-context "DB#create_table" do
-  setup do
-    @db = SchemaDummyDatabase.new
-  end
-  
-  specify "should accept the table name" do
-    @db.create_table(:cats) {}
-    @db.sqls.should == ['CREATE TABLE cats ()']
-  end
-
-  specify "should accept multiple columns" do
-    @db.create_table(:cats) do
-      column :id, :integer
-      column :name, :text
-    end
-    @db.sqls.should == ['CREATE TABLE cats (id integer, name text)']
-  end
-  
-  specify "should accept method calls as data types" do
-    @db.create_table(:cats) do
-      integer :id
-      text :name
-    end
-    @db.sqls.should == ['CREATE TABLE cats (id integer, name text)']
-  end
-
-  specify "should accept primary key definition" do
-    @db.create_table(:cats) do
-      primary_key :id
-    end
-    @db.sqls.should == ['CREATE TABLE cats (id integer PRIMARY KEY AUTOINCREMENT)']
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      primary_key :id, :serial, :auto_increment => false
-    end
-    @db.sqls.should == ['CREATE TABLE cats (id serial PRIMARY KEY)']
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      primary_key :id, :type => :serial, :auto_increment => false
-    end
-    @db.sqls.should == ['CREATE TABLE cats (id serial PRIMARY KEY)']
-  end
-
-  specify "should accept and literalize default values" do
-    @db.create_table(:cats) do
-      integer :id, :default => 123
-      text :name, :default => "abc'def"
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer DEFAULT 123, name text DEFAULT 'abc''def')"]
-  end
-  
-  specify "should accept not null definition" do
-    @db.create_table(:cats) do
-      integer :id
-      text :name, :null => false
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer, name text NOT NULL)"]
-  end
-  
-  specify "should accept unique definition" do
-    @db.create_table(:cats) do
-      integer :id
-      text :name, :unique => true
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer, name text UNIQUE)"]
-  end
-  
-  specify "should accept [SET|ENUM](...) types" do
-    @db.create_table(:cats) do
-      set :color, :elements => ['black', 'tricolor', 'grey']
-    end
-    @db.sqls.should == ["CREATE TABLE cats (color set('black', 'tricolor', 'grey'))"]
-  end
-  
-  specify "should accept varchar size" do
-    @db.create_table(:cats) do
-      varchar :name
-    end
-    @db.sqls.should == ["CREATE TABLE cats (name varchar(255))"]
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      varchar :name, :size => 51
-    end
-    @db.sqls.should == ["CREATE TABLE cats (name varchar(51))"]
-  end
-
-  specify "should accept foreign keys" do
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects)"]
-  end
-  
-  specify "should accept foreign keys with arbitrary keys" do
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :key => :id
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects(id))"]
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :key => :zzz
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects(zzz))"]
-  end
-  
-  specify "should accept foreign keys with ON DELETE clause" do
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :on_delete => :restrict
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE RESTRICT)"]
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :on_delete => :cascade
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE CASCADE)"]
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :on_delete => :no_action
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE NO ACTION)"]
-    @db.sqls.clear
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :on_delete => :set_null
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE SET NULL)"]
-    @db.sqls.clear
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :on_delete => :set_default
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE SET DEFAULT)"]
-    @db.sqls.clear
-  end
-  
-  specify "should accept inline index definition" do
-    @db.create_table(:cats) do
-      integer :id, :index => true
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE 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
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE CASCADE)",
-      "CREATE INDEX cats_project_id_index ON cats (project_id)"]
-  end
-  
-  specify "should accept index definitions" do
-    @db.create_table(:cats) do
-      integer :id
-      index :id
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_id_index ON cats (id)"]
-  end
-
-  specify "should accept unique index definitions" do
-    @db.create_table(:cats) do
-      text :name
-      unique :name
-    end
-    @db.sqls.should == ["CREATE TABLE cats (name text)", "CREATE UNIQUE INDEX cats_name_index ON cats (name)"]
-  end
-
-  specify "should accept multiple index definitions" do
-    @db.create_table(:cats) do
-      integer :id
-      index :id
-      index :name
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_id_index ON cats (id)", "CREATE INDEX cats_name_index ON cats (name)"]
-  end
-  
-  specify "should accept custom index names" do
-    @db.create_table(:cats) do
-      integer :id
-      index :id, :name => 'abc'
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX abc ON cats (id)"]
-  end
-
-  specify "should accept unique index definitions" do
-    @db.create_table(:cats) do
-      integer :id
-      index :id, :unique => true
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE UNIQUE INDEX cats_id_index ON cats (id)"]
-  end
-  
-  specify "should accept composite index definitions" do
-    @db.create_table(:cats) do
-      integer :id
-      index [:id, :name], :unique => true
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE UNIQUE INDEX cats_id_name_index ON cats (id, name)"]
-  end
-end
-
-context "DB#create_table!" do
-  setup do
-    @db = SchemaDummyDatabase.new
-  end
-  
-  specify "should drop the table and then create it" do
-    @db.create_table!(:cats) {}
-    @db.sqls.should == ['DROP TABLE cats', 'CREATE TABLE cats ()']
-  end
-end
-
-context "DB#drop_table" do
-  setup do
-    @db = SchemaDummyDatabase.new
-  end
-
-  specify "should generate a DROP TABLE statement" do
-    @db.drop_table :cats
-    @db.sqls.should == ['DROP TABLE cats']
-  end
-end