Una de las tareas más complicadas en entornos de desarrollo es trabajar con datos que se asemejen lo más posible a los del entorno real. Esto es crucial tanto para la creación de nuevos features como para poder replicar y resolver Bugs.

Afortunadamente Django nos ofrece una herramienta con la cual podemos manejar los datos de nuestras aplicaciones, ya sea haciendo respaldo de información, o cargando datos a nuestra base de datos. Esto último resulta particularmente útil cuando nos encontramos en desarrollo y deseamos trabajar con datos fakes.

Para esta nueva entrega en PyWombat hablaremos acerca de los fixtures en Django. Aprenderemos cómo y cuándo usarlos.

Bien, sin más introducción, pongamos manos a la obra.

Fixtures.

En términos simples los fixtures en Django no son más que archivos (e.g .JSON .XML, YAML …) con los cuales podemos gestionar los datos de nuestro sitio web. Ya sea para hacer algún respaldo de nuestra base de datos o simplemente cargar datos para temas de desarrollo o testing.

Una de las principales ventajas de usar fixtures es sin duda la facilidad de poder cargar datos a nuestra base de datos y así estar listos para poder crear nuevos features o solucionar bugs. Esto es sumamente útil para construir (o re construir) nuestros entornos de desarrollo.

Crear fixtures

La forma más sencilla de poder crear fixtures es usando el comando dumpdata.

E.g

python manage.py dumpdata myapp > myapp/fixtures/initial_data.json

La documentación nos indica que los fixtures debemos almacenarlos en una carpeta llamada fixtures que se encuentre dentro de nuestra aplicación.

python manage.py dumpdata countries > countries/fixtures/initial_data.json

o con un formato especifico.

python manage.py dumpdata countries --indent 4 > countries/fixtures/initial_data.json

Por default el formato será JSON, sin embargo podemos cambiar esto.

python manage.py dumpdata countries --format=yaml > countries/fixtures/initial_data.yaml

Dando como resultado el siguiente .json file.

[
    {
        "model": "countries.country", 
        "pk": 1,  
        "fields": {
            "name": "Argentina",
            "code": "AR",
            "created_at": "2024-09-28T12:00:00Z"
        }
    },
    {
        "model": "countries.country",
        "pk": 2,
        "fields": {
            "name": "Chile",
            "code": "CL",
            "created_at": "2024-09-28T12:30:00Z"
        }
    },
        {
        "model": "countries.country",
        "pk": 3,
        "fields": {
            "name": "Mexico",
            "code": "MX",
            "created_at": "2024-09-28T13:30:00Z"
        }
    }
]

Podemos observar como lo objetos son representados en objetos Json. Se determina a que modelo pertenecen, el id y por supuesto, cada uno de sus attributos.

Otra forma de crear los fixtures es haciéndolo de forma manual. Usando la misma estructura previamente mostrada (Modelo, llave primaria y campos) podremos crear nuestros propios archivos .json, un listado de objetos.

Aquí otro ejemplo para mi modelo Product.

  [
    {
        "model": "products.product",
        "pk": 1,
        "fields": {
            "name": "Wireless Headphones",
            "description": "High-quality wireless headphones with noise cancellation.",
            "price": 199.99
        }
    },
    {
        "model": "products.product",
        "pk": 2,
        "fields": {
            "name": "Smartwatch",
            "description": "A stylish smartwatch with fitness tracking and notifications.",
            "price": 129.99
        }
    },
    {
        "model": "products.product",
        "pk": 3,
        "fields": {
            "name": "Bluetooth Speaker",
            "description": "Portable Bluetooth speaker with 360-degree sound.",
            "price": 89.99
        }
    }
]

Por supuesto, estos son ejemplos sumamente sencillos, tú puedes usar modelos mucho más complejos con una N cantidad de campos.

Load fixtures.

Listo, ya tenemos nuestros fixtures, ¿ahora qué? Bueno, una vez los archivos se encuentren en nuestro proyecto ya podemos usarlos para cargar nuestra base de datos la N cantidad de veces que deseemos.

La forma más sencilla de lograr esto es ejecutando el siguiente comando.

python manage.py loaddata initial_data.json

Django buscará el archivo initial_data.json sobre cada carpeta fixtures de las aplicaciones registradas (He de allí la importancia de siempre guardar los fixtures en la carpeta fixtures de tus aplicaciones myapp/fixtures).

Si queremos especificar un fixture en particular debemos usar el siguiente comando.

python manage.py loaddata skills/fixtures/initial_data.json

Dado que un proyecto en Django tiende a tener una N cantidad de aplicaciones, y cada aplicación tiende a tener (por lo menos) un modelo, sin duda alguna, tarde o temprano, terminaremos con un N cantidad de fixtures en nuestros proyectos, por lo tanto te recomiendo siempre tener un único punto de acceso para cargar todos estos fixtures. Para ello podemos apoyarnos de un archivo Makefile.

E.g

Makefile

load_data:
  python manage.py loaddata countries/fixtures/initial_data.json
  python manage.py loaddata users/fixtures/initial_data.json
  python manage.py loaddata products/fixtures/initial_data.json
  python manage.py loaddata prices/fixtures/initial_data.json
  ...