activerecord 1.14.4 → 1.15.0

data/test/migration_test_firebird.rb

@@ -0,0 +1,124 @@
+require 'abstract_unit'
+require 'fixtures/course'
+
+class FirebirdMigrationTest < Test::Unit::TestCase
+  self.use_transactional_fixtures = false
+
+  def setup
+    # using Course connection for tests -- need a db that doesn't already have a BOOLEAN domain
+    @connection = Course.connection
+    @fireruby_connection = @connection.instance_variable_get(:@connection)
+  end
+
+  def teardown
+    @connection.drop_table :foo rescue nil
+    @connection.execute("DROP DOMAIN D_BOOLEAN") rescue nil
+  end
+
+  def test_create_table_with_custom_sequence_name
+    assert_nothing_raised do
+      @connection.create_table(:foo, :sequence => 'foo_custom_seq') do |f|
+        f.column :bar, :string
+      end
+    end
+    assert !sequence_exists?('foo_seq')
+    assert sequence_exists?('foo_custom_seq')
+
+    assert_nothing_raised { @connection.drop_table(:foo, :sequence => 'foo_custom_seq') }
+    assert !sequence_exists?('foo_custom_seq')
+  ensure
+    FireRuby::Generator.new('foo_custom_seq', @fireruby_connection).drop rescue nil
+  end
+
+  def test_create_table_without_sequence
+    assert_nothing_raised do
+      @connection.create_table(:foo, :sequence => false) do |f|
+        f.column :bar, :string
+      end
+    end
+    assert !sequence_exists?('foo_seq')
+    assert_nothing_raised { @connection.drop_table :foo }
+
+    assert_nothing_raised do
+      @connection.create_table(:foo, :id => false) do |f|
+        f.column :bar, :string
+      end
+    end
+    assert !sequence_exists?('foo_seq')
+    assert_nothing_raised { @connection.drop_table :foo }
+  end
+
+  def test_create_table_with_boolean_column
+    assert !boolean_domain_exists?
+    assert_nothing_raised do
+      @connection.create_table :foo do |f|
+        f.column :bar, :string
+        f.column :baz, :boolean
+      end
+    end
+    assert boolean_domain_exists?
+  end
+
+  def test_add_boolean_column
+    assert !boolean_domain_exists?
+    @connection.create_table :foo do |f|
+      f.column :bar, :string
+    end
+
+    assert_nothing_raised { @connection.add_column :foo, :baz, :boolean }
+    assert boolean_domain_exists?
+    assert_equal :boolean, @connection.columns(:foo).find { |c| c.name == "baz" }.type
+  end
+
+  def test_change_column_to_boolean
+    assert !boolean_domain_exists?
+    # Manually create table with a SMALLINT column, which can be changed to a BOOLEAN
+    @connection.execute "CREATE TABLE foo (bar SMALLINT)"
+    assert_equal :integer, @connection.columns(:foo).find { |c| c.name == "bar" }.type
+
+    assert_nothing_raised { @connection.change_column :foo, :bar, :boolean }
+    assert boolean_domain_exists?
+    assert_equal :boolean, @connection.columns(:foo).find { |c| c.name == "bar" }.type
+  end
+
+  def test_rename_table_with_data_and_index
+    @connection.create_table :foo do |f|
+      f.column :baz, :string, :limit => 50
+    end
+    100.times { |i| @connection.execute "INSERT INTO foo VALUES (GEN_ID(foo_seq, 1), 'record #{i+1}')" }
+    @connection.add_index :foo, :baz
+
+    assert_nothing_raised { @connection.rename_table :foo, :bar }
+    assert !@connection.tables.include?("foo")
+    assert @connection.tables.include?("bar")
+    assert_equal "index_bar_on_baz", @connection.indexes("bar").first.name
+    assert_equal 100, FireRuby::Generator.new("bar_seq", @fireruby_connection).last
+    assert_equal 100, @connection.select_one("SELECT COUNT(*) FROM bar")["count"]
+  ensure
+    @connection.drop_table :bar rescue nil
+  end
+
+  def test_renaming_table_with_fk_constraint_raises_error
+    @connection.create_table :parent do |p|
+      p.column :name, :string
+    end
+    @connection.create_table :child do |c|
+      c.column :parent_id, :integer
+    end
+    @connection.execute "ALTER TABLE child ADD CONSTRAINT fk_child_parent FOREIGN KEY(parent_id) REFERENCES parent(id)"
+    assert_raise(ActiveRecord::ActiveRecordError) { @connection.rename_table :child, :descendant }
+  ensure
+    @connection.drop_table :child rescue nil
+    @connection.drop_table :descendant rescue nil
+    @connection.drop_table :parent rescue nil
+  end
+
+  private
+    def boolean_domain_exists?
+      !@connection.select_one("SELECT 1 FROM rdb$fields WHERE rdb$field_name = 'D_BOOLEAN'").nil?
+    end
+
+    def sequence_exists?(sequence_name)
+      FireRuby::Generator.exists?(sequence_name, @fireruby_connection)
+    end
+end

