Cosa fare con i miei test di unità durante il refactoring del codice in una nuova classe

5

Spero di poter fare una domanda chiara ... Ho semplificato il mio esempio di codice per questa domanda, spero che abbia ancora senso.

public class PersonComponent
{
    public bool IsQualified(Person person)
    {
        if (person.PropertyA){ return true; }
        if (person.PropertyB && !person.PropertyC) { return true; }
        if (VeryDifficultFunction(person.Certificates))
        {
            return true;
        }
        return false;
    }

    private bool VeryDifficultFunction(List<Certificate> certificates)
    {}
}

public class Person
{
    public bool PropertyA { get; set; }
    public bool PropertyB { get; set; }
    public bool PropertyC { get; set; }
    public List<Certificate> Certificates { get; set; }
}

public class Certificate
{ }

Ho un personcomponent che determina se un dato person è qualificato o meno.

Oltre ad alcune semplici convalide su proprietà A , B e C c'è un albero delle decisioni complicato nella lista di Certificates della Persona.

Ora quando implemento questa decisione complicata in PersonComponent creerei tutti i test unitari su PersonComponent (diciamo che il numero di test è 12). Quindi, decido che questa conoscenza (l'albero delle decisioni complicato) sia troppa conoscenza per personcomponent , quindi la refactoring in una nuova classe, personCertificatescomponent .

Diciamo che questa classe ora assomiglia a questa:

public class PersonCertificatesComponent
{
    public bool GetVeryDifficultFunctionResult(List<Certificate> certificates)
    {}
}

Ora, cosa devo fare con i miei (12) test unitari per questo specifico codice?

DEVI MOVIMERli per operare su personCertificatescomponent ?

Pro:

Sembra una buona idea perché il personCertificatescomponent viene quindi testato separatamente (cosa che ritengo sia buona se qualcuno vuole riutilizzare questo componente), E (che è un grande vantaggio imo) Non devo impostare l'unità verifica il personcomponent ogni volta con i giusti valori per PropertyA/B/C , quindi raggiunge la parte VeryDifficultFunction .

Ho separato i test unitari per le 2 classi in modo da rendere il mio codice più "chiaro" (In qualche modo mi piacciono 2 classi con 8 test unitari meglio di 1 classe con 16 test unitari, ma forse è qualcosa che dovrei disimparare)

CONS:

Ma ora non ho più i test su personcomponent . Un'idea che è venuta fuori è stata testare l'unità se è stato utilizzato personCertificatescomponent (test di simulazione), ma poi sono legato al mio test unitario all'implementazione di personcomponent

O li COPIA, quindi personCertificatescomponent AND personcomponent sono entrambi testati unitamente? (che sembra bello, ma copiare i test non sembra SECCO)

O lascio i test dove sono? (pro e contro inverso di spostare i test di unità).

Non posso sopportare di non avere una buona risposta per me stesso .....

    
posta Michel 31.08.2015 - 10:41
fonte

2 risposte

7

Quando rifattori una classe senza cambiare la sua API, vuoi che i tuoi test unitari assicurino di non rompere nulla durante il refactoring. Quindi, ovviamente, non vuoi cambiare i tuoi test unitari esistenti su PersonComponent prima che il refactoring sia completato.

La domanda interessante è: è una buona idea cambiare i test in seguito , per rendere possibile testare PersonCertificatesComponent in isolamento? IMHO questo dipende dalle seguenti domande:

  • quanto è buono il tuo codice & copertura delle filiali per PersonCertificatesComponent con i test esistenti attraverso PersonComponent ? Se va bene, non fare nulla. In caso contrario, si consiglia di aggiungere successivamente ulteriori test per questa classe, ma non rimuovere i test esistenti.

  • i test delle unità esistenti non sono sufficientemente veloci o sono eccessivamente complicati e potrebbero essere migliorati eseguendo il refactoring per test più semplici e più veloci per PersonCertificatesComponent ? Se la risposta è sì, prendere in considerazione il refactoring dei test, altrimenti non fare nulla.

Quando decidi di rifattorizzare alcuni dei tuoi test a causa del secondo criterio, dovresti davvero evitare di ripetere te stesso e non creare codice con la stessa logica due volte - questo porterebbe direttamente a problemi di manutenzione. Quindi, verifica il codice & la copertura di ramo di PersonComponent non diminuirà quando si spostano i test da lì a PersonCertificatesComponent , oppure, se si intende utilizzare un test esistente come "modello" per uno nuovo, assicurarsi di riutilizzare lo stesso codice in un " duplicato "test.

    
risposta data 31.08.2015 - 11:18
fonte
-1

In modo TDD, ti rifatti i tuoi test insieme al tuo codice. Per prima cosa dovresti cambiare il test, quindi il tuo codice. Ma cerca di assicurarti di avere solo 1 o pochi test falliti alla volta. Per realizzare, potresti finire in uno stato intermedio, che non uscirà nel codice finale.

    
risposta data 31.08.2015 - 12:00
fonte

Leggi altre domande sui tag