sequel_core 1.0

data/spec/migration_spec.rb

@@ -0,0 +1,261 @@
+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

@@ -0,0 +1,66 @@
+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

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

data/spec/schema_generator_spec.rb

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,230 @@
+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