schema_plus 0.1.0.pre1

data/spec/connections/mysql/connection.rb

@@ -0,0 +1,18 @@
+print "Using MySQL\n"
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new(File.open("mysql.log", "w"))
+
+ActiveRecord::Base.configurations = {
+  'schema_plus' => {
+    :adapter => 'mysql',
+    :database => 'schema_plus_unittest',
+    :username => 'schema_plus',
+    :encoding => 'utf8',
+    :socket => '/tmp/mysql.sock',
+    :min_messages => 'warning'
+  }
+
+}
+
+ActiveRecord::Base.establish_connection 'schema_plus'

data/spec/connections/mysql2/connection.rb

@@ -0,0 +1,18 @@
+print "Using MySQL2\n"
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new(File.open("mysql2.log", "w"))
+
+ActiveRecord::Base.configurations = {
+  'schema_plus' => {
+    :adapter => 'mysql2',
+    :database => 'schema_plus_unittest',
+    :username => 'schema_plus',
+    :encoding => 'utf8',
+    :socket => '/tmp/mysql.sock',
+    :min_messages => 'warning'
+  }
+
+}
+
+ActiveRecord::Base.establish_connection 'schema_plus'

data/spec/connections/postgresql/connection.rb

@@ -0,0 +1,15 @@
+print "Using PostgreSQL\n"
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new(File.open("postgresql.log", "w"))
+
+ActiveRecord::Base.configurations = {
+  'schema_plus' => {
+    :adapter => 'postgresql',
+    :database => 'schema_plus_unittest',
+    :min_messages => 'warning'
+  }
+
+}
+
+ActiveRecord::Base.establish_connection 'schema_plus'

data/spec/connections/sqlite3/connection.rb

@@ -0,0 +1,14 @@
+print "Using SQLite3\n"
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new(File.open("sqlite3.log", "w"))
+
+ActiveRecord::Base.configurations = {
+  'schema_plus' => {
+    :adapter => 'sqlite3',
+    :database => File.expand_path('schema_plus.sqlite3', File.dirname(__FILE__)),
+  }
+
+}
+
+ActiveRecord::Base.establish_connection 'schema_plus'

data/spec/foreign_key_definition_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Foreign Key definition" do
+
+  before(:all) do
+    load_core_schema
+  end
+
+  let(:definition) { SchemaPlus::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new("posts_user_fkey", :posts, :user, :users, :id) }
+
+  it "it is dumped to sql with quoted values" do
+    definition.to_sql.should == %Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')})}
+  end
+
+  def quote_table_name(table)
+    ActiveRecord::Base.connection.quote_table_name(table)
+  end
+
+  def quote_column_name(column)
+    ActiveRecord::Base.connection.quote_column_name(column)
+  end
+
+end

data/spec/foreign_key_spec.rb

