Custom form validation methods in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a Django form's clean_() method raises ValidationError?

Consider a Django form with a clean_email() method that raises ValidationError if the email is invalid. What is the effect on the form's behavior when this error is raised?

Django

from django import forms

class EmailForm(forms.Form):
    email = forms.EmailField()

    def clean_email(self):
        email = self.cleaned_data.get('email')
        if not email.endswith('@example.com'):
            raise forms.ValidationError('Email must be from example.com domain')
        return email

A The form becomes invalid and the error message is added to the email field errors.

B The form ignores the error and treats the email as valid.

C The form raises an exception and stops processing immediately.

D The form clears the email field and continues validation.

💡 Hint

Think about how Django handles validation errors in field-specific clean methods.

When clean_() raises ValidationError, Django marks the form as invalid and attaches the error message to that field. This prevents form submission until corrected.

❓ state_output

intermediate

What is the value of cleaned_data after form validation with a custom clean() method?

Given a Django form with a custom clean() method that modifies cleaned_data, what will be the final value of cleaned_data after is_valid() is called?

Django

from django import forms

class NameForm(forms.Form):
    first_name = forms.CharField()
    last_name = forms.CharField()

    def clean(self):
        cleaned_data = super().clean()
        first = cleaned_data.get('first_name')
        last = cleaned_data.get('last_name')
        if first and last:
            cleaned_data['full_name'] = f'{first} {last}'
        return cleaned_data

form = NameForm({'first_name': 'Jane', 'last_name': 'Doe'})
form.is_valid()
result = form.cleaned_data.get('full_name')

A Raises KeyError

B 'Jane Doe'

C None

D 'Jane'

💡 Hint

Remember that clean() can add new keys to cleaned_data.

The clean() method adds a new key full_name combining first and last names. After validation, cleaned_data includes this key with value 'Jane Doe'.

📝 Syntax

advanced

Which option correctly defines a custom clean method for a Django form field?

Identify the correct syntax for a custom clean_() method in a Django form to validate the username field.

Django

from django import forms

class UserForm(forms.Form):
    username = forms.CharField()

    # Custom validation method here

A

def clean_username(self, username):
    if ' ' in username:
        raise forms.ValidationError('No spaces allowed')
    return username

B

def clean_username(self):
    username = self.data['username']
    if ' ' in username:
        raise forms.ValidationError('No spaces allowed')
    return username

C

def clean_username(self):
    username = self.cleaned_data['username']
    if ' ' in username:
        raise forms.ValidationError('No spaces allowed')
    return username

D

def clean(self, username):
    if ' ' in username:
        raise forms.ValidationError('No spaces allowed')
    return username

💡 Hint

Custom field clean methods take only self and access data from self.cleaned_data.

The correct method signature is def clean_fieldname(self):. It accesses the field value from self.cleaned_data. Option C follows this pattern correctly.

🔧 Debug

advanced

Why does this custom clean() method cause a KeyError during form validation?

Examine the following Django form code. Why does calling is_valid() raise a KeyError?

Django

from django import forms

class ProfileForm(forms.Form):
    age = forms.IntegerField()

    def clean(self):
        cleaned_data = super().clean()
        if cleaned_data['age'] < 18:
            raise forms.ValidationError('Must be at least 18')
        return cleaned_data

form = ProfileForm({'age': ''})
form.is_valid()

A Because ValidationError must be raised with a dictionary, not a string.

B Because age is a string and cannot be compared with an integer.

C Because super().clean() is not called, so cleaned_data is empty.

D Because 'age' is missing from cleaned_data when the field is empty, causing KeyError.

💡 Hint

Think about what happens when a required field is empty before clean() runs.

If the 'age' field is empty or invalid, it is not included in cleaned_data. Accessing cleaned_data['age'] then raises a KeyError. The code should use cleaned_data.get('age') and check for None.

🧠 Conceptual

expert

Which statement about Django form custom validation methods is TRUE?

Choose the correct statement about how Django handles custom validation methods in forms.

A The <code>clean()</code> method runs after all <code>clean_<field>()</code> methods and can modify <code>cleaned_data</code> for multiple fields.

B The <code>clean_<field>()</code> methods run after <code>clean()</code> and cannot raise ValidationError.

C Custom validation methods must return a boolean indicating if the field is valid or not.

D If a <code>clean_<field>()</code> method raises ValidationError, the <code>clean()</code> method will not run.

💡 Hint

Consider the order Django calls validation methods and their roles.

Django calls all clean_() methods first, then calls clean(). The clean() method can access and modify all fields' data together. ValidationErrors in field methods do not stop clean() from running.

Practice

1. What is the purpose of defining a clean_fieldname method in a Django form?

