Comment affirmer un message de journal dans JUnit ?

Comment affirmer un message de journal dans JUnit

Introduction :

Test du comportement du code qui communique avec des systèmes implique souvent de vérifier le contenu et le format des messages générés. En Java, la journalisation est un moyen courant d'enregistrer de tels messages. Cet article explique comment effectuer des tests unitaires sur les entrées de journal à l'aide du framework JUnit.

Assertions JUnit sur les messages de journal :

L'extrait de code fourni dans la question vise à affirmer qu'une certaine entrée de journal avec un niveau spécifique (par exemple, INFO) et un message ("x s'est produit") a été générée par le code testé. Pour y parvenir, vous pouvez utiliser un enregistreur ou un gestionnaire personnalisé qui intercepte et stocke les événements du journal.

Approche de l'enregistreur/gestionnaire personnalisé :

Cette approche nécessite la création d'un enregistreur spécialisé. ou un gestionnaire qui capture les événements de journalisation. Les instructions de journal dans le code testé sont ensuite dirigées vers cet enregistreur personnalisé, permettant la récupération et l'inspection des messages enregistrés. Cependant, cette approche peut être complexe à mettre en œuvre et nécessite de modifier le code testé.

Modèle de collecteur de journaux :

Une solution plus pratique consiste à utiliser un appender personnalisé qui enregistre les événements de journalisation dans une collection ou une liste. Voici comment y parvenir :

1. Créez un Appender :
   Implémentez une sous-classe Appender personnalisée, en remplaçant la méthode append() pour stocker les événements de journalisation dans une structure de données ( par exemple, une liste).
2. Ajouter un appender à l'enregistreur :
   Ajoutez une instance de votre appender personnalisé à l'enregistreur souhaité. Cette étape peut être effectuée dans le cadre de la méthode de test ou à l'aide d'annotations telles que @Before et @After.
3. Assertion du message de journalisation :
   Après avoir exécuté le code testé, récupérez la liste des événements de votre appender. Vous pouvez ensuite utiliser les méthodes d'assertion de JUnit pour vérifier le niveau, le message et d'autres attributs de l'entrée de journal, comme démontré dans l'extrait de code fourni.

Exemple d'implémentation :

L'exemple de code suivant illustre le modèle de collecteur de journaux :

<code class="java">import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

import static org.junit.Assert.assertThat;
import static org.hamcrest.CoreMatchers.is;

public class LogCollectorTest {

    @Test
    public void testLogMessage() {
        // Create a custom appender to collect logging events.
        final TestAppender appender = new TestAppender();

        // Add the appender to the logger we wish to test.
        final Logger logger = Logger.getLogger(LogCollectorTest.class);
        logger.addAppender(appender);

        // Execute code under test.
        logger.info("Test");

        // Retrieve the list of logged events.
        final List<LoggingEvent> logs = appender.getLog();

        // Perform assertions on the first log entry.
        assertThat(logs.get(0).getLevel(), is(Level.INFO));
        assertThat(logs.get(0).getMessage(), is("Test"));
    }

    private static class TestAppender extends AppenderSkeleton {
        private final List<LoggingEvent> log = new ArrayList<>();

        @Override
        public boolean requiresLayout() {
            return false;
        }

        @Override
        protected void append(LoggingEvent loggingEvent) {
            log.add(loggingEvent);
        }

        @Override
        public void close() { }

        public List<LoggingEvent> getLog() {
            return new ArrayList<>(log);
        }
    }
}</code>

Conclusion :

Le modèle de collecteur de journaux fournit un moyen réutilisable et pratique d'affirmer sur enregistrer les messages dans les tests JUnit. En capturant les événements enregistrés dans une structure de données, vous pouvez facilement vérifier leur contenu et leur format, garantissant ainsi l'exactitude de l'interaction de votre code avec les systèmes de journalisation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!