Se moquant de Java enum pour ajouter une valeur de test en cas d'échec

Voici un exemple complet.

Le code est presque comme votre origine (juste simplifié meilleur test de validation):

public enum MyEnum {A, B}

public class Bar {

    public int foo(MyEnum value) {
        switch (value) {
            case A: return 1;
            case B: return 2;
        }
        throw new IllegalArgumentException("Do not know how to handle " + value);
    }
}

Et voici le test de l'unité avec le code complet de la couverture, le test fonctionne avec Powermock (1.4.10), Mockito (1.8.5) et JUnit (4.8.2):

@RunWith(PowerMockRunner.class)
public class BarTest {

    private Bar bar;

    @Before
    public void createBar() {
        bar = new Bar();
    }

    @Test(expected = IllegalArgumentException.class)
    @PrepareForTest(MyEnum.class)
    public void unknownValueShouldThrowException() throws Exception {
        MyEnum C = PowerMockito.mock(MyEnum.class);
        Whitebox.setInternalState(C, "name", "C");
        Whitebox.setInternalState(C, "ordinal", 2);

        PowerMockito.mockStatic(MyEnum.class);
        PowerMockito.when(MyEnum.values()).thenReturn(new MyEnum[]{MyEnum.A, MyEnum.B, C});

        bar.foo(C);
    }

    @Test
    public void AShouldReturn1() {
        assertEquals(1, bar.foo(MyEnum.A));
    }

    @Test
    public void BShouldReturn2() {
        assertEquals(2, bar.foo(MyEnum.B));
    }
}

Résultat:

Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.628 sec

Que vous avez indiqué dans votre montage, vous pouvez ajouter le functionaliy dans le enum lui-même. Toutefois, cela pourrait ne pas être la meilleure option, car elle peut constituer une infraction à la "Une Responsabilité" principe. Une autre façon d'y parvenir est de créer un mappage statique qui contient les valeurs de l'enum comme la clé et la fonctionnalité de la valeur. De cette façon, vous pouvez facilement tester si, pour toute valeur d'enum la validité de comportement en boucle sur toutes les valeurs. Il peut être un peu tiré par les cheveux sur cet exemple, mais c'est une technique que j'utilise souvent à la carte id de ressource à enum valeurs.

Juste de créer une fausse valeur d'enum ne sera pas suffisant, vous avez également besoin de manipuler un tableau d'entiers qui est créé par le compilateur.

---

En fait de créer une fausse valeur d'enum, vous n'avez même pas besoin de se moquant de cadre. Vous pouvez simplement utiliser Objenesis pour créer une nouvelle instance de la classe enum (oui, cela fonctionne) puis utilisez plain old Java réflexion pour définir les champs privés name et ordinal et vous avez déjà votre nouvelle enum instance.

À l'aide de Spock cadre des tests, cela ressemblerait à quelque chose comme:

given:
    def getPrivateFinalFieldForSetting = { clazz, fieldName ->
        def result = clazz.getDeclaredField(fieldName)
        result.accessible = true
        def modifiers = Field.getDeclaredFields0(false).find { it.name == 'modifiers' }
        modifiers.accessible = true
        modifiers.setInt(result, result.modifiers & ~FINAL)
        result
    }

and:
    def originalEnumValues = MyEnum.values()
    MyEnum NON_EXISTENT = ObjenesisHelper.newInstance(MyEnumy)
    getPrivateFinalFieldForSetting.curry(Enum).with {
        it('name').set(NON_EXISTENT, "NON_EXISTENT")
        it('ordinal').setInt(NON_EXISTENT, originalEnumValues.size())
    }

---

Si vous aussi vous voulez le MyEnum.values() méthode pour renvoyer la nouvelle enum, vous pouvez maintenant utiliser JMockit de se moquer de l' values() appel comme

new MockUp<MyEnum>() {
    @Mock
    MyEnum[] values() {
        [*originalEnumValues, NON_EXISTENT] as MyEnum[]
    }
}

