Index: activerecord/test/test_helper.rb =================================================================== --- activerecord/test/test_helper.rb (revision 0) +++ activerecord/test/test_helper.rb (revision 0) @@ -0,0 +1,93 @@ +AR_SUPPORT_PATH = File.expand_path(File.dirname(__FILE__) + "/support") +AR_ASSETS_PATH = AR_SUPPORT_PATH + "/assets" +AR_FIXTURES_PATH = AR_SUPPORT_PATH + "/fixtures" +AR_MIGRATIONS_PATH = AR_SUPPORT_PATH + "/migrations" +AR_MODELS_PATH = AR_SUPPORT_PATH + "/models" +AR_SCHEMA_PATH = AR_SUPPORT_PATH + "/schema" + +["/../lib", "/../../activesupport/lib"].each do |path| + $:.unshift(File.expand_path(File.dirname(__FILE__) + path)) +end + +# for access to test models +$:.unshift(AR_SUPPORT_PATH) + +require "test/unit" +require "active_record" +require "active_record/fixtures" +require "active_support/test_case" +require "connection" + +# Show backtraces for deprecated behavior for quicker cleanup. +ActiveSupport::Deprecation.debug = true + +unless Object.const_defined?(:QUOTED_TYPE) + QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name("type") +end + +class ActiveSupport::TestCase #:nodoc: + self.fixture_path = AR_FIXTURES_PATH + self.use_instantiated_fixtures = false + self.use_transactional_fixtures = true + + def create_fixtures(*table_names, &block) + Fixtures.create_fixtures(AR_FIXTURES_PATH, table_names, {}, &block) + end + + def assert_date_from_db(expected, actual, message = nil) + # SQL Server doesn't have a separate column type just for dates, + # so the time is in the string and incorrectly formatted + if current_adapter?(:SQLServerAdapter) + assert_equal expected.strftime("%Y/%m/%d 00:00:00"), actual.strftime("%Y/%m/%d 00:00:00") + elsif current_adapter?(:SybaseAdapter) + assert_equal expected.to_s, actual.to_date.to_s, message + else + assert_equal expected.to_s, actual.to_s, message + end + end + + def assert_queries(num = 1) + $query_count = 0 + yield + ensure + assert_equal num, $query_count, "#{$query_count} instead of #{num} queries were executed." + end + + def assert_no_queries(&block) + assert_queries(0, &block) + end +end + +def current_adapter?(*types) + types.any? do |type| + ActiveRecord::ConnectionAdapters.const_defined?(type) && + ActiveRecord::Base.connection.is_a?(ActiveRecord::ConnectionAdapters.const_get(type)) + end +end + +def uses_mocha(test_name) + require 'rubygems' + require 'mocha' + yield +rescue LoadError + $stderr.puts "Skipping #{test_name} tests. `gem install mocha` and try again." +end + +ActiveRecord::Base.connection.class.class_eval do + unless defined? IGNORED_SQL + IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/] + + def execute_with_counting(sql, name = nil, &block) + $query_count ||= 0 + $query_count += 1 unless IGNORED_SQL.any? { |r| sql =~ r } + execute_without_counting(sql, name, &block) + end + + alias_method_chain :execute, :counting + end +end + +# Make with_scope public for tests +class << ActiveRecord::Base + public :with_scope, :with_exclusive_scope +end Index: activerecord/test/all.sh =================================================================== --- activerecord/test/all.sh (revision 8601) +++ activerecord/test/all.sh (working copy) @@ -1,8 +0,0 @@ -#!/bin/sh - -if [ -z "$1" ]; then - echo "Usage: $0 " 1>&2 - exit 1 -fi - -ruby -I connections/native_$1 -e 'Dir["**/*_test.rb"].each { |path| require path }' Index: activerecord/test/connections/native_openbase/connection.rb =================================================================== --- activerecord/test/connections/native_openbase/connection.rb (revision 8601) +++ activerecord/test/connections/native_openbase/connection.rb (working copy) @@ -1,21 +0,0 @@ -print "Using native OpenBase\n" -require_dependency 'fixtures/course' -require 'logger' - -ActiveRecord::Base.logger = Logger.new("debug.log") - -ActiveRecord::Base.configurations = { - 'arunit' => { - :adapter => 'openbase', - :username => 'admin', - :database => 'activerecord_unittest', - }, - 'arunit2' => { - :adapter => 'openbase', - :username => 'admin', - :database => 'activerecord_unittest2' - } -} - -ActiveRecord::Base.establish_connection 'arunit' -Course.establish_connection 'arunit2' Index: activerecord/test/connections/native_sqlite/connection.rb =================================================================== --- activerecord/test/connections/native_sqlite/connection.rb (revision 8601) +++ activerecord/test/connections/native_sqlite/connection.rb (working copy) @@ -1,25 +0,0 @@ -print "Using native SQlite\n" -require_dependency 'fixtures/course' -require 'logger' -ActiveRecord::Base.logger = Logger.new("debug.log") - -class SqliteError < StandardError -end - -BASE_DIR = File.expand_path(File.dirname(__FILE__) + '/../../fixtures') -sqlite_test_db = "#{BASE_DIR}/fixture_database.sqlite" -sqlite_test_db2 = "#{BASE_DIR}/fixture_database_2.sqlite" - -def make_connection(clazz, db_file) - ActiveRecord::Base.configurations = { clazz.name => { :adapter => 'sqlite', :database => db_file } } - unless File.exist?(db_file) - puts "SQLite database not found at #{db_file}. Rebuilding it." - sqlite_command = %Q{sqlite "#{db_file}" "create table a (a integer); drop table a;"} - puts "Executing '#{sqlite_command}'" - raise SqliteError.new("Seems that there is no sqlite executable available") unless system(sqlite_command) - end - clazz.establish_connection(clazz.name) -end - -make_connection(ActiveRecord::Base, sqlite_test_db) -make_connection(Course, sqlite_test_db2) Index: activerecord/test/connections/native_frontbase/connection.rb =================================================================== --- activerecord/test/connections/native_frontbase/connection.rb (revision 8601) +++ activerecord/test/connections/native_frontbase/connection.rb (working copy) @@ -1,27 +0,0 @@ -puts 'Using native Frontbase' -require_dependency 'fixtures/course' -require 'logger' - -ActiveRecord::Base.logger = Logger.new("debug.log") - -ActiveRecord::Base.configurations = { - 'arunit' => { - :adapter => 'frontbase', - :host => 'localhost', - :username => 'rails', - :password => '', - :database => 'activerecord_unittest', - :session_name => "unittest-#{$$}" - }, - 'arunit2' => { - :adapter => 'frontbase', - :host => 'localhost', - :username => 'rails', - :password => '', - :database => 'activerecord_unittest2', - :session_name => "unittest-#{$$}" - } -} - -ActiveRecord::Base.establish_connection 'arunit' -Course.establish_connection 'arunit2' Index: activerecord/test/connections/native_postgresql/connection.rb =================================================================== --- activerecord/test/connections/native_postgresql/connection.rb (revision 8601) +++ activerecord/test/connections/native_postgresql/connection.rb (working copy) @@ -1,23 +0,0 @@ -print "Using native PostgreSQL\n" -require_dependency 'fixtures/course' -require 'logger' - -ActiveRecord::Base.logger = Logger.new("debug.log") - -ActiveRecord::Base.configurations = { - 'arunit' => { - :adapter => 'postgresql', - :username => 'postgres', - :database => 'activerecord_unittest', - :min_messages => 'warning' - }, - 'arunit2' => { - :adapter => 'postgresql', - :username => 'postgres', - :database => 'activerecord_unittest2', - :min_messages => 'warning' - } -} - -ActiveRecord::Base.establish_connection 'arunit' -Course.establish_connection 'arunit2' Index: activerecord/test/connections/native_sqlite3/in_memory_connection.rb =================================================================== --- activerecord/test/connections/native_sqlite3/in_memory_connection.rb (revision 8601) +++ activerecord/test/connections/native_sqlite3/in_memory_connection.rb (working copy) @@ -1,18 +0,0 @@ -print "Using native SQLite3\n" -require_dependency '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', :database => ':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') -load("#{File.dirname(__FILE__)}/../../fixtures/db_definitions/schema.rb") Index: activerecord/test/connections/native_sqlite3/connection.rb =================================================================== --- activerecord/test/connections/native_sqlite3/connection.rb (revision 8601) +++ activerecord/test/connections/native_sqlite3/connection.rb (working copy) @@ -1,25 +0,0 @@ -print "Using native SQLite3\n" -require_dependency 'fixtures/course' -require 'logger' -ActiveRecord::Base.logger = Logger.new("debug.log") - -class SqliteError < StandardError -end - -BASE_DIR = File.expand_path(File.dirname(__FILE__) + '/../../fixtures') -sqlite_test_db = "#{BASE_DIR}/fixture_database.sqlite3" -sqlite_test_db2 = "#{BASE_DIR}/fixture_database_2.sqlite3" - -def make_connection(clazz, db_file) - ActiveRecord::Base.configurations = { clazz.name => { :adapter => 'sqlite3', :database => db_file, :timeout => 5000 } } - unless File.exist?(db_file) - puts "SQLite3 database not found at #{db_file}. Rebuilding it." - sqlite_command = %Q{sqlite3 "#{db_file}" "create table a (a integer); drop table a;"} - puts "Executing '#{sqlite_command}'" - raise SqliteError.new("Seems that there is no sqlite3 executable available") unless system(sqlite_command) - end - clazz.establish_connection(clazz.name) -end - -make_connection(ActiveRecord::Base, sqlite_test_db) -make_connection(Course, sqlite_test_db2) Index: activerecord/test/connections/native_mysql/connection.rb =================================================================== --- activerecord/test/connections/native_mysql/connection.rb (revision 8601) +++ activerecord/test/connections/native_mysql/connection.rb (working copy) @@ -1,27 +0,0 @@ -print "Using native MySQL\n" -require_dependency 'fixtures/course' -require 'logger' - -RAILS_DEFAULT_LOGGER = Logger.new('debug.log') -RAILS_DEFAULT_LOGGER.level = Logger::DEBUG -ActiveRecord::Base.logger = RAILS_DEFAULT_LOGGER - -# GRANT ALL PRIVILEGES ON activerecord_unittest.* to 'rails'@'localhost'; -# GRANT ALL PRIVILEGES ON activerecord_unittest2.* to 'rails'@'localhost'; - -ActiveRecord::Base.configurations = { - 'arunit' => { - :adapter => 'mysql', - :username => 'rails', - :encoding => 'utf8', - :database => 'activerecord_unittest', - }, - 'arunit2' => { - :adapter => 'mysql', - :username => 'rails', - :database => 'activerecord_unittest2' - } -} - -ActiveRecord::Base.establish_connection 'arunit' -Course.establish_connection 'arunit2' Index: activerecord/test/connections/native_oracle/connection.rb =================================================================== --- activerecord/test/connections/native_oracle/connection.rb (revision 8601) +++ activerecord/test/connections/native_oracle/connection.rb (working copy) @@ -1,27 +0,0 @@ -print "Using Oracle\n" -require_dependency 'fixtures/course' -require 'logger' - -ActiveRecord::Base.logger = Logger.new STDOUT -ActiveRecord::Base.logger.level = Logger::WARN - -# Set these to your database connection strings -db = ENV['ARUNIT_DB'] || 'activerecord_unittest' - -ActiveRecord::Base.configurations = { - 'arunit' => { - :adapter => 'oracle', - :username => 'arunit', - :password => 'arunit', - :database => db, - }, - 'arunit2' => { - :adapter => 'oracle', - :username => 'arunit2', - :password => 'arunit2', - :database => db - } -} - -ActiveRecord::Base.establish_connection 'arunit' -Course.establish_connection 'arunit2' Index: activerecord/test/connections/native_firebird/connection.rb =================================================================== --- activerecord/test/connections/native_firebird/connection.rb (revision 8601) +++ activerecord/test/connections/native_firebird/connection.rb (working copy) @@ -1,26 +0,0 @@ -print "Using native Firebird\n" -require_dependency 'fixtures/course' -require 'logger' - -ActiveRecord::Base.logger = Logger.new("debug.log") - -ActiveRecord::Base.configurations = { - 'arunit' => { - :adapter => 'firebird', - :host => 'localhost', - :username => 'rails', - :password => 'rails', - :database => 'activerecord_unittest', - :charset => 'UTF8' - }, - 'arunit2' => { - :adapter => 'firebird', - :host => 'localhost', - :username => 'rails', - :password => 'rails', - :database => 'activerecord_unittest2' - } -} - -ActiveRecord::Base.establish_connection 'arunit' -Course.establish_connection 'arunit2' Index: activerecord/test/connections/native_sybase/connection.rb =================================================================== --- activerecord/test/connections/native_sybase/connection.rb (revision 8601) +++ activerecord/test/connections/native_sybase/connection.rb (working copy) @@ -1,23 +0,0 @@ -print "Using native Sybase Open Client\n" -require_dependency 'fixtures/course' -require 'logger' - -ActiveRecord::Base.logger = Logger.new("debug.log") - -ActiveRecord::Base.configurations = { - 'arunit' => { - :adapter => 'sybase', - :host => 'database_ASE', - :username => 'sa', - :database => 'activerecord_unittest' - }, - 'arunit2' => { - :adapter => 'sybase', - :host => 'database_ASE', - :username => 'sa', - :database => 'activerecord_unittest2' - } -} - -ActiveRecord::Base.establish_connection 'arunit' -Course.establish_connection 'arunit2' Index: activerecord/test/connections/native_db2/connection.rb =================================================================== --- activerecord/test/connections/native_db2/connection.rb (revision 8601) +++ activerecord/test/connections/native_db2/connection.rb (working copy) @@ -1,25 +0,0 @@ -print "Using native DB2\n" -require_dependency 'fixtures/course' -require 'logger' - -ActiveRecord::Base.logger = Logger.new("debug.log") - -ActiveRecord::Base.configurations = { - 'arunit' => { - :adapter => 'db2', - :host => 'localhost', - :username => 'arunit', - :password => 'arunit', - :database => 'arunit' - }, - 'arunit2' => { - :adapter => 'db2', - :host => 'localhost', - :username => 'arunit', - :password => 'arunit', - :database => 'arunit2' - } -} - -ActiveRecord::Base.establish_connection 'arunit' -Course.establish_connection 'arunit2' Index: activerecord/test/ar_schema_test.rb =================================================================== --- activerecord/test/ar_schema_test.rb (revision 8601) +++ activerecord/test/ar_schema_test.rb (working copy) @@ -1,33 +0,0 @@ -require 'abstract_unit' -require "#{File.dirname(__FILE__)}/../lib/active_record/schema" - -if ActiveRecord::Base.connection.supports_migrations? - - class ActiveRecordSchemaTest < ActiveSupport::TestCase - self.use_transactional_fixtures = false - - def setup - @connection = ActiveRecord::Base.connection - end - - def teardown - @connection.drop_table :fruits rescue nil - end - - def test_schema_define - ActiveRecord::Schema.define(:version => 7) do - create_table :fruits do |t| - t.column :color, :string - t.column :fruit_size, :string # NOTE: "size" is reserved in Oracle - t.column :texture, :string - t.column :flavor, :string - end - end - - assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" } - assert_nothing_raised { @connection.select_all "SELECT * FROM schema_info" } - assert_equal 7, @connection.select_one("SELECT version FROM schema_info")['version'].to_i - end - end - -end Index: activerecord/test/connection_test_mysql.rb =================================================================== --- activerecord/test/connection_test_mysql.rb (revision 8601) +++ activerecord/test/connection_test_mysql.rb (working copy) @@ -1,30 +0,0 @@ -require "#{File.dirname(__FILE__)}/abstract_unit" - -class MysqlConnectionTest < ActiveSupport::TestCase - def setup - @connection = ActiveRecord::Base.connection - end - - def test_no_automatic_reconnection_after_timeout - assert @connection.active? - @connection.update('set @@wait_timeout=1') - sleep 2 - assert !@connection.active? - end - - def test_successful_reconnection_after_timeout_with_manual_reconnect - assert @connection.active? - @connection.update('set @@wait_timeout=1') - sleep 2 - @connection.reconnect! - assert @connection.active? - end - - def test_successful_reconnection_after_timeout_with_verify - assert @connection.active? - @connection.update('set @@wait_timeout=1') - sleep 2 - @connection.verify!(0) - assert @connection.active? - end -end Index: activerecord/test/mixin_test.rb =================================================================== --- activerecord/test/mixin_test.rb (revision 8601) +++ activerecord/test/mixin_test.rb (working copy) @@ -1,95 +0,0 @@ -require 'abstract_unit' - -class Mixin < ActiveRecord::Base -end - -# 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 TouchTest < ActiveSupport::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 - - assert_nil stamped.updated_at - assert_nil stamped.created_at - stamped.save - assert_equal Time.now, stamped.updated_at - assert_equal Time.now, stamped.created_at - end - - def test_create - obj = Mixin.create - assert_equal Time.now, obj.updated_at - assert_equal Time.now, obj.created_at - end - - def test_many_updates - stamped = Mixin.new - - assert_nil stamped.updated_at - assert_nil stamped.created_at - stamped.save - assert_equal Time.now, stamped.created_at - assert_equal Time.now, stamped.updated_at - - old_updated_at = stamped.updated_at - - Time.forced_now_time = 5.minutes.from_now - stamped.save - - assert_equal Time.now, stamped.updated_at - assert_equal old_updated_at, stamped.created_at - end - - def test_create_turned_off - Mixin.record_timestamps = false - - mixin = Mixin.new - - assert_nil mixin.updated_at - mixin.save - assert_nil mixin.updated_at - - # Make sure Mixin.record_timestamps gets reset, even if this test fails, - # so that other tests do not fail because Mixin.record_timestamps == false - rescue Exception => e - raise e - ensure - Mixin.record_timestamps = true - end - -end Index: activerecord/test/attribute_methods_test.rb =================================================================== --- activerecord/test/attribute_methods_test.rb (revision 8601) +++ activerecord/test/attribute_methods_test.rb (working copy) @@ -1,146 +0,0 @@ -require 'abstract_unit' -require 'fixtures/topic' - -class AttributeMethodsTest < ActiveSupport::TestCase - fixtures :topics - def setup - @old_suffixes = ActiveRecord::Base.send(:attribute_method_suffixes).dup - @target = Class.new(ActiveRecord::Base) - @target.table_name = 'topics' - end - - def teardown - ActiveRecord::Base.send(:attribute_method_suffixes).clear - ActiveRecord::Base.attribute_method_suffix *@old_suffixes - end - - - def test_match_attribute_method_query_returns_match_data - assert_not_nil md = @target.match_attribute_method?('title=') - assert_equal 'title', md.pre_match - assert_equal ['='], md.captures - - %w(_hello_world ist! _maybe?).each do |suffix| - @target.class_eval "def attribute#{suffix}(*args) args end" - @target.attribute_method_suffix suffix - - assert_not_nil md = @target.match_attribute_method?("title#{suffix}") - assert_equal 'title', md.pre_match - assert_equal [suffix], md.captures - end - end - - def test_declared_attribute_method_affects_respond_to_and_method_missing - topic = @target.new(:title => 'Budget') - assert topic.respond_to?('title') - assert_equal 'Budget', topic.title - assert !topic.respond_to?('title_hello_world') - assert_raise(NoMethodError) { topic.title_hello_world } - - %w(_hello_world _it! _candidate= able?).each do |suffix| - @target.class_eval "def attribute#{suffix}(*args) args end" - @target.attribute_method_suffix suffix - - meth = "title#{suffix}" - assert topic.respond_to?(meth) - assert_equal ['title'], topic.send(meth) - assert_equal ['title', 'a'], topic.send(meth, 'a') - assert_equal ['title', 1, 2, 3], topic.send(meth, 1, 2, 3) - end - end - - def test_should_unserialize_attributes_for_frozen_records - myobj = {:value1 => :value2} - topic = Topic.create("content" => myobj) - topic.freeze - assert_equal myobj, topic.content - end - - def test_kernel_methods_not_implemented_in_activerecord - %w(test name display y).each do |method| - assert_equal false, ActiveRecord::Base.instance_method_already_implemented?(method), "##{method} is defined" - end - end - - def test_primary_key_implemented - assert_equal true, Class.new(ActiveRecord::Base).instance_method_already_implemented?('id') - end - - def test_defined_kernel_methods_implemented_in_model - %w(test name display y).each do |method| - klass = Class.new ActiveRecord::Base - klass.class_eval "def #{method}() 'defined #{method}' end" - assert_equal true, klass.instance_method_already_implemented?(method), "##{method} is not defined" - end - end - - def test_defined_kernel_methods_implemented_in_model_abstract_subclass - %w(test name display y).each do |method| - abstract = Class.new ActiveRecord::Base - abstract.class_eval "def #{method}() 'defined #{method}' end" - abstract.abstract_class = true - klass = Class.new abstract - assert_equal true, klass.instance_method_already_implemented?(method), "##{method} is not defined" - end - end - - def test_raises_dangerous_attribute_error_when_defining_activerecord_method_in_model - %w(save create_or_update).each do |method| - klass = Class.new ActiveRecord::Base - klass.class_eval "def #{method}() 'defined #{method}' end" - assert_raises ActiveRecord::DangerousAttributeError do - klass.instance_method_already_implemented?(method) - end - end - end - - def test_only_time_related_columns_are_meant_to_be_cached_by_default - expected = %w(datetime timestamp time date).sort - assert_equal expected, ActiveRecord::Base.attribute_types_cached_by_default.map(&:to_s).sort -end - - def test_declaring_attributes_as_cached_adds_them_to_the_attributes_cached_by_default - default_attributes = Topic.cached_attributes - Topic.cache_attributes :replies_count - expected = default_attributes + ["replies_count"] - assert_equal expected.sort, Topic.cached_attributes.sort - Topic.instance_variable_set "@cached_attributes", nil - end - - def test_time_related_columns_are_actually_cached - column_types = %w(datetime timestamp time date).map(&:to_sym) - column_names = Topic.columns.select{|c| column_types.include?(c.type) }.map(&:name) - - assert_equal column_names.sort, Topic.cached_attributes.sort - assert_equal time_related_columns_on_topic.sort, Topic.cached_attributes.sort - end - - def test_accessing_cached_attributes_caches_the_converted_values_and_nothing_else - t = topics(:first) - cache = t.instance_variable_get "@attributes_cache" - - assert_not_nil cache - assert cache.empty? - - all_columns = Topic.columns.map(&:name) - cached_columns = time_related_columns_on_topic - uncached_columns = all_columns - cached_columns - - all_columns.each do |attr_name| - attribute_gets_cached = Topic.cache_attribute?(attr_name) - val = t.send attr_name unless attr_name == "type" - if attribute_gets_cached - assert cached_columns.include?(attr_name) - assert_equal val, cache[attr_name] - else - assert uncached_columns.include?(attr_name) - assert !cache.include?(attr_name) - end - end - end - - private - def time_related_columns_on_topic - Topic.columns.select{|c| [:time, :date, :datetime, :timestamp].include?(c.type)}.map(&:name) - end -end Index: activerecord/test/locking_test.rb =================================================================== --- activerecord/test/locking_test.rb (revision 8601) +++ activerecord/test/locking_test.rb (working copy) @@ -1,282 +0,0 @@ -require 'abstract_unit' -require 'fixtures/person' -require 'fixtures/reader' -require 'fixtures/legacy_thing' - -class LockWithoutDefault < ActiveRecord::Base; end - -class LockWithCustomColumnWithoutDefault < ActiveRecord::Base - set_table_name :lock_without_defaults_cust - set_locking_column :custom_lock_version -end - -class ReadonlyFirstNamePerson < Person - attr_readonly :first_name -end - -class OptimisticLockingTest < ActiveSupport::TestCase - fixtures :people, :legacy_things - - # need to disable transactional fixtures, because otherwise the sqlite3 - # adapter (at least) chokes when we try and change the schema in the middle - # of a test (see test_increment_counter_*). - self.use_transactional_fixtures = false - - def test_lock_existing - p1 = Person.find(1) - p2 = Person.find(1) - assert_equal 0, p1.lock_version - assert_equal 0, p2.lock_version - - p1.save! - assert_equal 1, p1.lock_version - assert_equal 0, p2.lock_version - - assert_raises(ActiveRecord::StaleObjectError) { p2.save! } - end - - def test_lock_repeating - p1 = Person.find(1) - p2 = Person.find(1) - assert_equal 0, p1.lock_version - assert_equal 0, p2.lock_version - - p1.save! - assert_equal 1, p1.lock_version - assert_equal 0, p2.lock_version - - assert_raises(ActiveRecord::StaleObjectError) { p2.save! } - assert_raises(ActiveRecord::StaleObjectError) { p2.save! } - end - - def test_lock_new - p1 = Person.new(:first_name => 'anika') - assert_equal 0, p1.lock_version - - p1.save! - p2 = Person.find(p1.id) - assert_equal 0, p1.lock_version - assert_equal 0, p2.lock_version - - p1.save! - assert_equal 1, p1.lock_version - assert_equal 0, p2.lock_version - - assert_raises(ActiveRecord::StaleObjectError) { p2.save! } - end - - def test_lock_new_with_nil - p1 = Person.new(:first_name => 'anika') - p1.save! - p1.lock_version = nil # simulate bad fixture or column with no default - p1.save! - assert_equal 1, p1.lock_version - end - - - def test_lock_column_name_existing - t1 = LegacyThing.find(1) - t2 = LegacyThing.find(1) - assert_equal 0, t1.version - assert_equal 0, t2.version - - t1.save! - assert_equal 1, t1.version - assert_equal 0, t2.version - - assert_raises(ActiveRecord::StaleObjectError) { t2.save! } - end - - def test_lock_column_is_mass_assignable - p1 = Person.create(:first_name => 'bianca') - assert_equal 0, p1.lock_version - assert_equal p1.lock_version, Person.new(p1.attributes).lock_version - - p1.save! - assert_equal 1, p1.lock_version - assert_equal p1.lock_version, Person.new(p1.attributes).lock_version - end - - def test_lock_without_default_sets_version_to_zero - t1 = LockWithoutDefault.new - assert_equal 0, t1.lock_version - end - - def test_lock_with_custom_column_without_default_sets_version_to_zero - t1 = LockWithCustomColumnWithoutDefault.new - assert_equal 0, t1.custom_lock_version - end - - def test_readonly_attributes - assert_equal Set.new([ 'first_name' ]), ReadonlyFirstNamePerson.readonly_attributes - - p = ReadonlyFirstNamePerson.create(:first_name => "unchangeable name") - p.reload - assert_equal "unchangeable name", p.first_name - - p.update_attributes(:first_name => "changed name") - p.reload - assert_equal "unchangeable name", p.first_name - end - - { :lock_version => Person, :custom_lock_version => LegacyThing }.each do |name, model| - define_method("test_increment_counter_updates_#{name}") do - counter_test model, 1 do |id| - model.increment_counter :test_count, id - end - end - - define_method("test_decrement_counter_updates_#{name}") do - counter_test model, -1 do |id| - model.decrement_counter :test_count, id - end - end - - define_method("test_update_counters_updates_#{name}") do - counter_test model, 1 do |id| - model.update_counters id, :test_count => 1 - end - end - end - - private - - def add_counter_column_to(model) - model.connection.add_column model.table_name, :test_count, :integer, :null => false, :default => 0 - model.reset_column_information - # OpenBase does not set a value to existing rows when adding a not null default column - model.update_all(:test_count => 0) if current_adapter?(:OpenBaseAdapter) - end - - def remove_counter_column_from(model) - model.connection.remove_column model.table_name, :test_count - model.reset_column_information - end - - def counter_test(model, expected_count) - add_counter_column_to(model) - object = model.find(:first) - assert_equal 0, object.test_count - assert_equal 0, object.send(model.locking_column) - yield object.id - object.reload - assert_equal expected_count, object.test_count - assert_equal 1, object.send(model.locking_column) - ensure - remove_counter_column_from(model) - end -end - - -# TODO: test against the generated SQL since testing locking behavior itself -# is so cumbersome. Will deadlock Ruby threads if the underlying db.execute -# blocks, so separate script called by Kernel#system is needed. -# (See exec vs. async_exec in the PostgreSQL adapter.) - -# TODO: The SQL Server, Sybase, and OpenBase adapters currently have no support for pessimistic locking - -unless current_adapter?(:SQLServerAdapter, :SybaseAdapter, :OpenBaseAdapter) - class PessimisticLockingTest < ActiveSupport::TestCase - self.use_transactional_fixtures = false - fixtures :people, :readers - - def setup - # Avoid introspection queries during tests. - Person.columns; Reader.columns - - @allow_concurrency = ActiveRecord::Base.allow_concurrency - ActiveRecord::Base.allow_concurrency = true - end - - def teardown - ActiveRecord::Base.allow_concurrency = @allow_concurrency - end - - # Test typical find. - def test_sane_find_with_lock - assert_nothing_raised do - Person.transaction do - Person.find 1, :lock => true - end - end - end - - # Test scoped lock. - def test_sane_find_with_scoped_lock - assert_nothing_raised do - Person.transaction do - Person.with_scope(:find => { :lock => true }) do - Person.find 1 - end - end - end - end - - # PostgreSQL protests SELECT ... FOR UPDATE on an outer join. - unless current_adapter?(:PostgreSQLAdapter) - # Test locked eager find. - def test_eager_find_with_lock - assert_nothing_raised do - Person.transaction do - Person.find 1, :include => :readers, :lock => true - end - end - end - end - - # Locking a record reloads it. - def test_sane_lock_method - assert_nothing_raised do - Person.transaction do - person = Person.find 1 - old, person.first_name = person.first_name, 'fooman' - person.lock! - assert_equal old, person.first_name - end - end - end - - if current_adapter?(:PostgreSQLAdapter, :OracleAdapter) - def test_no_locks_no_wait - first, second = duel { Person.find 1 } - assert first.end > second.end - end - - def test_second_lock_waits - assert [0.2, 1, 5].any? { |zzz| - first, second = duel(zzz) { Person.find 1, :lock => true } - second.end > first.end - } - end - - protected - def duel(zzz = 5) - t0, t1, t2, t3 = nil, nil, nil, nil - - a = Thread.new do - t0 = Time.now - Person.transaction do - yield - sleep zzz # block thread 2 for zzz seconds - end - t1 = Time.now - end - - b = Thread.new do - sleep zzz / 2.0 # ensure thread 1 tx starts first - t2 = Time.now - Person.transaction { yield } - t3 = Time.now - end - - a.join - b.join - - assert t1 > t0 + zzz - assert t2 > t0 - assert t3 > t2 - [t0.to_f..t1.to_f, t2.to_f..t3.to_f] - end - end - end -end Index: activerecord/test/query_cache_test.rb =================================================================== --- activerecord/test/query_cache_test.rb (revision 8601) +++ activerecord/test/query_cache_test.rb (working copy) @@ -1,104 +0,0 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/reply' -require 'fixtures/task' -require 'fixtures/course' - - -class QueryCacheTest < ActiveSupport::TestCase - fixtures :tasks, :topics - - def test_find_queries - assert_queries(2) { Task.find(1); Task.find(1) } - end - - def test_find_queries_with_cache - Task.cache do - assert_queries(1) { Task.find(1); Task.find(1) } - end - end - - def test_count_queries_with_cache - Task.cache do - assert_queries(1) { Task.count; Task.count } - end - end - - def test_query_cache_dups_results_correctly - Task.cache do - now = Time.now.utc - task = Task.find 1 - assert_not_equal now, task.starting - task.starting = now - task.reload - assert_not_equal now, task.starting - end - end - - def test_cache_is_flat - Task.cache do - Topic.columns # don't count this query - assert_queries(1) { Topic.find(1); Topic.find(1); } - end - - ActiveRecord::Base.cache do - assert_queries(1) { Task.find(1); Task.find(1) } - end - end - - def test_cache_does_not_wrap_string_results_in_arrays - Task.cache do - assert_instance_of String, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks") - end - end -end - -uses_mocha 'QueryCacheExpiryTest' do - -class QueryCacheExpiryTest < ActiveSupport::TestCase - fixtures :tasks - - def test_find - Task.connection.expects(:clear_query_cache).times(1) - - assert !Task.connection.query_cache_enabled - Task.cache do - assert Task.connection.query_cache_enabled - Task.find(1) - - Task.uncached do - assert !Task.connection.query_cache_enabled - Task.find(1) - end - - assert Task.connection.query_cache_enabled - end - assert !Task.connection.query_cache_enabled - end - - def test_update - Task.connection.expects(:clear_query_cache).times(2) - - Task.cache do - Task.find(1).save! - end - end - - def test_destroy - Task.connection.expects(:clear_query_cache).times(2) - - Task.cache do - Task.find(1).destroy - end - end - - def test_insert - ActiveRecord::Base.connection.expects(:clear_query_cache).times(2) - - Task.cache do - Task.create! - end - end -end - -end Index: activerecord/test/reflection_test.rb =================================================================== --- activerecord/test/reflection_test.rb (revision 8601) +++ activerecord/test/reflection_test.rb (working copy) @@ -1,175 +0,0 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/customer' -require 'fixtures/company' -require 'fixtures/company_in_module' -require 'fixtures/subscriber' - -class ReflectionTest < ActiveSupport::TestCase - fixtures :topics, :customers, :companies, :subscribers - - def setup - @first = Topic.find(1) - 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_read_attribute_names - assert_equal( - %w( id title author_name author_email_address bonus_time written_on last_read content approved replies_count parent_id type ).sort, - @first.attribute_names - ) - end - - def test_columns - assert_equal 12, Topic.columns.length - end - - def test_columns_are_returned_in_the_order_they_were_declared - column_names = Topic.columns.map { |column| column.name } - assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content approved replies_count parent_id type), column_names - end - - def test_content_columns - content_columns = Topic.content_columns - content_column_names = content_columns.map {|column| column.name} - assert_equal 8, content_columns.length - assert_equal %w(title author_name author_email_address written_on bonus_time last_read content approved).sort, content_column_names.sort - end - - def test_column_string_type_and_limit - 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 - end - - def test_integer_columns - assert_equal :integer, @first.column_for_attribute("id").type - end - - def test_reflection_klass_for_nested_class_name - reflection = ActiveRecord::Reflection::MacroReflection.new(nil, nil, { :class_name => 'MyApplication::Business::Company' }, nil) - assert_nothing_raised do - assert_equal MyApplication::Business::Company, reflection.klass - end - end - - def test_aggregation_reflection - reflection_for_address = ActiveRecord::Reflection::AggregateReflection.new( - :composed_of, :address, { :mapping => [ %w(address_street street), %w(address_city city), %w(address_country country) ] }, Customer - ) - - reflection_for_balance = ActiveRecord::Reflection::AggregateReflection.new( - :composed_of, :balance, { :class_name => "Money", :mapping => %w(balance amount) }, Customer - ) - - reflection_for_gps_location = ActiveRecord::Reflection::AggregateReflection.new( - :composed_of, :gps_location, { }, Customer - ) - - assert Customer.reflect_on_all_aggregations.include?(reflection_for_gps_location) - assert Customer.reflect_on_all_aggregations.include?(reflection_for_balance) - assert Customer.reflect_on_all_aggregations.include?(reflection_for_address) - - assert_equal reflection_for_address, Customer.reflect_on_aggregation(:address) - - assert_equal Address, Customer.reflect_on_aggregation(:address).klass - - assert_equal Money, Customer.reflect_on_aggregation(:balance).klass - end - - def test_has_many_reflection - reflection_for_clients = ActiveRecord::Reflection::AssociationReflection.new(:has_many, :clients, { :order => "id", :dependent => :destroy }, Firm) - - assert_equal reflection_for_clients, Firm.reflect_on_association(:clients) - - assert_equal Client, Firm.reflect_on_association(:clients).klass - assert_equal 'companies', Firm.reflect_on_association(:clients).table_name - - assert_equal Client, Firm.reflect_on_association(:clients_of_firm).klass - assert_equal 'companies', Firm.reflect_on_association(:clients_of_firm).table_name - end - - def test_has_one_reflection - reflection_for_account = ActiveRecord::Reflection::AssociationReflection.new(:has_one, :account, { :foreign_key => "firm_id", :dependent => :destroy }, Firm) - assert_equal reflection_for_account, Firm.reflect_on_association(:account) - - assert_equal Account, Firm.reflect_on_association(:account).klass - assert_equal 'accounts', Firm.reflect_on_association(:account).table_name - end - - def test_belongs_to_inferred_foreign_key_from_assoc_name - Company.belongs_to :foo - assert_equal "foo_id", Company.reflect_on_association(:foo).primary_key_name - Company.belongs_to :bar, :class_name => "Xyzzy" - assert_equal "bar_id", Company.reflect_on_association(:bar).primary_key_name - Company.belongs_to :baz, :class_name => "Xyzzy", :foreign_key => "xyzzy_id" - assert_equal "xyzzy_id", Company.reflect_on_association(:baz).primary_key_name - end - - def test_association_reflection_in_modules - assert_reflection MyApplication::Business::Firm, - :clients_of_firm, - :klass => MyApplication::Business::Client, - :class_name => 'Client', - :table_name => 'companies' - - assert_reflection MyApplication::Billing::Account, - :firm, - :klass => MyApplication::Business::Firm, - :class_name => 'MyApplication::Business::Firm', - :table_name => 'companies' - - assert_reflection MyApplication::Billing::Account, - :qualified_billing_firm, - :klass => MyApplication::Billing::Firm, - :class_name => 'MyApplication::Billing::Firm', - :table_name => 'companies' - - assert_reflection MyApplication::Billing::Account, - :unqualified_billing_firm, - :klass => MyApplication::Billing::Firm, - :class_name => 'Firm', - :table_name => 'companies' - - assert_reflection MyApplication::Billing::Account, - :nested_qualified_billing_firm, - :klass => MyApplication::Billing::Nested::Firm, - :class_name => 'MyApplication::Billing::Nested::Firm', - :table_name => 'companies' - - assert_reflection MyApplication::Billing::Account, - :nested_unqualified_billing_firm, - :klass => MyApplication::Billing::Nested::Firm, - :class_name => 'Nested::Firm', - :table_name => 'companies' - end - - def test_reflection_of_all_associations - 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 - - private - def assert_reflection(klass, association, options) - assert reflection = klass.reflect_on_association(association) - options.each do |method, value| - assert_equal(value, reflection.send(method)) - end - end -end Index: activerecord/test/aaa_create_tables_test.rb =================================================================== --- activerecord/test/aaa_create_tables_test.rb (revision 8601) +++ activerecord/test/aaa_create_tables_test.rb (working copy) @@ -1,72 +0,0 @@ -# The filename begins with "aaa" to ensure this is the first test. -require 'abstract_unit' - -class AAACreateTablesTest < ActiveSupport::TestCase - self.use_transactional_fixtures = false - - def setup - @base_path = "#{File.dirname(__FILE__)}/fixtures/db_definitions" - end - - def test_drop_and_create_main_tables - recreate ActiveRecord::Base unless use_migrations? - assert true - end - - def test_load_schema - if ActiveRecord::Base.connection.supports_migrations? - eval(File.read("#{File.dirname(__FILE__)}/fixtures/db_definitions/schema.rb")) - else - recreate ActiveRecord::Base, '3' - end - assert true - end - - def test_drop_and_create_courses_table - if Course.connection.supports_migrations? - eval(File.read("#{File.dirname(__FILE__)}/fixtures/db_definitions/schema2.rb")) - end - recreate Course, '2' unless use_migrations_for_courses? - assert true - end - - private - def use_migrations? - unittest_sql_filename = ActiveRecord::Base.connection.adapter_name.downcase + ".sql" - not File.exist? "#{@base_path}/#{unittest_sql_filename}" - end - - def use_migrations_for_courses? - unittest2_sql_filename = ActiveRecord::Base.connection.adapter_name.downcase + "2.sql" - not File.exist? "#{@base_path}/#{unittest2_sql_filename}" - end - - def recreate(base, suffix = nil) - connection = base.connection - adapter_name = connection.adapter_name.downcase + suffix.to_s - execute_sql_file "#{@base_path}/#{adapter_name}.drop.sql", connection - execute_sql_file "#{@base_path}/#{adapter_name}.sql", connection - end - - def execute_sql_file(path, connection) - # OpenBase has a different format for sql files - if current_adapter?(:OpenBaseAdapter) then - File.read(path).split("go").each_with_index do |sql, i| - begin - # OpenBase does not support comments embedded in sql - connection.execute(sql,"SQL statement ##{i}") unless sql.blank? - rescue ActiveRecord::StatementInvalid - #$stderr.puts "warning: #{$!}" - end - end - else - File.read(path).split(';').each_with_index do |sql, i| - begin - connection.execute("\n\n-- statement ##{i}\n#{sql}\n") unless sql.blank? - rescue ActiveRecord::StatementInvalid - #$stderr.puts "warning: #{$!}" - end - end - end - end -end Index: activerecord/test/associations_test.rb =================================================================== --- activerecord/test/associations_test.rb (revision 8601) +++ activerecord/test/associations_test.rb (working copy) @@ -1,2177 +0,0 @@ -require 'abstract_unit' -require 'fixtures/developer' -require 'fixtures/project' -require 'fixtures/company' -require 'fixtures/topic' -require 'fixtures/reply' -require 'fixtures/computer' -require 'fixtures/customer' -require 'fixtures/order' -require 'fixtures/categorization' -require 'fixtures/category' -require 'fixtures/post' -require 'fixtures/author' -require 'fixtures/comment' -require 'fixtures/tag' -require 'fixtures/tagging' -require 'fixtures/person' -require 'fixtures/reader' - -class AssociationsTest < ActiveSupport::TestCase - fixtures :accounts, :companies, :developers, :projects, :developers_projects, - :computers - - def test_bad_collection_keys - assert_raise(ArgumentError, 'ActiveRecord should have barked on bad collection keys') do - Class.new(ActiveRecord::Base).has_many(:wheels, :name => 'wheels') - end - end - - def test_should_construct_new_finder_sql_after_create - person = Person.new - assert_equal [], person.readers.find(:all) - person.save! - reader = Reader.create! :person => person, :post => Post.new(:title => "foo", :body => "bar") - assert_equal [reader], person.readers.find(:all) - end - - def test_force_reload - firm = Firm.new("name" => "A New Firm, Inc") - firm.save - firm.clients.each {|c|} # forcing to load all clients - assert firm.clients.empty?, "New firm shouldn't have client objects" - assert_equal 0, firm.clients.size, "New firm should have 0 clients" - - client = Client.new("name" => "TheClient.com", "firm_id" => firm.id) - client.save - - assert firm.clients.empty?, "New firm should have cached no client objects" - assert_equal 0, firm.clients.size, "New firm should have cached 0 clients count" - - assert !firm.clients(true).empty?, "New firm should have reloaded client objects" - assert_equal 1, firm.clients(true).size, "New firm should have reloaded clients count" - end - - def test_storing_in_pstore - require "tmpdir" - store_filename = File.join(Dir.tmpdir, "ar-pstore-association-test") - File.delete(store_filename) if File.exist?(store_filename) - require "pstore" - apple = Firm.create("name" => "Apple") - natural = Client.new("name" => "Natural Company") - apple.clients << natural - - db = PStore.new(store_filename) - db.transaction do - db["apple"] = apple - end - - db = PStore.new(store_filename) - db.transaction do - assert_equal "Natural Company", db["apple"].clients.first.name - end - end -end - -class AssociationProxyTest < ActiveSupport::TestCase - fixtures :authors, :posts, :categorizations, :categories, :developers, :projects, :developers_projects - - def test_proxy_accessors - welcome = posts(:welcome) - assert_equal welcome, welcome.author.proxy_owner - assert_equal welcome.class.reflect_on_association(:author), welcome.author.proxy_reflection - welcome.author.class # force load target - assert_equal welcome.author, welcome.author.proxy_target - - david = authors(:david) - assert_equal david, david.posts.proxy_owner - assert_equal david.class.reflect_on_association(:posts), david.posts.proxy_reflection - david.posts.first # force load target - assert_equal david.posts, david.posts.proxy_target - - assert_equal david, david.posts_with_extension.testing_proxy_owner - assert_equal david.class.reflect_on_association(:posts_with_extension), david.posts_with_extension.testing_proxy_reflection - david.posts_with_extension.first # force load target - assert_equal david.posts_with_extension, david.posts_with_extension.testing_proxy_target - end - - def test_push_does_not_load_target - david = authors(:david) - - david.posts << (post = Post.new(:title => "New on Edge", :body => "More cool stuff!")) - assert !david.posts.loaded? - assert david.posts.include?(post) - end - - def test_push_has_many_through_does_not_load_target - david = authors(:david) - - david.categories << categories(:technology) - assert !david.categories.loaded? - assert david.categories.include?(categories(:technology)) - end - - def test_push_followed_by_save_does_not_load_target - david = authors(:david) - - david.posts << (post = Post.new(:title => "New on Edge", :body => "More cool stuff!")) - assert !david.posts.loaded? - david.save - assert !david.posts.loaded? - assert david.posts.include?(post) - end - - def test_push_does_not_lose_additions_to_new_record - josh = Author.new(:name => "Josh") - josh.posts << Post.new(:title => "New on Edge", :body => "More cool stuff!") - assert josh.posts.loaded? - assert_equal 1, josh.posts.size - end - - def test_save_on_parent_does_not_load_target - david = developers(:david) - - assert !david.projects.loaded? - david.update_attribute(:created_at, Time.now) - assert !david.projects.loaded? - end - - def test_save_on_parent_saves_children - developer = Developer.create :name => "Bryan", :salary => 50_000 - assert_equal 1, developer.reload.audit_logs.size - end - - def test_failed_reload_returns_nil - p = setup_dangling_association - assert_nil p.author.reload - end - - def test_failed_reset_returns_nil - p = setup_dangling_association - assert_nil p.author.reset - end - - def test_reload_returns_assocition - david = developers(:david) - assert_nothing_raised do - assert_equal david.projects, david.projects.reload.reload - end - end - - def setup_dangling_association - josh = Author.create(:name => "Josh") - p = Post.create(:title => "New on Edge", :body => "More cool stuff!", :author => josh) - josh.destroy - p - end -end - -class HasOneAssociationsTest < ActiveSupport::TestCase - fixtures :accounts, :companies, :developers, :projects, :developers_projects - - def setup - Account.destroyed_account_ids.clear - end - - def test_has_one - assert_equal companies(:first_firm).account, Account.find(1) - assert_equal Account.find(1).credit_limit, companies(:first_firm).account.credit_limit - end - - def test_has_one_cache_nils - firm = companies(:another_firm) - assert_queries(1) { assert_nil firm.account } - assert_queries(0) { assert_nil firm.account } - - firms = Firm.find(:all, :include => :account) - assert_queries(0) { firms.each(&:account) } - end - - def test_can_marshal_has_one_association_with_nil_target - firm = Firm.new - assert_nothing_raised do - assert_equal firm.attributes, Marshal.load(Marshal.dump(firm)).attributes - end - - firm.account - assert_nothing_raised do - assert_equal firm.attributes, Marshal.load(Marshal.dump(firm)).attributes - end - end - - def test_proxy_assignment - company = companies(:first_firm) - assert_nothing_raised { company.account = company.account } - end - - def test_triple_equality - assert Account === companies(:first_firm).account - assert companies(:first_firm).account === Account - end - - def test_type_mismatch - assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).account = 1 } - assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).account = Project.find(1) } - end - - def test_natural_assignment - apple = Firm.create("name" => "Apple") - citibank = Account.create("credit_limit" => 10) - apple.account = citibank - assert_equal apple.id, citibank.firm_id - end - - def test_natural_assignment_to_nil - old_account_id = companies(:first_firm).account.id - companies(:first_firm).account = nil - companies(:first_firm).save - assert_nil companies(:first_firm).account - # account is dependent, therefore is destroyed when reference to owner is lost - assert_raises(ActiveRecord::RecordNotFound) { Account.find(old_account_id) } - end - - def test_assignment_without_replacement - apple = Firm.create("name" => "Apple") - citibank = Account.create("credit_limit" => 10) - apple.account = citibank - assert_equal apple.id, citibank.firm_id - - hsbc = apple.build_account({ :credit_limit => 20}, false) - assert_equal apple.id, hsbc.firm_id - hsbc.save - assert_equal apple.id, citibank.firm_id - - nykredit = apple.create_account({ :credit_limit => 30}, false) - assert_equal apple.id, nykredit.firm_id - assert_equal apple.id, citibank.firm_id - assert_equal apple.id, hsbc.firm_id - end - - def test_assignment_without_replacement_on_create - apple = Firm.create("name" => "Apple") - citibank = Account.create("credit_limit" => 10) - apple.account = citibank - assert_equal apple.id, citibank.firm_id - - hsbc = apple.create_account({:credit_limit => 10}, false) - assert_equal apple.id, hsbc.firm_id - hsbc.save - assert_equal apple.id, citibank.firm_id - end - - def test_dependence - num_accounts = Account.count - - firm = Firm.find(1) - assert !firm.account.nil? - account_id = firm.account.id - assert_equal [], Account.destroyed_account_ids[firm.id] - - firm.destroy - assert_equal num_accounts - 1, Account.count - assert_equal [account_id], Account.destroyed_account_ids[firm.id] - end - - def test_exclusive_dependence - num_accounts = Account.count - - firm = ExclusivelyDependentFirm.find(9) - assert !firm.account.nil? - account_id = firm.account.id - assert_equal [], Account.destroyed_account_ids[firm.id] - - firm.destroy - assert_equal num_accounts - 1, Account.count - assert_equal [], Account.destroyed_account_ids[firm.id] - end - - def test_dependence_with_nil_associate - firm = DependentFirm.new(:name => 'nullify') - firm.save! - assert_nothing_raised { firm.destroy } - end - - def test_succesful_build_association - firm = Firm.new("name" => "GlobalMegaCorp") - firm.save - - account = firm.build_account("credit_limit" => 1000) - assert account.save - assert_equal account, firm.account - end - - def test_failing_build_association - firm = Firm.new("name" => "GlobalMegaCorp") - firm.save - - account = firm.build_account - assert !account.save - assert_equal "can't be empty", account.errors.on("credit_limit") - end - - def test_build_association_twice_without_saving_affects_nothing - count_of_account = Account.count - firm = Firm.find(:first) - account1 = firm.build_account("credit_limit" => 1000) - account2 = firm.build_account("credit_limit" => 2000) - - assert_equal count_of_account, Account.count - end - - def test_create_association - firm = Firm.create(:name => "GlobalMegaCorp") - account = firm.create_account(:credit_limit => 1000) - assert_equal account, firm.reload.account - end - - def test_build - firm = Firm.new("name" => "GlobalMegaCorp") - firm.save - - firm.account = account = Account.new("credit_limit" => 1000) - assert_equal account, firm.account - assert account.save - assert_equal account, firm.account - end - - def test_build_before_child_saved - firm = Firm.find(1) - - account = firm.account.build("credit_limit" => 1000) - assert_equal account, firm.account - assert account.new_record? - assert firm.save - assert_equal account, firm.account - assert !account.new_record? - end - - def test_build_before_either_saved - firm = Firm.new("name" => "GlobalMegaCorp") - - firm.account = account = Account.new("credit_limit" => 1000) - assert_equal account, firm.account - assert account.new_record? - assert firm.save - assert_equal account, firm.account - assert !account.new_record? - end - - def test_failing_build_association - firm = Firm.new("name" => "GlobalMegaCorp") - firm.save - - firm.account = account = Account.new - assert_equal account, firm.account - assert !account.save - assert_equal account, firm.account - assert_equal "can't be empty", account.errors.on("credit_limit") - end - - def test_create - firm = Firm.new("name" => "GlobalMegaCorp") - firm.save - firm.account = account = Account.create("credit_limit" => 1000) - assert_equal account, firm.account - end - - def test_create_before_save - firm = Firm.new("name" => "GlobalMegaCorp") - firm.account = account = Account.create("credit_limit" => 1000) - assert_equal account, firm.account - end - - def test_dependence_with_missing_association - Account.destroy_all - firm = Firm.find(1) - assert firm.account.nil? - firm.destroy - end - - def test_dependence_with_missing_association_and_nullify - Account.destroy_all - firm = DependentFirm.find(:first) - assert firm.account.nil? - firm.destroy - end - - def test_assignment_before_parent_saved - firm = Firm.new("name" => "GlobalMegaCorp") - firm.account = a = Account.find(1) - assert firm.new_record? - assert_equal a, firm.account - assert firm.save - assert_equal a, firm.account - assert_equal a, firm.account(true) - end - - def test_finding_with_interpolated_condition - firm = Firm.find(:first) - superior = firm.clients.create(:name => 'SuperiorCo') - superior.rating = 10 - superior.save - assert_equal 10, firm.clients_with_interpolated_conditions.first.rating - end - - def test_assignment_before_child_saved - firm = Firm.find(1) - firm.account = a = Account.new("credit_limit" => 1000) - assert !a.new_record? - assert_equal a, firm.account - assert_equal a, firm.account - assert_equal a, firm.account(true) - end - - def test_assignment_before_either_saved - firm = Firm.new("name" => "GlobalMegaCorp") - firm.account = a = Account.new("credit_limit" => 1000) - assert firm.new_record? - assert a.new_record? - assert_equal a, firm.account - assert firm.save - assert !firm.new_record? - assert !a.new_record? - assert_equal a, firm.account - assert_equal a, firm.account(true) - end - - def test_not_resaved_when_unchanged - firm = Firm.find(:first, :include => :account) - assert_queries(1) { firm.save! } - - firm = Firm.find(:first) - firm.account = Account.find(:first) - assert_queries(1) { firm.save! } - - firm = Firm.find(:first).clone - firm.account = Account.find(:first) - assert_queries(2) { firm.save! } - - firm = Firm.find(:first).clone - firm.account = Account.find(:first).clone - assert_queries(2) { firm.save! } - end - - def test_save_still_works_after_accessing_nil_has_one - jp = Company.new :name => 'Jaded Pixel' - jp.dummy_account.nil? - - assert_nothing_raised do - jp.save! - end - end - -end - - -class HasManyAssociationsTest < ActiveSupport::TestCase - fixtures :accounts, :companies, :developers, :projects, - :developers_projects, :topics, :authors, :comments - - def setup - Client.destroyed_client_ids.clear - end - - def force_signal37_to_load_all_clients_of_firm - companies(:first_firm).clients_of_firm.each {|f| } - end - - def test_counting_with_counter_sql - assert_equal 2, Firm.find(:first).clients.count - end - - def test_counting - assert_equal 2, Firm.find(:first).plain_clients.count - end - - def test_counting_with_single_conditions - assert_equal 2, Firm.find(:first).plain_clients.count(:conditions => '1=1') - end - - def test_counting_with_single_hash - assert_equal 2, Firm.find(:first).plain_clients.count(:conditions => '1=1') - end - - def test_counting_with_column_name_and_hash - assert_equal 2, Firm.find(:first).plain_clients.count(:all, :conditions => '1=1') - end - - def test_finding - assert_equal 2, Firm.find(:first).clients.length - end - - def test_find_many_with_merged_options - assert_equal 1, companies(:first_firm).limited_clients.size - assert_equal 1, companies(:first_firm).limited_clients.find(:all).size - assert_equal 2, companies(:first_firm).limited_clients.find(:all, :limit => nil).size - end - - def test_dynamic_find_should_respect_association_order - assert_equal companies(:second_client), companies(:first_firm).clients_sorted_desc.find(:first, :conditions => "type = 'Client'") - assert_equal companies(:second_client), companies(:first_firm).clients_sorted_desc.find_by_type('Client') - end - - def test_dynamic_find_order_should_override_association_order - assert_equal companies(:first_client), companies(:first_firm).clients_sorted_desc.find(:first, :conditions => "type = 'Client'", :order => 'id') - assert_equal companies(:first_client), companies(:first_firm).clients_sorted_desc.find_by_type('Client', :order => 'id') - end - - def test_dynamic_find_all_should_respect_association_order - assert_equal [companies(:second_client), companies(:first_client)], companies(:first_firm).clients_sorted_desc.find(:all, :conditions => "type = 'Client'") - assert_equal [companies(:second_client), companies(:first_client)], companies(:first_firm).clients_sorted_desc.find_all_by_type('Client') - end - - def test_dynamic_find_all_order_should_override_association_order - assert_equal [companies(:first_client), companies(:second_client)], companies(:first_firm).clients_sorted_desc.find(:all, :conditions => "type = 'Client'", :order => 'id') - assert_equal [companies(:first_client), companies(:second_client)], companies(:first_firm).clients_sorted_desc.find_all_by_type('Client', :order => 'id') - end - - def test_dynamic_find_all_should_respect_association_limit - assert_equal 1, companies(:first_firm).limited_clients.find(:all, :conditions => "type = 'Client'").length - assert_equal 1, companies(:first_firm).limited_clients.find_all_by_type('Client').length - end - - def test_dynamic_find_all_limit_should_override_association_limit - assert_equal 2, companies(:first_firm).limited_clients.find(:all, :conditions => "type = 'Client'", :limit => 9_000).length - assert_equal 2, companies(:first_firm).limited_clients.find_all_by_type('Client', :limit => 9_000).length - end - - def test_triple_equality - assert !(Array === Firm.find(:first).clients) - assert Firm.find(:first).clients === Array - end - - def test_finding_default_orders - assert_equal "Summit", Firm.find(:first).clients.first.name - end - - def test_finding_with_different_class_name_and_order - assert_equal "Microsoft", Firm.find(:first).clients_sorted_desc.first.name - end - - def test_finding_with_foreign_key - assert_equal "Microsoft", Firm.find(:first).clients_of_firm.first.name - end - - def test_finding_with_condition - assert_equal "Microsoft", Firm.find(:first).clients_like_ms.first.name - end - - def test_finding_with_condition_hash - assert_equal "Microsoft", Firm.find(:first).clients_like_ms_with_hash_conditions.first.name - end - - def test_finding_using_sql - firm = Firm.find(:first) - first_client = firm.clients_using_sql.first - assert_not_nil first_client - assert_equal "Microsoft", first_client.name - assert_equal 1, firm.clients_using_sql.size - assert_equal 1, Firm.find(:first).clients_using_sql.size - end - - def test_counting_using_sql - assert_equal 1, Firm.find(:first).clients_using_counter_sql.size - assert Firm.find(:first).clients_using_counter_sql.any? - assert_equal 0, Firm.find(:first).clients_using_zero_counter_sql.size - assert !Firm.find(:first).clients_using_zero_counter_sql.any? - end - - def test_counting_non_existant_items_using_sql - assert_equal 0, Firm.find(:first).no_clients_using_counter_sql.size - end - - def test_belongs_to_sanity - c = Client.new - assert_nil c.firm - - if c.firm - assert false, "belongs_to failed if check" - end - - unless c.firm - else - assert false, "belongs_to failed unless check" - end - end - - def test_find_ids - firm = Firm.find(:first) - - assert_raises(ActiveRecord::RecordNotFound) { firm.clients.find } - - client = firm.clients.find(2) - assert_kind_of Client, client - - client_ary = firm.clients.find([2]) - assert_kind_of Array, client_ary - assert_equal client, client_ary.first - - client_ary = firm.clients.find(2, 3) - assert_kind_of Array, client_ary - assert_equal 2, client_ary.size - assert_equal client, client_ary.first - - assert_raises(ActiveRecord::RecordNotFound) { firm.clients.find(2, 99) } - end - - def test_find_string_ids_when_using_finder_sql - firm = Firm.find(:first) - - client = firm.clients_using_finder_sql.find("2") - assert_kind_of Client, client - - client_ary = firm.clients_using_finder_sql.find(["2"]) - assert_kind_of Array, client_ary - assert_equal client, client_ary.first - - client_ary = firm.clients_using_finder_sql.find("2", "3") - assert_kind_of Array, client_ary - assert_equal 2, client_ary.size - assert client_ary.include?(client) - end - - def test_find_all - firm = Firm.find(:first) - assert_equal 2, firm.clients.find(:all, :conditions => "#{QUOTED_TYPE} = 'Client'").length - assert_equal 1, firm.clients.find(:all, :conditions => "name = 'Summit'").length - end - - def test_find_all_sanitized - firm = Firm.find(:first) - summit = firm.clients.find(:all, :conditions => "name = 'Summit'") - assert_equal summit, firm.clients.find(:all, :conditions => ["name = ?", "Summit"]) - assert_equal summit, firm.clients.find(:all, :conditions => ["name = :name", { :name => "Summit" }]) - end - - def test_find_first - firm = Firm.find(:first) - client2 = Client.find(2) - assert_equal firm.clients.first, firm.clients.find(:first) - assert_equal client2, firm.clients.find(:first, :conditions => "#{QUOTED_TYPE} = 'Client'") - end - - def test_find_first_sanitized - firm = Firm.find(:first) - client2 = Client.find(2) - assert_equal client2, firm.clients.find(:first, :conditions => ["#{QUOTED_TYPE} = ?", 'Client']) - assert_equal client2, firm.clients.find(:first, :conditions => ["#{QUOTED_TYPE} = :type", { :type => 'Client' }]) - end - - def test_find_in_collection - assert_equal Client.find(2).name, companies(:first_firm).clients.find(2).name - assert_raises(ActiveRecord::RecordNotFound) { companies(:first_firm).clients.find(6) } - end - - def test_find_grouped - all_clients_of_firm1 = Client.find(:all, :conditions => "firm_id = 1") - grouped_clients_of_firm1 = Client.find(:all, :conditions => "firm_id = 1", :group => "firm_id", :select => 'firm_id, count(id) as clients_count') - assert_equal 2, all_clients_of_firm1.size - assert_equal 1, grouped_clients_of_firm1.size - end - - def test_adding - force_signal37_to_load_all_clients_of_firm - natural = Client.new("name" => "Natural Company") - companies(:first_firm).clients_of_firm << natural - assert_equal 2, companies(:first_firm).clients_of_firm.size # checking via the collection - assert_equal 2, companies(:first_firm).clients_of_firm(true).size # checking using the db - assert_equal natural, companies(:first_firm).clients_of_firm.last - end - - def test_adding_using_create - first_firm = companies(:first_firm) - assert_equal 2, first_firm.plain_clients.size - natural = first_firm.plain_clients.create(:name => "Natural Company") - assert_equal 3, first_firm.plain_clients.length - assert_equal 3, first_firm.plain_clients.size - end - - def test_create_with_bang_on_has_many_when_parent_is_new_raises - assert_raises(ActiveRecord::RecordNotSaved) do - firm = Firm.new - firm.plain_clients.create! :name=>"Whoever" - end - end - - def test_regular_create_on_has_many_when_parent_is_new_raises - assert_raises(ActiveRecord::RecordNotSaved) do - firm = Firm.new - firm.plain_clients.create :name=>"Whoever" - end - end - - def test_create_with_bang_on_has_many_raises_when_record_not_saved - assert_raises(ActiveRecord::RecordInvalid) do - firm = Firm.find(:first) - firm.plain_clients.create! - end - end - - def test_create_with_bang_on_habtm_when_parent_is_new_raises - assert_raises(ActiveRecord::RecordNotSaved) do - Developer.new("name" => "Aredridel").projects.create! - end - end - - def test_adding_a_mismatch_class - assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).clients_of_firm << nil } - assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).clients_of_firm << 1 } - assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).clients_of_firm << Topic.find(1) } - end - - def test_adding_a_collection - force_signal37_to_load_all_clients_of_firm - companies(:first_firm).clients_of_firm.concat([Client.new("name" => "Natural Company"), Client.new("name" => "Apple")]) - assert_equal 3, companies(:first_firm).clients_of_firm.size - assert_equal 3, companies(:first_firm).clients_of_firm(true).size - end - - def test_adding_before_save - no_of_firms = Firm.count - no_of_clients = Client.count - - new_firm = Firm.new("name" => "A New Firm, Inc") - c = Client.new("name" => "Apple") - - new_firm.clients_of_firm.push Client.new("name" => "Natural Company") - assert_equal 1, new_firm.clients_of_firm.size - new_firm.clients_of_firm << c - assert_equal 2, new_firm.clients_of_firm.size - - assert_equal no_of_firms, Firm.count # Firm was not saved to database. - assert_equal no_of_clients, Client.count # Clients were not saved to database. - assert new_firm.save - assert !new_firm.new_record? - assert !c.new_record? - assert_equal new_firm, c.firm - assert_equal no_of_firms+1, Firm.count # Firm was saved to database. - assert_equal no_of_clients+2, Client.count # Clients were saved to database. - - assert_equal 2, new_firm.clients_of_firm.size - assert_equal 2, new_firm.clients_of_firm(true).size - end - - def test_invalid_adding - firm = Firm.find(1) - assert !(firm.clients_of_firm << c = Client.new) - assert c.new_record? - assert !firm.valid? - assert !firm.save - assert c.new_record? - end - - def test_invalid_adding_before_save - no_of_firms = Firm.count - no_of_clients = Client.count - new_firm = Firm.new("name" => "A New Firm, Inc") - new_firm.clients_of_firm.concat([c = Client.new, Client.new("name" => "Apple")]) - assert c.new_record? - assert !c.valid? - assert !new_firm.valid? - assert !new_firm.save - assert c.new_record? - assert new_firm.new_record? - end - - def test_build - new_client = companies(:first_firm).clients_of_firm.build("name" => "Another Client") - assert_equal "Another Client", new_client.name - assert new_client.new_record? - assert_equal new_client, companies(:first_firm).clients_of_firm.last - assert companies(:first_firm).save - assert !new_client.new_record? - assert_equal 2, companies(:first_firm).clients_of_firm(true).size - end - - def test_build_many - new_clients = companies(:first_firm).clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) - assert_equal 2, new_clients.size - - assert companies(:first_firm).save - assert_equal 3, companies(:first_firm).clients_of_firm(true).size - end - - def test_build_followed_by_save_does_not_load_target - new_client = companies(:first_firm).clients_of_firm.build("name" => "Another Client") - assert companies(:first_firm).save - assert !companies(:first_firm).clients_of_firm.loaded? - end - - def test_build_without_loading_association - first_topic = topics(:first) - Reply.column_names - - assert_equal 1, first_topic.replies.length - - assert_no_queries do - first_topic.replies.build(:title => "Not saved", :content => "Superstars") - assert_equal 2, first_topic.replies.size - end - - assert_equal 2, first_topic.replies.to_ary.size - end - - def test_create_without_loading_association - first_firm = companies(:first_firm) - Firm.column_names - Client.column_names - - assert_equal 1, first_firm.clients_of_firm.size - first_firm.clients_of_firm.reset - - assert_queries(1) do - first_firm.clients_of_firm.create(:name => "Superstars") - end - - assert_equal 2, first_firm.clients_of_firm.size - end - - def test_invalid_build - new_client = companies(:first_firm).clients_of_firm.build - assert new_client.new_record? - assert !new_client.valid? - assert_equal new_client, companies(:first_firm).clients_of_firm.last - assert !companies(:first_firm).save - assert new_client.new_record? - assert_equal 1, companies(:first_firm).clients_of_firm(true).size - end - - def test_create - force_signal37_to_load_all_clients_of_firm - new_client = companies(:first_firm).clients_of_firm.create("name" => "Another Client") - assert !new_client.new_record? - assert_equal new_client, companies(:first_firm).clients_of_firm.last - assert_equal new_client, companies(:first_firm).clients_of_firm(true).last - end - - def test_create_many - companies(:first_firm).clients_of_firm.create([{"name" => "Another Client"}, {"name" => "Another Client II"}]) - assert_equal 3, companies(:first_firm).clients_of_firm(true).size - end - - def test_create_followed_by_save_does_not_load_target - new_client = companies(:first_firm).clients_of_firm.create("name" => "Another Client") - assert companies(:first_firm).save - assert !companies(:first_firm).clients_of_firm.loaded? - end - - def test_find_or_initialize - the_client = companies(:first_firm).clients.find_or_initialize_by_name("Yet another client") - assert_equal companies(:first_firm).id, the_client.firm_id - assert_equal "Yet another client", the_client.name - assert the_client.new_record? - end - - def test_find_or_create - number_of_clients = companies(:first_firm).clients.size - the_client = companies(:first_firm).clients.find_or_create_by_name("Yet another client") - assert_equal number_of_clients + 1, companies(:first_firm, :reload).clients.size - assert_equal the_client, companies(:first_firm).clients.find_or_create_by_name("Yet another client") - assert_equal number_of_clients + 1, companies(:first_firm, :reload).clients.size - end - - def test_deleting - force_signal37_to_load_all_clients_of_firm - companies(:first_firm).clients_of_firm.delete(companies(:first_firm).clients_of_firm.first) - assert_equal 0, companies(:first_firm).clients_of_firm.size - assert_equal 0, companies(:first_firm).clients_of_firm(true).size - end - - def test_deleting_before_save - new_firm = Firm.new("name" => "A New Firm, Inc.") - new_client = new_firm.clients_of_firm.build("name" => "Another Client") - assert_equal 1, new_firm.clients_of_firm.size - new_firm.clients_of_firm.delete(new_client) - assert_equal 0, new_firm.clients_of_firm.size - end - - def test_deleting_a_collection - force_signal37_to_load_all_clients_of_firm - companies(:first_firm).clients_of_firm.create("name" => "Another Client") - assert_equal 2, companies(:first_firm).clients_of_firm.size - companies(:first_firm).clients_of_firm.delete([companies(:first_firm).clients_of_firm[0], companies(:first_firm).clients_of_firm[1]]) - assert_equal 0, companies(:first_firm).clients_of_firm.size - assert_equal 0, companies(:first_firm).clients_of_firm(true).size - end - - def test_delete_all - force_signal37_to_load_all_clients_of_firm - companies(:first_firm).clients_of_firm.create("name" => "Another Client") - assert_equal 2, companies(:first_firm).clients_of_firm.size - companies(:first_firm).clients_of_firm.delete_all - assert_equal 0, companies(:first_firm).clients_of_firm.size - assert_equal 0, companies(:first_firm).clients_of_firm(true).size - end - - def test_delete_all_with_not_yet_loaded_association_collection - force_signal37_to_load_all_clients_of_firm - companies(:first_firm).clients_of_firm.create("name" => "Another Client") - assert_equal 2, companies(:first_firm).clients_of_firm.size - companies(:first_firm).clients_of_firm.reset - companies(:first_firm).clients_of_firm.delete_all - assert_equal 0, companies(:first_firm).clients_of_firm.size - assert_equal 0, companies(:first_firm).clients_of_firm(true).size - end - - def test_clearing_an_association_collection - firm = companies(:first_firm) - client_id = firm.clients_of_firm.first.id - assert_equal 1, firm.clients_of_firm.size - - firm.clients_of_firm.clear - - assert_equal 0, firm.clients_of_firm.size - assert_equal 0, firm.clients_of_firm(true).size - assert_equal [], Client.destroyed_client_ids[firm.id] - - # Should not be destroyed since the association is not dependent. - assert_nothing_raised do - assert Client.find(client_id).firm.nil? - end - end - - def test_clearing_a_dependent_association_collection - firm = companies(:first_firm) - client_id = firm.dependent_clients_of_firm.first.id - assert_equal 1, firm.dependent_clients_of_firm.size - - # :dependent means destroy is called on each client - firm.dependent_clients_of_firm.clear - - assert_equal 0, firm.dependent_clients_of_firm.size - assert_equal 0, firm.dependent_clients_of_firm(true).size - assert_equal [client_id], Client.destroyed_client_ids[firm.id] - - # Should be destroyed since the association is dependent. - assert Client.find_by_id(client_id).nil? - end - - def test_clearing_an_exclusively_dependent_association_collection - firm = companies(:first_firm) - client_id = firm.exclusively_dependent_clients_of_firm.first.id - assert_equal 1, firm.exclusively_dependent_clients_of_firm.size - - assert_equal [], Client.destroyed_client_ids[firm.id] - - # :exclusively_dependent means each client is deleted directly from - # the database without looping through them calling destroy. - firm.exclusively_dependent_clients_of_firm.clear - - assert_equal 0, firm.exclusively_dependent_clients_of_firm.size - assert_equal 0, firm.exclusively_dependent_clients_of_firm(true).size - # no destroy-filters should have been called - assert_equal [], Client.destroyed_client_ids[firm.id] - - # Should be destroyed since the association is exclusively dependent. - assert Client.find_by_id(client_id).nil? - end - - def test_dependent_association_respects_optional_conditions_on_delete - firm = companies(:odegy) - Client.create(:client_of => firm.id, :name => "BigShot Inc.") - Client.create(:client_of => firm.id, :name => "SmallTime Inc.") - # only one of two clients is included in the association due to the :conditions key - assert_equal 2, Client.find_all_by_client_of(firm.id).size - assert_equal 1, firm.dependent_conditional_clients_of_firm.size - firm.destroy - # only the correctly associated client should have been deleted - assert_equal 1, Client.find_all_by_client_of(firm.id).size - end - - def test_dependent_association_respects_optional_sanitized_conditions_on_delete - firm = companies(:odegy) - Client.create(:client_of => firm.id, :name => "BigShot Inc.") - Client.create(:client_of => firm.id, :name => "SmallTime Inc.") - # only one of two clients is included in the association due to the :conditions key - assert_equal 2, Client.find_all_by_client_of(firm.id).size - assert_equal 1, firm.dependent_sanitized_conditional_clients_of_firm.size - firm.destroy - # only the correctly associated client should have been deleted - assert_equal 1, Client.find_all_by_client_of(firm.id).size - end - - def test_clearing_without_initial_access - firm = companies(:first_firm) - - firm.clients_of_firm.clear - - assert_equal 0, firm.clients_of_firm.size - assert_equal 0, firm.clients_of_firm(true).size - end - - def test_deleting_a_item_which_is_not_in_the_collection - force_signal37_to_load_all_clients_of_firm - summit = Client.find_by_name('Summit') - companies(:first_firm).clients_of_firm.delete(summit) - assert_equal 1, companies(:first_firm).clients_of_firm.size - assert_equal 1, companies(:first_firm).clients_of_firm(true).size - assert_equal 2, summit.client_of - end - - def test_deleting_type_mismatch - david = Developer.find(1) - david.projects.reload - assert_raises(ActiveRecord::AssociationTypeMismatch) { david.projects.delete(1) } - end - - def test_deleting_self_type_mismatch - david = Developer.find(1) - david.projects.reload - assert_raises(ActiveRecord::AssociationTypeMismatch) { david.projects.delete(Project.find(1).developers) } - end - - def test_destroy_all - force_signal37_to_load_all_clients_of_firm - assert !companies(:first_firm).clients_of_firm.empty?, "37signals has clients after load" - companies(:first_firm).clients_of_firm.destroy_all - assert companies(:first_firm).clients_of_firm.empty?, "37signals has no clients after destroy all" - assert companies(:first_firm).clients_of_firm(true).empty?, "37signals has no clients after destroy all and refresh" - end - - def test_dependence - firm = companies(:first_firm) - assert_equal 2, firm.clients.size - firm.destroy - assert Client.find(:all, :conditions => "firm_id=#{firm.id}").empty? - end - - def test_destroy_dependent_when_deleted_from_association - firm = Firm.find(:first) - assert_equal 2, firm.clients.size - - client = firm.clients.first - firm.clients.delete(client) - - assert_raise(ActiveRecord::RecordNotFound) { Client.find(client.id) } - assert_raise(ActiveRecord::RecordNotFound) { firm.clients.find(client.id) } - assert_equal 1, firm.clients.size - end - - def test_three_levels_of_dependence - topic = Topic.create "title" => "neat and simple" - reply = topic.replies.create "title" => "neat and simple", "content" => "still digging it" - silly_reply = reply.replies.create "title" => "neat and simple", "content" => "ain't complaining" - - assert_nothing_raised { topic.destroy } - end - - uses_transaction :test_dependence_with_transaction_support_on_failure - def test_dependence_with_transaction_support_on_failure - firm = companies(:first_firm) - clients = firm.clients - assert_equal 2, clients.length - clients.last.instance_eval { def before_destroy() raise "Trigger rollback" end } - - firm.destroy rescue "do nothing" - - assert_equal 2, Client.find(:all, :conditions => "firm_id=#{firm.id}").size - end - - def test_dependence_on_account - num_accounts = Account.count - companies(:first_firm).destroy - assert_equal num_accounts - 1, Account.count - end - - def test_depends_and_nullify - num_accounts = Account.count - num_companies = Company.count - - core = companies(:rails_core) - assert_equal accounts(:rails_core_account), core.account - assert_equal companies(:leetsoft, :jadedpixel), core.companies - core.destroy - assert_nil accounts(:rails_core_account).reload.firm_id - assert_nil companies(:leetsoft).reload.client_of - assert_nil companies(:jadedpixel).reload.client_of - - - assert_equal num_accounts, Account.count - end - - def test_included_in_collection - assert companies(:first_firm).clients.include?(Client.find(2)) - end - - def test_adding_array_and_collection - assert_nothing_raised { Firm.find(:first).clients + Firm.find(:all).last.clients } - end - - def test_find_all_without_conditions - firm = companies(:first_firm) - assert_equal 2, firm.clients.find(:all).length - end - - def test_replace_with_less - firm = Firm.find(:first) - firm.clients = [companies(:first_client)] - assert firm.save, "Could not save firm" - firm.reload - assert_equal 1, firm.clients.length - end - - def test_replace_with_less_and_dependent_nullify - num_companies = Company.count - companies(:rails_core).companies = [] - assert_equal num_companies, Company.count - end - - def test_replace_with_new - firm = Firm.find(:first) - firm.clients = [companies(:second_client), Client.new("name" => "New Client")] - firm.save - firm.reload - assert_equal 2, firm.clients.length - assert !firm.clients.include?(:first_client) - end - - def test_replace_on_new_object - firm = Firm.new("name" => "New Firm") - firm.clients = [companies(:second_client), Client.new("name" => "New Client")] - assert firm.save - firm.reload - assert_equal 2, firm.clients.length - assert firm.clients.include?(Client.find_by_name("New Client")) - end - - def test_get_ids - assert_equal [companies(:first_client).id, companies(:second_client).id], companies(:first_firm).client_ids - end - - def test_assign_ids - firm = Firm.new("name" => "Apple") - firm.client_ids = [companies(:first_client).id, companies(:second_client).id] - firm.save - firm.reload - assert_equal 2, firm.clients.length - assert firm.clients.include?(companies(:second_client)) - end - - def test_assign_ids_ignoring_blanks - firm = Firm.create!(:name => 'Apple') - firm.client_ids = [companies(:first_client).id, nil, companies(:second_client).id, ''] - firm.save! - - assert_equal 2, firm.clients(true).size - assert firm.clients.include?(companies(:second_client)) - end - - def test_get_ids_for_through - assert_equal [comments(:eager_other_comment1).id], authors(:mary).comment_ids - end - - def test_assign_ids_for_through - assert_raise(NoMethodError) { authors(:mary).comment_ids = [123] } - end - - def test_dynamic_find_should_respect_association_order_for_through - assert_equal Comment.find(10), authors(:david).comments_desc.find(:first, :conditions => "comments.type = 'SpecialComment'") - assert_equal Comment.find(10), authors(:david).comments_desc.find_by_type('SpecialComment') - end - - def test_dynamic_find_order_should_override_association_order_for_through - assert_equal Comment.find(3), authors(:david).comments_desc.find(:first, :conditions => "comments.type = 'SpecialComment'", :order => 'comments.id') - assert_equal Comment.find(3), authors(:david).comments_desc.find_by_type('SpecialComment', :order => 'comments.id') - end - - def test_dynamic_find_all_should_respect_association_order_for_through - assert_equal [Comment.find(10), Comment.find(7), Comment.find(6), Comment.find(3)], authors(:david).comments_desc.find(:all, :conditions => "comments.type = 'SpecialComment'") - assert_equal [Comment.find(10), Comment.find(7), Comment.find(6), Comment.find(3)], authors(:david).comments_desc.find_all_by_type('SpecialComment') - end - - def test_dynamic_find_all_order_should_override_association_order_for_through - assert_equal [Comment.find(3), Comment.find(6), Comment.find(7), Comment.find(10)], authors(:david).comments_desc.find(:all, :conditions => "comments.type = 'SpecialComment'", :order => 'comments.id') - assert_equal [Comment.find(3), Comment.find(6), Comment.find(7), Comment.find(10)], authors(:david).comments_desc.find_all_by_type('SpecialComment', :order => 'comments.id') - end - - def test_dynamic_find_all_should_respect_association_limit_for_through - assert_equal 1, authors(:david).limited_comments.find(:all, :conditions => "comments.type = 'SpecialComment'").length - assert_equal 1, authors(:david).limited_comments.find_all_by_type('SpecialComment').length - end - - def test_dynamic_find_all_order_should_override_association_limit_for_through - assert_equal 4, authors(:david).limited_comments.find(:all, :conditions => "comments.type = 'SpecialComment'", :limit => 9_000).length - assert_equal 4, authors(:david).limited_comments.find_all_by_type('SpecialComment', :limit => 9_000).length - end - -end - -class BelongsToAssociationsTest < ActiveSupport::TestCase - fixtures :accounts, :companies, :developers, :projects, :topics, - :developers_projects, :computers, :authors, :posts, :tags, :taggings - - def test_belongs_to - Client.find(3).firm.name - assert_equal companies(:first_firm).name, Client.find(3).firm.name - assert !Client.find(3).firm.nil?, "Microsoft should have a firm" - end - - def test_proxy_assignment - account = Account.find(1) - assert_nothing_raised { account.firm = account.firm } - end - - def test_triple_equality - assert Client.find(3).firm === Firm - assert Firm === Client.find(3).firm - end - - def test_type_mismatch - assert_raise(ActiveRecord::AssociationTypeMismatch) { Account.find(1).firm = 1 } - assert_raise(ActiveRecord::AssociationTypeMismatch) { Account.find(1).firm = Project.find(1) } - end - - def test_natural_assignment - apple = Firm.create("name" => "Apple") - citibank = Account.create("credit_limit" => 10) - citibank.firm = apple - assert_equal apple.id, citibank.firm_id - end - - def test_no_unexpected_aliasing - first_firm = companies(:first_firm) - another_firm = companies(:another_firm) - - citibank = Account.create("credit_limit" => 10) - citibank.firm = first_firm - original_proxy = citibank.firm - citibank.firm = another_firm - - assert_equal first_firm.object_id, original_proxy.object_id - assert_equal another_firm.object_id, citibank.firm.object_id - end - - def test_creating_the_belonging_object - citibank = Account.create("credit_limit" => 10) - apple = citibank.create_firm("name" => "Apple") - assert_equal apple, citibank.firm - citibank.save - citibank.reload - assert_equal apple, citibank.firm - end - - def test_building_the_belonging_object - citibank = Account.create("credit_limit" => 10) - apple = citibank.build_firm("name" => "Apple") - citibank.save - assert_equal apple.id, citibank.firm_id - end - - def test_natural_assignment_to_nil - client = Client.find(3) - client.firm = nil - client.save - assert_nil client.firm(true) - assert_nil client.client_of - end - - def test_with_different_class_name - assert_equal Company.find(1).name, Company.find(3).firm_with_other_name.name - assert_not_nil Company.find(3).firm_with_other_name, "Microsoft should have a firm" - end - - def test_with_condition - assert_equal Company.find(1).name, Company.find(3).firm_with_condition.name - assert_not_nil Company.find(3).firm_with_condition, "Microsoft should have a firm" - end - - def test_belongs_to_counter - debate = Topic.create("title" => "debate") - assert_equal 0, debate.send(:read_attribute, "replies_count"), "No replies yet" - - trash = debate.replies.create("title" => "blah!", "content" => "world around!") - assert_equal 1, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply created" - - trash.destroy - assert_equal 0, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply deleted" - end - - def test_belongs_to_counter_with_reassigning - t1 = Topic.create("title" => "t1") - t2 = Topic.create("title" => "t2") - r1 = Reply.new("title" => "r1", "content" => "r1") - r1.topic = t1 - - assert r1.save - assert_equal 1, Topic.find(t1.id).replies.size - assert_equal 0, Topic.find(t2.id).replies.size - - r1.topic = Topic.find(t2.id) - - assert r1.save - assert_equal 0, Topic.find(t1.id).replies.size - assert_equal 1, Topic.find(t2.id).replies.size - - r1.topic = nil - - assert_equal 0, Topic.find(t1.id).replies.size - assert_equal 0, Topic.find(t2.id).replies.size - - r1.topic = t1 - - assert_equal 1, Topic.find(t1.id).replies.size - assert_equal 0, Topic.find(t2.id).replies.size - - r1.destroy - - assert_equal 0, Topic.find(t1.id).replies.size - assert_equal 0, Topic.find(t2.id).replies.size - end - - def test_belongs_to_counter_after_save - topic = Topic.create!(:title => "monday night") - topic.replies.create!(:title => "re: monday night", :content => "football") - assert_equal 1, Topic.find(topic.id)[:replies_count] - - topic.save! - assert_equal 1, Topic.find(topic.id)[:replies_count] - end - - def test_belongs_to_counter_after_update_attributes - topic = Topic.create!(:title => "37s") - topic.replies.create!(:title => "re: 37s", :content => "rails") - assert_equal 1, Topic.find(topic.id)[:replies_count] - - topic.update_attributes(:title => "37signals") - assert_equal 1, Topic.find(topic.id)[:replies_count] - end - - def test_belongs_to_counter_after_save - topic = Topic.create("title" => "monday night") - topic.replies.create("title" => "re: monday night", "content" => "football") - assert_equal 1, Topic.find(topic.id).send(:read_attribute, "replies_count") - - topic.save - assert_equal 1, Topic.find(topic.id).send(:read_attribute, "replies_count") - end - - def test_belongs_to_counter_after_update_attributes - topic = Topic.create("title" => "37s") - topic.replies.create("title" => "re: 37s", "content" => "rails") - assert_equal 1, Topic.find(topic.id).send(:read_attribute, "replies_count") - - topic.update_attributes("title" => "37signals") - assert_equal 1, Topic.find(topic.id).send(:read_attribute, "replies_count") - end - - def test_assignment_before_parent_saved - client = Client.find(:first) - apple = Firm.new("name" => "Apple") - client.firm = apple - assert_equal apple, client.firm - assert apple.new_record? - assert client.save - assert apple.save - assert !apple.new_record? - assert_equal apple, client.firm - assert_equal apple, client.firm(true) - end - - def test_assignment_before_child_saved - final_cut = Client.new("name" => "Final Cut") - firm = Firm.find(1) - final_cut.firm = firm - assert final_cut.new_record? - assert final_cut.save - assert !final_cut.new_record? - assert !firm.new_record? - assert_equal firm, final_cut.firm - assert_equal firm, final_cut.firm(true) - end - - def test_assignment_before_either_saved - final_cut = Client.new("name" => "Final Cut") - apple = Firm.new("name" => "Apple") - final_cut.firm = apple - assert final_cut.new_record? - assert apple.new_record? - assert final_cut.save - assert !final_cut.new_record? - assert !apple.new_record? - assert_equal apple, final_cut.firm - assert_equal apple, final_cut.firm(true) - end - - def test_new_record_with_foreign_key_but_no_object - c = Client.new("firm_id" => 1) - assert_equal Firm.find(:first), c.firm_with_basic_id - end - - def test_forgetting_the_load_when_foreign_key_enters_late - c = Client.new - assert_nil c.firm_with_basic_id - - c.firm_id = 1 - assert_equal Firm.find(:first), c.firm_with_basic_id - end - - def test_field_name_same_as_foreign_key - computer = Computer.find(1) - assert_not_nil computer.developer, ":foreign key == attribute didn't lock up" # ' - end - - def test_counter_cache - topic = Topic.create :title => "Zoom-zoom-zoom" - assert_equal 0, topic[:replies_count] - - reply = Reply.create(:title => "re: zoom", :content => "speedy quick!") - reply.topic = topic - - assert_equal 1, topic.reload[:replies_count] - assert_equal 1, topic.replies.size - - topic[:replies_count] = 15 - assert_equal 15, topic.replies.size - end - - def test_custom_counter_cache - reply = Reply.create(:title => "re: zoom", :content => "speedy quick!") - assert_equal 0, reply[:replies_count] - - silly = SillyReply.create(:title => "gaga", :content => "boo-boo") - silly.reply = reply - - assert_equal 1, reply.reload[:replies_count] - assert_equal 1, reply.replies.size - - reply[:replies_count] = 17 - assert_equal 17, reply.replies.size - end - - def test_store_two_association_with_one_save - num_orders = Order.count - num_customers = Customer.count - order = Order.new - - customer1 = order.billing = Customer.new - customer2 = order.shipping = Customer.new - assert order.save - assert_equal customer1, order.billing - assert_equal customer2, order.shipping - - order.reload - - assert_equal customer1, order.billing - assert_equal customer2, order.shipping - - assert_equal num_orders +1, Order.count - assert_equal num_customers +2, Customer.count - end - - - def test_store_association_in_two_relations_with_one_save - num_orders = Order.count - num_customers = Customer.count - order = Order.new - - customer = order.billing = order.shipping = Customer.new - assert order.save - assert_equal customer, order.billing - assert_equal customer, order.shipping - - order.reload - - assert_equal customer, order.billing - assert_equal customer, order.shipping - - assert_equal num_orders +1, Order.count - assert_equal num_customers +1, Customer.count - end - - def test_store_association_in_two_relations_with_one_save_in_existing_object - num_orders = Order.count - num_customers = Customer.count - order = Order.create - - customer = order.billing = order.shipping = Customer.new - assert order.save - assert_equal customer, order.billing - assert_equal customer, order.shipping - - order.reload - - assert_equal customer, order.billing - assert_equal customer, order.shipping - - assert_equal num_orders +1, Order.count - assert_equal num_customers +1, Customer.count - end - - def test_store_association_in_two_relations_with_one_save_in_existing_object_with_values - num_orders = Order.count - num_customers = Customer.count - order = Order.create - - customer = order.billing = order.shipping = Customer.new - assert order.save - assert_equal customer, order.billing - assert_equal customer, order.shipping - - order.reload - - customer = order.billing = order.shipping = Customer.new - - assert order.save - order.reload - - assert_equal customer, order.billing - assert_equal customer, order.shipping - - assert_equal num_orders +1, Order.count - assert_equal num_customers +2, Customer.count - end - - - def test_association_assignment_sticks - post = Post.find(:first) - - author1, author2 = Author.find(:all, :limit => 2) - assert_not_nil author1 - assert_not_nil author2 - - # make sure the association is loaded - post.author - - # set the association by id, directly - post.author_id = author2.id - - # save and reload - post.save! - post.reload - - # the author id of the post should be the id we set - assert_equal post.author_id, author2.id - end - -end - - -class ProjectWithAfterCreateHook < ActiveRecord::Base - set_table_name 'projects' - has_and_belongs_to_many :developers, - :class_name => "DeveloperForProjectWithAfterCreateHook", - :join_table => "developers_projects", - :foreign_key => "project_id", - :association_foreign_key => "developer_id" - - after_create :add_david - - def add_david - david = DeveloperForProjectWithAfterCreateHook.find_by_name('David') - david.projects << self - end -end - -class DeveloperForProjectWithAfterCreateHook < ActiveRecord::Base - set_table_name 'developers' - has_and_belongs_to_many :projects, - :class_name => "ProjectWithAfterCreateHook", - :join_table => "developers_projects", - :association_foreign_key => "project_id", - :foreign_key => "developer_id" -end - - -class HasAndBelongsToManyAssociationsTest < ActiveSupport::TestCase - fixtures :accounts, :companies, :categories, :posts, :categories_posts, :developers, :projects, :developers_projects - - def test_has_and_belongs_to_many - david = Developer.find(1) - - assert !david.projects.empty? - assert_equal 2, david.projects.size - - active_record = Project.find(1) - assert !active_record.developers.empty? - assert_equal 3, active_record.developers.size - assert active_record.developers.include?(david) - end - - def test_triple_equality - assert !(Array === Developer.find(1).projects) - assert Developer.find(1).projects === Array - end - - def test_adding_single - jamis = Developer.find(2) - jamis.projects.reload # causing the collection to load - action_controller = Project.find(2) - assert_equal 1, jamis.projects.size - assert_equal 1, action_controller.developers.size - - jamis.projects << action_controller - - assert_equal 2, jamis.projects.size - assert_equal 2, jamis.projects(true).size - assert_equal 2, action_controller.developers(true).size - end - - def test_adding_type_mismatch - jamis = Developer.find(2) - assert_raise(ActiveRecord::AssociationTypeMismatch) { jamis.projects << nil } - assert_raise(ActiveRecord::AssociationTypeMismatch) { jamis.projects << 1 } - end - - def test_adding_from_the_project - jamis = Developer.find(2) - action_controller = Project.find(2) - action_controller.developers.reload - assert_equal 1, jamis.projects.size - assert_equal 1, action_controller.developers.size - - action_controller.developers << jamis - - assert_equal 2, jamis.projects(true).size - assert_equal 2, action_controller.developers.size - assert_equal 2, action_controller.developers(true).size - end - - def test_adding_from_the_project_fixed_timestamp - jamis = Developer.find(2) - action_controller = Project.find(2) - action_controller.developers.reload - assert_equal 1, jamis.projects.size - assert_equal 1, action_controller.developers.size - updated_at = jamis.updated_at - - action_controller.developers << jamis - - assert_equal updated_at, jamis.updated_at - assert_equal 2, jamis.projects(true).size - assert_equal 2, action_controller.developers.size - assert_equal 2, action_controller.developers(true).size - end - - def test_adding_multiple - aredridel = Developer.new("name" => "Aredridel") - aredridel.save - aredridel.projects.reload - aredridel.projects.push(Project.find(1), Project.find(2)) - assert_equal 2, aredridel.projects.size - assert_equal 2, aredridel.projects(true).size - end - - def test_adding_a_collection - aredridel = Developer.new("name" => "Aredridel") - aredridel.save - aredridel.projects.reload - aredridel.projects.concat([Project.find(1), Project.find(2)]) - assert_equal 2, aredridel.projects.size - assert_equal 2, aredridel.projects(true).size - end - - def test_adding_uses_default_values_on_join_table - ac = projects(:action_controller) - assert !developers(:jamis).projects.include?(ac) - developers(:jamis).projects << ac - - assert developers(:jamis, :reload).projects.include?(ac) - project = developers(:jamis).projects.detect { |p| p == ac } - assert_equal 1, project.access_level.to_i - end - - def test_habtm_attribute_access_and_respond_to - project = developers(:jamis).projects[0] - assert project.has_attribute?("name") - assert project.has_attribute?("joined_on") - assert project.has_attribute?("access_level") - assert project.respond_to?("name") - assert project.respond_to?("name=") - assert project.respond_to?("name?") - assert project.respond_to?("joined_on") - # given that the 'join attribute' won't be persisted, I don't - # think we should define the mutators - #assert project.respond_to?("joined_on=") - assert project.respond_to?("joined_on?") - assert project.respond_to?("access_level") - #assert project.respond_to?("access_level=") - assert project.respond_to?("access_level?") - end - - def test_habtm_adding_before_save - no_of_devels = Developer.count - no_of_projects = Project.count - aredridel = Developer.new("name" => "Aredridel") - aredridel.projects.concat([Project.find(1), p = Project.new("name" => "Projekt")]) - assert aredridel.new_record? - assert p.new_record? - assert aredridel.save - assert !aredridel.new_record? - assert_equal no_of_devels+1, Developer.count - assert_equal no_of_projects+1, Project.count - assert_equal 2, aredridel.projects.size - assert_equal 2, aredridel.projects(true).size - end - - def test_habtm_saving_multiple_relationships - new_project = Project.new("name" => "Grimetime") - amount_of_developers = 4 - developers = (0...amount_of_developers).collect {|i| Developer.create(:name => "JME #{i}") }.reverse - - new_project.developer_ids = [developers[0].id, developers[1].id] - new_project.developers_with_callback_ids = [developers[2].id, developers[3].id] - assert new_project.save - - new_project.reload - assert_equal amount_of_developers, new_project.developers.size - assert_equal developers, new_project.developers - end - - def test_habtm_unique_order_preserved - assert_equal developers(:poor_jamis, :jamis, :david), projects(:active_record).non_unique_developers - assert_equal developers(:poor_jamis, :jamis, :david), projects(:active_record).developers - end - - def test_build - devel = Developer.find(1) - proj = devel.projects.build("name" => "Projekt") - assert_equal devel.projects.last, proj - assert proj.new_record? - devel.save - assert !proj.new_record? - assert_equal devel.projects.last, proj - assert_equal Developer.find(1).projects.sort_by(&:id).last, proj # prove join table is updated - end - - def test_build_by_new_record - devel = Developer.new(:name => "Marcel", :salary => 75000) - proj1 = devel.projects.build(:name => "Make bed") - proj2 = devel.projects.build(:name => "Lie in it") - assert_equal devel.projects.last, proj2 - assert proj2.new_record? - devel.save - assert !devel.new_record? - assert !proj2.new_record? - assert_equal devel.projects.last, proj2 - assert_equal Developer.find_by_name("Marcel").projects.last, proj2 # prove join table is updated - end - - def test_create - devel = Developer.find(1) - proj = devel.projects.create("name" => "Projekt") - assert_equal devel.projects.last, proj - assert !proj.new_record? - assert_equal Developer.find(1).projects.sort_by(&:id).last, proj # prove join table is updated - end - - def test_create_by_new_record - devel = Developer.new(:name => "Marcel", :salary => 75000) - proj1 = devel.projects.build(:name => "Make bed") - proj2 = devel.projects.build(:name => "Lie in it") - assert_equal devel.projects.last, proj2 - assert proj2.new_record? - devel.save - assert !devel.new_record? - assert !proj2.new_record? - assert_equal devel.projects.last, proj2 - assert_equal Developer.find_by_name("Marcel").projects.last, proj2 # prove join table is updated - end - - def test_uniq_after_the_fact - developers(:jamis).projects << projects(:active_record) - developers(:jamis).projects << projects(:active_record) - assert_equal 3, developers(:jamis).projects.size - assert_equal 1, developers(:jamis).projects.uniq.size - end - - def test_uniq_before_the_fact - projects(:active_record).developers << developers(:jamis) - projects(:active_record).developers << developers(:david) - assert_equal 3, projects(:active_record, :reload).developers.size - end - - def test_deleting - david = Developer.find(1) - active_record = Project.find(1) - david.projects.reload - assert_equal 2, david.projects.size - assert_equal 3, active_record.developers.size - - david.projects.delete(active_record) - - assert_equal 1, david.projects.size - assert_equal 1, david.projects(true).size - assert_equal 2, active_record.developers(true).size - end - - def test_deleting_array - david = Developer.find(1) - david.projects.reload - david.projects.delete(Project.find(:all)) - assert_equal 0, david.projects.size - assert_equal 0, david.projects(true).size - end - - def test_deleting_with_sql - david = Developer.find(1) - active_record = Project.find(1) - active_record.developers.reload - assert_equal 3, active_record.developers_by_sql.size - - active_record.developers_by_sql.delete(david) - assert_equal 2, active_record.developers_by_sql(true).size - end - - def test_deleting_array_with_sql - active_record = Project.find(1) - active_record.developers.reload - assert_equal 3, active_record.developers_by_sql.size - - active_record.developers_by_sql.delete(Developer.find(:all)) - assert_equal 0, active_record.developers_by_sql(true).size - end - - def test_deleting_all - david = Developer.find(1) - david.projects.reload - david.projects.clear - assert_equal 0, david.projects.size - assert_equal 0, david.projects(true).size - end - - def test_removing_associations_on_destroy - david = DeveloperWithBeforeDestroyRaise.find(1) - assert !david.projects.empty? - assert_nothing_raised { david.destroy } - assert david.projects.empty? - assert DeveloperWithBeforeDestroyRaise.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = 1").empty? - end - - def test_additional_columns_from_join_table - assert_date_from_db Date.new(2004, 10, 10), Developer.find(1).projects.first.joined_on.to_date - end - - def test_destroy_all - david = Developer.find(1) - david.projects.reload - assert !david.projects.empty? - david.projects.destroy_all - assert david.projects.empty? - assert david.projects(true).empty? - end - - def test_deprecated_push_with_attributes_was_removed - jamis = developers(:jamis) - assert_raise(NoMethodError) do - jamis.projects.push_with_attributes(projects(:action_controller), :joined_on => Date.today) - end - end - - def test_associations_with_conditions - assert_equal 3, projects(:active_record).developers.size - assert_equal 1, projects(:active_record).developers_named_david.size - assert_equal 1, projects(:active_record).developers_named_david_with_hash_conditions.size - - assert_equal developers(:david), projects(:active_record).developers_named_david.find(developers(:david).id) - assert_equal developers(:david), projects(:active_record).developers_named_david_with_hash_conditions.find(developers(:david).id) - assert_equal developers(:david), projects(:active_record).salaried_developers.find(developers(:david).id) - - projects(:active_record).developers_named_david.clear - assert_equal 2, projects(:active_record, :reload).developers.size - end - - def test_find_in_association - # Using sql - assert_equal developers(:david), projects(:active_record).developers.find(developers(:david).id), "SQL find" - - # Using ruby - active_record = projects(:active_record) - active_record.developers.reload - assert_equal developers(:david), active_record.developers.find(developers(:david).id), "Ruby find" - end - - def test_find_in_association_with_custom_finder_sql - assert_equal developers(:david), projects(:active_record).developers_with_finder_sql.find(developers(:david).id), "SQL find" - - active_record = projects(:active_record) - active_record.developers_with_finder_sql.reload - assert_equal developers(:david), active_record.developers_with_finder_sql.find(developers(:david).id), "Ruby find" - end - - def test_find_in_association_with_custom_finder_sql_and_string_id - assert_equal developers(:david), projects(:active_record).developers_with_finder_sql.find(developers(:david).id.to_s), "SQL find" - end - - def test_find_with_merged_options - assert_equal 1, projects(:active_record).limited_developers.size - assert_equal 1, projects(:active_record).limited_developers.find(:all).size - assert_equal 3, projects(:active_record).limited_developers.find(:all, :limit => nil).size - end - - def test_dynamic_find_should_respect_association_order - # Developers are ordered 'name DESC, id DESC' - low_id_jamis = developers(:jamis) - middle_id_jamis = developers(:poor_jamis) - high_id_jamis = projects(:active_record).developers.create(:name => 'Jamis') - - assert_equal high_id_jamis, projects(:active_record).developers.find(:first, :conditions => "name = 'Jamis'") - assert_equal high_id_jamis, projects(:active_record).developers.find_by_name('Jamis') - end - - def test_dynamic_find_order_should_override_association_order - # Developers are ordered 'name DESC, id DESC' - low_id_jamis = developers(:jamis) - middle_id_jamis = developers(:poor_jamis) - high_id_jamis = projects(:active_record).developers.create(:name => 'Jamis') - - assert_equal low_id_jamis, projects(:active_record).developers.find(:first, :conditions => "name = 'Jamis'", :order => 'id') - assert_equal low_id_jamis, projects(:active_record).developers.find_by_name('Jamis', :order => 'id') - end - - def test_dynamic_find_all_should_respect_association_order - # Developers are ordered 'name DESC, id DESC' - low_id_jamis = developers(:jamis) - middle_id_jamis = developers(:poor_jamis) - high_id_jamis = projects(:active_record).developers.create(:name => 'Jamis') - - assert_equal [high_id_jamis, middle_id_jamis, low_id_jamis], projects(:active_record).developers.find(:all, :conditions => "name = 'Jamis'") - assert_equal [high_id_jamis, middle_id_jamis, low_id_jamis], projects(:active_record).developers.find_all_by_name('Jamis') - end - - def test_dynamic_find_all_order_should_override_association_order - # Developers are ordered 'name DESC, id DESC' - low_id_jamis = developers(:jamis) - middle_id_jamis = developers(:poor_jamis) - high_id_jamis = projects(:active_record).developers.create(:name => 'Jamis') - - assert_equal [low_id_jamis, middle_id_jamis, high_id_jamis], projects(:active_record).developers.find(:all, :conditions => "name = 'Jamis'", :order => 'id') - assert_equal [low_id_jamis, middle_id_jamis, high_id_jamis], projects(:active_record).developers.find_all_by_name('Jamis', :order => 'id') - end - - def test_dynamic_find_all_should_respect_association_limit - assert_equal 1, projects(:active_record).limited_developers.find(:all, :conditions => "name = 'Jamis'").length - assert_equal 1, projects(:active_record).limited_developers.find_all_by_name('Jamis').length - end - - def test_dynamic_find_all_order_should_override_association_limit - assert_equal 2, projects(:active_record).limited_developers.find(:all, :conditions => "name = 'Jamis'", :limit => 9_000).length - assert_equal 2, projects(:active_record).limited_developers.find_all_by_name('Jamis', :limit => 9_000).length - end - - def test_new_with_values_in_collection - jamis = DeveloperForProjectWithAfterCreateHook.find_by_name('Jamis') - david = DeveloperForProjectWithAfterCreateHook.find_by_name('David') - project = ProjectWithAfterCreateHook.new(:name => "Cooking with Bertie") - project.developers << jamis - project.save! - project.reload - - assert project.developers.include?(jamis) - assert project.developers.include?(david) - end - - def test_find_in_association_with_options - developers = projects(:active_record).developers.find(:all) - assert_equal 3, developers.size - - assert_equal developers(:poor_jamis), projects(:active_record).developers.find(:first, :conditions => "salary < 10000") - assert_equal developers(:jamis), projects(:active_record).developers.find(:first, :order => "salary DESC") - end - - def test_replace_with_less - david = developers(:david) - david.projects = [projects(:action_controller)] - assert david.save - assert_equal 1, david.projects.length - end - - def test_replace_with_new - david = developers(:david) - david.projects = [projects(:action_controller), Project.new("name" => "ActionWebSearch")] - david.save - assert_equal 2, david.projects.length - assert !david.projects.include?(projects(:active_record)) - end - - def test_replace_on_new_object - new_developer = Developer.new("name" => "Matz") - new_developer.projects = [projects(:action_controller), Project.new("name" => "ActionWebSearch")] - new_developer.save - assert_equal 2, new_developer.projects.length - end - - def test_consider_type - developer = Developer.find(:first) - special_project = SpecialProject.create("name" => "Special Project") - - other_project = developer.projects.first - developer.special_projects << special_project - developer.reload - - assert developer.projects.include?(special_project) - assert developer.special_projects.include?(special_project) - assert !developer.special_projects.include?(other_project) - end - - def test_update_attributes_after_push_without_duplicate_join_table_rows - developer = Developer.new("name" => "Kano") - project = SpecialProject.create("name" => "Special Project") - assert developer.save - developer.projects << project - developer.update_attribute("name", "Bruza") - assert_equal 1, Developer.connection.select_value(<<-end_sql).to_i - SELECT count(*) FROM developers_projects - WHERE project_id = #{project.id} - AND developer_id = #{developer.id} - end_sql - end - - def test_updating_attributes_on_non_rich_associations - welcome = categories(:technology).posts.first - welcome.title = "Something else" - assert welcome.save! - end - - def test_habtm_respects_select - categories(:technology).select_testing_posts(true).each do |o| - assert_respond_to o, :correctness_marker - end - assert_respond_to categories(:technology).select_testing_posts.find(:first), :correctness_marker - end - - def test_updating_attributes_on_rich_associations - david = projects(:action_controller).developers.first - david.name = "DHH" - assert_raises(ActiveRecord::ReadOnlyRecord) { david.save! } - end - - def test_updating_attributes_on_rich_associations_with_limited_find_from_reflection - david = projects(:action_controller).selected_developers.first - david.name = "DHH" - assert_nothing_raised { david.save! } - end - - - def test_updating_attributes_on_rich_associations_with_limited_find - david = projects(:action_controller).developers.find(:all, :select => "developers.*").first - david.name = "DHH" - assert david.save! - end - - def test_join_table_alias - assert_equal 3, Developer.find(:all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL').size - end - - def test_join_with_group - group = Developer.columns.inject([]) do |g, c| - g << "developers.#{c.name}" - g << "developers_projects_2.#{c.name}" - end - Project.columns.each { |c| group << "projects.#{c.name}" } - - assert_equal 3, Developer.find(:all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL', :group => group.join(",")).size - end - - def test_get_ids - assert_equal projects(:active_record, :action_controller).map(&:id).sort, developers(:david).project_ids.sort - assert_equal [projects(:active_record).id], developers(:jamis).project_ids - end - - def test_assign_ids - developer = Developer.new("name" => "Joe") - developer.project_ids = projects(:active_record, :action_controller).map(&:id) - developer.save - developer.reload - assert_equal 2, developer.projects.length - assert_equal projects(:active_record), developer.projects[0] - assert_equal projects(:action_controller), developer.projects[1] - end - - def test_assign_ids_ignoring_blanks - developer = Developer.new("name" => "Joe") - developer.project_ids = [projects(:active_record).id, nil, projects(:action_controller).id, ''] - developer.save - developer.reload - assert_equal 2, developer.projects.length - assert_equal projects(:active_record), developer.projects[0] - assert_equal projects(:action_controller), developer.projects[1] - end - - def test_select_limited_ids_list - # Set timestamps - Developer.transaction do - Developer.find(:all, :order => 'id').each_with_index do |record, i| - record.update_attributes(:created_at => 5.years.ago + (i * 5.minutes)) - end - end - - join_base = ActiveRecord::Associations::ClassMethods::JoinDependency::JoinBase.new(Project) - join_dep = ActiveRecord::Associations::ClassMethods::JoinDependency.new(join_base, :developers, nil) - projects = Project.send(:select_limited_ids_list, {:order => 'developers.created_at'}, join_dep) - assert !projects.include?("'"), projects - assert_equal %w(1 2), projects.scan(/\d/).sort - end - - def test_scoped_find_on_through_association_doesnt_return_read_only_records - tag = Post.find(1).tags.find_by_name("General") - - assert_nothing_raised do - tag.save! - end - end -end - - -class OverridingAssociationsTest < ActiveSupport::TestCase - class Person < ActiveRecord::Base; end - class DifferentPerson < ActiveRecord::Base; end - - class PeopleList < ActiveRecord::Base - has_and_belongs_to_many :has_and_belongs_to_many, :before_add => :enlist - has_many :has_many, :before_add => :enlist - belongs_to :belongs_to - has_one :has_one - end - - class DifferentPeopleList < PeopleList - # Different association with the same name, callbacks should be omitted here. - has_and_belongs_to_many :has_and_belongs_to_many, :class_name => 'DifferentPerson' - has_many :has_many, :class_name => 'DifferentPerson' - belongs_to :belongs_to, :class_name => 'DifferentPerson' - has_one :has_one, :class_name => 'DifferentPerson' - end - - def test_habtm_association_redefinition_callbacks_should_differ_and_not_inherited - # redeclared association on AR descendant should not inherit callbacks from superclass - callbacks = PeopleList.read_inheritable_attribute(:before_add_for_has_and_belongs_to_many) - assert_equal([:enlist], callbacks) - callbacks = DifferentPeopleList.read_inheritable_attribute(:before_add_for_has_and_belongs_to_many) - assert_equal([], callbacks) - end - - def test_has_many_association_redefinition_callbacks_should_differ_and_not_inherited - # redeclared association on AR descendant should not inherit callbacks from superclass - callbacks = PeopleList.read_inheritable_attribute(:before_add_for_has_many) - assert_equal([:enlist], callbacks) - callbacks = DifferentPeopleList.read_inheritable_attribute(:before_add_for_has_many) - assert_equal([], callbacks) - end - - def test_habtm_association_redefinition_reflections_should_differ_and_not_inherited - assert_not_equal( - PeopleList.reflect_on_association(:has_and_belongs_to_many), - DifferentPeopleList.reflect_on_association(:has_and_belongs_to_many) - ) - end - - def test_has_many_association_redefinition_reflections_should_differ_and_not_inherited - assert_not_equal( - PeopleList.reflect_on_association(:has_many), - DifferentPeopleList.reflect_on_association(:has_many) - ) - end - - def test_belongs_to_association_redefinition_reflections_should_differ_and_not_inherited - assert_not_equal( - PeopleList.reflect_on_association(:belongs_to), - DifferentPeopleList.reflect_on_association(:belongs_to) - ) - end - - def test_has_one_association_redefinition_reflections_should_differ_and_not_inherited - assert_not_equal( - PeopleList.reflect_on_association(:has_one), - DifferentPeopleList.reflect_on_association(:has_one) - ) - end -end Index: activerecord/test/reserved_word_test_mysql.rb =================================================================== --- activerecord/test/reserved_word_test_mysql.rb (revision 8601) +++ activerecord/test/reserved_word_test_mysql.rb (working copy) @@ -1,177 +0,0 @@ -require "#{File.dirname(__FILE__)}/abstract_unit" - -class Group < ActiveRecord::Base - Group.table_name = 'group' - belongs_to :select, :class_name => 'Select' - has_one :values -end - -class Select < ActiveRecord::Base - Select.table_name = 'select' - has_many :groups -end - -class Values < ActiveRecord::Base - Values.table_name = 'values' -end - -class Distinct < ActiveRecord::Base - Distinct.table_name = 'distinct' - has_and_belongs_to_many :selects - has_many :values, :through => :groups -end - -# a suite of tests to ensure the ConnectionAdapters#MysqlAdapter can handle tables with -# reserved word names (ie: group, order, values, etc...) -class MysqlReservedWordTest < ActiveSupport::TestCase - def setup - @connection = ActiveRecord::Base.connection - - # we call execute directly here (and do similar below) because ActiveRecord::Base#create_table() - # will fail with these table names if these test cases fail - - create_tables_directly 'group'=>'id int auto_increment primary key, `order` varchar(255), select_id int', - 'select'=>'id int auto_increment primary key', - 'values'=>'id int auto_increment primary key, group_id int', - 'distinct'=>'id int auto_increment primary key', - 'distincts_selects'=>'distinct_id int, select_id int' - end - - def teardown - drop_tables_directly ['group', 'select', 'values', 'distinct', 'distincts_selects', 'order'] - end - - # create tables with reserved-word names and columns - def test_create_tables - assert_nothing_raised { - @connection.create_table :order do |t| - t.column :group, :string - end - } - end - - # rename tables with reserved-word names - def test_rename_tables - assert_nothing_raised { @connection.rename_table(:group, :order) } - end - - # alter column with a reserved-word name in a table with a reserved-word name - def test_change_columns - assert_nothing_raised { @connection.change_column_default(:group, :order, 'whatever') } - #the quoting here will reveal any double quoting issues in change_column's interaction with the column method in the adapter - assert_nothing_raised { @connection.change_column('group', 'order', :Int, :default => 0) } - assert_nothing_raised { @connection.rename_column(:group, :order, :values) } - end - - # dump structure of table with reserved word name - def test_structure_dump - assert_nothing_raised { @connection.structure_dump } - end - - # introspect table with reserved word name - def test_introspect - assert_nothing_raised { @connection.columns(:group) } - assert_nothing_raised { @connection.indexes(:group) } - end - - #fixtures - self.use_instantiated_fixtures = true - self.use_transactional_fixtures = false - - #fixtures :group - - def test_fixtures - f = create_test_fixtures :select, :distinct, :group, :values, :distincts_selects - - assert_nothing_raised { - f.each do |x| - x.delete_existing_fixtures - end - } - - assert_nothing_raised { - f.each do |x| - x.insert_fixtures - end - } - end - - #activerecord model class with reserved-word table name - def test_activerecord_model - create_test_fixtures :select, :distinct, :group, :values, :distincts_selects - x = nil - assert_nothing_raised { x = Group.new } - x.order = 'x' - assert_nothing_raised { x.save } - x.order = 'y' - assert_nothing_raised { x.save } - assert_nothing_raised { y = Group.find_by_order('y') } - assert_nothing_raised { y = Group.find(1) } - x = Group.find(1) - end - - # has_one association with reserved-word table name - def test_has_one_associations - create_test_fixtures :select, :distinct, :group, :values, :distincts_selects - v = nil - assert_nothing_raised { v = Group.find(1).values } - assert_equal v.id, 2 - end - - # belongs_to association with reserved-word table name - def test_belongs_to_associations - create_test_fixtures :select, :distinct, :group, :values, :distincts_selects - gs = nil - assert_nothing_raised { gs = Select.find(2).groups } - assert_equal gs.length, 2 - assert(gs.collect{|x| x.id}.sort == [2, 3]) - end - - # has_and_belongs_to_many with reserved-word table name - def test_has_and_belongs_to_many - create_test_fixtures :select, :distinct, :group, :values, :distincts_selects - s = nil - assert_nothing_raised { s = Distinct.find(1).selects } - assert_equal s.length, 2 - assert(s.collect{|x|x.id}.sort == [1, 2]) - end - - # activerecord model introspection with reserved-word table and column names - def test_activerecord_introspection - assert_nothing_raised { Group.table_exists? } - assert_nothing_raised { Group.columns } - end - - # Calculations - def test_calculations_work_with_reserved_words - assert_nothing_raised { Group.count } - end - - def test_associations_work_with_reserved_words - assert_nothing_raised { Select.find(:all, :include => [:groups]) } - end - - #the following functions were added to DRY test cases - - private - # custom fixture loader, uses Fixtures#create_fixtures and appends base_path to the current file's path - def create_test_fixtures(*fixture_names) - fixture_path = "./test/fixtures/reserved_words" - Fixtures.create_fixtures(fixture_path, fixture_names) - end - - # custom drop table, uses execute on connection to drop a table if it exists. note: escapes table_name - def drop_tables_directly(table_names, connection = @connection) - table_names.each do |name| - connection.execute("DROP TABLE IF EXISTS `#{name}`") - end - end - - # custom create table, uses execute on connection to create a table, note: escapes table_name, does NOT escape columns - def create_tables_directly (tables, connection = @connection) - tables.each do |table_name, column_properties| - connection.execute("CREATE TABLE `#{table_name}` ( #{column_properties} )") - end - end - -end Index: activerecord/test/synonym_test_oracle.rb =================================================================== --- activerecord/test/synonym_test_oracle.rb (revision 8601) +++ activerecord/test/synonym_test_oracle.rb (working copy) @@ -1,17 +0,0 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/subject' - -# confirm that synonyms work just like tables; in this case -# the "subjects" table in Oracle (defined in oci.sql) is just -# a synonym to the "topics" table - -class TestOracleSynonym < ActiveSupport::TestCase - - def test_oracle_synonym - topic = Topic.new - subject = Subject.new - assert_equal(topic.attributes, subject.attributes) - end - -end Index: activerecord/test/unconnected_test.rb =================================================================== --- activerecord/test/unconnected_test.rb (revision 8601) +++ activerecord/test/unconnected_test.rb (working copy) @@ -1,32 +0,0 @@ -require 'abstract_unit' - -class TestRecord < ActiveRecord::Base -end - -class TestUnconnectedAdapter < ActiveSupport::TestCase - self.use_transactional_fixtures = false - - def setup - @underlying = ActiveRecord::Base.connection - @specification = ActiveRecord::Base.remove_connection - end - - def teardown - @underlying = nil - ActiveRecord::Base.establish_connection(@specification) - end - - def test_connection_no_longer_established - assert_raise(ActiveRecord::ConnectionNotEstablished) do - TestRecord.find(1) - end - - assert_raise(ActiveRecord::ConnectionNotEstablished) do - TestRecord.new.save - end - end - - def test_underlying_adapter_no_longer_active - assert !@underlying.active?, "Removed adapter should no longer be active" - end -end Index: activerecord/test/column_alias_test.rb =================================================================== --- activerecord/test/column_alias_test.rb (revision 8601) +++ activerecord/test/column_alias_test.rb (working copy) @@ -1,17 +0,0 @@ -require 'abstract_unit' -require 'fixtures/topic' - -class TestColumnAlias < ActiveSupport::TestCase - fixtures :topics - - QUERY = if 'Oracle' == ActiveRecord::Base.connection.adapter_name - 'SELECT id AS pk FROM topics WHERE ROWNUM < 2' - else - 'SELECT id AS pk FROM topics' - end - - def test_column_alias - records = Topic.connection.select_all(QUERY) - assert_equal 'pk', records[0].keys[0] - end -end Index: activerecord/test/json_serialization_test.rb =================================================================== --- activerecord/test/json_serialization_test.rb (revision 8601) +++ activerecord/test/json_serialization_test.rb (working copy) @@ -1,180 +0,0 @@ -require 'abstract_unit' -require 'fixtures/contact' -require 'fixtures/post' -require 'fixtures/author' -require 'fixtures/tagging' -require 'fixtures/tag' -require 'fixtures/comment' - -class JsonSerializationTest < ActiveSupport::TestCase - def setup - @contact = Contact.new( - :name => 'Konata Izumi', - :age => 16, - :avatar => 'binarydata', - :created_at => Time.utc(2006, 8, 1), - :awesome => true, - :preferences => { :shows => 'anime' } - ) - end - - def test_should_encode_all_encodable_attributes - json = @contact.to_json - - assert_match %r{"name": "Konata Izumi"}, json - assert_match %r{"age": 16}, json - assert json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))})) - assert_match %r{"awesome": true}, json - assert_match %r{"preferences": \{"shows": "anime"\}}, json - end - - def test_should_allow_attribute_filtering_with_only - json = @contact.to_json(:only => [:name, :age]) - - assert_match %r{"name": "Konata Izumi"}, json - assert_match %r{"age": 16}, json - assert_no_match %r{"awesome": true}, json - assert !json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))})) - assert_no_match %r{"preferences": \{"shows": "anime"\}}, json - end - - def test_should_allow_attribute_filtering_with_except - json = @contact.to_json(:except => [:name, :age]) - - assert_no_match %r{"name": "Konata Izumi"}, json - assert_no_match %r{"age": 16}, json - assert_match %r{"awesome": true}, json - assert json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))})) - assert_match %r{"preferences": \{"shows": "anime"\}}, json - end - - def test_methods_are_called_on_object - # Define methods on fixture. - def @contact.label; "Has cheezburger"; end - def @contact.favorite_quote; "Constraints are liberating"; end - - # Single method. - assert_match %r{"label": "Has cheezburger"}, @contact.to_json(:only => :name, :methods => :label) - - # Both methods. - methods_json = @contact.to_json(:only => :name, :methods => [:label, :favorite_quote]) - assert_match %r{"label": "Has cheezburger"}, methods_json - assert_match %r{"favorite_quote": "Constraints are liberating"}, methods_json - end -end - -class DatabaseConnectedJsonEncodingTest < ActiveSupport::TestCase - fixtures :authors, :posts, :comments, :tags, :taggings - - def setup - @david = authors(:david) - @mary = authors(:mary) - end - - def test_includes_uses_association_name - json = @david.to_json(:include => :posts) - - assert_match %r{"posts": \[}, json - - assert_match %r{"id": 1}, json - assert_match %r{"name": "David"}, json - - assert_match %r{"author_id": 1}, json - assert_match %r{"title": "Welcome to the weblog"}, json - assert_match %r{"body": "Such a lovely day"}, json - - assert_match %r{"title": "So I was thinking"}, json - assert_match %r{"body": "Like I hopefully always am"}, json - end - - def test_includes_uses_association_name_and_applies_attribute_filters - json = @david.to_json(:include => { :posts => { :only => :title } }) - - assert_match %r{"name": "David"}, json - assert_match %r{"posts": \[}, json - - assert_match %r{"title": "Welcome to the weblog"}, json - assert_no_match %r{"body": "Such a lovely day"}, json - - assert_match %r{"title": "So I was thinking"}, json - assert_no_match %r{"body": "Like I hopefully always am"}, json - end - - def test_includes_fetches_second_level_associations - json = @david.to_json(:include => { :posts => { :include => { :comments => { :only => :body } } } }) - - assert_match %r{"name": "David"}, json - assert_match %r{"posts": \[}, json - - assert_match %r{"comments": \[}, json - assert_match %r{\{"body": "Thank you again for the welcome"\}}, json - assert_match %r{\{"body": "Don't think too hard"\}}, json - assert_no_match %r{"post_id": }, json - end - - def test_includes_fetches_nth_level_associations - json = @david.to_json( - :include => { - :posts => { - :include => { - :taggings => { - :include => { - :tag => { :only => :name } - } - } - } - } - }) - - assert_match %r{"name": "David"}, json - assert_match %r{"posts": \[}, json - - assert_match %r{"taggings": \[}, json - assert_match %r{"tag": \{"name": "General"\}}, json - end - - def test_should_not_call_methods_on_associations_that_dont_respond - def @david.favorite_quote; "Constraints are liberating"; end - json = @david.to_json(:include => :posts, :methods => :favorite_quote) - - assert !@david.posts.first.respond_to?(:favorite_quote) - assert_match %r{"favorite_quote": "Constraints are liberating"}, json - assert_equal %r{"favorite_quote": }.match(json).size, 1 - end - - def test_should_allow_only_option_for_list_of_authors - authors = [@david, @mary] - - assert_equal %([{"name": "David"}, {"name": "Mary"}]), authors.to_json(:only => :name) - end - - def test_should_allow_except_option_for_list_of_authors - authors = [@david, @mary] - - assert_equal %([{"id": 1}, {"id": 2}]), authors.to_json(:except => [:name, :author_address_id]) - end - - def test_should_allow_includes_for_list_of_authors - authors = [@david, @mary] - json = authors.to_json( - :only => :name, - :include => { - :posts => { :only => :id } - } - ) - - ['"name": "David"', '"posts": [', '{"id": 1}', '{"id": 2}', '{"id": 4}', - '{"id": 5}', '{"id": 6}', '"name": "Mary"', '"posts": [{"id": 7}]'].each do |fragment| - assert json.include?(fragment), json - end - end - - def test_should_allow_options_for_hash_of_authors - authors_hash = { - 1 => @david, - 2 => @mary - } - - assert_equal %({1: {"name": "David"}}), authors_hash.to_json(:only => [1, :name]) - end -end Index: activerecord/test/defaults_test.rb =================================================================== --- activerecord/test/defaults_test.rb (revision 8601) +++ activerecord/test/defaults_test.rb (working copy) @@ -1,67 +0,0 @@ -require 'abstract_unit' -require 'fixtures/default' -require 'fixtures/entrant' - -class DefaultTest < ActiveSupport::TestCase - def test_nil_defaults_for_not_null_columns - column_defaults = - if current_adapter?(:MysqlAdapter) - { 'id' => nil, 'name' => '', 'course_id' => nil } - else - { 'id' => nil, 'name' => nil, 'course_id' => nil } - end - - column_defaults.each do |name, default| - column = Entrant.columns_hash[name] - assert !column.null, "#{name} column should be NOT NULL" - assert_equal default, column.default, "#{name} column should be DEFAULT #{default.inspect}" - end - end - - if current_adapter?(:MysqlAdapter) - # MySQL uses an implicit default 0 rather than NULL unless in strict mode. - # We use an implicit NULL so schema.rb is compatible with other databases. - def test_mysql_integer_not_null_defaults - klass = Class.new(ActiveRecord::Base) - klass.table_name = 'test_integer_not_null_default_zero' - klass.connection.create_table klass.table_name do |t| - t.column :zero, :integer, :null => false, :default => 0 - t.column :omit, :integer, :null => false - end - - assert_equal 0, klass.columns_hash['zero'].default - assert !klass.columns_hash['zero'].null - # 0 in MySQL 4, nil in 5. - assert [0, nil].include?(klass.columns_hash['omit'].default) - assert !klass.columns_hash['omit'].null - - assert_raise(ActiveRecord::StatementInvalid) { klass.create! } - - assert_nothing_raised do - instance = klass.create!(:omit => 1) - assert_equal 0, instance.zero - assert_equal 1, instance.omit - end - ensure - klass.connection.drop_table(klass.table_name) rescue nil - end - end - - if current_adapter?(:PostgreSQLAdapter, :SQLServerAdapter, :FirebirdAdapter, :OpenBaseAdapter, :OracleAdapter) - def test_default_integers - default = Default.new - assert_instance_of Fixnum, default.positive_integer - assert_equal 1, default.positive_integer - assert_instance_of Fixnum, default.negative_integer - assert_equal -1, default.negative_integer - assert_instance_of BigDecimal, default.decimal_number - assert_equal BigDecimal.new("2.78"), default.decimal_number - end - end - - if current_adapter?(:PostgreSQLAdapter) - def test_multiline_default_text - assert_equal "--- []\n\n", Default.columns_hash['multiline_default'].default - end - end -end Index: activerecord/test/active_record/ar_schema_test.rb =================================================================== --- activerecord/test/active_record/ar_schema_test.rb (revision 0) +++ activerecord/test/active_record/ar_schema_test.rb (working copy) @@ -1,6 +1,7 @@ -require 'abstract_unit' -require "#{File.dirname(__FILE__)}/../lib/active_record/schema" +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require "active_record/schema" + if ActiveRecord::Base.connection.supports_migrations? class ActiveRecordSchemaTest < ActiveSupport::TestCase Index: activerecord/test/active_record/connection_test_mysql.rb =================================================================== --- activerecord/test/active_record/connection_test_mysql.rb (revision 0) +++ activerecord/test/active_record/connection_test_mysql.rb (working copy) @@ -1,4 +1,4 @@ -require "#{File.dirname(__FILE__)}/abstract_unit" +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") class MysqlConnectionTest < ActiveSupport::TestCase def setup Index: activerecord/test/active_record/mixin_test.rb =================================================================== --- activerecord/test/active_record/mixin_test.rb (revision 0) +++ activerecord/test/active_record/mixin_test.rb (working copy) @@ -1,4 +1,4 @@ -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") class Mixin < ActiveRecord::Base end Index: activerecord/test/active_record/locking_test.rb =================================================================== --- activerecord/test/active_record/locking_test.rb (revision 0) +++ activerecord/test/active_record/locking_test.rb (working copy) @@ -1,8 +1,9 @@ -require 'abstract_unit' -require 'fixtures/person' -require 'fixtures/reader' -require 'fixtures/legacy_thing' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/person' +require 'models/reader' +require 'models/legacy_thing' + class LockWithoutDefault < ActiveRecord::Base; end class LockWithCustomColumnWithoutDefault < ActiveRecord::Base Index: activerecord/test/active_record/attribute_methods_test.rb =================================================================== --- activerecord/test/active_record/attribute_methods_test.rb (revision 0) +++ activerecord/test/active_record/attribute_methods_test.rb (working copy) @@ -1,6 +1,7 @@ -require 'abstract_unit' -require 'fixtures/topic' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/topic' + class AttributeMethodsTest < ActiveSupport::TestCase fixtures :topics def setup Index: activerecord/test/active_record/query_cache_test.rb =================================================================== --- activerecord/test/active_record/query_cache_test.rb (revision 0) +++ activerecord/test/active_record/query_cache_test.rb (working copy) @@ -1,10 +1,11 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/reply' -require 'fixtures/task' -require 'fixtures/course' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/topic' +require 'models/reply' +require 'models/task' +require 'models/course' + class QueryCacheTest < ActiveSupport::TestCase fixtures :tasks, :topics Index: activerecord/test/active_record/reflection_test.rb =================================================================== --- activerecord/test/active_record/reflection_test.rb (revision 0) +++ activerecord/test/active_record/reflection_test.rb (working copy) @@ -1,10 +1,11 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/customer' -require 'fixtures/company' -require 'fixtures/company_in_module' -require 'fixtures/subscriber' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/topic' +require 'models/customer' +require 'models/company' +require 'models/company_in_module' +require 'models/subscriber' + class ReflectionTest < ActiveSupport::TestCase fixtures :topics, :customers, :companies, :subscribers Index: activerecord/test/active_record/aaa_create_tables_test.rb =================================================================== --- activerecord/test/active_record/aaa_create_tables_test.rb (revision 0) +++ activerecord/test/active_record/aaa_create_tables_test.rb (working copy) @@ -1,11 +1,11 @@ # The filename begins with "aaa" to ensure this is the first test. -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") class AAACreateTablesTest < ActiveSupport::TestCase self.use_transactional_fixtures = false def setup - @base_path = "#{File.dirname(__FILE__)}/fixtures/db_definitions" + @base_path = AR_SCHEMA_PATH end def test_drop_and_create_main_tables @@ -15,7 +15,7 @@ def test_load_schema if ActiveRecord::Base.connection.supports_migrations? - eval(File.read("#{File.dirname(__FILE__)}/fixtures/db_definitions/schema.rb")) + eval(File.read("#{AR_SCHEMA_PATH}/schema.rb")) else recreate ActiveRecord::Base, '3' end @@ -24,7 +24,7 @@ def test_drop_and_create_courses_table if Course.connection.supports_migrations? - eval(File.read("#{File.dirname(__FILE__)}/fixtures/db_definitions/schema2.rb")) + eval(File.read("#{AR_SCHEMA_PATH}/schema2.rb")) end recreate Course, '2' unless use_migrations_for_courses? assert true Index: activerecord/test/active_record/associations_test.rb =================================================================== --- activerecord/test/active_record/associations_test.rb (revision 0) +++ activerecord/test/active_record/associations_test.rb (working copy) @@ -1,22 +1,23 @@ -require 'abstract_unit' -require 'fixtures/developer' -require 'fixtures/project' -require 'fixtures/company' -require 'fixtures/topic' -require 'fixtures/reply' -require 'fixtures/computer' -require 'fixtures/customer' -require 'fixtures/order' -require 'fixtures/categorization' -require 'fixtures/category' -require 'fixtures/post' -require 'fixtures/author' -require 'fixtures/comment' -require 'fixtures/tag' -require 'fixtures/tagging' -require 'fixtures/person' -require 'fixtures/reader' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/developer' +require 'models/project' +require 'models/company' +require 'models/topic' +require 'models/reply' +require 'models/computer' +require 'models/customer' +require 'models/order' +require 'models/categorization' +require 'models/category' +require 'models/post' +require 'models/author' +require 'models/comment' +require 'models/tag' +require 'models/tagging' +require 'models/person' +require 'models/reader' + class AssociationsTest < ActiveSupport::TestCase fixtures :accounts, :companies, :developers, :projects, :developers_projects, :computers Index: activerecord/test/active_record/reserved_word_test_mysql.rb =================================================================== --- activerecord/test/active_record/reserved_word_test_mysql.rb (revision 0) +++ activerecord/test/active_record/reserved_word_test_mysql.rb (working copy) @@ -1,4 +1,4 @@ -require "#{File.dirname(__FILE__)}/abstract_unit" +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") class Group < ActiveRecord::Base Group.table_name = 'group' @@ -156,7 +156,7 @@ private # custom fixture loader, uses Fixtures#create_fixtures and appends base_path to the current file's path def create_test_fixtures(*fixture_names) - fixture_path = "./test/fixtures/reserved_words" + fixture_path = AR_FIXTURES_PATH + "/reserved_words" Fixtures.create_fixtures(fixture_path, fixture_names) end Index: activerecord/test/active_record/synonym_test_oracle.rb =================================================================== --- activerecord/test/active_record/synonym_test_oracle.rb (revision 0) +++ activerecord/test/active_record/synonym_test_oracle.rb (working copy) @@ -1,7 +1,8 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/subject' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/topic' +require 'models/subject' + # confirm that synonyms work just like tables; in this case # the "subjects" table in Oracle (defined in oci.sql) is just # a synonym to the "topics" table Index: activerecord/test/active_record/unconnected_test.rb =================================================================== --- activerecord/test/active_record/unconnected_test.rb (revision 0) +++ activerecord/test/active_record/unconnected_test.rb (working copy) @@ -1,4 +1,4 @@ -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") class TestRecord < ActiveRecord::Base end Index: activerecord/test/active_record/json_serialization_test.rb =================================================================== --- activerecord/test/active_record/json_serialization_test.rb (revision 0) +++ activerecord/test/active_record/json_serialization_test.rb (working copy) @@ -1,11 +1,12 @@ -require 'abstract_unit' -require 'fixtures/contact' -require 'fixtures/post' -require 'fixtures/author' -require 'fixtures/tagging' -require 'fixtures/tag' -require 'fixtures/comment' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/contact' +require 'models/post' +require 'models/author' +require 'models/tagging' +require 'models/tag' +require 'models/comment' + class JsonSerializationTest < ActiveSupport::TestCase def setup @contact = Contact.new( Index: activerecord/test/active_record/column_alias_test.rb =================================================================== --- activerecord/test/active_record/column_alias_test.rb (revision 0) +++ activerecord/test/active_record/column_alias_test.rb (working copy) @@ -1,6 +1,7 @@ -require 'abstract_unit' -require 'fixtures/topic' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/topic' + class TestColumnAlias < ActiveSupport::TestCase fixtures :topics Index: activerecord/test/active_record/defaults_test.rb =================================================================== --- activerecord/test/active_record/defaults_test.rb (revision 0) +++ activerecord/test/active_record/defaults_test.rb (working copy) @@ -1,7 +1,8 @@ -require 'abstract_unit' -require 'fixtures/default' -require 'fixtures/entrant' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/default' +require 'models/entrant' + class DefaultTest < ActiveSupport::TestCase def test_nil_defaults_for_not_null_columns column_defaults = Index: activerecord/test/active_record/fixtures_test.rb =================================================================== --- activerecord/test/active_record/fixtures_test.rb (revision 0) +++ activerecord/test/active_record/fixtures_test.rb (working copy) @@ -1,21 +1,22 @@ -require 'abstract_unit' -require 'fixtures/post' -require 'fixtures/binary' -require 'fixtures/topic' -require 'fixtures/computer' -require 'fixtures/developer' -require 'fixtures/company' -require 'fixtures/task' -require 'fixtures/reply' -require 'fixtures/joke' -require 'fixtures/course' -require 'fixtures/category' -require 'fixtures/parrot' -require 'fixtures/pirate' -require 'fixtures/treasure' -require 'fixtures/matey' -require 'fixtures/ship' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/post' +require 'models/binary' +require 'models/topic' +require 'models/computer' +require 'models/developer' +require 'models/company' +require 'models/task' +require 'models/reply' +require 'models/joke' +require 'models/course' +require 'models/category' +require 'models/parrot' +require 'models/pirate' +require 'models/treasure' +require 'models/matey' +require 'models/ship' + class FixturesTest < ActiveSupport::TestCase self.use_instantiated_fixtures = true self.use_transactional_fixtures = false @@ -27,7 +28,7 @@ movies projects subscribers topics tasks ) MATCH_ATTRIBUTE_NAME = /[a-zA-Z][-_\w]*/ - BINARY_FIXTURE_PATH = File.dirname(__FILE__) + '/fixtures/flowers.jpg' + BINARY_FIXTURE_PATH = File.join(AR_ASSETS_PATH, "flowers.jpg") def test_clean_fixtures FIXTURES.each do |name| @@ -140,26 +141,26 @@ end def test_empty_yaml_fixture - assert_not_nil Fixtures.new( Account.connection, "accounts", 'Account', File.dirname(__FILE__) + "/fixtures/naked/yml/accounts") + assert_not_nil Fixtures.new(Account.connection, "accounts", 'Account', AR_FIXTURES_PATH + "/naked/yml/accounts") end def test_empty_yaml_fixture_with_a_comment_in_it - assert_not_nil Fixtures.new( Account.connection, "companies", 'Company', File.dirname(__FILE__) + "/fixtures/naked/yml/companies") + assert_not_nil Fixtures.new( Account.connection, "companies", 'Company', AR_FIXTURES_PATH + "/naked/yml/companies") end def test_dirty_dirty_yaml_file assert_raises(Fixture::FormatError) do - Fixtures.new( Account.connection, "courses", 'Course', File.dirname(__FILE__) + "/fixtures/naked/yml/courses") + Fixtures.new( Account.connection, "courses", 'Course', AR_FIXTURES_PATH + "/naked/yml/courses") end end def test_empty_csv_fixtures - assert_not_nil Fixtures.new( Account.connection, "accounts", 'Account', File.dirname(__FILE__) + "/fixtures/naked/csv/accounts") + assert_not_nil Fixtures.new( Account.connection, "accounts", 'Account', AR_FIXTURES_PATH + "/csv/accounts") end def test_omap_fixtures assert_nothing_raised do - fixtures = Fixtures.new(Account.connection, 'categories', 'Category', File.dirname(__FILE__) + '/fixtures/categories_ordered') + fixtures = Fixtures.new(Account.connection, 'categories', 'Category', AR_FIXTURES_PATH + '/categories_ordered') i = 0 fixtures.each do |name, fixture| @@ -358,7 +359,7 @@ end class SetTableNameFixturesTest < ActiveSupport::TestCase - set_fixture_class :funny_jokes => 'Joke' + set_fixture_class :funny_jokes => Joke fixtures :funny_jokes def test_table_method @@ -430,7 +431,7 @@ end class LoadAllFixturesTest < ActiveSupport::TestCase - self.fixture_path= File.join(File.dirname(__FILE__), '/fixtures/all') + self.fixture_path= File.join(AR_FIXTURES_PATH, '/all') fixtures :all def test_all_there Index: activerecord/test/active_record/base_test.rb =================================================================== --- activerecord/test/active_record/base_test.rb (revision 0) +++ activerecord/test/active_record/base_test.rb (working copy) @@ -1,20 +1,22 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/reply' -require 'fixtures/company' -require 'fixtures/customer' -require 'fixtures/developer' -require 'fixtures/project' -require 'fixtures/default' -require 'fixtures/auto_id' -require 'fixtures/column_name' -require 'fixtures/subscriber' -require 'fixtures/keyboard' -require 'fixtures/post' -require 'fixtures/minimalistic' -require 'fixtures/warehouse_thing' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") + require 'rexml/document' +require 'models/topic' +require 'models/reply' +require 'models/company' +require 'models/customer' +require 'models/developer' +require 'models/project' +require 'models/default' +require 'models/auto_id' +require 'models/column_name' +require 'models/subscriber' +require 'models/keyboard' +require 'models/post' +require 'models/minimalistic' +require 'models/warehouse_thing' + class Category < ActiveRecord::Base; end class Smarts < ActiveRecord::Base; end class CreditCard < ActiveRecord::Base Index: activerecord/test/active_record/schema_dumper_test.rb =================================================================== --- activerecord/test/active_record/schema_dumper_test.rb (revision 0) +++ activerecord/test/active_record/schema_dumper_test.rb (working copy) @@ -1,7 +1,8 @@ -require 'abstract_unit' -require "#{File.dirname(__FILE__)}/../lib/active_record/schema_dumper" -require 'stringio' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require "active_record/schema_dumper" +require "stringio" + if ActiveRecord::Base.connection.respond_to?(:tables) class SchemaDumperTest < ActiveSupport::TestCase Index: activerecord/test/active_record/callbacks_test.rb =================================================================== --- activerecord/test/active_record/callbacks_test.rb (revision 0) +++ activerecord/test/active_record/callbacks_test.rb (working copy) @@ -1,4 +1,4 @@ -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") class CallbackDeveloper < ActiveRecord::Base set_table_name 'developers' Index: activerecord/test/active_record/adapter_test.rb =================================================================== --- activerecord/test/active_record/adapter_test.rb (revision 0) +++ activerecord/test/active_record/adapter_test.rb (working copy) @@ -1,4 +1,4 @@ -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") class AdapterTest < ActiveSupport::TestCase def setup @@ -83,8 +83,8 @@ # test resetting sequences in odd tables in postgreSQL if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!) - require 'fixtures/movie' - require 'fixtures/subscriber' + require 'models/movie' + require 'models/subscriber' def test_reset_empty_table_with_custom_pk Movie.delete_all Index: activerecord/test/active_record/active_schema_test_mysql.rb =================================================================== --- activerecord/test/active_record/active_schema_test_mysql.rb (revision 0) +++ activerecord/test/active_record/active_schema_test_mysql.rb (working copy) @@ -1,4 +1,4 @@ -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") class ActiveSchemaTest < ActiveSupport::TestCase def setup Index: activerecord/test/active_record/class_inheritable_attributes_test.rb =================================================================== --- activerecord/test/active_record/class_inheritable_attributes_test.rb (revision 0) +++ activerecord/test/active_record/class_inheritable_attributes_test.rb (working copy) @@ -1,5 +1,5 @@ -require 'test/unit' -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") + require 'active_support/core_ext/class/inheritable_attributes' class A Index: activerecord/test/active_record/calculations_test.rb =================================================================== --- activerecord/test/active_record/calculations_test.rb (revision 0) +++ activerecord/test/active_record/calculations_test.rb (working copy) @@ -1,7 +1,8 @@ -require 'abstract_unit' -require 'fixtures/company' -require 'fixtures/topic' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/company' +require 'models/topic' + Company.has_many :accounts class NumericData < ActiveRecord::Base Index: activerecord/test/active_record/threaded_connections_test.rb =================================================================== --- activerecord/test/active_record/threaded_connections_test.rb (revision 0) +++ activerecord/test/active_record/threaded_connections_test.rb (working copy) @@ -1,7 +1,8 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/reply' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/topic' +require 'models/reply' + unless %w(FrontBase).include? ActiveRecord::Base.connection.adapter_name class ThreadedConnectionsTest < ActiveSupport::TestCase self.use_transactional_fixtures = false Index: activerecord/test/active_record/schema_test_postgresql.rb =================================================================== --- activerecord/test/active_record/schema_test_postgresql.rb (revision 0) +++ activerecord/test/active_record/schema_test_postgresql.rb (working copy) @@ -1,4 +1,4 @@ -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") class SchemaTest < ActiveSupport::TestCase self.use_transactional_fixtures = false Index: activerecord/test/active_record/binary_test.rb =================================================================== --- activerecord/test/active_record/binary_test.rb (revision 0) +++ activerecord/test/active_record/binary_test.rb (working copy) @@ -1,4 +1,4 @@ -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") # Without using prepared statements, it makes no sense to test # BLOB data with SQL Server, because the length of a statement is @@ -8,16 +8,16 @@ # BLOB data with DB2 or Firebird, because the length of a statement # is limited to 32KB. unless current_adapter?(:SQLServerAdapter, :SybaseAdapter, :DB2Adapter, :FirebirdAdapter) - require 'fixtures/binary' + require 'models/binary' class BinaryTest < ActiveSupport::TestCase - FIXTURES = %w(flowers.jpg example.log) + ASSETS = %w(flowers.jpg example.log) def test_load_save Binary.delete_all - FIXTURES.each do |filename| - data = File.read("#{File.dirname(__FILE__)}/fixtures/#{filename}").freeze + ASSETS.each do |filename| + data = File.read(File.join(AR_ASSETS_PATH, filename)).freeze bin = Binary.new(:data => data) assert_equal data, bin.data, 'Newly assigned data differs from original' Index: activerecord/test/active_record/adapter_test_sqlserver.rb =================================================================== --- activerecord/test/active_record/adapter_test_sqlserver.rb (revision 0) +++ activerecord/test/active_record/adapter_test_sqlserver.rb (working copy) @@ -1,8 +1,9 @@ -require 'abstract_unit' -require 'fixtures/default' -require 'fixtures/post' -require 'fixtures/task' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/default' +require 'models/post' +require 'models/task' + class SqlServerAdapterTest < ActiveSupport::TestCase class TableWithRealColumn < ActiveRecord::Base; end Index: activerecord/test/active_record/deprecated_finder_test.rb =================================================================== --- activerecord/test/active_record/deprecated_finder_test.rb (revision 0) +++ activerecord/test/active_record/deprecated_finder_test.rb (working copy) @@ -1,6 +1,7 @@ -require 'abstract_unit' -require 'fixtures/entrant' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/entrant' + class DeprecatedFinderTest < ActiveSupport::TestCase fixtures :entrants Index: activerecord/test/active_record/inheritance_test.rb =================================================================== --- activerecord/test/active_record/inheritance_test.rb (revision 0) +++ activerecord/test/active_record/inheritance_test.rb (working copy) @@ -1,8 +1,9 @@ -require 'abstract_unit' -require 'fixtures/company' -require 'fixtures/project' -require 'fixtures/subscriber' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/company' +require 'models/project' +require 'models/subscriber' + class InheritanceTest < ActiveSupport::TestCase fixtures :companies, :projects, :subscribers, :accounts Index: activerecord/test/active_record/migration_test.rb =================================================================== --- activerecord/test/active_record/migration_test.rb (revision 0) +++ activerecord/test/active_record/migration_test.rb (working copy) @@ -1,12 +1,16 @@ -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") + require 'bigdecimal/util' -require 'fixtures/person' -require 'fixtures/topic' -require File.dirname(__FILE__) + '/fixtures/migrations/1_people_have_last_names' -require File.dirname(__FILE__) + '/fixtures/migrations/2_we_need_reminders' -require File.dirname(__FILE__) + '/fixtures/migrations_with_decimal/1_give_me_big_numbers' +require 'models/person' +require 'models/topic' +require AR_MIGRATIONS_PATH + '/valid/1_people_have_last_names' +require AR_MIGRATIONS_PATH + '/valid/2_we_need_reminders' +require AR_MIGRATIONS_PATH + '/decimal/1_give_me_big_numbers' + +VALID_MIGRATIONS_PATH = AR_MIGRATIONS_PATH + "/valid/" + if ActiveRecord::Base.connection.supports_migrations? class BigNumber < ActiveRecord::Base; end @@ -686,7 +690,7 @@ assert !Person.column_methods_hash.include?(:last_name) assert !Reminder.table_exists? - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/') + ActiveRecord::Migrator.up(VALID_MIGRATIONS_PATH) assert_equal 3, ActiveRecord::Migrator.current_version Person.reset_column_information @@ -694,7 +698,7 @@ assert Reminder.create("content" => "hello world", "remind_at" => Time.now) assert_equal "hello world", Reminder.find(:first).content - ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/') + ActiveRecord::Migrator.down(VALID_MIGRATIONS_PATH) assert_equal 0, ActiveRecord::Migrator.current_version Person.reset_column_information @@ -706,22 +710,22 @@ assert !Person.column_methods_hash.include?(:last_name) assert !Reminder.table_exists? - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1) + ActiveRecord::Migrator.up(VALID_MIGRATIONS_PATH, 1) Person.reset_column_information assert Person.column_methods_hash.include?(:last_name) assert !Reminder.table_exists? - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 2) + ActiveRecord::Migrator.up(VALID_MIGRATIONS_PATH, 2) assert Reminder.create("content" => "hello world", "remind_at" => Time.now) assert_equal "hello world", Reminder.find(:first).content end def test_migrator_one_down - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/') + ActiveRecord::Migrator.up(VALID_MIGRATIONS_PATH) - ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/', 1) + ActiveRecord::Migrator.down(VALID_MIGRATIONS_PATH, 1) Person.reset_column_information assert Person.column_methods_hash.include?(:last_name) @@ -729,39 +733,39 @@ end def test_migrator_one_up_one_down - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1) - ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/', 0) + ActiveRecord::Migrator.up(VALID_MIGRATIONS_PATH, 1) + ActiveRecord::Migrator.down(VALID_MIGRATIONS_PATH, 0) assert !Person.column_methods_hash.include?(:last_name) assert !Reminder.table_exists? end def test_migrator_verbosity - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1) + ActiveRecord::Migrator.up(VALID_MIGRATIONS_PATH, 1) assert PeopleHaveLastNames.message_count > 0 PeopleHaveLastNames.message_count = 0 - ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/', 0) + ActiveRecord::Migrator.down(VALID_MIGRATIONS_PATH, 0) assert PeopleHaveLastNames.message_count > 0 PeopleHaveLastNames.message_count = 0 end def test_migrator_verbosity_off PeopleHaveLastNames.verbose = false - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1) + ActiveRecord::Migrator.up(VALID_MIGRATIONS_PATH, 1) assert PeopleHaveLastNames.message_count.zero? - ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/', 0) + ActiveRecord::Migrator.down(VALID_MIGRATIONS_PATH, 0) assert PeopleHaveLastNames.message_count.zero? end def test_migrator_going_down_due_to_version_target - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1) - ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations/', 0) + ActiveRecord::Migrator.up(VALID_MIGRATIONS_PATH, 1) + ActiveRecord::Migrator.migrate(VALID_MIGRATIONS_PATH, 0) assert !Person.column_methods_hash.include?(:last_name) assert !Reminder.table_exists? - ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations/') + ActiveRecord::Migrator.migrate(VALID_MIGRATIONS_PATH) Person.reset_column_information assert Person.column_methods_hash.include?(:last_name) @@ -854,16 +858,18 @@ def test_migrator_with_duplicates assert_raises(ActiveRecord::DuplicateMigrationVersionError) do - ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations_with_duplicate/', nil) + ActiveRecord::Migrator.migrate(AR_MIGRATIONS_PATH + "/duplicates/", nil) end end def test_migrator_with_missing_version_numbers - ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations_with_missing_versions/', 500) + missing_path = AR_MIGRATIONS_PATH + "/missing/" + + ActiveRecord::Migrator.migrate(missing_path, 500) assert !Person.column_methods_hash.include?(:middle_name) assert_equal 4, ActiveRecord::Migrator.current_version - ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations_with_missing_versions/', 2) + ActiveRecord::Migrator.migrate(missing_path, 2) Person.reset_column_information assert !Reminder.table_exists? assert Person.column_methods_hash.include?(:last_name) Index: activerecord/test/active_record/default_test_firebird.rb =================================================================== --- activerecord/test/active_record/default_test_firebird.rb (revision 0) +++ activerecord/test/active_record/default_test_firebird.rb (working copy) @@ -1,6 +1,7 @@ -require 'abstract_unit' -require 'fixtures/default' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/default' + class DefaultTest < ActiveSupport::TestCase def test_default_timestamp default = Default.new Index: activerecord/test/active_record/date_time_test.rb =================================================================== --- activerecord/test/active_record/date_time_test.rb (revision 0) +++ activerecord/test/active_record/date_time_test.rb (working copy) @@ -1,7 +1,8 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/task' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/topic' +require 'models/task' + class DateTimeTest < ActiveSupport::TestCase def test_saves_both_date_and_time time_values = [1807, 2, 10, 15, 30, 45] Index: activerecord/test/active_record/table_name_test_sqlserver.rb =================================================================== --- activerecord/test/active_record/table_name_test_sqlserver.rb (revision 0) +++ activerecord/test/active_record/table_name_test_sqlserver.rb (working copy) @@ -1,6 +1,7 @@ -require 'abstract_unit' -require "#{File.dirname(__FILE__)}/../lib/active_record/schema" +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require "active_record/schema" + if ActiveRecord::Base.connection.supports_migrations? class Order < ActiveRecord::Base self.table_name = '[order]' Index: activerecord/test/active_record/xml_serialization_test.rb =================================================================== --- activerecord/test/active_record/xml_serialization_test.rb (revision 0) +++ activerecord/test/active_record/xml_serialization_test.rb (working copy) @@ -1,10 +1,11 @@ -require 'abstract_unit' -require 'fixtures/contact' -require 'fixtures/post' -require 'fixtures/author' -require 'fixtures/tagging' -require 'fixtures/comment' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/contact' +require 'models/post' +require 'models/author' +require 'models/tagging' +require 'models/comment' + class XmlSerializationTest < ActiveSupport::TestCase def test_should_serialize_default_root @xml = Contact.new.to_xml Index: activerecord/test/active_record/associations/callbacks_test.rb =================================================================== --- activerecord/test/active_record/associations/callbacks_test.rb (revision 8601) +++ activerecord/test/active_record/associations/callbacks_test.rb (working copy) @@ -1,11 +1,12 @@ -require 'abstract_unit' -require 'fixtures/post' -require 'fixtures/comment' -require 'fixtures/author' -require 'fixtures/category' -require 'fixtures/project' -require 'fixtures/developer' +require File.expand_path(File.dirname(__FILE__) + "/../../test_helper") +require 'models/post' +require 'models/comment' +require 'models/author' +require 'models/category' +require 'models/project' +require 'models/developer' + class AssociationCallbacksTest < ActiveSupport::TestCase fixtures :posts, :authors, :projects, :developers Index: activerecord/test/active_record/associations/join_model_test.rb =================================================================== --- activerecord/test/active_record/associations/join_model_test.rb (revision 8601) +++ activerecord/test/active_record/associations/join_model_test.rb (working copy) @@ -1,17 +1,18 @@ -require 'abstract_unit' -require 'fixtures/tag' -require 'fixtures/tagging' -require 'fixtures/post' -require 'fixtures/item' -require 'fixtures/comment' -require 'fixtures/author' -require 'fixtures/category' -require 'fixtures/categorization' -require 'fixtures/vertex' -require 'fixtures/edge' -require 'fixtures/book' -require 'fixtures/citation' +require File.expand_path(File.dirname(__FILE__) + "/../../test_helper") +require 'models/tag' +require 'models/tagging' +require 'models/post' +require 'models/item' +require 'models/comment' +require 'models/author' +require 'models/category' +require 'models/categorization' +require 'models/vertex' +require 'models/edge' +require 'models/book' +require 'models/citation' + class AssociationsJoinModelTest < ActiveSupport::TestCase self.use_transactional_fixtures = false fixtures :posts, :authors, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites, :vertices, :items, :books Index: activerecord/test/active_record/associations/eager_test.rb =================================================================== --- activerecord/test/active_record/associations/eager_test.rb (revision 8601) +++ activerecord/test/active_record/associations/eager_test.rb (working copy) @@ -1,12 +1,13 @@ -require 'abstract_unit' -require 'fixtures/post' -require 'fixtures/comment' -require 'fixtures/author' -require 'fixtures/category' -require 'fixtures/company' -require 'fixtures/person' -require 'fixtures/reader' +require File.expand_path(File.dirname(__FILE__) + "/../../test_helper") +require 'models/post' +require 'models/comment' +require 'models/author' +require 'models/category' +require 'models/company' +require 'models/person' +require 'models/reader' + class EagerAssociationTest < ActiveSupport::TestCase fixtures :posts, :comments, :authors, :categories, :categories_posts, :companies, :accounts, :tags, :people, :readers Index: activerecord/test/active_record/associations/eager_singularization_test.rb =================================================================== --- activerecord/test/active_record/associations/eager_singularization_test.rb (revision 8601) +++ activerecord/test/active_record/associations/eager_singularization_test.rb (working copy) @@ -1,4 +1,4 @@ -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../../test_helper") class Virus < ActiveRecord::Base belongs_to :octopus Index: activerecord/test/active_record/associations/inner_join_association_test.rb =================================================================== --- activerecord/test/active_record/associations/inner_join_association_test.rb (revision 8601) +++ activerecord/test/active_record/associations/inner_join_association_test.rb (working copy) @@ -1,10 +1,11 @@ -require 'abstract_unit' -require 'fixtures/post' -require 'fixtures/comment' -require 'fixtures/author' -require 'fixtures/category' -require 'fixtures/categorization' +require File.expand_path(File.dirname(__FILE__) + "/../../test_helper") +require 'models/post' +require 'models/comment' +require 'models/author' +require 'models/category' +require 'models/categorization' + class InnerJoinAssociationTest < ActiveSupport::TestCase fixtures :authors, :posts, :comments, :categories, :categories_posts, :categorizations Index: activerecord/test/active_record/associations/cascaded_eager_loading_test.rb =================================================================== --- activerecord/test/active_record/associations/cascaded_eager_loading_test.rb (revision 8601) +++ activerecord/test/active_record/associations/cascaded_eager_loading_test.rb (working copy) @@ -1,13 +1,14 @@ -require 'abstract_unit' -require 'fixtures/post' -require 'fixtures/comment' -require 'fixtures/author' -require 'fixtures/category' -require 'fixtures/categorization' -require 'fixtures/company' -require 'fixtures/topic' -require 'fixtures/reply' +require File.expand_path(File.dirname(__FILE__) + "/../../test_helper") +require 'models/post' +require 'models/comment' +require 'models/author' +require 'models/category' +require 'models/categorization' +require 'models/company' +require 'models/topic' +require 'models/reply' + class CascadedEagerLoadingTest < ActiveSupport::TestCase fixtures :authors, :mixins, :companies, :posts, :topics @@ -93,8 +94,9 @@ end end -require 'fixtures/vertex' -require 'fixtures/edge' +require 'models/vertex' +require 'models/edge' + class CascadedEagerLoadingTest < ActiveSupport::TestCase fixtures :edges, :vertices Index: activerecord/test/active_record/associations/extension_test.rb =================================================================== --- activerecord/test/active_record/associations/extension_test.rb (revision 8601) +++ activerecord/test/active_record/associations/extension_test.rb (working copy) @@ -1,9 +1,10 @@ -require 'abstract_unit' -require 'fixtures/post' -require 'fixtures/comment' -require 'fixtures/project' -require 'fixtures/developer' +require File.expand_path(File.dirname(__FILE__) + "/../../test_helper") +require 'models/post' +require 'models/comment' +require 'models/project' +require 'models/developer' + class AssociationsExtensionsTest < ActiveSupport::TestCase fixtures :projects, :developers, :developers_projects, :comments, :posts Index: activerecord/test/active_record/datatype_test_postgresql.rb =================================================================== --- activerecord/test/active_record/datatype_test_postgresql.rb (revision 0) +++ activerecord/test/active_record/datatype_test_postgresql.rb (working copy) @@ -1,4 +1,4 @@ -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") class PostgresqlArray < ActiveRecord::Base end Index: activerecord/test/active_record/lifecycle_test.rb =================================================================== --- activerecord/test/active_record/lifecycle_test.rb (revision 0) +++ activerecord/test/active_record/lifecycle_test.rb (working copy) @@ -1,8 +1,9 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/developer' -require 'fixtures/reply' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/topic' +require 'models/developer' +require 'models/reply' + class Topic; def after_find() end end class Developer; def after_find() end end class SpecialDeveloper < Developer; end Index: activerecord/test/active_record/migration_test_firebird.rb =================================================================== --- activerecord/test/active_record/migration_test_firebird.rb (revision 0) +++ activerecord/test/active_record/migration_test_firebird.rb (working copy) @@ -1,6 +1,7 @@ -require 'abstract_unit' -require 'fixtures/course' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/course' + class FirebirdMigrationTest < ActiveSupport::TestCase self.use_transactional_fixtures = false Index: activerecord/test/active_record/multiple_db_test.rb =================================================================== --- activerecord/test/active_record/multiple_db_test.rb (revision 0) +++ activerecord/test/active_record/multiple_db_test.rb (working copy) @@ -1,8 +1,9 @@ -require 'abstract_unit' -require 'fixtures/entrant' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/entrant' + # So we can test whether Course.connection survives a reload. -require_dependency 'fixtures/course' +require_dependency 'models/course' class MultipleDbTest < ActiveSupport::TestCase self.use_transactional_fixtures = false @@ -53,7 +54,7 @@ Dependencies.clear Object.send(:remove_const, :Course) - require_dependency 'fixtures/course' + require_dependency 'models/course' assert Course.connection end Index: activerecord/test/active_record/method_scoping_test.rb =================================================================== --- activerecord/test/active_record/method_scoping_test.rb (revision 0) +++ activerecord/test/active_record/method_scoping_test.rb (working copy) @@ -1,10 +1,11 @@ -require 'abstract_unit' -require 'fixtures/developer' -require 'fixtures/project' -require 'fixtures/comment' -require 'fixtures/post' -require 'fixtures/category' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/developer' +require 'models/project' +require 'models/comment' +require 'models/post' +require 'models/category' + class MethodScopingTest < ActiveSupport::TestCase fixtures :developers, :projects, :comments, :posts Index: activerecord/test/active_record/copy_table_test_sqlite.rb =================================================================== --- activerecord/test/active_record/copy_table_test_sqlite.rb (revision 0) +++ activerecord/test/active_record/copy_table_test_sqlite.rb (working copy) @@ -1,4 +1,4 @@ -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") class CopyTableTest < ActiveSupport::TestCase fixtures :companies, :comments Index: activerecord/test/active_record/schema_authorization_test_postgresql.rb =================================================================== --- activerecord/test/active_record/schema_authorization_test_postgresql.rb (revision 0) +++ activerecord/test/active_record/schema_authorization_test_postgresql.rb (working copy) @@ -1,4 +1,4 @@ -require 'abstract_unit' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") class SchemaThing < ActiveRecord::Base end Index: activerecord/test/active_record/connection_test_firebird.rb =================================================================== --- activerecord/test/active_record/connection_test_firebird.rb (revision 0) +++ activerecord/test/active_record/connection_test_firebird.rb (working copy) @@ -1,4 +1,4 @@ -require "#{File.dirname(__FILE__)}/abstract_unit" +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") class FirebirdConnectionTest < ActiveSupport::TestCase def test_charset_properly_set Index: activerecord/test/active_record/finder_test.rb =================================================================== --- activerecord/test/active_record/finder_test.rb (revision 0) +++ activerecord/test/active_record/finder_test.rb (working copy) @@ -1,13 +1,14 @@ -require 'abstract_unit' -require 'fixtures/author' -require 'fixtures/comment' -require 'fixtures/company' -require 'fixtures/topic' -require 'fixtures/reply' -require 'fixtures/entrant' -require 'fixtures/developer' -require 'fixtures/post' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/author' +require 'models/comment' +require 'models/company' +require 'models/topic' +require 'models/reply' +require 'models/entrant' +require 'models/developer' +require 'models/post' + class FinderTest < ActiveSupport::TestCase fixtures :companies, :topics, :entrants, :developers, :developers_projects, :posts, :comments, :accounts, :authors Index: activerecord/test/active_record/modules_test.rb =================================================================== --- activerecord/test/active_record/modules_test.rb (revision 0) +++ activerecord/test/active_record/modules_test.rb (working copy) @@ -1,6 +1,7 @@ -require 'abstract_unit' -require 'fixtures/company_in_module' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/company_in_module' + class ModulesTest < ActiveSupport::TestCase fixtures :accounts, :companies, :projects, :developers Index: activerecord/test/active_record/transactions_test.rb =================================================================== --- activerecord/test/active_record/transactions_test.rb (revision 0) +++ activerecord/test/active_record/transactions_test.rb (working copy) @@ -1,8 +1,9 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/reply' -require 'fixtures/developer' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/topic' +require 'models/reply' +require 'models/developer' + class TransactionTest < ActiveSupport::TestCase self.use_transactional_fixtures = false fixtures :topics, :developers Index: activerecord/test/active_record/aggregations_test.rb =================================================================== --- activerecord/test/active_record/aggregations_test.rb (revision 0) +++ activerecord/test/active_record/aggregations_test.rb (working copy) @@ -1,6 +1,7 @@ -require 'abstract_unit' -require 'fixtures/customer' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/customer' + class AggregationsTest < ActiveSupport::TestCase fixtures :customers Index: activerecord/test/active_record/pk_test.rb =================================================================== --- activerecord/test/active_record/pk_test.rb (revision 0) +++ activerecord/test/active_record/pk_test.rb (working copy) @@ -1,11 +1,12 @@ -require "#{File.dirname(__FILE__)}/abstract_unit" -require 'fixtures/topic' -require 'fixtures/reply' -require 'fixtures/subscriber' -require 'fixtures/movie' -require 'fixtures/keyboard' -require 'fixtures/mixed_case_monkey' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/topic' +require 'models/reply' +require 'models/subscriber' +require 'models/movie' +require 'models/keyboard' +require 'models/mixed_case_monkey' + class PrimaryKeysTest < ActiveSupport::TestCase fixtures :topics, :subscribers, :movies, :mixed_case_monkeys Index: activerecord/test/active_record/readonly_test.rb =================================================================== --- activerecord/test/active_record/readonly_test.rb (revision 0) +++ activerecord/test/active_record/readonly_test.rb (working copy) @@ -1,11 +1,12 @@ -require 'abstract_unit' -require 'fixtures/post' -require 'fixtures/comment' -require 'fixtures/developer' -require 'fixtures/project' -require 'fixtures/reader' -require 'fixtures/person' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/post' +require 'models/comment' +require 'models/developer' +require 'models/project' +require 'models/reader' +require 'models/person' + # Dummy class methods to test implicit association scoping. def Comment.foo() find :first end def Project.foo() find :first end Index: activerecord/test/active_record/serialization_test.rb =================================================================== --- activerecord/test/active_record/serialization_test.rb (revision 0) +++ activerecord/test/active_record/serialization_test.rb (working copy) @@ -1,6 +1,7 @@ -require 'abstract_unit' -require 'fixtures/contact' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/contact' + class SerializationTest < ActiveSupport::TestCase FORMATS = [ :xml, :json ] Index: activerecord/test/active_record/validations_test.rb =================================================================== --- activerecord/test/active_record/validations_test.rb (revision 0) +++ activerecord/test/active_record/validations_test.rb (working copy) @@ -1,10 +1,11 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/reply' -require 'fixtures/person' -require 'fixtures/developer' -require 'fixtures/warehouse_thing' +require File.expand_path(File.dirname(__FILE__) + "/../test_helper") +require 'models/topic' +require 'models/reply' +require 'models/person' +require 'models/developer' +require 'models/warehouse_thing' + # The following methods in Topic are used in test_conditional_validation_* class Topic def condition_is_true Index: activerecord/test/fixtures_test.rb =================================================================== --- activerecord/test/fixtures_test.rb (revision 8601) +++ activerecord/test/fixtures_test.rb (working copy) @@ -1,594 +0,0 @@ -require 'abstract_unit' -require 'fixtures/post' -require 'fixtures/binary' -require 'fixtures/topic' -require 'fixtures/computer' -require 'fixtures/developer' -require 'fixtures/company' -require 'fixtures/task' -require 'fixtures/reply' -require 'fixtures/joke' -require 'fixtures/course' -require 'fixtures/category' -require 'fixtures/parrot' -require 'fixtures/pirate' -require 'fixtures/treasure' -require 'fixtures/matey' -require 'fixtures/ship' - -class FixturesTest < ActiveSupport::TestCase - self.use_instantiated_fixtures = true - self.use_transactional_fixtures = false - - fixtures :topics, :developers, :accounts, :tasks, :categories, :funny_jokes, :binaries - - FIXTURES = %w( accounts binaries companies customers - developers developers_projects entrants - movies projects subscribers topics tasks ) - MATCH_ATTRIBUTE_NAME = /[a-zA-Z][-_\w]*/ - - BINARY_FIXTURE_PATH = File.dirname(__FILE__) + '/fixtures/flowers.jpg' - - def test_clean_fixtures - FIXTURES.each do |name| - fixtures = nil - assert_nothing_raised { fixtures = create_fixtures(name) } - assert_kind_of(Fixtures, fixtures) - fixtures.each { |name, fixture| - fixture.each { |key, value| - assert_match(MATCH_ATTRIBUTE_NAME, key) - } - } - end - end - - def test_multiple_clean_fixtures - fixtures_array = nil - assert_nothing_raised { fixtures_array = create_fixtures(*FIXTURES) } - assert_kind_of(Array, fixtures_array) - fixtures_array.each { |fixtures| assert_kind_of(Fixtures, fixtures) } - end - - def test_attributes - topics = create_fixtures("topics") - assert_equal("The First Topic", topics["first"]["title"]) - assert_nil(topics["second"]["author_email_address"]) - end - - def test_inserts - topics = create_fixtures("topics") - first_row = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'David'") - assert_equal("The First Topic", first_row["title"]) - - second_row = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'Mary'") - assert_nil(second_row["author_email_address"]) - end - - if ActiveRecord::Base.connection.supports_migrations? - def test_inserts_with_pre_and_suffix - # Reset cache to make finds on the new table work - Fixtures.reset_cache - - ActiveRecord::Base.connection.create_table :prefix_topics_suffix do |t| - t.column :title, :string - t.column :author_name, :string - t.column :author_email_address, :string - t.column :written_on, :datetime - t.column :bonus_time, :time - t.column :last_read, :date - t.column :content, :string - t.column :approved, :boolean, :default => true - t.column :replies_count, :integer, :default => 0 - t.column :parent_id, :integer - t.column :type, :string, :limit => 50 - end - - # Store existing prefix/suffix - old_prefix = ActiveRecord::Base.table_name_prefix - old_suffix = ActiveRecord::Base.table_name_suffix - - # Set a prefix/suffix we can test against - ActiveRecord::Base.table_name_prefix = 'prefix_' - ActiveRecord::Base.table_name_suffix = '_suffix' - - topics = create_fixtures("topics") - - first_row = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'David'") - assert_equal("The First Topic", first_row["title"]) - - second_row = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'Mary'") - assert_nil(second_row["author_email_address"]) - ensure - # Restore prefix/suffix to its previous values - ActiveRecord::Base.table_name_prefix = old_prefix - ActiveRecord::Base.table_name_suffix = old_suffix - - ActiveRecord::Base.connection.drop_table :prefix_topics_suffix rescue nil - end - end - - def test_insert_with_datetime - topics = create_fixtures("tasks") - first = Task.find(1) - assert first - end - - def test_logger_level_invariant - level = ActiveRecord::Base.logger.level - create_fixtures('topics') - assert_equal level, ActiveRecord::Base.logger.level - end - - def test_instantiation - topics = create_fixtures("topics") - assert_kind_of Topic, topics["first"].find - end - - def test_complete_instantiation - assert_equal 2, @topics.size - assert_equal "The First Topic", @first.title - end - - def test_fixtures_from_root_yml_with_instantiation - # assert_equal 2, @accounts.size - assert_equal 50, @unknown.credit_limit - end - - def test_erb_in_fixtures - assert_equal 11, @developers.size - assert_equal "fixture_5", @dev_5.name - end - - def test_empty_yaml_fixture - assert_not_nil Fixtures.new( Account.connection, "accounts", 'Account', File.dirname(__FILE__) + "/fixtures/naked/yml/accounts") - end - - def test_empty_yaml_fixture_with_a_comment_in_it - assert_not_nil Fixtures.new( Account.connection, "companies", 'Company', File.dirname(__FILE__) + "/fixtures/naked/yml/companies") - end - - def test_dirty_dirty_yaml_file - assert_raises(Fixture::FormatError) do - Fixtures.new( Account.connection, "courses", 'Course', File.dirname(__FILE__) + "/fixtures/naked/yml/courses") - end - end - - def test_empty_csv_fixtures - assert_not_nil Fixtures.new( Account.connection, "accounts", 'Account', File.dirname(__FILE__) + "/fixtures/naked/csv/accounts") - end - - def test_omap_fixtures - assert_nothing_raised do - fixtures = Fixtures.new(Account.connection, 'categories', 'Category', File.dirname(__FILE__) + '/fixtures/categories_ordered') - - i = 0 - fixtures.each do |name, fixture| - assert_equal "fixture_no_#{i}", name - assert_equal "Category #{i}", fixture['name'] - i += 1 - end - end - end - - def test_yml_file_in_subdirectory - assert_equal(categories(:sub_special_1).name, "A special category in a subdir file") - assert_equal(categories(:sub_special_1).class, SpecialCategory) - end - - def test_subsubdir_file_with_arbitrary_name - assert_equal(categories(:sub_special_3).name, "A special category in an arbitrarily named subsubdir file") - assert_equal(categories(:sub_special_3).class, SpecialCategory) - end - - def test_binary_in_fixtures - assert_equal 1, @binaries.size - data = File.open(BINARY_FIXTURE_PATH, "rb").read.freeze - assert_equal data, @flowers.data - end -end - -if Account.connection.respond_to?(:reset_pk_sequence!) - class FixturesResetPkSequenceTest < ActiveSupport::TestCase - fixtures :accounts - fixtures :companies - - def setup - @instances = [Account.new(:credit_limit => 50), Company.new(:name => 'RoR Consulting')] - Fixtures.reset_cache # make sure tables get reinitialized - end - - def test_resets_to_min_pk_with_specified_pk_and_sequence - @instances.each do |instance| - model = instance.class - model.delete_all - model.connection.reset_pk_sequence!(model.table_name, model.primary_key, model.sequence_name) - - instance.save! - assert_equal 1, instance.id, "Sequence reset for #{model.table_name} failed." - end - end - - def test_resets_to_min_pk_with_default_pk_and_sequence - @instances.each do |instance| - model = instance.class - model.delete_all - model.connection.reset_pk_sequence!(model.table_name) - - instance.save! - assert_equal 1, instance.id, "Sequence reset for #{model.table_name} failed." - end - end - - def test_create_fixtures_resets_sequences_when_not_cached - @instances.each do |instance| - max_id = create_fixtures(instance.class.table_name).inject(0) do |max_id, (name, fixture)| - fixture_id = fixture['id'].to_i - fixture_id > max_id ? fixture_id : max_id - end - - # Clone the last fixture to check that it gets the next greatest id. - instance.save! - assert_equal max_id + 1, instance.id, "Sequence reset for #{instance.class.table_name} failed." - end - end - end -end - -class FixturesWithoutInstantiationTest < ActiveSupport::TestCase - self.use_instantiated_fixtures = false - fixtures :topics, :developers, :accounts - - def test_without_complete_instantiation - assert_nil @first - assert_nil @topics - assert_nil @developers - assert_nil @accounts - end - - def test_fixtures_from_root_yml_without_instantiation - assert_nil @unknown - end - - def test_accessor_methods - assert_equal "The First Topic", topics(:first).title - assert_equal "Jamis", developers(:jamis).name - assert_equal 50, accounts(:signals37).credit_limit - end - - def test_accessor_methods_with_multiple_args - assert_equal 2, topics(:first, :second).size - assert_raise(StandardError) { topics([:first, :second]) } - end - - uses_mocha 'reloading_fixtures_through_accessor_methods' do - def test_reloading_fixtures_through_accessor_methods - assert_equal "The First Topic", topics(:first).title - @loaded_fixtures['topics']['first'].expects(:find).returns(stub(:title => "Fresh Topic!")) - assert_equal "Fresh Topic!", topics(:first, true).title - end - end -end - -class FixturesWithoutInstanceInstantiationTest < ActiveSupport::TestCase - self.use_instantiated_fixtures = true - self.use_instantiated_fixtures = :no_instances - - fixtures :topics, :developers, :accounts - - def test_without_instance_instantiation - assert_nil @first - assert_not_nil @topics - assert_not_nil @developers - assert_not_nil @accounts - end -end - -class TransactionalFixturesTest < ActiveSupport::TestCase - self.use_instantiated_fixtures = true - self.use_transactional_fixtures = true - - fixtures :topics - - def test_destroy - assert_not_nil @first - @first.destroy - end - - def test_destroy_just_kidding - assert_not_nil @first - end -end - -class MultipleFixturesTest < ActiveSupport::TestCase - fixtures :topics - fixtures :developers, :accounts - - def test_fixture_table_names - assert_equal %w(topics developers accounts), fixture_table_names - end -end - -class SetupTest < ActiveSupport::TestCase - # fixtures :topics - - def setup - @first = true - end - - def test_nothing - end -end - -class SetupSubclassTest < SetupTest - def setup - super - @second = true - end - - def test_subclassing_should_preserve_setups - assert @first - assert @second - end -end - - -class OverlappingFixturesTest < ActiveSupport::TestCase - fixtures :topics, :developers - fixtures :developers, :accounts - - def test_fixture_table_names - assert_equal %w(topics developers accounts), fixture_table_names - end -end - -class ForeignKeyFixturesTest < ActiveSupport::TestCase - fixtures :fk_test_has_pk, :fk_test_has_fk - - # if foreign keys are implemented and fixtures - # are not deleted in reverse order then this test - # case will raise StatementInvalid - - def test_number1 - assert true - end - - def test_number2 - assert true - end -end - -class SetTableNameFixturesTest < ActiveSupport::TestCase - set_fixture_class :funny_jokes => 'Joke' - fixtures :funny_jokes - - def test_table_method - assert_kind_of Joke, funny_jokes(:a_joke) - end -end - -class CustomConnectionFixturesTest < ActiveSupport::TestCase - set_fixture_class :courses => Course - fixtures :courses - - def test_connection - assert_kind_of Course, courses(:ruby) - assert_equal Course.connection, courses(:ruby).connection - end -end - -class InvalidTableNameFixturesTest < ActiveSupport::TestCase - fixtures :funny_jokes - - def test_raises_error - assert_raises FixtureClassNotFound do - funny_jokes(:a_joke) - end - end -end - -class CheckEscapedYamlFixturesTest < ActiveSupport::TestCase - set_fixture_class :funny_jokes => 'Joke' - fixtures :funny_jokes - - def test_proper_escaped_fixture - assert_equal "The \\n Aristocrats\nAte the candy\n", funny_jokes(:another_joke).name - end -end - -class DevelopersProject; end -class ManyToManyFixturesWithClassDefined < ActiveSupport::TestCase - fixtures :developers_projects - - def test_this_should_run_cleanly - assert true - end -end - -class FixturesBrokenRollbackTest < ActiveSupport::TestCase - def blank_setup; end - alias_method :ar_setup_fixtures, :setup_fixtures - alias_method :setup_fixtures, :blank_setup - alias_method :setup, :blank_setup - - def blank_teardown; end - alias_method :ar_teardown_fixtures, :teardown_fixtures - alias_method :teardown_fixtures, :blank_teardown - alias_method :teardown, :blank_teardown - - def test_no_rollback_in_teardown_unless_transaction_active - assert_equal 0, Thread.current['open_transactions'] - assert_raise(RuntimeError) { ar_setup_fixtures } - assert_equal 0, Thread.current['open_transactions'] - assert_nothing_raised { ar_teardown_fixtures } - assert_equal 0, Thread.current['open_transactions'] - end - - private - def load_fixtures - raise 'argh' - end -end - -class LoadAllFixturesTest < ActiveSupport::TestCase - self.fixture_path= File.join(File.dirname(__FILE__), '/fixtures/all') - fixtures :all - - def test_all_there - assert_equal %w(developers people tasks), fixture_table_names.sort - end -end - -class FasterFixturesTest < ActiveSupport::TestCase - fixtures :categories, :authors - - def load_extra_fixture(name) - fixture = create_fixtures(name) - assert fixture.is_a?(Fixtures) - @loaded_fixtures[fixture.table_name] = fixture - end - - def test_cache - assert Fixtures.fixture_is_cached?(ActiveRecord::Base.connection, 'categories') - assert Fixtures.fixture_is_cached?(ActiveRecord::Base.connection, 'authors') - - assert_no_queries do - create_fixtures('categories') - create_fixtures('authors') - end - - load_extra_fixture('posts') - assert Fixtures.fixture_is_cached?(ActiveRecord::Base.connection, 'posts') - self.class.setup_fixture_accessors('posts') - assert_equal 'Welcome to the weblog', posts(:welcome).title - end -end - -class FoxyFixturesTest < ActiveSupport::TestCase - fixtures :parrots, :parrots_pirates, :pirates, :treasures, :mateys, :ships, :computers, :developers - - def test_identifies_strings - assert_equal(Fixtures.identify("foo"), Fixtures.identify("foo")) - assert_not_equal(Fixtures.identify("foo"), Fixtures.identify("FOO")) - end - - def test_identifies_symbols - assert_equal(Fixtures.identify(:foo), Fixtures.identify(:foo)) - end - - TIMESTAMP_COLUMNS = %w(created_at created_on updated_at updated_on) - - def test_populates_timestamp_columns - TIMESTAMP_COLUMNS.each do |property| - assert_not_nil(parrots(:george).send(property), "should set #{property}") - end - end - - def test_does_not_populate_timestamp_columns_if_model_has_set_record_timestamps_to_false - TIMESTAMP_COLUMNS.each do |property| - assert_nil(ships(:black_pearl).send(property), "should not set #{property}") - end - end - - def test_populates_all_columns_with_the_same_time - last = nil - - TIMESTAMP_COLUMNS.each do |property| - current = parrots(:george).send(property) - last ||= current - - assert_equal(last, current) - last = current - end - end - - def test_only_populates_columns_that_exist - assert_not_nil(pirates(:blackbeard).created_on) - assert_not_nil(pirates(:blackbeard).updated_on) - end - - def test_preserves_existing_fixture_data - assert_equal(2.weeks.ago.to_date, pirates(:redbeard).created_on.to_date) - assert_equal(2.weeks.ago.to_date, pirates(:redbeard).updated_on.to_date) - end - - def test_generates_unique_ids - assert_not_nil(parrots(:george).id) - assert_not_equal(parrots(:george).id, parrots(:louis).id) - end - - def test_automatically_sets_primary_key - assert_not_nil(ships(:black_pearl)) - end - - def test_preserves_existing_primary_key - assert_equal(2, ships(:interceptor).id) - end - - def test_resolves_belongs_to_symbols - assert_equal(parrots(:george), pirates(:blackbeard).parrot) - end - - def test_ignores_belongs_to_symbols_if_association_and_foreign_key_are_named_the_same - assert_equal(developers(:david), computers(:workstation).developer) - end - - def test_supports_join_tables - assert(pirates(:blackbeard).parrots.include?(parrots(:george))) - assert(pirates(:blackbeard).parrots.include?(parrots(:louis))) - assert(parrots(:george).pirates.include?(pirates(:blackbeard))) - end - - def test_supports_inline_habtm - assert(parrots(:george).treasures.include?(treasures(:diamond))) - assert(parrots(:george).treasures.include?(treasures(:sapphire))) - assert(!parrots(:george).treasures.include?(treasures(:ruby))) - end - - def test_supports_inline_habtm_with_specified_id - assert(parrots(:polly).treasures.include?(treasures(:ruby))) - assert(parrots(:polly).treasures.include?(treasures(:sapphire))) - assert(!parrots(:polly).treasures.include?(treasures(:diamond))) - end - - def test_supports_yaml_arrays - assert(parrots(:louis).treasures.include?(treasures(:diamond))) - assert(parrots(:louis).treasures.include?(treasures(:sapphire))) - end - - def test_strips_DEFAULTS_key - assert_raise(StandardError) { parrots(:DEFAULTS) } - - # this lets us do YAML defaults and not have an extra fixture entry - %w(sapphire ruby).each { |t| assert(parrots(:davey).treasures.include?(treasures(t))) } - end - - def test_supports_label_interpolation - assert_equal("frederick", parrots(:frederick).name) - end - - def test_supports_polymorphic_belongs_to - assert_equal(pirates(:redbeard), treasures(:sapphire).looter) - assert_equal(parrots(:louis), treasures(:ruby).looter) - end - - def test_only_generates_a_pk_if_necessary - m = Matey.find(:first) - m.pirate = pirates(:blackbeard) - m.target = pirates(:redbeard) - end - - def test_supports_sti - assert_kind_of DeadParrot, parrots(:polly) - assert_equal pirates(:blackbeard), parrots(:polly).killer - end -end - -class ActiveSupportSubclassWithFixturesTest < ActiveSupport::TestCase - fixtures :parrots - - # This seemingly useless assertion catches a bug that caused the fixtures - # setup code call nil[] - def test_foo - assert_equal parrots(:louis), Parrot.find_by_name("King Louis") - end -end Index: activerecord/test/base_test.rb =================================================================== --- activerecord/test/base_test.rb (revision 8601) +++ activerecord/test/base_test.rb (working copy) @@ -1,1831 +0,0 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/reply' -require 'fixtures/company' -require 'fixtures/customer' -require 'fixtures/developer' -require 'fixtures/project' -require 'fixtures/default' -require 'fixtures/auto_id' -require 'fixtures/column_name' -require 'fixtures/subscriber' -require 'fixtures/keyboard' -require 'fixtures/post' -require 'fixtures/minimalistic' -require 'fixtures/warehouse_thing' -require 'rexml/document' - -class Category < ActiveRecord::Base; end -class Smarts < ActiveRecord::Base; end -class CreditCard < ActiveRecord::Base - class PinNumber < ActiveRecord::Base - class CvvCode < ActiveRecord::Base; end - class SubCvvCode < CvvCode; end - end - class SubPinNumber < PinNumber; end - class Brand < Category; end -end -class MasterCreditCard < ActiveRecord::Base; end -class Post < ActiveRecord::Base; end -class Computer < ActiveRecord::Base; end -class NonExistentTable < ActiveRecord::Base; end -class TestOracleDefault < ActiveRecord::Base; end - -class LoosePerson < ActiveRecord::Base - self.table_name = 'people' - self.abstract_class = true - attr_protected :credit_rating, :administrator -end - -class LooseDescendant < LoosePerson - attr_protected :phone_number -end - -class LooseDescendantSecond< LoosePerson - attr_protected :phone_number - attr_protected :name -end - -class TightPerson < ActiveRecord::Base - self.table_name = 'people' - attr_accessible :name, :address -end - -class TightDescendant < TightPerson - attr_accessible :phone_number -end - -class ReadonlyTitlePost < Post - attr_readonly :title -end - -class Booleantest < ActiveRecord::Base; end - -class Task < ActiveRecord::Base - attr_protected :starting -end - -class TopicWithProtectedContentAndAccessibleAuthorName < ActiveRecord::Base - self.table_name = 'topics' - attr_accessible :author_name - attr_protected :content -end - -class BasicsTest < ActiveSupport::TestCase - fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, 'warehouse-things' - - def test_table_exists - assert !NonExistentTable.table_exists? - assert Topic.table_exists? - end - - def test_set_attributes - topic = Topic.find(1) - topic.attributes = { "title" => "Budget", "author_name" => "Jason" } - topic.save - assert_equal("Budget", topic.title) - assert_equal("Jason", topic.author_name) - assert_equal(topics(:first).author_email_address, Topic.find(1).author_email_address) - end - - def test_integers_as_nil - test = AutoId.create('value' => '') - assert_nil AutoId.find(test.id).value - end - - def test_set_attributes_with_block - topic = Topic.new do |t| - t.title = "Budget" - t.author_name = "Jason" - end - - assert_equal("Budget", topic.title) - assert_equal("Jason", topic.author_name) - end - - def test_respond_to? - topic = Topic.find(1) - assert topic.respond_to?("title") - assert topic.respond_to?("title?") - assert topic.respond_to?("title=") - assert topic.respond_to?(:title) - assert topic.respond_to?(:title?) - assert topic.respond_to?(:title=) - assert topic.respond_to?("author_name") - assert topic.respond_to?("attribute_names") - assert !topic.respond_to?("nothingness") - assert !topic.respond_to?(:nothingness) - end - - def test_array_content - topic = Topic.new - topic.content = %w( one two three ) - topic.save - - assert_equal(%w( one two three ), Topic.find(topic.id).content) - end - - def test_hash_content - topic = Topic.new - topic.content = { "one" => 1, "two" => 2 } - topic.save - - assert_equal 2, Topic.find(topic.id).content["two"] - - topic.content["three"] = 3 - topic.save - - assert_equal 3, Topic.find(topic.id).content["three"] - end - - def test_update_array_content - topic = Topic.new - topic.content = %w( one two three ) - - topic.content.push "four" - assert_equal(%w( one two three four ), topic.content) - - topic.save - - topic = Topic.find(topic.id) - topic.content << "five" - assert_equal(%w( one two three four five ), topic.content) - end - - def test_case_sensitive_attributes_hash - # DB2 is not case-sensitive - return true if current_adapter?(:DB2Adapter) - - assert_equal @loaded_fixtures['computers']['workstation'].to_hash, Computer.find(:first).attributes - end - - def test_create - topic = Topic.new - topic.title = "New Topic" - topic.save - topic_reloaded = Topic.find(topic.id) - assert_equal("New Topic", topic_reloaded.title) - end - - def test_save! - topic = Topic.new(:title => "New Topic") - assert topic.save! - - reply = Reply.new - assert_raise(ActiveRecord::RecordInvalid) { reply.save! } - end - - def test_save_null_string_attributes - topic = Topic.find(1) - topic.attributes = { "title" => "null", "author_name" => "null" } - topic.save! - topic.reload - assert_equal("null", topic.title) - assert_equal("null", topic.author_name) - end - - def test_save_nil_string_attributes - topic = Topic.find(1) - topic.title = nil - topic.save! - topic.reload - assert_nil topic.title - end - - def test_save_for_record_with_only_primary_key - minimalistic = Minimalistic.new - assert_nothing_raised { minimalistic.save } - end - - def test_save_for_record_with_only_primary_key_that_is_provided - assert_nothing_raised { Minimalistic.create!(:id => 2) } - end - - def test_hashes_not_mangled - new_topic = { :title => "New Topic" } - new_topic_values = { :title => "AnotherTopic" } - - topic = Topic.new(new_topic) - assert_equal new_topic[:title], topic.title - - topic.attributes= new_topic_values - assert_equal new_topic_values[:title], topic.title - end - - def test_create_many - topics = Topic.create([ { "title" => "first" }, { "title" => "second" }]) - assert_equal 2, topics.size - assert_equal "first", topics.first.title - end - - def test_create_columns_not_equal_attributes - topic = Topic.new - topic.title = 'Another New Topic' - topic.send :write_attribute, 'does_not_exist', 'test' - assert_nothing_raised { topic.save } - end - - def test_create_through_factory - topic = Topic.create("title" => "New Topic") - topicReloaded = Topic.find(topic.id) - assert_equal(topic, topicReloaded) - end - - def test_update - topic = Topic.new - topic.title = "Another New Topic" - topic.written_on = "2003-12-12 23:23:00" - topic.save - topicReloaded = Topic.find(topic.id) - assert_equal("Another New Topic", topicReloaded.title) - - topicReloaded.title = "Updated topic" - topicReloaded.save - - topicReloadedAgain = Topic.find(topic.id) - - assert_equal("Updated topic", topicReloadedAgain.title) - end - - def test_update_columns_not_equal_attributes - topic = Topic.new - topic.title = "Still another topic" - topic.save - - topicReloaded = Topic.find(topic.id) - topicReloaded.title = "A New Topic" - topicReloaded.send :write_attribute, 'does_not_exist', 'test' - assert_nothing_raised { topicReloaded.save } - end - - def test_update_for_record_with_only_primary_key - minimalistic = minimalistics(:first) - assert_nothing_raised { minimalistic.save } - end - - def test_write_attribute - topic = Topic.new - topic.send(:write_attribute, :title, "Still another topic") - assert_equal "Still another topic", topic.title - - topic.send(:write_attribute, "title", "Still another topic: part 2") - assert_equal "Still another topic: part 2", topic.title - end - - def test_read_attribute - topic = Topic.new - topic.title = "Don't change the topic" - assert_equal "Don't change the topic", topic.send(:read_attribute, "title") - assert_equal "Don't change the topic", topic["title"] - - assert_equal "Don't change the topic", topic.send(:read_attribute, :title) - assert_equal "Don't change the topic", topic[:title] - end - - def test_read_attribute_when_false - topic = topics(:first) - topic.approved = false - assert !topic.approved?, "approved should be false" - topic.approved = "false" - assert !topic.approved?, "approved should be false" - end - - def test_read_attribute_when_true - topic = topics(:first) - topic.approved = true - assert topic.approved?, "approved should be true" - topic.approved = "true" - assert topic.approved?, "approved should be true" - end - - def test_read_write_boolean_attribute - topic = Topic.new - # puts "" - # puts "New Topic" - # puts topic.inspect - topic.approved = "false" - # puts "Expecting false" - # puts topic.inspect - assert !topic.approved?, "approved should be false" - topic.approved = "false" - # puts "Expecting false" - # puts topic.inspect - assert !topic.approved?, "approved should be false" - topic.approved = "true" - # puts "Expecting true" - # puts topic.inspect - assert topic.approved?, "approved should be true" - topic.approved = "true" - # puts "Expecting true" - # puts topic.inspect - assert topic.approved?, "approved should be true" - # puts "" - end - - def test_query_attribute_string - [nil, "", " "].each do |value| - assert_equal false, Topic.new(:author_name => value).author_name? - end - - assert_equal true, Topic.new(:author_name => "Name").author_name? - end - - def test_query_attribute_number - [nil, 0, "0"].each do |value| - assert_equal false, Developer.new(:salary => value).salary? - end - - assert_equal true, Developer.new(:salary => 1).salary? - assert_equal true, Developer.new(:salary => "1").salary? - end - - def test_query_attribute_boolean - [nil, "", false, "false", "f", 0].each do |value| - assert_equal false, Topic.new(:approved => value).approved? - end - - [true, "true", "1", 1].each do |value| - assert_equal true, Topic.new(:approved => value).approved? - end - end - - def test_query_attribute_with_custom_fields - object = Company.find_by_sql(<<-SQL).first - SELECT c1.*, c2.ruby_type as string_value, c2.rating as int_value - FROM companies c1, companies c2 - WHERE c1.firm_id = c2.id - AND c1.id = 2 - SQL - - assert_equal "Firm", object.string_value - assert object.string_value? - - object.string_value = " " - assert !object.string_value? - - assert_equal 1, object.int_value.to_i - assert object.int_value? - - object.int_value = "0" - assert !object.int_value? - end - - - def test_reader_for_invalid_column_names - Topic.send(:define_read_method, "mumub-jumbo".to_sym, "mumub-jumbo", nil) - assert !Topic.generated_methods.include?("mumub-jumbo") - end - - def test_non_attribute_access_and_assignment - topic = Topic.new - assert !topic.respond_to?("mumbo") - assert_raises(NoMethodError) { topic.mumbo } - assert_raises(NoMethodError) { topic.mumbo = 5 } - end - - def test_preserving_date_objects - # SQL Server doesn't have a separate column type just for dates, so all are returned as time - return true if current_adapter?(:SQLServerAdapter) - - if current_adapter?(:SybaseAdapter, :OracleAdapter) - # Sybase ctlib does not (yet?) support the date type; use datetime instead. - # Oracle treats all dates/times as Time. - assert_kind_of( - Time, Topic.find(1).last_read, - "The last_read attribute should be of the Time class" - ) - else - assert_kind_of( - Date, Topic.find(1).last_read, - "The last_read attribute should be of the Date class" - ) - end - end - - def test_preserving_time_objects - assert_kind_of( - Time, Topic.find(1).bonus_time, - "The bonus_time attribute should be of the Time class" - ) - - assert_kind_of( - Time, Topic.find(1).written_on, - "The written_on attribute should be of the Time class" - ) - - # For adapters which support microsecond resolution. - if current_adapter?(:PostgreSQLAdapter) - assert_equal 11, Topic.find(1).written_on.sec - assert_equal 223300, Topic.find(1).written_on.usec - assert_equal 9900, Topic.find(2).written_on.usec - end - end - - def test_custom_mutator - topic = Topic.find(1) - # This mutator is protected in the class definition - topic.send(:approved=, true) - assert topic.instance_variable_get("@custom_approved") - end - - def test_destroy - topic = Topic.find(1) - assert_equal topic, topic.destroy, 'topic.destroy did not return self' - assert topic.frozen?, 'topic not frozen after destroy' - assert_raise(ActiveRecord::RecordNotFound) { Topic.find(topic.id) } - end - - def test_record_not_found_exception - assert_raises(ActiveRecord::RecordNotFound) { topicReloaded = Topic.find(99999) } - end - - def test_initialize_with_attributes - topic = Topic.new({ - "title" => "initialized from attributes", "written_on" => "2003-12-12 23:23" - }) - - assert_equal("initialized from attributes", topic.title) - end - - def test_initialize_with_invalid_attribute - begin - topic = Topic.new({ "title" => "test", - "last_read(1i)" => "2005", "last_read(2i)" => "2", "last_read(3i)" => "31"}) - rescue ActiveRecord::MultiparameterAssignmentErrors => ex - assert_equal(1, ex.errors.size) - assert_equal("last_read", ex.errors[0].attribute) - end - end - - def test_load - topics = Topic.find(:all, :order => 'id') - assert_equal(2, topics.size) - assert_equal(topics(:first).title, topics.first.title) - end - - def test_load_with_condition - topics = Topic.find(:all, :conditions => "author_name = 'Mary'") - - assert_equal(1, topics.size) - assert_equal(topics(:second).title, topics.first.title) - end - - def test_table_name_guesses - classes = [Category, Smarts, CreditCard, CreditCard::PinNumber, CreditCard::PinNumber::CvvCode, CreditCard::SubPinNumber, CreditCard::Brand, MasterCreditCard] - - assert_equal "topics", Topic.table_name - - assert_equal "categories", Category.table_name - assert_equal "smarts", Smarts.table_name - assert_equal "credit_cards", CreditCard.table_name - assert_equal "credit_card_pin_numbers", CreditCard::PinNumber.table_name - assert_equal "credit_card_pin_number_cvv_codes", CreditCard::PinNumber::CvvCode.table_name - assert_equal "credit_card_pin_numbers", CreditCard::SubPinNumber.table_name - assert_equal "categories", CreditCard::Brand.table_name - assert_equal "master_credit_cards", MasterCreditCard.table_name - - ActiveRecord::Base.pluralize_table_names = false - classes.each(&:reset_table_name) - - assert_equal "category", Category.table_name - assert_equal "smarts", Smarts.table_name - assert_equal "credit_card", CreditCard.table_name - assert_equal "credit_card_pin_number", CreditCard::PinNumber.table_name - assert_equal "credit_card_pin_number_cvv_code", CreditCard::PinNumber::CvvCode.table_name - assert_equal "credit_card_pin_number", CreditCard::SubPinNumber.table_name - assert_equal "category", CreditCard::Brand.table_name - assert_equal "master_credit_card", MasterCreditCard.table_name - - ActiveRecord::Base.pluralize_table_names = true - classes.each(&:reset_table_name) - - ActiveRecord::Base.table_name_prefix = "test_" - Category.reset_table_name - assert_equal "test_categories", Category.table_name - ActiveRecord::Base.table_name_suffix = "_test" - Category.reset_table_name - assert_equal "test_categories_test", Category.table_name - ActiveRecord::Base.table_name_prefix = "" - Category.reset_table_name - assert_equal "categories_test", Category.table_name - ActiveRecord::Base.table_name_suffix = "" - Category.reset_table_name - assert_equal "categories", Category.table_name - - ActiveRecord::Base.pluralize_table_names = false - ActiveRecord::Base.table_name_prefix = "test_" - Category.reset_table_name - assert_equal "test_category", Category.table_name - ActiveRecord::Base.table_name_suffix = "_test" - Category.reset_table_name - assert_equal "test_category_test", Category.table_name - ActiveRecord::Base.table_name_prefix = "" - Category.reset_table_name - assert_equal "category_test", Category.table_name - ActiveRecord::Base.table_name_suffix = "" - Category.reset_table_name - assert_equal "category", Category.table_name - - ActiveRecord::Base.pluralize_table_names = true - classes.each(&:reset_table_name) - end - - def test_destroy_all - assert_equal 2, Topic.count - - Topic.destroy_all "author_name = 'Mary'" - assert_equal 1, Topic.count - end - - def test_destroy_many - assert_equal 3, Client.count - Client.destroy([2, 3]) - assert_equal 1, Client.count - end - - def test_delete_many - Topic.delete([1, 2]) - assert_equal 0, Topic.count - end - - def test_boolean_attributes - assert ! Topic.find(1).approved? - assert Topic.find(2).approved? - end - - def test_increment_counter - Topic.increment_counter("replies_count", 1) - assert_equal 2, Topic.find(1).replies_count - - Topic.increment_counter("replies_count", 1) - assert_equal 3, Topic.find(1).replies_count - end - - def test_decrement_counter - Topic.decrement_counter("replies_count", 2) - assert_equal -1, Topic.find(2).replies_count - - Topic.decrement_counter("replies_count", 2) - assert_equal -2, Topic.find(2).replies_count - end - - def test_update_all - assert_equal 2, Topic.update_all("content = 'bulk updated!'") - assert_equal "bulk updated!", Topic.find(1).content - assert_equal "bulk updated!", Topic.find(2).content - - assert_equal 2, Topic.update_all(['content = ?', 'bulk updated again!']) - assert_equal "bulk updated again!", Topic.find(1).content - assert_equal "bulk updated again!", Topic.find(2).content - - assert_equal 2, Topic.update_all(['content = ?', nil]) - assert_nil Topic.find(1).content - end - - def test_update_all_with_hash - assert_not_nil Topic.find(1).last_read - assert_equal 2, Topic.update_all(:content => 'bulk updated with hash!', :last_read => nil) - assert_equal "bulk updated with hash!", Topic.find(1).content - assert_equal "bulk updated with hash!", Topic.find(2).content - assert_nil Topic.find(1).last_read - assert_nil Topic.find(2).last_read - end - - def test_update_all_with_non_standard_table_name - assert_equal 1, WarehouseThing.update_all(['value = ?', 0], ['id = ?', 1]) - assert_equal 0, WarehouseThing.find(1).value - end - - if current_adapter?(:MysqlAdapter) - def test_update_all_with_order_and_limit - assert_equal 1, Topic.update_all("content = 'bulk updated!'", nil, :limit => 1, :order => 'id DESC') - end - end - - def test_update_all_ignores_order_limit_from_association - author = Author.find(1) - assert_nothing_raised do - assert_equal author.posts_with_comments_and_categories.length, author.posts_with_comments_and_categories.update_all("body = 'bulk update!'") - end - end - - def test_update_many - topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } } - updated = Topic.update(topic_data.keys, topic_data.values) - - assert_equal 2, updated.size - assert_equal "1 updated", Topic.find(1).content - assert_equal "2 updated", Topic.find(2).content - end - - def test_delete_all - assert_equal 2, Topic.delete_all - end - - def test_update_by_condition - Topic.update_all "content = 'bulk updated!'", ["approved = ?", true] - assert_equal "Have a nice day", Topic.find(1).content - assert_equal "bulk updated!", Topic.find(2).content - end - - def test_attribute_present - t = Topic.new - t.title = "hello there!" - t.written_on = Time.now - assert t.attribute_present?("title") - assert t.attribute_present?("written_on") - assert !t.attribute_present?("content") - end - - def test_attribute_keys_on_new_instance - t = Topic.new - assert_equal nil, t.title, "The topics table has a title column, so it should be nil" - assert_raise(NoMethodError) { t.title2 } - end - - def test_class_name - assert_equal "Firm", ActiveRecord::Base.class_name("firms") - assert_equal "Category", ActiveRecord::Base.class_name("categories") - assert_equal "AccountHolder", ActiveRecord::Base.class_name("account_holder") - - ActiveRecord::Base.pluralize_table_names = false - assert_equal "Firms", ActiveRecord::Base.class_name( "firms" ) - ActiveRecord::Base.pluralize_table_names = true - - ActiveRecord::Base.table_name_prefix = "test_" - assert_equal "Firm", ActiveRecord::Base.class_name( "test_firms" ) - ActiveRecord::Base.table_name_suffix = "_tests" - assert_equal "Firm", ActiveRecord::Base.class_name( "test_firms_tests" ) - ActiveRecord::Base.table_name_prefix = "" - assert_equal "Firm", ActiveRecord::Base.class_name( "firms_tests" ) - ActiveRecord::Base.table_name_suffix = "" - assert_equal "Firm", ActiveRecord::Base.class_name( "firms" ) - end - - def test_null_fields - assert_nil Topic.find(1).parent_id - assert_nil Topic.create("title" => "Hey you").parent_id - end - - def test_default_values - topic = Topic.new - assert topic.approved? - assert_nil topic.written_on - assert_nil topic.bonus_time - assert_nil topic.last_read - - topic.save - - topic = Topic.find(topic.id) - assert topic.approved? - assert_nil topic.last_read - - # Oracle has some funky default handling, so it requires a bit of - # extra testing. See ticket #2788. - if current_adapter?(:OracleAdapter) - test = TestOracleDefault.new - assert_equal "X", test.test_char - assert_equal "hello", test.test_string - assert_equal 3, test.test_int - end - end - - # Oracle, SQLServer, and Sybase do not have a TIME datatype. - unless current_adapter?(:SQLServerAdapter, :OracleAdapter, :SybaseAdapter) - def test_utc_as_time_zone - Topic.default_timezone = :utc - attributes = { "bonus_time" => "5:42:00AM" } - topic = Topic.find(1) - topic.attributes = attributes - assert_equal Time.utc(2000, 1, 1, 5, 42, 0), topic.bonus_time - Topic.default_timezone = :local - end - - def test_utc_as_time_zone_and_new - Topic.default_timezone = :utc - attributes = { "bonus_time(1i)"=>"2000", - "bonus_time(2i)"=>"1", - "bonus_time(3i)"=>"1", - "bonus_time(4i)"=>"10", - "bonus_time(5i)"=>"35", - "bonus_time(6i)"=>"50" } - topic = Topic.new(attributes) - assert_equal Time.utc(2000, 1, 1, 10, 35, 50), topic.bonus_time - Topic.default_timezone = :local - end - end - - def test_default_values_on_empty_strings - topic = Topic.new - topic.approved = nil - topic.last_read = nil - - topic.save - - topic = Topic.find(topic.id) - assert_nil topic.last_read - - # Sybase adapter does not allow nulls in boolean columns - if current_adapter?(:SybaseAdapter) - assert topic.approved == false - else - assert_nil topic.approved - end - end - - def test_equality - assert_equal Topic.find(1), Topic.find(2).topic - end - - def test_equality_of_new_records - assert_not_equal Topic.new, Topic.new - end - - def test_hashing - assert_equal [ Topic.find(1) ], [ Topic.find(2).topic ] & [ Topic.find(1) ] - end - - def test_destroy_new_record - client = Client.new - client.destroy - assert client.frozen? - end - - def test_destroy_record_with_associations - client = Client.find(3) - client.destroy - assert client.frozen? - assert_kind_of Firm, client.firm - assert_raises(ActiveSupport::FrozenObjectError) { client.name = "something else" } - end - - def test_update_attribute - assert !Topic.find(1).approved? - Topic.find(1).update_attribute("approved", true) - assert Topic.find(1).approved? - - Topic.find(1).update_attribute(:approved, false) - assert !Topic.find(1).approved? - end - - def test_update_attributes - topic = Topic.find(1) - assert !topic.approved? - assert_equal "The First Topic", topic.title - - topic.update_attributes("approved" => true, "title" => "The First Topic Updated") - topic.reload - assert topic.approved? - assert_equal "The First Topic Updated", topic.title - - topic.update_attributes(:approved => false, :title => "The First Topic") - topic.reload - assert !topic.approved? - assert_equal "The First Topic", topic.title - end - - def test_update_attributes! - reply = Reply.find(2) - assert_equal "The Second Topic's of the day", reply.title - assert_equal "Have a nice day", reply.content - - reply.update_attributes!("title" => "The Second Topic's of the day updated", "content" => "Have a nice evening") - reply.reload - assert_equal "The Second Topic's of the day updated", reply.title - assert_equal "Have a nice evening", reply.content - - reply.update_attributes!(:title => "The Second Topic's of the day", :content => "Have a nice day") - reply.reload - assert_equal "The Second Topic's of the day", reply.title - assert_equal "Have a nice day", reply.content - - assert_raise(ActiveRecord::RecordInvalid) { reply.update_attributes!(:title => nil, :content => "Have a nice evening") } - end - - def test_mass_assignment_should_raise_exception_if_accessible_and_protected_attribute_writers_are_both_used - topic = TopicWithProtectedContentAndAccessibleAuthorName.new - assert_raises(RuntimeError) { topic.attributes = { "author_name" => "me" } } - assert_raises(RuntimeError) { topic.attributes = { "content" => "stuff" } } - end - - def test_mass_assignment_protection - firm = Firm.new - firm.attributes = { "name" => "Next Angle", "rating" => 5 } - assert_equal 1, firm.rating - end - - def test_mass_assignment_protection_against_class_attribute_writers - [:logger, :configurations, :primary_key_prefix_type, :table_name_prefix, :table_name_suffix, :pluralize_table_names, :colorize_logging, - :default_timezone, :allow_concurrency, :schema_format, :verification_timeout, :lock_optimistically, :record_timestamps].each do |method| - assert Task.respond_to?(method) - assert Task.respond_to?("#{method}=") - assert Task.new.respond_to?(method) - assert !Task.new.respond_to?("#{method}=") - end - end - - def test_customized_primary_key_remains_protected - subscriber = Subscriber.new(:nick => 'webster123', :name => 'nice try') - assert_nil subscriber.id - - keyboard = Keyboard.new(:key_number => 9, :name => 'nice try') - assert_nil keyboard.id - end - - def test_customized_primary_key_remains_protected_when_referred_to_as_id - subscriber = Subscriber.new(:id => 'webster123', :name => 'nice try') - assert_nil subscriber.id - - keyboard = Keyboard.new(:id => 9, :name => 'nice try') - assert_nil keyboard.id - end - - def test_mass_assignment_protection_on_defaults - firm = Firm.new - firm.attributes = { "id" => 5, "type" => "Client" } - assert_nil firm.id - assert_equal "Firm", firm[:type] - end - - def test_mass_assignment_accessible - reply = Reply.new("title" => "hello", "content" => "world", "approved" => true) - reply.save - - assert reply.approved? - - reply.approved = false - reply.save - - assert !reply.approved? - end - - def test_mass_assignment_protection_inheritance - assert_nil LoosePerson.accessible_attributes - assert_equal Set.new([ 'credit_rating', 'administrator' ]), LoosePerson.protected_attributes - - assert_nil LooseDescendant.accessible_attributes - assert_equal Set.new([ 'credit_rating', 'administrator', 'phone_number' ]), LooseDescendant.protected_attributes - - assert_nil LooseDescendantSecond.accessible_attributes - assert_equal Set.new([ 'credit_rating', 'administrator', 'phone_number', 'name' ]), LooseDescendantSecond.protected_attributes, 'Running attr_protected twice in one class should merge the protections' - - assert_nil TightPerson.protected_attributes - assert_equal Set.new([ 'name', 'address' ]), TightPerson.accessible_attributes - - assert_nil TightDescendant.protected_attributes - assert_equal Set.new([ 'name', 'address', 'phone_number' ]), TightDescendant.accessible_attributes - end - - def test_readonly_attributes - assert_equal Set.new([ 'title' ]), ReadonlyTitlePost.readonly_attributes - - post = ReadonlyTitlePost.create(:title => "cannot change this", :body => "changeable") - post.reload - assert_equal "cannot change this", post.title - - post.update_attributes(:title => "try to change", :body => "changed") - post.reload - assert_equal "cannot change this", post.title - assert_equal "changed", post.body - end - - def test_multiparameter_attributes_on_date - attributes = { "last_read(1i)" => "2004", "last_read(2i)" => "6", "last_read(3i)" => "24" } - topic = Topic.find(1) - topic.attributes = attributes - # note that extra #to_date call allows test to pass for Oracle, which - # treats dates/times the same - assert_date_from_db Date.new(2004, 6, 24), topic.last_read.to_date - end - - def test_multiparameter_attributes_on_date_with_empty_date - attributes = { "last_read(1i)" => "2004", "last_read(2i)" => "6", "last_read(3i)" => "" } - topic = Topic.find(1) - topic.attributes = attributes - # note that extra #to_date call allows test to pass for Oracle, which - # treats dates/times the same - assert_date_from_db Date.new(2004, 6, 1), topic.last_read.to_date - end - - def test_multiparameter_attributes_on_date_with_all_empty - attributes = { "last_read(1i)" => "", "last_read(2i)" => "", "last_read(3i)" => "" } - topic = Topic.find(1) - topic.attributes = attributes - assert_nil topic.last_read - end - - def test_multiparameter_attributes_on_time - attributes = { - "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24", - "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00" - } - topic = Topic.find(1) - topic.attributes = attributes - assert_equal Time.local(2004, 6, 24, 16, 24, 0), topic.written_on - end - - def test_multiparameter_attributes_on_time_with_empty_seconds - attributes = { - "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24", - "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "" - } - topic = Topic.find(1) - topic.attributes = attributes - assert_equal Time.local(2004, 6, 24, 16, 24, 0), topic.written_on - end - - def test_multiparameter_mass_assignment_protector - task = Task.new - time = Time.mktime(2000, 1, 1, 1) - task.starting = time - attributes = { "starting(1i)" => "2004", "starting(2i)" => "6", "starting(3i)" => "24" } - task.attributes = attributes - assert_equal time, task.starting - end - - def test_multiparameter_assignment_of_aggregation - customer = Customer.new - address = Address.new("The Street", "The City", "The Country") - attributes = { "address(1)" => address.street, "address(2)" => address.city, "address(3)" => address.country } - customer.attributes = attributes - assert_equal address, customer.address - end - - def test_attributes_on_dummy_time - # Oracle, SQL Server, and Sybase do not have a TIME datatype. - return true if current_adapter?(:SQLServerAdapter, :OracleAdapter, :SybaseAdapter) - - attributes = { - "bonus_time" => "5:42:00AM" - } - topic = Topic.find(1) - topic.attributes = attributes - assert_equal Time.local(2000, 1, 1, 5, 42, 0), topic.bonus_time - end - - def test_boolean - b_false = Booleantest.create({ "value" => false }) - false_id = b_false.id - b_true = Booleantest.create({ "value" => true }) - true_id = b_true.id - - b_false = Booleantest.find(false_id) - assert !b_false.value? - b_true = Booleantest.find(true_id) - assert b_true.value? - end - - def test_boolean_cast_from_string - b_false = Booleantest.create({ "value" => "0" }) - false_id = b_false.id - b_true = Booleantest.create({ "value" => "1" }) - true_id = b_true.id - - b_false = Booleantest.find(false_id) - assert !b_false.value? - b_true = Booleantest.find(true_id) - assert b_true.value? - end - - def test_clone - topic = Topic.find(1) - cloned_topic = nil - assert_nothing_raised { cloned_topic = topic.clone } - assert_equal topic.title, cloned_topic.title - assert cloned_topic.new_record? - - # test if the attributes have been cloned - topic.title = "a" - cloned_topic.title = "b" - assert_equal "a", topic.title - assert_equal "b", cloned_topic.title - - # test if the attribute values have been cloned - topic.title = {"a" => "b"} - cloned_topic = topic.clone - cloned_topic.title["a"] = "c" - assert_equal "b", topic.title["a"] - - #test if attributes set as part of after_initialize are cloned correctly - assert_equal topic.author_email_address, cloned_topic.author_email_address - - # test if saved clone object differs from original - cloned_topic.save - assert !cloned_topic.new_record? - assert cloned_topic.id != topic.id - end - - def test_clone_with_aggregate_of_same_name_as_attribute - dev = DeveloperWithAggregate.find(1) - assert_kind_of DeveloperSalary, dev.salary - - clone = nil - assert_nothing_raised { clone = dev.clone } - assert_kind_of DeveloperSalary, clone.salary - assert_equal dev.salary.amount, clone.salary.amount - assert clone.new_record? - - # test if the attributes have been cloned - original_amount = clone.salary.amount - dev.salary.amount = 1 - assert_equal original_amount, clone.salary.amount - - assert clone.save - assert !clone.new_record? - assert clone.id != dev.id - end - - def test_clone_preserves_subtype - clone = nil - assert_nothing_raised { clone = Company.find(3).clone } - assert_kind_of Client, clone - end - - def test_bignum - company = Company.find(1) - company.rating = 2147483647 - company.save - company = Company.find(1) - assert_equal 2147483647, company.rating - end - - # TODO: extend defaults tests to other databases! - if current_adapter?(:PostgreSQLAdapter) - def test_default - default = Default.new - - # fixed dates / times - assert_equal Date.new(2004, 1, 1), default.fixed_date - assert_equal Time.local(2004, 1,1,0,0,0,0), default.fixed_time - - # char types - assert_equal 'Y', default.char1 - assert_equal 'a varchar field', default.char2 - assert_equal 'a text field', default.char3 - end - - class Geometric < ActiveRecord::Base; end - def test_geometric_content - - # accepted format notes: - # ()'s aren't required - # values can be a mix of float or integer - - g = Geometric.new( - :a_point => '(5.0, 6.1)', - #:a_line => '((2.0, 3), (5.5, 7.0))' # line type is currently unsupported in postgresql - :a_line_segment => '(2.0, 3), (5.5, 7.0)', - :a_box => '2.0, 3, 5.5, 7.0', - :a_path => '[(2.0, 3), (5.5, 7.0), (8.5, 11.0)]', # [ ] is an open path - :a_polygon => '((2.0, 3), (5.5, 7.0), (8.5, 11.0))', - :a_circle => '<(5.3, 10.4), 2>' - ) - - assert g.save - - # Reload and check that we have all the geometric attributes. - h = Geometric.find(g.id) - - assert_equal '(5,6.1)', h.a_point - assert_equal '[(2,3),(5.5,7)]', h.a_line_segment - assert_equal '(5.5,7),(2,3)', h.a_box # reordered to store upper right corner then bottom left corner - assert_equal '[(2,3),(5.5,7),(8.5,11)]', h.a_path - assert_equal '((2,3),(5.5,7),(8.5,11))', h.a_polygon - assert_equal '<(5.3,10.4),2>', h.a_circle - - # use a geometric function to test for an open path - objs = Geometric.find_by_sql ["select isopen(a_path) from geometrics where id = ?", g.id] - assert_equal objs[0].isopen, 't' - - # test alternate formats when defining the geometric types - - g = Geometric.new( - :a_point => '5.0, 6.1', - #:a_line => '((2.0, 3), (5.5, 7.0))' # line type is currently unsupported in postgresql - :a_line_segment => '((2.0, 3), (5.5, 7.0))', - :a_box => '(2.0, 3), (5.5, 7.0)', - :a_path => '((2.0, 3), (5.5, 7.0), (8.5, 11.0))', # ( ) is a closed path - :a_polygon => '2.0, 3, 5.5, 7.0, 8.5, 11.0', - :a_circle => '((5.3, 10.4), 2)' - ) - - assert g.save - - # Reload and check that we have all the geometric attributes. - h = Geometric.find(g.id) - - assert_equal '(5,6.1)', h.a_point - assert_equal '[(2,3),(5.5,7)]', h.a_line_segment - assert_equal '(5.5,7),(2,3)', h.a_box # reordered to store upper right corner then bottom left corner - assert_equal '((2,3),(5.5,7),(8.5,11))', h.a_path - assert_equal '((2,3),(5.5,7),(8.5,11))', h.a_polygon - assert_equal '<(5.3,10.4),2>', h.a_circle - - # use a geometric function to test for an closed path - objs = Geometric.find_by_sql ["select isclosed(a_path) from geometrics where id = ?", g.id] - assert_equal objs[0].isclosed, 't' - end - end - - class NumericData < ActiveRecord::Base - self.table_name = 'numeric_data' - end - - def test_numeric_fields - m = NumericData.new( - :bank_balance => 1586.43, - :big_bank_balance => BigDecimal("1000234000567.95"), - :world_population => 6000000000, - :my_house_population => 3 - ) - assert m.save - - m1 = NumericData.find(m.id) - assert_not_nil m1 - - # As with migration_test.rb, we should make world_population >= 2**62 - # to cover 64-bit platforms and test it is a Bignum, but the main thing - # is that it's an Integer. - assert_kind_of Integer, m1.world_population - assert_equal 6000000000, m1.world_population - - assert_kind_of Fixnum, m1.my_house_population - assert_equal 3, m1.my_house_population - - assert_kind_of BigDecimal, m1.bank_balance - assert_equal BigDecimal("1586.43"), m1.bank_balance - - assert_kind_of BigDecimal, m1.big_bank_balance - assert_equal BigDecimal("1000234000567.95"), m1.big_bank_balance - end - - def test_auto_id - auto = AutoId.new - auto.save - assert (auto.id > 0) - end - - def quote_column_name(name) - "<#{name}>" - end - - def test_quote_keys - ar = AutoId.new - source = {"foo" => "bar", "baz" => "quux"} - actual = ar.send(:quote_columns, self, source) - inverted = actual.invert - assert_equal("", inverted["bar"]) - assert_equal("", inverted["quux"]) - end - - def test_sql_injection_via_find - assert_raises(ActiveRecord::RecordNotFound, ActiveRecord::StatementInvalid) do - Topic.find("123456 OR id > 0") - end - end - - def test_column_name_properly_quoted - col_record = ColumnName.new - col_record.references = 40 - assert col_record.save - col_record.references = 41 - assert col_record.save - assert_not_nil c2 = ColumnName.find(col_record.id) - assert_equal(41, c2.references) - end - - def test_quoting_arrays - replies = Reply.find(:all, :conditions => [ "id IN (?)", topics(:first).replies.collect(&:id) ]) - assert_equal topics(:first).replies.size, replies.size - - replies = Reply.find(:all, :conditions => [ "id IN (?)", [] ]) - assert_equal 0, replies.size - end - - MyObject = Struct.new :attribute1, :attribute2 - - def test_serialized_attribute - myobj = MyObject.new('value1', 'value2') - topic = Topic.create("content" => myobj) - Topic.serialize("content", MyObject) - assert_equal(myobj, topic.content) - end - - def test_nil_serialized_attribute_with_class_constraint - myobj = MyObject.new('value1', 'value2') - topic = Topic.new - assert_nil topic.content - end - - def test_should_raise_exception_on_serialized_attribute_with_type_mismatch - myobj = MyObject.new('value1', 'value2') - topic = Topic.new(:content => myobj) - assert topic.save - Topic.serialize(:content, Hash) - assert_raise(ActiveRecord::SerializationTypeMismatch) { Topic.find(topic.id).content } - ensure - Topic.serialize(:content) - end - - def test_serialized_attribute_with_class_constraint - settings = { "color" => "blue" } - Topic.serialize(:content, Hash) - topic = Topic.new(:content => settings) - assert topic.save - assert_equal(settings, Topic.find(topic.id).content) - ensure - Topic.serialize(:content) - end - - def test_quote - author_name = "\\ \001 ' \n \\n \"" - topic = Topic.create('author_name' => author_name) - assert_equal author_name, Topic.find(topic.id).author_name - end - - if RUBY_VERSION < '1.9' - def test_quote_chars - str = 'The Narrator' - topic = Topic.create(:author_name => str) - assert_equal str, topic.author_name - - assert_kind_of ActiveSupport::Multibyte::Chars, str.chars - topic = Topic.find_by_author_name(str.chars) - - assert_kind_of Topic, topic - assert_equal str, topic.author_name, "The right topic should have been found by name even with name passed as Chars" - end - end - - def test_class_level_destroy - should_be_destroyed_reply = Reply.create("title" => "hello", "content" => "world") - Topic.find(1).replies << should_be_destroyed_reply - - Topic.destroy(1) - assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1) } - assert_raise(ActiveRecord::RecordNotFound) { Reply.find(should_be_destroyed_reply.id) } - end - - def test_class_level_delete - should_be_destroyed_reply = Reply.create("title" => "hello", "content" => "world") - Topic.find(1).replies << should_be_destroyed_reply - - Topic.delete(1) - assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1) } - assert_nothing_raised { Reply.find(should_be_destroyed_reply.id) } - end - - def test_increment_attribute - assert_equal 50, accounts(:signals37).credit_limit - accounts(:signals37).increment! :credit_limit - assert_equal 51, accounts(:signals37, :reload).credit_limit - - accounts(:signals37).increment(:credit_limit).increment!(:credit_limit) - assert_equal 53, accounts(:signals37, :reload).credit_limit - end - - def test_increment_nil_attribute - assert_nil topics(:first).parent_id - topics(:first).increment! :parent_id - assert_equal 1, topics(:first).parent_id - end - - def test_increment_attribute_by - assert_equal 50, accounts(:signals37).credit_limit - accounts(:signals37).increment! :credit_limit, 5 - assert_equal 55, accounts(:signals37, :reload).credit_limit - - accounts(:signals37).increment(:credit_limit, 1).increment!(:credit_limit, 3) - assert_equal 59, accounts(:signals37, :reload).credit_limit - end - - def test_decrement_attribute - assert_equal 50, accounts(:signals37).credit_limit - - accounts(:signals37).decrement!(:credit_limit) - assert_equal 49, accounts(:signals37, :reload).credit_limit - - accounts(:signals37).decrement(:credit_limit).decrement!(:credit_limit) - assert_equal 47, accounts(:signals37, :reload).credit_limit - end - - def test_decrement_attribute_by - assert_equal 50, accounts(:signals37).credit_limit - accounts(:signals37).decrement! :credit_limit, 5 - assert_equal 45, accounts(:signals37, :reload).credit_limit - - accounts(:signals37).decrement(:credit_limit, 1).decrement!(:credit_limit, 3) - assert_equal 41, accounts(:signals37, :reload).credit_limit - end - - def test_toggle_attribute - assert !topics(:first).approved? - topics(:first).toggle!(:approved) - assert topics(:first).approved? - topic = topics(:first) - topic.toggle(:approved) - assert !topic.approved? - topic.reload - assert topic.approved? - end - - def test_reload - t1 = Topic.find(1) - t2 = Topic.find(1) - t1.title = "something else" - t1.save - t2.reload - assert_equal t1.title, t2.title - end - - def test_define_attr_method_with_value - k = Class.new( ActiveRecord::Base ) - k.send(:define_attr_method, :table_name, "foo") - assert_equal "foo", k.table_name - end - - def test_define_attr_method_with_block - k = Class.new( ActiveRecord::Base ) - k.send(:define_attr_method, :primary_key) { "sys_" + original_primary_key } - assert_equal "sys_id", k.primary_key - end - - def test_set_table_name_with_value - k = Class.new( ActiveRecord::Base ) - k.table_name = "foo" - assert_equal "foo", k.table_name - k.set_table_name "bar" - assert_equal "bar", k.table_name - end - - def test_set_table_name_with_block - k = Class.new( ActiveRecord::Base ) - k.set_table_name { "ks" } - assert_equal "ks", k.table_name - end - - def test_set_primary_key_with_value - k = Class.new( ActiveRecord::Base ) - k.primary_key = "foo" - assert_equal "foo", k.primary_key - k.set_primary_key "bar" - assert_equal "bar", k.primary_key - end - - def test_set_primary_key_with_block - k = Class.new( ActiveRecord::Base ) - k.set_primary_key { "sys_" + original_primary_key } - assert_equal "sys_id", k.primary_key - end - - def test_set_inheritance_column_with_value - k = Class.new( ActiveRecord::Base ) - k.inheritance_column = "foo" - assert_equal "foo", k.inheritance_column - k.set_inheritance_column "bar" - assert_equal "bar", k.inheritance_column - end - - def test_set_inheritance_column_with_block - k = Class.new( ActiveRecord::Base ) - k.set_inheritance_column { original_inheritance_column + "_id" } - assert_equal "type_id", k.inheritance_column - end - - def test_count_with_join - res = Post.count_by_sql "SELECT COUNT(*) FROM posts LEFT JOIN comments ON posts.id=comments.post_id WHERE posts.#{QUOTED_TYPE} = 'Post'" - - res2 = Post.count(:conditions => "posts.#{QUOTED_TYPE} = 'Post'", :joins => "LEFT JOIN comments ON posts.id=comments.post_id") - assert_equal res, res2 - - res3 = nil - assert_nothing_raised do - res3 = Post.count(:conditions => "posts.#{QUOTED_TYPE} = 'Post'", - :joins => "LEFT JOIN comments ON posts.id=comments.post_id") - end - assert_equal res, res3 - - res4 = Post.count_by_sql "SELECT COUNT(p.id) FROM posts p, comments co WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id" - res5 = nil - assert_nothing_raised do - res5 = Post.count(:conditions => "p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id", - :joins => "p, comments co", - :select => "p.id") - end - - assert_equal res4, res5 - - unless current_adapter?(:SQLite2Adapter, :DeprecatedSQLiteAdapter) - res6 = Post.count_by_sql "SELECT COUNT(DISTINCT p.id) FROM posts p, comments co WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id" - res7 = nil - assert_nothing_raised do - res7 = Post.count(:conditions => "p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id", - :joins => "p, comments co", - :select => "p.id", - :distinct => true) - end - assert_equal res6, res7 - end - end - - def test_clear_association_cache_stored - firm = Firm.find(1) - assert_kind_of Firm, firm - - firm.clear_association_cache - assert_equal Firm.find(1).clients.collect{ |x| x.name }.sort, firm.clients.collect{ |x| x.name }.sort - end - - def test_clear_association_cache_new_record - firm = Firm.new - client_stored = Client.find(3) - client_new = Client.new - client_new.name = "The Joneses" - clients = [ client_stored, client_new ] - - firm.clients << clients - assert_equal clients.map(&:name).to_set, firm.clients.map(&:name).to_set - - firm.clear_association_cache - assert_equal clients.map(&:name).to_set, firm.clients.map(&:name).to_set - end - - def test_interpolate_sql - assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo@bar') } - assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo bar) baz') } - assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo bar} baz') } - end - - def test_scoped_find_conditions - scoped_developers = Developer.with_scope(:find => { :conditions => 'salary > 90000' }) do - Developer.find(:all, :conditions => 'id < 5') - end - assert !scoped_developers.include?(developers(:david)) # David's salary is less than 90,000 - assert_equal 3, scoped_developers.size - end - - def test_scoped_find_limit_offset - scoped_developers = Developer.with_scope(:find => { :limit => 3, :offset => 2 }) do - Developer.find(:all, :order => 'id') - end - assert !scoped_developers.include?(developers(:david)) - assert !scoped_developers.include?(developers(:jamis)) - assert_equal 3, scoped_developers.size - - # Test without scoped find conditions to ensure we get the whole thing - developers = Developer.find(:all, :order => 'id') - assert_equal Developer.count, developers.size - end - - def test_scoped_find_order - # Test order in scope - scoped_developers = Developer.with_scope(:find => { :limit => 1, :order => 'salary DESC' }) do - Developer.find(:all) - end - assert_equal 'Jamis', scoped_developers.first.name - assert scoped_developers.include?(developers(:jamis)) - # Test scope without order and order in find - scoped_developers = Developer.with_scope(:find => { :limit => 1 }) do - Developer.find(:all, :order => 'salary DESC') - end - # Test scope order + find order, find has priority - scoped_developers = Developer.with_scope(:find => { :limit => 3, :order => 'id DESC' }) do - Developer.find(:all, :order => 'salary ASC') - end - assert scoped_developers.include?(developers(:poor_jamis)) - assert scoped_developers.include?(developers(:david)) - assert scoped_developers.include?(developers(:dev_10)) - # Test without scoped find conditions to ensure we get the right thing - developers = Developer.find(:all, :order => 'id', :limit => 1) - assert scoped_developers.include?(developers(:david)) - end - - def test_scoped_find_limit_offset_including_has_many_association - topics = Topic.with_scope(:find => {:limit => 1, :offset => 1, :include => :replies}) do - Topic.find(:all, :order => "topics.id") - end - assert_equal 1, topics.size - assert_equal 2, topics.first.id - end - - def test_scoped_find_order_including_has_many_association - developers = Developer.with_scope(:find => { :order => 'developers.salary DESC', :include => :projects }) do - Developer.find(:all) - end - assert developers.size >= 2 - for i in 1...developers.size - assert developers[i-1].salary >= developers[i].salary - end - end - - def test_abstract_class - assert !ActiveRecord::Base.abstract_class? - assert LoosePerson.abstract_class? - assert !LooseDescendant.abstract_class? - end - - def test_base_class - assert_equal LoosePerson, LoosePerson.base_class - assert_equal LooseDescendant, LooseDescendant.base_class - assert_equal TightPerson, TightPerson.base_class - assert_equal TightPerson, TightDescendant.base_class - - assert_equal Post, Post.base_class - assert_equal Post, SpecialPost.base_class - assert_equal Post, StiPost.base_class - assert_equal SubStiPost, SubStiPost.base_class - end - - def test_descends_from_active_record - # Tries to call Object.abstract_class? - assert_raise(NoMethodError) do - ActiveRecord::Base.descends_from_active_record? - end - - # Abstract subclass of AR::Base. - assert LoosePerson.descends_from_active_record? - - # Concrete subclass of an abstract class. - assert LooseDescendant.descends_from_active_record? - - # Concrete subclass of AR::Base. - assert TightPerson.descends_from_active_record? - - # Concrete subclass of a concrete class but has no type column. - assert TightDescendant.descends_from_active_record? - - # Concrete subclass of AR::Base. - assert Post.descends_from_active_record? - - # Abstract subclass of a concrete class which has a type column. - # This is pathological, as you'll never have Sub < Abstract < Concrete. - assert !StiPost.descends_from_active_record? - - # Concrete subclasses an abstract class which has a type column. - assert !SubStiPost.descends_from_active_record? - end - - def test_find_on_abstract_base_class_doesnt_use_type_condition - old_class = LooseDescendant - Object.send :remove_const, :LooseDescendant - - descendant = old_class.create! - assert_not_nil LoosePerson.find(descendant.id), "Should have found instance of LooseDescendant when finding abstract LoosePerson: #{descendant.inspect}" - ensure - unless Object.const_defined?(:LooseDescendant) - Object.const_set :LooseDescendant, old_class - end - end - - def test_assert_queries - query = lambda { ActiveRecord::Base.connection.execute 'select count(*) from developers' } - assert_queries(2) { 2.times { query.call } } - assert_queries 1, &query - assert_no_queries { assert true } - end - - def test_to_xml - xml = REXML::Document.new(topics(:first).to_xml(:indent => 0)) - bonus_time_in_current_timezone = topics(:first).bonus_time.xmlschema - written_on_in_current_timezone = topics(:first).written_on.xmlschema - last_read_in_current_timezone = topics(:first).last_read.xmlschema - - assert_equal "topic", xml.root.name - assert_equal "The First Topic" , xml.elements["//title"].text - assert_equal "David" , xml.elements["//author-name"].text - - assert_equal "1", xml.elements["//id"].text - assert_equal "integer" , xml.elements["//id"].attributes['type'] - - assert_equal "1", xml.elements["//replies-count"].text - assert_equal "integer" , xml.elements["//replies-count"].attributes['type'] - - assert_equal written_on_in_current_timezone, xml.elements["//written-on"].text - assert_equal "datetime" , xml.elements["//written-on"].attributes['type'] - - assert_equal "--- Have a nice day\n" , xml.elements["//content"].text - assert_equal "yaml" , xml.elements["//content"].attributes['type'] - - assert_equal "david@loudthinking.com", xml.elements["//author-email-address"].text - - assert_equal nil, xml.elements["//parent-id"].text - assert_equal "integer", xml.elements["//parent-id"].attributes['type'] - assert_equal "true", xml.elements["//parent-id"].attributes['nil'] - - if current_adapter?(:SybaseAdapter, :SQLServerAdapter, :OracleAdapter) - assert_equal last_read_in_current_timezone, xml.elements["//last-read"].text - assert_equal "datetime" , xml.elements["//last-read"].attributes['type'] - else - assert_equal "2004-04-15", xml.elements["//last-read"].text - assert_equal "date" , xml.elements["//last-read"].attributes['type'] - end - - # Oracle and DB2 don't have true boolean or time-only fields - unless current_adapter?(:OracleAdapter, :DB2Adapter) - assert_equal "false", xml.elements["//approved"].text - assert_equal "boolean" , xml.elements["//approved"].attributes['type'] - - assert_equal bonus_time_in_current_timezone, xml.elements["//bonus-time"].text - assert_equal "datetime" , xml.elements["//bonus-time"].attributes['type'] - end - end - - def test_to_xml_skipping_attributes - xml = topics(:first).to_xml(:indent => 0, :skip_instruct => true, :except => [:title, :replies_count]) - assert_equal "", xml.first(7) - assert !xml.include?(%(The First Topic)) - assert xml.include?(%(David)) - - xml = topics(:first).to_xml(:indent => 0, :skip_instruct => true, :except => [:title, :author_name, :replies_count]) - assert !xml.include?(%(The First Topic)) - assert !xml.include?(%(David)) - end - - def test_to_xml_including_has_many_association - xml = topics(:first).to_xml(:indent => 0, :skip_instruct => true, :include => :replies, :except => :replies_count) - assert_equal "", xml.first(7) - assert xml.include?(%()) - assert xml.include?(%(The Second Topic's of the day)) - end - - def test_array_to_xml_including_has_many_association - xml = [ topics(:first), topics(:second) ].to_xml(:indent => 0, :skip_instruct => true, :include => :replies) - assert xml.include?(%()) - end - - def test_array_to_xml_including_methods - xml = [ topics(:first), topics(:second) ].to_xml(:indent => 0, :skip_instruct => true, :methods => [ :topic_id ]) - assert xml.include?(%(#{topics(:first).topic_id})), xml - assert xml.include?(%(#{topics(:second).topic_id})), xml - end - - def test_array_to_xml_including_has_one_association - xml = [ companies(:first_firm), companies(:rails_core) ].to_xml(:indent => 0, :skip_instruct => true, :include => :account) - assert xml.include?(companies(:first_firm).account.to_xml(:indent => 0, :skip_instruct => true)) - assert xml.include?(companies(:rails_core).account.to_xml(:indent => 0, :skip_instruct => true)) - end - - def test_array_to_xml_including_belongs_to_association - xml = [ companies(:first_client), companies(:second_client), companies(:another_client) ].to_xml(:indent => 0, :skip_instruct => true, :include => :firm) - assert xml.include?(companies(:first_client).to_xml(:indent => 0, :skip_instruct => true)) - assert xml.include?(companies(:second_client).firm.to_xml(:indent => 0, :skip_instruct => true)) - assert xml.include?(companies(:another_client).firm.to_xml(:indent => 0, :skip_instruct => true)) - end - - def test_to_xml_including_belongs_to_association - xml = companies(:first_client).to_xml(:indent => 0, :skip_instruct => true, :include => :firm) - assert !xml.include?("") - - xml = companies(:second_client).to_xml(:indent => 0, :skip_instruct => true, :include => :firm) - assert xml.include?("") - end - - def test_to_xml_including_multiple_associations - xml = companies(:first_firm).to_xml(:indent => 0, :skip_instruct => true, :include => [ :clients, :account ]) - assert_equal "", xml.first(6) - assert xml.include?(%()) - assert xml.include?(%()) - end - - def test_to_xml_including_multiple_associations_with_options - xml = companies(:first_firm).to_xml( - :indent => 0, :skip_instruct => true, - :include => { :clients => { :only => :name } } - ) - - assert_equal "", xml.first(6) - assert xml.include?(%(Summit)) - assert xml.include?(%()) - end - - def test_to_xml_including_methods - xml = Company.new.to_xml(:methods => :arbitrary_method, :skip_instruct => true) - assert_equal "", xml.first(9) - assert xml.include?(%(I am Jack's profound disappointment)) - end - - def test_to_xml_with_block - value = "Rockin' the block" - xml = Company.new.to_xml(:skip_instruct => true) do |xml| - xml.tag! "arbitrary-element", value - end - assert_equal "", xml.first(9) - assert xml.include?(%(#{value})) - end - - def test_except_attributes - assert_equal( - %w( author_name type id approved replies_count bonus_time written_on content author_email_address parent_id last_read).sort, - topics(:first).attributes(:except => :title).keys.sort - ) - - assert_equal( - %w( replies_count bonus_time written_on content author_email_address parent_id last_read).sort, - topics(:first).attributes(:except => [ :title, :id, :type, :approved, :author_name ]).keys.sort - ) - end - - def test_include_attributes - assert_equal(%w( title ), topics(:first).attributes(:only => :title).keys) - assert_equal(%w( title author_name type id approved ).sort, topics(:first).attributes(:only => [ :title, :id, :type, :approved, :author_name ]).keys.sort) - end - - def test_type_name_with_module_should_handle_beginning - assert_equal 'ActiveRecord::Person', ActiveRecord::Base.send(:type_name_with_module, 'Person') - assert_equal '::Person', ActiveRecord::Base.send(:type_name_with_module, '::Person') - end - - def test_to_param_should_return_string - assert_kind_of String, Client.find(:first).to_param - end - - def test_inspect_class - assert_equal 'ActiveRecord::Base', ActiveRecord::Base.inspect - assert_equal 'LoosePerson(abstract)', LoosePerson.inspect - assert_match(/^Topic\(id: integer, title: string/, Topic.inspect) - end - - def test_inspect_instance - topic = topics(:first) - assert_equal %(#), topic.inspect - end - - def test_inspect_new_instance - assert_match /Topic id: nil/, Topic.new.inspect - end - - def test_inspect_limited_select_instance - assert_equal %(#), Topic.find(:first, :select => 'id', :conditions => 'id = 1').inspect - assert_equal %(#), Topic.find(:first, :select => 'id, title', :conditions => 'id = 1').inspect - end - - def test_inspect_class_without_table - assert_equal "NonExistentTable(Table doesn't exist)", NonExistentTable.inspect - end - - def test_attribute_for_inspect - t = topics(:first) - t.title = "The First Topic Now Has A Title With\nNewlines And More Than 50 Characters" - - assert_equal %("#{t.written_on.to_s(:db)}"), t.attribute_for_inspect(:written_on) - assert_equal '"The First Topic Now Has A Title With\nNewlines And M..."', t.attribute_for_inspect(:title) - end - - def test_becomes - assert_kind_of Reply, topics(:first).becomes(Reply) - assert_equal "The First Topic", topics(:first).becomes(Reply).title - end - - def test_silence_sets_log_level_to_error_in_block - original_logger = ActiveRecord::Base.logger - log = StringIO.new - ActiveRecord::Base.logger = Logger.new(log) - ActiveRecord::Base.logger.level = Logger::DEBUG - ActiveRecord::Base.silence do - ActiveRecord::Base.logger.warn "warn" - ActiveRecord::Base.logger.error "error" - end - assert_equal "error\n", log.string - ensure - ActiveRecord::Base.logger = original_logger - end - - def test_silence_sets_log_level_back_to_level_before_yield - original_logger = ActiveRecord::Base.logger - log = StringIO.new - ActiveRecord::Base.logger = Logger.new(log) - ActiveRecord::Base.logger.level = Logger::WARN - ActiveRecord::Base.silence do - end - assert_equal Logger::WARN, ActiveRecord::Base.logger.level - ensure - ActiveRecord::Base.logger = original_logger - end - - def test_benchmark_with_log_level - original_logger = ActiveRecord::Base.logger - log = StringIO.new - ActiveRecord::Base.logger = Logger.new(log) - ActiveRecord::Base.logger.level = Logger::WARN - ActiveRecord::Base.benchmark("Debug Topic Count", Logger::DEBUG) { Topic.count } - ActiveRecord::Base.benchmark("Warn Topic Count", Logger::WARN) { Topic.count } - ActiveRecord::Base.benchmark("Error Topic Count", Logger::ERROR) { Topic.count } - assert_no_match /Debug Topic Count/, log.string - assert_match /Warn Topic Count/, log.string - assert_match /Error Topic Count/, log.string - ensure - ActiveRecord::Base.logger = original_logger - end - - def test_benchmark_with_use_silence - original_logger = ActiveRecord::Base.logger - log = StringIO.new - ActiveRecord::Base.logger = Logger.new(log) - ActiveRecord::Base.benchmark("Logging", Logger::DEBUG, true) { ActiveRecord::Base.logger.debug "Loud" } - ActiveRecord::Base.benchmark("Logging", Logger::DEBUG, false) { ActiveRecord::Base.logger.debug "Quiet" } - assert_no_match /Loud/, log.string - assert_match /Quiet/, log.string - ensure - ActiveRecord::Base.logger = original_logger - end -end Index: activerecord/test/schema_dumper_test.rb =================================================================== --- activerecord/test/schema_dumper_test.rb (revision 8601) +++ activerecord/test/schema_dumper_test.rb (working copy) @@ -1,131 +0,0 @@ -require 'abstract_unit' -require "#{File.dirname(__FILE__)}/../lib/active_record/schema_dumper" -require 'stringio' - -if ActiveRecord::Base.connection.respond_to?(:tables) - - class SchemaDumperTest < ActiveSupport::TestCase - def standard_dump - stream = StringIO.new - ActiveRecord::SchemaDumper.ignore_tables = [] - ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream) - 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 test_schema_dump_excludes_sqlite_sequence - output = standard_dump - assert_no_match %r{create_table "sqlite_sequence"}, 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 column_definition_lines(output = standard_dump) - output.scan(/^( *)create_table.*?\n(.*?)^\1end/m).map{ |m| m.last.split(/\n/) } - end - - def test_types_line_up - column_definition_lines.each do |column_set| - next if column_set.empty? - - lengths = column_set.map do |column| - if match = column.match(/t\.(?:integer|decimal|float|datetime|timestamp|time|date|text|binary|string|boolean)\s+"/) - match[0].length - end - end - - assert_equal 1, lengths.uniq.length - end - end - - def test_arguments_line_up - column_definition_lines.each do |column_set| - 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 = [/^[^r]/] - ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream) - output = stream.string - assert_match %r{:null => false}, output - end - - def test_schema_dump_with_string_ignored_table - stream = StringIO.new - - ActiveRecord::SchemaDumper.ignore_tables = ['accounts'] - ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream) - output = stream.string - assert_no_match %r{create_table "accounts"}, output - assert_match %r{create_table "authors"}, output - assert_no_match %r{create_table "schema_info"}, output - end - - - def test_schema_dump_with_regexp_ignored_table - stream = StringIO.new - - ActiveRecord::SchemaDumper.ignore_tables = [/^account/] - ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream) - output = stream.string - assert_no_match %r{create_table "accounts"}, output - assert_match %r{create_table "authors"}, output - assert_no_match %r{create_table "schema_info"}, output - end - - - def test_schema_dump_illegal_ignored_table_value - stream = StringIO.new - ActiveRecord::SchemaDumper.ignore_tables = [5] - assert_raise(StandardError) do - ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream) - end - end - - if current_adapter?(:MysqlAdapter) - def test_schema_dump_should_not_add_default_value_for_mysql_text_field - output = standard_dump - assert_match %r{t.text\s+"body",\s+:default => "",\s+:null => false$}, output - end - - def test_mysql_schema_dump_should_honor_nonstandard_primary_keys - output = standard_dump - match = output.match(%r{create_table "movies"(.*)do}) - assert_not_nil(match, "nonstandardpk table not found") - assert_match %r(:primary_key => "movieid"), match[1], "non-standard primary key not preserved" - 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 Index: activerecord/test/association_inheritance_reload.rb =================================================================== --- activerecord/test/association_inheritance_reload.rb (revision 8601) +++ activerecord/test/association_inheritance_reload.rb (working copy) @@ -1,14 +0,0 @@ -require 'abstract_unit' -require 'fixtures/company' - -class AssociationInheritanceReloadTest < ActiveSupport::TestCase - fixtures :companies - - def test_set_attributes - assert_equal ["errors.add_on_empty('name', \"can't be empty\")"], Firm.read_inheritable_attribute("validate"), "Second run" - # ActiveRecord::Base.reset_column_information_and_inheritable_attributes_for_all_subclasses - remove_subclass_of(ActiveRecord::Base) - load 'fixtures/company.rb' - assert_equal ["errors.add_on_empty('name', \"can't be empty\")"], Firm.read_inheritable_attribute("validate"), "Second run" - end -end \ No newline at end of file Index: activerecord/test/callbacks_test.rb =================================================================== --- activerecord/test/callbacks_test.rb (revision 8601) +++ activerecord/test/callbacks_test.rb (working copy) @@ -1,400 +0,0 @@ -require 'abstract_unit' - -class CallbackDeveloper < ActiveRecord::Base - set_table_name 'developers' - - class << self - def callback_string(callback_method) - "history << [#{callback_method.to_sym.inspect}, :string]" - end - - def callback_proc(callback_method) - Proc.new { |model| model.history << [callback_method, :proc] } - end - - def define_callback_method(callback_method) - define_method("#{callback_method}_method") do |model| - model.history << [callback_method, :method] - end - end - - def callback_object(callback_method) - klass = Class.new - klass.send(:define_method, callback_method) do |model| - model.history << [callback_method, :object] - end - klass.new - end - end - - ActiveRecord::Callbacks::CALLBACKS.each do |callback_method| - callback_method_sym = callback_method.to_sym - define_callback_method(callback_method_sym) - send(callback_method, callback_method_sym) - send(callback_method, callback_string(callback_method_sym)) - send(callback_method, callback_proc(callback_method_sym)) - send(callback_method, callback_object(callback_method_sym)) - send(callback_method) { |model| model.history << [callback_method_sym, :block] } - end - - def history - @history ||= [] - end - - # after_initialize and after_find are invoked only if instance methods have been defined. - def after_initialize - end - - def after_find - end -end - -class ParentDeveloper < ActiveRecord::Base - set_table_name 'developers' - attr_accessor :after_save_called - before_validation {|record| record.after_save_called = true} -end - -class ChildDeveloper < ParentDeveloper - -end - -class RecursiveCallbackDeveloper < ActiveRecord::Base - set_table_name 'developers' - - before_save :on_before_save - after_save :on_after_save - - attr_reader :on_before_save_called, :on_after_save_called - - def on_before_save - @on_before_save_called ||= 0 - @on_before_save_called += 1 - save unless @on_before_save_called > 1 - end - - def on_after_save - @on_after_save_called ||= 0 - @on_after_save_called += 1 - save unless @on_after_save_called > 1 - 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 CallbackCancellationDeveloper < ActiveRecord::Base - set_table_name 'developers' - def before_create - false - end -end - -class CallbacksTest < ActiveSupport::TestCase - fixtures :developers - - def test_initialize - david = CallbackDeveloper.new - assert_equal [ - [ :after_initialize, :string ], - [ :after_initialize, :proc ], - [ :after_initialize, :object ], - [ :after_initialize, :block ], - ], david.history - end - - def test_find - david = CallbackDeveloper.find(1) - assert_equal [ - [ :after_find, :string ], - [ :after_find, :proc ], - [ :after_find, :object ], - [ :after_find, :block ], - [ :after_initialize, :string ], - [ :after_initialize, :proc ], - [ :after_initialize, :object ], - [ :after_initialize, :block ], - ], david.history - end - - def test_new_valid? - david = CallbackDeveloper.new - david.valid? - assert_equal [ - [ :after_initialize, :string ], - [ :after_initialize, :proc ], - [ :after_initialize, :object ], - [ :after_initialize, :block ], - [ :before_validation, :string ], - [ :before_validation, :proc ], - [ :before_validation, :object ], - [ :before_validation, :block ], - [ :before_validation_on_create, :string ], - [ :before_validation_on_create, :proc ], - [ :before_validation_on_create, :object ], - [ :before_validation_on_create, :block ], - [ :after_validation, :string ], - [ :after_validation, :proc ], - [ :after_validation, :object ], - [ :after_validation, :block ], - [ :after_validation_on_create, :string ], - [ :after_validation_on_create, :proc ], - [ :after_validation_on_create, :object ], - [ :after_validation_on_create, :block ] - ], david.history - end - - def test_existing_valid? - david = CallbackDeveloper.find(1) - david.valid? - assert_equal [ - [ :after_find, :string ], - [ :after_find, :proc ], - [ :after_find, :object ], - [ :after_find, :block ], - [ :after_initialize, :string ], - [ :after_initialize, :proc ], - [ :after_initialize, :object ], - [ :after_initialize, :block ], - [ :before_validation, :string ], - [ :before_validation, :proc ], - [ :before_validation, :object ], - [ :before_validation, :block ], - [ :before_validation_on_update, :string ], - [ :before_validation_on_update, :proc ], - [ :before_validation_on_update, :object ], - [ :before_validation_on_update, :block ], - [ :after_validation, :string ], - [ :after_validation, :proc ], - [ :after_validation, :object ], - [ :after_validation, :block ], - [ :after_validation_on_update, :string ], - [ :after_validation_on_update, :proc ], - [ :after_validation_on_update, :object ], - [ :after_validation_on_update, :block ] - ], david.history - end - - def test_create - david = CallbackDeveloper.create('name' => 'David', 'salary' => 1000000) - assert_equal [ - [ :after_initialize, :string ], - [ :after_initialize, :proc ], - [ :after_initialize, :object ], - [ :after_initialize, :block ], - [ :before_validation, :string ], - [ :before_validation, :proc ], - [ :before_validation, :object ], - [ :before_validation, :block ], - [ :before_validation_on_create, :string ], - [ :before_validation_on_create, :proc ], - [ :before_validation_on_create, :object ], - [ :before_validation_on_create, :block ], - [ :after_validation, :string ], - [ :after_validation, :proc ], - [ :after_validation, :object ], - [ :after_validation, :block ], - [ :after_validation_on_create, :string ], - [ :after_validation_on_create, :proc ], - [ :after_validation_on_create, :object ], - [ :after_validation_on_create, :block ], - [ :before_save, :string ], - [ :before_save, :proc ], - [ :before_save, :object ], - [ :before_save, :block ], - [ :before_create, :string ], - [ :before_create, :proc ], - [ :before_create, :object ], - [ :before_create, :block ], - [ :after_create, :string ], - [ :after_create, :proc ], - [ :after_create, :object ], - [ :after_create, :block ], - [ :after_save, :string ], - [ :after_save, :proc ], - [ :after_save, :object ], - [ :after_save, :block ] - ], david.history - end - - def test_save - david = CallbackDeveloper.find(1) - david.save - assert_equal [ - [ :after_find, :string ], - [ :after_find, :proc ], - [ :after_find, :object ], - [ :after_find, :block ], - [ :after_initialize, :string ], - [ :after_initialize, :proc ], - [ :after_initialize, :object ], - [ :after_initialize, :block ], - [ :before_validation, :string ], - [ :before_validation, :proc ], - [ :before_validation, :object ], - [ :before_validation, :block ], - [ :before_validation_on_update, :string ], - [ :before_validation_on_update, :proc ], - [ :before_validation_on_update, :object ], - [ :before_validation_on_update, :block ], - [ :after_validation, :string ], - [ :after_validation, :proc ], - [ :after_validation, :object ], - [ :after_validation, :block ], - [ :after_validation_on_update, :string ], - [ :after_validation_on_update, :proc ], - [ :after_validation_on_update, :object ], - [ :after_validation_on_update, :block ], - [ :before_save, :string ], - [ :before_save, :proc ], - [ :before_save, :object ], - [ :before_save, :block ], - [ :before_update, :string ], - [ :before_update, :proc ], - [ :before_update, :object ], - [ :before_update, :block ], - [ :after_update, :string ], - [ :after_update, :proc ], - [ :after_update, :object ], - [ :after_update, :block ], - [ :after_save, :string ], - [ :after_save, :proc ], - [ :after_save, :object ], - [ :after_save, :block ] - ], david.history - end - - def test_destroy - david = CallbackDeveloper.find(1) - david.destroy - assert_equal [ - [ :after_find, :string ], - [ :after_find, :proc ], - [ :after_find, :object ], - [ :after_find, :block ], - [ :after_initialize, :string ], - [ :after_initialize, :proc ], - [ :after_initialize, :object ], - [ :after_initialize, :block ], - [ :before_destroy, :string ], - [ :before_destroy, :proc ], - [ :before_destroy, :object ], - [ :before_destroy, :block ], - [ :after_destroy, :string ], - [ :after_destroy, :proc ], - [ :after_destroy, :object ], - [ :after_destroy, :block ] - ], david.history - end - - def test_delete - david = CallbackDeveloper.find(1) - CallbackDeveloper.delete(david.id) - assert_equal [ - [ :after_find, :string ], - [ :after_find, :proc ], - [ :after_find, :object ], - [ :after_find, :block ], - [ :after_initialize, :string ], - [ :after_initialize, :proc ], - [ :after_initialize, :object ], - [ :after_initialize, :block ], - ], david.history - end - - def test_before_save_returning_false - david = ImmutableDeveloper.find(1) - assert david.valid? - assert !david.save - assert_raises(ActiveRecord::RecordNotSaved) { david.save! } - - david = ImmutableDeveloper.find(1) - david.salary = 10_000_000 - assert !david.valid? - assert !david.save - assert_raises(ActiveRecord::RecordInvalid) { david.save! } - end - - def test_before_create_returning_false - someone = CallbackCancellationDeveloper.new - assert someone.valid? - assert !someone.save - end - - def test_before_destroy_returning_false - david = ImmutableDeveloper.find(1) - assert !david.destroy - assert_not_nil ImmutableDeveloper.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 } - CallbackDeveloper.before_validation proc { |model| model.history << [:before_validation, :should_never_get_here] } - david.save - assert_equal [ - [ :after_find, :string ], - [ :after_find, :proc ], - [ :after_find, :object ], - [ :after_find, :block ], - [ :after_initialize, :string ], - [ :after_initialize, :proc ], - [ :after_initialize, :object ], - [ :after_initialize, :block ], - [ :before_validation, :string ], - [ :before_validation, :proc ], - [ :before_validation, :object ], - [ :before_validation, :block ], - [ :before_validation, :returning_false ] - ], david.history - end - - def test_inheritence_of_callbacks - parent = ParentDeveloper.new - assert !parent.after_save_called - parent.save - assert parent.after_save_called - - child = ChildDeveloper.new - assert !child.after_save_called - child.save - assert child.after_save_called - end - -end Index: activerecord/test/adapter_test.rb =================================================================== --- activerecord/test/adapter_test.rb (revision 8601) +++ activerecord/test/adapter_test.rb (working copy) @@ -1,106 +0,0 @@ -require 'abstract_unit' - -class AdapterTest < ActiveSupport::TestCase - def setup - @connection = ActiveRecord::Base.connection - end - - def test_tables - if @connection.respond_to?(:tables) - tables = @connection.tables - assert tables.include?("accounts") - assert tables.include?("authors") - assert tables.include?("tasks") - assert tables.include?("topics") - else - warn "#{@connection.class} does not respond to #tables" - end - end - - def test_indexes - idx_name = "accounts_idx" - - if @connection.respond_to?(:indexes) - indexes = @connection.indexes("accounts") - assert indexes.empty? - - @connection.add_index :accounts, :firm_id, :name => idx_name - indexes = @connection.indexes("accounts") - assert_equal "accounts", indexes.first.table - # OpenBase does not have the concept of a named index - # Indexes are merely properties of columns. - assert_equal idx_name, indexes.first.name unless current_adapter?(:OpenBaseAdapter) - assert !indexes.first.unique - assert_equal ["firm_id"], indexes.first.columns - else - warn "#{@connection.class} does not respond to #indexes" - end - - ensure - @connection.remove_index(:accounts, :name => idx_name) rescue nil - end - - def test_current_database - if @connection.respond_to?(:current_database) - assert_equal ENV['ARUNIT_DB_NAME'] || "activerecord_unittest", @connection.current_database - end - end - - if current_adapter?(:MysqlAdapter) - def test_charset - assert_not_nil @connection.charset - assert_not_equal 'character_set_database', @connection.charset - assert_equal @connection.show_variable('character_set_database'), @connection.charset - end - - def test_collation - assert_not_nil @connection.collation - assert_not_equal 'collation_database', @connection.collation - assert_equal @connection.show_variable('collation_database'), @connection.collation - end - - def test_show_nonexistent_variable_returns_nil - assert_nil @connection.show_variable('foo_bar_baz') - end - end - - def test_table_alias - def @connection.test_table_alias_length() 10; end - class << @connection - alias_method :old_table_alias_length, :table_alias_length - alias_method :table_alias_length, :test_table_alias_length - end - - assert_equal 'posts', @connection.table_alias_for('posts') - assert_equal 'posts_comm', @connection.table_alias_for('posts_comments') - assert_equal 'dbo_posts', @connection.table_alias_for('dbo.posts') - - class << @connection - remove_method :table_alias_length - alias_method :table_alias_length, :old_table_alias_length - end - end - - # test resetting sequences in odd tables in postgreSQL - if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!) - require 'fixtures/movie' - require 'fixtures/subscriber' - - def test_reset_empty_table_with_custom_pk - Movie.delete_all - Movie.connection.reset_pk_sequence! 'movies' - assert_equal 1, Movie.create(:name => 'fight club').id - end - - if ActiveRecord::Base.connection.adapter_name != "FrontBase" - def test_reset_table_with_non_integer_pk - Subscriber.delete_all - Subscriber.connection.reset_pk_sequence! 'subscribers' - sub = Subscriber.new(:name => 'robert drake') - sub.id = 'bob drake' - assert_nothing_raised { sub.save! } - end - end - end - -end Index: activerecord/test/active_schema_test_mysql.rb =================================================================== --- activerecord/test/active_schema_test_mysql.rb (revision 8601) +++ activerecord/test/active_schema_test_mysql.rb (working copy) @@ -1,46 +0,0 @@ -require 'abstract_unit' - -class ActiveSchemaTest < ActiveSupport::TestCase - def setup - ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do - alias_method :execute_without_stub, :execute - def execute(sql, name = nil) return sql end - end - end - - def teardown - ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do - remove_method :execute - alias_method :execute, :execute_without_stub - end - end - - def test_drop_table - assert_equal "DROP TABLE `people`", drop_table(:people) - end - - if current_adapter?(:MysqlAdapter) - def test_create_mysql_database_with_encoding - assert_equal "CREATE DATABASE `matt` DEFAULT CHARACTER SET `utf8`", create_database(:matt) - assert_equal "CREATE DATABASE `aimonetti` DEFAULT CHARACTER SET `latin1`", create_database(:aimonetti, {:charset => 'latin1'}) - assert_equal "CREATE DATABASE `matt_aimonetti` DEFAULT CHARACTER SET `big5` COLLATE `big5_chinese_ci`", create_database(:matt_aimonetti, {:charset => :big5, :collation => :big5_chinese_ci}) - end - end - - def test_add_column - assert_equal "ALTER TABLE `people` ADD `last_name` varchar(255)", add_column(:people, :last_name, :string) - end - - def test_add_column_with_limit - assert_equal "ALTER TABLE `people` ADD `key` varchar(32)", add_column(:people, :key, :string, :limit => 32) - end - - def test_drop_table_with_specific_database - assert_equal "DROP TABLE `otherdb`.`people`", drop_table('otherdb.people') - end - - private - def method_missing(method_symbol, *arguments) - ActiveRecord::Base.connection.send(method_symbol, *arguments) - end -end Index: activerecord/test/calculations_test.rb =================================================================== --- activerecord/test/calculations_test.rb (revision 8601) +++ activerecord/test/calculations_test.rb (working copy) @@ -1,251 +0,0 @@ -require 'abstract_unit' -require 'fixtures/company' -require 'fixtures/topic' - -Company.has_many :accounts - -class NumericData < ActiveRecord::Base - self.table_name = 'numeric_data' -end - -class CalculationsTest < ActiveSupport::TestCase - fixtures :companies, :accounts, :topics - - def test_should_sum_field - assert_equal 318, Account.sum(:credit_limit) - end - - def test_should_average_field - value = Account.average(:credit_limit) - assert_kind_of Float, value - assert_in_delta 53.0, value, 0.001 - end - - def test_should_return_nil_as_average - assert_nil NumericData.average(:bank_balance) - end - - def test_should_get_maximum_of_field - assert_equal 60, Account.maximum(:credit_limit) - end - - def test_should_get_maximum_of_field_with_include - assert_equal 50, Account.maximum(:credit_limit, :include => :firm, :conditions => "companies.name != 'Summit'") - end - - def test_should_get_maximum_of_field_with_scoped_include - Account.with_scope :find => { :include => :firm, :conditions => "companies.name != 'Summit'" } do - assert_equal 50, Account.maximum(:credit_limit) - end - end - - def test_should_get_minimum_of_field - assert_equal 50, Account.minimum(:credit_limit) - end - - def test_should_group_by_field - c = Account.sum(:credit_limit, :group => :firm_id) - [1,6,2].each { |firm_id| assert c.keys.include?(firm_id) } - end - - def test_should_group_by_summed_field - c = Account.sum(:credit_limit, :group => :firm_id) - assert_equal 50, c[1] - assert_equal 105, c[6] - assert_equal 60, c[2] - end - - def test_should_order_by_grouped_field - c = Account.sum(:credit_limit, :group => :firm_id, :order => "firm_id") - assert_equal [1, 2, 6, 9], c.keys.compact - end - - def test_should_order_by_calculation - c = Account.sum(:credit_limit, :group => :firm_id, :order => "sum_credit_limit desc, firm_id") - assert_equal [105, 60, 53, 50, 50], c.keys.collect { |k| c[k] } - assert_equal [6, 2, 9, 1], c.keys.compact - end - - def test_should_limit_calculation - c = Account.sum(:credit_limit, :conditions => "firm_id IS NOT NULL", - :group => :firm_id, :order => "firm_id", :limit => 2) - assert_equal [1, 2], c.keys.compact - end - - def test_should_limit_calculation_with_offset - c = Account.sum(:credit_limit, :conditions => "firm_id IS NOT NULL", - :group => :firm_id, :order => "firm_id", :limit => 2, :offset => 1) - assert_equal [2, 6], c.keys.compact - end - - def test_should_group_by_summed_field_having_condition - c = Account.sum(:credit_limit, :group => :firm_id, - :having => 'sum(credit_limit) > 50') - assert_nil c[1] - assert_equal 105, c[6] - assert_equal 60, c[2] - end - - def test_should_group_by_summed_association - c = Account.sum(:credit_limit, :group => :firm) - assert_equal 50, c[companies(:first_firm)] - assert_equal 105, c[companies(:rails_core)] - assert_equal 60, c[companies(:first_client)] - end - - def test_should_sum_field_with_conditions - assert_equal 105, Account.sum(:credit_limit, :conditions => 'firm_id = 6') - end - - def test_should_group_by_summed_field_with_conditions - c = Account.sum(:credit_limit, :conditions => 'firm_id > 1', - :group => :firm_id) - assert_nil c[1] - assert_equal 105, c[6] - assert_equal 60, c[2] - end - - def test_should_group_by_summed_field_with_conditions_and_having - c = Account.sum(:credit_limit, :conditions => 'firm_id > 1', - :group => :firm_id, - :having => 'sum(credit_limit) > 60') - assert_nil c[1] - assert_equal 105, c[6] - assert_nil c[2] - end - - def test_should_group_by_fields_with_table_alias - c = Account.sum(:credit_limit, :group => 'accounts.firm_id') - assert_equal 50, c[1] - assert_equal 105, c[6] - assert_equal 60, c[2] - end - - def test_should_calculate_with_invalid_field - assert_equal 6, Account.calculate(:count, '*') - assert_equal 6, Account.calculate(:count, :all) - end - - def test_should_calculate_grouped_with_invalid_field - c = Account.count(:all, :group => 'accounts.firm_id') - assert_equal 1, c[1] - assert_equal 2, c[6] - assert_equal 1, c[2] - end - - def test_should_calculate_grouped_association_with_invalid_field - c = Account.count(:all, :group => :firm) - assert_equal 1, c[companies(:first_firm)] - assert_equal 2, c[companies(:rails_core)] - assert_equal 1, c[companies(:first_client)] - end - - uses_mocha 'group_by_non_numeric_foreign_key_association' do - def test_should_group_by_association_with_non_numeric_foreign_key - ActiveRecord::Base.connection.expects(:select_all).returns([{"count_all" => 1, "firm_id" => "ABC"}]) - - firm = mock() - firm.expects(:id).returns("ABC") - firm.expects(:class).returns(Firm) - Company.expects(:find).with(["ABC"]).returns([firm]) - - column = mock() - column.expects(:name).at_least_once.returns(:firm_id) - column.expects(:type_cast).with("ABC").returns("ABC") - Account.expects(:columns).at_least_once.returns([column]) - - c = Account.count(:all, :group => :firm) - assert_equal Firm, c.first.first.class - assert_equal 1, c.first.last - end - end - - def test_should_not_modify_options_when_using_includes - options = {:conditions => 'companies.id > 1', :include => :firm} - options_copy = options.dup - - Account.count(:all, options) - assert_equal options_copy, options - end - - def test_should_calculate_grouped_by_function - c = Company.count(:all, :group => "UPPER(#{QUOTED_TYPE})") - assert_equal 2, c[nil] - assert_equal 1, c['DEPENDENTFIRM'] - assert_equal 3, c['CLIENT'] - assert_equal 2, c['FIRM'] - end - - def test_should_calculate_grouped_by_function_with_table_alias - c = Company.count(:all, :group => "UPPER(companies.#{QUOTED_TYPE})") - assert_equal 2, c[nil] - assert_equal 1, c['DEPENDENTFIRM'] - assert_equal 3, c['CLIENT'] - assert_equal 2, c['FIRM'] - end - - def test_should_not_overshadow_enumerable_sum - assert_equal 6, [1, 2, 3].sum(&:abs) - end - - def test_should_sum_scoped_field - assert_equal 15, companies(:rails_core).companies.sum(:id) - end - - def test_should_sum_scoped_field_with_conditions - assert_equal 8, companies(:rails_core).companies.sum(:id, :conditions => 'id > 7') - end - - def test_should_group_by_scoped_field - c = companies(:rails_core).companies.sum(:id, :group => :name) - assert_equal 7, c['Leetsoft'] - assert_equal 8, c['Jadedpixel'] - end - - def test_should_group_by_summed_field_with_conditions_and_having - c = companies(:rails_core).companies.sum(:id, :group => :name, - :having => 'sum(id) > 7') - assert_nil c['Leetsoft'] - assert_equal 8, c['Jadedpixel'] - end - - def test_should_reject_invalid_options - assert_nothing_raised do - [:count, :sum].each do |func| - # empty options are valid - Company.send(:validate_calculation_options, func) - # these options are valid for all calculations - [:select, :conditions, :joins, :order, :group, :having, :distinct].each do |opt| - Company.send(:validate_calculation_options, func, opt => true) - end - end - - # :include is only valid on :count - Company.send(:validate_calculation_options, :count, :include => true) - end - - assert_raises(ArgumentError) { Company.send(:validate_calculation_options, :sum, :foo => :bar) } - assert_raises(ArgumentError) { Company.send(:validate_calculation_options, :count, :foo => :bar) } - end - - def test_should_count_selected_field_with_include - assert_equal 6, Account.count(:distinct => true, :include => :firm) - assert_equal 4, Account.count(:distinct => true, :include => :firm, :select => :credit_limit) - end - - def test_count_with_column_parameter - assert_equal 5, Account.count(:firm_id) - end - - def test_count_with_column_and_options_parameter - assert_equal 2, Account.count(:firm_id, :conditions => "credit_limit = 50") - end - - def test_count_with_no_parameters_isnt_deprecated - assert_not_deprecated { Account.count } - end - - def test_count_with_too_many_parameters_raises - assert_raise(ArgumentError) { Account.count(1, 2, 3) } - end -end Index: activerecord/test/class_inheritable_attributes_test.rb =================================================================== --- activerecord/test/class_inheritable_attributes_test.rb (revision 8601) +++ activerecord/test/class_inheritable_attributes_test.rb (working copy) @@ -1,32 +0,0 @@ -require 'test/unit' -require 'abstract_unit' -require 'active_support/core_ext/class/inheritable_attributes' - -class A - include ClassInheritableAttributes -end - -class B < A - write_inheritable_array "first", [ :one, :two ] -end - -class C < A - write_inheritable_array "first", [ :three ] -end - -class D < B - write_inheritable_array "first", [ :four ] -end - - -class ClassInheritableAttributesTest < ActiveSupport::TestCase - def test_first_level - assert_equal [ :one, :two ], B.read_inheritable_attribute("first") - assert_equal [ :three ], C.read_inheritable_attribute("first") - end - - def test_second_level - assert_equal [ :one, :two, :four ], D.read_inheritable_attribute("first") - assert_equal [ :one, :two ], B.read_inheritable_attribute("first") - end -end Index: activerecord/test/threaded_connections_test.rb =================================================================== --- activerecord/test/threaded_connections_test.rb (revision 8601) +++ activerecord/test/threaded_connections_test.rb (working copy) @@ -1,48 +0,0 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/reply' - -unless %w(FrontBase).include? ActiveRecord::Base.connection.adapter_name - class ThreadedConnectionsTest < ActiveSupport::TestCase - self.use_transactional_fixtures = false - - fixtures :topics - - def setup - @connection = ActiveRecord::Base.remove_connection - @connections = [] - @allow_concurrency = ActiveRecord::Base.allow_concurrency - end - - def teardown - # clear the connection cache - ActiveRecord::Base.send(:clear_all_cached_connections!) - # set allow_concurrency to saved value - ActiveRecord::Base.allow_concurrency = @allow_concurrency - # reestablish old connection - ActiveRecord::Base.establish_connection(@connection) - end - - def gather_connections(use_threaded_connections) - ActiveRecord::Base.allow_concurrency = use_threaded_connections - ActiveRecord::Base.establish_connection(@connection) - - 5.times do - Thread.new do - Topic.find :first - @connections << ActiveRecord::Base.active_connections.values.first - end.join - end - end - - def test_threaded_connections - gather_connections(true) - assert_equal @connections.uniq.length, 5 - end - - def test_unthreaded_connections - gather_connections(false) - assert_equal @connections.uniq.length, 1 - end - end -end Index: activerecord/test/schema_test_postgresql.rb =================================================================== --- activerecord/test/schema_test_postgresql.rb (revision 8601) +++ activerecord/test/schema_test_postgresql.rb (working copy) @@ -1,64 +0,0 @@ -require 'abstract_unit' - -class SchemaTest < ActiveSupport::TestCase - self.use_transactional_fixtures = false - - SCHEMA_NAME = 'test_schema' - TABLE_NAME = 'things' - COLUMNS = [ - 'id integer', - 'name character varying(50)', - 'moment timestamp without time zone default now()' - ] - - def setup - @connection = ActiveRecord::Base.connection - @connection.execute "CREATE SCHEMA #{SCHEMA_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})" - end - - def teardown - @connection.execute "DROP SCHEMA #{SCHEMA_NAME} CASCADE" - end - - def test_with_schema_prefixed_table_name - assert_nothing_raised do - assert_equal COLUMNS, columns("#{SCHEMA_NAME}.#{TABLE_NAME}") - end - end - - def test_with_schema_search_path - assert_nothing_raised do - with_schema_search_path(SCHEMA_NAME) do - assert_equal COLUMNS, columns(TABLE_NAME) - end - end - end - - def test_raise_on_unquoted_schema_name - assert_raise(ActiveRecord::StatementInvalid) do - with_schema_search_path '$user,public' - end - end - - def test_without_schema_search_path - assert_raise(ActiveRecord::StatementInvalid) { columns(TABLE_NAME) } - end - - def test_ignore_nil_schema_search_path - assert_nothing_raised { with_schema_search_path nil } - end - - private - def columns(table_name) - @connection.send(:column_definitions, table_name).map do |name, type, default| - "#{name} #{type}" + (default ? " default #{default}" : '') - end - end - - def with_schema_search_path(schema_search_path) - @connection.schema_search_path = schema_search_path - yield if block_given? - ensure - @connection.schema_search_path = "'$user', public" - end -end Index: activerecord/test/binary_test.rb =================================================================== --- activerecord/test/binary_test.rb (revision 8601) +++ activerecord/test/binary_test.rb (working copy) @@ -1,32 +0,0 @@ -require 'abstract_unit' - -# 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 or Firebird, because the length of a statement -# is limited to 32KB. -unless current_adapter?(:SQLServerAdapter, :SybaseAdapter, :DB2Adapter, :FirebirdAdapter) - require 'fixtures/binary' - - class BinaryTest < ActiveSupport::TestCase - FIXTURES = %w(flowers.jpg example.log) - - def test_load_save - Binary.delete_all - - FIXTURES.each do |filename| - data = File.read("#{File.dirname(__FILE__)}/fixtures/#{filename}").freeze - - bin = Binary.new(:data => data) - assert_equal data, bin.data, 'Newly assigned data differs from original' - - bin.save! - assert_equal data, bin.data, 'Data differs from original after save' - - assert_equal data, bin.reload.data, 'Reloaded data differs from original' - end - end - end -end Index: activerecord/test/adapter_test_sqlserver.rb =================================================================== --- activerecord/test/adapter_test_sqlserver.rb (revision 8601) +++ activerecord/test/adapter_test_sqlserver.rb (working copy) @@ -1,95 +0,0 @@ -require 'abstract_unit' -require 'fixtures/default' -require 'fixtures/post' -require 'fixtures/task' - -class SqlServerAdapterTest < ActiveSupport::TestCase - class TableWithRealColumn < ActiveRecord::Base; end - - fixtures :posts, :tasks - - def setup - @connection = ActiveRecord::Base.connection - end - - def teardown - @connection.execute("SET LANGUAGE us_english") rescue nil - end - - def test_real_column_has_float_type - assert_equal :float, TableWithRealColumn.columns_hash["real_number"].type - end - - # SQL Server 2000 has a bug where some unambiguous date formats are not - # correctly identified if the session language is set to german - def test_date_insertion_when_language_is_german - @connection.execute("SET LANGUAGE deutsch") - - assert_nothing_raised do - Task.create(:starting => Time.utc(2000, 1, 31, 5, 42, 0), :ending => Date.new(2006, 12, 31)) - end - end - - def test_indexes_with_descending_order - # Make sure we have an index with descending order - @connection.execute "CREATE INDEX idx_credit_limit ON accounts (credit_limit DESC)" rescue nil - assert_equal ["credit_limit"], @connection.indexes('accounts').first.columns - ensure - @connection.execute "DROP INDEX accounts.idx_credit_limit" - end - - def test_execute_without_block_closes_statement - assert_all_statements_used_are_closed do - @connection.execute("SELECT 1") - end - end - - def test_execute_with_block_closes_statement - assert_all_statements_used_are_closed do - @connection.execute("SELECT 1") do |sth| - assert !sth.finished?, "Statement should still be alive within block" - end - end - end - - def test_insert_with_identity_closes_statement - assert_all_statements_used_are_closed do - @connection.insert("INSERT INTO accounts ([id], [firm_id],[credit_limit]) values (999, 1, 50)") - end - end - - def test_insert_without_identity_closes_statement - assert_all_statements_used_are_closed do - @connection.insert("INSERT INTO accounts ([firm_id],[credit_limit]) values (1, 50)") - end - end - - def test_active_closes_statement - assert_all_statements_used_are_closed do - @connection.active? - end - end - - def assert_all_statements_used_are_closed(&block) - existing_handles = [] - ObjectSpace.each_object(DBI::StatementHandle) {|handle| existing_handles << handle} - GC.disable - - yield - - used_handles = [] - ObjectSpace.each_object(DBI::StatementHandle) {|handle| used_handles << handle unless existing_handles.include? handle} - - assert_block "No statements were used within given block" do - used_handles.size > 0 - end - - ObjectSpace.each_object(DBI::StatementHandle) do |handle| - assert_block "Statement should have been closed within given block" do - handle.finished? - end - end - ensure - GC.enable - end -end Index: activerecord/test/deprecated_finder_test.rb =================================================================== --- activerecord/test/deprecated_finder_test.rb (revision 8601) +++ activerecord/test/deprecated_finder_test.rb (working copy) @@ -1,30 +0,0 @@ -require 'abstract_unit' -require 'fixtures/entrant' - -class DeprecatedFinderTest < ActiveSupport::TestCase - fixtures :entrants - - def test_deprecated_find_all_was_removed - assert_raise(NoMethodError) { Entrant.find_all } - end - - def test_deprecated_find_first_was_removed - assert_raise(NoMethodError) { Entrant.find_first } - end - - def test_deprecated_find_on_conditions_was_removed - assert_raise(NoMethodError) { Entrant.find_on_conditions } - end - - def test_count - assert_equal(0, Entrant.count(:conditions => "id > 3")) - assert_equal(1, Entrant.count(:conditions => ["id > ?", 2])) - assert_equal(2, Entrant.count(:conditions => ["id > ?", 1])) - end - - def test_count_by_sql - assert_equal(0, Entrant.count_by_sql("SELECT COUNT(*) FROM entrants WHERE id > 3")) - assert_equal(1, Entrant.count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 2])) - assert_equal(2, Entrant.count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 1])) - end -end Index: activerecord/test/inheritance_test.rb =================================================================== --- activerecord/test/inheritance_test.rb (revision 8601) +++ activerecord/test/inheritance_test.rb (working copy) @@ -1,211 +0,0 @@ -require 'abstract_unit' -require 'fixtures/company' -require 'fixtures/project' -require 'fixtures/subscriber' - -class InheritanceTest < ActiveSupport::TestCase - fixtures :companies, :projects, :subscribers, :accounts - - def test_company_descends_from_active_record - assert_raise(NoMethodError) { ActiveRecord::Base.descends_from_active_record? } - assert AbstractCompany.descends_from_active_record?, 'AbstractCompany should descend from ActiveRecord::Base' - assert Company.descends_from_active_record?, 'Company should descend from ActiveRecord::Base' - assert !Class.new(Company).descends_from_active_record?, 'Company subclass should not descend from ActiveRecord::Base' - end - - def test_a_bad_type_column - #SQLServer need to turn Identity Insert On before manually inserting into the Identity column - if current_adapter?(:SQLServerAdapter, :SybaseAdapter) - Company.connection.execute "SET IDENTITY_INSERT companies ON" - end - Company.connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')" - - #We then need to turn it back Off before continuing. - if current_adapter?(:SQLServerAdapter, :SybaseAdapter) - Company.connection.execute "SET IDENTITY_INSERT companies OFF" - end - assert_raises(ActiveRecord::SubclassNotFound) { Company.find(100) } - end - - def test_inheritance_find - assert Company.find(1).kind_of?(Firm), "37signals should be a firm" - assert Firm.find(1).kind_of?(Firm), "37signals should be a firm" - assert Company.find(2).kind_of?(Client), "Summit should be a client" - assert Client.find(2).kind_of?(Client), "Summit should be a client" - end - - def test_alt_inheritance_find - switch_to_alt_inheritance_column - test_inheritance_find - switch_to_default_inheritance_column - end - - def test_inheritance_find_all - companies = Company.find(:all, :order => 'id') - assert companies[0].kind_of?(Firm), "37signals should be a firm" - assert companies[1].kind_of?(Client), "Summit should be a client" - end - - def test_alt_inheritance_find_all - switch_to_alt_inheritance_column - test_inheritance_find_all - switch_to_default_inheritance_column - end - - def test_inheritance_save - firm = Firm.new - firm.name = "Next Angle" - firm.save - - next_angle = Company.find(firm.id) - assert next_angle.kind_of?(Firm), "Next Angle should be a firm" - end - - def test_alt_inheritance_save - switch_to_alt_inheritance_column - test_inheritance_save - switch_to_default_inheritance_column - end - - def test_inheritance_condition - assert_equal 9, Company.count - assert_equal 2, Firm.count - assert_equal 3, Client.count - end - - def test_alt_inheritance_condition - switch_to_alt_inheritance_column - test_inheritance_condition - switch_to_default_inheritance_column - end - - def test_finding_incorrect_type_data - assert_raises(ActiveRecord::RecordNotFound) { Firm.find(2) } - assert_nothing_raised { Firm.find(1) } - end - - def test_alt_finding_incorrect_type_data - switch_to_alt_inheritance_column - test_finding_incorrect_type_data - switch_to_default_inheritance_column - end - - def test_update_all_within_inheritance - Client.update_all "name = 'I am a client'" - assert_equal "I am a client", Client.find(:all).first.name - assert_equal "37signals", Firm.find(:all).first.name - end - - def test_alt_update_all_within_inheritance - switch_to_alt_inheritance_column - test_update_all_within_inheritance - switch_to_default_inheritance_column - end - - def test_destroy_all_within_inheritance - Client.destroy_all - assert_equal 0, Client.count - assert_equal 2, Firm.count - end - - def test_alt_destroy_all_within_inheritance - switch_to_alt_inheritance_column - test_destroy_all_within_inheritance - switch_to_default_inheritance_column - end - - def test_find_first_within_inheritance - assert_kind_of Firm, Company.find(:first, :conditions => "name = '37signals'") - assert_kind_of Firm, Firm.find(:first, :conditions => "name = '37signals'") - assert_nil Client.find(:first, :conditions => "name = '37signals'") - end - - def test_alt_find_first_within_inheritance - switch_to_alt_inheritance_column - test_find_first_within_inheritance - switch_to_default_inheritance_column - end - - def test_complex_inheritance - very_special_client = VerySpecialClient.create("name" => "veryspecial") - assert_equal very_special_client, VerySpecialClient.find(:first, :conditions => "name = 'veryspecial'") - assert_equal very_special_client, SpecialClient.find(:first, :conditions => "name = 'veryspecial'") - assert_equal very_special_client, Company.find(:first, :conditions => "name = 'veryspecial'") - assert_equal very_special_client, Client.find(:first, :conditions => "name = 'veryspecial'") - assert_equal 1, Client.find(:all, :conditions => "name = 'Summit'").size - assert_equal very_special_client, Client.find(very_special_client.id) - end - - def test_alt_complex_inheritance - switch_to_alt_inheritance_column - test_complex_inheritance - switch_to_default_inheritance_column - end - - def test_eager_load_belongs_to_something_inherited - account = Account.find(1, :include => :firm) - assert_not_nil account.instance_variable_get("@firm"), "nil proves eager load failed" - end - - def test_alt_eager_loading - switch_to_alt_inheritance_column - test_eager_load_belongs_to_something_inherited - switch_to_default_inheritance_column - end - - def test_inheritance_without_mapping - assert_kind_of SpecialSubscriber, SpecialSubscriber.find("webster132") - assert_nothing_raised { s = SpecialSubscriber.new("name" => "And breaaaaathe!"); s.id = 'roger'; s.save } - end - - private - def switch_to_alt_inheritance_column - # we don't want misleading test results, so get rid of the values in the type column - Company.find(:all, :order => 'id').each do |c| - c['type'] = nil - c.save - end - [ Company, Firm, Client].each { |klass| klass.reset_column_information } - Company.set_inheritance_column('ruby_type') - end - def switch_to_default_inheritance_column - [ Company, Firm, Client].each { |klass| klass.reset_column_information } - Company.set_inheritance_column('type') - end -end - - -class InheritanceComputeTypeTest < ActiveSupport::TestCase - fixtures :companies - - def setup - Dependencies.log_activity = true - end - - def teardown - Dependencies.log_activity = false - self.class.const_remove :FirmOnTheFly rescue nil - Firm.const_remove :FirmOnTheFly rescue nil - end - - def test_instantiation_doesnt_try_to_require_corresponding_file - foo = Firm.find(:first).clone - foo.ruby_type = foo.type = 'FirmOnTheFly' - foo.save! - - # Should fail without FirmOnTheFly in the type condition. - assert_raise(ActiveRecord::RecordNotFound) { Firm.find(foo.id) } - - # Nest FirmOnTheFly in the test case where Dependencies won't see it. - self.class.const_set :FirmOnTheFly, Class.new(Firm) - assert_raise(ActiveRecord::SubclassNotFound) { Firm.find(foo.id) } - - # Nest FirmOnTheFly in Firm where Dependencies will see it. - # This is analogous to nesting models in a migration. - Firm.const_set :FirmOnTheFly, Class.new(Firm) - - # And instantiate will find the existing constant rather than trying - # to require firm_on_the_fly. - assert_nothing_raised { assert_kind_of Firm::FirmOnTheFly, Firm.find(foo.id) } - end -end Index: activerecord/test/migration_test.rb =================================================================== --- activerecord/test/migration_test.rb (revision 8601) +++ activerecord/test/migration_test.rb (working copy) @@ -1,971 +0,0 @@ -require 'abstract_unit' -require 'bigdecimal/util' - -require 'fixtures/person' -require 'fixtures/topic' -require File.dirname(__FILE__) + '/fixtures/migrations/1_people_have_last_names' -require File.dirname(__FILE__) + '/fixtures/migrations/2_we_need_reminders' -require File.dirname(__FILE__) + '/fixtures/migrations_with_decimal/1_give_me_big_numbers' - -if ActiveRecord::Base.connection.supports_migrations? - class BigNumber < ActiveRecord::Base; end - - class Reminder < ActiveRecord::Base; end - - class ActiveRecord::Migration - class < 40) - Person.reset_column_information - end - - def test_add_index - # Limit size of last_name and key columns to support Firebird index limitations - Person.connection.add_column "people", "last_name", :string, :limit => 100 - Person.connection.add_column "people", "key", :string, :limit => 100 - Person.connection.add_column "people", "administrator", :boolean - - assert_nothing_raised { Person.connection.add_index("people", "last_name") } - assert_nothing_raised { Person.connection.remove_index("people", "last_name") } - - # Orcl nds shrt indx nms. Sybs 2. - # OpenBase does not have named indexes. You must specify a single column name - unless current_adapter?(:OracleAdapter, :SybaseAdapter, :OpenBaseAdapter) - assert_nothing_raised { Person.connection.add_index("people", ["last_name", "first_name"]) } - assert_nothing_raised { Person.connection.remove_index("people", :column => ["last_name", "first_name"]) } - assert_nothing_raised { Person.connection.add_index("people", ["last_name", "first_name"]) } - assert_nothing_raised { Person.connection.remove_index("people", :name => "index_people_on_last_name_and_first_name") } - assert_nothing_raised { Person.connection.add_index("people", ["last_name", "first_name"]) } - assert_nothing_raised { Person.connection.remove_index("people", "last_name_and_first_name") } - assert_nothing_raised { Person.connection.add_index("people", ["last_name", "first_name"]) } - assert_nothing_raised { Person.connection.remove_index("people", ["last_name", "first_name"]) } - end - - # quoting - # Note: changed index name from "key" to "key_idx" since "key" is a Firebird reserved word - # OpenBase does not have named indexes. You must specify a single column name - unless current_adapter?(:OpenBaseAdapter) - assert_nothing_raised { Person.connection.add_index("people", ["key"], :name => "key_idx", :unique => true) } - assert_nothing_raised { Person.connection.remove_index("people", :name => "key_idx", :unique => true) } - end - - # Sybase adapter does not support indexes on :boolean columns - # OpenBase does not have named indexes. You must specify a single column - unless current_adapter?(:SybaseAdapter, :OpenBaseAdapter) - assert_nothing_raised { Person.connection.add_index("people", %w(last_name first_name administrator), :name => "named_admin") } - assert_nothing_raised { Person.connection.remove_index("people", :name => "named_admin") } - end - end - - def test_create_table_adds_id - Person.connection.create_table :testings do |t| - t.column :foo, :string - end - - assert_equal %w(foo id), - Person.connection.columns(:testings).map { |c| c.name }.sort - ensure - Person.connection.drop_table :testings rescue nil - end - - def test_create_table_with_not_null_column - assert_nothing_raised do - Person.connection.create_table :testings do |t| - t.column :foo, :string, :null => false - end - end - - assert_raises(ActiveRecord::StatementInvalid) do - Person.connection.execute "insert into testings (foo) values (NULL)" - end - ensure - Person.connection.drop_table :testings rescue nil - end - - def test_create_table_with_defaults - # MySQL doesn't allow defaults on TEXT or BLOB columns. - mysql = current_adapter?(:MysqlAdapter) - - Person.connection.create_table :testings do |t| - t.column :one, :string, :default => "hello" - t.column :two, :boolean, :default => true - t.column :three, :boolean, :default => false - t.column :four, :integer, :default => 1 - t.column :five, :text, :default => "hello" unless mysql - end - - columns = Person.connection.columns(:testings) - one = columns.detect { |c| c.name == "one" } - two = columns.detect { |c| c.name == "two" } - three = columns.detect { |c| c.name == "three" } - four = columns.detect { |c| c.name == "four" } - five = columns.detect { |c| c.name == "five" } unless mysql - - assert_equal "hello", one.default - assert_equal true, two.default - assert_equal false, three.default - assert_equal 1, four.default - assert_equal "hello", five.default unless mysql - - ensure - Person.connection.drop_table :testings rescue nil - end - - def test_create_table_with_limits - assert_nothing_raised do - Person.connection.create_table :testings do |t| - t.column :foo, :string, :limit => 255 - - t.column :default_int, :integer - - t.column :one_int, :integer, :limit => 1 - t.column :four_int, :integer, :limit => 4 - t.column :eight_int, :integer, :limit => 8 - end - end - - columns = Person.connection.columns(:testings) - foo = columns.detect { |c| c.name == "foo" } - assert_equal 255, foo.limit - - default = columns.detect { |c| c.name == "default_int" } - one = columns.detect { |c| c.name == "one_int" } - four = columns.detect { |c| c.name == "four_int" } - eight = columns.detect { |c| c.name == "eight_int" } - - if current_adapter?(:PostgreSQLAdapter) - assert_equal 'integer', default.sql_type - assert_equal 'smallint', one.sql_type - assert_equal 'integer', four.sql_type - assert_equal 'bigint', eight.sql_type - elsif current_adapter?(:OracleAdapter) - assert_equal 'NUMBER(38)', default.sql_type - assert_equal 'NUMBER(1)', one.sql_type - assert_equal 'NUMBER(4)', four.sql_type - assert_equal 'NUMBER(8)', eight.sql_type - end - ensure - Person.connection.drop_table :testings rescue nil - end - - # SQL Server, Sybase, and SQLite3 will not allow you to add a NOT NULL - # column to a table without a default value. - unless current_adapter?(:SQLServerAdapter, :SybaseAdapter, :SQLiteAdapter) - def test_add_column_not_null_without_default - Person.connection.create_table :testings do |t| - t.column :foo, :string - end - Person.connection.add_column :testings, :bar, :string, :null => false - - assert_raises(ActiveRecord::StatementInvalid) do - Person.connection.execute "insert into testings (foo, bar) values ('hello', NULL)" - end - ensure - Person.connection.drop_table :testings rescue nil - end - end - - def test_add_column_not_null_with_default - Person.connection.create_table :testings do |t| - t.column :foo, :string - end - - con = Person.connection - Person.connection.enable_identity_insert("testings", true) if current_adapter?(:SybaseAdapter) - Person.connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}) values (1, 'hello')" - Person.connection.enable_identity_insert("testings", false) if current_adapter?(:SybaseAdapter) - assert_nothing_raised {Person.connection.add_column :testings, :bar, :string, :null => false, :default => "default" } - - assert_raises(ActiveRecord::StatementInvalid) do - unless current_adapter?(:OpenBaseAdapter) - Person.connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}, #{con.quote_column_name('bar')}) values (2, 'hello', NULL)" - else - Person.connection.insert("INSERT INTO testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}, #{con.quote_column_name('bar')}) VALUES (2, 'hello', NULL)", - "Testing Insert","id",2) - end - end - ensure - Person.connection.drop_table :testings rescue nil - end - - # We specifically do a manual INSERT here, and then test only the SELECT - # functionality. This allows us to more easily catch INSERT being broken, - # but SELECT actually working fine. - def test_native_decimal_insert_manual_vs_automatic - correct_value = '0012345678901234567890.0123456789'.to_d - - Person.delete_all - Person.connection.add_column "people", "wealth", :decimal, :precision => '30', :scale => '10' - Person.reset_column_information - - # Do a manual insertion - if current_adapter?(:OracleAdapter) - Person.connection.execute "insert into people (id, wealth) values (people_seq.nextval, 12345678901234567890.0123456789)" - elsif current_adapter?(:OpenBaseAdapter) - Person.connection.execute "insert into people (wealth) values ('12345678901234567890.0123456789')" - else - Person.connection.execute "insert into people (wealth) values (12345678901234567890.0123456789)" - end - - # SELECT - row = Person.find(:first) - assert_kind_of BigDecimal, row.wealth - - # If this assert fails, that means the SELECT is broken! - unless current_adapter?(:SQLite3Adapter) - assert_equal correct_value, row.wealth - end - - # Reset to old state - Person.delete_all - - # Now use the Rails insertion - assert_nothing_raised { Person.create :wealth => BigDecimal.new("12345678901234567890.0123456789") } - - # SELECT - row = Person.find(:first) - assert_kind_of BigDecimal, row.wealth - - # If these asserts fail, that means the INSERT (create function, or cast to SQL) is broken! - unless current_adapter?(:SQLite3Adapter) - assert_equal correct_value, row.wealth - end - - # Reset to old state - Person.connection.del_column "people", "wealth" rescue nil - Person.reset_column_information - end - - def test_native_types - Person.delete_all - Person.connection.add_column "people", "last_name", :string - Person.connection.add_column "people", "bio", :text - Person.connection.add_column "people", "age", :integer - Person.connection.add_column "people", "height", :float - Person.connection.add_column "people", "wealth", :decimal, :precision => '30', :scale => '10' - Person.connection.add_column "people", "birthday", :datetime - Person.connection.add_column "people", "favorite_day", :date - Person.connection.add_column "people", "moment_of_truth", :datetime - Person.connection.add_column "people", "male", :boolean - Person.reset_column_information - - assert_nothing_raised do - Person.create :first_name => 'bob', :last_name => 'bobsen', - :bio => "I was born ....", :age => 18, :height => 1.78, - :wealth => BigDecimal.new("12345678901234567890.0123456789"), - :birthday => 18.years.ago, :favorite_day => 10.days.ago, - :moment_of_truth => "1782-10-10 21:40:18", :male => true - end - - bob = Person.find(:first) - assert_equal 'bob', bob.first_name - assert_equal 'bobsen', bob.last_name - assert_equal "I was born ....", bob.bio - assert_equal 18, bob.age - - # Test for 30 significent digits (beyond the 16 of float), 10 of them - # after the decimal place. - - unless current_adapter?(:SQLite3Adapter) - assert_equal BigDecimal.new("0012345678901234567890.0123456789"), bob.wealth - end - - assert_equal true, bob.male? - - assert_equal String, bob.first_name.class - assert_equal String, bob.last_name.class - assert_equal String, bob.bio.class - assert_equal Fixnum, bob.age.class - assert_equal Time, bob.birthday.class - - if current_adapter?(:SQLServerAdapter, :OracleAdapter, :SybaseAdapter) - # Sybase, and Oracle don't differentiate between date/time - assert_equal Time, bob.favorite_day.class - else - assert_equal Date, bob.favorite_day.class - end - - # Test DateTime column and defaults, including timezone. - # FIXME: moment of truth may be Time on 64-bit platforms. - if bob.moment_of_truth.is_a?(DateTime) - assert_equal DateTime.now.offset, bob.moment_of_truth.offset - assert_not_equal 0, bob.moment_of_truth.offset - assert_not_equal "Z", bob.moment_of_truth.zone - assert_equal DateTime::ITALY, bob.moment_of_truth.start - end - - assert_equal TrueClass, bob.male?.class - assert_kind_of BigDecimal, bob.wealth - end - - if current_adapter?(:MysqlAdapter) - def test_unabstracted_database_dependent_types - Person.delete_all - - ActiveRecord::Migration.add_column :people, :intelligence_quotient, :tinyint - Person.reset_column_information - Person.create :intelligence_quotient => 300 - jonnyg = Person.find(:first) - assert_equal 127, jonnyg.intelligence_quotient - jonnyg.destroy - ensure - ActiveRecord::Migration.remove_column :people, :intelligence_quotient rescue nil - end - end - - def test_add_remove_single_field_using_string_arguments - assert !Person.column_methods_hash.include?(:last_name) - - ActiveRecord::Migration.add_column 'people', 'last_name', :string - - Person.reset_column_information - assert Person.column_methods_hash.include?(:last_name) - - ActiveRecord::Migration.remove_column 'people', 'last_name' - - Person.reset_column_information - assert !Person.column_methods_hash.include?(:last_name) - end - - def test_add_remove_single_field_using_symbol_arguments - assert !Person.column_methods_hash.include?(:last_name) - - ActiveRecord::Migration.add_column :people, :last_name, :string - - Person.reset_column_information - assert Person.column_methods_hash.include?(:last_name) - - ActiveRecord::Migration.remove_column :people, :last_name - - Person.reset_column_information - assert !Person.column_methods_hash.include?(:last_name) - end - - def test_add_rename - Person.delete_all - - begin - Person.connection.add_column "people", "girlfriend", :string - Person.reset_column_information - Person.create :girlfriend => 'bobette' - - Person.connection.rename_column "people", "girlfriend", "exgirlfriend" - - Person.reset_column_information - bob = Person.find(:first) - - assert_equal "bobette", bob.exgirlfriend - ensure - Person.connection.remove_column("people", "girlfriend") rescue nil - Person.connection.remove_column("people", "exgirlfriend") rescue nil - end - - end - - def test_rename_column_using_symbol_arguments - begin - names_before = Person.find(:all).map(&:first_name) - Person.connection.rename_column :people, :first_name, :nick_name - Person.reset_column_information - assert Person.column_names.include?("nick_name") - assert_equal names_before, Person.find(:all).map(&:nick_name) - ensure - Person.connection.remove_column("people","nick_name") - Person.connection.add_column("people","first_name", :string) - end - end - - def test_rename_column - begin - names_before = Person.find(:all).map(&:first_name) - Person.connection.rename_column "people", "first_name", "nick_name" - Person.reset_column_information - assert Person.column_names.include?("nick_name") - assert_equal names_before, Person.find(:all).map(&:nick_name) - ensure - Person.connection.remove_column("people","nick_name") - Person.connection.add_column("people","first_name", :string) - end - end - - def test_rename_column_with_sql_reserved_word - begin - assert_nothing_raised { Person.connection.rename_column "people", "first_name", "group" } - Person.reset_column_information - assert Person.column_names.include?("group") - ensure - Person.connection.remove_column("people", "group") rescue nil - Person.connection.add_column("people", "first_name", :string) rescue nil - end - end - - def test_rename_column_with_an_index - ActiveRecord::Base.connection.create_table(:hats) do |table| - table.column :hat_name, :string, :limit => 100 - table.column :hat_size, :integer - end - Person.connection.add_index :people, :first_name - assert_nothing_raised do - Person.connection.rename_column "hats", "hat_name", "name" - end - ensure - ActiveRecord::Base.connection.drop_table(:hats) - end - - def test_remove_column_with_index - ActiveRecord::Base.connection.create_table(:hats) do |table| - table.column :hat_name, :string, :limit => 100 - table.column :hat_size, :integer - end - ActiveRecord::Base.connection.add_index "hats", "hat_size" - - assert_nothing_raised { Person.connection.remove_column("hats", "hat_size") } - ensure - ActiveRecord::Base.connection.drop_table(:hats) - end - - def test_remove_column_with_multi_column_index - ActiveRecord::Base.connection.create_table(:hats) do |table| - table.column :hat_name, :string, :limit => 100 - table.column :hat_size, :integer - table.column :hat_style, :string, :limit => 100 - end - ActiveRecord::Base.connection.add_index "hats", ["hat_style", "hat_size"], :unique => true - - assert_nothing_raised { Person.connection.remove_column("hats", "hat_size") } - ensure - ActiveRecord::Base.connection.drop_table(:hats) - end - - def test_change_type_of_not_null_column - assert_nothing_raised do - Topic.connection.change_column "topics", "written_on", :datetime, :null => false - Topic.reset_column_information - - Topic.connection.change_column "topics", "written_on", :datetime, :null => false - Topic.reset_column_information - end - end - - def test_rename_table - begin - ActiveRecord::Base.connection.create_table :octopuses do |t| - t.column :url, :string - end - ActiveRecord::Base.connection.rename_table :octopuses, :octopi - - # Using explicit id in insert for compatibility across all databases - con = ActiveRecord::Base.connection - con.enable_identity_insert("octopi", true) if current_adapter?(:SybaseAdapter) - assert_nothing_raised { con.execute "INSERT INTO octopi (#{con.quote_column_name('id')}, #{con.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')" } - con.enable_identity_insert("octopi", false) if current_adapter?(:SybaseAdapter) - - assert_equal 'http://www.foreverflying.com/octopus-black7.jpg', ActiveRecord::Base.connection.select_value("SELECT url FROM octopi WHERE id=1") - - ensure - ActiveRecord::Base.connection.drop_table :octopuses rescue nil - ActiveRecord::Base.connection.drop_table :octopi rescue nil - end - end - - def test_change_column_nullability - Person.delete_all - Person.connection.add_column "people", "funny", :boolean - Person.reset_column_information - assert Person.columns_hash["funny"].null, "Column 'funny' must initially allow nulls" - Person.connection.change_column "people", "funny", :boolean, :null => false, :default => true - Person.reset_column_information - assert !Person.columns_hash["funny"].null, "Column 'funny' must *not* allow nulls at this point" - Person.connection.change_column "people", "funny", :boolean, :null => true - Person.reset_column_information - assert Person.columns_hash["funny"].null, "Column 'funny' must allow nulls again at this point" - end - - def test_rename_table_with_an_index - begin - ActiveRecord::Base.connection.create_table :octopuses do |t| - t.column :url, :string - end - ActiveRecord::Base.connection.add_index :octopuses, :url - - ActiveRecord::Base.connection.rename_table :octopuses, :octopi - - # Using explicit id in insert for compatibility across all databases - con = ActiveRecord::Base.connection - con.enable_identity_insert("octopi", true) if current_adapter?(:SybaseAdapter) - assert_nothing_raised { con.execute "INSERT INTO octopi (#{con.quote_column_name('id')}, #{con.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')" } - con.enable_identity_insert("octopi", false) if current_adapter?(:SybaseAdapter) - - assert_equal 'http://www.foreverflying.com/octopus-black7.jpg', ActiveRecord::Base.connection.select_value("SELECT url FROM octopi WHERE id=1") - assert ActiveRecord::Base.connection.indexes(:octopi).first.columns.include?("url") - ensure - ActiveRecord::Base.connection.drop_table :octopuses rescue nil - ActiveRecord::Base.connection.drop_table :octopi rescue nil - end - end - - def test_change_column - Person.connection.add_column 'people', 'age', :integer - old_columns = Person.connection.columns(Person.table_name, "#{name} Columns") - assert old_columns.find { |c| c.name == 'age' and c.type == :integer } - - assert_nothing_raised { Person.connection.change_column "people", "age", :string } - - new_columns = Person.connection.columns(Person.table_name, "#{name} Columns") - assert_nil new_columns.find { |c| c.name == 'age' and c.type == :integer } - assert new_columns.find { |c| c.name == 'age' and c.type == :string } - - old_columns = Topic.connection.columns(Topic.table_name, "#{name} Columns") - assert old_columns.find { |c| c.name == 'approved' and c.type == :boolean and c.default == true } - assert_nothing_raised { Topic.connection.change_column :topics, :approved, :boolean, :default => false } - new_columns = Topic.connection.columns(Topic.table_name, "#{name} Columns") - assert_nil new_columns.find { |c| c.name == 'approved' and c.type == :boolean and c.default == true } - assert new_columns.find { |c| c.name == 'approved' and c.type == :boolean and c.default == false } - assert_nothing_raised { Topic.connection.change_column :topics, :approved, :boolean, :default => true } - end - - def test_change_column_with_nil_default - Person.connection.add_column "people", "contributor", :boolean, :default => true - Person.reset_column_information - assert Person.new.contributor? - - assert_nothing_raised { Person.connection.change_column "people", "contributor", :boolean, :default => nil } - Person.reset_column_information - assert !Person.new.contributor? - assert_nil Person.new.contributor - ensure - Person.connection.remove_column("people", "contributor") rescue nil - end - - def test_change_column_with_new_default - Person.connection.add_column "people", "administrator", :boolean, :default => true - Person.reset_column_information - assert Person.new.administrator? - - assert_nothing_raised { Person.connection.change_column "people", "administrator", :boolean, :default => false } - Person.reset_column_information - assert !Person.new.administrator? - ensure - Person.connection.remove_column("people", "administrator") rescue nil - end - - def test_change_column_default - Person.connection.change_column_default "people", "first_name", "Tester" - Person.reset_column_information - assert_equal "Tester", Person.new.first_name - end - - def test_change_column_quotes_column_names - Person.connection.create_table :testings do |t| - t.column :select, :string - end - - assert_nothing_raised { Person.connection.change_column :testings, :select, :string, :limit => 10 } - - assert_nothing_raised { Person.connection.execute "insert into testings (#{Person.connection.quote_column_name('select')}) values ('7 chars')" } - ensure - Person.connection.drop_table :testings rescue nil - end - - def test_change_column_default_to_null - Person.connection.change_column_default "people", "first_name", nil - Person.reset_column_information - assert_nil Person.new.first_name - end - - def test_add_table - assert !Reminder.table_exists? - - WeNeedReminders.up - - assert Reminder.create("content" => "hello world", "remind_at" => Time.now) - assert_equal "hello world", Reminder.find(:first).content - - WeNeedReminders.down - assert_raises(ActiveRecord::StatementInvalid) { Reminder.find(:first) } - end - - def test_add_table_with_decimals - Person.connection.drop_table :big_numbers rescue nil - - assert !BigNumber.table_exists? - GiveMeBigNumbers.up - - assert BigNumber.create( - :bank_balance => 1586.43, - :big_bank_balance => BigDecimal("1000234000567.95"), - :world_population => 6000000000, - :my_house_population => 3, - :value_of_e => BigDecimal("2.7182818284590452353602875") - ) - - b = BigNumber.find(:first) - assert_not_nil b - - assert_not_nil b.bank_balance - assert_not_nil b.big_bank_balance - assert_not_nil b.world_population - assert_not_nil b.my_house_population - assert_not_nil b.value_of_e - - # TODO: set world_population >= 2**62 to cover 64-bit platforms and test - # is_a?(Bignum) - assert_kind_of Integer, b.world_population - assert_equal 6000000000, b.world_population - assert_kind_of Fixnum, b.my_house_population - assert_equal 3, b.my_house_population - assert_kind_of BigDecimal, b.bank_balance - assert_equal BigDecimal("1586.43"), b.bank_balance - assert_kind_of BigDecimal, b.big_bank_balance - assert_equal BigDecimal("1000234000567.95"), b.big_bank_balance - - # This one is fun. The 'value_of_e' field is defined as 'DECIMAL' with - # precision/scale explicitly left out. By the SQL standard, numbers - # assigned to this field should be truncated but that's seldom respected. - if current_adapter?(:PostgreSQLAdapter, :SQLite2Adapter) - # - PostgreSQL changes the SQL spec on columns declared simply as - # "decimal" to something more useful: instead of being given a scale - # of 0, they take on the compile-time limit for precision and scale, - # so the following should succeed unless you have used really wacky - # compilation options - # - SQLite2 has the default behavior of preserving all data sent in, - # so this happens there too - assert_kind_of BigDecimal, b.value_of_e - assert_equal BigDecimal("2.7182818284590452353602875"), b.value_of_e - elsif current_adapter?(:SQLiteAdapter) - # - SQLite3 stores a float, in violation of SQL - assert_kind_of BigDecimal, b.value_of_e - assert_equal BigDecimal("2.71828182845905"), b.value_of_e - elsif current_adapter?(:SQLServer) - # - SQL Server rounds instead of truncating - assert_kind_of Fixnum, b.value_of_e - assert_equal 3, b.value_of_e - else - # - SQL standard is an integer - assert_kind_of Fixnum, b.value_of_e - assert_equal 2, b.value_of_e - end - - GiveMeBigNumbers.down - assert_raises(ActiveRecord::StatementInvalid) { BigNumber.find(:first) } - end - - def test_migrator - assert !Person.column_methods_hash.include?(:last_name) - assert !Reminder.table_exists? - - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/') - - assert_equal 3, ActiveRecord::Migrator.current_version - Person.reset_column_information - assert Person.column_methods_hash.include?(:last_name) - assert Reminder.create("content" => "hello world", "remind_at" => Time.now) - assert_equal "hello world", Reminder.find(:first).content - - ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/') - - assert_equal 0, ActiveRecord::Migrator.current_version - Person.reset_column_information - assert !Person.column_methods_hash.include?(:last_name) - assert_raises(ActiveRecord::StatementInvalid) { Reminder.find(:first) } - end - - def test_migrator_one_up - assert !Person.column_methods_hash.include?(:last_name) - assert !Reminder.table_exists? - - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1) - - Person.reset_column_information - assert Person.column_methods_hash.include?(:last_name) - assert !Reminder.table_exists? - - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 2) - - assert Reminder.create("content" => "hello world", "remind_at" => Time.now) - assert_equal "hello world", Reminder.find(:first).content - end - - def test_migrator_one_down - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/') - - ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/', 1) - - Person.reset_column_information - assert Person.column_methods_hash.include?(:last_name) - assert !Reminder.table_exists? - end - - def test_migrator_one_up_one_down - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1) - ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/', 0) - - assert !Person.column_methods_hash.include?(:last_name) - assert !Reminder.table_exists? - end - - def test_migrator_verbosity - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1) - assert PeopleHaveLastNames.message_count > 0 - PeopleHaveLastNames.message_count = 0 - - ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/', 0) - assert PeopleHaveLastNames.message_count > 0 - PeopleHaveLastNames.message_count = 0 - end - - def test_migrator_verbosity_off - PeopleHaveLastNames.verbose = false - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1) - assert PeopleHaveLastNames.message_count.zero? - ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/', 0) - assert PeopleHaveLastNames.message_count.zero? - end - - def test_migrator_going_down_due_to_version_target - ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1) - ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations/', 0) - - assert !Person.column_methods_hash.include?(:last_name) - assert !Reminder.table_exists? - - ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations/') - - Person.reset_column_information - assert Person.column_methods_hash.include?(:last_name) - assert Reminder.create("content" => "hello world", "remind_at" => Time.now) - assert_equal "hello world", Reminder.find(:first).content - end - - def test_schema_info_table_name - ActiveRecord::Base.table_name_prefix = "prefix_" - ActiveRecord::Base.table_name_suffix = "_suffix" - Reminder.reset_table_name - assert_equal "prefix_schema_info_suffix", ActiveRecord::Migrator.schema_info_table_name - ActiveRecord::Base.table_name_prefix = "" - ActiveRecord::Base.table_name_suffix = "" - Reminder.reset_table_name - assert_equal "schema_info", ActiveRecord::Migrator.schema_info_table_name - ensure - ActiveRecord::Base.table_name_prefix = "" - ActiveRecord::Base.table_name_suffix = "" - end - - def test_proper_table_name - assert_equal "table", ActiveRecord::Migrator.proper_table_name('table') - assert_equal "table", ActiveRecord::Migrator.proper_table_name(:table) - assert_equal "reminders", ActiveRecord::Migrator.proper_table_name(Reminder) - Reminder.reset_table_name - assert_equal Reminder.table_name, ActiveRecord::Migrator.proper_table_name(Reminder) - - # Use the model's own prefix/suffix if a model is given - ActiveRecord::Base.table_name_prefix = "ARprefix_" - ActiveRecord::Base.table_name_suffix = "_ARsuffix" - Reminder.table_name_prefix = 'prefix_' - Reminder.table_name_suffix = '_suffix' - Reminder.reset_table_name - assert_equal "prefix_reminders_suffix", ActiveRecord::Migrator.proper_table_name(Reminder) - Reminder.table_name_prefix = '' - Reminder.table_name_suffix = '' - Reminder.reset_table_name - - # Use AR::Base's prefix/suffix if string or symbol is given - ActiveRecord::Base.table_name_prefix = "prefix_" - ActiveRecord::Base.table_name_suffix = "_suffix" - Reminder.reset_table_name - assert_equal "prefix_table_suffix", ActiveRecord::Migrator.proper_table_name('table') - assert_equal "prefix_table_suffix", ActiveRecord::Migrator.proper_table_name(:table) - ActiveRecord::Base.table_name_prefix = "" - ActiveRecord::Base.table_name_suffix = "" - Reminder.reset_table_name - end - - def test_add_drop_table_with_prefix_and_suffix - assert !Reminder.table_exists? - ActiveRecord::Base.table_name_prefix = 'prefix_' - ActiveRecord::Base.table_name_suffix = '_suffix' - Reminder.reset_table_name - Reminder.reset_sequence_name - WeNeedReminders.up - assert Reminder.create("content" => "hello world", "remind_at" => Time.now) - assert_equal "hello world", Reminder.find(:first).content - - WeNeedReminders.down - assert_raises(ActiveRecord::StatementInvalid) { Reminder.find(:first) } - ensure - ActiveRecord::Base.table_name_prefix = '' - ActiveRecord::Base.table_name_suffix = '' - Reminder.reset_table_name - Reminder.reset_sequence_name - end - - def test_create_table_with_binary_column - Person.connection.drop_table :binary_testings rescue nil - - assert_nothing_raised { - Person.connection.create_table :binary_testings do |t| - t.column "data", :binary, :null => false - end - } - - columns = Person.connection.columns(:binary_testings) - data_column = columns.detect { |c| c.name == "data" } - - if current_adapter?(:MysqlAdapter) - assert_equal '', data_column.default - else - assert_nil data_column.default - end - - Person.connection.drop_table :binary_testings rescue nil - end - - def test_migrator_with_duplicates - assert_raises(ActiveRecord::DuplicateMigrationVersionError) do - ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations_with_duplicate/', nil) - end - end - - def test_migrator_with_missing_version_numbers - ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations_with_missing_versions/', 500) - assert !Person.column_methods_hash.include?(:middle_name) - assert_equal 4, ActiveRecord::Migrator.current_version - - ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations_with_missing_versions/', 2) - Person.reset_column_information - assert !Reminder.table_exists? - assert Person.column_methods_hash.include?(:last_name) - assert_equal 2, ActiveRecord::Migrator.current_version - end - - def test_create_table_with_custom_sequence_name - return unless current_adapter? :OracleAdapter - - # table name is 29 chars, the standard sequence name will - # be 33 chars and fail - assert_raises(ActiveRecord::StatementInvalid) do - begin - Person.connection.create_table :table_with_name_thats_just_ok do |t| - t.column :foo, :string, :null => false - end - ensure - Person.connection.drop_table :table_with_name_thats_just_ok rescue nil - end - end - - # should be all good w/ a custom sequence name - assert_nothing_raised do - begin - Person.connection.create_table :table_with_name_thats_just_ok, - :sequence_name => 'suitably_short_seq' do |t| - t.column :foo, :string, :null => false - end - - Person.connection.execute("select suitably_short_seq.nextval from dual") - - ensure - Person.connection.drop_table :table_with_name_thats_just_ok, - :sequence_name => 'suitably_short_seq' rescue nil - end - end - - # confirm the custom sequence got dropped - assert_raises(ActiveRecord::StatementInvalid) do - Person.connection.execute("select suitably_short_seq.nextval from dual") - end - end - end - - uses_mocha 'Sexy migration tests' do - class SexyMigrationsTest < ActiveSupport::TestCase - def test_references_column_type_adds_id - with_new_table do |t| - t.expects(:column).with('customer_id', :integer, {}) - t.references :customer - end - end - - def test_references_column_type_with_polymorphic_adds_type - with_new_table do |t| - t.expects(:column).with('taggable_type', :string, {}) - t.expects(:column).with('taggable_id', :integer, {}) - t.references :taggable, :polymorphic => true - end - end - - def test_belongs_to_works_like_references - with_new_table do |t| - t.expects(:column).with('customer_id', :integer, {}) - t.belongs_to :customer - end - end - - def test_timestamps_creates_updated_at_and_created_at - with_new_table do |t| - t.expects(:column).with(:created_at, :datetime) - t.expects(:column).with(:updated_at, :datetime) - t.timestamps - end - end - - def test_integer_creates_integer_column - with_new_table do |t| - t.expects(:column).with(:foo, 'integer', {}) - t.expects(:column).with(:bar, 'integer', {}) - t.integer :foo, :bar - end - end - - def test_string_creates_string_column - with_new_table do |t| - t.expects(:column).with(:foo, 'string', {}) - t.expects(:column).with(:bar, 'string', {}) - t.string :foo, :bar - end - end - - protected - def with_new_table - Person.connection.create_table :delete_me do |t| - yield t - end - ensure - Person.connection.drop_table :delete_me rescue nil - end - - end # SexyMigrationsTest - end # uses_mocha -end - Index: activerecord/test/default_test_firebird.rb =================================================================== --- activerecord/test/default_test_firebird.rb (revision 8601) +++ activerecord/test/default_test_firebird.rb (working copy) @@ -1,16 +0,0 @@ -require 'abstract_unit' -require 'fixtures/default' - -class DefaultTest < ActiveSupport::TestCase - def test_default_timestamp - default = Default.new - assert_instance_of(Time, default.default_timestamp) - assert_equal(:datetime, default.column_for_attribute(:default_timestamp).type) - - # Variance should be small; increase if required -- e.g., if test db is on - # remote host and clocks aren't synchronized. - t1 = Time.new - accepted_variance = 1.0 - assert_in_delta(t1.to_f, default.default_timestamp.to_f, accepted_variance) - end -end Index: activerecord/test/date_time_test.rb =================================================================== --- activerecord/test/date_time_test.rb (revision 8601) +++ activerecord/test/date_time_test.rb (working copy) @@ -1,37 +0,0 @@ -require 'abstract_unit' -require 'fixtures/topic' -require 'fixtures/task' - -class DateTimeTest < ActiveSupport::TestCase - def test_saves_both_date_and_time - time_values = [1807, 2, 10, 15, 30, 45] - now = DateTime.civil(*time_values) - - task = Task.new - task.starting = now - task.save! - - # check against Time.local_time, since some platforms will return a Time instead of a DateTime - assert_equal Time.local_time(*time_values), Task.find(task.id).starting - end - - def test_assign_empty_date_time - task = Task.new - task.starting = '' - task.ending = nil - assert_nil task.starting - assert_nil task.ending - end - - def test_assign_empty_date - topic = Topic.new - topic.last_read = '' - assert_nil topic.last_read - end - - def test_assign_empty_time - topic = Topic.new - topic.bonus_time = '' - assert_nil topic.bonus_time - end -end Index: activerecord/test/table_name_test_sqlserver.rb =================================================================== --- activerecord/test/table_name_test_sqlserver.rb (revision 8601) +++ activerecord/test/table_name_test_sqlserver.rb (working copy) @@ -1,23 +0,0 @@ -require 'abstract_unit' -require "#{File.dirname(__FILE__)}/../lib/active_record/schema" - -if ActiveRecord::Base.connection.supports_migrations? - class Order < ActiveRecord::Base - self.table_name = '[order]' - end - - class TableNameTest < ActiveSupport::TestCase - self.use_transactional_fixtures = false - - # Ensures Model.columns works when using SQLServer escape characters. - # Enables legacy schemas using SQL reserved words as table names. - # Should work with table names with spaces as well ('table name'). - def test_escaped_table_name - assert_nothing_raised do - ActiveRecord::Base.connection.select_all 'SELECT * FROM [order]' - end - assert_equal '[order]', Order.table_name - assert_equal 5, Order.columns.length - end - end -end Index: activerecord/test/xml_serialization_test.rb =================================================================== --- activerecord/test/xml_serialization_test.rb (revision 8601) +++ activerecord/test/xml_serialization_test.rb (working copy) @@ -1,202 +0,0 @@ -require 'abstract_unit' -require 'fixtures/contact' -require 'fixtures/post' -require 'fixtures/author' -require 'fixtures/tagging' -require 'fixtures/comment' - -class XmlSerializationTest < ActiveSupport::TestCase - def test_should_serialize_default_root - @xml = Contact.new.to_xml - assert_match %r{^}, @xml - assert_match %r{$}, @xml - end - - def test_should_serialize_default_root_with_namespace - @xml = Contact.new.to_xml :namespace=>"http://xml.rubyonrails.org/contact" - assert_match %r{^}, @xml - assert_match %r{$}, @xml - end - - def test_should_serialize_custom_root - @xml = Contact.new.to_xml :root => 'xml_contact' - assert_match %r{^}, @xml - assert_match %r{$}, @xml - end - - def test_should_allow_undasherized_tags - @xml = Contact.new.to_xml :root => 'xml_contact', :dasherize => false - assert_match %r{^}, @xml - assert_match %r{$}, @xml - assert_match %r{David}, @xml - end -end - -class DefaultXmlSerializationTest < ActiveSupport::TestCase - def setup - @xml = Contact.new(:name => 'aaron stack', :age => 25, :avatar => 'binarydata', :created_at => Time.utc(2006, 8, 1), :awesome => false, :preferences => { :gem => 'ruby' }).to_xml - end - - def test_should_serialize_string - assert_match %r{aaron stack}, @xml - end - - def test_should_serialize_integer - assert_match %r{25}, @xml - end - - def test_should_serialize_binary - assert_match %r{YmluYXJ5ZGF0YQ==\n}, @xml - assert_match %r{2006-08-01T00:00:00Z}, @xml - end - - def test_should_serialize_boolean - assert_match %r{false}, @xml - end - - def test_should_serialize_yaml - assert_match %r{--- \n:gem: ruby\n}, @xml - end -end - -class NilXmlSerializationTest < ActiveSupport::TestCase - def setup - @xml = Contact.new.to_xml(:root => 'xml_contact') - end - - def test_should_serialize_string - assert_match %r{}, @xml - end - - def test_should_serialize_integer - assert %r{}.match(@xml) - attributes = $1 - assert_match %r{nil="true"}, attributes - assert_match %r{type="integer"}, attributes - end - - def test_should_serialize_binary - assert %r{}.match(@xml) - attributes = $1 - assert_match %r{type="binary"}, attributes - assert_match %r{encoding="base64"}, attributes - assert_match %r{nil="true"}, attributes - end - - def test_should_serialize_datetime - assert %r{}.match(@xml) - attributes = $1 - assert_match %r{nil="true"}, attributes - assert_match %r{type="datetime"}, attributes - end - - def test_should_serialize_boolean - assert %r{}.match(@xml) - attributes = $1 - assert_match %r{type="boolean"}, attributes - assert_match %r{nil="true"}, attributes - end - - def test_should_serialize_yaml - assert %r{}.match(@xml) - attributes = $1 - assert_match %r{type="yaml"}, attributes - assert_match %r{nil="true"}, attributes - end -end - -class DatabaseConnectedXmlSerializationTest < ActiveSupport::TestCase - fixtures :authors, :posts - # to_xml used to mess with the hash the user provided which - # caused the builder to be reused. This meant the document kept - # getting appended to. - def test_passing_hash_shouldnt_reuse_builder - options = {:include=>:posts} - david = authors(:david) - first_xml_size = david.to_xml(options).size - second_xml_size = david.to_xml(options).size - assert_equal first_xml_size, second_xml_size - end - - def test_include_uses_association_name - xml = authors(:david).to_xml :include=>:hello_posts, :indent => 0 - assert_match %r{}, xml - assert_match %r{}, xml - assert_match %r{}, xml - end - - def test_methods_are_called_on_object - xml = authors(:david).to_xml :methods => :label, :indent => 0 - assert_match %r{}, xml - end - - def test_should_not_call_methods_on_associations_that_dont_respond - xml = authors(:david).to_xml :include=>:hello_posts, :methods => :label, :indent => 2 - assert !authors(:david).hello_posts.first.respond_to?(:label) - assert_match %r{^ }, xml - assert_no_match %r{^