come effettuare l'unittest con una copertura completa del test [duplicato]

1

Sto cercando di entrare nel test delle unità con Python (anche se la mia domanda non è specifico per python). Voglio aggiungere un test per la funzione che ho già - so che dovrei farlo viceversa, ma eccomi qui, in cerca di test unitari codice esistente.

Ecco la mia funzione:

def my_function(value):
    """
    value: tuple or string
    """
    is_tuple = False
    my_value = value
    if isinstance(value, tuple):
        my_value = value[0]
        is_tuple = True
    return(is_tuple, my_value)

Ecco il mio test

import unittest
class TestMyFunction(unittest.TestCase):
    def test_my_function(self):
        sv_tupel = my_function(('foo','bar'))
        sv_tupel_res = (True, 'foo')
        sv_single = my_function('foo bar')
        sv_single_res = (False, 'foo bar')
        self.assertEqual(sv_tupel, sv_tupel_res)
        self.assertEqual(sv_single, sv_single_res)

Ora ho testato due casi di input, ma ci sono, naturalmente molto più. Potrei forse anche testare se la funzione fallisce se l'input non è quello che dovrebbe essere.

Quindi la mia domanda è, qual è la pratica generale / buona pratica per ottenere una copertura completa del test. In questo esempio il input e output sono piuttosto semplici e quindi il risultato è un test l'unità potrebbe essere più complessa. Quindi mi chiedo come scrivere un test ottiene tutti i possibili casi d'angolo e introduce varianti senza elencarli manualmente in modo esplicito. O è proprio così deve essere? Le persone in generale scelgono solo alcuni casi d'angolo, e aggiungere altro se risulta che il test non è stato abbastanza approfondito?

Inoltre, per i due casi che ho provato, dovrei scrivere due test o è giusto uno poiché verifica una funzione?

Modifica Ho trovato una risposta parziale alla mia domanda, che aiuta a costruire test di portata più ampia. Per esempio. potresti non aver bisogno di trovare tutti i casi d'angolo, ma la suite lo farà per te: link (Grazie a Raymond Hettinger per averlo twittato)

    
posta Isaac 22.02.2015 - 20:29
fonte

1 risposta

2

Non esiste una formula magica per testare a fondo il tuo codice. Immagino anche per una funzione banale, come stringReverse() puoi inventare una miriade di casi limite, molto tempo per pensare / scrivere test:

  • Cosa succede se la stringa è nullo?
  • Cosa succede se la stringa è vuota?
  • Cosa succede se la stringa è enorme e occupa una gran parte della memoria disponibile?
  • Cosa succede se la lunghezza della stringa è maggiore di Max Integer? Ciò causa problemi su alcuni sistemi.
  • Cosa succede se la stringa ha caratteri non ASCII, o addirittura il carattere null nel mezzo?
  • Conserva il caso? ecc.

La difficoltà di completamente testare ogni possibile parte della tua applicazione aumenta notevolmente quando consideri i test di integrazione.

È un po 'un'arte trovare l'equilibrio tra paranoia e apatia qui. Se vuoi testare l'inferno vivente con il tuo codice, questo è davvero buono e lodevole. Tuttavia, anche se ti ho detto una formula sicura per il "giusto" grado di copertura del codice, sono disposto a scommettere che la mancanza di tempo o la difficoltà di test ti farebbero deviare un po '(lo fanno tutti).

Tutto ciò detto, ci sono delle linee guida che si potrebbero seguire. Molto è stato scritto facendo proselitismo su come il tuo codice dovrebbe essere testato. Un buon inizio potrebbe essere questo link: Introduzione a Test Driven Development (TDD)

    
risposta data 22.02.2015 - 23:50
fonte

Leggi altre domande sui tag