ou vous pouvez à nouveau utiliser le bon vieux réflexion pour manipuler les $VALUES domaine comme:

given:
    getPrivateFinalFieldForSetting.curry(MyEnum).with {
        it('$VALUES').set(null, [*originalEnumValues, NON_EXISTENT] as MyEnum[])
    }

expect:
    true //your test here

cleanup:
    getPrivateFinalFieldForSetting.curry(MyEnum).with {
        it('$VALUES').set(null, originalEnumValues)
    }

---

Aussi longtemps que vous n'avez pas affaire à un switch expression, mais avec quelques ifs ou similaire, soit juste ou de la première partie de la première et de la deuxième partie peut être suffisant pour vous.

Si vous faites affaire avec un switch expression, d'e. g. vouloir une couverture de 100% pour le default affaire, qui lève une exception dans le cas où l'enum est agrandi comme dans votre exemple, les choses deviennent un peu plus compliqué et en même temps un peu plus facile.

Un peu plus compliqué car vous avez besoin de faire un peu de sérieux de la réflexion afin de manipuler un terrain synthétique que le compilateur génère dans un synthétique anonyme innner classe que le compilateur génère, de sorte qu'il n'est vraiment pas évident ce que vous faites et vous êtes lié à la mise en œuvre effective du compilateur, ce qui pourrait casser à tout moment, dans toute version de Java, ou même si vous utilisez des compilateurs différents pour la même version de Java. Il est déjà différente entre Java 6 et Java 8.

Un peu plus facile, parce que vous pouvez oublier les deux premières parties de cette réponse, parce que vous n'avez pas besoin de créer un nouveau enum exemple à tous, vous avez juste besoin de manipuler un int[], que vous avez besoin de manipuler de toute façon pour faire le test que vous souhaitez.

J'ai récemment trouvé un très bon article au sujet de cette à https://www.javaspecialists.eu/archive/Issue161.html.

La plupart des informations y est toujours valable, sauf que maintenant l'intérieur de la classe contenant le commutateur de la carte n'est plus un nom interne de la classe, mais la classe anonyme, de sorte que vous ne pouvez pas utiliser getDeclaredClasses, mais plus besoin d'utiliser une approche différente indiqué ci-dessous.

Fondamentalement résumé, interrupteur sur le bytecode à niveau ne fonctionne pas avec les énumérations, mais seulement avec des entiers. Donc, ce que le compilateur n'est, elle crée un anonyme intérieur de la classe (précédemment nommée intérieure que par l'écriture d'article, c'est Java 6 vs Java 8) qui est titulaire d'un static final int[] champ appelé $SwitchMap$net$kautler$MyEnum qui est rempli avec des nombres entiers 1, 2, 3, ... sur les indices de MyEnum#ordinal() valeurs.

Cela signifie que lorsque le code est livré pour le changement réel, il ne

switch(<anonymous class here>.$SwitchMap$net$kautler$MyEnum[myEnumVariable.ordinal()]) {
    case 1: break;
    case 2: break;
    default: throw new AssertionError("Missing switch case for: " + myEnumVariable);
}

Si maintenant myEnumVariable aurait la valeur NON_EXISTENT créé dans la première étape ci-dessus, vous obtenez une ArrayIndexOutOfBoundsException si vous définissez ordinal à une valeur supérieure à la matrice de l'généré par le compilateur, ou vous obtenez l'un de l'autre interrupteur valeurs si ce n'est, dans les deux cas, ce ne serait pas aider à tester le voulait default cas.

Vous pouvez maintenant obtenir ce int[] champ et le fixer en place pour contenir un mappage pour l'orinal de votre NON_EXISTENT enum instance. Mais comme je l'ai dit plus tôt, exactement pour ce cas d'utilisation, les tests de la default cas, vous n'avez pas besoin de la première de deux étapes à tous. Au lieu de cela, vous pouvez simplement donner un enum cas pour le code testé et tout simplement de manipuler la cartographie int[], de sorte que le default cas est déclenchée.

