1
0
Fork 0
mirror of https://github.com/rails/rails.git synced 2022-11-09 12:12:34 -05:00
rails--rails/activerecord/test/cases/persistence_test.rb
2016-02-03 22:08:13 +09:00

1001 lines
31 KiB
Ruby

require "cases/helper"
require 'models/aircraft'
require 'models/post'
require 'models/comment'
require 'models/author'
require 'models/topic'
require 'models/reply'
require 'models/category'
require 'models/company'
require 'models/developer'
require 'models/computer'
require 'models/project'
require 'models/minimalistic'
require 'models/warehouse_thing'
require 'models/parrot'
require 'models/minivan'
require 'models/owner'
require 'models/person'
require 'models/pet'
require 'models/ship'
require 'models/toy'
require 'models/admin'
require 'models/admin/user'
require 'rexml/document'
class PersistenceTest < ActiveRecord::TestCase
fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, 'warehouse-things', :authors, :author_addresses, :categorizations, :categories, :posts, :minivans, :pets, :toys
# Oracle UPDATE does not support ORDER BY
unless current_adapter?(:OracleAdapter)
def test_update_all_ignores_order_without_limit_from_association
author = authors(:david)
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_all_doesnt_ignore_order
assert_equal authors(:david).id + 1, authors(:mary).id # make sure there is going to be a duplicate PK error
test_update_with_order_succeeds = lambda do |order|
begin
Author.order(order).update_all('id = id + 1')
rescue ActiveRecord::ActiveRecordError
false
end
end
if test_update_with_order_succeeds.call('id DESC')
assert !test_update_with_order_succeeds.call('id ASC') # test that this wasn't a fluke and using an incorrect order results in an exception
else
# test that we're failing because the current Arel's engine doesn't support UPDATE ORDER BY queries is using subselects instead
assert_sql(/\AUPDATE .+ \(SELECT .* ORDER BY id DESC\)\Z/i) do
test_update_with_order_succeeds.call('id DESC')
end
end
end
def test_update_all_with_order_and_limit_updates_subset_only
author = authors(:david)
assert_nothing_raised do
assert_equal 1, author.posts_sorted_by_id_limited.size
assert_equal 2, author.posts_sorted_by_id_limited.limit(2).to_a.size
assert_equal 1, author.posts_sorted_by_id_limited.update_all([ "body = ?", "bulk update!" ])
assert_equal "bulk update!", posts(:welcome).body
assert_not_equal "bulk update!", posts(:thinking).body
end
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 Topic.count > 0
assert_equal Topic.count, Topic.delete_all
end
def test_delete_all_with_joins_and_where_part_is_hash
where_args = {:toys => {:name => 'Bone'}}
count = Pet.joins(:toys).where(where_args).count
assert_equal count, 1
assert_equal count, Pet.joins(:toys).where(where_args).delete_all
end
def test_delete_all_with_joins_and_where_part_is_not_hash
where_args = ['toys.name = ?', 'Bone']
count = Pet.joins(:toys).where(where_args).count
assert_equal count, 1
assert_equal count, Pet.joins(:toys).where(where_args).delete_all
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_increment_updates_counter_in_db_using_offset
a1 = accounts(:signals37)
initial_credit = a1.credit_limit
a2 = Account.find(accounts(:signals37).id)
a1.increment!(:credit_limit)
a2.increment!(:credit_limit)
assert_equal initial_credit + 2, a1.reload.credit_limit
end
def test_destroy_all
conditions = "author_name = 'Mary'"
topics_by_mary = Topic.all.merge!(:where => conditions, :order => 'id').to_a
assert ! topics_by_mary.empty?
assert_difference('Topic.count', -topics_by_mary.size) do
destroyed = Topic.where(conditions).destroy_all.sort_by(&:id)
assert_equal topics_by_mary, destroyed
assert destroyed.all?(&:frozen?), "destroyed topics should be frozen"
end
end
def test_destroy_many
clients = Client.all.merge!(:order => 'id').find([2, 3])
assert_difference('Client.count', -2) do
destroyed = Client.destroy([2, 3]).sort_by(&:id)
assert_equal clients, destroyed
assert destroyed.all?(&:frozen?), "destroyed clients should be frozen"
end
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_becomes_includes_errors
company = Company.new(:name => nil)
assert !company.valid?
original_errors = company.errors
client = company.becomes(Client)
assert_equal original_errors.keys, client.errors.keys
end
def test_becomes_errors_base
child_class = Class.new(Admin::User) do
store_accessor :settings, :foo
def self.name; 'Admin::ChildUser'; end
end
admin = Admin::User.new
admin.errors.add :token, :invalid
child = admin.becomes(child_class)
assert_equal [:token], child.errors.keys
assert_nothing_raised do
child.errors.add :foo, :invalid
end
end
def test_duped_becomes_persists_changes_from_the_original
original = topics(:first)
copy = original.dup.becomes(Reply)
copy.save!
assert_equal "The First Topic", Topic.find(copy.id).title
end
def test_becomes_includes_changed_attributes
company = Company.new(name: "37signals")
client = company.becomes(Client)
assert_equal "37signals", client.name
assert_equal %w{name}, client.changed
end
def test_delete_many
original_count = Topic.count
Topic.delete(deleting = [1, 2])
assert_equal original_count - deleting.size, Topic.count
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_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 = WrongReply.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_save_with_duping_of_destroyed_object
developer = Developer.first
developer.destroy
new_developer = developer.dup
new_developer.save
assert new_developer.persisted?
assert_not new_developer.destroyed?
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.instantiate(
'attributes' => {
'title' => 'Another New Topic',
'does_not_exist' => 'test'
}
)
assert_nothing_raised { topic.save }
end
def test_create_through_factory_with_block
topic = Topic.create("title" => "New Topic") do |t|
t.author_name = "David"
end
assert_equal("New Topic", topic.title)
assert_equal("David", topic.author_name)
end
def test_create_many_through_factory_with_block
topics = Topic.create([ { "title" => "first" }, { "title" => "second" }]) do |t|
t.author_name = "David"
end
assert_equal 2, topics.size
topic1, topic2 = Topic.find(topics[0].id), Topic.find(topics[1].id)
assert_equal "first", topic1.title
assert_equal "David", topic1.author_name
assert_equal "second", topic2.title
assert_equal "David", topic2.author_name
end
def test_update_object
topic = Topic.new
topic.title = "Another New Topic"
topic.written_on = "2003-12-12 23:23:00"
topic.save
topic_reloaded = Topic.find(topic.id)
assert_equal("Another New Topic", topic_reloaded.title)
topic_reloaded.title = "Updated topic"
topic_reloaded.save
topic_reloaded_again = Topic.find(topic.id)
assert_equal("Updated topic", topic_reloaded_again.title)
end
def test_update_columns_not_equal_attributes
topic = Topic.new
topic.title = "Still another topic"
topic.save
topic_reloaded = Topic.instantiate(topic.attributes.merge('does_not_exist' => 'test'))
topic_reloaded.title = 'A New Topic'
assert_nothing_raised { topic_reloaded.save }
end
def test_update_for_record_with_only_primary_key
minimalistic = minimalistics(:first)
assert_nothing_raised { minimalistic.save }
end
def test_update_sti_type
assert_instance_of Reply, topics(:second)
topic = topics(:second).becomes!(Topic)
assert_instance_of Topic, topic
topic.save!
assert_instance_of Topic, Topic.find(topic.id)
end
def test_preserve_original_sti_type
reply = topics(:second)
assert_equal "Reply", reply.type
topic = reply.becomes(Topic)
assert_equal "Reply", reply.type
assert_instance_of Topic, topic
assert_equal "Reply", topic.type
end
def test_update_sti_subclass_type
assert_instance_of Topic, topics(:first)
reply = topics(:first).becomes!(Reply)
assert_instance_of Reply, reply
reply.save!
assert_instance_of Reply, Reply.find(reply.id)
end
def test_update_after_create
klass = Class.new(Topic) do
def self.name; 'Topic'; end
after_create do
update_attribute("author_name", "David")
end
end
topic = klass.new
topic.title = "Another New Topic"
topic.save
topic_reloaded = Topic.find(topic.id)
assert_equal("Another New Topic", topic_reloaded.title)
assert_equal("David", topic_reloaded.author_name)
end
def test_update_attribute_does_not_run_sql_if_attribute_is_not_changed
klass = Class.new(Topic) do
def self.name; 'Topic'; end
end
topic = klass.create(title: 'Another New Topic')
assert_queries(0) do
topic.update_attribute(:title, 'Another New Topic')
end
end
def test_update_does_not_run_sql_if_record_has_not_changed
topic = Topic.create(title: 'Another New Topic')
assert_queries(0) { topic.update(title: 'Another New Topic') }
assert_queries(0) { topic.update_attributes(title: 'Another New Topic') }
end
def test_delete
topic = Topic.find(1)
assert_equal topic, topic.delete, 'topic.delete did not return self'
assert topic.frozen?, 'topic not frozen after delete'
assert_raise(ActiveRecord::RecordNotFound) { Topic.find(topic.id) }
end
def test_delete_doesnt_run_callbacks
Topic.find(1).delete
assert_not_nil Topic.find(2)
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_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_raise(ActiveRecord::RecordNotFound) { Topic.find(99999) }
end
def test_update_all
assert_equal Topic.count, Topic.update_all("content = 'bulk updated!'")
assert_equal "bulk updated!", Topic.find(1).content
assert_equal "bulk updated!", Topic.find(2).content
assert_equal Topic.count, 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 Topic.count, 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 Topic.count, 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.where(id: 1).update_all(['value = ?', 0])
assert_equal 0, WarehouseThing.find(1).value
end
def test_delete_new_record
client = Client.new
client.delete
assert client.frozen?
end
def test_delete_record_with_associations
client = Client.find(3)
client.delete
assert client.frozen?
assert_kind_of Firm, client.firm
assert_raise(RuntimeError) { client.name = "something else" }
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_raise(RuntimeError) { 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_attribute_for_readonly_attribute
minivan = Minivan.find('m1')
assert_raises(ActiveRecord::ActiveRecordError) { minivan.update_attribute(:color, 'black') }
end
def test_update_attribute_with_one_updated
t = Topic.first
t.update_attribute(:title, 'super_title')
assert_equal 'super_title', t.title
assert !t.changed?, "topic should not have changed"
assert !t.title_changed?, "title should not have changed"
assert_nil t.title_change, 'title change should be nil'
t.reload
assert_equal 'super_title', t.title
end
def test_update_attribute_for_updated_at_on
developer = Developer.find(1)
prev_month = Time.now.prev_month.change(usec: 0)
developer.update_attribute(:updated_at, prev_month)
assert_equal prev_month, developer.updated_at
developer.update_attribute(:salary, 80001)
assert_not_equal prev_month, developer.updated_at
developer.reload
assert_not_equal prev_month, developer.updated_at
end
def test_update_column
topic = Topic.find(1)
topic.update_column("approved", true)
assert topic.approved?
topic.reload
assert topic.approved?
topic.update_column(:approved, false)
assert !topic.approved?
topic.reload
assert !topic.approved?
end
def test_update_column_should_not_use_setter_method
dev = Developer.find(1)
dev.instance_eval { def salary=(value); write_attribute(:salary, value * 2); end }
dev.update_column(:salary, 80000)
assert_equal 80000, dev.salary
dev.reload
assert_equal 80000, dev.salary
end
def test_update_column_should_raise_exception_if_new_record
topic = Topic.new
assert_raises(ActiveRecord::ActiveRecordError) { topic.update_column("approved", false) }
end
def test_update_column_should_not_leave_the_object_dirty
topic = Topic.find(1)
topic.update_column("content", "--- Have a nice day\n...\n")
topic.reload
topic.update_column(:content, "--- You too\n...\n")
assert_equal [], topic.changed
topic.reload
topic.update_column("content", "--- Have a nice day\n...\n")
assert_equal [], topic.changed
end
def test_update_column_with_model_having_primary_key_other_than_id
minivan = Minivan.find('m1')
new_name = 'sebavan'
minivan.update_column(:name, new_name)
assert_equal new_name, minivan.name
end
def test_update_column_for_readonly_attribute
minivan = Minivan.find('m1')
prev_color = minivan.color
assert_raises(ActiveRecord::ActiveRecordError) { minivan.update_column(:color, 'black') }
assert_equal prev_color, minivan.color
end
def test_update_column_should_not_modify_updated_at
developer = Developer.find(1)
prev_month = Time.now.prev_month.change(usec: 0)
developer.update_column(:updated_at, prev_month)
assert_equal prev_month, developer.updated_at
developer.update_column(:salary, 80001)
assert_equal prev_month, developer.updated_at
developer.reload
assert_equal prev_month.to_i, developer.updated_at.to_i
end
def test_update_column_with_one_changed_and_one_updated
t = Topic.order('id').limit(1).first
author_name = t.author_name
t.author_name = 'John'
t.update_column(:title, 'super_title')
assert_equal 'John', t.author_name
assert_equal 'super_title', t.title
assert t.changed?, "topic should have changed"
assert t.author_name_changed?, "author_name should have changed"
t.reload
assert_equal author_name, t.author_name
assert_equal 'super_title', t.title
end
def test_update_column_with_default_scope
developer = DeveloperCalledDavid.first
developer.name = 'John'
developer.save!
assert developer.update_column(:name, 'Will'), 'did not update record due to default scope'
end
def test_update_columns
topic = Topic.find(1)
topic.update_columns({ "approved" => true, title: "Sebastian Topic" })
assert topic.approved?
assert_equal "Sebastian Topic", topic.title
topic.reload
assert topic.approved?
assert_equal "Sebastian Topic", topic.title
end
def test_update_columns_should_not_use_setter_method
dev = Developer.find(1)
dev.instance_eval { def salary=(value); write_attribute(:salary, value * 2); end }
dev.update_columns(salary: 80000)
assert_equal 80000, dev.salary
dev.reload
assert_equal 80000, dev.salary
end
def test_update_columns_should_raise_exception_if_new_record
topic = Topic.new
assert_raises(ActiveRecord::ActiveRecordError) { topic.update_columns({ approved: false }) }
end
def test_update_columns_should_not_leave_the_object_dirty
topic = Topic.find(1)
topic.update({ "content" => "--- Have a nice day\n...\n", :author_name => "Jose" })
topic.reload
topic.update_columns({ content: "--- You too\n...\n", "author_name" => "Sebastian" })
assert_equal [], topic.changed
topic.reload
topic.update_columns({ content: "--- Have a nice day\n...\n", author_name: "Jose" })
assert_equal [], topic.changed
end
def test_update_columns_with_model_having_primary_key_other_than_id
minivan = Minivan.find('m1')
new_name = 'sebavan'
minivan.update_columns(name: new_name)
assert_equal new_name, minivan.name
end
def test_update_columns_with_one_readonly_attribute
minivan = Minivan.find('m1')
prev_color = minivan.color
prev_name = minivan.name
assert_raises(ActiveRecord::ActiveRecordError) { minivan.update_columns({ name: "My old minivan", color: 'black' }) }
assert_equal prev_color, minivan.color
assert_equal prev_name, minivan.name
minivan.reload
assert_equal prev_color, minivan.color
assert_equal prev_name, minivan.name
end
def test_update_columns_should_not_modify_updated_at
developer = Developer.find(1)
prev_month = Time.now.prev_month.change(usec: 0)
developer.update_columns(updated_at: prev_month)
assert_equal prev_month, developer.updated_at
developer.update_columns(salary: 80000)
assert_equal prev_month, developer.updated_at
assert_equal 80000, developer.salary
developer.reload
assert_equal prev_month.to_i, developer.updated_at.to_i
assert_equal 80000, developer.salary
end
def test_update_columns_with_one_changed_and_one_updated
t = Topic.order('id').limit(1).first
author_name = t.author_name
t.author_name = 'John'
t.update_columns(title: 'super_title')
assert_equal 'John', t.author_name
assert_equal 'super_title', t.title
assert t.changed?, "topic should have changed"
assert t.author_name_changed?, "author_name should have changed"
t.reload
assert_equal author_name, t.author_name
assert_equal 'super_title', t.title
end
def test_update_columns_changing_id
topic = Topic.find(1)
topic.update_columns(id: 123)
assert_equal 123, topic.id
topic.reload
assert_equal 123, topic.id
end
def test_update_columns_returns_boolean
topic = Topic.find(1)
assert_equal true, topic.update_columns(title: "New title")
end
def test_update_columns_with_default_scope
developer = DeveloperCalledDavid.first
developer.name = 'John'
developer.save!
assert developer.update_columns(name: 'Will'), 'did not update record due to default scope'
end
def test_update
topic = Topic.find(1)
assert !topic.approved?
assert_equal "The First Topic", topic.title
topic.update("approved" => true, "title" => "The First Topic Updated")
topic.reload
assert topic.approved?
assert_equal "The First Topic Updated", topic.title
topic.update(approved: false, title: "The First Topic")
topic.reload
assert !topic.approved?
assert_equal "The First Topic", topic.title
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
error = assert_raise(ActiveRecord::RecordNotUnique, ActiveRecord::StatementInvalid) do
topic.update_attributes(id: 3, title: "Hm is it possible?")
end
assert_not_nil error.cause
assert_not_equal "Hm is it possible?", Topic.find(3).title
topic.update_attributes(id: 1234)
assert_nothing_raised { topic.reload }
assert_equal topic.title, Topic.find(1234).title
end
def test_update_attributes_parameters
topic = Topic.find(1)
assert_nothing_raised do
topic.update_attributes({})
end
assert_raises(ArgumentError) do
topic.update_attributes(nil)
end
end
def test_update!
Reply.validates_presence_of(:title)
reply = Reply.find(2)
assert_equal "The Second Topic of the day", reply.title
assert_equal "Have a nice day", reply.content
reply.update!("title" => "The Second Topic of the day updated", "content" => "Have a nice evening")
reply.reload
assert_equal "The Second Topic of the day updated", reply.title
assert_equal "Have a nice evening", reply.content
reply.update!(title: "The Second Topic of the day", content: "Have a nice day")
reply.reload
assert_equal "The Second Topic of the day", reply.title
assert_equal "Have a nice day", reply.content
assert_raise(ActiveRecord::RecordInvalid) { reply.update!(title: nil, content: "Have a nice evening") }
ensure
Reply.clear_validators!
end
def test_update_attributes!
Reply.validates_presence_of(:title)
reply = Reply.find(2)
assert_equal "The Second Topic of the day", reply.title
assert_equal "Have a nice day", reply.content
reply.update_attributes!("title" => "The Second Topic of the day updated", "content" => "Have a nice evening")
reply.reload
assert_equal "The Second Topic of the day updated", reply.title
assert_equal "Have a nice evening", reply.content
reply.update_attributes!(title: "The Second Topic of the day", content: "Have a nice day")
reply.reload
assert_equal "The Second Topic 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") }
ensure
Reply.clear_validators!
end
def test_destroyed_returns_boolean
developer = Developer.first
assert_equal false, developer.destroyed?
developer.destroy
assert_equal true, developer.destroyed?
developer = Developer.last
assert_equal false, developer.destroyed?
developer.delete
assert_equal true, developer.destroyed?
end
def test_persisted_returns_boolean
developer = Developer.new(:name => "Jose")
assert_equal false, developer.persisted?
developer.save!
assert_equal true, developer.persisted?
developer = Developer.first
assert_equal true, developer.persisted?
developer.destroy
assert_equal false, developer.persisted?
developer = Developer.last
assert_equal true, developer.persisted?
developer.delete
assert_equal false, developer.persisted?
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_create_with_custom_timestamps
custom_datetime = 1.hour.ago.beginning_of_day
%w(created_at created_on updated_at updated_on).each do |attribute|
parrot = LiveParrot.create(:name => "colombian", attribute => custom_datetime)
assert_equal custom_datetime, parrot[attribute]
end
end
def test_persist_inherited_class_with_different_table_name
minimalistic_aircrafts = Class.new(Minimalistic) do
self.table_name = "aircraft"
end
assert_difference "Aircraft.count", 1 do
aircraft = minimalistic_aircrafts.create(name: "Wright Flyer")
aircraft.name = "Wright Glider"
aircraft.save
end
assert_equal "Wright Glider", Aircraft.last.name
end
def test_instantiate_creates_a_new_instance
post = Post.instantiate("title" => "appropriate documentation", "type" => "SpecialPost")
assert_equal "appropriate documentation", post.title
assert_instance_of SpecialPost, post
# body was not initialized
assert_raises ActiveModel::MissingAttributeError do
post.body
end
end
def test_reload_removes_custom_selects
post = Post.select('posts.*, 1 as wibble').last!
assert_equal 1, post[:wibble]
assert_nil post.reload[:wibble]
end
def test_find_via_reload
post = Post.new
assert post.new_record?
post.id = 1
post.reload
assert_equal "Welcome to the weblog", post.title
assert_not post.new_record?
end
def test_reload_via_querycache
ActiveRecord::Base.connection.enable_query_cache!
ActiveRecord::Base.connection.clear_query_cache
assert ActiveRecord::Base.connection.query_cache_enabled, 'cache should be on'
parrot = Parrot.create(:name => 'Shane')
# populate the cache with the SELECT result
found_parrot = Parrot.find(parrot.id)
assert_equal parrot.id, found_parrot.id
# Manually update the 'name' attribute in the DB directly
assert_equal 1, ActiveRecord::Base.connection.query_cache.length
ActiveRecord::Base.uncached do
found_parrot.name = 'Mary'
found_parrot.save
end
# Now reload, and verify that it gets the DB version, and not the querycache version
found_parrot.reload
assert_equal 'Mary', found_parrot.name
found_parrot = Parrot.find(parrot.id)
assert_equal 'Mary', found_parrot.name
ensure
ActiveRecord::Base.connection.disable_query_cache!
end
class SaveTest < ActiveRecord::TestCase
self.use_transactional_tests = false
def test_save_touch_false
widget = Class.new(ActiveRecord::Base) do
connection.create_table :widgets, force: true do |t|
t.string :name
t.timestamps null: false
end
self.table_name = :widgets
end
instance = widget.create!({
name: 'Bob',
created_at: 1.day.ago,
updated_at: 1.day.ago
})
created_at = instance.created_at
updated_at = instance.updated_at
instance.name = 'Barb'
instance.save!(touch: false)
assert_equal instance.created_at, created_at
assert_equal instance.updated_at, updated_at
ensure
ActiveRecord::Base.connection.drop_table widget.table_name
widget.reset_column_information
end
end
def test_reset_column_information_resets_children
child = Class.new(Topic)
child.new # force schema to load
ActiveRecord::Base.connection.add_column(:topics, :foo, :string)
Topic.reset_column_information
assert_equal "bar", child.new(foo: :bar).foo
ensure
ActiveRecord::Base.connection.remove_column(:topics, :foo)
Topic.reset_column_information
end
end