data/test/mixin_nested_set_test.rb

@@ -178,7 +178,19 @@ class MixinNestedSetTest < Test::Unit::TestCase
     mixins(:set_1).add_child mixins(:set_4)
 
     assert_equal( 3, mixins(:set_1).all_children.length )
-
-
+  end
+  
+  def test_inheritance
+    parent = mixins(:sti_set_3100)
+    child = mixins(:sti_set_3101)
+    grandchild = mixins(:sti_set_3102)
+    assert_equal 5, parent.full_set.size
+    assert_equal 2, child.full_set.size
+    assert_equal 4, parent.all_children.size
+    assert_equal 1, child.all_children.size
+    assert_equal 2, parent.direct_children.size
+    assert_equal 1, child.direct_children.size
+    child.destroy
+    assert_equal 3, parent.full_set.size
   end
 end

data/test/mixin_test.rb

@@ -4,6 +4,23 @@ require 'active_record/acts/list'
 require 'active_record/acts/nested_set'
 require 'fixtures/mixin'
 
+# Let us control what Time.now returns for the TouchTest suite
+class Time
+  @@forced_now_time = nil
+  cattr_accessor :forced_now_time
+  
+  class << self
+    def now_with_forcing
+      if @@forced_now_time
+        @@forced_now_time
+      else
+        now_without_forcing
+      end
+    end
+    alias_method_chain :now, :forcing
+  end
+end
+
 class ListTest < Test::Unit::TestCase
   fixtures :mixins
 
@@ -200,10 +217,12 @@ class TreeTest < Test::Unit::TestCase
   fixtures :mixins
 
   def test_has_child
-    assert_equal true, mixins(:tree_1).has_children?
-    assert_equal true, mixins(:tree_2).has_children?
-    assert_equal false, mixins(:tree_3).has_children?
-    assert_equal false, mixins(:tree_4).has_children?
+    assert_deprecated 'has_children?' do
+      assert_equal true, mixins(:tree_1).has_children?
+      assert_equal true, mixins(:tree_2).has_children?
+      assert_equal false, mixins(:tree_3).has_children?
+      assert_equal false, mixins(:tree_4).has_children?
+    end
   end
 
   def test_children
@@ -214,10 +233,12 @@ class TreeTest < Test::Unit::TestCase
   end
 
   def test_has_parent
-    assert_equal false, mixins(:tree_1).has_parent?
-    assert_equal true, mixins(:tree_2).has_parent?
-    assert_equal true, mixins(:tree_3).has_parent?
-    assert_equal true, mixins(:tree_4).has_parent?
+    assert_deprecated 'has_parent?' do
+      assert_equal false, mixins(:tree_1).has_parent?
+      assert_equal true, mixins(:tree_2).has_parent?
+      assert_equal true, mixins(:tree_3).has_parent?
+      assert_equal true, mixins(:tree_4).has_parent?
+    end
   end
 
   def test_parent
@@ -304,6 +325,23 @@ end
 
 class TouchTest < Test::Unit::TestCase
   fixtures :mixins
+  
+  def setup
+    Time.forced_now_time = Time.now
+  end
+  
+  def teardown
+    Time.forced_now_time = nil
+  end
+
+  def test_time_mocking
+    five_minutes_ago = 5.minutes.ago
+    Time.forced_now_time = five_minutes_ago
+    assert_equal five_minutes_ago, Time.now
+    
+    Time.forced_now_time = nil
+    assert_not_equal five_minutes_ago, Time.now
+  end
 
   def test_update
     stamped = Mixin.new
@@ -311,14 +349,14 @@ class TouchTest < Test::Unit::TestCase
     assert_nil stamped.updated_at
     assert_nil stamped.created_at
     stamped.save
-    assert_not_nil stamped.updated_at
-    assert_not_nil stamped.created_at
+    assert_equal Time.now, stamped.updated_at
+    assert_equal Time.now, stamped.created_at
   end
 
   def test_create
