github.com/googollee/clic@v0.1.5/set_test.go (about)

     1  package clic_test
     2  
     3  import (
     4  	"bytes"
     5  	"context"
     6  	"errors"
     7  	"flag"
     8  	"fmt"
     9  	"log"
    10  	"log/slog"
    11  	"strings"
    12  	"testing"
    13  	"unsafe"
    14  
    15  	"github.com/googollee/clic"
    16  	"github.com/googollee/clic/source"
    17  )
    18  
    19  func ExampleSet() {
    20  	// structs
    21  	type Database struct {
    22  		Driver string `clic:"driver,sqlite3,the driver of the database [sqlite3,mysql,postgres]"`
    23  		URL    string `clic:"url,./database.sqlite,the url of the database"`
    24  	}
    25  	type Log struct {
    26  		Level slog.Level `clic:"level,INFO,the level of the log [DEBUG,INFO,WARN,ERROR]"`
    27  	}
    28  	initLog := func(ctx context.Context, log *Log) error {
    29  		fmt.Println("set log level:", log.Level)
    30  		return nil
    31  	}
    32  
    33  	// set with sources
    34  	fset := flag.NewFlagSet("", flag.ExitOnError)
    35  	set := clic.NewSet(fset,
    36  		// The order means srouce priority, flag > config file > env
    37  		source.Flag(source.FlagSplitter(".")),
    38  		source.File(source.FilePathFlag("config"), source.FileFormat(source.JSON{})),
    39  		source.Env(source.EnvSplitter("_")),
    40  	)
    41  
    42  	// args
    43  	args := []string{"-log.level", "WARN", "-database.driver", "driver", "-database.url", "url", "other_cmd"}
    44  
    45  	// main code
    46  	ctx := context.Background()
    47  
    48  	var db Database
    49  	set.RegisterValue("database", &db)
    50  	set.RegisterCallback("log", initLog)
    51  
    52  	if err := set.Parse(ctx, args); err != nil {
    53  		log.Fatal("parse error:", err)
    54  	}
    55  
    56  	fmt.Println("database:", db)
    57  	fmt.Println("remain args:", fset.Args())
    58  
    59  	// Output:
    60  	// set log level: WARN
    61  	// database: {driver url}
    62  	// remain args: [other_cmd]
    63  }
    64  
    65  func ExampleSet_showHelp() {
    66  	// structs
    67  	type Database struct {
    68  		Driver string `clic:"driver,sqlite3,the driver of the database [sqlite3,mysql,postgres]"`
    69  		URL    string `clic:"url,./database.sqlite,the url of the database"`
    70  	}
    71  	type Log struct {
    72  		Level slog.Level `clic:"level,INFO,the level of the log [DEBUG,INFO,WARN,ERROR]"`
    73  	}
    74  	initLog := func(ctx context.Context, log *Log) error {
    75  		fmt.Println("set log level:", log.Level)
    76  		return nil
    77  	}
    78  
    79  	// set with sources
    80  	fset := flag.NewFlagSet("", flag.ContinueOnError)
    81  	var helpOutput bytes.Buffer
    82  	fset.SetOutput(&helpOutput)
    83  	set := clic.NewSet(fset,
    84  		// The order means srouce priority, flag > config file > env
    85  		source.Flag(source.FlagSplitter(".")),
    86  		source.File(source.FilePathFlag("config"), source.FileFormat(source.JSON{})),
    87  		source.Env(source.EnvSplitter("_")),
    88  	)
    89  
    90  	// args
    91  	args := []string{"-h"}
    92  
    93  	// main code
    94  	ctx := context.Background()
    95  
    96  	var db Database
    97  	set.RegisterValue("database", &db)
    98  	set.RegisterCallback("log", initLog)
    99  
   100  	if err := set.Parse(ctx, args); !errors.Is(err, flag.ErrHelp) {
   101  		log.Fatal("parse error:", err)
   102  	}
   103  
   104  	fmt.Println(strings.ReplaceAll(helpOutput.String(), "\t", "    "))
   105  	// Output:
   106  	// Usage:
   107  	//   -config string
   108  	//         the path of the config file
   109  	//   -database.driver value
   110  	//         the driver of the database [sqlite3,mysql,postgres] (default sqlite3)
   111  	//   -database.url value
   112  	//         the url of the database (default ./database.sqlite)
   113  	//   -log.level value
   114  	//         the level of the log [DEBUG,INFO,WARN,ERROR] (default INFO)
   115  }
   116  
   117  func TestInvalidRegister(t *testing.T) {
   118  	type C struct{ Int int }
   119  	var c C
   120  
   121  	type Invalid struct {
   122  		Int int `clic:"int,invalid,int"`
   123  	}
   124  	var invalid Invalid
   125  
   126  	var vInterface any
   127  	var vFunc func()
   128  	var vChan chan struct{}
   129  	var vUnsafePointer unsafe.Pointer
   130  	var vMap map[string]string
   131  
   132  	tests := []struct {
   133  		name  string
   134  		value any
   135  	}{
   136  		{"value", &c},
   137  		{"callback", &c},
   138  
   139  		{"nil_value", nil},
   140  		{"non_ptr", "abc"},
   141  		{"invalid_default", &invalid},
   142  		{"p_interface", &vInterface},
   143  		{"p_func", &vFunc},
   144  		{"p_chan", &vChan},
   145  		{"p_unsafe_pointer", &vUnsafePointer},
   146  		{"p_map", &vMap},
   147  	}
   148  
   149  	for _, tc := range tests {
   150  		t.Run(tc.name, func(t *testing.T) {
   151  			fset := flag.NewFlagSet("", flag.ContinueOnError)
   152  			set := clic.NewSet(fset)
   153  
   154  			set.RegisterValue("value", &c)
   155  			set.RegisterCallback("callback", func(context.Context, *C) error { return nil })
   156  
   157  			defer func() {
   158  				if r := recover(); r == nil {
   159  					t.Error("set.Register() passes, want a panic")
   160  				}
   161  			}()
   162  
   163  			set.RegisterValue(tc.name, tc.value)
   164  		})
   165  	}
   166  }
   167  
   168  func TestInvalidRegisterCallback(t *testing.T) {
   169  	type C struct{ Int int }
   170  	var c C
   171  
   172  	type Invalid struct {
   173  		Int int `clic:"int,invalid,int"`
   174  	}
   175  
   176  	tests := []struct {
   177  		name string
   178  		fn   any
   179  	}{
   180  		{"value", func(context.Context, *C) error { return nil }},
   181  		{"callback", func(context.Context, *C) error { return nil }},
   182  
   183  		{"nil_func", nil},
   184  		{"non_func", "str"},
   185  		{"invalid_default", func(context.Context, *Invalid) error { return nil }},
   186  		{"non_ptr", func(context.Context, int) error { return nil }},
   187  		{"non_ctx", func(int, *int) error { return nil }},
   188  		{"non_return", func(context.Context, *int) {}},
   189  		{"non_error", func(context.Context, *int) int { return 1 }},
   190  	}
   191  
   192  	for _, tc := range tests {
   193  		t.Run(tc.name, func(t *testing.T) {
   194  			fset := flag.NewFlagSet("", flag.ContinueOnError)
   195  			set := clic.NewSet(fset)
   196  
   197  			set.RegisterValue("value", &c)
   198  			set.RegisterCallback("callback", func(context.Context, *C) error { return nil })
   199  
   200  			defer func() {
   201  				if r := recover(); r == nil {
   202  					t.Error("set.RegisterCallback() passes, want a panic")
   203  				}
   204  			}()
   205  
   206  			set.RegisterCallback(tc.name, tc.fn)
   207  		})
   208  	}
   209  }
   210  
   211  func TestCallbackError(t *testing.T) {
   212  	wantErr := errors.New("error")
   213  
   214  	type C struct {
   215  		Int int `clic:"int,0,int"`
   216  	}
   217  	initC := func(context.Context, *C) error {
   218  		return wantErr
   219  	}
   220  
   221  	fset := flag.NewFlagSet("", flag.ContinueOnError)
   222  	set := clic.NewSet(fset)
   223  
   224  	set.RegisterCallback("callback", initC)
   225  
   226  	ctx := context.Background()
   227  	if err := set.Parse(ctx, []string{}); !errors.Is(err, wantErr) {
   228  		t.Errorf("set.Parse() = %v, want: %v", err, wantErr)
   229  	}
   230  }
   231  
   232  func TestInvalidValue(t *testing.T) {
   233  	type C struct {
   234  		Int int `clic:"int,0,int"`
   235  	}
   236  	var c C
   237  
   238  	fset := flag.NewFlagSet("", flag.ContinueOnError)
   239  	set := clic.NewSet(fset)
   240  
   241  	set.RegisterValue("value", &c)
   242  
   243  	t.Setenv("VALUE_INT", "invalid_int")
   244  
   245  	ctx := context.Background()
   246  	if err := set.Parse(ctx, []string{}); err == nil {
   247  		t.Errorf("set.Parse() = %v, want an error", err)
   248  	}
   249  }