Donc tout ce qui est nécessaire pour ce test est en fait, encore une fois écrit dans Spock (Groovy) du code, mais vous pouvez facilement l'adapter à Java trop:

given:
    def getPrivateFinalFieldForSetting = { clazz, fieldName ->
        def result = clazz.getDeclaredField(fieldName)
        result.accessible = true
        def modifiers = Field.getDeclaredFields0(false).find { it.name == 'modifiers' }
        modifiers.accessible = true
        modifiers.setInt(result, result.modifiers & ~FINAL)
        result
    }

and:
    def switchMapField
    def originalSwitchMap
    def namePrefix = ClassThatContainsTheSwitchExpression.name
    def classLoader = ClassThatContainsTheSwitchExpression.classLoader
    for (int i = 1; ; i++) {
        def clazz = classLoader.loadClass("$namePrefix$$i")
        try {
            switchMapField = getPrivateFinalFieldForSetting(clazz, '$SwitchMap$net$kautler$MyEnum')
            if (switchMapField) {
                originalSwitchMap = switchMapField.get(null)
                def switchMap = new int[originalSwitchMap.size()]
                Arrays.fill(switchMap, Integer.MAX_VALUE)
                switchMapField.set(null, switchMap)
                break
            }
        } catch (NoSuchFieldException ignore) {
            //try next class
        }
    }

when:
    testee.triggerSwitchExpression()

then:
    AssertionError ae = thrown()
    ae.message == "Unhandled switch case for enum value 'MY_ENUM_VALUE'"

cleanup:
    switchMapField.set(null, originalSwitchMap)

Dans ce cas, vous n'avez pas besoin de se moquant de cadre à tous. En fait, il ne serait pas vous aider en tout cas, pas de moqueries cadre, je suis conscient de vous permet de simuler un tableau. Vous pouvez utiliser JMockit ou tout se moquant de cadre pour se moquer de la valeur de retour de ordinal(), mais ce serait encore simplement changer l'interrupteur de la succursale ou d'une AIOOBE.

Ce que ce code j'ai juste indiqué n'est:

• il parcourt l'anonyme de classes à l'intérieur de la classe qui contient le commutateur expression
• dans ceux qu'elle recherche le champ avec le commutateur de la carte
• si le champ n'est pas trouvé, la classe suivante est essayé
• si un ClassNotFoundException est jeté par Class.forName, le test échoue, ce qui est prévu, parce que cela signifie que vous avez compilé le code avec un compilateur qui suit une stratégie différente ou un modèle de nommage, si vous avez besoin d'ajouter un peu plus d'intelligence pour couvrir les différentes compilateur stratégies pour la commutation sur les valeurs de l'enum. Parce que si la classe avec le terrain est trouvé, le break quitte la boucle for et le test peut continuer. Toute cette stratégie dépend bien sûr de anonyme classes étant numérotés à partir de 1 et sans lacunes, mais j'espère que c'est plutôt une hypothèse sûre. Si vous faites affaire avec un compilateur où ce n'est pas le cas, l'algorithme de recherche doit être adapté en conséquence.
• si le commutateur de la carte de terrain est trouvé, une nouvelle int tableau de la même taille est créé
• le nouveau tableau est rempli avec Integer.MAX_VALUE qui normalement devrait déclencher la default cas aussi longtemps que vous n'avez pas un enum avec de 2 147 483 647 valeurs
• le nouveau tableau est attribué à l'interrupteur de la carte de champ
• pour la boucle est à gauche à l'aide de break
• maintenant, le test peut être fait, le déclenchement de l'interrupteur d'expression à évaluer
• enfin (dans un finally bloc si vous n'êtes pas à l'aide de Spock, dans un cleanup bloc si vous utilisez Spock) pour s'assurer que cela n'affecte pas les autres tests sur le même classe, l'original de changer la carte est remise dans le commutateur de la carte de champ

Je pense que la façon la plus simple pour atteindre le IllegalArgumentException est de passer la valeur null à la méthode foo et vous pourrez lire "je Ne sais pas comment gérer la valeur null"