aspgems-redhillonrails_core 2.0.0.beta1

data/spec/index_definition_spec.rb

@@ -0,0 +1,145 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'models/user'
+
+describe "Index definition" do
+
+  let(:migration) { ::ActiveRecord::Migration }
+
+  context "when index is multicolumn" do
+    before(:each) do
+      migration.suppress_messages do
+        migration.execute "CREATE INDEX users_login_index ON users (login, deleted_at)"
+      end
+      User.reset_column_information
+      @index = index_definition(%w[login deleted_at])
+    end
+
+    after(:each) do
+      migration.suppress_messages do
+        migration.remove_index :users, :name => 'users_login_index'
+      end
+    end
+
+    it "is included in User.indexes" do
+      User.indexes.select { |index| index.columns == %w[login deleted_at] }.should have(1).item
+    end
+
+  end
+
+  if ::ActiveRecord::Base.connection.class.include?(RedhillonrailsCore::ActiveRecord::ConnectionAdapters::PostgresqlAdapter)
+
+    context "when case insensitive is added" do
+
+      before(:each) do
+        migration.suppress_messages do
+          migration.execute "CREATE INDEX users_login_index ON users(LOWER(login))"
+        end
+        User.reset_column_information
+        @index = User.indexes.detect { |i| i.expression =~ /lower\(\(login\)::text\)/i }
+      end
+
+      after(:each) do
+        migration.suppress_messages do
+          migration.remove_index :users, :name => 'users_login_index'
+        end
+      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 "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.suppress_messages do
+          migration.execute "CREATE INDEX users_login_index ON users(login) WHERE deleted_at IS NULL"
+        end
+        User.reset_column_information
+        @index = index_definition("login")
+      end
+
+      after(:each) do
+        migration.suppress_messages do
+          migration.remove_index :users, :name => 'users_login_index'
+        end
+      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.suppress_messages do
+          migration.execute "CREATE INDEX users_login_index ON users (extract(EPOCH from deleted_at)) WHERE deleted_at IS NULL"
+        end
+        User.reset_column_information
+        @index = User.indexes.detect { |i| i.expression.present? }
+      end
+
+      after(:each) do
+        migration.suppress_messages do
+          migration.remove_index :users, :name => 'users_login_index'
+        end
+      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,67 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'models/user'
+
+describe "add_index" do
+
+  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 ::ActiveRecord::Base.connection.class.include?(RedhillonrailsCore::ActiveRecord::ConnectionAdapters::PostgresqlAdapter)
+
+    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

data/spec/models/comment.rb

@@ -0,0 +1,5 @@
+class Comment < ActiveRecord::Base
+
+  belongs_to :post
+
+end

data/spec/models/post.rb

@@ -0,0 +1,6 @@
+class Post < ActiveRecord::Base
+
+  belongs_to :user
+  has_many :comments
+
+end

data/spec/models/user.rb

@@ -0,0 +1,5 @@
+class User < ActiveRecord::Base
+
+  has_many :posts
+
+end

data/spec/schema/schema.rb

@@ -0,0 +1,21 @@
+ActiveRecord::Schema.define do
+
+  create_table :users, :force => true do |t|
+    t.string :login
+    t.datetime :deleted_at
+  end
+
+  create_table :posts, :force => true do |t|
+    t.text :body
+    t.integer :user_id
+    t.integer :author_id
+  end
+
+  create_table :comments, :force => true do |t|
+    t.text :body
+    t.integer :post_id
+  end
+
+  add_foreign_key :comments, :post_id, :posts, :id
+
+end

data/spec/schema_dumper_spec.rb

