Genera file di test reali della dimensione esatta

Il problema

Fare un file di test è facile. Fare i mille giusti è la parte noiosa

Stai testando software che accetta file dalle persone. Prima o poi ti servono:

• un PDF di esattamente 10 MB, per scoprire se il limite di upload è reale
• i tre file ai due lati di quel limite, per scovare errori di uno in più o in meno
• 10.000 file di log, per vedere cosa fa il job notturno quando la cartella è grande
• uno ZIP che contiene davvero 200 documenti, non un guscio vuoto con l'estensione giusta
• un file da 4 GB, senza tenere un file da 4 GB nel tuo repository
• le stesse fixture sul tuo portatile e sul server di build, byte per byte

È ciò che questo sostituisce. È pensato per ingegneri QA, automazione dei test e chiunque abbia dietro al proprio codice un modulo di upload, una routine di importazione, un parser o una quota di storage.

Cosa lo rende diverso

Gli altri generatori si fermano ai byte. Questo risponde a ciò che il tuo test chiede davvero

Una cartella di file ti lascia ancora a decidere cosa dovrebbe dimostrare ciascuno. Ogni esecuzione qui scrive un manifest.json accanto ai file - un semplice elenco di tutto ciò che è stato prodotto e, per ogni voce, un'aspettativa dichiarata.

Poniamo che il tuo endpoint di upload permetta 1 MB. Chiedi i tre file che stanno su quella linea:

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

Tre file, tre risposte diverse, in forma leggibile da macchina. Il tuo test legge il manifest invece che tu scriva le asserzioni 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"]

Preset

Scegli la domanda, ottieni l'intero set

Un preset è un set di file di test progettato attorno a una domanda di test, così non devi capire tu quali file dimostrano cosa. Ognuno ha una pagina che dice cosa trova di solito, cosa c'è nel set e ogni impostazione che accetta.

• Vuoto e minimo

  Un file valido e piccolo quanto il formato consente passa?

  empty-and-minimal

• Gestione dei nomi di file

  Il mio sistema salverà, mostrerà e restituirà un nome di file che non si aspettava?

  filename-handling

• Limiti di dimensione

  Un limite di dimensione viene applicato esattamente dove è dichiarato?

  size-boundaries

• Importazione di tabelle

  La mia importazione di tabelle regge a ciò che esportano gli strumenti reali?

  tabular-import

• Codifica del testo

  Il mio lettore sa in quale codifica è un file, o tira a indovinare?

  text-encoding

• Validazione dell'upload

  Il mio modulo di upload accetta ciò che deve e respinge il resto?

  upload-validation

Tutti i preset, e come si rapportano alle ricette

Guida rapida

Tre comandi per vederlo funzionare

1. Crea un file

   Un PNG, esattamente due megabyte:

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

2. Crea molti file

   Diecimila file di log, ciascuno tra uno e otto kilobyte, con le dimensioni estratte dal seed così domani dà lo stesso set. Dai a ogni esecuzione la sua directory - il manifest è l'unica traccia di ciò che un'esecuzione ha scritto, quindi lo strumento si rifiuta di scriverne un secondo sopra:

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

3. Controllali, poi rimuovili

   verify ti dice che nulla si è mosso. cleanup rimuove esattamente ciò che è stato scritto e nient'altro:

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

Le dimensioni si contano a 1024, come fa il tuo file manager, quindi 2mb significa 2097152 byte. Funziona anche un semplice numero di byte. La documentazione copre le ricette, il manifest e i codici di uscita.

Cosa ottieni

Costruito per una suite che gira senza supervisione

• Dimensione esatta, al byte

  Chiedi 10485761 byte e ottieni esattamente quelli. Una dimensione che un formato non può raggiungere è un errore con un motivo, mai un file della dimensione sbagliata.

• 26 formati reali

  Non zeri di riempimento con un'estensione. Un PNG generato si apre in un visualizzatore di immagini, un DOCX si apre in Word, uno ZIP si estrae. Ognuno è verificato con lettori indipendenti prima del rilascio.

• Un manifest che è un oracolo di test

  Percorso, dimensione, SHA-256, formato, seed, versione dello strumento - e cosa il tuo sistema deve fare con il file.

• Riproducibile

  Stessa ricetta e stesso seed, stessi byte, su qualsiasi macchina. Committa una piccola ricetta YAML invece di grandi fixture binarie.

• Due interfacce, un solo motore

  Una riga di comando pensata per la CI e una finestra desktop per il test esplorativo. Nessuna è una versione ridotta dell'altra, e un test le confronta capacità per capacità.

• Completamente offline

  Nessun account, nessun cloud, nessuna telemetria, nessun controllo degli aggiornamenti. Il binario della riga di comando non ha alcuno stack di rete compilato al suo interno.

Download

Scegli la build per il tuo sistema

Decomprimi l'archivio ed eseguilo. tfg è la riga di comando e tfg-gui è la finestra desktop. Non c'è un installer e nulla da aggiungere alla tua macchina.

Gratuito e open source, GPL-3.0. Nessuna registrazione. I download per Windows e macOS sono firmati e si avviano senza avvisi.