-    @obj = Mixin.create
-    assert_not_nil @obj.updated_at
-    assert_not_nil @obj.created_at
+    obj = Mixin.create
+    assert_equal Time.now, obj.updated_at
+    assert_equal Time.now, obj.created_at
   end
 
   def test_many_updates
@@ -327,16 +365,16 @@ class TouchTest < Test::Unit::TestCase
     assert_nil stamped.updated_at
     assert_nil stamped.created_at
     stamped.save
-    assert_not_nil stamped.created_at
-    assert_not_nil stamped.updated_at
+    assert_equal Time.now, stamped.created_at
+    assert_equal Time.now, stamped.updated_at
 
     old_updated_at = stamped.updated_at
 
-    sleep 1
+    Time.forced_now_time = 5.minutes.from_now
     stamped.save
-    assert_not_equal stamped.created_at, stamped.updated_at
-    assert_not_equal old_updated_at, stamped.updated_at
 
+    assert_equal Time.now, stamped.updated_at
+    assert_equal old_updated_at, stamped.created_at
   end
 
   def test_create_turned_off

data/test/modules_test.rb

@@ -5,10 +5,9 @@ class ModulesTest < Test::Unit::TestCase
   fixtures :accounts, :companies, :projects, :developers
 
   def test_module_spanning_associations
-    assert MyApplication::Business::Firm.find(:first).has_clients?, "Firm should have clients"
     firm = MyApplication::Business::Firm.find(:first)
+    assert !firm.clients.empty?, "Firm should have clients"
     assert_nil firm.class.table_name.match('::'), "Firm shouldn't have the module appear in its table name"
-    assert_equal 2, firm.clients_count, "Firm should have two clients"
   end
 
   def test_module_spanning_has_and_belongs_to_many_associations
@@ -25,4 +24,11 @@ class ModulesTest < Test::Unit::TestCase
     assert_kind_of MyApplication::Billing::Nested::Firm, account.nested_qualified_billing_firm
     assert_kind_of MyApplication::Billing::Nested::Firm, account.nested_unqualified_billing_firm
   end
+  
+  def test_find_account_and_include_company
+    account = MyApplication::Billing::Account.find(1, :include => :firm)
+    assert_kind_of MyApplication::Business::Firm, account.instance_variable_get('@firm')
+    assert_kind_of MyApplication::Business::Firm, account.firm
+  end
+  
 end

data/test/multiple_db_test.rb

@@ -39,11 +39,11 @@ class MultipleDbTest < Test::Unit::TestCase
 
   def test_associations
     c1 = Course.find(1)
-    assert_equal 2, c1.entrants_count
+    assert_equal 2, c1.entrants.count
     e1 = Entrant.find(1)
     assert_equal e1.course.id, c1.id
     c2 = Course.find(2)
-    assert_equal 1, c2.entrants_count
+    assert_equal 1, c2.entrants.count
     e3 = Entrant.find(3)
     assert_equal e3.course.id, c2.id
   end

data/test/pk_test.rb

@@ -1,5 +1,6 @@
 require "#{File.dirname(__FILE__)}/abstract_unit"
 require 'fixtures/topic'
+require 'fixtures/reply'
 require 'fixtures/subscriber'
 require 'fixtures/movie'
 require 'fixtures/keyboard'

data/test/reflection_test.rb

@@ -45,6 +45,12 @@ class ReflectionTest < Test::Unit::TestCase
     assert_equal :string, @first.column_for_attribute("title").type
     assert_equal 255, @first.column_for_attribute("title").limit
   end
+  
+  def test_column_null_not_null
+    subscriber = Subscriber.find(:first)
+    assert subscriber.column_for_attribute("name").null
+    assert !subscriber.column_for_attribute("nick").null
+  end
 
   def test_human_name_for_column
     assert_equal "Author name", @first.column_for_attribute("author_name").human_name
@@ -137,8 +143,8 @@ class ReflectionTest < Test::Unit::TestCase
   end
   
   def test_reflection_of_all_associations
-    assert_equal 13, Firm.reflect_on_all_associations.size
-    assert_equal 11, Firm.reflect_on_all_associations(:has_many).size
+    assert_equal 17, Firm.reflect_on_all_associations.size
+    assert_equal 15, Firm.reflect_on_all_associations(:has_many).size
     assert_equal 2, Firm.reflect_on_all_associations(:has_one).size
     assert_equal 0, Firm.reflect_on_all_associations(:belongs_to).size
   end

data/test/schema_authorization_test_postgresql.rb

