Search⌘ K
AI Features
Home
Courses
Mastering Unit Testing with Pytest

Database Unit Testing for MongoDB

Explore how to perform database unit testing for MongoDB using pytest. Understand key concepts like test data, fixtures, and CRUD tests. Learn to create models with ODM libraries, use mongomock for an in-memory database, and write tests that validate database interactions to improve reliability and correctness.

We'll cover the following...

Overview of database testing

Database testing is a crucial aspect of software development that focuses on verifying the correctness, reliability, and performance of database-related functionalities. It involves designing and executing tests to validate the behavior of the database and its interactions with the application.

The goal of database testing is to ensure that the database functions correctly and consistently, adhering to the defined business rules and constraints. By thoroughly testing the database, we can identify and resolve issues related to data integrity, data validation, data retrieval, data manipulation, and overall system performance.

Key concepts in database testing

  • Test data: Test data refers to data that is used specifically for testing purposes. It includes both the initial data state for testing scenarios and the expected results against which the actual results are compared.

  • Test cases: Test cases are specific scenarios or conditions that need to be tested. Each test case consists of a set of inputs, preconditions, and expected outputs. Test cases should cover various aspects of database functionality, such as CRUD operations (create, read, update, delete), complex queries, constraints, and transaction handling.

  • Test environment: The test environment includes the setup required to execute database tests effectively. It involves creating a dedicated test database, configuring the necessary database connections, and ensuring the availability of required resources for testing.

Introduction to MongoDB

MongoDB is a popular NoSQL document database that provides high performance, scalability, and flexibility for storing and retrieving data. Unlike traditional relational databases, MongoDB stores data in a flexible JSON-like format called BSON (Binary JSON), which allows for easy and dynamic schema evolution.

Key concepts in MongoDB:

  • Collections: MongoDB organizes data into collections that are analogous to tables in a relational database. Each collection consists of a set of documents that can have varying structures and fields.

  • Documents: A document in MongoDB is a basic unit of data and is equivalent to a row or record in a relational database. It is a JSON-like object that contains key-value pairs, where values can be strings, numbers, arrays, or nested documents.

  • Fields: Fields represent individual pieces of data within a document. Each field has a name and a corresponding value. Fields can be of different data types, including strings, numbers, booleans, dates, arrays, or subdocuments.

  • Documents schema: MongoDB is schema-flexible, meaning that documents within a collection can have different structures and fields. There is no fixed schema definition, allowing for easy evolution and modification of data structures.

Database models

To create database models in MongoDB, we can use object-document mapper (ODM) libraries—PyMongo or mongoengine. These libraries provide abstractions and utilities for working with MongoDB collections and documents in a more structured manner.

Let’s take an example of a blog application where we want to store information about blog posts and comments. Here’s how we can create the database models using the mongoengine library in Python:

from mongoengine import Document, StringField, DateTimeField, ListField, ReferenceField



class Post(Document):

    title = StringField(required=True)

    content = StringField(required=True)

    created_at = DateTimeField(required=True)

    comments = ListField(ReferenceField('Comment'))



class Comment(Document):

    content = StringField(required=True)

    created_at = DateTimeField(required=True)

    author = StringField(required=True)
MongoDB models

In the above example, we define two models: Post and Comment.

  • The Post model represents a blog post and contains fields such as title, content, created_at, and comments.

  • The Comment model represents a comment on a blog post and contains fields like content, created_at, and author.

Note: The ListField and ReferenceField field types are used to establish relationships between models. In this case, the comments field in the Post model is a list of references to Comment documents.

Once we define the models, we can perform various operations, such as creating, updating, querying, and deleting documents using the defined models and the ODM library’s methods.

Unit tests for the models

Let’s see how we can create effective unit tests for our database models to verify their functionality and data integrity.

Database fixture

The database fixture is responsible for setting up the database connection and providing access to the database during testing. It can be configured to create a separate test database or use an existing one. Here is an example:

import pytest

from pymongo import MongoClient



@pytest.fixture(scope="session")

def db():

    # Connect to the MongoDB test database

    client = MongoClient('mongodb://localhost:27017/')

    db = client['test_db']

    yield db

    # Clean up after the tests by dropping the test database

    client.drop_database('test_db')
Database fixture

We can also use mongomock for database fixtures. The mongomock library for Python provides an in-memory MongoDB-like database for unit testing. It allows us to simulate a MongoDB database without actually connecting to a real MongoDB server, making it convenient for testing purposes.

