Test JUnit avec entrée utilisateur simulée

Question

J'essaie de créer des tests JUnit pour une méthode qui nécessite une entrée utilisateur. La méthode testée ressemble un peu à la méthode suivante :

public static int testUserInput() {
    Scanner keyboard = new Scanner(System.in);
    System.out.println("Give a number between 1 and 10");
    int input = keyboard.nextInt();

    while (input < 1 || input > 10) {
        System.out.println("Wrong number, try again.");
        input = keyboard.nextInt();
    }

    return input;
}

Existe-t-il un moyen de passer automatiquement un int au programme au lieu que moi ou quelqu'un d'autre le fasse manuellement dans la méthode de test JUnit ? Comme simuler l'entrée de l'utilisateur ?

Merci d'avance.

Answer 1

Vous pouvez remplacer System.in avec votre propre flux en appelant System.setIn(InputStream in) . InputStream peut être un tableau d'octets :

InputStream sysInBackup = System.in; // backup System.in to restore it later
ByteArrayInputStream in = new ByteArrayInputStream("My string".getBytes());
System.setIn(in);

// do your thing

// optionally, reset System.in to its original
System.setIn(sysInBackup);

Une approche différente peut rendre cette méthode plus testable en passant IN et OUT comme paramètres :

public static int testUserInput(InputStream in,PrintStream out) {
    Scanner keyboard = new Scanner(in);
    out.println("Give a number between 1 and 10");
    int input = keyboard.nextInt();

    while (input < 1 || input > 10) {
        out.println("Wrong number, try again.");
        input = keyboard.nextInt();
    }

    return input;
}

Answer 2

Pour tester votre code, vous devez créer une enveloppe pour les fonctions d'entrée/sortie du système. Vous pouvez le faire en utilisant l'injection de dépendances, en nous donnant une classe qui peut demander de nouveaux entiers :

public static class IntegerAsker {
    private final Scanner scanner;
    private final PrintStream out;

    public IntegerAsker(InputStream in, PrintStream out) {
        scanner = new Scanner(in);
        this.out = out;
    }

    public int ask(String message) {
        out.println(message);
        return scanner.nextInt();
    }
}

Ensuite, vous pouvez créer des tests pour votre fonction, en utilisant un framework mock (j'utilise Mockito) :

@Test
public void getsIntegerWhenWithinBoundsOfOneToTen() throws Exception {
    IntegerAsker asker = mock(IntegerAsker.class);
    when(asker.ask(anyString())).thenReturn(3);

    assertEquals(getBoundIntegerFromUser(asker), 3);
}

@Test
public void asksForNewIntegerWhenOutsideBoundsOfOneToTen() throws Exception {
    IntegerAsker asker = mock(IntegerAsker.class);
    when(asker.ask("Give a number between 1 and 10")).thenReturn(99);
    when(asker.ask("Wrong number, try again.")).thenReturn(3);

    getBoundIntegerFromUser(asker);

    verify(asker).ask("Wrong number, try again.");
}

Puis écrivez votre fonction qui passe les tests. La fonction est beaucoup plus propre, car vous pouvez supprimer la duplication de la demande et de l'obtention des entiers et les appels système réels sont encapsulés.

public static void main(String[] args) {
    getBoundIntegerFromUser(new IntegerAsker(System.in, System.out));
}

public static int getBoundIntegerFromUser(IntegerAsker asker) {
    int input = asker.ask("Give a number between 1 and 10");
    while (input < 1 || input > 10)
        input = asker.ask("Wrong number, try again.");
    return input;
}

Cela peut sembler exagéré pour votre petit exemple, mais si vous construisez une application plus importante, un tel développement peut s'avérer rapidement payant.

Answer 3

Une façon courante de tester un code similaire serait d'extraire une méthode qui prend en compte un Scanner et un PrintWriter, comme dans le cas suivant cette réponse de StackOverflow et de le tester :

public void processUserInput() {
  processUserInput(new Scanner(System.in), System.out);
}

/** For testing. Package-private if possible. */
public void processUserInput(Scanner scanner, PrintWriter output) {
  output.println("Give a number between 1 and 10");
  int input = scanner.nextInt();

  while (input < 1 || input > 10) {
    output.println("Wrong number, try again.");
    input = scanner.nextInt();
  }

  return input;
}

Notez que vous ne pourrez pas lire vos résultats avant la fin, et que vous devrez spécifier toutes vos entrées au préalable :

@Test
public void shouldProcessUserInput() {
  StringWriter output = new StringWriter();
  String input = "11\n"       // "Wrong number, try again."
               + "10\n";

  assertEquals(10, systemUnderTest.processUserInput(
      new Scanner(input), new PrintWriter(output)));

  assertThat(output.toString(), contains("Wrong number, try again.")););
}

Bien sûr, plutôt que de créer une méthode de surcharge, vous pourriez aussi conserver le "scanner" et la "sortie" comme champs mutables dans votre système à tester. J'ai tendance à préférer garder les classes aussi apatrides que possible, mais ce n'est pas une concession très importante si cela compte pour vous ou vos collègues/instructeurs.

Vous pouvez également choisir de placer votre code de test dans le même paquetage Java que le code testé (même s'il se trouve dans un dossier source différent), ce qui vous permet d'assouplir la visibilité de la surcharge à deux paramètres pour qu'elle soit privée par paquetage.

Answer 4

J'ai réussi à trouver un moyen plus simple. Cependant, vous devez utiliser une bibliothèque externe System.rules par @Stefan Birkner

J'ai juste pris l'exemple fourni là, je pense que ça ne pouvait pas être plus simple :

import java.util.Scanner;

public class Summarize {
  public static int sumOfNumbersFromSystemIn() {
    Scanner scanner = new Scanner(System.in);
    int firstSummand = scanner.nextInt();
    int secondSummand = scanner.nextInt();
    return firstSummand + secondSummand;
  }
}

Test

import static org.junit.Assert.*;
import static org.junit.contrib.java.lang.system.TextFromStandardInputStream.*;

import org.junit.Rule;
import org.junit.Test;
import org.junit.contrib.java.lang.system.TextFromStandardInputStream;

public class SummarizeTest {
  @Rule
  public final TextFromStandardInputStream systemInMock
    = emptyStandardInputStream();

  @Test
  public void summarizesTwoNumbers() {
    systemInMock.provideLines("1", "2");
    assertEquals(3, Summarize.sumOfNumbersFromSystemIn());
  }
}

Le problème est que dans mon cas, ma deuxième entrée contient des espaces et cela rend le flux d'entrée entier nul !

Answer 5

Vous pourriez commencer par extraire la logique qui récupère le numéro du clavier dans sa propre méthode. Vous pourrez alors tester la logique de validation sans vous soucier du clavier. Pour tester l'appel keyboard.nextInt(), vous pouvez envisager d'utiliser un objet fantaisie.