class BasicsTest

Constants

DeveloperSalary
GUESSED_CLASSES

Public Instance Methods

cast(value) click to toggle source
# File activerecord/test/cases/base_test.rb, line 1318
def cast(value)
  "t.lo"
end
eastern_time_zone() click to toggle source
# File activerecord/test/cases/base_test.rb, line 263
def eastern_time_zone
  if Gem.win_platform?
    "EST5EDT"
  else
    "America/New_York"
  end
end
test_abstract_class_table_name() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1131
def test_abstract_class_table_name
  assert_nil AbstractCompany.table_name
end
test_all() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1091
def test_all
  developers = Developer.all
  assert_kind_of ActiveRecord::Relation, developers
  assert_equal Developer.all, developers
end
test_all_with_conditions() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1097
def test_all_with_conditions
  assert_equal Developer.all.merge!(order: "id desc").to_a, Developer.order("id desc").to_a
end
test_assert_queries() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1147
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
test_attribute_names() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1269
def test_attribute_names
  assert_equal ["id", "type", "firm_id", "firm_name", "name", "client_of", "rating", "account_id", "description"],
               Company.attribute_names
end
test_attribute_names_on_abstract_class() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1291
def test_attribute_names_on_abstract_class
  assert_equal [], AbstractCompany.attribute_names
end
test_attribute_names_on_table_not_exists() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1287
def test_attribute_names_on_table_not_exists
  assert_equal [], NonExistentTable.attribute_names
end
test_attributes() click to toggle source
# File activerecord/test/cases/base_test.rb, line 708
def test_attributes
  category = Category.new(name: "Ruby")

  expected_attributes = category.attribute_names.map do |attribute_name|
    [attribute_name, category.public_send(attribute_name)]
  end.to_h

  assert_instance_of Hash, category.attributes
  assert_equal expected_attributes, category.attributes
end
test_attributes_on_dummy_time() click to toggle source
# File activerecord/test/cases/base_test.rb, line 682
def test_attributes_on_dummy_time
  # Oracle does not have a TIME datatype.
  return true if current_adapter?(:OracleAdapter)

  with_timezone_config default: :local do
    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
end
test_attributes_on_dummy_time_with_invalid_time() click to toggle source
# File activerecord/test/cases/base_test.rb, line 696
def test_attributes_on_dummy_time_with_invalid_time
  # Oracle does not have a TIME datatype.
  return true if current_adapter?(:OracleAdapter)

  attributes = {
    "bonus_time" => "not a time"
  }
  topic = Topic.find(1)
  topic.attributes = attributes
  assert_nil topic.bonus_time
end
test_auto_id() click to toggle source
# File activerecord/test/cases/base_test.rb, line 919
def test_auto_id
  auto = AutoId.new
  auto.save
  assert(auto.id > 0)
