Skip to content

Commit 0fba88a

Browse files
BoRuDarBoRuDar
authored
Merge dev (#40)
* Fix wrapcheck linter errors * Fix errcheck linter errors + prettify tests * Fix jsonProvider coverage * Fix flagProvider coverage
1 parent 0465e7d commit 0fba88a

8 files changed

+122
-78
lines changed

‎configurator_test.go

+1-1
Original file line numberDiff line numberDiff line change
@@ -210,7 +210,7 @@ func TestConfigurator_NameCollision(t *testing.T) {
210210

211211
func TestConfigurator_FailedProvider(t *testing.T) {
212212
err := New(&struct{}{}, NewJSONFileProvider("doesn't exist")).InitValues()
213-
assert(t, err.Error(), "cannot init [JSONFileProvider] provider: open doesn't exist: no such file or directory")
213+
assert(t, "cannot init [JSONFileProvider] provider: JSONFileProvider.Init: open doesn't exist: no such file or directory", err.Error())
214214
}
215215

216216
func Test_FromEnvAndDefault(t *testing.T) {

‎fieldSetter.go

+2-2
Original file line numberDiff line numberDiff line change
@@ -19,11 +19,11 @@ type FieldSetter interface {
1919
func SetField(field reflect.StructField, val reflect.Value, valStr string) error {
2020
if val.CanInterface() {
2121
if fs, ok := val.Addr().Interface().(FieldSetter); ok {
22-
return fs.SetField(field, val, valStr)
22+
return fs.SetField(field, val, valStr) // nolint:wrapcheck
2323
}
2424

2525
if fs, ok := val.Interface().(FieldSetter); ok {
26-
return fs.SetField(field, val, valStr)
26+
return fs.SetField(field, val, valStr) // nolint:wrapcheck
2727
}
2828
}
2929

‎fieldStetter_test.go

+63-57
Original file line numberDiff line numberDiff line change
@@ -17,35 +17,35 @@ func TestSetValue_String(t *testing.T) {
1717
fieldType := reflect.TypeOf(&testStr).Elem()
1818
fieldVal := reflect.ValueOf(&testStr).Elem()
1919
testValue := "test_val1"
20+
expectedValue := "test_val1"
2021

21-
setValue(fieldType, fieldVal, testValue)
22-
if !reflect.DeepEqual(fieldVal.String(), testStr) {
23-
t.Fatalf("\nexpected result: [%s] \nbut got: [%s]", testValue, testStr)
24-
}
22+
err := setValue(fieldType, fieldVal, testValue)
23+
assert(t, nil, err)
24+
assert(t, expectedValue, fieldVal.String())
2525
}
2626

2727
func TestSetValue_Int8(t *testing.T) {
2828
var testInt8 int8
2929
fieldType := reflect.TypeOf(&testInt8).Elem()
3030
fieldVal := reflect.ValueOf(&testInt8).Elem()
3131
testValue := "42"
32+
expectedValue := int64(42)
3233

33-
setValue(fieldType, fieldVal, testValue)
34-
if fieldVal.Int() != int64(testInt8) {
35-
t.Fatalf("\nexpected result: [%s] \nbut got: [%d]", testValue, testInt8)
36-
}
34+
err := setValue(fieldType, fieldVal, testValue)
35+
assert(t, nil, err)
36+
assert(t, expectedValue, fieldVal.Int())
3737
}
3838

3939
func TestSetValue_Uint16(t *testing.T) {
4040
var testUint16 uint16
4141
fieldType := reflect.TypeOf(&testUint16).Elem()
4242
fieldVal := reflect.ValueOf(&testUint16).Elem()
4343
testValue := "42"
44+
expectedValue := uint64(42)
4445

45-
setValue(fieldType, fieldVal, testValue)
46-
if fieldVal.Uint() != uint64(testUint16) {
47-
t.Fatalf("\nexpected result: [%s] \nbut got: [%d]", testValue, testUint16)
48-
}
46+
err := setValue(fieldType, fieldVal, testValue)
47+
assert(t, nil, err)
48+
assert(t, expectedValue, fieldVal.Uint())
4949
}
5050

5151
func TestSetValue_Int64(t *testing.T) {
@@ -73,28 +73,28 @@ func TestSetValue_Duration(t *testing.T) {
7373
assert(t, expectedVal, time.Duration(fieldVal.Int()))
7474
}
7575

76-
func TestSetValue_Float32(t *testing.T) {
76+
func TestSetValue_Float(t *testing.T) {
7777
var testFloat32 float32
7878
fieldType := reflect.TypeOf(&testFloat32).Elem()
7979
fieldVal := reflect.ValueOf(&testFloat32).Elem()
8080
testValue := "42"
81+
expectedValue := float64(42)
8182

82-
setValue(fieldType, fieldVal, testValue)
83-
if fieldVal.Float() != float64(testFloat32) {
84-
t.Fatalf("\nexpected result: [%s] \nbut got: [%f]", testValue, testFloat32)
85-
}
83+
err := setValue(fieldType, fieldVal, testValue)
84+
assert(t, nil, err)
85+
assert(t, expectedValue, fieldVal.Float())
8686
}
8787

8888
func TestSetValue_Bool(t *testing.T) {
8989
var testBool bool
9090
fieldType := reflect.TypeOf(&testBool).Elem()
9191
fieldVal := reflect.ValueOf(&testBool).Elem()
9292
testValue := "true"
93+
expectedValue := true
9394

94-
setValue(fieldType, fieldVal, testValue)
95-
if fieldVal.Bool() != true {
96-
t.Fatalf("\nexpected result: [%s] \nbut got: [%v]", testValue, testBool)
97-
}
95+
err := setValue(fieldType, fieldVal, testValue)
96+
assert(t, nil, err)
97+
assert(t, expectedValue, fieldVal.Bool())
9898
}
9999

100100
// SetPtr tests
@@ -122,7 +122,8 @@ func TestSetPtrValue_Ints(t *testing.T) {
122122
fieldType := reflect.TypeOf(&testInt).Elem()
123123
fieldVal := reflect.ValueOf(&testInt).Elem()
124124

125-
setPtrValue(fieldType, fieldVal, testValue)
125+
err := setPtrValue(fieldType, fieldVal, testValue)
126+
assert(t, nil, err)
126127
if testValue != strconv.FormatInt(int64(*testInt), 10) {
127128
t.Errorf("\nexpected result: [%s] \nbut got: [%v]", testValue, testInt)
128129
}
@@ -134,7 +135,8 @@ func TestSetPtrValue_Ints(t *testing.T) {
134135
fieldType := reflect.TypeOf(&testInt8).Elem()
135136
fieldVal := reflect.ValueOf(&testInt8).Elem()
136137

137-
setPtrValue(fieldType, fieldVal, testValue)
138+
err := setPtrValue(fieldType, fieldVal, testValue)
139+
assert(t, nil, err)
138140
if testValue != strconv.FormatInt(int64(*testInt8), 10) {
139141
t.Errorf("\nexpected result: [%s] \nbut got: [%v]", testValue, testInt8)
140142
}
@@ -146,7 +148,8 @@ func TestSetPtrValue_Ints(t *testing.T) {
146148
fieldType := reflect.TypeOf(&testInt16).Elem()
147149
fieldVal := reflect.ValueOf(&testInt16).Elem()
148150

149-
setPtrValue(fieldType, fieldVal, testValue)
151+
err := setPtrValue(fieldType, fieldVal, testValue)
152+
assert(t, nil, err)
150153
if testValue != strconv.FormatInt(int64(*testInt16), 10) {
151154
t.Errorf("\nexpected result: [%s] \nbut got: [%v]", testValue, testInt16)
152155
}
@@ -158,7 +161,8 @@ func TestSetPtrValue_Ints(t *testing.T) {
158161
fieldType := reflect.TypeOf(&testInt32).Elem()
159162
fieldVal := reflect.ValueOf(&testInt32).Elem()
160163

161-
setPtrValue(fieldType, fieldVal, testValue)
164+
err := setPtrValue(fieldType, fieldVal, testValue)
165+
assert(t, nil, err)
162166
if testValue != strconv.FormatInt(int64(*testInt32), 10) {
163167
t.Errorf("\nexpected result: [%s] \nbut got: [%v]", testValue, testInt32)
164168
}
@@ -170,7 +174,8 @@ func TestSetPtrValue_Ints(t *testing.T) {
170174
fieldType := reflect.TypeOf(&testInt64).Elem()
171175
fieldVal := reflect.ValueOf(&testInt64).Elem()
172176

173-
setPtrValue(fieldType, fieldVal, testValue)
177+
err := setPtrValue(fieldType, fieldVal, testValue)
178+
assert(t, nil, err)
174179
if testValue != strconv.FormatInt(*testInt64, 10) {
175180
t.Errorf("\nexpected result: [%s] \nbut got: [%v]", testValue, testInt64)
176181
}
@@ -186,7 +191,8 @@ func TestSetPtrValue_Uints(t *testing.T) {
186191
fieldType := reflect.TypeOf(&testUint).Elem()
187192
fieldVal := reflect.ValueOf(&testUint).Elem()
188193

189-
setPtrValue(fieldType, fieldVal, testValue)
194+
err := setPtrValue(fieldType, fieldVal, testValue)
195+
assert(t, nil, err)
190196
if testValue != strconv.FormatUint(uint64(*testUint), 10) {
191197
t.Errorf("\nexpected result: [%s] \nbut got: [%v]", testValue, testUint)
192198
}
@@ -198,7 +204,8 @@ func TestSetPtrValue_Uints(t *testing.T) {
198204
fieldType := reflect.TypeOf(&testUint8).Elem()
199205
fieldVal := reflect.ValueOf(&testUint8).Elem()
200206

201-
setPtrValue(fieldType, fieldVal, testValue)
207+
err := setPtrValue(fieldType, fieldVal, testValue)
208+
assert(t, nil, err)
202209
if testValue != strconv.FormatUint(uint64(*testUint8), 10) {
203210
t.Errorf("\nexpected result: [%s] \nbut got: [%v]", testValue, testUint8)
204211
}
@@ -210,7 +217,8 @@ func TestSetPtrValue_Uints(t *testing.T) {
210217
fieldType := reflect.TypeOf(&testUint16).Elem()
211218
fieldVal := reflect.ValueOf(&testUint16).Elem()
212219

213-
setPtrValue(fieldType, fieldVal, testValue)
220+
err := setPtrValue(fieldType, fieldVal, testValue)
221+
assert(t, nil, err)
214222
if testValue != strconv.FormatUint(uint64(*testUint16), 10) {
215223
t.Errorf("\nexpected result: [%s] \nbut got: [%v]", testValue, testUint16)
216224
}
@@ -222,7 +230,8 @@ func TestSetPtrValue_Uints(t *testing.T) {
222230
fieldType := reflect.TypeOf(&testUint32).Elem()
223231
fieldVal := reflect.ValueOf(&testUint32).Elem()
224232

225-
setPtrValue(fieldType, fieldVal, testValue)
233+
err := setPtrValue(fieldType, fieldVal, testValue)
234+
assert(t, nil, err)
226235
if testValue != strconv.FormatUint(uint64(*testUint32), 10) {
227236
t.Errorf("\nexpected result: [%s] \nbut got: [%v]", testValue, testUint32)
228237
}
@@ -234,7 +243,8 @@ func TestSetPtrValue_Uints(t *testing.T) {
234243
fieldType := reflect.TypeOf(&testUint64).Elem()
235244
fieldVal := reflect.ValueOf(&testUint64).Elem()
236245

237-
setPtrValue(fieldType, fieldVal, testValue)
246+
err := setPtrValue(fieldType, fieldVal, testValue)
247+
assert(t, nil, err)
238248
if testValue != strconv.FormatUint(*testUint64, 10) {
239249
t.Errorf("\nexpected result: [%s] \nbut got: [%v]", testValue, testUint64)
240250
}
@@ -250,7 +260,8 @@ func TestSetPtrValue_Floats(t *testing.T) {
250260
fieldType := reflect.TypeOf(&testFloat32).Elem()
251261
fieldVal := reflect.ValueOf(&testFloat32).Elem()
252262

253-
setPtrValue(fieldType, fieldVal, testValue)
263+
err := setPtrValue(fieldType, fieldVal, testValue)
264+
assert(t, nil, err)
254265

255266
gotStr := strconv.FormatFloat(float64(*testFloat32), 'f', 1, 64)
256267
if testValue != gotStr {
@@ -264,7 +275,8 @@ func TestSetPtrValue_Floats(t *testing.T) {
264275
fieldType := reflect.TypeOf(&testFloat32).Elem()
265276
fieldVal := reflect.ValueOf(&testFloat32).Elem()
266277

267-
setPtrValue(fieldType, fieldVal, testValue)
278+
err := setPtrValue(fieldType, fieldVal, testValue)
279+
assert(t, nil, err)
268280

269281
gotStr := strconv.FormatFloat(*testFloat32, 'f', 1, 64)
270282
if testValue != gotStr {
@@ -296,10 +308,9 @@ func TestSetValue_StringSlice(t *testing.T) {
296308
testValue := "test_val1;test_val2"
297309
expected := []string{"test_val1", "test_val2"}
298310

299-
setValue(fieldType, fieldVal, testValue)
300-
if !reflect.DeepEqual(expected, fieldVal.Interface()) {
301-
t.Fatalf("\nexpected result: %+v \nbut got: %+v", expected, fieldVal.Interface())
302-
}
311+
err := setValue(fieldType, fieldVal, testValue)
312+
assert(t, nil, err)
313+
assert(t, expected, fieldVal.Interface())
303314
}
304315

305316
func TestSetValue_StringSliceSingleElement(t *testing.T) {
@@ -309,10 +320,9 @@ func TestSetValue_StringSliceSingleElement(t *testing.T) {
309320
testValue := "test_val1"
310321
expected := []string{"test_val1"}
311322

312-
setValue(fieldType, fieldVal, testValue)
313-
if !reflect.DeepEqual(expected, fieldVal.Interface()) {
314-
t.Fatalf("\nexpected result: %+v \nbut got: %+v", expected, fieldVal.Interface())
315-
}
323+
err := setValue(fieldType, fieldVal, testValue)
324+
assert(t, nil, err)
325+
assert(t, expected, fieldVal.Interface())
316326
}
317327

318328
func TestSetValue_IntSlice(t *testing.T) {
@@ -322,10 +332,9 @@ func TestSetValue_IntSlice(t *testing.T) {
322332
testValue := "1 ; 2 "
323333
expected := []int{1, 2}
324334

325-
setValue(fieldType, fieldVal, testValue)
326-
if !reflect.DeepEqual(expected, fieldVal.Interface()) {
327-
t.Fatalf("\nexpected result: %+v \nbut got: %+v", expected, fieldVal.Interface())
328-
}
335+
err := setValue(fieldType, fieldVal, testValue)
336+
assert(t, nil, err)
337+
assert(t, expected, fieldVal.Interface())
329338
}
330339

331340
func TestSetValue_UintSlice(t *testing.T) {
@@ -337,10 +346,9 @@ func TestSetValue_UintSlice(t *testing.T) {
337346
expected = []uint{1, 2}
338347
)
339348

340-
setValue(fieldType, fieldVal, testValue)
341-
if !reflect.DeepEqual(expected, fieldVal.Interface()) {
342-
t.Fatalf("\nexpected result: %+v \nbut got: %+v", expected, fieldVal.Interface())
343-
}
349+
err := setValue(fieldType, fieldVal, testValue)
350+
assert(t, nil, err)
351+
assert(t, expected, fieldVal.Interface())
344352
}
345353

346354
func TestSetValue_FloatSlice(t *testing.T) {
@@ -350,10 +358,9 @@ func TestSetValue_FloatSlice(t *testing.T) {
350358
testValue := "1;2.0"
351359
expected := []float64{1, 2}
352360

353-
setValue(fieldType, fieldVal, testValue)
354-
if !reflect.DeepEqual(expected, fieldVal.Interface()) {
355-
t.Fatalf("\nexpected result: %+v \nbut got: %+v", expected, fieldVal.Interface())
356-
}
361+
err := setValue(fieldType, fieldVal, testValue)
362+
assert(t, nil, err)
363+
assert(t, expected, fieldVal.Interface())
357364
}
358365

359366
func TestSetValue_BoolSlice(t *testing.T) {
@@ -363,10 +370,9 @@ func TestSetValue_BoolSlice(t *testing.T) {
363370
testValue := "true; false; "
364371
expected := []bool{true, false}
365372

366-
setValue(fieldType, fieldVal, testValue)
367-
if !reflect.DeepEqual(expected, fieldVal.Interface()) {
368-
t.Fatalf("\nexpected result: %+v \nbut got: %+v", expected, fieldVal.Interface())
369-
}
373+
err := setValue(fieldType, fieldVal, testValue)
374+
assert(t, nil, err)
375+
assert(t, expected, fieldVal.Interface())
370376
}
371377

372378
func TestSetValue_EmptySlice(t *testing.T) {

‎flagProvider.go

+10-5
Original file line numberDiff line numberDiff line change
@@ -36,12 +36,16 @@ func (flagProvider) Name() string {
3636
return FlagProviderName
3737
}
3838

39-
func (fp flagProvider) Init(ptr any) (err error) {
39+
func (fp flagProvider) Init(ptr any) error {
4040
if err := fp.initFlagProvider(ptr); err != nil {
4141
return err
4242
}
4343

44-
return fp.flagSet.Parse(os.Args[1:])
44+
if err := fp.flagSet.Parse(os.Args[1:]); err != nil {
45+
return fmt.Errorf("%s.Init: %w", FlagProviderName, err)
46+
}
47+
48+
return nil
4549
}
4650

4751
// FlagSet is the part of flag.FlagSet that NewFlagProvider uses
@@ -70,12 +74,13 @@ type flagData struct {
7074
usage string
7175
}
7276

73-
func (fp flagProvider) initFlagProvider(i any) error {
77+
func (fp flagProvider) initFlagProvider(ptr any) error {
7478
var (
75-
t = reflect.TypeOf(i)
76-
v = reflect.ValueOf(i)
79+
t = reflect.TypeOf(ptr)
80+
v = reflect.ValueOf(ptr)
7781
)
7882

83+
// nolint:exhaustive
7984
switch t.Kind() {
8085
case reflect.Ptr:
8186
t = t.Elem()

‎flagProvider_test.go

+27
Original file line numberDiff line numberDiff line change
@@ -234,3 +234,30 @@ func TestFlagProvider_Errors(t *testing.T) {
234234
})
235235
}
236236
}
237+
238+
type _flagSetMock struct {
239+
err error
240+
result string
241+
}
242+
243+
func (f *_flagSetMock) Parse(arguments []string) error {
244+
return f.err
245+
}
246+
247+
func (f *_flagSetMock) String(name string, value string, usage string) *string {
248+
return &f.result
249+
}
250+
251+
func TestFlagProvider_CustomFlagSetError(t *testing.T) {
252+
type testStruct struct {
253+
Name string `flag:"flag_name9||Description"`
254+
}
255+
testObj := testStruct{}
256+
os.Args = []string{""}
257+
258+
fs := &_flagSetMock{result: "", err: fmt.Errorf("flagSetMock error")}
259+
provider := NewFlagProvider(WithFlagSet(fs))
260+
261+
err := provider.Init(&testObj)
262+
assert(t, "FlagProvider.Init: flagSetMock error", err.Error())
263+
}

0 commit comments

Comments
 (0)