API error handling in Flask - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the Flask class.

Flask

from flask import [1]
app = [1](__name__)

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

AFlask

BResponse

CRequest

Djsonify

Attempts:

3 left

💡 Hint

Common Mistakes

Importing Request instead of Flask

Using jsonify instead of Flask

Forgetting to import Flask

You need to import Flask to create the app instance.

2fill in blank

medium

Complete the code to return a JSON error response with status 404.

Flask

from flask import jsonify

@app.route('/item/<int:id>')
def get_item(id):
    item = None  # pretend we look for item
    if not item:
        return jsonify({'error': 'Item not found'}), [1]

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

A403

B200

C500

D404

Attempts:

3 left

💡 Hint

Common Mistakes

Using 200 instead of 404

Using 500 which means server error

Using 403 which means forbidden

HTTP status code 404 means 'Not Found', which fits this error.

3fill in blank

hard

Fix the error in the code to handle 400 Bad Request errors globally.

Flask

@app.errorhandler([1])
def bad_request(error):
    return jsonify({'error': 'Bad request'}), 400

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

A404

B403

C400

D500

Attempts:

3 left

💡 Hint

Common Mistakes

Using 404 instead of 400

Using 500 which is server error

Using 403 which means forbidden

The error handler must match the 400 status code to catch bad requests.

4fill in blank

hard

Fill both blanks to create a custom error handler for 404 errors returning JSON.

Flask

@app.errorhandler([1])
def not_found(error):
    response = [2]({'error': 'Resource not found'}, 404)
    return response

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

A404

Bjsonify

Cmake_response

Dabort

Attempts:

3 left

💡 Hint

Common Mistakes

Using jsonify alone without make_response

Using abort inside error handler

Using wrong error code

The decorator uses 404 to catch not found errors, and make_response creates a response with JSON and status code.

5fill in blank

hard

Fill all three blanks to raise a 400 error with a custom message using abort.

Flask

from flask import abort

@app.route('/submit', methods=['POST'])
def submit():
    data = request.json
    if not data or 'name' not in data:
        abort([1], description=[2])
    return 'Success', 200

@app.errorhandler([3])
def handle_bad_request(e):
    return jsonify(error=str(e.description)), 400

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

A400

B'Missing name field'

D'Invalid data'

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong status code in abort

Not providing a description string

Mismatch between abort code and errorhandler code

Use abort with 400 and a description string. The error handler catches 400 errors and returns JSON with the message.

Practice

1. What is the main purpose of using @app.errorhandler in a Flask API?

easy

A. To start the Flask application

B. To define new API routes

C. To catch specific errors and return custom responses

D. To connect to a database

Solution

1. Step 1: Understand the role of @app.errorhandler

   This decorator is used to catch errors that happen during API requests.

2. Step 2: Recognize its use for custom responses

   It allows you to send back clear messages and proper HTTP status codes when errors occur.

3. Final Answer:

   To catch specific errors and return custom responses -> Option C

4. Quick Check:

   @app.errorhandler catches errors [OK]

Hint: Remember: errorhandler catches errors to customize responses [OK]

Common Mistakes:

• Thinking it defines routes
• Confusing it with app.run()
• Assuming it manages database connections

2. Which of the following is the correct syntax to handle a 404 error in Flask?

easy

A. @app.errorhandler(404)
def not_found(error):
return 'Not Found', 404

B. @app.route(404)
def not_found():
return 'Not Found'

C. @app.errorhandler('404')
def not_found(error):
return 'Not Found', 404

D. @app.errorhandler(404)
def not_found():
return 'Not Found'

Solution

1. Step 1: Identify correct decorator usage

   The @app.errorhandler decorator takes an integer status code like 404 without quotes.

2. Step 2: Check function signature and return

   The handler function should accept an error argument and return a response with the status code.

3. Final Answer:

   @app.errorhandler(404)\ndef not_found(error):\n return 'Not Found', 404 -> Option A

4. Quick Check:

   Correct decorator and function signature = @app.errorhandler(404) def not_found(error): return 'Not Found', 404 [OK]

Hint: Use integer status codes without quotes in errorhandler [OK]

Common Mistakes:

• Using @app.route instead of @app.errorhandler
• Passing status code as string '404'
• Omitting the error parameter in handler function

3. Given this Flask error handler code:

from flask import abort, jsonify
@app.errorhandler(400)
def bad_request(error):
    return jsonify({'error': 'Bad Request'}), 400

@app.route('/test')
def test():
    abort(400)

What will be the JSON response and status code when accessing /test?

medium

A. {"error": "Bad Request"} with status code 400

B. Plain text 'Bad Request' with status code 200

C. Default Flask 400 error page with status code 400

D. Empty response with status code 400

Solution

1. Step 1: Understand abort triggers error handler

   The abort(400) call triggers the 400 error handler defined by @app.errorhandler(400).

2. Step 2: Check handler return value

   The handler returns a JSON dictionary with the error message and status code 400.

3. Final Answer:

   {"error": "Bad Request"} with status code 400 -> Option A

4. Quick Check:

   abort triggers handler response JSON + 400 [OK]

Hint: abort(code) triggers matching errorhandler response [OK]

Common Mistakes:

• Expecting plain text instead of JSON
• Assuming default Flask error page shows
• Missing status code in response

4. What is wrong with this Flask error handler code?

@app.errorhandler(500)
def internal_error():
    return {'error': 'Server Error'}, 500

medium

A. The decorator should be @app.route, not @app.errorhandler

B. The status code 500 should be a string '500'

C. The return value must be a string, not a dictionary

D. The handler function must accept an error parameter

Solution

1. Step 1: Check function signature for error handlers

   Error handler functions must accept one parameter for the error object.

2. Step 2: Identify missing parameter

   The function internal_error has no parameters, so Flask will raise a TypeError.

3. Final Answer:

   The handler function must accept an error parameter -> Option D

4. Quick Check:

   Error handler functions need error argument [OK]

Hint: Error handlers always need an error parameter [OK]

Common Mistakes:

• Omitting the error parameter
• Using string status codes
• Confusing errorhandler with route decorator

5. You want to create a Flask API error handler that returns a JSON response with a custom message and the correct HTTP status code for any KeyError raised in your routes. Which of the following is the best way to implement this?

hard

A. @app.errorhandler(400)
def handle_key_error(error):
return {'error': 'Missing key in request'}, 400

B. @app.errorhandler(KeyError)
def handle_key_error(error):
return {'error': 'Missing key in request'}, 400

C. @app.route('/error')
def handle_key_error():
return {'error': 'Missing key in request'}, 400

D. @app.errorhandler(Exception)
def handle_key_error(error):
return {'error': 'Missing key in request'}, 400

Solution

1. Step 1: Use exception class in errorhandler

   To catch a specific Python error like KeyError, use it directly in @app.errorhandler(KeyError).

2. Step 2: Return JSON with appropriate status code

   Return a JSON message and HTTP 400 (bad request) status code to indicate client error.

3. Final Answer:

   @app.errorhandler(KeyError)\ndef handle_key_error(error):\n return {'error': 'Missing key in request'}, 400 -> Option B

4. Quick Check:

   Use exception class in errorhandler for specific errors [OK]

Hint: Use exception class in errorhandler to catch specific errors [OK]

Common Mistakes:

• Using status code instead of exception class
• Defining error handler as a route
• Catching all exceptions instead of specific one