Comment tester les applications Go qui interagissent avec l'entrée standard (Stdin) ?

Écrire des tests Go pour les interactions Stdin

Dans les tests logiciels, il est souvent nécessaire d'écrire des tests qui interagissent avec stdin, le flux d'entrée standard. Ceci est particulièrement pertinent lors du test d'applications qui lisent les entrées de la console ou d'une interface utilisateur.

Considérez l'application Go suivante qui lit les lignes depuis stdin et les renvoie vers stdout :

<code class="go">package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
)

func main() {
    reader := bufio.NewReader(os.Stdin)
    for {
        fmt.Print("> ")
        bytes, _, err := reader.ReadLine()
        if err == io.EOF {
            os.Exit(0)
        }
        fmt.Println(string(bytes))
    }
}</code>

Pour tester cette application, un scénario de test peut être écrit pour simuler la saisie de l'utilisateur et comparer les résultats au résultat attendu :

<code class="go">package main

import (
    "bufio"
    "io"
    "os"
    "os/exec"
    "testing"
)

func TestInput(t *testing.T) {
    subproc := exec.Command(os.Args[0])
    stdin, _ := subproc.StdinPipe()
    stdout, _ := subproc.StdoutPipe()
    defer stdin.Close()

    input := "abc\n"

    subproc.Start()
    io.WriteString(stdin, input)
    reader := bufio.NewReader(stdout)
    bytes, _, _ := reader.ReadLine()
    output := string(bytes)
    if input != output {
        t.Errorf("Wanted: %v, Got: %v", input, output)
    }
    subproc.Wait()
}</code>

Cependant, ce test peut échouer avec l'erreur : "Recherché : abc, Got : --- FAIL : TestInput (3.32s)".

Pour résoudre ce problème, envisagez la solution suivante :

Au lieu de manipuler stdin et stdout directement dans la fonction principale, définissez une fonction distincte qui accepte io.Reader et io.Writer comme paramètres et effectue les opérations souhaitées. La fonction principale peut alors appeler cette fonction, ce qui facilite le test.

Par exemple, créez une fonction appelée Echo :

<code class="go">func Echo(reader io.Reader, writer io.Writer) {
    reader := bufio.NewReader(reader)
    for {
        fmt.Print("> ", writer)
        bytes, _, err := reader.ReadLine()
        if err == io.EOF {
            return
        }
        fmt.Println(string(bytes), writer)
    }
}</code>

Dans le test, appelez directement la fonction Echo au lieu de interagir avec stdin et stdout :

<code class="go">// ...

func TestInput(t *testing.T) {
    inputReader := strings.NewReader("abc\n")
    outputWriter := new(bytes.Buffer)
    Echo(inputReader, outputWriter)
    result := outputWriter.String()
    if input != result {
        t.Errorf("Wanted: %v, Got: %v", input, result)
    }
}</code>

Ce test devrait maintenant réussir, car il teste directement la fonction Echo sans s'appuyer sur la manipulation de stdin et stdout.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!