Testing Files Generator
Italiano

Come creare un file corrotto per i test

Un validatore a cui sono stati mostrati solo file sani non è stato davvero testato. Ecco come ottenere un file rotto di proposito, che esce con esattamente la dimensione richiesta e porta un manifest che dice cosa il tuo sistema deve farne.

La risposta breve

tfg generate --format png --size 2mb --damage zero-head --out ./out scrive un PNG di esattamente 2097152 byte i cui primi byte sono zeri, e il manifest accanto registra che il tuo sistema deve rifiutarlo.

Il modo solito

Perché un file corrotto a mano è un cattivo test

I modi soliti sono un editor esadecimale, uno script che cambia qualche byte a caso o un file accorciato con head o truncate. Funzionano una volta, poi costano:

Cosa ottieni

Un file danneggiato ha ancora la dimensione richiesta

Il file viene generato normalmente e rotto dopo, mentre va verso il disco. Mantiene la dimensione richiesta, e lo stesso comando riscrive gli stessi byte.

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

Le impostazioni vanno dopo i due punti. L'opzione si può ripetere, e i danni vengono applicati nell'ordine in cui li scrivi. Funziona con ognuno dei 32 formati.

Cosa sa fare

Quali danni ci sono?

Questa è la lista che il programma stampa, letta da lui quando si costruisce questa pagina. tfg damage stampa la stessa, e tfg damage <id> dice cosa accetta ciascuno.

Danno Cosa fa ai byte File più piccolo Impostazioni
append-junk Scrive byte casuali dopo la fine del file e mantiene esattamente la dimensione richiesta, come arriva un file con qualcosa attaccato in fondo. 64 bytes
truncate Taglia la fine del file e mantiene esattamente la dimensione richiesta, come la lascia un caricamento o una copia interrotti. 4 missing
zero-head Sovrascrive con zeri i primi byte del file, lasciandone intatta la lunghezza. La maggior parte dei lettori guarda prima lì, quindi quasi tutto si accorge di questo danno. 8 bytes

zero-head scrive zeri sull'inizio del file. La maggior parte dei lettori guarda prima lì, la firma e l'intestazione che dicono cos'è il file, quindi quasi ogni lettore se ne accorge. Il testo semplice e i log non hanno firma e vengono rifiutati lo stesso, perché una serie di byte nulli non è testo. Sotto i quattro byte alcuni formati escono con un danno di cui nessun lettore si lamenta, ed è per questo che l'impostazione parte da quattro.

truncate taglia la fine del file, come la lascia un caricamento o una copia interrotti, e il file ha comunque la dimensione richiesta: viene generato più grande e solo il suo inizio arriva sul disco. missing dice quale parte del file intero manca, la metà se non indichi altro.

append-junk scrive byte casuali dopo la fine del file, 64 se non indichi altro, come arriva un file con qualcosa attaccato in fondo. Lo stesso comando aggiunge gli stessi byte.

Cosa dice il manifest

Un manifest che dice cosa deve succedere

Dove il danno viola le regole del formato, la voce dice che il tuo sistema deve rifiutarlo, con il danno registrato accanto:

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

Dove i lettori non concordano, la voce lo dice invece di tirare a indovinare. Un file di testo tagliato è ancora testo, e la maggior parte dei visualizzatori ignora i byte dopo la fine di un PNG, quindi la voce lascia la risposta al tuo sistema, offre entrambe e dice perché:

"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> elenca i formati in cui un danno lascia la risposta al tuo sistema, e perché.

Quattro richieste vengono rifiutate prima che venga scritto qualcosa, perché ciascuna lascerebbe su disco un file che il manifest descrive male:

In una ricetta

File sani e rotti in una sola esecuzione

Metti entrambi in una ricetta, e il manifest porta l'aspettativa di ogni file, così il test non ha bisogno di un elenco di quale sia quale:

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

In un test

Trasformarlo in un test

Il test legge il manifest e controlla che ciò che è successo sia ciò che era stato dichiarato. Non ha bisogno di un elenco di nomi di file:

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

Un file il cui esito è unspecified viene escluso qui, perché cosa il tuo sistema debba farne lo decide la tua politica. La sua voce dice perché, e policy_options elenca le risposte possibili.

Un buon rifiuto è un rifiuto pulito. Un messaggio che dice cosa non andava è la risposta che vuoi. Un errore del server, un blocco o un file salvato a metà è il difetto che questo test esiste per trovare.

Avanti

Dove andare da qui