end
test_benchmark_with_log_level() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1154
def test_benchmark_with_log_level
  original_logger = ActiveRecord::Base.logger
  log = StringIO.new
  ActiveRecord::Base.logger = ActiveSupport::Logger.new(log)
  ActiveRecord::Base.logger.level = Logger::WARN
  ActiveRecord::Base.benchmark("Debug Topic Count", level: :debug) { Topic.count }
  ActiveRecord::Base.benchmark("Warn Topic Count",  level: :warn)  { Topic.count }
  ActiveRecord::Base.benchmark("Error Topic Count", level: :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
test_benchmark_with_use_silence() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1169
def test_benchmark_with_use_silence
  original_logger = ActiveRecord::Base.logger
  log = StringIO.new
  ActiveRecord::Base.logger = ActiveSupport::Logger.new(log)
  ActiveRecord::Base.logger.level = Logger::DEBUG
  ActiveRecord::Base.benchmark("Logging", level: :debug, silence: false)  { ActiveRecord::Base.logger.debug "Quiet" }
  assert_match(/Quiet/, log.string)
ensure
  ActiveRecord::Base.logger = original_logger
end
test_bignum() click to toggle source
# File activerecord/test/cases/base_test.rb, line 886
def test_bignum
  company = Company.find(1)
  company.rating = 2147483648
  company.save
  company = Company.find(1)
  assert_equal 2147483648, company.rating
end
test_bignum_pk() click to toggle source
# File activerecord/test/cases/base_test.rb, line 895
def test_bignum_pk
  company = Company.create!(id: 2147483648, name: "foo")
  assert_equal company, Company.find(company.id)
end
test_boolean() click to toggle source
# File activerecord/test/cases/base_test.rb, line 719
def test_boolean
  b_nil = Boolean.create("value" => nil)
  nil_id = b_nil.id
  b_false = Boolean.create("value" => false)
  false_id = b_false.id
  b_true = Boolean.create("value" => true)
  true_id = b_true.id

  b_nil = Boolean.find(nil_id)
  assert_nil b_nil.value
  b_false = Boolean.find(false_id)
  assert !b_false.value?
  b_true = Boolean.find(true_id)
  assert b_true.value?
end
test_boolean_cast_from_string() click to toggle source
# File activerecord/test/cases/base_test.rb, line 745
def test_boolean_cast_from_string
  b_blank = Boolean.create("value" => "")
  blank_id = b_blank.id
  b_false = Boolean.create("value" => "0")
  false_id = b_false.id
  b_true = Boolean.create("value" => "1")
  true_id = b_true.id

  b_blank = Boolean.find(blank_id)
  assert_nil b_blank.value
  b_false = Boolean.find(false_id)
  assert !b_false.value?
  b_true = Boolean.find(true_id)
  assert b_true.value?
end
test_boolean_without_questionmark() click to toggle source
# File activerecord/test/cases/base_test.rb, line 735
def test_boolean_without_questionmark
  b_true = Boolean.create("value" => true)
  true_id = b_true.id

  subclass   = Class.new(Boolean).find true_id
  superclass = Boolean.find true_id

  assert_equal superclass.read_attribute(:has_fun), subclass.read_attribute(:has_fun)
end
test_clear_cache!() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1180
def test_clear_cache!
  # preheat cache
  c1 = Post.connection.schema_cache.columns("posts")
  ActiveRecord::Base.clear_cache!
  c2 = Post.connection.schema_cache.columns("posts")
  c1.each_with_index do |v, i|
    assert_not_same v, c2[i]
  end
  assert_equal c1, c2
end
test_clear_cash_when_setting_table_name() click to toggle source
# File activerecord/test/cases/base_test.rb, line 987
def test_clear_cash_when_setting_table_name
  original_table_name = Joke.table_name

  Joke.table_name = "funny_jokes"
  before_columns = Joke.columns
  before_seq = Joke.sequence_name

  Joke.table_name = "cold_jokes"
  after_columns = Joke.columns
  after_seq = Joke.sequence_name

  assert_not_equal before_columns, after_columns
  assert_not_equal before_seq, after_seq unless before_seq.nil? && after_seq.nil?
ensure
  Joke.table_name = original_table_name
end
test_clone_of_new_object_marks_as_dirty_only_changed_attributes() click to toggle source
# File activerecord/test/cases/base_test.rb, line 856
def test_clone_of_new_object_marks_as_dirty_only_changed_attributes
  developer = Developer.new name: "Bjorn"
  assert developer.name_changed?            # obviously
  assert !developer.salary_changed?         # attribute has non-nil default value, so treated as not changed

  cloned_developer = developer.clone
  assert cloned_developer.name_changed?
  assert !cloned_developer.salary_changed?  # ... and cloned instance should behave same
end
test_clone_of_new_object_marks_attributes_as_dirty() click to toggle source
# File activerecord/test/cases/base_test.rb, line 846
def test_clone_of_new_object_marks_attributes_as_dirty
  developer = Developer.new name: "Bjorn", salary: 100000
  assert developer.name_changed?
  assert developer.salary_changed?

  cloned_developer = developer.clone
  assert cloned_developer.name_changed?
  assert cloned_developer.salary_changed?
end
test_clone_of_new_object_with_defaults() click to toggle source
# File activerecord/test/cases/base_test.rb, line 836
def test_clone_of_new_object_with_defaults
  developer = Developer.new
  assert !developer.name_changed?
  assert !developer.salary_changed?

  cloned_developer = developer.clone
  assert !cloned_developer.name_changed?
  assert !cloned_developer.salary_changed?
end
test_clone_preserves_subtype() click to toggle source
# File activerecord/test/cases/base_test.rb, line 830
def test_clone_preserves_subtype
  clone = nil
  assert_nothing_raised { clone = Company.find(3).clone }
  assert_kind_of Client, clone
end
test_column_name_properly_quoted() click to toggle source
# File activerecord/test/cases/base_test.rb, line 931
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
test_column_names_are_escaped() click to toggle source
# File activerecord/test/cases/base_test.rb, line 71
def test_column_names_are_escaped
  conn      = ActiveRecord::Base.connection
  classname = conn.class.name[/[^:]*$/]
  badchar   = {
    "SQLite3Adapter"    => '"',
    "Mysql2Adapter"     => "`",
    "PostgreSQLAdapter" => '"',
    "OracleAdapter"     => '"',
    "FbAdapter"         => '"'
  }.fetch(classname) {
    raise "need a bad char for #{classname}"
  }

  quoted = conn.quote_column_name "foo#{badchar}bar"
  if current_adapter?(:OracleAdapter)
    # Oracle does not allow double quotes in table and column names at all
    # therefore quoting removes them
    assert_equal("#{badchar}foobar#{badchar}", quoted)
  else
    assert_equal("#{badchar}foo#{badchar * 2}bar#{badchar}", quoted)
  end
end
test_column_types_typecast() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1310
def test_column_types_typecast
  topic = Topic.first
  assert_not_equal "t.lo", topic.author_name

  attrs = topic.attributes.dup
  attrs.delete "id"

  typecast = Class.new(ActiveRecord::Type::Value) {
    def cast(value)
      "t.lo"
    end
  }

  types = { "author_name" => typecast.new }
  topic = Topic.instantiate(attrs, types)

  assert_equal "t.lo", topic.author_name
end
test_columns_should_obey_set_primary_key() click to toggle source
# File activerecord/test/cases/base_test.rb, line 94
def test_columns_should_obey_set_primary_key
  pk = Subscriber.columns_hash[Subscriber.primary_key]
  assert_equal "nick", pk.name, "nick should be primary key"
end
test_comparison_with_different_objects() click to toggle source
# File activerecord/test/cases/base_test.rb, line 618
def test_comparison_with_different_objects
  topic = Topic.create
  category = Category.create(name: "comparison")
  assert_nil topic <=> category
end
test_comparison_with_different_objects_in_array() click to toggle source
# File activerecord/test/cases/base_test.rb, line 624
def test_comparison_with_different_objects_in_array
  topic = Topic.create
  assert_raises(ArgumentError) do
    [1, topic].sort
  end
end
test_count_with_join() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1062
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.where("posts.#{QUOTED_TYPE} = 'Post'").joins("LEFT JOIN comments ON posts.id=comments.post_id").count
  assert_equal res, res2

  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 = Post.where("p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id").joins("p, comments co").select("p.id").count
  assert_equal res4, res5

  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 = Post.where("p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id").joins("p, comments co").select("p.id").distinct.count
  assert_equal res6, res7
end
test_create_after_initialize_with_array_param() click to toggle source
# File activerecord/test/cases/base_test.rb, line 305
def test_create_after_initialize_with_array_param
  cbs = CustomBulb.create([{ name: "Dude" }, { name: "Bob" }])
  assert_equal "Dude", cbs[0].name
  assert_equal "Bob", cbs[1].name
  assert cbs[0].frickinawesome
  assert !cbs[1].frickinawesome
end
test_create_after_initialize_with_block() click to toggle source
# File activerecord/test/cases/base_test.rb, line 299
def test_create_after_initialize_with_block
  cb = CustomBulb.create { |c| c.name = "Dude" }
  assert_equal("Dude", cb.name)
  assert_equal(true, cb.frickinawesome)
end
test_create_after_initialize_without_block() click to toggle source
# File activerecord/test/cases/base_test.rb, line 293
def test_create_after_initialize_without_block
  cb = CustomBulb.create(name: "Dude")
  assert_equal("Dude", cb.name)
  assert_equal(true, cb.frickinawesome)
end
test_create_without_prepared_statement() click to toggle source
# File activerecord/test/cases/base_test.rb, line 601
def test_create_without_prepared_statement
  topic = Topic.connection.unprepared_statement do
    Topic.create(title: "foo")
  end

  assert_equal topic, Topic.find(topic.id)
end
test_current_scope_is_reset() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1191
def test_current_scope_is_reset
  Object.const_set :UnloadablePost, Class.new(ActiveRecord::Base)
  UnloadablePost.send(:current_scope=, UnloadablePost.all)

  UnloadablePost.unloadable
  klass = UnloadablePost
  assert_not_nil ActiveRecord::Scoping::ScopeRegistry.value_for(:current_scope, klass)
  ActiveSupport::Dependencies.remove_unloadable_constants!
  assert_nil ActiveRecord::Scoping::ScopeRegistry.value_for(:current_scope, klass)
ensure
  Object.class_eval { remove_const :UnloadablePost } if defined?(UnloadablePost)
end
test_custom_mutator() click to toggle source
# File activerecord/test/cases/base_test.rb, line 271
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
test_default() click to toggle source
# File activerecord/test/cases/base_test.rb, line 903
def test_default
  with_timezone_config default: :local do
    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
end
test_default_values() click to toggle source
# File activerecord/test/cases/base_test.rb, line 451
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
test_default_values_are_deeply_dupped() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1355
def test_default_values_are_deeply_dupped
  company = Company.new
  company.description << "foo"
  assert_equal "", Company.new.description
end
test_default_values_on_empty_strings() click to toggle source
# File activerecord/test/cases/base_test.rb, line 499
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

  assert_nil topic.approved
end
test_destroy_without_prepared_statement() click to toggle source
# File activerecord/test/cases/base_test.rb, line 609
def test_destroy_without_prepared_statement
  topic = Topic.create(title: "foo")
  Topic.connection.unprepared_statement do
    Topic.find(topic.id).destroy
  end

  assert_nil Topic.find_by_id(topic.id)
end
test_distinct_delegates_to_scoped() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1302
def test_distinct_delegates_to_scoped
  assert_equal Bird.all.distinct, Bird.distinct
end
test_dont_clear_inheritance_column_when_setting_explicitly() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1016
def test_dont_clear_inheritance_column_when_setting_explicitly
  k = Class.new(Joke)
  k.inheritance_column = "my_type"
  before_inherit = k.inheritance_column

  k.reset_column_information
  after_inherit = k.inheritance_column

  assert_equal before_inherit, after_inherit unless before_inherit.blank? && after_inherit.blank?
end
test_dont_clear_sequence_name_when_setting_explicitly() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1004
def test_dont_clear_sequence_name_when_setting_explicitly
  k = Class.new(Joke)
  k.sequence_name = "black_jokes_seq"
  k.table_name = "cold_jokes"
  before_seq = k.sequence_name

  k.table_name = "funny_jokes"
  after_seq = k.sequence_name

  assert_equal before_seq, after_seq unless before_seq.nil? && after_seq.nil?
end
test_dup() click to toggle source
# File activerecord/test/cases/base_test.rb, line 766
def test_dup
  topic = Topic.find(1)
  duped_topic = nil
  assert_nothing_raised { duped_topic = topic.dup }
  assert_equal topic.title, duped_topic.title
  assert !duped_topic.persisted?

  # test if the attributes have been duped
  topic.title = "a"
  duped_topic.title = "b"
  assert_equal "a", topic.title
  assert_equal "b", duped_topic.title

  # test if the attribute values have been duped
  duped_topic = topic.dup
  duped_topic.title.replace "c"
  assert_equal "a", topic.title

  # test if attributes set as part of after_initialize are duped correctly
  assert_equal topic.author_email_address, duped_topic.author_email_address

  # test if saved clone object differs from original
  duped_topic.save
  assert duped_topic.persisted?
  assert_not_equal duped_topic.id, topic.id

  duped_topic.reload
  assert_equal("c", duped_topic.title)
end
test_dup_does_not_copy_associations() click to toggle source
# File activerecord/test/cases/base_test.rb, line 822
def test_dup_does_not_copy_associations
  author = authors(:david)
  assert_not_equal [], author.posts

  author_dup = author.dup
  assert_equal [], author_dup.posts
end
test_dup_of_saved_object_marks_as_dirty_only_changed_attributes() click to toggle source
# File activerecord/test/cases/base_test.rb, line 876
def test_dup_of_saved_object_marks_as_dirty_only_changed_attributes
  developer = Developer.create! name: "Bjorn"
  assert !developer.name_changed?           # both attributes of saved object should be treated as not changed
  assert !developer.salary_changed?

  cloned_developer = developer.dup
  assert cloned_developer.name_changed?     # ... but on cloned object should be
  assert !cloned_developer.salary_changed?  # ... BUT salary has non-nil default which should be treated as not changed on cloned instance
end
test_dup_of_saved_object_marks_attributes_as_dirty() click to toggle source
# File activerecord/test/cases/base_test.rb, line 866
def test_dup_of_saved_object_marks_attributes_as_dirty
  developer = Developer.create! name: "Bjorn", salary: 100000
  assert !developer.name_changed?
  assert !developer.salary_changed?

  cloned_developer = developer.dup
  assert cloned_developer.name_changed?     # both attributes differ from defaults
  assert cloned_developer.salary_changed?
end
test_dup_with_aggregate_of_same_name_as_attribute() click to toggle source
# File activerecord/test/cases/base_test.rb, line 797
def test_dup_with_aggregate_of_same_name_as_attribute
  developer_with_aggregate = Class.new(ActiveRecord::Base) do
    self.table_name = "developers"
    composed_of :salary, class_name: "BasicsTest::DeveloperSalary", mapping: [%w(salary amount)]
  end

  dev = developer_with_aggregate.find(1)
  assert_kind_of DeveloperSalary, dev.salary

  dup = nil
  assert_nothing_raised { dup = dev.dup }
  assert_kind_of DeveloperSalary, dup.salary
  assert_equal dev.salary.amount, dup.salary.amount
  assert !dup.persisted?

  # test if the attributes have been duped
  original_amount = dup.salary.amount
  dev.salary.amount = 1
  assert_equal original_amount, dup.salary.amount

  assert dup.save
  assert dup.persisted?
  assert_not_equal dup.id, dev.id
end
test_equality() click to toggle source
# File activerecord/test/cases/base_test.rb, line 512
def test_equality
  assert_equal Topic.find(1), Topic.find(2).topic
end
test_equality_of_collection_proxy_and_association_relation() click to toggle source
# File activerecord/test/cases/base_test.rb, line 575
def test_equality_of_collection_proxy_and_association_relation
  car = Car.create!
  car.bulbs.build
  car.save

  assert_equal car.bulbs, car.bulbs.includes(:car), "CollectionProxy should be comparable with AssociationRelation"
  assert_equal car.bulbs.includes(:car), car.bulbs, "AssociationRelation should be comparable with CollectionProxy"
end
test_equality_of_destroyed_records() click to toggle source
# File activerecord/test/cases/base_test.rb, line 534
def test_equality_of_destroyed_records
  topic_1 = Topic.new(title: "test_1")
  topic_1.save
  topic_2 = Topic.find(topic_1.id)
  topic_1.destroy
  assert_equal topic_1, topic_2
  assert_equal topic_2, topic_1
end
test_equality_of_new_records() click to toggle source
# File activerecord/test/cases/base_test.rb, line 529
def test_equality_of_new_records
  assert_not_equal Topic.new, Topic.new
  assert_equal false, Topic.new == Topic.new
end
test_equality_of_relation_and_array() click to toggle source
# File activerecord/test/cases/base_test.rb, line 558
def test_equality_of_relation_and_array
  car = Car.create!
  car.bulbs.build
  car.save

  assert Bulb.where(car_id: car.id) == car.bulbs.to_a, "Relation should be comparable with Array"
end
test_equality_of_relation_and_association_relation() click to toggle source
# File activerecord/test/cases/base_test.rb, line 566
def test_equality_of_relation_and_association_relation
  car = Car.create!
  car.bulbs.build
  car.save

  assert_equal Bulb.where(car_id: car.id), car.bulbs.includes(:car), "Relation should be comparable with AssociationRelation"
  assert_equal car.bulbs.includes(:car), Bulb.where(car_id: car.id), "AssociationRelation should be comparable with Relation"
end
test_equality_of_relation_and_collection_proxy() click to toggle source
# File activerecord/test/cases/base_test.rb, line 549
def test_equality_of_relation_and_collection_proxy
  car = Car.create!
  car.bulbs.build
  car.save

  assert car.bulbs == Bulb.where(car_id: car.id), "CollectionProxy should be comparable with Relation"
  assert Bulb.where(car_id: car.id) == car.bulbs, "Relation should be comparable with CollectionProxy"
end
test_equality_with_blank_ids() click to toggle source
# File activerecord/test/cases/base_test.rb, line 543
def test_equality_with_blank_ids
  one = Subscriber.new(id: "")
  two = Subscriber.new(id: "")
  assert_equal one, two
end
test_failed_comparison_of_unlike_class_records() click to toggle source
# File activerecord/test/cases/base_test.rb, line 595
def test_failed_comparison_of_unlike_class_records
  assert_raises ArgumentError do
    [ topics(:first), posts(:welcome) ].sort
  end
end
test_find_by_slug() click to toggle source
# File activerecord/test/cases/base_test.rb, line 516
def test_find_by_slug
  assert_equal Topic.find("1-meowmeow"), Topic.find(1)
end
test_find_by_slug_with_array() click to toggle source
# File activerecord/test/cases/base_test.rb, line 520
def test_find_by_slug_with_array
  assert_equal Topic.find([1, 2]), Topic.find(["1-meowmeow", "2-hello"])
  assert_equal "The Second Topic of the day", Topic.find(["2-hello", "1-meowmeow"]).first.title
end
test_find_by_slug_with_range() click to toggle source
# File activerecord/test/cases/base_test.rb, line 525
def test_find_by_slug_with_range
  assert_equal Topic.where(id: "1-meowmeow".."2-hello"), Topic.where(id: 1..2)
end
test_find_keeps_multiple_group_values() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1121
def test_find_keeps_multiple_group_values
  combined = Developer.all.merge!(group: "developers.name, developers.salary, developers.id, developers.created_at, developers.updated_at, developers.created_on, developers.updated_on").to_a
  assert_equal combined, Developer.all.merge!(group: ["developers.name", "developers.salary", "developers.id", "developers.created_at", "developers.updated_at", "developers.created_on", "developers.updated_on"]).to_a
end
test_find_keeps_multiple_order_values() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1116
def test_find_keeps_multiple_order_values
  combined = Developer.all.merge!(order: "developers.name, developers.salary").to_a
  assert_equal combined, Developer.all.merge!(order: ["developers.name", "developers.salary"]).to_a
end
test_find_last() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1082
def test_find_last
  last = Developer.last
  assert_equal last, Developer.all.merge!(order: "id desc").first
end
test_find_multiple_ordered_last() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1111
def test_find_multiple_ordered_last
  last = Developer.all.merge!(order: "developers.name, developers.salary DESC").last
  assert_equal last, Developer.all.merge!(order: "developers.name, developers.salary DESC").to_a.last
end
test_find_on_abstract_base_class_doesnt_use_type_condition() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1135
def test_find_on_abstract_base_class_doesnt_use_type_condition
  old_class = LooseDescendant
  Object.send :remove_const, :LooseDescendant

  descendant = old_class.create! first_name: "bob"
  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
test_find_ordered_last() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1101
def test_find_ordered_last
  last = Developer.all.merge!(order: "developers.salary ASC").last
  assert_equal last, Developer.all.merge!(order: "developers.salary ASC").to_a.last
end
test_find_reverse_ordered_last() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1106
def test_find_reverse_ordered_last
  last = Developer.all.merge!(order: "developers.salary DESC").last
  assert_equal last, Developer.all.merge!(order: "developers.salary DESC").to_a.last
end
test_find_symbol_ordered_last() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1126
def test_find_symbol_ordered_last
  last = Developer.all.merge!(order: :salary).last
  assert_equal last, Developer.all.merge!(order: :salary).to_a.last
end
test_group_weirds_by_from() click to toggle source
# File activerecord/test/cases/base_test.rb, line 676
def test_group_weirds_by_from
  Weird.create("a$b" => "value", :from => "aaron")
  count = Weird.group(Weird.arel_table[:from]).count
  assert_equal 1, count["aaron"]
end
test_has_attribute() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1274
def test_has_attribute
  assert Company.has_attribute?("id")
  assert Company.has_attribute?("type")
  assert Company.has_attribute?("name")
  assert_not Company.has_attribute?("lastname")
  assert_not Company.has_attribute?("age")
end
test_has_attribute_with_symbol() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1282
def test_has_attribute_with_symbol
  assert Company.has_attribute?(:id)
  assert_not Company.has_attribute?(:age)
end
test_hashing() click to toggle source
# File activerecord/test/cases/base_test.rb, line 584
def test_hashing
  assert_equal [ Topic.find(1) ], [ Topic.find(2).topic ] & [ Topic.find(1) ]
end
test_initialize_with_attributes() click to toggle source
# File activerecord/test/cases/base_test.rb, line 278
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
test_initialize_with_invalid_attribute() click to toggle source
# File activerecord/test/cases/base_test.rb, line 285
def test_initialize_with_invalid_attribute
  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
test_invalid_limit() click to toggle source
# File activerecord/test/cases/base_test.rb, line 126
def test_invalid_limit
  assert_raises(ArgumentError) do
    Topic.limit("asdfadf").to_a
  end
end
test_last() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1087
def test_last
  assert_equal Developer.all.merge!(order: "id desc").first, Developer.last
end
test_limit_should_sanitize_sql_injection_for_limit_with_commas() click to toggle source
# File activerecord/test/cases/base_test.rb, line 138
def test_limit_should_sanitize_sql_injection_for_limit_with_commas
  assert_raises(ArgumentError) do
    Topic.limit("1, 7 procedure help()").to_a
  end
end
test_limit_should_sanitize_sql_injection_for_limit_without_commas() click to toggle source
# File activerecord/test/cases/base_test.rb, line 132
def test_limit_should_sanitize_sql_injection_for_limit_without_commas
  assert_raises(ArgumentError) do
    Topic.limit("1 select * from schema").to_a
  end
end
test_limit_should_take_value_from_latest_limit() click to toggle source
# File activerecord/test/cases/base_test.rb, line 122
def test_limit_should_take_value_from_latest_limit
  assert_equal 1, Topic.limit(2).limit(1).to_a.length
end
test_limit_without_comma() click to toggle source
# File activerecord/test/cases/base_test.rb, line 117
def test_limit_without_comma
  assert_equal 1, Topic.limit("1").to_a.length
  assert_equal 1, Topic.limit(1).to_a.length
end
test_load() click to toggle source
# File activerecord/test/cases/base_test.rb, line 313
def test_load
  topics = Topic.all.merge!(order: "id").to_a
  assert_equal(5, topics.size)
  assert_equal(topics(:first).title, topics.first.title)
end
test_load_with_condition() click to toggle source
# File activerecord/test/cases/base_test.rb, line 319
def test_load_with_condition
  topics = Topic.all.merge!(where: "author_name = 'Mary'").to_a

  assert_equal(1, topics.size)
  assert_equal(topics(:second).title, topics.first.title)
end
test_many_mutations() click to toggle source
# File activerecord/test/cases/base_test.rb, line 110
def test_many_mutations
  car = Car.new name: "<3<3<3"
  car.engines_count = 0
  20_000.times { car.engines_count += 1 }
  assert car.save
end
test_marshal_between_processes() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1230
def test_marshal_between_processes
  # Define a new model to ensure there are no caches
  if self.class.const_defined?("Post", false)
    flunk "there should be no post constant"
  end

  self.class.const_set("Post", Class.new(ActiveRecord::Base) {
    has_many :comments
  })

  rd, wr = IO.pipe
  rd.binmode
  wr.binmode

  ActiveRecord::Base.connection_handler.clear_all_connections!

  fork do
    rd.close
    post = Post.new
    post.comments.build
    wr.write Marshal.dump(post)
    wr.close
  end

  wr.close
  assert Marshal.load rd.read
  rd.close
end
test_marshal_new_record_round_trip() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1212
def test_marshal_new_record_round_trip
  marshalled = Marshal.dump(Post.new)
  post       = Marshal.load(marshalled)

  assert post.new_record?, "should be a new record"
end
test_marshal_round_trip() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1204
def test_marshal_round_trip
  expected = posts(:welcome)
  marshalled = Marshal.dump(expected)
  actual = Marshal.load(marshalled)

  assert_equal expected.attributes, actual.attributes
end
test_marshalling_new_record_round_trip_with_associations() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1260
def test_marshalling_new_record_round_trip_with_associations
  post = Post.new
  post.comments.build

  post = Marshal.load(Marshal.dump(post))

  assert post.new_record?, "should be a new record"
end
test_marshalling_with_associations() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1219
def test_marshalling_with_associations
  post = Post.new
  post.comments.build

  marshalled = Marshal.dump(post)
  post       = Marshal.load(marshalled)

  assert_equal 1, post.comments.length
end
test_new_record_returns_boolean() click to toggle source
# File activerecord/test/cases/base_test.rb, line 761
def test_new_record_returns_boolean
  assert_equal false, Topic.new.persisted?
  assert_equal true, Topic.find(1).persisted?
end
test_no_limit_offset() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1076
def test_no_limit_offset
  assert_nothing_raised do
    Developer.all.merge!(offset: 2).to_a
  end
end
test_non_valid_identifier_column_name() click to toggle source
# File activerecord/test/cases/base_test.rb, line 664
def test_non_valid_identifier_column_name
  weird = Weird.create("a$b" => "value")
  weird.reload
  assert_equal "value", weird.send("a$b")
  assert_equal "value", weird.read_attribute("a$b")

  weird.update_columns("a$b" => "value2")
  weird.reload
  assert_equal "value2", weird.send("a$b")
  assert_equal "value2", weird.read_attribute("a$b")
end
test_null_fields() click to toggle source
# File activerecord/test/cases/base_test.rb, line 446
def test_null_fields
  assert_nil Topic.find(1).parent_id
  assert_nil Topic.create("title" => "Hey you").parent_id
end
test_preserving_date_objects() click to toggle source
# File activerecord/test/cases/base_test.rb, line 154
def test_preserving_date_objects
  # Oracle enhanced adapter allows to define Date attributes in model class (see topic.rb)
  assert_kind_of(
    Date, Topic.find(1).last_read,
    "The last_read attribute should be of the Date class"
  )
end
test_preserving_time_objects() click to toggle source
# File activerecord/test/cases/base_test.rb, line 187
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 subsecond_precision_supported?
    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
    assert_equal 129346, Topic.find(3).written_on.usec
  end
end
test_preserving_time_objects_with_local_time_conversion_to_default_timezone_utc() click to toggle source
# File activerecord/test/cases/base_test.rb, line 207
def test_preserving_time_objects_with_local_time_conversion_to_default_timezone_utc
  with_env_tz eastern_time_zone do
    with_timezone_config default: :utc do
      time = Time.local(2000)
      topic = Topic.create("written_on" => time)
      saved_time = Topic.find(topic.id).reload.written_on
      assert_equal time, saved_time
      assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "EST"], time.to_a
      assert_equal [0, 0, 5, 1, 1, 2000, 6, 1, false, "UTC"], saved_time.to_a
    end
  end
