activerecord 1.11.1 → 1.12.1

data/test/binary_test.rb

@@ -2,53 +2,36 @@ require 'abstract_unit'
 require 'fixtures/binary'
 
 class BinaryTest < Test::Unit::TestCase
+  BINARY_FIXTURE_PATH = File.dirname(__FILE__) + '/fixtures/flowers.jpg'
+
   def setup
-    @data = create_data_fixture
+    Binary.connection.execute 'DELETE FROM binaries'
+    @data = File.read(BINARY_FIXTURE_PATH).freeze
   end
   
-  def test_load_save
-    # Without using prepared statements, it makes no sense to test
-    # BLOB data with SQL Server, because the length of a statement is
-    # limited to 8KB.
-    if ActiveRecord::ConnectionAdapters.const_defined? :SQLServerAdapter
-      return true if ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::SQLServerAdapter)
-    end
-
-    # Without using prepared statements, it makes no sense to test
-    # BLOB data with DB2, because the length of a statement is
-    # limited to 32KB.
-    if ActiveRecord::ConnectionAdapters.const_defined? :DB2Adapter
-      return true if ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::DB2Adapter)
-    end
-
-    if ActiveRecord::ConnectionAdapters.const_defined? :OracleAdapter
-      return true if ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::OracleAdapter)
-    end
-    bin = Binary.new
-    bin.data = @data
-
-    assert bin.data == @data,
-      "Assigned data differs from file data"
-        
-    bin.save
+  def test_truth
+    assert true
+  end
 
-    assert bin.data == @data,
-      "Assigned data differs from file data after save"
+  # Without using prepared statements, it makes no sense to test
+  # BLOB data with SQL Server, because the length of a statement is
+  # limited to 8KB.
+  #
+  # Without using prepared statements, it makes no sense to test
+  # BLOB data with DB2, because the length of a statement is
+  # limited to 32KB.
+  unless %w(SQLServer DB2 OCI).include? ActiveRecord::Base.connection.adapter_name
+    def test_load_save
+      bin = Binary.new
+      bin.data = @data
 
-    db_bin = Binary.find(bin.id)
+      assert @data == bin.data, 'Newly assigned data differs from original'
+          
+      bin.save
+      assert @data == bin.data, 'Data differs from original after save'
 
-    assert db_bin.data == bin.data,
-      "Loaded binary data differs from memory version"
-    
-    assert db_bin.data == File.new(File.dirname(__FILE__)+"/fixtures/associations.png","rb").read, 
-      "Loaded binary data differs from file version"
-  end
-  
-  private
-  
-  def create_data_fixture
-    Binary.connection.execute("DELETE FROM binaries")
-    File.new(File.dirname(__FILE__)+"/fixtures/associations.png","rb").read
+      db_bin = Binary.find(bin.id)
+      assert @data == db_bin.data, 'Reloaded data differs from original'
+    end
   end
-  
 end

data/test/callbacks_test.rb

@@ -70,6 +70,44 @@ class RecursiveCallbackDeveloper < ActiveRecord::Base
   end
 end
 
+class ImmutableDeveloper < ActiveRecord::Base
+  set_table_name 'developers'
+
+  validates_inclusion_of :salary, :in => 50000..200000
+
+  before_save :cancel
+  before_destroy :cancel
+
+  def cancelled?
+    @cancelled == true
+  end
+
+  private
+    def cancel
+      @cancelled = true
+      false
+    end
+end
+
+class ImmutableMethodDeveloper < ActiveRecord::Base
+  set_table_name 'developers'
+
+  validates_inclusion_of :salary, :in => 50000..200000
+
+  def cancelled?
+    @cancelled == true
+  end
+
+  def before_save
+    @cancelled = true
+    false
+  end
+
+  def before_destroy
+    @cancelled = true
+    false
+  end
+end
 
 class CallbacksTest < Test::Unit::TestCase
   fixtures :developers
@@ -283,6 +321,43 @@ class CallbacksTest < Test::Unit::TestCase
     ], david.history
   end
 
+  def test_before_save_returning_false
+    david = ImmutableDeveloper.find(1)
+    assert david.valid?
+    assert david.save
+    assert david.cancelled?
+
+    david = ImmutableDeveloper.find(1)
+    david.salary = 10_000_000
+    assert !david.valid?
+    assert !david.save
+    assert !david.cancelled?
+
+    david = ImmutableMethodDeveloper.find(1)
+    assert david.valid?
+    assert david.save
+    assert david.cancelled?
+
+    david = ImmutableMethodDeveloper.find(1)
+    david.salary = 10_000_000
+    assert !david.valid?
+    assert !david.save
+    assert !david.cancelled?
+  end
+
+  def test_before_destroy_returning_false
+    david = ImmutableDeveloper.find(1)
+    david.destroy
+    assert david.cancelled?
+    assert_not_nil ImmutableDeveloper.find_by_id(1)
+
+    david = ImmutableMethodDeveloper.find(1)
+    david.destroy
+    assert david.cancelled?
+    assert_not_nil ImmutableMethodDeveloper.find_by_id(1)
+  end
+
+
   def test_zzz_callback_returning_false # must be run last since we modify CallbackDeveloper
     david = CallbackDeveloper.find(1)
     CallbackDeveloper.before_validation proc { |model| model.history << [:before_validation, :returning_false]; return false }

