github.com/googollee/clic@v0.1.5/source/file_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 TestFile(t *testing.T) { 12 tests := []struct { 13 name string 14 options []FileOption 15 wantHelp string 16 args []string 17 wantA1, wantA2, wantA3 string 18 }{ 19 { 20 name: "FromValue", 21 options: []FileOption{}, 22 wantHelp: " -config string\n \tthe path of the config file\n", 23 args: []string{"-config", "./testdata/valid.json"}, 24 wantA1: "123", 25 wantA2: "abc", 26 wantA3: "xyz", 27 }, 28 { 29 name: "FromDefault", 30 options: []FileOption{}, 31 wantHelp: " -config string\n \tthe path of the config file\n", 32 args: []string{"-config", "./testdata/empty.json"}, 33 wantA1: "a1", 34 wantA2: "a2", 35 wantA3: "a3", 36 }, 37 { 38 name: "WithFlagFormat", 39 options: []FileOption{FileFormat(JSON{}), FilePathFlag("c")}, 40 wantHelp: " -c string\n \tthe path of the config file\n", 41 args: []string{"-c", "./testdata/valid.json"}, 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 src := File(tc.options...) 52 a1, a2, a3 = "a1", "a2", "a3" 53 54 if err := src.Register(fset, fields); err != nil { 55 t.Fatalf("src.Prepare(fields) returns error: %v", err) 56 } 57 58 var output bytes.Buffer 59 fset.SetOutput(&output) 60 fset.PrintDefaults() 61 62 if diff := cmp.Diff(output.String(), tc.wantHelp); diff != "" { 63 t.Errorf("output diff: (-got, +want)\n%s", diff) 64 } 65 66 if err := fset.Parse(tc.args); err != nil { 67 t.Fatalf("fset.Parse() error: %v", err) 68 } 69 70 if err := src.Parse(t.Context(), tc.args); err != nil { 71 t.Fatalf("src.Parse() should return no error, which is not: %v", err) 72 } 73 74 if got, want := a1, tc.wantA1; got != want { 75 t.Errorf("after src.Parse(), a1 = %q, want: %q", got, want) 76 } 77 if got, want := a2, tc.wantA2; got != want { 78 t.Errorf("after src.Parse(), a2 = %q, want: %q", got, want) 79 } 80 if got, want := a3, tc.wantA3; got != want { 81 t.Errorf("after src.Parse(), a3 = %q, want: %q", got, want) 82 } 83 }) 84 } 85 86 t.Run("InvalidFile", func(t *testing.T) { 87 fset := flag.NewFlagSet("", flag.ContinueOnError) 88 src := File() 89 90 var output bytes.Buffer 91 fset.SetOutput(&output) 92 t.Logf("output:\n%s", output.String()) 93 94 if err := src.Register(fset, fields); err != nil { 95 t.Fatalf("src.Prepare(fields) returns error: %v", err) 96 } 97 98 args := []string{"-config", "testdata/not_exist.json"} 99 if err := fset.Parse(args); err != nil { 100 t.Fatalf("fset.Parse() error: %v", err) 101 } 102 103 if err := src.Parse(t.Context(), args); err == nil { 104 t.Fatalf("src.Parse() error: %v, want an error", err) 105 } 106 }) 107 108 t.Run("EmptyConfigFile", func(t *testing.T) { 109 fset := flag.NewFlagSet("", flag.ContinueOnError) 110 src := File() 111 112 if err := src.Register(fset, fields); err != nil { 113 t.Fatalf("src.Prepare(fields) returns error: %v", err) 114 } 115 116 args := []string{"-config", ""} 117 if err := fset.Parse(args); err != nil { 118 t.Fatalf("fset.Parse() error: %v", err) 119 } 120 121 if err := src.Parse(t.Context(), args); err != nil { 122 t.Fatalf("src.Parse() = %v, want no error", err) 123 } 124 }) 125 126 t.Run("InvalidFlag", func(t *testing.T) { 127 fset := flag.NewFlagSet("", flag.ContinueOnError) 128 src := File() 129 130 if err := src.Register(fset, fields); err != nil { 131 t.Fatalf("src.Prepare(fields) returns error: %v", err) 132 } 133 134 args := []string{"-nonexist_flag", ""} 135 if err := fset.Parse(args); err == nil { 136 t.Fatalf("fset.Parse() = nil, want an error") 137 } 138 139 if err := src.Parse(t.Context(), args); err != nil { 140 t.Fatalf("src.Parse() = %v, want no error", err) 141 } 142 }) 143 } 144 145 func TestFileError(t *testing.T) { 146 tests := []struct { 147 name string 148 options []FileOption 149 }{ 150 {"EmptyCodec", []FileOption{FileFormat(nil)}}, 151 {"EmptyPathFlag", []FileOption{FilePathFlag("")}}, 152 } 153 154 for _, tc := range tests { 155 t.Run(tc.name, func(t *testing.T) { 156 fset := flag.NewFlagSet("", flag.ContinueOnError) 157 src := File(tc.options...) 158 err := src.Error() 159 if err == nil { 160 t.Errorf("src().Error() want an error, which is not") 161 } 162 163 errPrepare := src.Register(fset, fields) 164 if err != errPrepare { 165 t.Errorf("src().Prepare() = %v, src().Error() = %v, they should be same", errPrepare, err) 166 } 167 168 args := []string{} 169 if err := fset.Parse(args); err != nil { 170 t.Fatalf("fset.Parse() error: %v", err) 171 } 172 173 errParse := src.Parse(t.Context(), args) 174 if err != errPrepare { 175 t.Errorf("src().Parse() = %v, src().Error() = %v, they should be same", errParse, err) 176 } 177 }) 178 } 179 }