Comment tester unitairement les valeurs des indicateurs de ligne de commande par rapport à une énumération en Go ?

Test des indicateurs de ligne de commande dans Go

Cet article explore les techniques de test des indicateurs de ligne de commande dans Golang. Plus précisément, nous examinerons comment tester unitairement les valeurs des indicateurs par rapport à une énumération.

Énoncé du problème

Étant donné le code suivant :

<code class="go">// Define flag for output format
var formatType string

// Constants representing valid format types
const (
    text = "text"
    json = "json"
    hash = "hash"
)

// Initialize flags
func init() {
    flag.StringVar(&formatType, "format", "text", "Desired output format")
}

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

Nous souhaitez écrire un test unitaire pour vérifier que la valeur de l'indicateur -format correspond à l'une des constantes prédéfinies.

Solution utilisant le type d'indicateur personnalisé

Pour tester les indicateurs de manière plus de manière flexible, nous pouvons utiliser la fonction flag.Var avec un type personnalisé implémentant l'interface Value.

<code class="go">package main

import (
    "errors"
    "flag"
    "fmt"
)

// Custom type representing format type
type formatType string

// String() method for Value interface
func (f *formatType) String() string {
    return fmt.Sprint(*f)
}

// Set() method for Value interface
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
}

// Initialize flag with custom type
func init() {
    typeFlag := "text" // Default value
    usage := `Format type. Must be "text", "json" or "hash". Defaults to "text".`
    flag.Var(&typeFlag, "format", usage)
}

// Main function
func main() {
    flag.Parse()
    fmt.Println("Format type is", typeFlag)
}
</code>

Dans cette solution, flag.Var prend un pointeur vers un type personnalisé qui satisfait l'interface Value, permettant nous de définir notre propre logique de validation dans la méthode Set.

Type d'indicateur personnalisé de test unitaire

Les tests unitaires pour le type d'indicateur personnalisé peuvent être écrits comme suit :

<code class="go">// Test unit validates that the format flag is within the enumeration
func TestFormatFlag(t *testing.T) {
    testCases := []struct {
        input       string
        expectedErr string
    }{
        {"text", ""},
        {"json", ""},
        {"hash", ""},
        {"", "Invalid Format Type"},
        {"xml", "Invalid Format Type"},
    }

    for _, tc := range testCases {
        t.Run(tc.input, func(t *testing.T) {
            args := []string{"-format", tc.input}
            flag.CommandLine = flag.NewFlagSet("test", flag.PanicOnError)
            err := flag.CommandLine.Parse(args)

            if err != nil && err.Error() != tc.expectedErr {
                t.Errorf("Unexpected error: %v", err)
                return
            }
        })
    }
}</code>

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!