Django Fake Model

0.1.4 · maintenance · verified Sun Apr 12

django-fake-model is a simple Python library designed for creating temporary, in-memory Django models specifically for unit testing purposes. It allows developers to quickly define and use fake models within their tests without polluting the main database schema, facilitating isolated and efficient testing. The current version is 0.1.4, and its release cadence has been very slow, with the last update in 2017.

Warnings

breaking The library has not been updated since 2017 and is likely incompatible with modern Django versions (3.x, 4.x, 5.x) and newer Python versions (3.8+). It was last officially tested with Django 1.9.
Fix: For newer Django projects, consider using more actively maintained alternatives like `django-dynamic-models` or manual test-model creation. If absolutely necessary, pin Django to 1.9 and Python to 3.7 or earlier.
gotcha The lack of active maintenance since 2017 means the library may have unpatched bugs, security vulnerabilities, or simply not function as expected with contemporary Django ecosystem components.
Fix: Carefully evaluate the long-term implications of using an unmaintained library. For new development, prioritize actively supported tools.
gotcha Prior to version 0.1.3, defining and using multiple fake models within the same test context could lead to unexpected behavior or conflicts. This was fixed in 0.1.3.
Fix: Ensure you are using version 0.1.3 or higher to reliably use multiple fake models within your tests.
gotcha Version 0.1.4 specifically fixed issues related to the `fake_me` class decorator when used with `nose` tests. If you are using `fake_me` with other test runners, thoroughly test its behavior.
Fix: Upgrade to version 0.1.4 for `nose` compatibility. For other test runners (e.g., `pytest-django`), verify functionality explicitly or consider using `model_me` which might be more robust across different setups.

Install

pip install django-fake-model Install stable version

Imports

model_me
```
from fake_model import model_me
```
fake_me
```
from fake_model import fake_me
```

Quickstart

This quickstart demonstrates how to use the `model_me` decorator to create a temporary Django model for a specific test method. The fake model is automatically registered and unregistered, ensuring test isolation. This code snippet should be placed within a Django test file and run as part of a Django test suite.

import unittest
from django.test import TestCase
from django.db import models
from fake_model import model_me

class MyFakeModelTest(TestCase):
    """
    Example demonstrating the model_me decorator for creating a temporary Django model.
    To execute this test, ensure you have a Django project configured and run it
    via `python manage.py test your_app_name`.
    """
    @model_me('my_app', 'MyFakeModel', fields={
        'name': models.CharField(max_length=255),
        'value': models.IntegerField(default=0),
    })
    def test_create_and_query_fake_model(self, MyFakeModel):
        # MyFakeModel is a temporary model class, available only within this test method
        self.assertFalse(MyFakeModel.objects.exists()) # Should be empty initially

        instance = MyFakeModel.objects.create(name='Test Item', value=42)
        self.assertEqual(instance.name, 'Test Item')
        self.assertEqual(instance.value, 42)

        retrieved = MyFakeModel.objects.get(name='Test Item')
        self.assertEqual(retrieved.pk, instance.pk)
        self.assertEqual(retrieved.value, 42)

        self.assertEqual(MyFakeModel.objects.count(), 1)

view raw JSON →