Nel mio attuale progetto, mi viene difficile trovare una buona soluzione per creare test di integrazione scalabili senza effetti collaterali. Un piccolo chiarimento sulla proprietà free dell'effetto collaterale: riguarda principalmente il database; non ci dovrebbero essere cambiamenti nel database dopo che i test sono stati completati (lo stato dovrebbe essere preservato). Forse la scalabilità e la conservazione dello stato non si incontrano, ma voglio davvero spingere per una soluzione migliore.
Ecco un tipico test di integrazione (questi test toccano il livello del database):
public class OrderTests {
List<Order> ordersToDelete = new ArrayList<Order>();
public testOrderCreation() {
Order order = new Order();
assertTrue(order.save());
orderToDelete.add(order);
}
public testOrderComparison() {
Order order = new Order();
Order order2 = new Order();
assertFalse(order.isEqual(order2);
orderToDelete.add(order);
orderToDelete.add(order2);
}
// More tests
public teardown() {
for(Order order : ordersToDelete)
order.delete();
}
}
Come si può immaginare, questo approccio produce test estremamente lenti. Inoltre, se applicato a tutti i test di integrazione, sono necessari circa 5 secondi per testare solo una piccola parte del sistema. Posso immaginare che questo numero salga quando la copertura è aumentata.
Quale sarebbe un altro approccio per scrivere tali test? Un'alternativa che posso pensare è avere una specie di variabili globali (all'interno di una classe) e tutti i metodi di test condividono questa variabile. Di conseguenza, vengono creati solo pochi ordini e amp; soppressa; risultante in test più rapidi. Tuttavia, penso che questo introduce un problema più grande; i test non sono più isolati e diventa sempre più difficile da capire & analizzarli.
Potrebbe essere semplicemente che i test di integrazione non sono pensati per essere eseguiti tutte le volte che si effettuano i test unitari; quindi basse prestazioni potrebbero essere accettabili per quelli. In ogni caso, sarebbe bello sapere se qualcuno ha trovato alternative per migliorare la scalabilità.