has_one relationship in Ruby on Rails - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this has_one association output?

Given the following Rails models, what will user.profile.name output if the profile exists?

Ruby on Rails

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  belongs_to :user
  # attribute :name, :string
end

user = User.create(name: 'Alice')
user.create_profile(name: 'Alice Profile')

puts user.profile.name

A Alice Profile

B nil

C Raises NoMethodError

D Raises ActiveRecord::RecordNotFound

💡 Hint

Remember that has_one creates a method to access the associated object.

The has_one association creates a method profile on User that returns the associated Profile object. Since the profile was created with name 'Alice Profile', user.profile.name returns that string.

❓ state_output

intermediate

What is the value of profile.user after creation?

Given these models and code, what will profile.user.name output?

Ruby on Rails

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  belongs_to :user
end

user = User.create(name: 'Bob')
profile = user.create_profile

puts profile.user.name

A Raises NoMethodError

B nil

C Bob

D Raises ActiveRecord::RecordInvalid

💡 Hint

Check the belongs_to association from Profile to User.

The belongs_to association on Profile creates a method user that returns the associated User. Since the profile was created from the user, profile.user.name returns 'Bob'.

📝 Syntax

advanced

Which option correctly defines a has_one association with dependent destroy?

You want to define a has_one association where deleting the parent deletes the child. Which code is correct?

A has_one :profile, dependent: destroy

B has_one :profile, dependent: :destroy

C has_one :profile, dependent => :destroy

D has_one :profile, dependent: 'destroy'

💡 Hint

Check the syntax for passing options as symbols.

The correct syntax uses a symbol for the option value: dependent: :destroy. Option B uses a string instead of a symbol, B misses the colon before destroy, and C uses the older hash rocket syntax incorrectly.

🔧 Debug

advanced

Why does user.profile return nil unexpectedly?

Given these models and code, why does user.profile return nil even after creating a profile?

Ruby on Rails

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  belongs_to :user
end

user = User.create(name: 'Carol')
Profile.create(name: 'Carol Profile')

puts user.profile

A has_one association requires reload to update, so user.profile is stale

B User must use has_many for multiple profiles, so has_one returns nil

C belongs_to is missing in Profile, so association fails

D Profile was created without linking to the user, so user.profile is nil

💡 Hint

Check if the profile is linked to the user when created.

The profile was created without specifying the user_id, so it is not linked to the user. Therefore, user.profile returns nil.

🧠 Conceptual

expert

What happens if you call build_profile twice on the same user?

Consider a user with no profile. You call user.build_profile(name: 'First') then user.build_profile(name: 'Second') without saving. What is the state of user.profile.name?

Ruby on Rails

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  belongs_to :user
end

user = User.create(name: 'Dave')
user.build_profile(name: 'First')
user.build_profile(name: 'Second')

puts user.profile.name

A Second

B First

C nil

D Raises ActiveRecord::RecordNotSaved

💡 Hint

Think about what build_profile does and if it replaces the previous unsaved profile.

Calling build_profile twice replaces the unsaved profile object. The last built profile is returned by user.profile, so the name is 'Second'.

Practice

1. What does the has_one association in Rails represent?

easy

A. A many-to-many connection between two models

B. A one-to-many connection from one model to many others

C. A one-to-one connection from one model to another

D. A model inheriting from another model

Solution

1. Step 1: Understand the purpose of has_one

   The has_one association sets up a one-to-one link from one model to another, meaning each instance of the first model is connected to exactly one instance of the second model.

2. Step 2: Compare with other associations

   Unlike has_many (one-to-many) or has_and_belongs_to_many (many-to-many), has_one is strictly one-to-one.

3. Final Answer:

   A one-to-one connection from one model to another -> Option C

4. Quick Check:

   has_one = one-to-one [OK]

Hint: Remember: has_one means exactly one related record [OK]

Common Mistakes:

• Confusing has_one with has_many
• Thinking has_one creates many related records
• Mixing up has_one with belongs_to

2. Which of the following is the correct syntax to declare a has_one association in a Rails model?

easy

A. has_one = :profile

B. has_one profile

C. has_one => :profile

D. has_one :profile

Solution

1. Step 1: Recall Rails association syntax

   In Rails, associations are declared using the method name followed by a symbol representing the related model, e.g., has_one :profile.

2. Step 2: Identify correct Ruby syntax

   has_one :profile uses the correct Ruby method call with a symbol argument. Options A, B, and C are invalid Ruby syntax for this purpose.

3. Final Answer:

   has_one :profile -> Option D

4. Quick Check:

   Association syntax uses symbol with colon [OK]

Hint: Use colon before association name: has_one :name [OK]

Common Mistakes:

• Omitting the colon before the association name
• Using hash rocket syntax incorrectly
• Assigning association with equals sign

3. Given these models:

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  belongs_to :user
end

What will user.profile return if the user has no profile record?

medium

A. nil

B. An error is raised

C. An empty Profile object

D. A new unsaved Profile instance

Solution

1. Step 1: Understand has_one association behavior

   If no associated record exists, calling user.profile returns nil because there is no linked profile.

2. Step 2: Confirm no automatic creation

   Rails does not create or return empty or new instances automatically for has_one associations.

3. Final Answer:

   nil -> Option A

4. Quick Check:

   No associated record means nil [OK]

Hint: No linked record? Association returns nil [OK]

Common Mistakes:

• Expecting an empty or new object instead of nil
• Assuming an error is raised when missing association
• Confusing with build_profile method

4. Identify the error in this code snippet:

class User < ApplicationRecord
  has_one :profile
end

class Profile < ApplicationRecord
  has_one :user
end

medium

A. Profile should use belongs_to :user instead of has_one

B. User should use belongs_to :profile instead of has_one

C. Both models should use has_one for the association

D. No error; the code is correct

Solution

1. Step 1: Understand correct association directions

   In a one-to-one relationship, the model holding the foreign key uses belongs_to. Here, Profile should belong to User.

2. Step 2: Identify incorrect association

   Using has_one :user in Profile is wrong because it implies Profile owns User, which is not the case.

3. Final Answer:

   Profile should use belongs_to :user instead of has_one -> Option A

4. Quick Check:

   Foreign key side uses belongs_to [OK]

Hint: belongs_to goes on model with foreign key [OK]

Common Mistakes:

• Using has_one on both sides
• Confusing which model holds foreign key
• Omitting belongs_to in related model

5. You want to ensure that when a User is deleted, their associated Profile is also deleted automatically. How do you modify the has_one association in the User model?

hard

A. has_one :profile, autosave: true

B. has_one :profile, dependent: :destroy

C. has_one :profile, validate: true

D. has_one :profile, inverse_of: :user

Solution

1. Step 1: Understand dependent option in associations

   The dependent: :destroy option tells Rails to delete the associated record when the owner is deleted.

2. Step 2: Apply to has_one association

   Adding dependent: :destroy to has_one :profile ensures the profile is removed automatically with the user.

3. Final Answer:

   has_one :profile, dependent: :destroy -> Option B

4. Quick Check:

   dependent: :destroy deletes associated record [OK]

Hint: Use dependent: :destroy to auto-delete associated record [OK]

Common Mistakes:

• Using autosave or validate instead of dependent
• Forgetting to add dependent option
• Confusing inverse_of with dependent