Serializer validation in Django - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the base serializer class.

Django

from rest_framework import [1]

Drag options to blanks, or click blank then click option'

Aviews

Bserializers

Cmodels

Dfields

Attempts:

3 left

💡 Hint

Common Mistakes

Importing views instead of serializers

Importing models which is unrelated to serializers

The serializers module contains the base serializer classes needed to create serializers.

2fill in blank

medium

Complete the serializer class to validate that the 'age' field is at least 18.

Django

class UserSerializer(serializers.Serializer):
    age = serializers.IntegerField()

    def validate_age(self, value):
        if value < [1]:
            raise serializers.ValidationError("Must be at least 18 years old.")
        return value

Drag options to blanks, or click blank then click option'

A18

B20

C16

D21

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong age number like 21 or 16

Not raising ValidationError when age is less

The validation requires the age to be at least 18, so the check is value < 18.

3fill in blank

hard

Fix the error in the serializer's validate method to check that 'start_date' is before 'end_date'.

Django

class EventSerializer(serializers.Serializer):
    start_date = serializers.DateField()
    end_date = serializers.DateField()

    def validate(self, data):
        if data['start_date'] > data[[1]]:
            raise serializers.ValidationError("start_date must be before end_date.")
        return data

Drag options to blanks, or click blank then click option'

A'start_date'

B'date'

C'finish_date'

D'end_date'

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong key like 'start_date' or 'date'

Using a key that does not exist in the data dictionary

The code compares start_date with end_date, so the key must be 'end_date'.

4fill in blank

hard

Fill both blanks to add a custom validation that checks 'email' contains '@' and raise an error if not.

Django

class EmailSerializer(serializers.Serializer):
    email = serializers.CharField()

    def validate_email(self, value):
        if [1] not in value:
            raise serializers.ValidationError("Invalid email address.")
        return [2]

Drag options to blanks, or click blank then click option'

A'@'

Bvalue

Cemail

D'#'

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for wrong character like '#'

Returning a wrong variable name instead of value

The code checks if '@' is in the email string and returns the original value if valid.

5fill in blank

hard

Fill all three blanks to create a serializer that validates 'username' length and 'password' confirmation.

Django

class RegisterSerializer(serializers.Serializer):
    username = serializers.CharField()
    password = serializers.CharField(write_only=True)
    password2 = serializers.CharField(write_only=True)

    def validate_username(self, value):
        if len(value) < [1]:
            raise serializers.ValidationError("Username too short.")
        return value

    def validate(self, data):
        if data[[2]] != data[[3]]:
            raise serializers.ValidationError("Passwords do not match.")
        return data

Drag options to blanks, or click blank then click option'

A5

B'password'

C'password2'

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Using too small a number for username length

Mixing up password field names in validation

The username must be at least 5 characters. The validate method compares 'password' and 'password2' fields for equality.

Practice

1. What is the main purpose of serializer validation in Django REST Framework?

easy

A. To check if the input data is correct before saving or processing

B. To automatically save data to the database

C. To format the output data for display

D. To create database tables automatically

Solution

1. Step 1: Understand serializer validation role

   Serializer validation ensures the data received is correct and meets rules before using it.

2. Step 2: Differentiate from other serializer tasks

   Saving data or formatting output are separate steps; validation happens first to prevent errors.

3. Final Answer:

   To check if the input data is correct before saving or processing -> Option A

4. Quick Check:

   Validation = Data correctness check [OK]

Hint: Validation checks data correctness before saving or using it [OK]

Common Mistakes:

• Confusing validation with saving data
• Thinking validation formats output
• Assuming validation creates database tables

2. Which method name is correct to validate a single field called email in a serializer?

easy

A. validateEmail

B. validate_field_email

C. check_email

D. validate_email

Solution

1. Step 1: Recall Django REST Framework naming convention

   Single field validation methods must be named validate_<fieldname>.

2. Step 2: Match method name to field email

   The correct method is validate_email, exactly matching the field name.

3. Final Answer:

   validate_email -> Option D

4. Quick Check:

   Single field validator = validate_fieldname [OK]

Hint: Use validate_ plus field name exactly for single field validation [OK]

Common Mistakes:

• Using camelCase instead of snake_case
• Adding extra words like 'field' in method name
• Using incorrect prefixes like 'check_'

3. Given this serializer code, what will happen if age is less than 18?

class UserSerializer(serializers.Serializer):
    age = serializers.IntegerField()

    def validate_age(self, value):
        if value < 18:
            raise serializers.ValidationError('Must be at least 18')
        return value

medium

A. ValidationError with message 'Must be at least 18' is raised

B. The age is automatically set to 18

C. No error, age is accepted as is

D. Serializer ignores the age field

Solution

1. Step 1: Understand the validate_age method logic

   The method checks if age is less than 18 and raises ValidationError if true.

2. Step 2: Predict behavior when age < 18

   If age is less than 18, the error is raised stopping validation and returning the message.

3. Final Answer:

   ValidationError with message 'Must be at least 18' is raised -> Option A

4. Quick Check:

   Age < 18 triggers ValidationError [OK]

Hint: ValidationError raised when condition inside validate_<field> fails [OK]

Common Mistakes:

• Assuming age is changed automatically
• Thinking no error occurs for invalid age
• Believing the field is ignored silently

4. Identify the error in this serializer validation code:

class ProductSerializer(serializers.Serializer):
    price = serializers.FloatField()

    def validate(self, data):
        if data['price'] < 0:
            raise serializers.ValidationError('Price must be positive')
        return data

    def validate_price(self, value):
        if value == 0:
            raise serializers.ValidationError('Price cannot be zero')
        return value

medium

A. validate method should call super().validate(data)

B. validate_price should return data, not value

C. No error, code is correct

D. ValidationError messages must be dictionaries, not strings

Solution

1. Step 1: Check validate_price method

   It correctly checks if value is zero and raises error, then returns value.

2. Step 2: Check validate method

   It checks if price is negative and raises error, then returns data dictionary.

3. Step 3: Confirm ValidationError usage

   Passing string message is allowed; dictionary is optional for field-specific errors.

4. Final Answer:

   No error, code is correct -> Option C

5. Quick Check:

   Both validate and validate_<field> methods are valid [OK]

Hint: Both validate and validate_<field> can coexist and return correct types [OK]

Common Mistakes:

• Expecting validate_price to return data dict
• Thinking super().validate(data) is mandatory
• Believing ValidationError must be dict only

5. You want to validate that start_date is before end_date in a serializer. Which is the best way to do this?

hard

A. Use validate_start_date to compare both dates

B. Use the validate(self, data) method to compare both fields

C. Validate dates outside the serializer only

D. Use validate_end_date to compare both dates

Solution

1. Step 1: Understand single field validators scope

   Methods like validate_start_date only receive one field's value, so cannot compare two fields.

2. Step 2: Use validate method for multi-field validation

   The validate(self, data) method receives all fields and can compare start_date and end_date together.

3. Final Answer:

   Use the validate(self, data) method to compare both fields -> Option B

4. Quick Check:

   Multi-field validation = validate(data) method [OK]

Hint: Use validate(data) for checks involving multiple fields [OK]

Common Mistakes:

• Trying to compare fields inside single field validators
• Ignoring multi-field validation method
• Doing validation only outside serializer