Skip to main content

Simple tests tools to make testing faster and easier.

Project description Updates Documentation Status

Simple tests tools to make testing faster and easier. Most of the tools are to do a quick scaffolding for tests.

The tools presume a naming convention:

  • Tests: Are named with the convention TestCaseModelName. For a model named Poll the test would be generated as the testing class would be TestCasePoll

  • Factories: Are named with the convention ModelName. For a model named Poll the test would be generated as the testing class would be PollFactory

  • Serializers: Are named with the convention TestCaseSerializer. For a model named Poll the test would be generated as the testing class would be PollSerializer

Compatibility matrix:

Python version

Django 1.11.x

Django 2.2.x

Django 3.0.x










The full documentation is at


Install Django Test Tools:

pip install django-test-tools

In your file add it to your INSTALLED_APPS


Create an output folder in the root folder of you project, name it what ever you want, and add the settings variable TEST_OUTPUT_PATH pointing to it. Make sure to add this folder to your .gitignore file.

import environ

    environ.Path(__file__) - 3
)  # (my_project/config/settings/ - 3 = alpha_clinic/)
APPS_DIR = ROOT_DIR.path("my_project")
TEST_OUTPUT_PATH = ROOT_DIR.path("output").root


Factory Generator

To create Factory Boy style factories.

For a django project named polling_app with an app name poll the following command will generate the scaffolding for the tests for all the models in th app polls.

$  python generate_factories polling_app.polls

For the following models

class OperatingSystem(models.Model):
    name = models.CharField(max_length=20)
    version = models.CharField(max_length=5)
    licenses_available = models.IntegerField()
    cost = models.DecimalField(decimal_places=2, max_digits=7)

    class Meta:
        unique_together = ('name', 'version')

class Server(models.Model):
                   (DEVELOPMENT, 'Dev'))
    name = models.CharField(max_length=20, unique=True)
    notes = models.TextField()
    virtual = models.BooleanField()
    ip_address = models.GenericIPAddressField()
    created = models.DateTimeField()
    online_date = models.DateField()
    operating_system = models.ForeignKey(OperatingSystem, related_name='servers', on_delete=models.CASCADE)
    server_id = models.CharField(max_length=6)
    use = models.CharField(max_length=4, choices=USE_CHOICES, default=DEVELOPMENT)
    comments = models.TextField(null=True, blank=True)

running python generate_factories example.servers > ./output/ will create the following factories

import string

from random import randint
from pytz import timezone

from django.conf import settings

from factory import Iterator
from factory import LazyAttribute
from factory import SubFactory
from factory import lazy_attribute
from factory.django import DjangoModelFactory, FileField
from factory.fuzzy import FuzzyText, FuzzyInteger
from faker import Factory as FakerFactory

from example.servers.models import OperatingSystem, Server

faker = FakerFactory.create()

class OperatingSystemFactory(DjangoModelFactory):
    class Meta:
        model = OperatingSystem

    name = LazyAttribute(lambda x: faker.text(max_nb_chars=20))
    version = LazyAttribute(lambda x: faker.text(max_nb_chars=5))
    licenses_available = LazyAttribute(lambda o: randint(1, 100))
    cost = LazyAttribute(lambda x: faker.pydecimal(left_digits=5, right_digits=2, positive=True))

class ServerFactory(DjangoModelFactory):
    class Meta:
        model = Server

    name = LazyAttribute(lambda x: faker.text(max_nb_chars=20))
    notes = LazyAttribute(lambda x: faker.paragraph(nb_sentences=3, variable_nb_sentences=True))
    virtual = Iterator([True, False])
    ip_address = LazyAttribute(lambda o: faker.ipv4(network=False))
    created = LazyAttribute(lambda x: faker.date_time_between(start_date="-1y", end_date="now",
    online_date = LazyAttribute(lambda x: faker.date_time_between(start_date="-1y", end_date="now",
    operating_system = SubFactory(OperatingSystemFactory)
    server_id = LazyAttribute(lambda x: FuzzyText(length=6, chars=string.digits).fuzz())
    use = Iterator(Server.CHOICES, getter=lambda x: x[0])
    comments = LazyAttribute(lambda x: faker.paragraph(nb_sentences=3, variable_nb_sentences=True))

Important the use attribute is created incorrectly. When you use choices you need to manually change it to USE_CHOICES.

use = Iterator(Server.USE_CHOICES, getter=lambda x: x[0])

Model Test Case Generator

$  python generate_model_test_cases

Serializer Generator

$ python generate_serializers -s ModelSerializer

Writing assertions

One of the most boring steps of writing tests is checking the content of static dictionaries. You now the content of the dictionary and you need to compare it with a result.

In the following code the assertions for the data dictionary will be generated in the fn file. IMPORTANT the name of the dictionary in this case data must be the same as the second argument of the method in order to generate the correct assertions.

fn = './output/'
data = [
        {'name': 'kilo', 'password': 9999,
         'groups': ['admin', 'users'],
         'config': {'server': 'all', 'bulding': 116}},
        {'name': 'pasto', 'password': 'nogo',
         'groups': ['users'],
         'config': {'server': 'database', 'bulding': None},
         'created_date': date(2016, 1, 3),
         'modified': '2016-10-01'}
    filename = write_assertions(data, 'data', filename=fn, type_only=True,excluded_keys=['config']))

The result of this script:

self.assertEqual(len(data), 2)
self.assertEqual(len(data[0]['groups']), 2)
self.assertEqual(data[0]['groups'][0], 'admin')
self.assertEqual(data[0]['groups'][1], 'users')
self.assertEqual(data[0]['name'], 'kilo')
self.assertEqual(data[0]['password'], 9999)
self.assertEqual(len(data[1]['groups']), 1)
self.assertEqual(data[1]['groups'][0], 'users')
self.assertEqual(data[1]['name'], 'pasto')
self.assertEqual(data[1]['password'], 'nogo')

Running Tests

Does the code actually work?

source <YOURVIRTUALENV>/bin/activate
(myenv) $ python tests

Pushing code to Pypi

  1. Setup environment

source ./venv/bin/activate
  1. Updated version. Instead of patch you could also use major o minor depending on the level of the release.

$ make patch
  1. Check the .travis.yml to make sure the versions of Django are the latests. Check in for the latest versions.

  2. Check for Django and Python versions.

  3. Close the git-flow release manually.

  4. Push to repo, Travis CI should deploy to pypi

make travis-push


Tools used in rendering this package:


0.1.0 (2017-04-26)

  • First release on PyPI.

Project details

Release history Release notifications | RSS feed

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

django-test-tools-2.2.3.tar.gz (41.2 kB view hashes)

Uploaded Source

Built Distribution

django_test_tools-2.2.3-py2.py3-none-any.whl (50.8 kB view hashes)

Uploaded Python 2 Python 3

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page