end
test_preserving_time_objects_with_time_with_zone_conversion_to_default_timezone_local() click to toggle source
# File activerecord/test/cases/base_test.rb, line 248
def test_preserving_time_objects_with_time_with_zone_conversion_to_default_timezone_local
  with_env_tz eastern_time_zone do
    with_timezone_config default: :local do
      Time.use_zone "Central Time (US & Canada)" do
        time = Time.zone.local(2000)
        topic = Topic.create("written_on" => time)
        saved_time = Topic.find(topic.id).reload.written_on
        assert_equal time, saved_time
        assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "CST"], time.to_a
        assert_equal [0, 0, 1, 1, 1, 2000, 6, 1, false, "EST"], saved_time.to_a
      end
    end
  end
end
test_preserving_time_objects_with_time_with_zone_conversion_to_default_timezone_utc() click to toggle source
# File activerecord/test/cases/base_test.rb, line 220
def test_preserving_time_objects_with_time_with_zone_conversion_to_default_timezone_utc
  with_env_tz eastern_time_zone do
    with_timezone_config default: :utc do
      Time.use_zone "Central Time (US & Canada)" do
        time = Time.zone.local(2000)
        topic = Topic.create("written_on" => time)
        saved_time = Topic.find(topic.id).reload.written_on
        assert_equal time, saved_time
        assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "CST"], time.to_a
        assert_equal [0, 0, 6, 1, 1, 2000, 6, 1, false, "UTC"], saved_time.to_a
      end
    end
  end
