Testing Files Generator
Nederlands

Hoe maak je een beschadigd bestand om mee te testen

Een validator aan wie alleen gezonde bestanden zijn getoond, is niet echt getest. Zo krijg je een bestand dat met opzet kapot is, precies de grootte heeft die je vraagt en een manifest meebrengt dat zegt wat je systeem ermee moet doen.

Het korte antwoord

tfg generate --format png --size 2mb --damage zero-head --out ./out schrijft een PNG van precies 2097152 bytes waarvan de eerste bytes nullen zijn, en het manifest ernaast legt vast dat je systeem het moet weigeren.

De gebruikelijke weg

Waarom een met de hand beschadigd bestand een slechte test is

Gebruikelijk zijn een hexeditor, een script dat een paar willekeurige bytes omgooit, of een bestand dat met head of truncate wordt ingekort. Het werkt één keer, en daarna kost het je:

Wat je krijgt

Een beschadigd bestand heeft nog steeds de grootte die je vroeg

Het bestand wordt normaal gegenereerd en daarna kapotgemaakt, op weg naar de schijf. Het houdt de grootte die je vroeg, en hetzelfde commando schrijft opnieuw dezelfde bytes.

tfg generate --format png --size 2mb --damage zero-head --out ./out
tfg generate --format pdf --size 1mb --count 5 --damage zero-head:bytes=16 --out ./broken
tfg generate --format zip --size 5mb --damage truncate:missing=30 --out ./cut
tfg generate --format jpg --size 500kb --damage append-junk --out ./tail

Instellingen komen achter een dubbele punt. De optie mag herhaald worden, en de beschadigingen worden toegepast in de volgorde waarin je ze schrijft. Het werkt met elk van de 32 formaten.

Wat het kan

Welke beschadigingen zijn er?

Dit is de lijst die het programma afdrukt, uit het programma gelezen op het moment dat deze pagina wordt gebouwd. tfg damage drukt dezelfde af, en tfg damage <id> zegt wat één ervan aanneemt.

Beschadiging Wat het met de bytes doet Kleinste bestand Instellingen
append-junk Schrijft willekeurige bytes achter het einde van het bestand en houdt precies de gevraagde grootte, zoals een bestand binnenkomt waar iets aan het einde aan vastzit. 64 bytes
truncate Knipt het einde van het bestand af en houdt precies de gevraagde grootte, zoals een afgebroken upload of kopie het achterlaat. 4 missing
zero-head Overschrijft de eerste bytes van het bestand met nullen en laat de lengte ongemoeid. De meeste lezers kijken daar eerst, dus bijna alles merkt deze beschadiging. 8 bytes

zero-head schrijft nullen over het begin van het bestand. De meeste lezers kijken daar eerst, naar de handtekening en de kop die zeggen wat het bestand is, dus bijna elke lezer merkt het. Platte tekst en logbestanden hebben geen handtekening en worden ook geweigerd, omdat een reeks nulbytes geen tekst is. Onder vier bytes komen sommige formaten uit met schade waar geen lezer over klaagt, en daarom begint de instelling bij vier.

truncate knipt het einde van het bestand af, zoals een afgebroken upload of kopie het achterlaat, en het bestand heeft toch de gevraagde grootte: het wordt groter gemaakt en alleen het begin komt op de schijf. missing zegt welk deel van het hele bestand weg is, de helft als je niets anders opgeeft.

append-junk schrijft willekeurige bytes achter het einde van het bestand, 64 als je niets anders opgeeft, zoals een bestand binnenkomt waar iets aan het einde aan vastzit. Dezelfde opdracht voegt dezelfde bytes toe.

Wat het manifest zegt

Een manifest dat zegt wat er moet gebeuren

Waar de beschadiging de regels van het formaat breekt, zegt de vermelding dat je systeem het bestand moet weigeren, met de beschadiging ernaast vastgelegd:

"expected": {
  "outcome": "reject",
  "reason": "content_malformed",
  "confidence": "certain"
},
"damage": [
  {
    "type": "zero-head",
    "settings": {
      "bytes": "8"
    }
  }
]

Waar lezers verschillen, zegt de vermelding dat in plaats van te gokken. Een afgeknipt tekstbestand is nog steeds tekst, en de meeste viewers slaan bytes achter het einde van een PNG over, dus laat de vermelding het antwoord aan je systeem, biedt beide aan en zegt waarom:

"expected": {
  "outcome": "unspecified",
  "reason": "content_malformed",
  "detail": "A PNG ends at its IEND chunk and most viewers skip what follows it.",
  "confidence": "policy_dependent",
  "policy_options": ["accept", "reject"]
}

tfg damage <id> noemt de formaten waarin een beschadiging het antwoord aan je systeem laat, en waarom.

Vier verzoeken worden geweigerd voordat er iets wordt geschreven, omdat elk een bestand op schijf zou laten staan dat het manifest verkeerd beschrijft:

In een recept

Gezonde en kapotte bestanden in één run

Zet beide in één recept, en het manifest draagt de verwachting van elk bestand, zodat de test geen lijst nodig heeft van welk bestand welk is:

version: 1
targets:
  - id: healthy
    format: pdf
    size: 1mb
    expected: accept
  - id: broken
    format: pdf
    size: 1mb
    damage:
      - zero-head

In een test

Er een test van maken

De test leest het manifest en controleert dat wat er gebeurde is wat er werd opgegeven. Hij heeft geen lijst met bestandsnamen nodig:

import json, os

directory = "healthy-and-broken"
manifest = json.load(open(os.path.join(directory, "manifest.json")))

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

Een bestand met de uitkomst unspecified wordt hier overgeslagen, omdat je eigen beleid bepaalt wat je systeem ermee moet doen. De vermelding zegt waarom, en policy_options noemt de mogelijke antwoorden.

Een goede weigering is een schone weigering. Een melding die zegt wat er mis was, is het antwoord dat je wilt. Een serverfout, een vastloper of een half opgeslagen bestand is het gebrek dat deze test moet vinden.

Verder

Waar je vandaar heen kunt