Mockito se moque de la classe finale locale mais échoue à Jenkins

J'ai écrit quelques tests unitaires pour une méthode statique. La méthode statique ne prend qu'un seul argument. Le type de l'argument est une classe finale. En termes de code:

public class Utility {

   public static Optional<String> getName(Customer customer) {
       // method's body.
   }
}

public final class Customer {
   // class definition
}

Donc , pour la Utilityclasse que j'ai créé une classe de test UtilityTestsdans lequel j'ai des tests écrits pour cette méthode, getName. Le framework de tests unitaires est TestNG et la bibliothèque de simulation utilisée est Mockito. Un test typique a donc la structure suivante:

public class UtilityTests {

   @Test
   public void getNameTest() {
     // Arrange
     Customer customerMock = Mockito.mock(Customer.class);
     Mockito.when(...).thenReturn(...);

     // Act
     Optional<String> name = Utility.getName(customerMock);

     // Assert
     Assert.assertTrue(...);
   }
}

Quel est le problème ?

Alors que les tests s'exécutent avec succès localement, à l'intérieur d'IntelliJ, ils échouent sur Jenkins (lorsque je pousse mon code dans la branche distante, une génération est déclenchée et des tests unitaires s'exécutent à la fin). Le message d'erreur est comme suit:

org.mockito.exceptions.base.MockitoException: ne peut pas se moquer / espionner classe com.packagename.Customer Mockito ne peut pas se moquer / espionner parce que: - classe finale

Qu'est-ce que j'ai essayé?

J'ai cherché un peu, pour trouver une solution mais je n'y suis pas arrivée. Je note ici que je ne suis pas autorisé à changer le fait qu'il Customers'agit d'une classe finale . En plus de cela, j'aimerais si possible ne pas changer du tout sa conception (par exemple, créer une interface, qui contiendrait les méthodes que je veux simuler et déclarer que la classe Customer implémente cette interface, comme Jose l'a correctement souligné dans son commentaire). La chose que j'ai essayée est la deuxième option mentionnée au mockito-final . Malgré le fait que cela ait résolu le problème, cela freine certains autres tests unitaires :(, qui ne peuvent pas être résolus de manière apparente.

Des questions

Voici donc les deux questions que j'ai:

1. Comment est-ce possible en premier lieu? Le test ne devrait-il pas échouer localement et à Jenkins?
2. Comment cela peut-il être corrigé en fonction des contraintes que j'ai mentionnées ci-dessus?

Merci d'avance pour votre aide.

Une autre approche consisterait à utiliser le modèle «méthode pour classer».

1. Déplacez les méthodes de la classe client vers une autre classe / classes, par exemple CustomerSomething, par exemple / CustomerFinances (ou quelle que soit sa responsabilité).
2. Ajoutez un constructeur au client.
3. Maintenant, vous n'avez plus besoin de vous moquer du client, juste la classe CustomerSomething! Vous n'aurez peut-être pas besoin de vous en moquer non plus s'il n'a pas de dépendances externes.

Voici un bon blog sur le sujet: https://simpleprogrammer.com/back-to-basics-mock-élimination-patterns/

Comment est-ce possible en premier lieu? Le test ne devrait-il pas échouer localement et à Jenkins?

C'est évidemment une sorte de spécificités env. La seule question est - comment déterminer la cause de la différence.

Je vous suggère de vérifier la org.mockito.internal.util.MockUtil#typeMockabilityOfméthode et de comparer ce qui mockMakerest réellement utilisé dans les deux environnements et pourquoi.

Si mockMakerc'est la même chose - comparer les classes chargées IDE-Clientvs Jenkins-Client- ont-ils une différence sur le moment de l'exécution du test.

Comment cela peut-il être corrigé en fonction des contraintes que j'ai mentionnées ci-dessus?

Le code suivant est écrit en supposant OpenJDK 12 et Mockito 2.28.2, mais je pense que vous pouvez l'ajuster à n'importe quelle version réellement utilisée.

public class UtilityTest {    
    @Rule
    public InlineMocksRule inlineMocksRule = new InlineMocksRule();

    @Rule
    public MockitoRule mockitoRule = MockitoJUnit.rule();

    @Test
    public void testFinalClass() {
        // Given
        String testName = "Ainz Ooal Gown";
        Client client = Mockito.mock(Client.class);
        Mockito.when(client.getName()).thenReturn(testName);

        // When
        String name = Utility.getName(client).orElseThrow();

        // Then
        assertEquals(testName, name);
    }

    static final class Client {
        final String getName() {
            return "text";
        }
    }

    static final class Utility {
        static Optional<String> getName(Client client) {
            return Optional.ofNullable(client).map(Client::getName);
        }
    }    
}

Avec une règle distincte pour les simulateurs en ligne:

import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.internal.util.MockUtil;

import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class InlineMocksRule implements TestRule {
    private static Field MOCK_MAKER_FIELD;

    static {
        try {
            MethodHandles.Lookup lookup = MethodHandles.privateLookupIn(Field.class, MethodHandles.lookup());
            VarHandle modifiers = lookup.findVarHandle(Field.class, "modifiers", int.class);

            MOCK_MAKER_FIELD = MockUtil.class.getDeclaredField("mockMaker");
            MOCK_MAKER_FIELD.setAccessible(true);

            int mods = MOCK_MAKER_FIELD.getModifiers();
            if (Modifier.isFinal(mods)) {
                modifiers.set(MOCK_MAKER_FIELD, mods & ~Modifier.FINAL);
            }
        } catch (IllegalAccessException | NoSuchFieldException ex) {
            throw new RuntimeException(ex);
        }
    }

    @Override
    public Statement apply(Statement base, Description description) {
        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                Object oldMaker = MOCK_MAKER_FIELD.get(null);
                MOCK_MAKER_FIELD.set(null, Plugins.getPlugins().getInlineMockMaker());
                try {
                    base.evaluate();
                } finally {
                    MOCK_MAKER_FIELD.set(null, oldMaker);
                }
            }
        };
    }
}

Assurez-vous d'exécuter le test avec les mêmes arguments. Vérifiez si vos configurations d'exécution intellij correspondent aux jenkins. https://www.jetbrains.com/help/idea/creating-and-editing-run-debug-configurations.html . Vous pouvez essayer d'exécuter le test sur la machine locale avec les mêmes arguments que sur jenkins (depuis le terminal), si cela échoue, cela signifie que le problème est dans les arguments