end
test_preserving_time_objects_with_utc_time_conversion_to_default_timezone_local() click to toggle source
# File activerecord/test/cases/base_test.rb, line 235
def test_preserving_time_objects_with_utc_time_conversion_to_default_timezone_local
  with_env_tz eastern_time_zone do
    with_timezone_config default: :local do
      time = Time.utc(2000)
      topic = Topic.create("written_on" => time)
      saved_time = Topic.find(topic.id).reload.written_on
      assert_equal time, saved_time
      assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "UTC"], time.to_a
      assert_equal [0, 0, 19, 31, 12, 1999, 5, 365, false, "EST"], saved_time.to_a
    end
  end
end
test_previously_changed() click to toggle source
# File activerecord/test/cases/base_test.rb, line 162
def test_previously_changed
  topic = Topic.first
  topic.title = "<3<3<3"
  assert_equal({}, topic.previous_changes)

  topic.save!
  expected = ["The First Topic", "<3<3<3"]
  assert_equal(expected, topic.previous_changes["title"])
end
test_previously_changed_dup() click to toggle source
# File activerecord/test/cases/base_test.rb, line 172
def test_previously_changed_dup
  topic = Topic.first
  topic.title = "<3<3<3"
  topic.save!

  t2 = topic.dup

  assert_equal(topic.previous_changes, t2.previous_changes)

  topic.title = "lolwut"
  topic.save!

  assert_not_equal(topic.previous_changes, t2.previous_changes)