@@ -0,0 +1,138 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'stringio'
+
+require 'models/post'
+
+describe "Schema dump" do
+
+  let(:dump) do
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = %w[users comments]
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    stream.string
+  end
+
+  it "should include foreign_key definition" do
+    with_foreign_key Post, :user_id, :users, :id do
+      dump.should match(to_regexp(%q{add_foreign_key "posts", ["user_id"], "users", ["id"]}))
+    end
+  end
+
+  unless ::ActiveRecord::Base.connection.class.include?(RedhillonrailsCore::ActiveRecord::ConnectionAdapters::Sqlite3Adapter)
+
+    it "should include foreign_key options" do
+      with_foreign_key Post, :user_id, :users, :id, :on_update => :cascade, :on_delete => :set_null do
+        dump.should match(to_regexp(%q{add_foreign_key "posts", ["user_id"], "users", ["id"], :on_update => :cascade, :on_delete => :set_null}))
+      end
+    end
+
+  end
+
+  it "should include index definition" do
+    with_index Post, :user_id do
+      dump.should match(to_regexp(%q{add_index "posts", ["user_id"]}))
+    end
+  end
+
+  it "should include index name" do
+    with_index Post, :user_id, :name => "posts_user_id_index" do
+      dump.should match(to_regexp(%q{add_index "posts", ["user_id"], :name => "posts_user_id_index"}))
+    end
+  end
+  
+  it "should define unique index" do
+    with_index Post, :user_id, :name => "posts_user_id_index", :unique => true do
+      dump.should match(to_regexp(%q{add_index "posts", ["user_id"], :name => "posts_user_id_index", :unique => true}))
+    end
+  end
+  
+  it "should order foreign keys" do
+    with_foreign_key Post, :user_id, :users, :id, :name => 'posts_user_id_fk' do
+      with_foreign_key Post, :author_id, :users, :id, :name => 'posts_author_id_fk' do
+        foreign_key_defs = dump.split("\n").select { |x| x.match(/add_foreign_key/) }
+        foreign_key_defs.size.should be_equal(2)
+        foreign_key_defs[0].should match(to_regexp(%q{add_foreign_key "posts", ["author_id"], "users", ["id"]}))
+        foreign_key_defs[1].should match(to_regexp(%q{add_foreign_key "posts", ["user_id"], "users", ["id"]}))
+      end
+    end
+  end
+
+  it "should order indexes" do
+    with_index Post, :user_id do
+      with_index Post, :author_id do
+        index_defs = dump.split("\n").select { |x| x.match(/add_index/) }
+        index_defs.size.should be_equal(2)
+        index_defs[0].should match(to_regexp(%q{add_index "posts", ["author_id"]}))
+        index_defs[1].should match(to_regexp(%q{add_index "posts", ["user_id"]}))
+      end
+    end
+  end
+
+  if ::ActiveRecord::Base.connection.class.include?(RedhillonrailsCore::ActiveRecord::ConnectionAdapters::PostgresqlAdapter)
+
+  it "should define case insensitive index" do
+    with_index Post, :name => "posts_user_body_index", :expression => "USING btree (LOWER(body))" do
+      dump.should match(to_regexp(%q{add_index "posts", ["body"], :name => "posts_user_body_index", :case_sensitive => false}))
+    end
+  end
+
+  it "should define conditions" do
+    with_index Post, :user_id, :name => "posts_user_id_index", :conditions => "user_id IS NOT NULL" do
+      dump.should match(to_regexp(%q{add_index "posts", ["user_id"], :name => "posts_user_id_index", :conditions => "(user_id IS NOT NULL)"}))
+    end
+  end
+
+  it "should define expression" do
+    with_index Post, :name => "posts_freaky_index", :expression => "USING hash (least(id, user_id))" do
+      dump.should match(to_regexp(%q{add_index "posts", :name => "posts_freaky_index", :kind => "hash", :expression => "LEAST(id, user_id)"}))
+    end
+  end
+  
+  it "should define kind" do
+    with_index Post, :name => "posts_body_index", :expression => "USING hash (body)" do
+      dump.should match(to_regexp(%q{add_index "posts", ["body"], :name => "posts_body_index", :kind => "hash"}))
+    end
+  end
+  
+  end # of postgresql specific examples
+
+  protected
+  def to_regexp(string)
+    Regexp.new(Regexp.escape(string))
+  end
+
+  def with_foreign_key(model, columns, referenced_table_name, referenced_columns, options = {})
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Migration.add_foreign_key(model.table_name, columns, referenced_table_name, referenced_columns, options)
+    end
+    model.reset_column_information
+    yield
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Migration.remove_foreign_key(model.table_name, determine_foreign_key_name(model, columns, options))
+    end
+  end
+  
+  def with_index(model, columns, options = {})
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Migration.add_index(model.table_name, columns, options)
+    end
+    model.reset_column_information
+    yield
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Migration.remove_index(model.table_name, :name => determine_index_name(model, columns, options))
+    end
+  end
+
+  def determine_index_name(model, columns, options)
+    name = columns[:name] if columns.is_a?(Hash)
+    name ||= options[:name]
+    name ||= model.indexes.detect { |index| index.table == model.table_name.to_s && index.columns == Array(columns).collect(&:to_s) }.name
+    name
+  end
+
+  def determine_foreign_key_name(model, columns, options)
+    name = options[:name] 
+    name ||= model.foreign_keys.detect { |fk| fk.table_name == model.table_name.to_s && fk.column_names == Array(columns).collect(&:to_s) }.name
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'active_record'
+require 'redhillonrails_core'
+require 'connection'
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.include(RedhillonrailsCoreMatchers)
+  # load schema
+  ActiveRecord::Migration.suppress_messages do
+    eval(File.read(File.join(File.dirname(__FILE__), 'schema', 'schema.rb')))
+  end
+end
+

data/spec/support/reference.rb

@@ -0,0 +1,66 @@
+module RedhillonrailsCoreMatchers
+
+  class Reference
+    def initialize(expected)
+      @column_names = nil
+      unless expected.empty?
+        @references_column_names = Array(expected).collect(&:to_s)
+        @references_table_name = @references_column_names.shift 
+      end
+    end
+
+    def matches?(model)
+      @model = model
+      if @references_table_name
+        @result = @model.foreign_keys.select do |fk|
+          fk.references_table_name == @references_table_name && 
+            @references_column_names.empty? ? true : fk.references_column_names == @references_column_names
+        end
+      else
+        @result = @model.foreign_keys
+      end
+      if @column_names 
+        @result.any? do |fk| 
+          fk.column_names == @column_names &&
+            (@on_update ? fk.on_update == @on_update : true) &&
+            (@on_delete ? fk.on_delete == @on_delete : true)
+        end
+      else
+        !@result.empty?
+      end
+    end
+
+    def failure_message_for_should(should_not = false)
+      target_column_names = @column_names.present? ? "(#{@column_names.join(', ')})" : "" 
+      destinantion_column_names = @references_table_name ? "#{@references_table_name}(#{@references_column_names.join(', ')})" : "anything"
+      invert = should_not ? 'not' : ''
+      "Expected #{@model.table_name}#{target_column_names} to #{invert} reference #{destinantion_column_names}"
+    end
+
+    def failure_message_for_should_not
+      failure_message_for_should(true)
+    end
+  
+    def on(*column_names)
+      @column_names = column_names.collect(&:to_s)
+      self
+    end
+
+    def on_update(action)
+      @on_update = action
+      self
+    end
+
+    def on_delete(action)
+      @on_delete = action
+      self
+    end
+
+  end
+
+  def reference(*expect)
+    Reference.new(expect)
+  end
+
+end
+