easy

A. To handle form submission via AJAX

B. To automatically save the form data to the database

C. To add custom validation logic for a specific form field

D. To style the form field with CSS classes

Solution

1. Step 1: Understand the role of clean_fieldname

   This method is used to add validation logic for a single field in a Django form.

2. Step 2: Differentiate from other methods

   Unlike clean which validates multiple fields, clean_fieldname focuses on one field only.

3. Final Answer:

   To add custom validation logic for a specific form field -> Option C

4. Quick Check:

   clean_fieldname validates one field [OK]

Hint: Remember: clean_fieldname validates one field only [OK]

Common Mistakes:

• Confusing clean_fieldname with clean method
• Thinking it saves data automatically
• Assuming it styles the form

2. Which of the following is the correct way to raise a validation error inside a custom clean method for a field named email?

easy

A. return ValidationError('Invalid email')

B. raise ValidationError('Invalid email')

C. self.add_error('email', 'Invalid email')

D. ValidationError('Invalid email')

Solution

1. Step 1: Identify how to raise errors in Django forms

   In custom clean methods, you raise a ValidationError to signal invalid data.

2. Step 2: Check the syntax for raising errors

   The correct syntax is to use raise ValidationError('message'), not return or just call it.

3. Final Answer:

   raise ValidationError('Invalid email') -> Option B

4. Quick Check:

   Use raise to throw ValidationError [OK]

Hint: Use raise, not return, to signal validation errors [OK]

Common Mistakes:

• Using return instead of raise
• Calling ValidationError without raise
• Misusing self.add_error inside clean_fieldname

3. Given this Django form snippet, what will happen if the user enters 'abc' for the age field?

class MyForm(forms.Form):
    age = forms.IntegerField()

    def clean_age(self):
        age = self.cleaned_data.get('age')
        if age < 18:
            raise ValidationError('Must be at least 18')
        return age

medium

A. Form will crash with a TypeError

B. Form will accept 'abc' and pass validation

C. clean_age will raise 'Must be at least 18' error

D. Form will raise a validation error because 'abc' is not an integer

Solution

1. Step 1: Understand IntegerField behavior

   IntegerField automatically validates input to be an integer before calling clean_age.

2. Step 2: Analyze input 'abc'

   'abc' is not an integer, so IntegerField will raise a validation error before clean_age runs.

3. Final Answer:

   Form will raise a validation error because 'abc' is not an integer -> Option D

4. Quick Check:

   IntegerField rejects non-integers first [OK]

Hint: IntegerField validates type before custom clean runs [OK]

Common Mistakes:

• Thinking clean_age handles type errors
• Assuming 'Must be at least 18' error triggers for 'abc'
• Expecting a crash instead of validation error

4. Identify the error in this custom form validation method:

def clean(self):
    data = self.cleaned_data
    if data['start_date'] > data['end_date']:
        raise ValidationError('Start date must be before end date')
    return data

medium

A. Accessing cleaned_data directly without calling super().clean()

B. Raising ValidationError with a string instead of a dictionary

C. Not returning cleaned_data at the end of clean()

D. Using '>' operator instead of '>=' for date comparison

Solution

1. Step 1: Check how clean() should be overridden

   When overriding clean(), you must call super().clean() to get cleaned_data properly.

2. Step 2: Identify the error in accessing cleaned_data

   This code accesses self.cleaned_data directly without calling super().clean(), which may cause missing or incomplete data.

3. Final Answer:

   Accessing cleaned_data directly without calling super().clean() -> Option A

4. Quick Check:

   Always call super().clean() first [OK]

Hint: Call super().clean() before using cleaned_data [OK]

Common Mistakes:

• Forgetting to call super().clean()
• Returning wrong data type
• Misusing ValidationError format

5. You want to ensure that a Django form's password and confirm_password fields match. Which is the best way to implement this validation?

hard

A. Override the form's clean method to compare both fields and raise ValidationError if they differ

B. Add a validator to the password field that checks confirm_password

C. Define a clean_password method that compares both fields

D. Use JavaScript on the client side only to check matching passwords

Solution

1. Step 1: Understand field-level vs form-level validation

   Field-level methods like clean_password only see one field's data, so can't compare two fields.

2. Step 2: Use form-level clean() for cross-field validation

   Overriding clean lets you access all fields and compare password and confirm_password.

3. Final Answer:

   Override the form's clean method to compare both fields and raise ValidationError if they differ -> Option A

4. Quick Check:

   Use clean() for multi-field validation [OK]

Hint: Use clean() method for comparing multiple fields [OK]

Common Mistakes:

• Trying to compare fields in clean_password
• Relying only on client-side JavaScript
• Adding validators that can't access other fields