@@ -0,0 +1,142 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'models/user'
+require 'models/post'
+require 'models/comment'
+
+describe "Foreign Key" do
+  
+  before(:all) do
+    load_core_schema
+  end
+
+  let(:migration) { ::ActiveRecord::Migration }
+
+  if SchemaPlusHelpers.sqlite3?
+
+    it "raises an exception when attempting to add" do
+      expect { 
+        add_foreign_key(:posts, :author_id, :users, :id, :on_update => :cascade, :on_delete => :restrict)
+      }.should raise_error(NotImplementedError)
+    end
+
+    it "raises an exception when attempting to remove" do
+      expect { 
+        remove_foreign_key(:posts, "dummy")
+      }.should raise_error(NotImplementedError)
+    end
+
+  else
+
+    context "when is added", "posts(author_id)" do
+
+      before(:each) do 
+        add_foreign_key(:posts, :author_id, :users, :id, :on_update => :cascade, :on_delete => :restrict)
+      end
+
+      after(:each) do
+        fk = Post.foreign_keys.detect { |fk| fk.column_names == %w[author_id] }
+        remove_foreign_key(:posts, fk.name)
+      end
+
+      it "references users(id)" do
+        Post.should reference(:users, :id).on(:author_id)
+      end
+
+      it "cascades on update" do
+        Post.should reference(:users).on_update(:cascade)
+      end
+
+      it "restricts on delete" do
+        Post.should reference(:users).on_delete(:restrict)
+      end
+
+      it "is available in Post.foreign_keys" do
+        Post.foreign_keys.collect(&:column_names).should include(%w[author_id])
+      end
+
+      it "is available in User.reverse_foreign_keys" do
+        User.reverse_foreign_keys.collect(&:column_names).should include(%w[author_id])
+      end
+
+    end
+
+    context "when is dropped", "comments(post_id)" do
+
+      let(:foreign_key_name) { fk = Comment.foreign_keys.detect { |definition| definition.column_names == %w[post_id] } and fk.name }
+
+      before(:each) do
+        remove_foreign_key(:comments, foreign_key_name)
+      end
+
+      after(:each) do
+        add_foreign_key(:comments, :post_id, :posts, :id)
+      end
+
+      it "doesn't reference posts(id)" do
+        Comment.should_not reference(:posts).on(:post_id)
+      end
+
+      it "is no longer available in Post.foreign_keys" do
+        Comment.foreign_keys.collect(&:column_names).should_not include(%w[post_id])
+      end
+
+      it "is no longer available in User.reverse_foreign_keys" do
+        Post.reverse_foreign_keys.collect(&:column_names).should_not include(%w[post_id])
+      end
+
+    end
+
+    context "when referencing column and column is removed" do
+
+      let(:foreign_key_name) { Comment.foreign_keys.detect { |definition| definition.column_names == %w[post_id] }.name }
+
+      it "should remove foreign keys" do
+        remove_foreign_key(:comments, foreign_key_name)
+        Post.reverse_foreign_keys.collect { |fk| fk.column_names == %w[post_id] && fk.table_name == "comments" }.should be_empty
+      end
+
+    end
+
+    context "when table name is a rerved word" do
+      before(:each) do
+        migration.suppress_messages do
+          migration.create_table :references, :force => true do |t|
+            t.integer :post_id
+          end
+        end
+      end
+
+      it "can add, detect, and remove a foreign key without error" do
+        migration.suppress_messages do
+          expect {
+            migration.add_foreign_key(:references, :post_id, :posts, :id)
+            foreign_key = migration.foreign_keys(:references).detect{|definition| definition.column_names == ["post_id"]}
+            migration.remove_foreign_key(:references, foreign_key.name)
+          }.should_not raise_error
+        end
+      end
+    end
+
+  end
+
+  protected
+  def add_foreign_key(*args)
+    migration.suppress_messages do
+      migration.add_foreign_key(*args)
+    end
+    User.reset_column_information
+    Post.reset_column_information
+    Comment.reset_column_information
+  end
+
+  def remove_foreign_key(*args)
+    migration.suppress_messages do
+      migration.remove_foreign_key(*args)
+    end
+    User.reset_column_information
+    Post.reset_column_information
+    Comment.reset_column_information
+  end
+
+end

data/spec/index_definition_spec.rb

