Comment tester unitairement la validation des indicateurs de ligne de commande dans Go ?

Comment tester les indicateurs de ligne de commande dans Go

Introduction :

Les tests unitaires sont crucial pour garantir la fiabilité et l’exactitude de votre code, y compris la gestion des indicateurs de ligne de commande. L'analyse des indicateurs est une tâche courante dans les applications Go, et il est essentiel de vérifier que les indicateurs sont correctement validés. Cet article explique comment tester les indicateurs de ligne de commande dans Go.

Configuration du test unitaire :

Pour valider les indicateurs de test unitaire, nous allons créer un fichier personnalisé type d'indicateur qui vérifie si la valeur d'un indicateur se trouve dans une énumération attendue. Considérons l'exemple de code suivant :

<code class="go">var formatType string

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

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

    flag.StringVar(&amp;formatType, "format", defaultFormat, formatUsage)
    flag.StringVar(&amp;formatType, "f", defaultFormat, formatUsage+" (shorthand)")
}</code>

Validation du drapeau personnalisé :

Nous pouvons définir un drapeau personnalisé.Type de valeur pour valider le drapeau de format :

<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 &amp;&amp; *f != "text" {
        return errors.New("format flag already set")
    }
    if value != "text" &amp;&amp; value != "json" &amp;&amp; value != "hash" {
        return errors.New("Invalid Format Type")
    }
    *f = formatType(value)
    return nil
}</code>

Création du test unitaire :

Maintenant, écrivons un test unitaire qui vérifie la validation du drapeau personnalisé :

<code class="go">func TestValidateFormatFlag(t *testing.T) {
    testCases := []struct {
        input    string
        expected error
    }{
        {"text", nil},
        {"json", nil},
        {"hash", nil},
        {"invalid", errors.New("Invalid Format Type")},
    }

    for _, tc := range testCases {
        args := []string{"-format", tc.input}
        os.Args = args

        typeFlag = "text"
        flag.CommandLine = flag.NewFlagSet("test", flag.ContinueOnError)
        flag.Var(&amp;typeFlag, "format", "Format type. Must be \"text\", \"json\" or \"hash\". Defaults to \"text\".")
        if err := flag.CommandLine.Parse(args[1:]); err != nil {
            t.Errorf("Error parsing flags: %v", err)
        }

        if tc.expected != nil && err == nil {
            t.Errorf("Expected error: %v, got nil", tc.expected)
        } else if tc.expected == nil && err != nil {
            t.Errorf("Unexpected error: %v", err)
        }
    }
}</code>

Dans ce test, nous mettre en place une série de cas de test avec différentes entrées et erreurs attendues. Nous nous moquons des arguments de ligne de commande en utilisant os.Args et analysons les indicateurs à l'aide d'un FlagSet personnalisé. En comparant l'erreur réelle avec l'erreur attendue pour chaque scénario de test, nous garantissons que la validation des indicateurs fonctionne comme prévu.

Conseils pour exécuter des tests d'indicateur :

• Créez des tests unitaires distincts pour chaque exigence de validation d'indicateur.
• Utilisez un framework fictif tel que testify pour simplifier la configuration des tests et les assertions.
• Évitez d'utiliser une véritable analyse de ligne de commande dans les tests unitaires pour garantir l'isolement.

Conclusion :

En implémentant des types d'indicateurs personnalisés et en écrivant des tests unitaires, vous pouvez valider efficacement les indicateurs de ligne de commande dans Go. Cette pratique permet de maintenir la fiabilité et la robustesse de vos applications.

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!