1 package integration_test
2
3 import (
4 "github.com/udacity/graphb"
5
6 "edge-infra.dev/pkg/edge/api/graph/model"
7 sqlquery "edge-infra.dev/pkg/edge/api/sql"
8 "edge-infra.dev/pkg/edge/api/utils"
9 "edge-infra.dev/test/framework/integration"
10 )
11
12 func (s *Suite) TestCreateVirtualMachine() {
13 integration.SkipIf(s.Framework)
14 var response struct{ CreateVirtualMachine *model.VirtualMachine }
15
16 mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053ba\",memory:\"1024\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType,disks{diskId,bootOrder}}}"
17
18 err := ResolverClient.Post(mutation, &response)
19 s.NoErrorf(err, "error resolving vm mutation")
20
21 s.NotNilf(response.CreateVirtualMachine, "returned vm is null")
22 virtualMachine := response.CreateVirtualMachine
23
24 s.Len(virtualMachine.Disks, 2)
25 s.Equal(1, virtualMachine.Disks[0].BootOrder)
26 s.Equal("618648c8-56f4-4578-a4ff-ae88782b0b9f", virtualMachine.ClusterEdgeID)
27 s.Equal("ien-00005e0053ba", virtualMachine.Hostname)
28 s.Equal(false, virtualMachine.TargetPowerState)
29 s.Equal(1, virtualMachine.Cpus)
30 s.Equal("1024", virtualMachine.Memory)
31 s.Equal(model.MachineTypeQ35, virtualMachine.MachineType)
32 _, err = s.DB.Exec(sqlquery.VirtualMachineDeleteQuery, virtualMachine.VirtualMachineID)
33 s.NoError(err)
34 }
35
36 func (s *Suite) TestCreateVirtualMachineDefaults() {
37 integration.SkipIf(s.Framework)
38 var response struct{ CreateVirtualMachine *model.VirtualMachine }
39 mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053bb\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
40 err := ResolverClient.Post(mutation, &response)
41
42 s.NoErrorf(err, "error resolving vm mutation")
43
44 s.NotNilf(response.CreateVirtualMachine, "returned vm is null")
45 virtualMachine := response.CreateVirtualMachine
46
47 s.Equal(model.MachineTypeQ35, virtualMachine.MachineType)
48 s.Equal(false, virtualMachine.TargetPowerState)
49 s.Equal(1, virtualMachine.Cpus)
50 s.Equal("1024Mi", virtualMachine.Memory)
51
52 _, err = s.DB.Exec(sqlquery.VirtualMachineDeleteQuery, virtualMachine.VirtualMachineID)
53 s.NoError(err)
54 }
55
56 func (s *Suite) TestCreateVirtualMachineInvalidMemoryOne() {
57 integration.SkipIf(s.Framework)
58 var response struct{ CreateVirtualMachine *model.VirtualMachine }
59
60 mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053bc\",memory:\"1024Gb\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
61 err := ResolverClient.Post(mutation, &response)
62 s.Errorf(err, "should be an error resolving vm mutation")
63 s.Nilf(response.CreateVirtualMachine, "returned vm is not null")
64 }
65
66 func (s *Suite) TestCreateVirtualMachineInvalidMemoryTwo() {
67 integration.SkipIf(s.Framework)
68 var response struct{ CreateVirtualMachine *model.VirtualMachine }
69
70 mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053bc\",memory:\"1024mb\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
71 err = ResolverClient.Post(mutation, &response)
72 s.Errorf(err, "should be an error resolving vm mutation")
73 s.Nilf(response.CreateVirtualMachine, "returned vm is not null")
74 }
75
76 func (s *Suite) TestCreateVirtualMachineHostnameExistsOnDifferentClusterNamespace() {
77 integration.SkipIf(s.Framework)
78 var response struct{ CreateVirtualMachine *model.VirtualMachine }
79
80 mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053aa\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
81 err := ResolverClient.Post(mutation, &response)
82 s.NoErrorf(err, "error resolving vm mutation")
83 s.NotNilf(response.CreateVirtualMachine, "returned vm is null")
84
85 virtualMachine := response.CreateVirtualMachine
86 s.Equal("618648c8-56f4-4578-a4ff-ae88782b0b9f", virtualMachine.ClusterEdgeID)
87 s.Equal("test-namespace", virtualMachine.Namespace)
88
89 _, err = s.DB.Exec(sqlquery.VirtualMachineDeleteQuery, virtualMachine.VirtualMachineID)
90 s.NoError(err)
91 }
92
93 func (s *Suite) TestGetVirtualMachineByID() {
94 integration.SkipIf(s.Framework)
95
96 var response struct{ VirtualMachine *model.VirtualMachine }
97 virtualMachineID := "9a84dd25-da1c-455a-8100-3370050169c8"
98 query := getVirtualMachineQuery(&virtualMachineID)
99 err := ResolverClient.Post(query, &response)
100
101 s.NoErrorf(err, "resolver failed for get VM by ID")
102 s.NotEmptyf(response.VirtualMachine, "resolver response empty for get VM by ID")
103 s.NotEmptyf(response.VirtualMachine.Disks, "failed to return VM's disks")
104 s.Equalf(virtualMachineID, response.VirtualMachine.VirtualMachineID, "incorrect VM returned for get VM by ID")
105 }
106
107 func (s *Suite) TestGetVirtualMachinesByClusterEdgeID() {
108 integration.SkipIf(s.Framework)
109 var response struct{ VirtualMachines []*model.VirtualMachine }
110 clusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
111 query := getVirtualMachinesQuery(&clusterEdgeID, nil)
112 err := ResolverClient.Post(query, &response)
113 s.NoErrorf(err, "resolver failed for get VMs by clusterEdgeID")
114 s.NotEmpty(response.VirtualMachines, "resolver response empty for get VMs by clusterEdgeID")
115 s.Equalf(2, len(response.VirtualMachines), "resolver response != 2 for get VMs by clusterEdgeID")
116 }
117
118 func (s *Suite) TestGetVirtualMachines() {
119 integration.SkipIf(s.Framework)
120 var response struct{ VirtualMachines []*model.VirtualMachine }
121 query := getVirtualMachinesQuery(nil, nil)
122 err := ResolverClient.Post(query, &response)
123 s.NoErrorf(err, "resolver failed for get VMs without input")
124 s.NotEmptyf(response.VirtualMachines, "resolver response empty for get VMs without input")
125 }
126
127 func (s *Suite) TestGetVirtualMachinesByHostname() {
128 integration.SkipIf(s.Framework)
129 var response struct{ VirtualMachines []*model.VirtualMachine }
130 virtualMachineHostname := "ien-00005e0053ab"
131 query := getVirtualMachinesQuery(nil, &virtualMachineHostname)
132 err := ResolverClient.Post(query, &response)
133 s.NoErrorf(err, "resolver failed for get VMs by hostname")
134 s.NotEmptyf(response.VirtualMachines, "resolver response empty for get VMs by hostname")
135 s.Equalf(1, len(response.VirtualMachines), "resolver response != 1 for get VMs by hostname")
136 virtualMachine := response.VirtualMachines[0]
137 s.Equal("d4d79814-149c-4120-892e-b2a38b4dca21", virtualMachine.VirtualMachineID, "incorrect VM returned for get VMs by hostname")
138 }
139
140 func (s *Suite) TestGetVirtualMachinesByClusterEdgeIDAndHostname() {
141 integration.SkipIf(s.Framework)
142 var response struct{ VirtualMachines []*model.VirtualMachine }
143 clusterEdgeID := "6e04c043-89ca-4dc2-a2ea-4605dbdd4c65"
144 virtualMachineHostname := "ien-00005e0053ac"
145 query := getVirtualMachinesQuery(&clusterEdgeID, &virtualMachineHostname)
146 err := ResolverClient.Post(query, &response)
147 s.NoErrorf(err, "resolver failed for get VMs by clusterEdgeID and hostname")
148 s.NotEmptyf(response.VirtualMachines, "resolver response empty for get VMs by clusterEdgeID and hostname")
149 s.Equalf(1, len(response.VirtualMachines), "resolver response != 1 for get VMs by clusterEdgeID and hostname")
150 virtualMachine := response.VirtualMachines[0]
151 s.Equalf("830389ef-186f-405b-b3e4-44875a624604", virtualMachine.VirtualMachineID, "incorrect VM returned for get VMs by clusterEdgeID and hostname")
152 }
153
154 func (s *Suite) TestUpdateVirtualMachine() {
155 integration.SkipIf(s.Framework)
156 var response struct{ UpdateVirtualMachine *model.VirtualMachine }
157
158 mutation := "mutation{updateVirtualMachine(updateVM:{virtualMachineId:\"9297e9b5-d5f5-43a7-a517-e8c4f3cdb166\",virtualMachineValues:{targetPowerState:true,cpus:2,memory:\"1024Mi\",machineType:i440fx}}){virtualMachineId,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
159 err := ResolverClient.Post(mutation, &response)
160 s.NoError(err)
161 s.NotNil(response.UpdateVirtualMachine)
162 virtualMachine := response.UpdateVirtualMachine
163 s.Equal("9297e9b5-d5f5-43a7-a517-e8c4f3cdb166", virtualMachine.VirtualMachineID)
164 s.Equal(true, virtualMachine.TargetPowerState)
165 s.Equal(2, virtualMachine.Cpus)
166 s.Equal("1024Mi", virtualMachine.Memory)
167 s.Equal(model.MachineTypeI440fx, virtualMachine.MachineType)
168 s.Nil(virtualMachine.Disks)
169 }
170
171 func (s *Suite) TestUpdateVirtualMachineWithDisks() {
172 integration.SkipIf(s.Framework)
173 var response struct{ UpdateVirtualMachine *model.VirtualMachine }
174
175 mutation := "mutation{updateVirtualMachine(updateVM:{virtualMachineId:\"9297e9b5-d5f5-43a7-a517-e8c4f3cdb166\",virtualMachineValues:{disks:{diskId:\"cbb62d9b-21b5-445d-a0e6-fce31b7257ca\",virtualMachineDiskValues:{containerImageUrl:\"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.7.2\"}}}}){virtualMachineId,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType,disks{diskId,containerImageUrl}}}"
176
177 err := ResolverClient.Post(mutation, &response)
178 s.NoErrorf(err, "error resolving vm mutation")
179
180 s.NotNilf(response.UpdateVirtualMachine, "returned vm is null")
181 virtualMachine := response.UpdateVirtualMachine
182
183 s.NotNil(virtualMachine.Disks)
184 s.Equal("cbb62d9b-21b5-445d-a0e6-fce31b7257ca", virtualMachine.Disks[0].DiskID)
185 s.Equal("docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.7.2", virtualMachine.Disks[0].ContainerImageURL)
186 }
187
188 func (s *Suite) TestDeleteVirtualMachine() {
189 integration.SkipIf(s.Framework)
190 var response struct{ DeleteVirtualMachine bool }
191 virtualMachineID := "cda453a6-1773-4161-8959-21c3c9586c7b"
192 mutation := deleteVirtualMachineMutation(&virtualMachineID)
193 err := ResolverClient.Post(mutation, &response)
194 s.NoErrorf(err, "resolver failed for delete VM")
195 s.Truef(response.DeleteVirtualMachine, "resolver returned false for delete VM")
196 }
197
198 func deleteVirtualMachineMutation(virtualMachineID *string) string {
199 return MustParse(graphb.Query{
200 Type: graphb.TypeMutation,
201 Fields: []*graphb.Field{
202 {
203 Name: "deleteVirtualMachine",
204 Arguments: []graphb.Argument{
205 graphb.ArgumentString("virtualMachineId", utils.ConvertToString(virtualMachineID)),
206 },
207 },
208 },
209 })
210 }
211
212 func getVirtualMachineQuery(virtualMachineID *string) string {
213 return MustParse(graphb.Query{
214 Type: graphb.TypeQuery,
215 Fields: []*graphb.Field{
216 {
217 Name: "virtualMachine",
218 Arguments: []graphb.Argument{
219 graphb.ArgumentString("virtualMachineId", utils.ConvertToString(virtualMachineID)),
220 },
221 Fields: virtualMachineFields,
222 },
223 },
224 })
225 }
226
227 func getVirtualMachinesQuery(clusterEdgeID *string, virtualMachineHostname *string) string {
228 getVirtualMachinesArg := []graphb.Argument{}
229 if clusterEdgeID != nil {
230 getVirtualMachinesArg = append(getVirtualMachinesArg, graphb.ArgumentString("clusterEdgeId", utils.ConvertToString(clusterEdgeID)))
231 }
232 if virtualMachineHostname != nil {
233 getVirtualMachinesArg = append(getVirtualMachinesArg, graphb.ArgumentString("hostname", utils.ConvertToString(virtualMachineHostname)))
234 }
235 return MustParse(graphb.Query{
236 Type: graphb.TypeQuery,
237 Fields: []*graphb.Field{
238 {
239 Name: "virtualMachines",
240 Arguments: getVirtualMachinesArg,
241 Fields: virtualMachineFields,
242 },
243 },
244 })
245 }
246
247 var virtualMachineFields = []*graphb.Field{
248 {
249 Name: "virtualMachineId",
250 },
251 {
252 Name: "namespace",
253 },
254 {
255 Name: "clusterEdgeId",
256 },
257 {
258 Name: "clusterName",
259 },
260 {
261 Name: "hostname",
262 },
263 {
264 Name: "targetPowerState",
265 },
266 {
267 Name: "cpus",
268 },
269 {
270 Name: "memory",
271 },
272 {
273 Name: "machineType",
274 },
275 {
276 Name: "disks",
277 Fields: virtualMachineDiskFields,
278 },
279 }
280
View as plain text