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 }