@@ -0,0 +1,139 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+
+describe "Index definition" do
+
+  let(:migration) { ::ActiveRecord::Migration }
+  
+  before(:all) do
+    load_core_schema
+  end
+
+  around(:each) do |example|
+    migration.suppress_messages do
+      example.run
+    end
+  end
+
+  after(:each) do
+    migration.remove_index :users, :name => 'users_login_index' if migration.index_name_exists? :users, 'users_login_index', true
+  end
+
+  context "when index is multicolumn" do
+    before(:each) do
+      migration.execute "CREATE INDEX users_login_index ON users (login, deleted_at)"
+      User.reset_column_information
+      @index = index_definition(%w[login deleted_at])
+    end
+
+    it "is included in User.indexes" do
+      User.indexes.select { |index| index.columns == %w[login deleted_at] }.should have(1).item
+    end
+
+  end
+
+  it "should correctly report supports_partial_indexes?" do
+    query = lambda { migration.execute "CREATE INDEX users_login_index ON users(login) WHERE deleted_at IS NULL" }
+    if migration.supports_partial_indexes?
+      query.should_not raise_error
+    else
+      query.should raise_error
+    end
+  end
+
+  if SchemaPlusHelpers.postgresql?
+
+    context "when case insensitive is added" do
+
+      before(:each) do
+        migration.execute "CREATE INDEX users_login_index ON users(LOWER(login))"
+        User.reset_column_information
+        @index = User.indexes.detect { |i| i.expression =~ /lower\(\(login\)::text\)/i }
+      end
+
+      it "is included in User.indexes" do
+        @index.should_not be_nil
+      end
+
+      it "is not case_sensitive" do
+        @index.should_not be_case_sensitive
+      end
+
+      it "its column should not be case sensitive" do
+        User.columns.find{|column| column.name == "login"}.should_not be_case_sensitive
+      end
+
+      it "defines expression" do
+        @index.expression.should == "lower((login)::text)"
+      end
+
+      it "doesn't define conditions" do
+        @index.conditions.should be_nil
+      end
+
+    end
+
+
+    context "when index is partial and column is not downcased" do
+      before(:each) do
+        migration.execute "CREATE INDEX users_login_index ON users(login) WHERE deleted_at IS NULL"
+        User.reset_column_information
+        @index = index_definition("login")
+      end
+
+      it "is included in User.indexes" do
+        User.indexes.select { |index| index.columns == ["login"] }.should have(1).item
+      end
+
+      it "is case_sensitive" do
+        @index.should be_case_sensitive
+      end
+
+      it "doesn't define expression" do
+        @index.expression.should be_nil
+      end
+
+      it "defines conditions" do
+        @index.conditions.should == "(deleted_at IS NULL)"
+      end
+
+    end
+
+    context "when index contains expression" do
+      before(:each) do
+        migration.execute "CREATE INDEX users_login_index ON users (extract(EPOCH from deleted_at)) WHERE deleted_at IS NULL"
+        User.reset_column_information
+        @index = User.indexes.detect { |i| i.expression.present? }
+      end
+
+      it "exists" do
+        @index.should_not be_nil
+      end
+
+      it "doesnt have columns defined" do
+        @index.columns.should be_empty
+      end
+
+      it "is case_sensitive" do
+        @index.should be_case_sensitive
+      end
+
+      it "defines expression" do
+        @index.expression.should == "date_part('epoch'::text, deleted_at)"
+      end
+
+      it "defines conditions" do
+        @index.conditions.should == "(deleted_at IS NULL)"
+      end
+
+    end
+
+  end # of postgresql specific examples
+
+  protected
+  def index_definition(column_names)
+    User.indexes.detect { |index| index.columns == Array(column_names) }
+  end
+
+
+end

data/spec/index_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'models/user'
+
+describe "add_index" do
+  
+  before(:all) do
+    load_core_schema
+  end
+
+  let(:migration) { ::ActiveRecord::Migration }
+
+  after(:each) do
+    migration.suppress_messages do
+      migration.remove_index(:users, :name => @index.name) if @index
+    end
+  end
+
+  it "should create index when called without additional options" do
+    add_index(:users, :login)
+    index_for(:login).should_not be_nil
+  end
+
+  it "should create unique index" do
+    add_index(:users, :login, :unique => true)
+    index_for(:login).unique.should == true
+  end
+
+  it "should assign given name" do
+    add_index(:users, :login, :name => 'users_login_index')
+    index_for(:login).name.should == 'users_login_index'
+  end
+
+  if SchemaPlusHelpers.postgresql?
+
+    it "should assign conditions" do
+      add_index(:users, :login, :conditions => 'deleted_at IS NULL')
+      index_for(:login).conditions.should == '(deleted_at IS NULL)'
+    end
+
+    it "should assign expression" do
+      add_index(:users, :expression => "USING hash (upper(login)) WHERE deleted_at IS NULL", :name => 'users_login_index')
+      @index = User.indexes.detect { |i| i.expression.present? }
+      @index.expression.should == "upper((login)::text)"
+      @index.conditions.should == "(deleted_at IS NULL)"
+    end
+
+    it "should raise if no column given and expression is missing" do
+      expect { add_index(:users, :name => 'users_login_index') }.should raise_error(ArgumentError)
+    end
+
+    it "should raise if expression without name is given" do
+      expect { add_index(:users, :expression => "USING btree (login)") }.should raise_error(ArgumentError)
+    end
+
+  end # of postgresql specific examples
+
+  protected
+  def add_index(*args)
+    migration.suppress_messages do
+      migration.add_index(*args)
+    end
+    User.reset_column_information
+  end
+
+  def index_for(column_names)
+    @index = User.indexes.detect { |i| i.columns == Array(column_names).collect(&:to_s) }
+  end
+
+
+end