How do I unit test command line flags in Go?

The key to unit testing command line flags in Go is utilizing the flag package from the standard library to define and parse command line arguments, and then leveraging the testing package to write and execute tests. Here is a step-by-step approach and example:

Step 1: Define and Parse Command Line Flags

First, we need to define some command line flags and parse them within the program. This is typically performed in the main() function or other initialization functions.

go
package main

import (
    "flag"
    "fmt"
)

var (
    name = flag.String("name", "World", "a name to say hello to")
    age  = flag.Int("age", 30, "your age")
)

func init() {
    flag.Parse()
}

func greeting() string {
    return fmt.Sprintf("Hello, %s! You are %d years old.", *name, *age)
}

func main() {
    fmt.Println(greeting())
}

Step 2: Write Unit Tests

To unit test the command line argument parsing in the above code, redefine and parse these flags within the test code. You can simulate command line input in your test file using flag.Set.

go
package main

import (
    "flag"
    "testing"
)

func TestGreeting(t *testing.T) {
    // Set command line arguments
    flag.Set("name", "Alice")
    flag.Set("age", "28")

    // Call the function under test
    result := greeting()

    // Verify the result matches expectations
    expected := "Hello, Alice! You are 28 years old."
    if result != expected {
        t.Errorf("greeting() = %q, want %q", result, expected)
    }
}

Step 3: Run the Tests

Execute the tests using Go's test tool:

bash
go test

Notes

• When using flag.Set in tests, it is assumed that command line flags have already been parsed via flag.Parse(), so in the test environment, you may need to call flag.Parse() again or ensure it is invoked before the test function executes.
• It is common practice to separate command line parsing code from business logic code to simplify unit testing. In the above example, the greeting() function is independent of command line flag parsing, which facilitates testing.

Through these steps, you can effectively unit test command line flags in Go programs.