Genereer echte testbestanden in elke exacte grootte

Het probleem

Eén testbestand maken is makkelijk. De juiste duizend maken is het vervelende deel

Je test software die bestanden van mensen aanneemt. Vroeg of laat heb je nodig:

• een PDF van precies 10 MB, om uit te zoeken of de uploadlimiet echt is
• de drie bestanden aan weerszijden van die limiet, om off-by-one-fouten te vangen
• 10.000 logbestanden, om te zien wat de nachtelijke taak doet als de map groot is
• een ZIP die echt 200 documenten bevat, geen lege huls met de juiste extensie
• een bestand van 4 GB, zonder een bestand van 4 GB in je repository te bewaren
• dezelfde fixtures op je laptop en op de buildserver, byte voor byte

Dat is wat dit vervangt. Het is gebouwd voor QA-engineers, testautomatisering en iedereen wiens code een uploadformulier, een importroutine, een parser of een opslagquotum achter zich heeft.

Wat het anders maakt

Andere generatoren stoppen bij de bytes. Deze beantwoordt wat je test werkelijk vraagt

Een map met bestanden laat je nog steeds beslissen wat elk bestand moet bewijzen. Elke run schrijft hier een manifest.json naast de bestanden - een eenvoudige lijst van alles wat is gemaakt, en bij elk item een gedeclareerde verwachting.

Stel dat je upload-endpoint 1 MB toestaat. Vraag de drie bestanden die op die lijn zitten:

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

Drie bestanden, drie verschillende antwoorden, in machineleesbare vorm. Je test leest het manifest in plaats van dat jij de asserties met de hand schrijft:

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

Kies de vraag, krijg de hele set

Een preset is een set testbestanden ontworpen rond één testvraag, zodat je zelf niet hoeft uit te zoeken welke bestanden wat bewijzen. Elke heeft een pagina die zegt wat hij meestal vindt, wat er in de set zit en welke instellingen hij kent.

• Leeg en minimaal

  Komt een geldig bestand dat zo klein is als het formaat toestaat door de controle?

  empty-and-minimal

• Omgaan met bestandsnamen

  Slaat mijn systeem een bestandsnaam op, toont en geeft het die terug, ook als het die niet verwachtte?

  filename-handling

• Groottegrenzen

  Wordt een groottelimiet precies afgedwongen waar hij is opgegeven?

  size-boundaries

• Tabelimport

  Overleeft mijn tabelimport wat echte tools exporteren?

  tabular-import

• Tekencodering

  Weet mijn lezer in welke codering een bestand staat, of gokt hij?

  text-encoding

• Uploadvalidatie

  Neemt mijn uploadformulier aan wat het moet en weigert het de rest?

  upload-validation

Alle presets, en hoe ze zich tot recepten verhouden

Snel starten

Drie opdrachten om het te zien werken

1. Maak een bestand

   Eén PNG, precies twee megabyte:

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

2. Maak veel bestanden

   Tienduizend logbestanden, elk tussen één en acht kilobyte, met groottes getrokken uit de seed zodat morgen dezelfde set oplevert. Geef elke run een eigen map - het manifest is het enige verslag van wat een run schreef, dus de tool weigert er een tweede overheen te schrijven:

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

3. Controleer ze en verwijder ze dan

   verify zegt je dat er niets verschoven is. cleanup verwijdert precies wat is geschreven en niets anders:

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

Groottes tellen in 1024-tallen, zoals je bestandsbeheer doet, dus 2mb betekent 2097152 bytes. Een gewoon aantal bytes werkt ook. De documentatie behandelt recepten, het manifest en de afsluitcodes.

Wat je krijgt

Gebouwd voor een suite die onbeheerd draait

• Exacte grootte, tot op de byte

  Vraag 10485761 bytes en krijg precies dat. Een grootte die een formaat niet kan halen is een fout met een reden, nooit een bestand van de verkeerde grootte.

• 26 echte formaten

  Geen opgevulde nullen met een extensie. Een gegenereerde PNG opent in een afbeeldingsviewer, een DOCX opent in Word, een ZIP pakt uit. Elk wordt vóór levering gecontroleerd met onafhankelijke lezers.

• Een manifest dat een testorakel is

  Pad, grootte, SHA-256, formaat, seed, toolversie - en wat je systeem met het bestand moet doen.

• Reproduceerbaar

  Hetzelfde recept en dezelfde seed, dezelfde bytes, op elke machine. Commit een klein YAML-recept in plaats van grote binaire fixtures.

• Twee interfaces, één engine

  Een opdrachtregel gebouwd voor CI en een bureaubladvenster voor verkennend testen. Geen van beide is een uitgeklede versie van de ander, en een test vergelijkt ze mogelijkheid voor mogelijkheid.

• Volledig offline

  Geen account, geen cloud, geen telemetrie, geen updatecontrole. In de opdrachtregel-binary is helemaal geen netwerkstack gecompileerd.

Download

Kies de build voor je systeem

Pak het archief uit en start het. tfg is de opdrachtregel en tfg-gui is het bureaubladvenster. Er is geen installatieprogramma en niets om aan je machine toe te voegen.

Gratis en open source, GPL-3.0. Geen account nodig. De downloads voor Windows en macOS zijn ondertekend en starten zonder waarschuwing.