end
test_primary_key_and_references_columns_should_be_identical_type() click to toggle source
# File activerecord/test/cases/base_test.rb, line 103
def test_primary_key_and_references_columns_should_be_identical_type
  pk = Author.columns_hash["id"]
  ref = Post.columns_hash["author_id"]

  assert_equal pk.bigint?, ref.bigint?
end
test_primary_key_with_no_id() click to toggle source
# File activerecord/test/cases/base_test.rb, line 99
def test_primary_key_with_no_id
  assert_nil Edge.primary_key
end
test_quote() click to toggle source
# File activerecord/test/cases/base_test.rb, line 949
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
test_quoted_table_name_after_set_table_name() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1033
def test_quoted_table_name_after_set_table_name
  klass = Class.new(ActiveRecord::Base)

  klass.table_name = "foo"
  assert_equal "foo", klass.table_name
  assert_equal klass.connection.quote_table_name("foo"), klass.quoted_table_name

  klass.table_name = "bar"
  assert_equal "bar", klass.table_name
  assert_equal klass.connection.quote_table_name("bar"), klass.quoted_table_name
end
test_quoting_arrays() click to toggle source
# File activerecord/test/cases/base_test.rb, line 941
def test_quoting_arrays
  replies = Reply.all.merge!(where: [ "id IN (?)", topics(:first).replies.collect(&:id) ]).to_a
  assert_equal topics(:first).replies.size, replies.size

  replies = Reply.all.merge!(where: [ "id IN (?)", [] ]).to_a
  assert_equal 0, replies.size
