Per come la vedo io, entrambi avete il vantaggio e siete in "svantaggio" (sic).
Il vantaggio è che hai un sistema con cui ti senti a tuo agio e che funziona per te. Sei contento che confermi la validità del tuo prodotto e probabilmente non troverai alcun valore commerciale nel tentativo di modificare tutti i test per qualcosa che utilizza un framework diverso. Se riesci a riformattare il tuo codice e i tuoi test raccolgono le modifiche - o meglio ancora, se puoi modificare i tuoi test e il tuo codice esistente fallisce i test fino a quando non viene refactored, allora hai coperto tutte le tue basi. Tuttavia...
Uno dei vantaggi di avere un'API di unit test ben progettata è che c'è molto supporto nativo nella maggior parte degli IDE moderni. Ciò non influirà sul VI hard-core ed emacs degli utenti là fuori che ghignano agli utenti di Visual Studio là fuori, ma per quelli che usano un buon IDE, hai la possibilità di eseguire il debug dei test ed eseguirli all'interno l'IDE stesso. Questo è buono, tuttavia c'è un vantaggio ancora maggiore a seconda del framework che usi e che è nella lingua usata per testare il tuo codice.
Quando dico linguaggio , non sto parlando di un linguaggio di programmazione, ma piuttosto di un ricco insieme di parole racchiuse in una sintassi fluente che fa leggere il codice di prova come una storia. In particolare, sono diventato un sostenitore dell'uso dei framework BDD . La mia API DotD BDD preferita personale è StoryQ, ma ce ne sono molti altri con lo stesso scopo di base, ovvero estrarre un concetto da un documento dei requisiti e scriverlo in codice in modo simile a come è scritto nelle specifiche. Le API davvero buone vanno comunque oltre, intercettando ogni singola istruzione all'interno di un test e indicando se tale istruzione è stata eseguita correttamente o non è riuscita. Questo è incredibilmente utile, poiché puoi vedere l'intero test eseguito senza tornare presto, il che significa che i tuoi sforzi di debug diventano incredibilmente efficienti in quanto devi solo focalizzare la tua attenzione sulle parti del test fallite, senza bisogno di decodificare l'intera chiamata sequenza. L'altra cosa interessante è che l'output del test mostra tutte queste informazioni,
Come esempio di ciò di cui sto parlando, confronta quanto segue:
Utilizzando gli asserti:
Assert(variable_A == expected_value_1); // if this fails...
Assert(variable_B == expected_value_2); // ...this will not execute
Assert(variable_C == expected_value_3); // ...and nor will this!
Utilizzando un'API BDD fluente:
(Immagina che i bit in corsivo siano fondamentalmente puntatori a metodi)
WithScenario("Test Scenario")
.Given(*AConfiguration*) // each method
.When(*MyMethodToTestIsCalledWith*, variable_A, variable_B, variable_C) // in the
.Then(*ExpectVariableAEquals*, expected_value_1) // Scenario will
.And(*ExpectVariableBEquals*, expected_value_2) // indicate if it has
.And(*ExpectVariableCEquals*, expected_value_3) // passed or failed execution.
.Execute();
Ora concesso che la sintassi BDD sia più lunga e più complessa, e questi esempi sono terribilmente inventati, tuttavia per situazioni di test molto complesse in cui molte cose stanno cambiando in un sistema a causa di un determinato comportamento del sistema, la sintassi BDD ti offre un chiaro descrizione di ciò che si sta testando e di come è stata definita la configurazione del test e si può mostrare questo codice a un non programmatore e capiranno immediatamente cosa sta succedendo. Inoltre, se "variabile_A" non supera il test in entrambi i casi, l'esempio Asserti non verrebbe eseguito oltre la prima asserzione fino a quando non si fosse risolto il problema, mentre l'API BDD avrebbe eseguito a sua volta tutti i metodi chiamati nella catena, indicando quale le singole parti della dichiarazione erano in errore.
Personalmente trovo che questo approccio funzioni molto meglio dei più tradizionali framework xUnit, nel senso che la lingua dei test è la stessa lingua che i tuoi clienti parleranno dei loro requisiti logici. Anche così, sono riuscito a utilizzare i framework xUnit in uno stile simile senza dover inventare un'API di test completa per supportare i miei sforzi e, sebbene le affermazioni continueranno effettivamente a cortocircuitare da sole, leggono in modo più chiaro. Per esempio:
Utilizzando Nunit :
[Test]
void TestMyMethod()
{
const int theExpectedValue = someValue;
GivenASetupToTestMyMethod();
var theActualValue = WhenIExecuteMyMethodToTest();
Assert.That(theActualValue, Is.EqualTo(theExpectedValue)); // nice, but it's not BDD
}
Se decidi di esplorare utilizzando un'API di unit test, il mio consiglio è di sperimentare un numero elevato di API diverse per un po 'di tempo e di tenere e aprire la mente sul tuo approccio. Mentre sostengo personalmente BDD, le tue esigenze aziendali potrebbero richiedere qualcosa di diverso per le circostanze del tuo team. La chiave tuttavia è evitare di indovinare il sistema esistente. Puoi sempre supportare i tuoi test esistenti con alcuni test usando un'altra API, se necessario, ma sicuramente non consiglierei un enorme test di riscrittura solo per rendere tutto uguale. Poiché il codice legacy non è più in uso, è possibile sostituirlo facilmente e i relativi test con un nuovo codice e i test utilizzando un'API alternativa, senza che sia necessario investire in uno sforzo maggiore che non fornirà necessariamente alcun valore reale per l'azienda. Per quanto riguarda l'utilizzo di un'API di unit test,