@@ -0,0 +1,75 @@
+require 'abstract_unit'
+
+class SchemaThing < ActiveRecord::Base
+end
+
+class SchemaAuthorizationTest < Test::Unit::TestCase
+  self.use_transactional_fixtures = false
+
+  TABLE_NAME = 'schema_things'
+  COLUMNS = [
+    'id serial primary key',
+    'name character varying(50)'
+  ]
+  USERS = ['rails_pg_schema_user1', 'rails_pg_schema_user2']
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.execute "SET search_path TO '$user',public"
+    set_session_auth
+    USERS.each do |u|
+      @connection.execute "CREATE ROLE #{u}"
+      @connection.execute "CREATE SCHEMA AUTHORIZATION #{u}"
+      set_session_auth u
+      @connection.execute "CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
+      @connection.execute "INSERT INTO #{TABLE_NAME} (name) VALUES ('#{u}')"
+      set_session_auth
+    end
+  end
+
+  def teardown
+    set_session_auth 
+    @connection.execute "RESET search_path"
+    USERS.each do |u|
+      @connection.execute "DROP SCHEMA #{u} CASCADE"
+      @connection.execute "DROP ROLE #{u}"
+    end
+  end
+
+  def test_schema_invisible
+    assert_raise(ActiveRecord::StatementInvalid) do
+      set_session_auth
+      @connection.execute "SELECT * FROM #{TABLE_NAME}"
+    end
+  end
+
+  def test_schema_uniqueness
+    assert_nothing_raised do
+      set_session_auth
+      USERS.each do |u|
+        set_session_auth u
+        assert_equal u, @connection.select_value("SELECT name FROM #{TABLE_NAME} WHERE id = 1")
+        set_session_auth
+      end
+    end
+  end
+
+  def test_sequence_schema_caching
+    assert_nothing_raised do
+      USERS.each do |u|
+        set_session_auth u
+        st = SchemaThing.new :name => 'TEST1'
+        st.save!
+        st = SchemaThing.new :id => 5, :name => 'TEST2'
+        st.save!
+        set_session_auth
+      end
+    end
+  end
+
+  private
+    def set_session_auth auth = nil
+       @connection.execute "SET SESSION AUTHORIZATION #{auth || 'default'}"
+    end
+
+end

data/test/schema_dumper_test.rb

@@ -5,20 +5,48 @@ require 'stringio'
 if ActiveRecord::Base.connection.respond_to?(:tables)
 
   class SchemaDumperTest < Test::Unit::TestCase
-    def test_schema_dump
+    def standard_dump
       stream = StringIO.new
+      ActiveRecord::SchemaDumper.ignore_tables = []
       ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-      output = stream.string
-
+      stream.string
+    end
+    
+    def test_schema_dump
+      output = standard_dump
       assert_match %r{create_table "accounts"}, output
       assert_match %r{create_table "authors"}, output
       assert_no_match %r{create_table "schema_info"}, output
     end
     
+    def assert_line_up(lines, pattern, required = false)
+      return assert(true) if lines.empty?
+      matches = lines.map { |line| line.match(pattern) }
+      assert matches.all? if required
+      matches.compact!
+      return assert(true) if matches.empty?
+      assert_equal 1, matches.map{ |match| match.offset(0).first }.uniq.length
+    end
+    
+    def test_arguments_line_up
+      output  = standard_dump
+      output.scan(/^( *)create_table.*?\n(.*?)^\1end/m).map{ |m| m.last.split(/\n/) }.each do |column_set|
+        assert_line_up(column_set, /:(?:integer|decimal|float|datetime|timestamp|time|date|text|binary|string|boolean)/, true)
+        assert_line_up(column_set, /:default => /)
+        assert_line_up(column_set, /:limit => /)
+        assert_line_up(column_set, /:null => /)
+      end
+    end
+    
+    def test_no_dump_errors
+      output = standard_dump
+      assert_no_match %r{\# Could not dump table}, output
+    end
+    
     def test_schema_dump_includes_not_null_columns
       stream = StringIO.new
       
-      ActiveRecord::SchemaDumper.ignore_tables = [/^[^s]/]
+      ActiveRecord::SchemaDumper.ignore_tables = [/^[^r]/]
       ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
       output = stream.string
       assert_match %r{:null => false}, output
@@ -55,6 +83,14 @@ if ActiveRecord::Base.connection.respond_to?(:tables)
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
       end
     end
+
+    def test_schema_dump_includes_decimal_options
+      stream = StringIO.new      
+      ActiveRecord::SchemaDumper.ignore_tables = [/^[^n]/]
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+      output = stream.string
+      assert_match %r{:precision => 3,[[:space:]]+:scale => 2,[[:space:]]+:default => 2.78}, output
+    end
   end
 
 end