end
test_readonly_attributes() click to toggle source
# File activerecord/test/cases/base_test.rb, line 631
def test_readonly_attributes
  assert_equal Set.new([ "title" , "comments_count" ]), ReadonlyTitlePost.readonly_attributes

  post = ReadonlyTitlePost.create(title: "cannot change this", body: "changeable")
  post.reload
  assert_equal "cannot change this", post.title

  post.update(title: "try to change", body: "changed")
  post.reload
  assert_equal "cannot change this", post.title
  assert_equal "changed", post.body
end
test_reload() click to toggle source
# File activerecord/test/cases/base_test.rb, line 966
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
test_respect_internal_encoding() click to toggle source
# File activerecord/test/cases/base_test.rb, line 651
def test_respect_internal_encoding
  old_default_internal = Encoding.default_internal
  silence_warnings { Encoding.default_internal = "EUC-JP" }

  Weird.reset_column_information

  assert_equal ["EUC-JP"], Weird.columns.map { |c| c.name.encoding.name }.uniq
ensure
  silence_warnings { Encoding.default_internal = old_default_internal }
  Weird.reset_column_information
end
test_select_symbol() click to toggle source
# File activerecord/test/cases/base_test.rb, line 144
def test_select_symbol
  topic_ids = Topic.select(:id).map(&:id).sort
  assert_equal Topic.pluck(:id).sort, topic_ids
