Genera archivos de prueba reales al tamaño exacto

El problema

Hacer un archivo de prueba es fácil. Hacer los mil correctos es la parte tediosa

Estás probando software que acepta archivos de personas. Tarde o temprano necesitas:

• un PDF de exactamente 10 MB, para saber si el límite de subida es real
• los tres archivos a ambos lados de ese límite, para cazar errores de uno
• 10 000 archivos de registro, para ver qué hace el trabajo nocturno cuando la carpeta es grande
• un ZIP que de verdad contiene 200 documentos, no un cascarón con la extensión correcta
• un archivo de 4 GB, sin guardar un archivo de 4 GB en tu repositorio
• los mismos fixtures en tu portátil y en el servidor de compilación, byte a byte

Eso es lo que esto sustituye. Está pensado para ingenieros de QA, automatización de pruebas y cualquiera cuyo código tenga detrás un formulario de subida, una rutina de importación, un analizador o una cuota de almacenamiento.

Qué lo hace distinto

Otros generadores se quedan en los bytes. Este responde a lo que tu prueba realmente pregunta

Una carpeta de archivos te deja aún decidiendo qué se supone que demuestra cada uno. Cada ejecución escribe aquí un manifest.json junto a los archivos - una lista simple de todo lo producido y, para cada entrada, una expectativa declarada.

Supón que tu endpoint de subida permite 1 MB. Pide los tres archivos que están sobre esa línea:

tfg generate --preset size-boundaries --limit 1mb --spread 1B --format pdf --out ./edges

Tres archivos, tres respuestas distintas, en forma legible por máquina. Tu prueba lee el manifiesto en lugar de que escribas las aserciones a mano:

import json, os

directory = "edges"
manifest = json.load(open(os.path.join(directory, "manifest.json")))

for entry in manifest["files"]:
    response = upload(os.path.join(directory, entry["path"]))
    outcome = entry["expected"]["outcome"]
    if outcome == "accept":
        assert response.ok, entry["path"]
    elif outcome == "reject":
        assert not response.ok, entry["path"]

Presets

Elige la pregunta, obtén el conjunto entero

Un preset es un conjunto de archivos de prueba diseñado en torno a una pregunta de prueba, para que no tengas que averiguar qué archivos demuestran qué. Cada uno tiene una página que dice qué suele encontrar, qué hay en el conjunto y cada ajuste que admite.

• Vacío y mínimo

  ¿Pasa un archivo válido y tan pequeño como permite el formato?

  empty-and-minimal

• Manejo de nombres de archivo

  ¿Mi sistema guardará, mostrará y devolverá un nombre de archivo que no esperaba?

  filename-handling

• Límites de tamaño

  ¿Se aplica un límite de tamaño exactamente donde se declara?

  size-boundaries

• Importación de tablas

  ¿Sobrevive mi importación de tablas a lo que exportan las herramientas reales?

  tabular-import

• Codificación de texto

  ¿Sabe mi lector en qué codificación está un archivo, o lo adivina?

  text-encoding

• Validación de subida

  ¿Mi formulario de subida acepta lo que debe y rechaza el resto?

  upload-validation

Todos los presets, y cómo se relacionan con las recetas

Inicio rápido

Tres comandos para verlo funcionar

1. Crea un archivo

   Un PNG, exactamente dos megabytes:

   tfg generate --format png --size 2mb --out ./fixtures

2. Crea muchos archivos

   Diez mil archivos de registro, cada uno de entre uno y ocho kilobytes, con los tamaños sacados de la semilla para que mañana dé el mismo conjunto. Dale a cada ejecución su propio directorio - el manifiesto es el único registro de lo que escribió una ejecución, así que la herramienta se niega a escribir un segundo encima:

   tfg generate --format log --size-range 1kb-8kb --count 10000 --out ./logs

3. Compruébalos y luego elimínalos

   verify te dice que nada se movió. cleanup elimina exactamente lo que se escribió y nada más:

   tfg verify ./logs/manifest.json
   tfg cleanup ./logs/manifest.json --yes

Los tamaños cuentan de 1024 en 1024, como hace tu gestor de archivos, así que 2mb significa 2097152 bytes. Un número de bytes simple también sirve. La documentación cubre las recetas, el manifiesto y los códigos de salida.

Qué obtienes

Pensado para un conjunto de pruebas que corre sin supervisión

• Tamaño exacto, al byte

  Pide 10485761 bytes y obtén exactamente eso. Un tamaño que un formato no puede alcanzar es un error con un motivo, nunca un archivo del tamaño equivocado.

• 26 formatos reales

  No ceros de relleno con una extensión. Un PNG generado se abre en un visor de imágenes, un DOCX se abre en Word, un ZIP se extrae. Cada uno se comprueba con lectores independientes antes de publicarse.

• Un manifiesto que es un oráculo de pruebas

  Ruta, tamaño, SHA-256, formato, semilla, versión de la herramienta - y qué debe hacer tu sistema con el archivo.

• Reproducible

  Misma receta y misma semilla, mismos bytes, en cualquier máquina. Sube al repositorio una receta YAML pequeña en lugar de fixtures binarios grandes.

• Dos interfaces, un motor

  Una línea de comandos pensada para CI y una ventana de escritorio para pruebas exploratorias. Ninguna es una versión recortada de la otra, y una prueba las compara capacidad por capacidad.

• Completamente sin conexión

  Sin cuenta, sin nube, sin telemetría, sin comprobación de actualizaciones. El binario de la línea de comandos no lleva compilada ninguna pila de red.

Descarga

Elige la versión para tu sistema

Descomprime el archivo y ejecútalo. tfg es la línea de comandos y tfg-gui es la ventana de escritorio. No hay instalador ni nada que añadir a tu máquina.

Gratuito y de código abierto, GPL-3.0. Sin registro. Las descargas de Windows y macOS están firmadas y se inician sin advertencias.