github.com/googollee/clic@v0.1.5/source/flag_test.go (about) 1 package source 2 3 import ( 4 "bytes" 5 "flag" 6 "testing" 7 8 "github.com/google/go-cmp/cmp" 9 ) 10 11 func TestFlag(t *testing.T) { 12 tests := []struct { 13 name string 14 options []FlagOption 15 wantHelp string 16 args []string 17 wantA1, wantA2, wantA3 string 18 }{ 19 { 20 name: "FromValue", 21 options: []FlagOption{}, 22 wantHelp: " -a1 value\n \ta1 (default a1)\n -l1.a2 value\n \ta2 (default a2)\n -l2.l3.a3 value\n \ta3 (default a3)\n", 23 args: []string{"-a1", "123", "-l1.a2", "abc", "-l2.l3.a3", "xyz"}, 24 wantA1: "123", 25 wantA2: "abc", 26 wantA3: "xyz", 27 }, 28 { 29 name: "FromDefault", 30 options: []FlagOption{}, 31 wantHelp: " -a1 value\n \ta1 (default a1)\n -l1.a2 value\n \ta2 (default a2)\n -l2.l3.a3 value\n \ta3 (default a3)\n", 32 args: []string{}, 33 wantA1: "a1", 34 wantA2: "a2", 35 wantA3: "a3", 36 }, 37 { 38 name: "WithSplitter", 39 options: []FlagOption{FlagSplitter("_")}, 40 wantHelp: " -a1 value\n \ta1 (default a1)\n -l1_a2 value\n \ta2 (default a2)\n -l2_l3_a3 value\n \ta3 (default a3)\n", 41 args: []string{"-a1", "123", "-l1_a2", "abc", "-l2_l3_a3", "xyz"}, 42 wantA1: "123", 43 wantA2: "abc", 44 wantA3: "xyz", 45 }, 46 } 47 48 for _, tc := range tests { 49 t.Run(tc.name, func(t *testing.T) { 50 fset := flag.NewFlagSet("", flag.ContinueOnError) 51 52 src := Flag(tc.options...) 53 a1, a2, a3 = "a1", "a2", "a3" 54 55 if err := src.Register(fset, fields); err != nil { 56 t.Fatalf("src.Prepare(fields) returns error: %v", err) 57 } 58 59 var output bytes.Buffer 60 fset.SetOutput(&output) 61 fset.PrintDefaults() 62 63 if diff := cmp.Diff(output.String(), tc.wantHelp); diff != "" { 64 t.Errorf("output diff: (-got, +want)\n%s", diff) 65 } 66 67 if err := fset.Parse(tc.args); err != nil { 68 t.Fatalf("fset.Parse() error: %v", err) 69 } 70 71 if err := src.Parse(t.Context(), tc.args); err != nil { 72 t.Fatalf("src.Parse() should return no error, which is not: %v", err) 73 } 74 75 if got, want := a1, tc.wantA1; got != want { 76 t.Errorf("after src.Parse(), a1 = %q, want: %q", got, want) 77 } 78 if got, want := a2, tc.wantA2; got != want { 79 t.Errorf("after src.Parse(), a2 = %q, want: %q", got, want) 80 } 81 if got, want := a3, tc.wantA3; got != want { 82 t.Errorf("after src.Parse(), a3 = %q, want: %q", got, want) 83 } 84 }) 85 } 86 87 t.Run("InvalidValue", func(t *testing.T) { 88 fset := flag.NewFlagSet("", flag.ContinueOnError) 89 src := Flag() 90 91 var output bytes.Buffer 92 fset.SetOutput(&output) 93 t.Logf("output:\n%s", output.String()) 94 95 if err := src.Register(fset, fields); err != nil { 96 t.Fatalf("src.Prepare(fields) returns error: %v", err) 97 } 98 99 args := []string{"-flag.a", "123"} 100 if err := fset.Parse(args); err == nil { 101 t.Fatalf("fset.Parse() is nil, want an error") 102 } 103 104 if err := src.Parse(t.Context(), args); err == nil { 105 t.Fatalf("src.Parse() is nil, want an error") 106 } 107 }) 108 } 109 110 func TestFlagError(t *testing.T) { 111 tests := []struct { 112 name string 113 options []FlagOption 114 }{ 115 {"EmptySplitter", []FlagOption{FlagSplitter("")}}, 116 } 117 118 for _, tc := range tests { 119 t.Run(tc.name, func(t *testing.T) { 120 fset := flag.NewFlagSet("", flag.ContinueOnError) 121 src := Flag(tc.options...) 122 err := src.Error() 123 if err == nil { 124 t.Errorf("src().Error() want an error, which is not") 125 } 126 127 if errRegister := src.Register(fset, fields); err != errRegister { 128 t.Errorf("src().Prepare() = %v, src().Error() = %v, they should be same", errRegister, err) 129 } 130 131 args := []string{} 132 if err := fset.Parse(args); err != nil { 133 t.Fatalf("fset.Parse() error: %v", err) 134 } 135 136 if errParse := src.Parse(t.Context(), args); err != errParse { 137 t.Errorf("src().Parse() = %v, src().Error() = %v, they should be same", errParse, err) 138 } 139 }) 140 } 141 }