Custom validation methods in Ruby on Rails - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a custom validation method adds an error?

Consider a Rails model with a custom validation method that adds an error to an attribute. What is the effect on the model's validity and saving behavior?

Ruby on Rails

class Product < ApplicationRecord
  validate :price_must_be_positive

  def price_must_be_positive
    errors.add(:price, "must be positive") if price && price <= 0
  end
end

product = Product.new(price: -5)
valid = product.valid?
saved = product.save

A valid is false, saved is false because the error prevents saving

B valid is true, saved is true because validations are skipped

C valid is false, saved is true because save ignores errors

D valid is true, saved is false because save always fails

💡 Hint

Think about what happens when errors are added to the errors collection in Rails validations.

When a custom validation method adds an error to the model's errors, the model becomes invalid. Calling valid? returns false, and save returns false because it does not save invalid records.

📝 Syntax

intermediate

Which custom validation method syntax is correct?

Identify the correct way to define a custom validation method in a Rails model.

Ruby on Rails

class User < ApplicationRecord
  # Which of these custom validation method definitions is correct?

  # Option A
  validate :check_name
  def check_name
    errors.add(:name, "can't be blank") if name.blank?
  end

  # Option B
  validate check_name
  def check_name
    errors.add(:name, "can't be blank") if name.blank?
  end

  # Option C
  validates :check_name
  def check_name
    errors.add(:name, "can't be blank") if name.blank?
  end

  # Option D
  validate :check_name()
  def check_name
    errors.add(:name, "can't be blank") if name.blank?
  end
end

A Option A is correct

B Option B is correct

C Option C is correct

D Option D is correct

💡 Hint

Look at how the validate method expects its argument.

The validate method expects a symbol naming the custom validation method without parentheses. Option A uses validate :check_name which is correct. Option A misses the colon, Option A uses validates which is for attribute validations, and Option A uses parentheses which is invalid syntax.

🔧 Debug

advanced

Why does this custom validation not add errors as expected?

Given the following model code, why is the error not added using the proper method?

Ruby on Rails

class Order < ApplicationRecord
  validate :check_total

  def check_total
    if total < 0
      errors[:total] << "cannot be negative"
    end
  end
end

order = Order.new(total: -10)
order.save
order.errors.full_messages

A Using errors[:total] << adds errors but does not mark the model invalid

B The validation method is not called because validate is misspelled

C errors.add should be used instead of errors[:total] << to properly add errors

D The total attribute is missing from the model, so validation is skipped

💡 Hint

Check how errors are added to the errors collection in Rails.

Directly pushing to errors[:total] bypasses some of Rails' error handling logic such as internationalization support and options. The recommended and proper way is to use errors.add(:total, "cannot be negative").

❓ state_output

advanced

What is the value of errors after running this custom validation?

Examine the following Rails model and the result of running validations.

Ruby on Rails

class Event < ApplicationRecord
  validate :start_date_cannot_be_in_past

  def start_date_cannot_be_in_past
    if start_date && start_date < Date.today
      errors.add(:start_date, "can't be in the past")
    end
  end
end

event = Event.new(start_date: Date.today - 1)
event.valid?
event.errors.full_messages

A ["Start date can't be blank"]

B ["Start date can't be in the past"]

C []

D ["Start date is invalid"]

💡 Hint

Think about what happens when the start_date is before today.

The custom validation adds an error message if the start_date is before today. Since the date is yesterday, the error message is added and returned by errors.full_messages.

🧠 Conceptual

expert

Why use custom validation methods instead of built-in validators?

Which reason best explains why a Rails developer would create a custom validation method instead of using built-in validators like validates_presence_of or validates_numericality_of?

A To automatically generate error messages without writing any code

B Because built-in validators are deprecated and should not be used

C To improve performance by avoiding built-in validation overhead

D To implement complex or conditional validation logic that built-in validators cannot handle

💡 Hint

Think about when built-in validators are not enough.

Custom validation methods allow developers to write any logic needed for validation, especially when conditions or complex rules are required that built-in validators do not support.

Practice

1. What is the main purpose of a custom validation method in a Rails model?

easy

A. To add your own rules for checking data before saving

B. To automatically generate database tables

C. To create user interface elements

D. To speed up database queries

Solution

1. Step 1: Understand validation role in Rails

   Validations check data correctness before saving to the database.

2. Step 2: Identify custom validation purpose

   Custom validations let you write your own rules beyond built-in checks.

3. Final Answer:

   To add your own rules for checking data before saving -> Option A

4. Quick Check:

   Custom validation = custom data rules [OK]

Hint: Custom validations add your own data rules [OK]

Common Mistakes:

• Confusing validations with database setup
• Thinking validations create UI elements
• Assuming validations improve query speed

2. Which is the correct way to add a custom validation method named check_age in a Rails model?

easy

A. validates :check_age

B. validate :check_age

C. validate_check_age

D. validates_with :check_age

Solution

1. Step 1: Recall syntax for custom validations

   Use validate :method_name to call a custom method.

2. Step 2: Match method name with syntax

   For method check_age, syntax is validate :check_age.

3. Final Answer:

   validate :check_age -> Option B

4. Quick Check:

   Custom validation syntax = validate :method_name [OK]

Hint: Use 'validate :method_name' for custom validations [OK]

Common Mistakes:

• Using 'validates' instead of 'validate' for custom methods
• Adding underscores in method call
• Using 'validates_with' incorrectly

3. Given this model code:

class User < ApplicationRecord
  validate :check_name

  def check_name
    errors.add(:name, "can't be blank") if name.blank?
  end
end

What happens if you try to save a User with name = ''?

medium

A. The save fails with an error on the name attribute

B. The save succeeds without errors

C. A syntax error occurs

D. The save fails but no error message is added

Solution

1. Step 1: Understand the custom validation logic

   The method adds an error if name.blank? is true (empty string).

2. Step 2: Effect on saving a User with empty name

   Since name is blank, error is added and save fails.

3. Final Answer:

   The save fails with an error on the name attribute -> Option A

4. Quick Check:

   Blank name triggers error = save fails [OK]

Hint: Blank fields trigger errors in custom validations [OK]

Common Mistakes:

• Assuming save succeeds despite errors
• Confusing blank? with nil check
• Expecting syntax errors from valid code

4. Identify the error in this custom validation method:

class Product < ApplicationRecord
  validate :check_price

  def check_price
    errors.add(:price, "must be positive") if price <= 0
  end
end

medium

A. The method name should start with 'validate_'

B. The validation should use 'validates' instead of 'validate'

C. No error; the code is correct

D. The comparison operator should be '==' instead of '<='

Solution

1. Step 1: Check method naming and usage

   Custom validation methods do not need 'validate_' prefix; 'validate :method' is correct.

2. Step 2: Verify validation logic and syntax

   Using 'validate' with method and condition 'price <= 0' is valid Ruby and Rails syntax.

3. Final Answer:

   No error; the code is correct -> Option C

4. Quick Check:

   Custom validation syntax and logic are correct [OK]

Hint: Custom validation methods do not need special prefixes [OK]

Common Mistakes:

• Adding 'validate_' prefix to method name
• Using 'validates' for custom methods
• Changing correct comparison operators

5. You want to create a custom validation that ensures a User's username is at least 5 characters and contains no spaces. Which code correctly implements this?

hard

A. validate :username_rules

def username_rules
errors.add(:username, "invalid") if username.length <= 5 && username.include?(" ")
end

B. validates :username, length: { minimum: 5 }, format: { without: /\s/ }

C. validate :username_rules

def username_rules
errors.add(:username, "invalid") unless username.length >= 5 && !username.include:(" ")
end

D. validate :username_rules

def username_rules
if username.length < 5 || username.include?(" ")
errors.add(:username, "must be 5+ chars and no spaces")
end
end

Solution

1. Step 1: Understand the validation requirements

   Username must be at least 5 characters and contain no spaces.

2. Step 2: Analyze each option's logic

   validate :username_rules
   
   def username_rules
     if username.length < 5 || username.include?(" ")
       errors.add(:username, "must be 5+ chars and no spaces")
     end
   end

   uses OR logic to add error if username is shorter than 5 or contains spaces, which matches requirements.

3. Step 3: Check other options

   validates :username, length: { minimum: 5 }, format: { without: /\s/ }

   uses built-in validations, not custom method.

   validate :username_rules
   
   def username_rules
     errors.add(:username, "invalid") unless username.length >= 5 && !username.include:(" ")
   end

   has syntax error with colon in method call.

   validate :username_rules
   
   def username_rules
     errors.add(:username, "invalid") if username.length <= 5 && username.include?(" ")
   end

   uses wrong comparison (<= 5 excludes 5).

4. Final Answer:

   validate :username_rules def username_rules if username.length < 5 || username.include?(" ") errors.add(:username, "must be 5+ chars and no spaces") end end -> Option D

5. Quick Check:

   Custom validation logic matches requirements [OK]

Hint: Check logic carefully: use OR for combined invalid conditions [OK]

Common Mistakes:

• Using AND instead of OR for combined conditions
• Confusing built-in validations with custom methods
• Wrong comparison operators causing off-by-one errors