È bello o sbagliato duplicare i dati tra test e codice reale? Ad esempio, supponiamo di avere una classe Python FooSaver che salva i file con nomi particolari in una determinata directory:
class FooSaver(object):
def __init__(self, out_dir):
self.out_dir = out_dir
def _save_foo_named(self, type_, name):
to_save = None
if type_ == FOOTYPE_A:
to_save = make_footype_a()
elif type == FOOTYPE_B:
to_save = make_footype_b()
# etc, repeated
with open(self.out_dir + name, "w") as f:
f.write(str(to_save))
def save_type_a(self):
self._save_foo_named(a, "a.foo_file")
def save_type_b(self):
self._save_foo_named(b, "b.foo_file")
Ora nel mio test mi piacerebbe assicurarmi che tutti questi file siano stati creati, quindi voglio dire qualcosa del tipo:
foo = FooSaver("/tmp/special_name")
foo.save_type_a()
foo.save_type_b()
self.assertTrue(os.path.isfile("/tmp/special_name/a.foo_file"))
self.assertTrue(os.path.isfile("/tmp/special_name/b.foo_file"))
Anche se questo duplica i nomi di file in due punti, penso che sia buono: mi costringe a scrivere esattamente quello che mi aspetto di uscire dall'altra parte, aggiunge uno strato di protezione contro gli errori di battitura e in genere mi fa sentire sicuro che le cose stanno funzionando esattamente come mi aspetto. So che se cambiò a.foo_file in type_a.foo_file in futuro dovrò fare delle ricerche e sostituirmi nei miei test, ma non penso che sia un grosso problema. Preferirei avere dei falsi positivi se dimentico di aggiornare il test per assicurarmi che la mia comprensione del codice e dei test sia sincronizzata.
Un collaboratore ritiene che questa duplicazione sia cattiva e mi ha raccomandato di rifattorizzare entrambe le parti per qualcosa di simile:
class FooSaver(object):
A_FILENAME = "a.foo_file"
B_FILENAME = "b.foo_file"
# as before...
def save_type_a(self):
self._save_foo_named(a, self.A_FILENAME)
def save_type_b(self):
self._save_foo_named(b, self.B_FILENAME)
e nel test:
self.assertTrue(os.path.isfile("/tmp/special_name/" + FooSaver.A_FILENAME))
self.assertTrue(os.path.isfile("/tmp/special_name/" + FooSaver.B_FILENAME))
Non mi piace perché non mi rende sicuro che il codice stia facendo quello che mi aspettavo --- ho appena duplicato il passo out_dir + name sia dal lato della produzione che dal lato del test. Non scoprirò un errore nella mia comprensione di come + funzioni sulle stringhe e non accetterà errori di battitura.
D'altra parte, è chiaramente meno fragile che scrivere quelle stringhe due volte, e mi sembra un po 'sbagliato duplicare i dati su due file del genere.
C'è un chiaro precedente qui? Va bene duplicare le costanti tra test e codice di produzione, oppure è troppo fragile?