Using mongomock as a database fixture in the unit tests can provide several benefits. It allows us to isolate the tests from the actual database, providing faster and more reliable tests. Additionally, it allows us to easily create, modify, and query data within the in-memory database, making it suitable for testing various scenarios and edge cases. Here is how we can define the fixture:

@pytest.fixture(scope="session", autouse=True)

def db():



    mongomock.utcnow()

    disconnect()



    _db = connect(

        db="mongoenginetest",

        host="mongodb://localhost",

        uuidRepresentation="standard",

        mongo_client_class=mongomock.MongoClient,

    )



    yield _db



    disconnect()
MongoMock

Pytest factories

Factories are used to generate test data for the database. They provide a convenient way to create objects with predefined attributes for testing purposes. We can use a library like pytest-factoryboy to define and create data factories. Here’s an example of a data factory for the Post model:

import factory

from datetime import datetime

from myapp.models import Post



class PostFactory(factory.Factory):

    class Meta:

        model = Post



    title = factory.Faker('sentence')

    content = factory.Faker('text')

    created_at = factory.LazyFunction(datetime.now)
Post factory

CRUD unit tests for models

CRUD unit tests for models provide confidence in the core functionality of the application and help maintain the stability and reliability of our database interactions. They contribute to the overall quality of our codebase and facilitate ongoing development and maintenance.

Python 3.10.4
from models import Post, Comment
def test_find_one_post(post):
    found_post = Post.objects(pk=post.id).get()
    assert found_post is not None
    assert found_post.id == post.id
    assert found_post.title == post.title
    assert found_post.content == post.content
def test_find_one_comment(comment):
    found_comment = Comment.objects(pk=comment.id).get()
    assert found_comment is not None
    assert found_comment.id == comment.id
    assert found_comment.message == comment.message
def test_create_one_comment(post):
    data = {
        'message': 'New Comment',
        'author': 'educative'
    }
    comment = Comment(**data)
    comment.save()
    post.comments.append(comment)
    post.save()
    
    found_comment = Comment.objects(pk=comment.id).get()
    assert found_comment.message == 'New Comment'
def test_update_one_post(post):
    updated_data = {
        'title': 'Updated Post',
        'content': 'This post has been updated'
    }
    post.modify(**updated_data)
    updated_post = Post.objects(pk=post.id).get()
    assert updated_post.title == 'Updated Post'
    assert updated_post.content == 'This post has been updated'

In the above code, we define the Post and Comment models in models.py. The conftest.py file contains the mock database and post and comment fixtures. The post and comment fixtures save the contents of the respective factories in the database, return the data, and clean it up after the test. When we pass these fixtures in the test function, the corresponding database object can be found during the execution of the particular test. Now let’s see what each test does.

  • test_find_one_post(post): This test aims to find a specific Post object in the database by its ID. It retrieves the post using the Post.objects(pk=post.id).get() method and verifies that the found post is not None, indicating that it exists in the database. It further checks if the id, title, and content attributes of the found_post match the original post object, ensuring the retrieval and attributes are correct.

  • test_find_one_comment(comment): This test focuses on finding a specific Comment object in the database by its ID. It retrieves the comment using the Comment.objects(pk=comment.id).get() method and verifies that the found comment is not None, indicating its presence in the database. It then checks if the id and message attributes of the found comment match the original comment object, ensuring the retrieval and attributes are accurate.

  • test_create_one_comment(post): This test covers the creation of a new Comment object and its association with a Post object. It creates a new comment using the provided data and saves it to the database. It then appends the newly created comment to the post.comments list and saves the updated post. Finally, it retrieves the comment from the database using its ID and verifies that the message attribute matches the expected value, ensuring the comment creation and association were successful.

  • test_update_one_post(post): This test focuses on updating the attributes of a Post object. It modifies the title and content attributes of the post object and saves the changes to the database. It then retrieves the updated post from the database and checks if the title and content attributes match the new values, ensuring that the update operation was successful.

These tests ensure the correct functioning of important database operations such as finding, creating, and updating objects. By verifying the expected behavior of these operations, we can ensure the reliability and integrity of the database interactions within our application.

Conclusion

In conclusion, performing database unit testing is crucial for ensuring the reliability, correctness, and integrity of the database operations in our application. By writing comprehensive tests that cover CRUD operations and other essential functionalities, we can identify and address any issues or bugs early in the development process. Using pytest as a testing framework provides a simple and powerful way to organize and execute tests, along with its extensive ecosystem of plugins and fixtures that enhance testing capabilities. The flexibility of pytest allows us to write clear, concise, and maintainable test code.

Test your learning!

1.

When performing database unit testing with pytest and MongoDB, what is the purpose of using a test database?

Show Answer
1 / 2