data/test/conditions_scoping_test.rb

@@ -0,0 +1,136 @@
+require 'abstract_unit'
+require 'fixtures/developer'
+require 'fixtures/comment'
+require 'fixtures/post'
+require 'fixtures/category'
+
+class ConditionsScopingTest < Test::Unit::TestCase
+  fixtures :developers
+  
+  def test_set_conditions
+    Developer.constrain(:conditions => 'just a test...') do
+      assert_equal 'just a test...', Thread.current[:constraints][Developer][:conditions]
+    end
+  end
+
+  def test_scoped_find
+    Developer.constrain(:conditions => "name = 'David'") do
+      assert_nothing_raised { Developer.find(1) }
+    end
+  end
+  
+  def test_scoped_find_first
+    Developer.constrain(:conditions => "salary = 100000") do
+      assert_equal Developer.find(10), Developer.find(:first, :order => 'name')
+    end
+  end
+  
+  def test_scoped_find_all
+    Developer.constrain(:conditions => "name = 'David'") do
+      assert_equal [Developer.find(1)], Developer.find(:all)
+    end      
+  end
+  
+  def test_scoped_count
+    Developer.constrain(:conditions => "name = 'David'") do
+      assert_equal 1, Developer.count
+    end        
+
+    Developer.constrain(:conditions => 'salary = 100000') do
+      assert_equal 8, Developer.count
+      assert_equal 1, Developer.count("name LIKE 'fixture_1%'")
+    end        
+  end
+end
+
+class HasManyScopingTest< Test::Unit::TestCase
+  fixtures :comments, :posts
+  
+  def setup
+    @welcome = Post.find(1)
+  end
+  
+  def test_forwarding_of_static_methods
+    assert_equal 'a comment...', Comment.what_are_you
+    assert_equal 'a comment...', @welcome.comments.what_are_you
+  end
+
+  def test_forwarding_to_scoped
+    assert_equal 4, Comment.search_by_type('Comment').size
+    assert_equal 2, @welcome.comments.search_by_type('Comment').size
+  end
+  
+  def test_forwarding_to_dynamic_finders
+    assert_equal 4, Comment.find_all_by_type('Comment').size
+    assert_equal 2, @welcome.comments.find_all_by_type('Comment').size
+  end
+  
+end
+
+
+class HasAndBelongsToManyScopingTest< Test::Unit::TestCase
+  fixtures :posts, :categories
+
+  def setup
+    @welcome = Post.find(1)
+  end
+
+  def test_forwarding_of_static_methods
+    assert_equal 'a category...', Category.what_are_you
+    assert_equal 'a category...', @welcome.categories.what_are_you
+  end
+
+  def test_forwarding_to_dynamic_finders
+    assert_equal 1, Category.find_all_by_type('SpecialCategory').size
+    assert_equal 0, @welcome.categories.find_all_by_type('SpecialCategory').size
+    assert_equal 2, @welcome.categories.find_all_by_type('Category').size
+  end
+
+end
+
+
+=begin
+# We disabled the scoping for has_one and belongs_to as we can't think of a proper use case
+
+
+class BelongsToScopingTest< Test::Unit::TestCase
+  fixtures :comments, :posts
+
+  def setup
+    @greetings = Comment.find(1)
+  end
+
+  def test_forwarding_of_static_method
+    assert_equal 'a post...', Post.what_are_you
+    assert_equal 'a post...', @greetings.post.what_are_you
+  end
+
+  def test_forwarding_to_dynamic_finders
+    assert_equal 4, Post.find_all_by_type('Post').size
+    assert_equal 1, @greetings.post.find_all_by_type('Post').size
+  end
+
+end
+
+
+class HasOneScopingTest< Test::Unit::TestCase
+  fixtures :comments, :posts
+
+  def setup
+    @sti_comments = Post.find(4)
+  end
+
+  def test_forwarding_of_static_methods
+    assert_equal 'a comment...', Comment.what_are_you
+    assert_equal 'a very special comment...', @sti_comments.very_special_comment.what_are_you
+  end
+
+  def test_forwarding_to_dynamic_finders
+    assert_equal 1, Comment.find_all_by_type('VerySpecialComment').size
+    assert_equal 1, @sti_comments.very_special_comment.find_all_by_type('VerySpecialComment').size
+    assert_equal 0, @sti_comments.very_special_comment.find_all_by_type('Comment').size
+  end
+
+end
+
+=end

data/test/connections/native_mysql/connection.rb

@@ -9,16 +9,12 @@ db2 = 'activerecord_unittest2'
 
 ActiveRecord::Base.establish_connection(
   :adapter  => "mysql",
-  :host     => "localhost",
   :username => "rails",
-  :password => "",
   :database => db1
 )
 
 Course.establish_connection(
   :adapter  => "mysql",
-  :host     => "localhost",
   :username => "rails",
-  :password => "",
   :database => db2
 )

