Cosa succede con i test dei metodi quando quel metodo diventa privato dopo la riprogettazione in TDD?

Diciamo che inizio a sviluppare un gioco di ruolo con personaggi che attaccano altri personaggi e quel genere di cose.

Applicando TDD, realizzo alcuni casi di test per testare la logica all'interno del Character.receiveAttack(Int)metodo. Qualcosa come questo:

@Test
fun healthIsReducedWhenCharacterIsAttacked() {
    val c = Character(100) //arg is the health
    c.receiveAttack(50) //arg is the suffered attack damage
    assertThat(c.health, is(50));
}

Supponiamo di avere 10 metodi di prova receiveAttack. Ora aggiungo un metodo Character.attack(Character)(che chiama receiveAttackmetodo) e dopo alcuni cicli TDD che lo testano, prendo una decisione: Character.receiveAttack(Int)dovrebbe essere private.

Cosa succede con i precedenti 10 casi di test? Devo eliminarli? Devo mantenere il metodo public(non credo)?

Questa domanda non riguarda come testare metodi privati ​​ma come gestirli dopo una riprogettazione quando si applica TDD

In TDD, i test servono come documentazione eseguibile del progetto. Il tuo design è cambiato, quindi ovviamente anche la tua documentazione!

Si noti che, in TDD, l'unico modo in cui il attackmetodo avrebbe potuto apparire è il risultato del superamento di un test fallito. Il che significa che attackviene testato da qualche altro test. Ciò significa che indirettamente receiveAttack è coperto dai attacktest di. Idealmente, qualsiasi modifica a receiveAttackdovrebbe interrompere almeno uno dei attacktest.

E se non lo fa, allora c'è funzionalità receiveAttackche non è più necessaria e non dovrebbe più esistere!

Quindi, poiché receiveAttackè già stato testato attack, non importa se si mantengono o meno i test. Se il framework di test semplifica il test di metodi privati ​​e se si decide di testare metodi privati, è possibile mantenerli. Ma puoi anche eliminarli senza perdere la copertura e la sicurezza del test.

Se il metodo è abbastanza complesso da richiedere test, dovrebbe essere pubblico in alcune classi. Quindi fai il refactoring da:

public class X {
  private int complexity(...) {
    ...
  }
  public void somethingElse() {
    int c = complexity(...);
  }
}

a:

public class Complexity {
  public int calculate(...) {
    ...
  }
}

public class X {
  private Complexity complexity;
  public X(Complexity complexity) { // dependency injection happiness
    this.complexity = complexity;
  }

  public void something() {
    int c = complexity.calculate(...);
  }
}

Sposta il test corrente per X.complexity su ComplexityTest. Quindi scrivi X.qualcosa deridendo la complessità.

Nella mia esperienza, il refactoring verso classi più piccole e metodi più brevi offre enormi vantaggi. Sono più facili da capire, più facili da testare e finiscono per essere riutilizzati più di quanto ci si potrebbe aspettare.

Supponiamo che io abbia 10 metodi per testare il metodo receiveAttack. Ora aggiungo un metodo Character.attack (Character) (che chiama il metodo receiveAttack) e dopo alcuni cicli TDD che lo verificano, prendo una decisione: Character.receiveAttack (Int) dovrebbe essere privato.

Qualcosa da tenere a mente qui è che la decisione che stai prendendo è quella di rimuovere un metodo dall'API . Le cortesie di retrocompatibilità suggerirebbero

1. Se non è necessario rimuoverlo, lasciarlo nell'API
2. Se non è necessario rimuoverlo ancora , poi segnarlo come deprecato e, se possibile, documento quando alla fine della vita accadrà
3. Se è necessario rimuoverlo, è necessario apportare una modifica sostanziale alla versione

I test vengono rimossi / o sostituiti quando l'API non supporta più il metodo. A quel punto, il metodo privato è un dettaglio di implementazione che dovresti essere in grado di rifattorizzare.

A quel punto, sei tornato alla domanda standard se la tua suite di test dovrebbe accedere direttamente alle implementazioni, piuttosto interagendo semplicemente attraverso l'API pubblica. Un metodo privato è qualcosa che dovremmo essere in grado di sostituire senza che la suite di test si frapponga . Quindi mi aspetto che la coppia di test scompaia, sia che si ritiri, sia che si sposti con l'implementazione in un componente testabile separatamente.