1 package types
2
3 import (
4 "encoding/json"
5 "testing"
6
7 "github.com/stretchr/testify/assert"
8
9 "edge-infra.dev/pkg/sds/emergencyaccess/msgdata"
10 )
11
12 var (
13 defaultReqMsgID = "abcd"
14 defaultComID = "efgh"
15 defaultResponseDataJSON = []byte(`
16 {
17 "type": "Output",
18 "exitCode": 0,
19 "output": "hello\n",
20 "timestamp": "01-01-2023 00:00:00",
21 "duration": 0.1
22 }`)
23 defaultAttrMap = map[string]string{
24 "bannerId": "banner",
25 "storeId": "store",
26 "terminalId": "terminal",
27 "sessionId": "orderingKey",
28 "identity": "identity",
29 "version": "1.0",
30 "signature": "signature",
31 "request-message-uuid": defaultReqMsgID,
32 "commandId": defaultComID,
33 }
34 )
35
36 var (
37 validTarget = Target{
38 Projectid: "project",
39 Bannerid: "banner",
40 Storeid: "store",
41 Terminalid: "terminal",
42 }
43 defaultResponseData = msgdata.ResponseData{
44 Type: "Output",
45 ExitCode: 0,
46 Output: "hello\n",
47 TimeStamp: "01-01-2023 00:00:00",
48 Duration: 0.1,
49 }
50 defaultResponseAttr = msgdata.ResponseAttributes{
51 GeneralAttributes: msgdata.GeneralAttributes{
52 BannerID: "banner",
53 StoreID: "store",
54 TerminalID: "terminal",
55 SessionID: "orderingKey",
56 Identity: "identity",
57 Version: "1.0",
58 Signature: "signature",
59 },
60 ReqMsgID: "requestMessageID",
61 }
62 )
63
64 type commandResponse struct {
65 data msgdata.ResponseData
66 attributes msgdata.ResponseAttributes
67 msgdata.CommandResponse
68 }
69
70 func TestMarshalUnmarshalConnectionPayload(t *testing.T) {
71 msg, err := msgdata.NewCommandResponse(defaultResponseDataJSON, defaultAttrMap)
72 assert.NoError(t, err)
73 val := ConnectionPayload{Message: msg}
74 bytes, err := json.Marshal(val)
75 assert.NoError(t, err)
76 resp := ConnectionPayload{}
77 err = json.Unmarshal(bytes, &resp)
78 assert.NoError(t, err)
79 assert.EqualValues(t, val, resp)
80 }
81 func TestTargetValidation(t *testing.T) {
82 tests := map[string]struct {
83 target Target
84 exp int
85 }{
86 "Valid": {
87 target: validTarget,
88 exp: 0,
89 },
90 "One Error": {
91 target: Target{
92 Projectid: "project",
93 Bannerid: "banner",
94 Storeid: "store",
95 },
96 exp: 1,
97 },
98 "All Errors": {
99 target: Target{},
100 exp: 4,
101 },
102 }
103
104 for name, tc := range tests {
105 t.Run(name, func(t *testing.T) {
106 err := tc.target.validate()
107
108 if tc.exp == 0 {
109 assert.NoError(t, err)
110 } else {
111 assert.IsType(t, ValidationErr{}, err)
112 }
113
114 if e, ok := err.(ValidationErr); ok {
115 assert.Len(t, e, tc.exp)
116 }
117 })
118 }
119 }
120
121 func TestStartSessionPayloadValidation(t *testing.T) {
122 tests := map[string]struct {
123 payload StartSessionPayload
124 expErrs []error
125 expErrMsg []string
126 }{
127 "Valid": {
128 payload: StartSessionPayload{
129 Target: validTarget,
130 SessionID: "sessionID",
131 },
132 expErrs: nil,
133 expErrMsg: nil,
134 },
135 "One Error": {
136 payload: StartSessionPayload{
137 Target: validTarget,
138 SessionID: "",
139 },
140 expErrs: []error{errNilSessionID},
141 expErrMsg: []string{"Payload missing Session ID"},
142 },
143 "All Errors": {
144 payload: StartSessionPayload{},
145 expErrs: []error{
146 errNilSessionID,
147 errNilProjectID,
148 errNilBannerID,
149 errNilStoreID,
150 errNilTerminalID,
151 },
152 expErrMsg: []string{
153 "Payload missing Session ID",
154 "Target missing project ID",
155 "Target missing Banner ID",
156 "Target missing Store ID",
157 "Target missing Terminal ID",
158 },
159 },
160 }
161
162 for name, tc := range tests {
163 t.Run(name, func(t *testing.T) {
164 err := tc.payload.Validate()
165
166 for _, msg := range tc.expErrs {
167 assert.ErrorContains(t, err, msg.Error())
168 }
169 if len(tc.expErrs) != 0 {
170
171
172 assert.IsType(t, ValidationErr{}, err)
173 }
174
175 e, ok := err.(ValidationErr)
176 if !ok {
177 return
178 }
179
180 for _, msg := range tc.expErrMsg {
181 assert.Contains(t, e.UserError(), msg)
182 }
183 })
184 }
185 }
186
187 func TestConnectionPayloadValidation(t *testing.T) {
188 tests := map[string]struct {
189 payload ConnectionPayload
190 exp error
191 }{
192 "Valid Error": {
193 payload: ConnectionPayload{
194 Error: "error",
195 },
196 exp: nil,
197 },
198 "Valid Message": {
199 payload: ConnectionPayload{
200 Message: commandResponse{
201 data: defaultResponseData,
202 attributes: defaultResponseAttr,
203 },
204 },
205 exp: nil,
206 },
207 "Fail Both Init": {
208 payload: ConnectionPayload{
209 Error: "error",
210 Message: commandResponse{
211 data: defaultResponseData,
212 attributes: defaultResponseAttr,
213 },
214 },
215 exp: errBothInit,
216 },
217 "Fail Both Nil": {
218 payload: ConnectionPayload{},
219 exp: errBothNil,
220 },
221 }
222
223 for name, tc := range tests {
224 t.Run(name, func(t *testing.T) {
225 err := tc.payload.Validate()
226 assert.Equal(t, tc.exp, err)
227 })
228 }
229 }
230
231 func TestSendPayloadValidation(t *testing.T) {
232 tests := map[string]struct {
233 payload SendPayload
234 expErrs []error
235 expErrMsgs []string
236 }{
237 "Valid": {
238 payload: SendPayload{
239 Target: validTarget,
240 SessionID: "sessionID",
241 Command: "echo hello",
242 },
243 expErrs: nil,
244 expErrMsgs: nil,
245 },
246 "One Error": {
247 payload: SendPayload{
248 Target: validTarget,
249 SessionID: "sessionID",
250 Command: "",
251 },
252 expErrs: []error{errNilCommand},
253 expErrMsgs: []string{"Payload missing Command"},
254 },
255 "All Errors": {
256 payload: SendPayload{},
257 expErrs: []error{
258 errNilProjectID,
259 errNilBannerID,
260 errNilStoreID,
261 errNilTerminalID,
262 errNilSessionID,
263 errNilCommand,
264 },
265 expErrMsgs: []string{
266 "Payload missing Session ID",
267 "Payload missing Command",
268 "Target missing project ID",
269 "Target missing Banner ID",
270 "Target missing Store ID",
271 "Target missing Terminal ID",
272 },
273 },
274 }
275
276 for name, tc := range tests {
277 t.Run(name, func(t *testing.T) {
278 err := tc.payload.Validate()
279
280 for _, msg := range tc.expErrs {
281 assert.ErrorContains(t, err, msg.Error())
282 }
283 if len(tc.expErrs) != 0 {
284
285
286 assert.IsType(t, ValidationErr{}, err)
287 }
288
289 e, ok := err.(ValidationErr)
290 if !ok {
291 return
292 }
293
294 for _, msg := range tc.expErrMsgs {
295 assert.Contains(t, e.UserError(), msg)
296 }
297 })
298 }
299 }
300
301 func TestEndSessionPayload(t *testing.T) {
302 tests := map[string]struct {
303 payload EndSessionPayload
304 exp error
305 }{
306 "Valid": {
307 payload: EndSessionPayload{
308 SessionID: "sessionID",
309 },
310 exp: nil,
311 },
312 "Invalid": {
313 payload: EndSessionPayload{},
314 exp: ValidationErr{userError{errNilSessionID, "Payload missing Session ID"}},
315 },
316 }
317
318 for name, tc := range tests {
319 t.Run(name, func(t *testing.T) {
320 err := tc.payload.Validate()
321 assert.Equal(t, tc.exp, err)
322 })
323 }
324 }
325
View as plain text