data/test/connections/native_sqlite3/in_memory_connection.rb

@@ -0,0 +1,17 @@
+print "Using native SQLite3\n"
+require 'fixtures/course'
+require 'logger'
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+class SqliteError < StandardError
+end
+
+def make_connection(clazz, db_definitions_file)
+  clazz.establish_connection(:adapter => 'sqlite3', :dbfile  => ':memory:')
+  File.read("#{File.dirname(__FILE__)}/../../fixtures/db_definitions/#{db_definitions_file}").split(';').each do |command|
+    clazz.connection.execute(command) unless command.strip.empty?
+  end
+end
+
+make_connection(ActiveRecord::Base, 'sqlite.sql')
+make_connection(Course, 'sqlite2.sql')

data/test/copy_table_sqlite.rb

@@ -0,0 +1,64 @@
+require 'abstract_unit'
+
+class CopyTableTest < Test::Unit::TestCase
+  fixtures :companies, :comments
+  
+  def setup
+    @connection = ActiveRecord::Base.connection
+    class << @connection
+      public :copy_table, :table_structure, :indexes
+    end
+  end
+  
+  def test_copy_table(from = 'companies', to = 'companies2', options = {})
+    assert_nothing_raised {copy_table(from, to, options)}
+    assert_equal row_count(from), row_count(to)
+      
+    if block_given?
+      yield from, to, options
+    else
+      assert_equal column_names(from), column_names(to)
+    end
+    
+    @connection.drop_table(to) rescue nil
+  end
+  
+  def test_copy_table_renaming_column
+    test_copy_table('companies', 'companies2', 
+        :rename => {'client_of' => 'fan_of'}) do |from, to, options|
+      assert_equal column_values(from, 'client_of').compact.sort, 
+                   column_values(to, 'fan_of').compact.sort
+    end
+  end
+  
+  def test_copy_table_with_index
+    test_copy_table('comments', 'comments_with_index') do
+      @connection.add_index('comments_with_index', ['post_id', 'type'])
+      test_copy_table('comments_with_index', 'comments_with_index2') do
+        assert_equal table_indexes_without_name('comments_with_index'),
+                     table_indexes_without_name('comments_with_index2')
+      end
+    end
+  end
+  
+protected
+  def copy_table(from, to, options = {})
+    @connection.copy_table(from, to, {:temporary => true}.merge(options))
+  end
+
+  def column_names(table)
+    @connection.table_structure(table).map {|column| column['name']}
+  end
+  
+  def column_values(table, column)
+    @connection.select_all("SELECT #{column} FROM #{table}").map {|row| row[column]}
+  end
+
+  def table_indexes_without_name(table)
+    @connection.indexes('comments_with_index').delete(:name)
+  end
+  
+  def row_count(table)
+    @connection.select_one("SELECT COUNT(*) AS count FROM #{table}")['count']
+  end
+end

data/test/deprecated_associations_test.rb

@@ -9,7 +9,7 @@ require 'fixtures/reply'
 bad_collection_keys = false
 begin
   class Car < ActiveRecord::Base; has_many :wheels, :name => "wheels"; end
-rescue ActiveRecord::ActiveRecordError
+rescue ArgumentError
   bad_collection_keys = true
 end
 raise "ActiveRecord should have barked on bad collection keys" unless bad_collection_keys
@@ -79,10 +79,11 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase
   end
 
   def test_has_one_dependence
+    num_accounts = Account.count
     firm = Firm.find(1)
     assert firm.has_account?
-    firm.destroy
-    assert_equal 1, Account.find_all.length
+    firm.destroy            
+    assert_equal num_accounts - 1, Account.count
   end
 
   def test_has_one_dependence_with_missing_association
@@ -124,10 +125,10 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase
     assert !Account.find(2).firm?(companies(:first_firm)), "Unknown isn't linked"
   end
 
-  def test_has_many_dependence_on_account
-    assert_equal 2, Account.find_all.length
+  def test_has_many_dependence_on_account    
+    num_accounts = Account.count
     companies(:first_firm).destroy
-    assert_equal 1, Account.find_all.length
+    assert_equal num_accounts - 1, Account.count
   end
 
   def test_find_in

data/test/deprecated_finder_test.rb

@@ -4,7 +4,7 @@ require 'fixtures/topic'
 require 'fixtures/entrant'
 require 'fixtures/developer'
 
-class FinderTest < Test::Unit::TestCase
+class DeprecatedFinderTest < Test::Unit::TestCase
   fixtures :companies, :topics, :entrants, :developers
 
   def test_find_all_with_limit
@@ -38,8 +38,8 @@ class FinderTest < Test::Unit::TestCase
   end
   
   def test_deprecated_find_on_conditions
-    assert Topic.find_on_conditions(1, "approved = 0")
-    assert_raises(ActiveRecord::RecordNotFound) { Topic.find_on_conditions(1, "approved = 1") }
+    assert Topic.find_on_conditions(1, ["approved = ?", false])
+    assert_raises(ActiveRecord::RecordNotFound) { Topic.find_on_conditions(1, ["approved = ?", true]) }
   end
   
   def test_condition_interpolation