Un test de la fonction de sortie (stdout/stderr) à Passer des tests unitaires

J'ai une fonction simple, je veux tester:

func (t *Thing) print(min_verbosity int, message string) {
    if t.verbosity >= minv {
        fmt.Print(message)
    }
}

Mais comment puis-je tester cette fonction envoie sur la sortie standard? Test::Sortie fait ce que je veux en Perl. Je sais que je pourrais écrire mes propres réutilisable à faire de même dans le jeu de Go (comme décrit ici):

orig = os.Stdout
r,w,_ = os.Pipe()
thing.print("Some message")
var buf bytes.Buffer
io.Copy(&buf, r)
w.Close()
os.Stdout = orig
if(buf.String() != "Some message") {
    t.Error("Failure!")
}

Mais c'est beaucoup de travail supplémentaire pour chaque test. J'espère qu'il y a de plus standard, ou peut-être une abstraction de la bibliothèque pour gérer cela.

InformationsquelleAutor Flimzy | 2014-11-07
  1. 25

    Une chose à rappeler aussi, il n'y a rien qui vous empêche d'écrire des fonctions pour éviter le passe-partout.

    Par exemple, j'ai une application en ligne de commande qui utilise log et j'ai écrit cette fonction:

    func captureOutput(f func()) string {
    var buf bytes.Buffer
    log.SetOutput(&buf)
    f()
    log.SetOutput(os.Stderr)
    return buf.String()
}

    Ensuite utilisé comme ceci:

    output := captureOutput(func() {
    client.RemoveCertificate("www.example.com")
})
assert.Equal("removed certificate www.example.com\n", output)

    À l'aide de cette assertion de la bibliothèque: http://godoc.org/github.com/stretchr/testify/assert.

    • C'est probablement ce que je vais faire, comme il est un problème plus général de la solution que celle prévue par @Ainar-G, qui exige que je contrôle tout le code qui pourrait la sortie de quelque chose.
    InformationsquelleAutor Caleb
  2. 15

    Vous pouvez faire une des deux choses. La première consiste à utiliser Exemples.

    Le package fonctionne aussi et vérifie que le code d'exemple. Exemple de fonctions peuvent inclure une conclusion de commentaire sur une ligne qui commence par "Résultat:" et est comparée avec la sortie standard de la fonction lors de l'exécution des tests. (La comparaison ignore attaque et de fuite de l'espace.) Ces exemples illustrent un exemple:

    func ExampleHello() {
        fmt.Println("hello")
        //Output: hello
}

    La seconde (et la plus appropriée OMI) est d'utiliser de faux fonctions de votre IO. Dans votre code, vous n':

    var myPrint = fmt.Print

func (t *Thing) print(min_verbosity int, message string) {
    if t.verbosity >= minv {
        myPrint(message) //N.B.
    }
}

    Et dans vos tests:

    func init() {
    myPrint = fakePrint //fakePrint records everything it's supposed to print.
}

func Test...

    Une autre option est d'utiliser fmt.Fprintf avec un io.Writer qui est os.Stdout dans le code de production, mais peut-être dire que bytes.Buffer dans les tests.

    • Des exemples sont bon pour quand vous avez déterministe de sortie et de l'esf.Fprint est bon pour quand vous pouvez contrôler l'impression de code (que vous ne pouvez pas si c'est dans une bibliothèque externe ou quelque chose). Je pense que la plupart du temps, une de ces choses sera vrai. Si il y a un cas où ni est vrai une option pour lire ce qui est écrit à l'os.Stdout dans une chaîne, ce serait bien.
    InformationsquelleAutor Ainar-G
  3. 1

    Vous pourriez envisager d'ajouter une instruction de retour à votre fonction pour renvoyer la chaîne qui est en fait imprimé. 

    func (t *Thing) print(min_verbosity int, message string) string {
    if t.verbosity >= minv {
        fmt.Print(message)
        return message
    }
    return ""
}

    Maintenant, votre test pourrait-il suffit de cocher la chaîne renvoyée à une chaîne attendue (plutôt que de l'imprimer). Peut-être un peu plus en ligne avec le Développement Piloté par les tests (TDD).

    Et, dans votre code de production, rien ne devait changer, puisque vous n'avez pas à affecter la valeur de retour d'une fonction, si vous n'en avez pas besoin.

    InformationsquelleAutor Joe Bergevin