end
test_sequence_name_with_abstract_class() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1052
def test_sequence_name_with_abstract_class
  ak = Class.new(ActiveRecord::Base)
  ak.abstract_class = true
  k = Class.new(ak)
  k.table_name = "projects"
  orig_name = k.sequence_name
  skip "sequences not supported by db" unless orig_name
  assert_equal k.reset_sequence_name, orig_name
end
test_set_table_name_symbol_converted_to_string() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1027
def test_set_table_name_symbol_converted_to_string
  k = Class.new(Joke)
  k.table_name = :cold_jokes
  assert_equal "cold_jokes", k.table_name
end
test_set_table_name_with_inheritance() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1045
def test_set_table_name_with_inheritance
  k = Class.new(ActiveRecord::Base)
  def k.name; "Foo"; end
  def k.table_name; super + "ks"; end
  assert_equal "foosks", k.table_name
end
test_singular_table_name_guesses() click to toggle source
# File activerecord/test/cases/base_test.rb, line 343
def test_singular_table_name_guesses
  ActiveRecord::Base.pluralize_table_names = false
  GUESSED_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
ensure
  ActiveRecord::Base.pluralize_table_names = true
  GUESSED_CLASSES.each(&:reset_table_name)
end
test_singular_table_name_guesses_for_individual_table() click to toggle source
# File activerecord/test/cases/base_test.rb, line 430
def test_singular_table_name_guesses_for_individual_table
  Post.pluralize_table_names = false
  Post.reset_table_name
  assert_equal "post", Post.table_name
  assert_equal "categories", Category.table_name
ensure
  Post.pluralize_table_names = true
  Post.reset_table_name
end
test_singular_table_name_guesses_with_prefixes_and_suffixes() click to toggle source
# File activerecord/test/cases/base_test.rb, line 379
def test_singular_table_name_guesses_with_prefixes_and_suffixes
  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
ensure
  ActiveRecord::Base.pluralize_table_names = true
  ActiveRecord::Base.table_name_prefix = ""
  ActiveRecord::Base.table_name_suffix = ""
  GUESSED_CLASSES.each(&:reset_table_name)
