Association callbacks in Ruby on Rails - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a child record is destroyed with dependent: :destroy?

Consider a Rails model Author has_many books with dependent: :destroy. What happens when an Author is destroyed?

Ruby on Rails

class Author < ApplicationRecord
  has_many :books, dependent: :destroy
end

class Book < ApplicationRecord
  belongs_to :author
  before_destroy :log_destroy

  def log_destroy
    puts "Destroying book #{id}"
  end
end

# In console:
author = Author.find(1)
author.destroy

A The author is destroyed first, then all associated books are destroyed without running callbacks.

B The author is destroyed and associated books remain in the database with author_id set to NULL.

C All associated books are destroyed and their before_destroy callbacks run before the author is destroyed.

D Destroying the author raises an error because dependent: :destroy is not supported.

💡 Hint

Think about the order of callbacks and what dependent: :destroy means.

With dependent: :destroy, Rails destroys all associated records by calling their destroy method, which triggers callbacks like before_destroy. This happens before the parent record is destroyed.

❓ lifecycle

intermediate

When is the after_add callback triggered in a has_many association?

Given a has_many :comments, after_add: :notify_addition association, when does the notify_addition method get called?

Ruby on Rails

class Post < ApplicationRecord
  has_many :comments, after_add: :notify_addition

  def notify_addition(comment)
    puts "Added comment #{comment.id}"
  end
end

post = Post.find(1)
comment = Comment.new(content: 'Nice post!')
post.comments << comment

A Only after the comment is saved to the database and associated with the post.

B Immediately after a comment is added to the association collection in memory, before saving to the database.

C When the post itself is saved, regardless of changes to comments.

D Only when the comment is destroyed from the association.

💡 Hint

Consider when the callback triggers relative to adding objects to the association.

The after_add callback runs immediately after an object is added to the association collection in memory, even before saving it to the database.

📝 Syntax

advanced

Which option correctly defines a before_remove callback in a has_many association?

Choose the correct syntax to define a before_remove callback on a has_many :tags association that calls log_removal.

Ruby on Rails

class Article < ApplicationRecord
  has_many :tags, ???

  def log_removal(tag)
    puts "Removing tag #{tag.id}"
  end
end

A before_remove: :log_removal

B before_remove => :log_removal

C before_remove :log_removal

D before_remove = :log_removal

💡 Hint

Look for the correct Ruby hash syntax for options in associations.

The correct syntax uses a symbol key and symbol value with a colon: before_remove: :log_removal.

🔧 Debug

advanced

Why does the after_add callback not trigger when using update to change association?

Given this code:

post.comments << comment
post.update(comments: post.comments + [new_comment])

The after_add callback on comments does not run for new_comment. Why?

A Because <code>new_comment</code> is not saved before adding to the association.

B Because <code>after_add</code> only triggers on <code>delete</code> operations, not additions.

C Because <code>after_add</code> only triggers on <code>build</code> method calls.

D Because <code>update</code> replaces the association without triggering callbacks like <code>after_add</code>.

💡 Hint

Think about how callbacks are triggered when modifying associations directly vs. via update.

Using update with an array replaces the association in bulk and does not trigger after_add callbacks, which only run when adding objects directly to the association collection.

🧠 Conceptual

expert

What is the effect of using :before_add and :after_remove callbacks together on a has_many association?

In a has_many :items, before_add: :check_limit, after_remove: :log_removal association, what is the combined effect of these callbacks?

A Before adding an item, <code>check_limit</code> runs to possibly prevent addition; after removing an item, <code>log_removal</code> runs to record the removal.

B Both callbacks run only after the parent object is saved, not during association changes.

C The callbacks run only if the associated items are destroyed, not when added or removed from the collection.

D The callbacks run in reverse order: <code>log_removal</code> before removal and <code>check_limit</code> after addition.

💡 Hint

Consider the timing and purpose of before_add and after_remove callbacks.

before_add runs before an object is added to the association, allowing checks or prevention. after_remove runs after an object is removed, useful for logging or cleanup.