Wie teste ich Befehlszeilen-Flag-Werte anhand einer Aufzählung in Go?

Befehlszeilenflags in Go testen

In diesem Artikel werden Testtechniken für Befehlszeilenflags in Golang untersucht. Insbesondere werden wir untersuchen, wie Flag-Werte anhand einer Aufzählung einem Unit-Test unterzogen werden.

Problemstellung

Angesichts des folgenden Codes:

<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>

Wir Sie möchten einen Komponententest schreiben, um zu überprüfen, ob der Flag-Wert im Format mit einer der vordefinierten Konstanten übereinstimmt.

Lösung mit benutzerdefiniertem Flag-Typ

Um Flags in einem weiteren Format zu testen Auf flexible Weise können wir die Funktion flag.Var mit einem benutzerdefinierten Typ verwenden, der die Value-Schnittstelle implementiert.

<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>

In dieser Lösung nimmt flag.Var einen Zeiger auf einen benutzerdefinierten Typ, der die Value-Schnittstelle erfüllt, und ermöglicht so Wir können unsere eigene Validierungslogik innerhalb der Set-Methode definieren.

Benutzerdefinierter Flag-Typ für Unit-Tests

Unit-Tests für den benutzerdefinierten Flag-Typ können wie folgt geschrieben werden:

<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>

Das obige ist der detaillierte Inhalt vonWie teste ich Befehlszeilen-Flag-Werte anhand einer Aufzählung in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!