Unit Testing Jinja Templates with Flask
Last Updated :
08 Dec, 2023
Unit testing is an essential practice in software development to ensure the accuracy and functionality of code. When working with Jinja templates in Python, it's crucial to validate the correctness of the generated output. In this article, we will see how to perform unit testing Jinja Templates with Flask.
Pre-requisite
Python Unit Testing Jinja Templates Using Flask
To begin, ensure you have the necessary dependencies installed, such as `Jinja2`, and a testing framework like `unittest` or `pytest`. Below are some steps by which we can Unit Test Jinja Templates in Python.
Step 1: Create File Structure
Create a directory structure and prepare the template files that need testing. To follow along please use this directory structure:
Step 2: Preparing our Flask server (app.py)
To begin we must have a flask server that serves some templates that then we will be testing. So let's get the server first. The code sets up a basic Flask web application with two routes: '/' displaying the "Homepage" and /about showing the "About" page. It uses templates to render HTML content for each route in the Flask application.
Python3
from flask import Flask, render_template
app = Flask(__name__)
@app.route("/")
def index():
return render_template(
"index.html", title="Homepage", content="Welcome to our website!"
)
@app.route("/about")
def about():
return render_template(
"about.html", title="About", content="This is the about page."
)
if __name__ == "__main__":
app.run(debug=True)
Step 3: Create Templates
index.html: This code represents a basic template using Jinja2 syntax, intending to be rendered by a Flask application. It consists of a structure with placeholders ('{{ title }}' and '{{ content }}') to be filled dynamically by data passed from the Flask routes for the title and content.
HTML
<!DOCTYPE html>
<html>
<head>
<title>{{ title }}</title>
</head>
<body>
<h1>Welcome</h1>
<p>{{ content }}</p>
</body>
</html>
Output
If you now run this server you'll get a welcome page like this:
Step 4: Writing test cases for Jinja templates
We can use Python's testing framework`unittest` to write test methods to check various aspects of the template outputs. We can test for different input data, edge cases, and expected results. In the test methods, we can render the Jinja templates with sample data and compare the output with the expected output.
unit.py: This Python code is a unit test using the 'unittest' framework to test the Flask application's index route. It uses 'app.test_client()' to simulate an HTTP GET request to the root route ('/') and validates the presence of specific HTML elements and content within the returned response. Running 'unittest.main()' executes the defined test cases.
Python3
import unittest
from app import app
class TestFlaskApp(unittest.TestCase):
def setUp(self):
self.app = app.test_client()
def test_index_route(self):
response = self.app.get("/")
html_content = response.data.decode("utf-8")
self.assertIn("<title>Homepage</title>", html_content)
self.assertIn("<h1>Welcome</h1>", html_content)
self.assertIn("<p>Welcome to our website!</p>", html_content)
if __name__ == "__main__":
unittest.main()
Output
Run this file and you will get an output like below:
Step 5: Create Sample Error Test
In this step, we are creating a sample test that will create an error. Let's see that using the about route.
about.html: Similar template file as index.html. Notice the error in title variable name. Our app already has a about route so let's make a unit test function to test it
HTML
<!DOCTYPE html>
<html lang="en">
<head>
<title>{{ tle }}</title>
</head>
<body>
<h1>This about page will generate an Error</h1>
{{ content }}
</body>
</html>
unit.py: This code is a unit test for the about route. Now add this code in unit.py file.
Python3
def test_about_route(self):
response = self.app.get("/about")
html_content = response.data.decode("utf-8")
self.assertIn("<title>About</title>", html_content)
self.assertIn("<h1>About</h1>", html_content)
self.assertIn("<p>This is the about page.</p>", html_content)
Output
Now when you'll execute the unit.py file you'll find that it correctly recognizes that a test case failed.
It even shows you a trace back of where the error occurred so you can easily go and fix it.
By verifying the output against expected results, developers can ensure that their templates function as intended, promoting stability and reducing potential issues in production.
Video Output
Similar Reads
Templating With Jinja2 in Flask
Flask is a lightweight WSGI framework that is built on Python programming. WSGI simply means Web Server Gateway Interface. Flask is widely used as a backend to develop a fully-fledged Website. And to make a sure website, templating is very important. Flask is supported by inbuilt template support na
6 min read
Email Templates with Jinja in Python
HTML emails play a crucial role in modern communication, whether for newsletters, notifications, or transactional emails. Jinja, a powerful templating engine for Python, offers flexibility for creating dynamic and visually appealing HTML email templates. In this article, we will see how we can use J
3 min read
Get the Current URL within a Django Template
Django, a high-level Python web framework, encourages rapid development and clean, pragmatic design. One common requirement when developing web applications is to access the current URL within a template. This can be useful for various purposes such as highlighting the active link in a navigation me
3 min read
Read File Without Saving in Flask
Flask is a flexible, lightweight web-development framework built using python. A Flask application is a Python script that runs on a web server, which listens to HTTP requests and returns responses. It is designed for simple and faster development. In this article we will discuss how can we Read fil
2 min read
Flask Rendering Templates
Flask is a lightweight Python web framework that enables developers to build web applications easily. One of its key features is template rendering, which allows dynamic content generation using Jinja2 templating. In this guide, we'll explore how to render templates in Flask.Setting up FlaskSetting
6 min read
Flask - Templates
In this article, we are going to learn about the flask templates in Python. Python is a high-level, open-source, object-oriented language, consisting of libraries, used in many domains, such as Web Development, Machine Learning, and so on. In web development, Python is used for building REST APIs, s
8 min read
Access the Query String in Flask Routes
In this article, we are going to see how to Access the Query String in Flask Routes in Python. The query string is the portion of the URL and Query Parameters are part of the query string that contains the key-value pair. Example: http://127.0.0.1:50100/?name=isha&class=10 After ? character, eve
2 min read
GET Request Query Parameters with Flask
In this article, we will learn how we can use the request object in a flask to GET Request Query Parameters with Flask that is passed to your routes using Python. As we know, Flask is a web development framework written in Python, and the flask is widely used as a web framework for creating APIs (Ap
4 min read
Multi-value Query Parameters with Flask
Flask is a micro-framework written in Python. It is lightweight, and easy to use, making it famous for building RESTful APIs. In this article we are going to see how to use Multi-value query parameters with flask. You can know more about it here. Let's understand the basics with an example: Python3
2 min read
Update Flask using PIP
Flask, a popular web framework for Python, evolves with new features, bug fixes, and improvements. Keeping your Flask installation up-to-date ensures that you can leverage the latest enhancements and security patches. In this guide, we'll walk through the process of updating Flask using pip, the pac
2 min read