-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathparameterstore_test.go
153 lines (137 loc) · 6.1 KB
/
parameterstore_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
package parameterstore
import (
"errors"
"testing"
"github.com/stretchr/testify/assert"
)
const tag = "psTag"
const errorTag = "psErrorTag"
const privateTag = "psPrivateTag"
const intParsingErrorTag = "psIntParsingErrorTag"
const uintParsingErrorTag = "psUintParsingErrorTag"
const floatParsingErrorTag = "psFloatParsingErrorTag"
const boolParsingErrorTag = "psBoolParsingErrorTag"
const notSupportedTypeTag = "psNotSupportedTypeTag"
type paramsGroup struct {
IntParam int `psTag:"int_param"`
IntParamBase2 int `psTag:"int_param_base2"`
IntParamBase8 int `psTag:"int_param_base8"`
IntParamBase16 int `psTag:"int_param_base16"`
Int8Param int8 `psTag:"int8_param"`
Int16Param int16 `psTag:"int16_param"`
Int32Param int32 `psTag:"int32_param"`
Int64Param int64 `psTag:"int64_param"`
UintParam uint `psTag:"uint_param"`
Uint8Param uint8 `psTag:"uint8_param"`
Uint16Param uint16 `psTag:"uint16_param"`
Uint32Param uint32 `psTag:"uint32_param"`
Uint64Param uint64 `psTag:"uint64_param"`
Float32Param float32 `psTag:"float32_param"`
Float64Param float64 `psTag:"float64_param"`
StringParam string `psTag:"string_param"`
BoolParam bool `psTag:"bool_param"`
ErrorParam int `psErrorTag:"error"`
priveParam int `psPrivateTag:"private_param"`
IntParsingErrorParam int `psIntParsingErrorTag:"int_param_parsing_error"`
UintParsingErrorParam uint `psUintParsingErrorTag:"uint_param_parsing_error"`
FloatParsingErrorParam float32 `psFloatParsingErrorTag:"float_param_parsing_error"`
BoolParsingErrorParam bool `psBoolParsingErrorTag:"bool_param_parsing_error"`
MapParam map[string]string `psNotSupportedTypeTag:"type_not_supported"`
}
type parameterStore struct{}
func (ps parameterStore) GetParams(paramNames []string) (map[string]string, error) {
p := map[string]string{
"int_param": "-2147483648",
"int_param_base2": "-0b10000000000000000000000000000000",
"int_param_base8": "-0o20000000000",
"int_param_base16": "-0x80000000",
"int8_param": "-127",
"int16_param": "-32768",
"int32_param": "-2147483648",
"int64_param": "-9223372036854775808",
"uint_param": "18446744073709551615",
"uint8_param": "255",
"uint16_param": "65535",
"uint32_param": "4294967295",
"uint64_param": "18446744073709551615",
"float32_param": "0.123456789121212",
"float64_param": "0.123456789121212121212",
"string_param": "hello world!",
"bool_param": "true",
"int_param_parsing_error": "error",
"uint_param_parsing_error": "error",
"float_param_parsing_error": "error",
"bool_param_parsing_error": "error",
}
params := map[string]string{}
for _, key := range paramNames {
if key == "error" {
return map[string]string{}, errors.New("cannot get parameters")
}
params[key] = p[key]
}
return params, nil
}
func TestParameterStore(t *testing.T) {
ps := parameterStore{}
pg := paramsGroup{priveParam: 0}
err := LoadParamsGroup(&pg, ps, tag)
if assert.Nil(t, err) {
assert.Equal(t, pg.IntParam, -2147483648)
assert.Equal(t, pg.IntParamBase2, -0b10000000000000000000000000000000)
assert.Equal(t, pg.IntParamBase8, -0o20000000000)
assert.Equal(t, pg.IntParamBase16, -0x80000000)
assert.Equal(t, pg.Int8Param, int8(-127))
assert.Equal(t, pg.Int16Param, int16(-32768))
assert.Equal(t, pg.Int32Param, int32(-2147483648))
assert.Equal(t, pg.Int64Param, int64(-9223372036854775808))
assert.Equal(t, pg.UintParam, uint(18446744073709551615))
assert.Equal(t, pg.Uint8Param, uint8(255))
assert.Equal(t, pg.Uint16Param, uint16(65535))
assert.Equal(t, pg.Uint32Param, uint32(4294967295))
assert.Equal(t, pg.Uint64Param, uint64(18446744073709551615))
assert.Equal(t, pg.Float32Param, float32(0.123456789121212))
assert.Equal(t, pg.Float64Param, float64(0.123456789121212121212))
assert.Equal(t, pg.StringParam, "hello world!")
assert.Equal(t, pg.BoolParam, true)
}
var strPointer *string
str := "hello world!"
strPointer = &str
err = LoadParamsGroup(strPointer, ps, tag)
if assert.Error(t, err) {
assert.Equal(t, ErrParamsGroupInvalidType.Error(), err.Error())
}
err = LoadParamsGroup(*strPointer, ps, tag)
if assert.Error(t, err) {
assert.Equal(t, ErrParamsGroupInvalidType.Error(), err.Error())
}
err = LoadParamsGroup(&pg, ps, errorTag)
if assert.Error(t, err) {
assert.Equal(t, "error executing ParameterStore.GetParams: cannot get parameters", err.Error())
}
err = LoadParamsGroup(&pg, ps, privateTag)
if assert.Error(t, err) {
assert.Equal(t, "field priveParam cannot be set", err.Error())
}
err = LoadParamsGroup(&pg, ps, intParsingErrorTag)
if assert.Error(t, err) {
assert.Equal(t, "cannot parse parameter int_param_parsing_error to field IntParsingErrorParam of type int", err.Error())
}
err = LoadParamsGroup(&pg, ps, uintParsingErrorTag)
if assert.Error(t, err) {
assert.Equal(t, "cannot parse parameter uint_param_parsing_error to field UintParsingErrorParam of type uint", err.Error())
}
err = LoadParamsGroup(&pg, ps, floatParsingErrorTag)
if assert.Error(t, err) {
assert.Equal(t, "cannot parse parameter float_param_parsing_error to field FloatParsingErrorParam of type float32", err.Error())
}
err = LoadParamsGroup(&pg, ps, boolParsingErrorTag)
if assert.Error(t, err) {
assert.Equal(t, "cannot parse parameter bool_param_parsing_error to field BoolParsingErrorParam of type bool", err.Error())
}
err = LoadParamsGroup(&pg, ps, notSupportedTypeTag)
if assert.Error(t, err) {
assert.Equal(t, "type map for field MapParam not supported", err.Error())
}
}