Test de l'unité d'injection de dépendance Java

Votre titre fait clairement le problème: vous n'injectant pas la dépendance sur eMaNervice code>. Pour ce faire, ajoutez un setter ou (mieux) le rendre final code> et l'ajouter au constructeur.

qui ressemblerait à: p>

private MyApplication app;
private EmailService email;

@BeforeEach
void setup() {
    email = mock(EmailService.class);
    when(email.sendEmail(any(), any())).thenReturn(true);
    app = new MyApplication(email);
}

@Test
void testProcessZeroLengthMessageOrPerson() {
    assertFalse(app.processMessages("", "Person"));
    assertFalse(app.processMessages("Message", "")):
    assertFalse(app.processMessages("", "")):
}

@Test
void testProcessMessage() {
    assertTrue(app.processMessage("Message", "Person"));
    verify(email).sendEmail("Message", "Person");
}

J'ai effectué des tests pour le service de messagerie à l'aide du courrier vert xxx

GITUB

La solution évidente serait de utiliser à la place une injection de dépendance. Vous connaissez déjà le terme, alors je suppose que vous êtes assez ingénieux pour trouver les informations nécessaires pour appliquer une injection de dépendance à la classe à portée de main (il y a des informations sur Internet - Wikipedia, YouTube, ce site et beaucoup plus ..).

Toutefois, étant donné un scénario dans lequel vous souhaitez tester cette classe et ne sont pas disposés ou incapables de changer de code source et de corriger la violation, alors si e-mailservice et eMaNervice # Sendemail ne sont pas finaux, vous pouvez utiliser la réflexion: xxx

S'ils sont finaux, nous pouvons faire un nouveau chargeur de classe qui sera remplacé emailervice avec notre propre classe (peut-être un jour, je vais éditerai cette réponse et fournir un exemple de ceci).

Bien que ces techniques permettent de tester des cours d'incrimination, ils font des tests qui sont difficiles à comprendre et à entretenir. Je réfléchirais à deux fois avant d'ajouter un test comme l'un des éléments ci-dessus dans ma suite de tests et envisagerons la possibilité de refactoriser ou de remplacer la classe sous test bien avant cela.