Affirmer que l'option a une certaine valeur

J'ai une méthode Java qui renvoie un En option.
Je voudrais écrire un facile-à-lire le test unitaire pour que affirme que

le retour de l'Option a une valeur (c'est à dire, l'Option n'est pas vide) et que
la valeur renvoyée est égale à la valeur attendue.

Disons que ma méthode éprouvée est

Optional<String> testedMethod(){
  return Optional.of("actual value");
}

source d'informationauteur Matthias Braun

Vous pouvez également utiliser AssertJ pour couramment affirmations

@Test
public void testThatOptionalIsNotEmpty() {
    assertThat(testedMethod()).isNotEmpty();
}

@Test
public void testThatOptionalHasValue() {
    assertThat(testedMethod()).hasValue("hello");
}

12

TL;DR la meilleure approche globale a été suggéré par Ole V. V.:
```
assertEquals(Optional.of("expected"), opt);
```
D'autres alternatives sont discutées ci-dessous.

Il y a plusieurs façons de le faire, selon votre goût pour la clarté des résultats de test contre la concision de test écrit. Pour cette réponse, je vais en tenir à "stock" de Java 8 et JUnit 4 avec pas de dépendances supplémentaires.

Une façon, comme l'a suggéré dans un commentaire par Ole V. V.est de simplement écrire
```
assertEquals("expected", opt.get());
```
La plupart du temps cela fonctionne, mais si l'Option est vide, alors get() va jeter NoSuchElementException. Ceci provoque de JUnit pour signaler une erreur à la place d'un échec, qui pourrait ne pas être ce que vous voulez. Il n'est également pas très clairement ce qui se passe, sauf si vous savez déjà que get() jette NSEE dans ce cas.

Une alternative est
```
assertTrue(opt.isPresent() && "expected".equals(opt.get()));
```
Ce aussi la plupart du temps fonctionne, mais il n'a pas de rapport à la valeur réelle si il y a un décalage, ce qui pourrait faciliter le débogage gênant.

Une autre alternative est
```
assertEquals("expected", opt.orElseThrow(AssertionFailedError::new));
```
Cela donne le droit échecs et les rapports de la valeur réelle lorsqu'il y a une incompatibilité, mais il n'est pas très explicite au sujet de pourquoi AssertionFailedError est levée. Vous pourriez avoir à regarder un certain temps jusqu'à ce que vous vous rendez compte que l'AFE est lancée lorsque l'Option est vide.

Encore une autre alternative est
```
assertEquals("expected", opt.orElseThrow(() -> new AssertionFailedError("empty")));
```
mais cela commence à devenir plus clair.

Vous pourrait diviser en deux assertions,
```
assertTrue(opt.isPresent());
assertEquals("expected", opt.get());
```
mais vous avait déjà opposé à cette suggestion en raison de verbosité. Ce n'est pas vraiment terriblement bavard à mon avis, mais elle a quelques cognitifs généraux puisqu'il y a deux affirmations, et il s'appuie sur le deuxième seulement être vérifié si le premier réussit. Ce n'est pas incorrect, mais c'est un peu subtile.

Enfin, si vous êtes prêt à créer un peu de votre propre infrastructure, vous pouvez créer un appareil nommé sous-classe de AssertionFailedError et de l'utiliser comme ceci:
```
assertEquals("expected", opt.orElseThrow(UnexpectedEmptyOptional::new));
```
Enfin, dans un autre commentaire, Ole V. V. suggéré
```
assertEquals(Optional.of("correct"), opt);
```
Cela fonctionne assez bien, et en fait, ce pourrait être le meilleur de tous.

- Je utiliser Hamcrest En Option:

import static com.github.npathai.hamcrestopt.OptionalMatchers.hasValue;
import org.junit.Test;

public class MyUnitTests {

  @Test
  public void testThatOptionalHasValue(){
    String expectedValue = "actual value";
    assertThat(testedMethod(), hasValue(expectedValue));
  }
}

Vous pouvez ajouter Hamcrest Facultatif à vos dépendances en l'incluant dans votre build.gradle:

dependencies {
  testCompile 'junit:junit:4.12'
  testCompile 'com.github.npathai:hamcrest-optional:1.0'
}

1

Ci-dessous la méthode utilise le fait que vous pouvez spécifier une valeur par défaut de retour pour une option. Si votre méthode d'essai pourrait être quelque chose comme ceci:
```
@test
public void testThatOptionalHasValue() {
    String expectedValue = "actual value";
    String actualValue = Optional.ofNullable(testedMethod()).orElse("not " + expectedValue);
    assertEquals("The values are not the same", expectedValue, actualValue);
}
```
Ce guarentees que si votre méthode renvoie la valeur null, alors le résultat ne peut pas être la même que la valeur attendue.
0

Pourquoi n'utilisez-vous pas isPresent() et get()?

Vous devez vous connecter pour publier un commentaire.