Singleton et tests unitaires

Se moque nécessitent des interfaces, parce que ce que vous êtes en train de faire est de remplacer le vrai problème sous-jacent avec un imposteur qui imite ce que vous avez besoin pour le test. Depuis le client ne traite que d'une interface de type de référence, il n'a pas besoin de savoir ce que la mise en œuvre est.

Vous ne pouvez pas se moquer d'un béton de classe sans interface, parce que vous ne pouvez pas remplacer le comportement sans que le client de test savoir à ce sujet. C'est une classe entièrement nouvelle dans ce cas.

C'est vrai pour toutes les classes, Singleton ou pas.

C'est tellement simple.

Dans les tests unitaires, vous voulez isoler votre SUT (la classe que vous faites des tests).
Vous ne voulez pas tester un tas de classes, parce que cela irait à l'encontre du but de unité-tests.

Mais pas toutes les classes ne tout sur leur propre, à droite? La plupart des classes d'utilisation autres classes pour faire leur travail, et ils sorte de médiation entre autres classes, et ajouter un peu de leur propre, pour obtenir le résultat final.

Le point est - vous ne se soucient pas comment les classes de votre SUT dépend de travail. Vous vous souciez de la façon dont votre SUT travaille avec les classes. C'est pourquoi vous talon ou se moquer de les classes de votre SUT besoins. Et vous pouvez utiliser ces objets fantaisie parce que vous pouvez les passer en paramètres du constructeur pour votre SUT.

Avec les singletons - la mauvaise chose est que la getInstance() méthode est accessible à l'échelle mondiale. Cela signifie que vous avez l'habitude de les appeler à partir de dans une classe, au lieu de selon sur une interface, vous pouvez plus tard se moquer de. C'est pourquoi il est impossible de remplacer quand vous voulez tester votre SUT.

La solution est de ne pas utiliser le sournois public static MySingleton getInstance() méthode, mais à dépendent sur un interface vos besoins de la classe pour travailler avec. Le faire, et vous pouvez passer en test doubles chaque fois que vous en avez besoin.

Singleton objets sont créés, sans contrôle de l'extérieur. Dans l'un des chapitres d'un même livre Bloch suggère d'utiliser enums en tant que par défaut Singleton mise en œuvre. Voyons un exemple

public enum Day {
  MON(2), TUE(3), WED(4), THU(5), FRI(6), SAT(7), SUN(1);

  private final int index;

  private Day(int index) {

    this.index = index;
  }

  public boolean isToday() {

    return index == new GregorianCalendar().get(Calendar.DAY_OF_WEEK);
  }
}

Disons que nous avons un code qui doit être exécuté uniquement le week-end:

public void leisure() {

  if (Day.SAT.isToday() || Day.SUN.isToday()) {

    haveSomeFun();
    return;
  }

  doSomeWork();
}

Tests de loisirs de la méthode va être assez dur. Son exécution va être dépend de la journée, lorsqu'il est exécuté. Si elle s'exécute sur un jour de semaine doSomeWork() sera invoquée et le week-end haveSomeFun().

Pour ce cas, nous aurions besoin d'utiliser certains outils comme PowerMock pour intercepter le GregorianCalendar constructeur, de retour d'une maquette qui sera de retour un index correspondant à un jour de semaine ou de week-end dans les deux cas de test tester à la fois les chemins d'exécution de la leisure méthode.

Il est possible, voir l'exemple

import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.lang.reflect.Field;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class DriverSnapshotHandlerTest {
private static final String MOCKED_URL = "MockedURL";
private FormatterService formatter;
@SuppressWarnings("javadoc")
@Before
public void setUp() {
formatter = mock(FormatterService.class);
setMock(formatter);
when(formatter.formatTachoIcon()).thenReturn(MOCKED_URL);
}
/**
* Remove the mocked instance from the class. It is important, because other tests will be confused with the mocked instance.
* @throws Exception if the instance could not be accessible
*/
@After
public void resetSingleton() throws Exception {
Field instance = FormatterService.class.getDeclaredField("instance");
instance.setAccessible(true);
instance.set(null, null);
}
/**
* Set a mock to the {@link FormatterService} instance
* Throws {@link RuntimeException} in case if reflection failed, see a {@link Field#set(Object, Object)} method description.
* @param mock the mock to be inserted to a class
*/
private void setMock(FormatterService mock) {
Field instance;
try {
instance = FormatterService.class.getDeclaredField("instance");
instance.setAccessible(true);
instance.set(instance, mock);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* Test method for {@link com.example.DriverSnapshotHandler#getImageURL()}.
*/
@Test
public void testFormatterServiceIsCalled() {
DriverSnapshotHandler handler = new DriverSnapshotHandler();
String url = handler.getImageURL();
verify(formatter, atLeastOnce()).formatTachoIcon();
assertEquals(MOCKED_URL, url);
}
}

Le problème avec les singletons (et aussi avec des méthodes statiques), c'est qu'il rend difficile pour remplacer le code avec un moqué de mise en œuvre.

Par exemple, considérons le code suivant

public class TestMe() {
public String foo(String data) {
boolean isFeatureFlag = MySingletonConfig.getInstance().getFeatureFlag();
if (isFeatureFlag)
//do somethine with data
else
//do something else with the data
return result;
}
}

Il n'est pas facile d'écrire un test unitaire pour la méthode foo et de vérifier le bon comportement est effectuée.
C'est parce que vous ne pouvez pas facilement changer la valeur de retour de getFeatureFlag.

Le même problème existe pour les méthodes statiques - il n'est pas facile de remplacer la cible réelle méthode de la classe avec une simulation de comportement.

Bien sûr, il existe des solutions de contournement comme powermock, ou l'injection de dépendance à la méthode, ou la réflexion dans les tests.
Mais il est beaucoup mieux de ne pas utiliser les singletons, en premier lieu,