1 package integration_test
2
3 import (
4 "fmt"
5
6 "github.com/udacity/graphb"
7
8 "edge-infra.dev/pkg/edge/api/graph/model"
9 "edge-infra.dev/pkg/edge/api/services"
10 sqlquery "edge-infra.dev/pkg/edge/api/sql"
11 "edge-infra.dev/pkg/edge/api/utils"
12 "edge-infra.dev/test/framework/integration"
13 )
14
15 var terminalID = "c4aa6450-3b2a-11ed-a261-0242ac12c101"
16
17 func (s *Suite) TestCreateTerminal() {
18 integration.SkipIf(s.Framework)
19 var response struct{ CreateTerminal *model.Terminal }
20 mutation := "mutation{createTerminal(newTerminal:{lane:\"lane01\",role:worker,class:touchpoint,discoverDisks:empty,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"178.102.156.9\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,class,discoverDisks,bootDisk,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
21 err := ResolverClient.Post(mutation, &response)
22 s.NoError(err)
23
24 s.NotNil(response.CreateTerminal)
25 terminal := response.CreateTerminal
26 s.NotEmpty(terminal.Interfaces)
27 s.Equal(1, len(terminal.Interfaces))
28 terminalInterface := terminal.Interfaces[0]
29 s.NotEmpty(terminalInterface.Addresses)
30 s.Equal(1, len(terminalInterface.Addresses))
31 terminalAddress := terminalInterface.Addresses[0]
32
33 s.Equal("3396a52c-6a22-4049-9593-5a63b596a101", terminal.ClusterEdgeID)
34 s.Equal(model.TerminalRoleTypeWorker, terminal.Role)
35 s.Equal("lane01", *terminal.Lane)
36 s.Equal(model.TerminalClassTypeTouchpoint, *terminal.Class)
37 s.Equal(model.TerminalDiscoverDisksTypeEmpty, *terminal.DiscoverDisks)
38 s.Nil(terminal.BootDisk)
39
40 s.Equal("00:00:5e:00:53:bb", terminalInterface.MacAddress)
41 s.False(terminalInterface.Dhcp4)
42 s.True(terminalInterface.Dhcp6)
43
44 s.Equal("192.168.2.10", *terminalAddress.IP)
45 s.Equal(16, terminalAddress.PrefixLen)
46 s.Equal(model.InetTypeInet, terminalAddress.Family)
47
48 _, err = s.DB.Exec(sqlquery.TerminalDeleteQuery, terminal.TerminalID)
49 s.NoError(err)
50 }
51
52 func (s *Suite) TestCreateTerminalWithSpecifiedBootDisk() {
53 integration.SkipIf(s.Framework)
54 var response struct{ CreateTerminal *model.Terminal }
55 mutation := "mutation{createTerminal(newTerminal:{lane:\"lane01\",role:worker,class:touchpoint,discoverDisks:empty,bootDisk:\"/dev/sda\",clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"178.102.156.9\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,class,discoverDisks,bootDisk,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
56 err := ResolverClient.Post(mutation, &response)
57 s.NoError(err)
58
59 s.NotNil(response.CreateTerminal)
60 terminal := response.CreateTerminal
61 s.NotEmpty(terminal.Interfaces)
62 s.Equal(1, len(terminal.Interfaces))
63 terminalInterface := terminal.Interfaces[0]
64 s.NotEmpty(terminalInterface.Addresses)
65 s.Equal(1, len(terminalInterface.Addresses))
66 terminalAddress := terminalInterface.Addresses[0]
67
68 s.Equal("3396a52c-6a22-4049-9593-5a63b596a101", terminal.ClusterEdgeID)
69 s.Equal(model.TerminalRoleTypeWorker, terminal.Role)
70 s.Equal("lane01", *terminal.Lane)
71 s.Equal(model.TerminalClassTypeTouchpoint, *terminal.Class)
72 s.Equal(model.TerminalDiscoverDisksTypeEmpty, *terminal.DiscoverDisks)
73 s.Equal("/dev/sda", *terminal.BootDisk)
74
75 s.Equal("00:00:5e:00:53:bb", terminalInterface.MacAddress)
76 s.False(terminalInterface.Dhcp4)
77 s.True(terminalInterface.Dhcp6)
78
79 s.Equal("192.168.2.10", *terminalAddress.IP)
80 s.Equal(16, terminalAddress.PrefixLen)
81 s.Equal(model.InetTypeInet, terminalAddress.Family)
82
83 _, err = s.DB.Exec(sqlquery.TerminalDeleteQuery, terminal.TerminalID)
84 s.NoError(err)
85 }
86
87 func (s *Suite) TestCreateTerminalWithDefaultDiscoverDisks() {
88 integration.SkipIf(s.Framework)
89 var response struct{ CreateTerminal *model.Terminal }
90 mutation := "mutation{createTerminal(newTerminal:{lane:\"lane01\",role:worker,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"178.102.156.9\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,class,discoverDisks,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
91 err := ResolverClient.Post(mutation, &response)
92 s.NoError(err)
93
94
95 s.NotNil(response.CreateTerminal)
96 terminal := response.CreateTerminal
97 s.Equal(model.TerminalDiscoverDisksTypeEmpty, *terminal.DiscoverDisks)
98
99 _, err = s.DB.Exec(sqlquery.TerminalDeleteQuery, terminal.TerminalID)
100 s.NoError(err)
101 }
102
103 func (s *Suite) TestCreateTerminalAddress() {
104 integration.SkipIf(s.Framework)
105 var response struct{ CreateTerminalAddress *model.TerminalAddress }
106 mutation := "mutation{createTerminalAddress(terminalInterfaceId:\"3396a52c-6a22-4049-9593-5a63b596a203\",newTerminalAddress:{ip:\"192.168.2.10\",prefixLen:16,family:inet}){family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}"
107 err := ResolverClient.Post(mutation, &response)
108 s.NoError(err)
109 s.Equal("3396a52c-6a22-4049-9593-5a63b596a203", response.CreateTerminalAddress.TerminalInterfaceID)
110 s.Equal("192.168.2.10", *response.CreateTerminalAddress.IP)
111
112 _, err = s.DB.Exec(sqlquery.TerminalAddressDeleteQuery, response.CreateTerminalAddress.TerminalAddressID)
113 s.NoError(err)
114 }
115
116 func (s *Suite) TestCreateTerminalError() {
117 integration.SkipIf(s.Framework)
118 var response struct{ CreateTerminal *model.Terminal }
119
120 mutation := "mutation{createTerminal(newTerminal:{lane:\"\",role:worker,discoverDisks:all,interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"x.x.x.x\",gateway6:\"x.x.x.x\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
121 err := ResolverClient.Post(mutation, &response)
122 s.Error(err)
123 s.Nil(response.CreateTerminal)
124 }
125
126 func (s *Suite) TestCreateTerminalInterface() {
127 integration.SkipIf(s.Framework)
128 var response struct{ CreateTerminalInterface *model.TerminalInterface }
129 mutation := "mutation{createTerminalInterface(terminalId:\"c4aa6450-3b2a-11ed-a261-0242ac12c101\",newTerminalInterface:{macAddress:\"00:00:5e:00:53:bb\",dhcp4:true,dhcp6:true,addresses:[]}){dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId}}"
130 err := ResolverClient.Post(mutation, &response)
131 s.NoError(err)
132 s.Equal(terminalID, response.CreateTerminalInterface.TerminalID)
133 s.Equal("00:00:5e:00:53:bb", response.CreateTerminalInterface.MacAddress)
134
135 _, err = s.DB.Exec(sqlquery.TerminalInterfaceDeleteQuery, response.CreateTerminalInterface.TerminalInterfaceID)
136 s.NoError(err)
137 }
138
139 func (s *Suite) TestCreateTerminalInterfaceError() {
140 integration.SkipIf(s.Framework)
141 var response struct{ CreateTerminalInterface *model.TerminalInterface }
142 mutation := "mutation{createTerminalInterface(terminalId:\"c4aa6450-3b2a-11ed-a261-0242ac12c101\",newTerminalInterface:{macAddress:\"0000:5e:00:53:bb\",dhcp4:false,dhcp6:false,gateway4:\"178.102.156.9\",gateway6:\"22.234.148.200\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}){dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}"
143 err := ResolverClient.Post(mutation, &response)
144 s.Error(err)
145 }
146
147 func (s *Suite) TestCreateTerminalInvalidCIDR() {
148 integration.SkipIf(s.Framework)
149 var response struct{ CreateTerminal *model.Terminal }
150
151 mutation := "mutation{createTerminal(newTerminal:{lane:\"\",role:worker,discoverDisks:all,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"1.1.1.1\",gateway6:\"2.2.2.2\",addresses:[{ip:\"192.168.2.10\",prefixLen:-1,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
152 err := ResolverClient.Post(mutation, &response)
153 s.Error(err)
154 s.Nil(response.CreateTerminal)
155 }
156
157 func (s *Suite) TestCreateTerminalInvalidIP() {
158 integration.SkipIf(s.Framework)
159 var response struct{ CreateTerminal *model.Terminal }
160
161 mutation := "mutation{createTerminal(newTerminal:{lane:\"\",role:worker,discoverDisks:all,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"x.x.x.x\",gateway6:\"x.x.x.x\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
162 err := ResolverClient.Post(mutation, &response)
163 s.Error(err)
164 s.Nil(response.CreateTerminal)
165 }
166
167 func (s *Suite) TestCreateTerminalInvalidMac() {
168 integration.SkipIf(s.Framework)
169 var response struct{ CreateTerminal *model.Terminal }
170
171 mutation := "mutation{createTerminal(newTerminal:{lane:\"\",role:worker,discoverDisks:all,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"005e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"1.1.1.1\",gateway6:\"2.2.2.2\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
172 err := ResolverClient.Post(mutation, &response)
173 s.Error(err)
174 s.Nil(response.CreateTerminal)
175 }
176
177 func (s *Suite) TestCreateTerminalDHCPNotSet() {
178 integration.SkipIf(s.Framework)
179 var response struct{ CreateTerminal *model.Terminal }
180 mutation := "mutation{createTerminal(newTerminal:{lane:\"lane01\",role:worker,discoverDisks:all,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:false,gateway4:\"178.102.156.9\",gateway6:\"f886:c601:c61b:8eb1:ae5b:a21e:4332:f119\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet},{ip:\"a8ec:2b0c:05ac:27be:88e2:de7a:3c81:f439\",prefixLen:24,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
181 err := ResolverClient.Post(mutation, &response)
182 s.NoError(err)
183 terminal := response.CreateTerminal
184
185 s.NotEmpty(terminal.Interfaces)
186 s.Equal(1, len(terminal.Interfaces))
187 s.False(terminal.Interfaces[0].Dhcp4)
188 s.False(terminal.Interfaces[0].Dhcp6)
189 s.NotEmpty(terminal.Interfaces[0].Addresses)
190 s.Equal(2, len(terminal.Interfaces[0].Addresses))
191 s.Equal("192.168.2.10", *terminal.Interfaces[0].Addresses[0].IP)
192 s.Equal("a8ec:2b0c:05ac:27be:88e2:de7a:3c81:f439", *terminal.Interfaces[0].Addresses[1].IP)
193
194 _, err = s.DB.Exec(sqlquery.TerminalDeleteQuery, terminal.TerminalID)
195 s.NoError(err)
196 }
197
198 func (s *Suite) TestCreateTerminalWithDuplicateDiskPaths() {
199 integration.SkipIf(s.Framework)
200 var response struct{ CreateTerminal *model.Terminal }
201 mutation := "mutation{createTerminal(newTerminal:{role:worker,discoverDisks:empty,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:cc\",dhcp4:true,dhcp6:false}],disks:[{devicePath:\"/dev/sda1\",expectEmpty:true,includeDisk:true},{devicePath:\"/dev/sda1\",expectEmpty:true,includeDisk:true}]}){clusterEdgeId,disks{usePart,terminalId,terminalDiskId,includeDisk,expectEmpty,devicePath}}}"
202 err := ResolverClient.Post(mutation, &response)
203 s.ErrorContains(err, services.ErrDuplicateTerminalDiskDevicePaths.Error())
204 }
205
206 func (s *Suite) TestDeleteTerminal() {
207 integration.SkipIf(s.Framework)
208 var response struct{ DeleteTerminal bool }
209 terminalID := "c4aa6450-3b2a-11ed-a261-0242ac12c201"
210 mutation := deleteTerminalMutation(&terminalID)
211 err := ResolverClient.Post(mutation, &response)
212 s.NoError(err)
213 s.True(response.DeleteTerminal)
214 }
215
216 func (s *Suite) TestDeleteTerminalAddress() {
217 integration.SkipIf(s.Framework)
218
219 createAddressArgs := []interface{}{
220 "523f8d69-c76e-4592-a9bf-442fdb15e474",
221 "203.236.49.66",
222 16,
223 model.InetTypeInet.String(),
224 "3396a52c-6a22-4049-9593-5a63b596a203",
225 }
226 _, err := s.DB.Exec(sqlquery.TerminalAddressCreateQuery, createAddressArgs...)
227 s.NoError(err)
228
229 createAddressArgsv6 := []interface{}{
230 "3a291185-286d-4693-8792-f1a719d0f442",
231 "0538:928e:a40b:9529:f72c:599a:6e6e:cfe9",
232 16,
233 model.InetTypeInet.String(),
234 "3396a52c-6a22-4049-9593-5a63b596a203",
235 }
236 _, err = s.DB.Exec(sqlquery.TerminalAddressCreateQuery, createAddressArgsv6...)
237 s.NoError(err)
238
239 var response struct{ DeleteTerminalAddress bool }
240 addressID := "523f8d69-c76e-4592-a9bf-442fdb15e474"
241 mutation := deleteTerminalAddressMutation(&addressID)
242 err = ResolverClient.Post(mutation, &response)
243 s.NoError(err)
244 s.True(response.DeleteTerminalAddress)
245
246
247 _, err = s.DB.Exec(sqlquery.TerminalAddressDeleteQuery, createAddressArgsv6[0])
248 s.NoError(err)
249 }
250
251 func (s *Suite) TestDeleteTerminalError() {
252 integration.SkipIf(s.Framework)
253 var response struct{ DeleteTerminal bool }
254 query := deleteTerminalMutation(nil)
255 err := ResolverClient.Post(query, &response)
256 s.Error(err)
257 }
258
259 func (s *Suite) TestDeleteTerminalInterface() {
260 integration.SkipIf(s.Framework)
261
262 createIfaceArgs := []interface{}{
263 "55fb8510-3d78-4f8d-a43a-cae429109c6c",
264 "02:e8:55:57:bd:80",
265 false,
266 true,
267 "213.170.59.248",
268 "252.51.27.170",
269 terminalID,
270 }
271 _, err := s.DB.Exec(sqlquery.TerminalInterfaceCreateQuery, createIfaceArgs...)
272 s.NoError(err)
273
274 var response struct{ DeleteTerminalInterface bool }
275 ifaceID := "55fb8510-3d78-4f8d-a43a-cae429109c6c"
276 mutation := deleteTerminalInterfaceMutation(&ifaceID)
277 err = ResolverClient.Post(mutation, &response)
278 s.NoError(err)
279 s.True(response.DeleteTerminalInterface)
280 }
281
282 func (s *Suite) TestDeleteTerminalInterfaceError() {
283 integration.SkipIf(s.Framework)
284 var response struct{ DeleteTerminalInterface bool }
285 ifaceID := "3396a52c-6a22-4049-9593-5a63b596a203"
286 mutation := deleteTerminalInterfaceMutation(&ifaceID)
287 err = ResolverClient.Post(mutation, &response)
288 s.Error(err)
289 s.False(response.DeleteTerminalInterface)
290 }
291
292 func (s *Suite) TestGetTerminal() {
293 integration.SkipIf(s.Framework)
294
295 var response struct{ Terminal *model.Terminal }
296 query := getTerminalQuery(&terminalID)
297 err = ResolverClient.Post(query, &response)
298
299 s.NoError(err)
300 s.NotEmpty(response.Terminal)
301 s.Equal(terminalID, response.Terminal.TerminalID)
302 s.NotEmpty(response.Terminal.Interfaces)
303 terminalInterface := response.Terminal.Interfaces[0]
304 s.Equal("3396a52c-6a22-4049-9593-5a63b596a203", terminalInterface.TerminalInterfaceID)
305 s.NotEmpty(terminalInterface.Addresses)
306 terminalAddress := terminalInterface.Addresses[0]
307 s.Equal("1ad40dca-3b2d-11ed-a261-0242ac12a101", terminalAddress.TerminalAddressID)
308 }
309
310 func (s *Suite) TestGetTerminalError() {
311 integration.SkipIf(s.Framework)
312 var response struct{ Terminal *model.Terminal }
313 terminalID := "does-not-exist"
314 query := getTerminalQuery(&terminalID)
315 err := ResolverClient.Post(query, &response)
316 s.Error(err)
317 }
318
319 func (s *Suite) TestGetTerminals() {
320 integration.SkipIf(s.Framework)
321
322 var response struct{ Terminals []*model.Terminal }
323 clusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a200"
324 query := getTerminalsQuery(&clusterEdgeID, nil)
325 err = ResolverClient.Post(query, &response)
326 s.NoError(err)
327 s.NotEmpty(response.Terminals)
328 s.Equal(1, len(response.Terminals))
329 terminal := response.Terminals[0]
330 s.Equal(terminalID, terminal.TerminalID)
331 terminalInterface := terminal.Interfaces[0]
332 s.NotEmpty(terminalInterface.Addresses)
333 s.Equal(clusterEdgeID, terminal.ClusterEdgeID)
334 s.Equal("lane01", *terminal.Lane)
335 s.Equal("00:00:5e:00:53:af", terminal.Interfaces[0].MacAddress)
336 s.Equal("192.168.1.1", *terminal.Interfaces[0].Addresses[0].IP)
337
338 query = getTerminalsQuery(nil, nil)
339 err = ResolverClient.Post(query, &response)
340 s.NoError(err)
341 s.NotEmpty(response.Terminals)
342 s.Equal(6, len(response.Terminals))
343 s.Equal(terminalID, response.Terminals[0].TerminalID)
344 }
345
346 func (s *Suite) TestGetTerminalsError() {
347 integration.SkipIf(s.Framework)
348 var response struct{ Terminals []*model.Terminal }
349 clusterEdgeID := "does-not-exist"
350 query := getTerminalsQuery(&clusterEdgeID, nil)
351 err := ResolverClient.Post(query, &response)
352 s.Error(err)
353 }
354
355 func (s *Suite) TestUpdateTerminal() {
356 integration.SkipIf(s.Framework)
357
358 var response struct{ UpdateTerminal *model.Terminal }
359 terminalArgs := []interface{}{
360 terminalID,
361 "lane01",
362 model.TerminalRoleTypeWorker.String(),
363 model.TerminalClassTypeTouchpoint,
364 model.TerminalDiscoverDisksTypeEmpty,
365 nil,
366 nil,
367 nil,
368 false,
369 "3396a52c-6a22-4049-9593-5a63b596a200",
370 }
371
372 mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{lane:\"lane20\",class:touchpoint,discoverDisks:empty}}){terminalId,lane,role,class,discoverDisks,clusterEdgeId}}", terminalArgs[0])
373 err = ResolverClient.Post(mutation, &response)
374 s.NoError(err)
375 s.Equal(terminalArgs[0], response.UpdateTerminal.TerminalID)
376 s.Equal("lane20", *response.UpdateTerminal.Lane)
377 s.Equal(terminalArgs[2], response.UpdateTerminal.Role.String())
378 s.Equal(terminalArgs[3], *response.UpdateTerminal.Class)
379 s.Equal(terminalArgs[4], *response.UpdateTerminal.DiscoverDisks)
380 s.Nil(response.UpdateTerminal.BootDisk)
381 s.Nil(response.UpdateTerminal.PrimaryInterface)
382 s.Equal(terminalArgs[8], response.UpdateTerminal.SwapEnabled)
383 s.Equal(terminalArgs[9], response.UpdateTerminal.ClusterEdgeID)
384
385 _, err = s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
386 s.NoError(err)
387 }
388
389 func (s *Suite) TestUpdateTerminalWithBootDisk() {
390 integration.SkipIf(s.Framework)
391
392 var response struct{ UpdateTerminal *model.Terminal }
393 terminalArgs := []interface{}{
394 terminalID,
395 "lane01",
396 model.TerminalRoleTypeWorker.String(),
397 model.TerminalClassTypeTouchpoint,
398 model.TerminalDiscoverDisksTypeEmpty,
399 "/dev/sdx",
400 nil,
401 nil,
402 false,
403 }
404
405 mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{bootDisk:\"%s\"}}){bootDisk}}", terminalArgs[0], terminalArgs[5])
406 err = ResolverClient.Post(mutation, &response)
407 s.NoError(err)
408 s.Equal(terminalArgs[5], *response.UpdateTerminal.BootDisk)
409
410 _, err = s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
411 s.NoError(err)
412 }
413
414 func (s *Suite) TestUpdateTerminalWithSpecifiedInterface() {
415 integration.SkipIf(s.Framework)
416
417 var response struct{ UpdateTerminal *model.Terminal }
418 terminalArgs := []interface{}{
419 terminalID,
420 "lane01",
421 model.TerminalRoleTypeWorker.String(),
422 model.TerminalClassTypeTouchpoint,
423 model.TerminalDiscoverDisksTypeEmpty,
424 nil,
425 "3396a52c-6a22-4049-9593-5a63b596a203",
426 nil,
427 false,
428 }
429 mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{primaryInterface:\"%s\"}}){primaryInterface}}", terminalArgs[0], terminalArgs[6])
430 err = ResolverClient.Post(mutation, &response)
431 s.NoError(err)
432
433 s.Equal(terminalArgs[6], *response.UpdateTerminal.PrimaryInterface)
434
435 _, err = s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
436 s.NoError(err)
437 }
438
439 func (s *Suite) TestUpdateTerminalWhenRemovingPrimaryInterface() {
440 integration.SkipIf(s.Framework)
441
442 ifaceID := "55fb8510-3d78-4f8d-a43a-cae429109c6c"
443
444 createIfaceArgs := []interface{}{
445 ifaceID,
446 "02:e8:55:57:bd:80",
447 false,
448 true,
449 "213.170.59.248",
450 "252.51.27.170",
451 terminalID,
452 }
453 _, err = s.DB.Exec(sqlquery.TerminalInterfaceCreateQuery, createIfaceArgs...)
454 s.NoError(err)
455
456 var updateResponse struct{ UpdateTerminal *model.Terminal }
457 terminalArgs := []interface{}{
458 terminalID,
459 "lane01",
460 model.TerminalRoleTypeWorker.String(),
461 model.TerminalClassTypeTouchpoint,
462 model.TerminalDiscoverDisksTypeEmpty,
463 nil,
464 ifaceID,
465 nil,
466 false,
467 }
468 mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{primaryInterface:\"%s\"}}){primaryInterface}}", terminalArgs[0], terminalArgs[6])
469 err = ResolverClient.Post(mutation, &updateResponse)
470 s.NoError(err)
471
472 _, err := s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
473 s.NoError(err)
474
475 var deleteResponse struct{ DeleteTerminalInterface bool }
476 mutation = deleteTerminalInterfaceMutation(&ifaceID)
477 err = ResolverClient.Post(mutation, &deleteResponse)
478 s.NoError(err)
479 s.True(deleteResponse.DeleteTerminalInterface)
480
481 _, err = s.DB.Exec(sqlquery.TerminalInterfaceDeleteQuery, ifaceID)
482 s.NoError(err)
483
484 var response struct{ Terminal *model.Terminal }
485 query := getTerminalQuery(&terminalID)
486 err = ResolverClient.Post(query, &response)
487 s.NoError(err)
488 s.Nil(response.Terminal.PrimaryInterface)
489 }
490
491 func (s *Suite) TestUpdateTerminalWithInvalidInterface() {
492 integration.SkipIf(s.Framework)
493 var response struct{ UpdateTerminal *model.Terminal }
494 terminalArgs := []interface{}{
495 terminalID,
496 "lane01",
497 model.TerminalRoleTypeWorker.String(),
498 model.TerminalClassTypeTouchpoint,
499 model.TerminalDiscoverDisksTypeEmpty,
500 nil,
501 "3396a52f-6a22-4049-9593-5a63b596a204",
502 nil,
503 false,
504 }
505 mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{primaryInterface:\"%s\"}}){primaryInterface}}", terminalArgs[0], terminalArgs[6])
506 err = ResolverClient.Post(mutation, &response)
507 s.Error(err)
508
509 _, err = s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
510 s.Error(err)
511 }
512
513
514 func (s *Suite) TestUpdateTerminalInvalidIP() {
515 integration.SkipIf(s.Framework)
516 var response struct{ UpdateTerminal *model.Terminal }
517
518 var (
519 prefixLen = 16
520 dhcp4 = true
521 terminalLane = "lane20"
522 discoverDisks = model.TerminalDiscoverDisksTypeEmpty
523 macAddress = "de:fa:37:f8:6a:b2"
524 ip = ""
525 )
526 terminalAddressUpdateValues := []*model.TerminalAddressIDInput{
527 {
528 TerminalAddressID: "1ad40dca-3b2d-11ed-a261-0242ac12a101",
529 TerminalAddressValues: &model.TerminalAddressUpdateInput{
530 PrefixLen: &prefixLen,
531 IP: &ip,
532 },
533 },
534 }
535 terminalInterfaceUpdateValues := []*model.TerminalInterfaceIDInput{
536 {
537 TerminalInterfaceID: "3396a52c-6a22-4049-9593-5a63b596a203",
538 TerminalInterfaceValues: &model.TerminalInterfaceUpdateInput{
539 Dhcp4: &dhcp4,
540 MacAddress: &macAddress,
541 Addresses: terminalAddressUpdateValues,
542 },
543 },
544 }
545 terminalUpdateValues := model.TerminalIDInput{
546 TerminalID: terminalID,
547 TerminalValues: &model.TerminalUpdateInput{
548 Lane: &terminalLane,
549 DiscoverDisks: &discoverDisks,
550 Interfaces: terminalInterfaceUpdateValues,
551 },
552 }
553
554 mutation := updateTerminalMutation(&terminalUpdateValues)
555 err := ResolverClient.Post(mutation, &response)
556 s.Error(err)
557 s.Nil(response.UpdateTerminal)
558 }
559
560
561 func (s *Suite) TestUpdateTerminalInvalidMac() {
562 integration.SkipIf(s.Framework)
563 var response struct{ UpdateTerminal *model.Terminal }
564
565 var (
566 prefixLen = 16
567 dhcp4 = true
568 terminalLane = "lane20"
569 discoverDisks = model.TerminalDiscoverDisksTypeEmpty
570 macAddress = ""
571 ip = "252.227.220.89"
572 )
573 terminalAddressUpdateValues := []*model.TerminalAddressIDInput{
574 {
575 TerminalAddressID: "1ad40dca-3b2d-11ed-a261-0242ac12a101",
576 TerminalAddressValues: &model.TerminalAddressUpdateInput{
577 PrefixLen: &prefixLen,
578 IP: &ip,
579 },
580 },
581 }
582 terminalInterfaceUpdateValues := []*model.TerminalInterfaceIDInput{
583 {
584 TerminalInterfaceID: "3396a52c-6a22-4049-9593-5a63b596a203",
585 TerminalInterfaceValues: &model.TerminalInterfaceUpdateInput{
586 Dhcp4: &dhcp4,
587 MacAddress: &macAddress,
588 Addresses: terminalAddressUpdateValues,
589 },
590 },
591 }
592 terminalUpdateValues := model.TerminalIDInput{
593 TerminalID: terminalID,
594 TerminalValues: &model.TerminalUpdateInput{
595 Lane: &terminalLane,
596 DiscoverDisks: &discoverDisks,
597 Interfaces: terminalInterfaceUpdateValues,
598 },
599 }
600
601 mutation := updateTerminalMutation(&terminalUpdateValues)
602 err := ResolverClient.Post(mutation, &response)
603 s.Error(err)
604 s.Nil(response.UpdateTerminal)
605 }
606
607 func (s *Suite) TestUpdateTerminalError() {
608 integration.SkipIf(s.Framework)
609 var response struct{ UpdateTerminal *model.Terminal }
610
611 terminalAddressUpdateValues := []*model.TerminalAddressIDInput{
612 {
613 TerminalAddressID: "f0984590-40b7-11ed-b878-0242ac120002",
614 TerminalAddressValues: &model.TerminalAddressUpdateInput{},
615 },
616 }
617 terminalInterfaceUpdateValues := []*model.TerminalInterfaceIDInput{
618 {
619 TerminalInterfaceID: "e9958cf8-40b7-11ed-b878-0242ac120002",
620 TerminalInterfaceValues: &model.TerminalInterfaceUpdateInput{
621 Addresses: terminalAddressUpdateValues,
622 },
623 },
624 }
625 terminalLane := "lane05"
626 discoverDisks := model.TerminalDiscoverDisksTypeEmpty
627 terminalUpdateValues := model.TerminalIDInput{
628 TerminalID: "e856e784-40b6-11ed-b878-0242ac120002",
629 TerminalValues: &model.TerminalUpdateInput{
630 Lane: &terminalLane,
631 DiscoverDisks: &discoverDisks,
632 Interfaces: terminalInterfaceUpdateValues,
633 },
634 }
635
636 mutation := updateTerminalMutation(&terminalUpdateValues)
637 err := ResolverClient.Post(mutation, &response)
638 s.Error(err)
639 s.Empty(response.UpdateTerminal)
640 }
641
642
643 func (s *Suite) TestUpdateTerminalWithDuplicateDiskPaths_One() {
644 integration.SkipIf(s.Framework)
645
646 var response struct{ UpdateTerminal *model.Terminal }
647 mutation := "mutation{updateTerminal(terminal:{terminalId:\"42742ecf-55fa-467a-a3b2-174015a8109f\",terminalValues:{disks:[{terminalDiskId:\"ffd5d566-0569-4c8e-8fec-a283898fb487\",terminalDiskValues:{devicePath:\"/dev/sdd123\"}},{terminalDiskId:\"7d36aec7-dfda-49ce-8700-aa337fe74cbf\",terminalDiskValues:{devicePath:\"/dev/sdd123\"}}]}}){terminalId}}"
648 err = ResolverClient.Post(mutation, &response)
649 s.ErrorContains(err, services.ErrDuplicateTerminalDiskDevicePaths.Error())
650 }
651
652
653 func (s *Suite) TestUpdateTerminalWithDuplicateDiskPaths_Two() {
654 integration.SkipIf(s.Framework)
655
656 var response struct{ UpdateTerminal *model.Terminal }
657 mutation := "mutation{updateTerminal(terminal:{terminalId:\"42742ecf-55fa-467a-a3b2-174015a8109f\",terminalValues:{disks:[{terminalDiskId:\"ffd5d566-0569-4c8e-8fec-a283898fb487\",terminalDiskValues:{devicePath:\"/dev/sdz\"}}]}}){terminalId}}"
658 err = ResolverClient.Post(mutation, &response)
659 s.ErrorContains(err, services.ErrDuplicateTerminalDiskDevicePaths.Error())
660 }
661
662 func (s *Suite) TestGetBannerTerminals() {
663 integration.SkipIf(s.Framework)
664 var response struct{ BannerTerminals []*model.Terminal }
665
666 bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
667 query := getBannerTerminalsQuery(&bannerEdgeID)
668 err := ResolverClient.Post(query, &response)
669
670 s.NoError(err)
671 s.Equal(6, len(response.BannerTerminals))
672 }
673
674 func (s *Suite) TestGetBannerTerminalsError() {
675 integration.SkipIf(s.Framework)
676 var response struct {
677 BannerTerminals []*model.Terminal
678 }
679 query := getBannerTerminalsQuery(nil)
680 err := ResolverClient.Post(query, &response)
681 s.Error(err)
682 s.Empty(response.BannerTerminals)
683 }
684
685 func (s *Suite) TestGetTerminalDevices() {
686 integration.SkipIf(s.Framework)
687
688 var response struct{ TerminalDevices *model.TerminalDevices }
689 query := getTerminalDevicesQuery(&terminalID)
690 err = ResolverClient.Post(query, &response)
691 s.NoError(err)
692
693 s.NotEmpty(response.TerminalDevices)
694 s.Len(response.TerminalDevices.Classes, 1)
695 s.Len(response.TerminalDevices.Classes[0].Devices, 1)
696 s.Equal(response.TerminalDevices.Classes[0].Devices[0].Name, "card0-VGA-1 ACR-2199")
697 }
698
699 var terminalFields = []*graphb.Field{
700 {
701 Name: "clusterEdgeId",
702 },
703 {
704 Name: "clusterName",
705 },
706 {
707 Name: "hostname",
708 },
709 {
710 Name: "lane",
711 },
712 {
713 Name: "role",
714 },
715 {
716 Name: "terminalId",
717 },
718 {
719 Name: "class",
720 },
721 {
722 Name: "discoverDisks",
723 },
724 {
725 Name: "interfaces",
726 Fields: []*graphb.Field{
727 {
728 Name: "dhcp4",
729 },
730 {
731 Name: "dhcp6",
732 },
733 {
734 Name: "gateway4",
735 },
736 {
737 Name: "gateway6",
738 },
739 {
740 Name: "macAddress",
741 },
742 {
743 Name: "terminalId",
744 },
745 {
746 Name: "terminalInterfaceId",
747 },
748 {
749 Name: "addresses",
750 Fields: []*graphb.Field{
751 {
752 Name: "family",
753 },
754 {
755 Name: "terminalInterfaceId",
756 },
757 {
758 Name: "ip",
759 },
760 {
761 Name: "prefixLen",
762 },
763 {
764 Name: "terminalAddressId",
765 },
766 },
767 },
768 },
769 },
770 }
771
772 func updateTerminalMutation(updateTerminal *model.TerminalIDInput) string {
773 terminalValues := updateTerminal.TerminalValues
774 terminalInterfaceValues := terminalValues.Interfaces[0].TerminalInterfaceValues
775 terminalAddressValues := terminalInterfaceValues.Addresses[0].TerminalAddressValues
776 return MustParse(graphb.Query{
777 Type: graphb.TypeMutation,
778 Fields: []*graphb.Field{
779 {
780 Name: "updateTerminal",
781 Arguments: []graphb.Argument{
782 graphb.ArgumentCustomType("terminal",
783 graphb.ArgumentString("terminalId", updateTerminal.TerminalID),
784 graphb.ArgumentCustomType("terminalValues",
785 graphb.ArgumentString("lane", utils.ConvertToString(terminalValues.Lane)),
786 graphb.ArgumentString("discoverDisks", terminalValues.DiscoverDisks.String()),
787 graphb.ArgumentCustomTypeSlice("interfaces",
788 graphb.ArgumentCustomTypeSliceElem(
789 graphb.ArgumentString("terminalInterfaceId", terminalValues.Interfaces[0].TerminalInterfaceID),
790 graphb.ArgumentCustomType("terminalInterfaceValues",
791 graphb.ArgumentString("macAddress", utils.ConvertToString(terminalInterfaceValues.MacAddress)),
792 graphb.ArgumentBool("dhcp4", utils.ConvertToBool(terminalInterfaceValues.Dhcp4)),
793 graphb.ArgumentCustomTypeSlice("addresses",
794 graphb.ArgumentCustomTypeSliceElem(
795 graphb.ArgumentString("terminalAddressId", terminalInterfaceValues.Addresses[0].TerminalAddressID),
796 graphb.ArgumentCustomType("terminalAddressValues",
797 graphb.ArgumentString("ip", utils.ConvertToString(terminalAddressValues.IP)),
798 graphb.ArgumentInt("prefixLen", utils.ConvertToInt(terminalAddressValues.PrefixLen)),
799 ),
800 ),
801 ),
802 ),
803 ),
804 ),
805 ),
806 ),
807 },
808 Fields: terminalFields,
809 },
810 },
811 })
812 }
813
814 func deleteTerminalMutation(terminalID *string) string {
815 return MustParse(graphb.Query{
816 Type: graphb.TypeMutation,
817 Fields: []*graphb.Field{
818 {
819 Name: "deleteTerminal",
820 Arguments: []graphb.Argument{
821 graphb.ArgumentString("terminalId", utils.ConvertToString(terminalID)),
822 },
823 },
824 },
825 })
826 }
827
828 func deleteTerminalInterfaceMutation(terminalInterfaceID *string) string {
829 return MustParse(graphb.Query{
830 Type: graphb.TypeMutation,
831 Fields: []*graphb.Field{
832 {
833 Name: "deleteTerminalInterface",
834 Arguments: []graphb.Argument{
835 graphb.ArgumentString("terminalInterfaceId", utils.ConvertToString(terminalInterfaceID)),
836 },
837 },
838 },
839 })
840 }
841
842 func deleteTerminalAddressMutation(terminalAddressID *string) string {
843 return MustParse(graphb.Query{
844 Type: graphb.TypeMutation,
845 Fields: []*graphb.Field{
846 {
847 Name: "deleteTerminalAddress",
848 Arguments: []graphb.Argument{
849 graphb.ArgumentString("terminalAddressId", utils.ConvertToString(terminalAddressID)),
850 },
851 },
852 },
853 })
854 }
855
856 func getTerminalQuery(terminalID *string) string {
857 return MustParse(graphb.Query{
858 Type: graphb.TypeQuery,
859 Fields: []*graphb.Field{
860 {
861 Name: "terminal",
862 Arguments: []graphb.Argument{
863 graphb.ArgumentString("terminalId", utils.ConvertToString(terminalID)),
864 },
865 Fields: terminalFields,
866 },
867 },
868 })
869 }
870
871 func getTerminalDevicesQuery(terminalID *string) string {
872 return MustParse(graphb.Query{
873 Type: graphb.TypeQuery,
874 Fields: []*graphb.Field{
875 {
876 Name: "terminalDevices",
877 Arguments: []graphb.Argument{
878 graphb.ArgumentString("terminalId", utils.ConvertToString(terminalID)),
879 },
880 Fields: terminalDeviceFields(),
881 },
882 },
883 })
884 }
885
886 func terminalDeviceFields() []*graphb.Field {
887 return []*graphb.Field{
888 {
889 Name: "classes",
890 Fields: []*graphb.Field{
891 {
892 Name: "devices",
893 Fields: []*graphb.Field{
894 {
895 Name: "name",
896 },
897 },
898 },
899 {
900 Name: "name",
901 },
902 },
903 },
904 }
905 }
906
907 func getTerminalsQuery(clusterEdgeID *string, terminalHostname *string) string {
908 getTerminalsArg := []graphb.Argument{}
909 if clusterEdgeID != nil {
910 getTerminalsArg = append(getTerminalsArg, graphb.ArgumentString("clusterEdgeId", utils.ConvertToString(clusterEdgeID)))
911 }
912 if terminalHostname != nil {
913 getTerminalsArg = append(getTerminalsArg, graphb.ArgumentString("hostname", utils.ConvertToString(terminalHostname)))
914 }
915 return MustParse(graphb.Query{
916 Type: graphb.TypeQuery,
917 Fields: []*graphb.Field{
918 {
919 Name: "terminals",
920 Arguments: getTerminalsArg,
921 Fields: terminalFields,
922 },
923 },
924 })
925 }
926
927 func getBannerTerminalsQuery(bannerEdgeID *string) string {
928 getBannerTerminalsArg := []graphb.Argument{}
929 if bannerEdgeID != nil {
930 getBannerTerminalsArg = append(getBannerTerminalsArg, graphb.ArgumentString("bannerEdgeId", utils.ConvertToString(bannerEdgeID)))
931 }
932 return MustParse(graphb.Query{
933 Type: graphb.TypeQuery,
934 Fields: []*graphb.Field{
935 {
936 Name: "bannerTerminals",
937 Arguments: getBannerTerminalsArg,
938 Fields: terminalFields,
939 },
940 },
941 })
942 }
943
View as plain text