Assert with Grace : assertions logicielles personnalisées utilisant AssertJ pour un code plus propre

Introduction

Si vous ne savez pas ce qu'est une assertion douce, veuillez lire Soft Asserts – Pourquoi devriez-vous les utiliser pour les tests unitaires et d'intégration ?

Cet article est une continuation de Assert with Grace : Custom Assertions for Cleaner Code qui vous montre comment créer des assertions personnalisées à l'aide d'AssertJ. Ici, vous apprendrez comment étendre son approche pour utiliser l'approche d'assertion douce en plus de l'assertion personnalisée.

Assertions logicielles personnalisées avec AssertJ

Vous pouvez avoir une assertion dure en utilisant la classe Assertions d'AssertJ ou une classe personnalisée. Pour bénéficier de tous les avantages de l'assertion douce, nous devons :

• implémenter une assertion personnalisée
• créez la classe d'assertion logicielle personnalisée et étendez les AbstractSoftAssertions à partir d'AssertJ

L'assertion personnalisée

Vous avez appris à créer une assertion personnalisée dans l'article Assert with Grace : Custom Assertions for Cleaner Code. Cela ressemble à ceci :

public class SimulationAssert extends AbstractAssert<SimulationAssert, Simulation> {
    protected SimulationAssert(Simulation actual) {
        super(actual, SimulationAssert.class);
    }
    public static SimulationAssert assertThat(Simulation actual) {
        return new SimulationAssert(actual);
    }
    public SimulationAssert hasValidInstallments() {
        isNotNull();
        if (actual.getInstallments() < 2 || actual.getInstallments() >= 48) {
            failWithMessage("Installments must be must be equal or greater than 2 and equal or less than 48");
        }
        return this;
    }
    public SimulationAssert hasValidAmount() {
        isNotNull();
        var minimum = new BigDecimal("1.000");
        var maximum = new BigDecimal("40.000");
        if (actual.getAmount().compareTo(minimum) < 0 || actual.getAmount().compareTo(maximum) > 0) {
            failWithMessage("Amount must be equal or greater than $ 1.000 or equal or less than than $ 40.000");
        }
        return this;
    }
}

L'utilisation de l'assertion personnalisée montre plus de lisibilité dans le test et lui renvoie la responsabilité de tester les valeurs valides :

class SimulationsCustomAssertionTest {
    @Test
    void simulationErrorAssertion() {
        var simulation = Simulation.builder().name("John").cpf("9582728395").email("john@gmail.com")
                .amount(new BigDecimal("1.500")).installments(5).insurance(false).build();
        SimulationAssert.assertThat(simulation).hasValidInstallments();
        SimulationAssert.assertThat(simulation).hasValidAmount();
    }
}

Une fois l'assertion personnalisée disponible, il est temps d'implémenter l'assertion logicielle personnalisée.

Créer l'assertion logicielle personnalisée

Il existe un processus simple pour créer l'assertion logicielle personnalisée où la condition préalable est d'implémenter une assertion personnalisée. Compte tenu de l'article précédent, nous avons la classe SimulationAssert comme assertion personnalisée et allons créer SimulationSoftAssert comme assertion logicielle personnalisée. Voici les étapes :

1. Étendre la classe AbstractSoftAssertions
2. Créez la méthode assertThat() avec :
   • la méthode renvoie un objet en tant que classe d'assertion personnalisée
   • un paramètre au sujet de l'assertion
   • la méthode renvoie le proxy de la méthode où les paramètres sont la classe d'assertion personnalisée et le sujet de l'assertion
3. Créez la méthode assertSoftly() avec :
   • un paramètre en tant que consommateur de la classe d'assertion logicielle personnalisée
   • Utilisez la méthode SoftAssertionsProvider.assertSoftly() car le paramètre est la classe d'assertion logicielle personnalisée et le paramètre de méthode

Les étapes semblent complexes, mais en pratique, vous vous retrouverez avec ceci :

public class SimulationSoftAssert extends AbstractSoftAssertions {
    public SimulationAssert assertThat(Simulation actual) {
        return proxy(SimulationAssert.class, Simulation.class, actual);
    }
    public static void assertSoftly(Consumer<SimulationSoftAssert> softly) {
        SoftAssertionsProvider.assertSoftly(SimulationSoftAssert.class, softly);
    }
}

Utilisation de l'assertion logicielle personnalisée

La classe AssertJ SoftAssertion est responsable des assertions logicielles. Voici l'exemple applicable au contexte Simulation :

La classe AssertJ SoftAssertion est responsable des assertions logicielles. Voici l'exemple applicable au contexte Simulation :

public class SimulationAssert extends AbstractAssert<SimulationAssert, Simulation> {
    protected SimulationAssert(Simulation actual) {
        super(actual, SimulationAssert.class);
    }
    public static SimulationAssert assertThat(Simulation actual) {
        return new SimulationAssert(actual);
    }
    public SimulationAssert hasValidInstallments() {
        isNotNull();
        if (actual.getInstallments() < 2 || actual.getInstallments() >= 48) {
            failWithMessage("Installments must be must be equal or greater than 2 and equal or less than 48");
        }
        return this;
    }
    public SimulationAssert hasValidAmount() {
        isNotNull();
        var minimum = new BigDecimal("1.000");
        var maximum = new BigDecimal("40.000");
        if (actual.getAmount().compareTo(minimum) < 0 || actual.getAmount().compareTo(maximum) > 0) {
            failWithMessage("Amount must be equal or greater than $ 1.000 or equal or less than than $ 40.000");
        }
        return this;
    }
}

Le « problème » avec son utilisation est que nous ne pourrons pas utiliser l’assertion personnalisée que nous avons créée. Dans l'exemple ci-dessus, vous pouvez voir les assertions dans les versements et le montant en utilisant isEqualTo() car la classe SoftAssertions n'a pas accès à l'assertion personnalisée.

Nous avons résolu ce problème en créant la classe d'assertions logicielles personnalisée. Ainsi, au lieu d'utiliser la classe SoftAssertions, nous utiliserons la classe personnalisée : SimulationSoftAssert.

class SimulationsCustomAssertionTest {
    @Test
    void simulationErrorAssertion() {
        var simulation = Simulation.builder().name("John").cpf("9582728395").email("john@gmail.com")
                .amount(new BigDecimal("1.500")).installments(5).insurance(false).build();
        SimulationAssert.assertThat(simulation).hasValidInstallments();
        SimulationAssert.assertThat(simulation).hasValidAmount();
    }
}

Le SimulationSoftAssert.assertSoftly() est un fournisseur d'assertion douce qui appellera toutes les méthodes internes pour pouvoir gérer les erreurs et autres activités lors des assertions. Le assertThat() utilisé, à l'intérieur du assertSoftly() sera celui personnalisé qui aura accès à l'assertion personnalisée par le proxy() entre l'assertion douce et le sujet de l'assertion.

En utilisant cette approche, nous avons les assertions personnalisées disponibles dans l'assertion logicielle grâce à la mise en œuvre d'une assertion personnalisée.

La fin

C'est tout, les amis !

Vous pouvez trouver un exemple entièrement implémenté et fonctionnel dans le projet credit-api, où vous pouvez voir ce qui suit :

• Classe SimulationAssert
• Test d'utilisation dans la classe SimulationsCustomAssertionTest

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!