end
test_slice() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1333
def test_slice
  company = Company.new(rating: 1, name: "37signals", firm_name: "37signals")
  hash = company.slice(:name, :rating, "arbitrary_method")
  assert_equal hash[:name], company.name
  assert_equal hash["name"], company.name
  assert_equal hash[:rating], company.rating
  assert_equal hash["arbitrary_method"], company.arbitrary_method
  assert_equal hash[:arbitrary_method], company.arbitrary_method
  assert_nil hash[:firm_name]
  assert_nil hash["firm_name"]
end
test_slice_accepts_array_argument() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1345
def test_slice_accepts_array_argument
  attrs = {
    title: "slice",
    author_name: "@Cohen-Carlisle",
    content: "accept arrays so I don't have to splat"
  }.with_indifferent_access
  topic = Topic.new(attrs)
  assert_equal attrs, topic.slice(attrs.keys)
end
test_sql_injection_via_find() click to toggle source
# File activerecord/test/cases/base_test.rb, line 925
def test_sql_injection_via_find
  assert_raise(ActiveRecord::RecordNotFound, ActiveRecord::StatementInvalid) do
    Topic.find("123456 OR id > 0")
  end
end
test_successful_comparison_of_like_class_records() click to toggle source
# File activerecord/test/cases/base_test.rb, line 588
def test_successful_comparison_of_like_class_records
  topic_1 = Topic.create!
  topic_2 = Topic.create!

  assert_equal [topic_2, topic_1].sort, [topic_1, topic_2]
end
test_switching_between_table_name() click to toggle source
# File activerecord/test/cases/base_test.rb, line 975
def test_switching_between_table_name
  k = Class.new(Joke)

  assert_difference("GoodJoke.count") do
    k.table_name = "cold_jokes"
    k.create

    k.table_name = "funny_jokes"
    k.create
  end
end
test_table_exists() click to toggle source
# File activerecord/test/cases/base_test.rb, line 149
def test_table_exists
  assert !NonExistentTable.table_exists?
  assert Topic.table_exists?
end
test_table_name_guesses() click to toggle source
# File activerecord/test/cases/base_test.rb, line 328
def test_table_name_guesses
  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
ensure
  GUESSED_CLASSES.each(&:reset_table_name)
end
test_table_name_guesses_with_inherited_prefixes_and_suffixes() click to toggle source
# File activerecord/test/cases/base_test.rb, line 401
def test_table_name_guesses_with_inherited_prefixes_and_suffixes
  GUESSED_CLASSES.each(&:reset_table_name)

  CreditCard.table_name_prefix = "test_"
  CreditCard.reset_table_name
  Category.reset_table_name
  assert_equal "test_credit_cards", CreditCard.table_name
  assert_equal "categories", Category.table_name
  CreditCard.table_name_suffix = "_test"
  CreditCard.reset_table_name
  Category.reset_table_name
  assert_equal "test_credit_cards_test", CreditCard.table_name
  assert_equal "categories", Category.table_name
  CreditCard.table_name_prefix = ""
  CreditCard.reset_table_name
  Category.reset_table_name
  assert_equal "credit_cards_test", CreditCard.table_name
  assert_equal "categories", Category.table_name
  CreditCard.table_name_suffix = ""
  CreditCard.reset_table_name
  Category.reset_table_name
  assert_equal "credit_cards", CreditCard.table_name
  assert_equal "categories", Category.table_name
ensure
  CreditCard.table_name_prefix = ""
  CreditCard.table_name_suffix = ""
  GUESSED_CLASSES.each(&:reset_table_name)
end
test_table_name_guesses_with_prefixes_and_suffixes() click to toggle source
# File activerecord/test/cases/base_test.rb, line 360
def test_table_name_guesses_with_prefixes_and_suffixes
  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
ensure
  ActiveRecord::Base.table_name_prefix = ""
  ActiveRecord::Base.table_name_suffix = ""
  GUESSED_CLASSES.each(&:reset_table_name)
end
test_table_name_with_2_abstract_subclasses() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1306
def test_table_name_with_2_abstract_subclasses
  assert_equal "photos", Photo.table_name
end
test_toggle_attribute() click to toggle source
# File activerecord/test/cases/base_test.rb, line 955
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
test_touch_should_raise_error_on_a_new_object() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1295
def test_touch_should_raise_error_on_a_new_object
  company = Company.new(rating: 1, name: "37signals", firm_name: "37signals")
  assert_raises(ActiveRecord::ActiveRecordError) do
    company.touch :updated_at
  end
end
test_typecasting_aliases() click to toggle source
# File activerecord/test/cases/base_test.rb, line 1329
def test_typecasting_aliases
  assert_equal 10, Topic.select("10 as tenderlove").first.tenderlove
end
test_unicode_column_name() click to toggle source
# File activerecord/test/cases/base_test.rb, line 644
def test_unicode_column_name
  Weird.reset_column_information
  weird = Weird.create(なまえ: "たこ焼き仮面")
  assert_equal "たこ焼き仮面", weird.なまえ
end
test_update_all_with_order_and_limit() click to toggle source
# File activerecord/test/cases/base_test.rb, line 441
def test_update_all_with_order_and_limit
  assert_equal 1, Topic.limit(1).order("id DESC").update_all(content: "bulk updated!")
end
test_utc_as_time_zone() click to toggle source
# File activerecord/test/cases/base_test.rb, line 476
def test_utc_as_time_zone
  with_timezone_config default: :utc do
    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
  end
end
test_utc_as_time_zone_and_new() click to toggle source
# File activerecord/test/cases/base_test.rb, line 485
def test_utc_as_time_zone_and_new
  with_timezone_config default: :utc do
    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
  end
end