Comment tester unitairement la validation de l'énumération des indicateurs de ligne de commande dans Go ?

Tests unitaires des indicateurs de ligne de commande dans Go

Dans Go, la définition d'indicateurs personnalisés pour les applications de ligne de commande nécessite un processus de test approfondi pour garantir leur l'exactitude. Un scénario spécifique consiste à vérifier que la valeur d'un indicateur particulier s'inscrit dans une énumération prédéfinie.

Code à tester

<code class="go">var formatType string

const (
    text = "text"
    json = "json"
    hash = "hash"
)

func init() {
    const (
        defaultFormat = "text"
        formatUsage   = "desired output format"
    )

    flag.StringVar(&formatType, "format", defaultFormat, formatUsage)
    flag.StringVar(&formatType, "f", defaultFormat, formatUsage+" (shorthand)")
}

func main() {
    flag.Parse()
}</code>

Approche de test

Pour tester unitairement le comportement souhaité, nous pouvons exploiter la puissance de la fonction flag.Var, qui nous permet de définir des types personnalisés et des règles de validation pour les drapeaux.

<code class="go">type formatType string

func (f *formatType) String() string {
    return fmt.Sprint(*f)
}

func (f *formatType) Set(value string) error {
    if len(*f) > 0 && *f != "text" {
        return errors.New("format flag already set")
    }
    if value != "text" && value != "json" && value != "hash" {
        return errors.New("Invalid Format Type")
    }
    *f = formatType(value)
    return nil
}</code>

Dans cette implémentation de type personnalisé :

• String() renvoie la valeur actuelle du drapeau sous forme de chaîne.
• Set() met à jour la valeur de l'indicateur et garantit qu'il s'inscrit dans l'énumération autorisée.

En utilisant cet indicateur formatType personnalisé, le processus de test peut désormais valider le comportement de l'indicateur lorsqu'il est défini sur différentes valeurs.

Exemple de test

<code class="go">package main

import "testing"

func TestFormatType(t *testing.T) {
    tests := []struct {
        args   []string
        expect string
    }{
        {[]string{"-format", "text"}, "text"},
        {[]string{"-f", "json"}, "json"},
        {[]string{"-format", "foo"}, "Invalid Format Type"},
    }

    for _, test := range tests {
        t.Run(test.args[0], func(t *testing.T) {
            flag.Parse()
            if typeFlag != test.expect {
                t.Errorf("Expected %s got %s", test.expect, typeFlag)
            }
        })
    }
}</code>

Dans cet exemple :

• TestFormatType itère sur un liste des tests.
• Chaque test configure les arguments de ligne de commande, analyse les indicateurs et compare la valeur typeFlag résultante avec les résultats attendus.
• Si un test échoue, il signale une erreur.

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!