Guadagni:
- Capacità di produrre test unitari, di integrazione e di casi limite con asserzioni significative con l'intelligenza artificiale
- Capacità di estrarre sistematicamente la copertura dei test, i valori limite e gli scenari negativi con il supporto dell'intelligenza artificiale
- Capacità di verificare che i test prodotti dall'IA verifichino effettivamente il comportamento e non si limitino a ripetere il codice esistente
Il test è il meccanismo che dimostra che il software si comporta effettivamente come promesso. Una buona suite di test ti dice in pochi secondi se una modifica rompe qualcosa e dà all'ingegnere la libertà di agire con sicurezza. L’intelligenza artificiale accelera la parte più noiosa e saltata della scrittura del test: generare una moltitudine di scenari, punti di interruzione e casi negativi. Ma qui c'è una trappola subdola: l'intelligenza artificiale può scrivere test che verificano il comportamento attuale (forse difettoso) del codice, non il suo presunto comportamento; oppure può produrre test vuoti che passano sempre, senza verificare nulla. Il valore di un test non sta nel fatto che venga superato, ma nel fatto che controlli la cosa giusta e diventi rosso quando è sbagliata.
In questa unità imparerai come produrre test unitari, di integrazione e di casi limite con asserzioni significative; come estrarre sistematicamente la copertura dei test, i punti di interruzione e gli scenari negativi; e vedremo come verificare che i test che l'IA produce effettivamente validino il comportamento.
Concetti: Test unitario: verifica una singola funzione/classe isolatamente. Test di integrazione: verifica che più parti funzionino correttamente insieme. Assert: un'istruzione che verifica che un risultato sia uguale a quanto previsto; Questo è il cuore della prova. Copertura: quanta parte del codice viene eseguita da test; Una copertura elevata non garantisce la qualità.
Produzione di test significativi
Un buon test fa chiaramente tre cose: stabilisce uno stato, esegue un’azione, asserisce il risultato. Quando stampi i test sull'IA, specifica quale comportamento vuoi verificare e quali scenari dovrebbe coprire; Altrimenti produce test superficiali che passano sempre.
- Definire il comportamento da testare. "Cosa conta come giusto?" Rispondi chiaramente alla domanda.
- Richiedi tipi di scenari. Condizione normale, limite, negativa, di errore.
- Importa asserzioni significative. Non si è limitato a "generare un errore", ma "ha restituito il valore corretto".
- Controllare l'accuratezza del test. Il test diventa rosso quando infrangi consapevolmente il codice?
Richiesta di generazione di test completa: "Scrivi unit test per la seguente funzione 'applydiscount (importo, coupon)'. Avere ALMENO uno scenario nelle seguenti categorie: (1) coupon valido normale, (2) punti di interruzione (importo 0, sconto 100%), (3) negativo (coupon non valido, importo negativo), (4) caso di errore (coupon nullo). Dichiara il valore atteso CONCRETO in ciascun test (non solo 'lavorato'). Assegna un nome ai test leggibili. Codice: [codice]"
Richiesta di estrazione del valore limite: "Esegui un'analisi del valore limite per gli input di questa funzione. Per ciascun parametro, estrai i valori 'appena al limite', 'appena sotto il limite', 'appena sopra il limite' come una tabella. Quindi elenca gli scenari di test che coprono questi limiti. Non scrivere ancora il codice, solo l'elenco di analisi e scenari. Funzione: [firma]"
Attenzione: un'elevata copertura del test (ad esempio 90%) non dimostra che il codice sia corretto. La copertura misura quante righe sono state eseguite; non che quelle righe producano il risultato corretto. Un test senza affermazioni significative aumenta la copertura ma non garantisce nulla. Il contenuto dell'asserzione determina la qualità, non il numero delle asserzioni.
Testare il test stesso: la logica della mutazione
Il modo più pratico per capire se il test generato dall’intelligenza artificiale funziona effettivamente è violare deliberatamente il codice (logica del test di mutazione). Invertire una condizione, creare un segno + -; Se nessun test diventa rosso, i tuoi test non mantengono effettivamente quel comportamento.
Richiesta di ricerca della vulnerabilità del test: "Dimmi quali potenziali bug in questo codice i seguenti test NON POTREBBERO rilevare. Suggerisci 5 piccole mutazioni che potrebbero essere apportate al codice (ad esempio >= invece di >, - invece di +) e indica per ciascuna se i test esistenti potrebbero rilevarla. Per quelli non rilevati, suggerisci i test che dovrebbero essere aggiunti. Codice: [codice] Test: [test]"
Prompt debole / Prompt forte
DEBOLE: "Scrivi un test su questa funzione." (Risultato: di solito uno scenario felice, asserzione debole; errori mancati.) FORTE: "Scrivi un test a questa funzione 'passwordStrong'. Regola: almeno 8 caratteri, 1 lettera maiuscola, 1 cifra richiesta. Copri i seguenti scenari come test SEPARATI: esattamente 8 caratteri (limite), 7 caratteri (sotto il limite), nessuna lettera maiuscola, nessuna cifra, stringa vuota, solo spazi, troppo lungo (1000 caratteri) Affermare esplicitamente il vero/falso previsto valore in ciascun test e denominare il test in base a ciò che controlla."
Il potente prompt fornisce regole e scenari di confine completi. Le coppie di limiti come "esattamente 8/7 caratteri" sono i luoghi più comuni in cui si commettono errori (confondendo > con >=). Un prompt debole oltrepassa questi limiti e trasmette l'errore alla produzione.
Tipi di test e dove utilizzarli
Tipo di prova
Cosa conferma?
Contributo dell'IA
Attenzione
unità
Singola funzione/classe
Genera multi-scenari velocemente
È richiesta un'asserzione significativa
integrazione
Parti che lavorano insieme
Scenario e bozza di dati simulati
Vero comportamento di dipendenza
terminare/accettare
Intero flusso di utenti
Elenco dei passaggi e aspettative
incline alla fragilità
regressione
Vecchio errore che non ritorna
Test specifici per guasti
Dovrebbe essere aggiunto a ogni correzione
Mini custodie
Caso 1 – Il test che passa sempre. L'intelligenza artificiale scrive 12 test su una funzione e li superano tutti. L'ingegnere si insospettisce e distorce deliberatamente il valore di ritorno della funzione; Solo 3 test diventano rossi. Gli altri 9 test non contengono affermazioni significative. I test sono rafforzati dalla caccia alle mutazioni; la protezione reale si ottiene in 9 scenari.
Caso 2 — Errore al contorno. Una funzione di verifica dell'età dovrebbe dire "18 anni e più è valido" ma viene scritto >18, il che significa che 18 anni sono rifiutati. L'errore si manifesta immediatamente nei test perché l'IA genera lo scenario "esattamente 18" attraverso l'analisi dei breakpoint. Un singolo test di limite previene qualsiasi reclamo reale da parte degli utenti.
Caso 3: correzione del comportamento attuale. Quando all'IA viene detto di "scrivere un test basato su questo codice", produce un test che accetta come "corretto" un errore di arrotondamento già esistente nel codice. Quando l'ingegnere stampa il test in base al requisito (valore corretto previsto) e non al codice, il test diventa rosso e si verifica l'errore reale. I test dovrebbero derivare dalle aspettative, non dal codice.
Errori comuni
- Affermazione inutile. "Non ha generato un errore" non è sufficiente; È necessario verificare il valore corretto.
- Confondere l'ambito con la qualità. Una copertura elevata non è garanzia di risultati accurati.
- Stampa del test per codice. Corregge l'errore corrente su "true"; I test dovrebbero derivare dalle aspettative.
- Saltare i valori limite. Confondere > con >= è l'errore più comune; le coppie di confini devono essere testate.
- Non controllare il test stesso. Un test che non diventa rosso quando si viola il codice non fornisce protezione.
In sintesi
Una buona suite di test è la chiave per apportare modifiche con sicurezza. L’intelligenza artificiale genera rapidamente una moltitudine di scenari, limiti e situazioni negative; Ma se deriva i test dal codice anziché dai requisiti, può correggere i bug esistenti o scrivere test privi di significato che vengono sempre superati. Dichiara il valore atteso concreto in ogni test, includi coppie legate e verifica che i tuoi test effettivamente proteggano infrangendo deliberatamente il codice. Il contenuto dell'asserzione, non il numero di ambiti, determina la qualità.
Compito dell'applicazione
Seleziona una funzione e genera test in quattro categorie (normale, limite, negativo, errore) con una richiesta completa di generazione del test; Fai affermare il valore atteso concreto in ogni test. Quindi esegui il prompt di ricerca della vulnerabilità del test, suggerisci 5 piccole mutazioni nel codice ed esegui i test per verificare quali rilevano. Aggiungi un nuovo test per almeno una mutazione che non è stata rilevata e mostra che ora è in rosso.
lista di controllo
- [ ] Ho stampato i test in base al comportamento previsto/corretto, non al codice.
- [ ] Ho coperto scenari normali, limite, negativi ed errori.
- [ ] Ho affermato il valore atteso concreto in ciascun test.
- [ ] Ho testato le coppie di bordi (appena sopra-sotto / appena sopra-sotto).
- [] Decrittando deliberatamente il codice, ho confermato che i test erano diventati rossi.
- [ ] Ho aggiunto un nuovo test per le mutazioni non rilevate.