← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/altoros/gosigma/server_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/altoros/gosigma/server_test.go
 
1
// Copyright 2014 ALTOROS
 
2
// Licensed under the AGPLv3, see LICENSE file for details.
 
3
 
 
4
package gosigma
 
5
 
 
6
import (
 
7
        "testing"
 
8
 
 
9
        "github.com/altoros/gosigma/data"
 
10
        "github.com/altoros/gosigma/mock"
 
11
)
 
12
 
 
13
func TestClientServersEmpty(t *testing.T) {
 
14
        mock.ResetServers()
 
15
 
 
16
        cli, err := createTestClient(t)
 
17
        if err != nil || cli == nil {
 
18
                t.Error("NewClient() failed:", err, cli)
 
19
                return
 
20
        }
 
21
 
 
22
        check := func(rqspec RequestSpec) {
 
23
                servers, err := cli.Servers(rqspec)
 
24
                if err != nil {
 
25
                        t.Error(err)
 
26
                }
 
27
                if len(servers) > 0 {
 
28
                        t.Errorf("%v", servers)
 
29
                }
 
30
        }
 
31
 
 
32
        check(RequestShort)
 
33
        check(RequestDetail)
 
34
}
 
35
 
 
36
func TestClientServers(t *testing.T) {
 
37
        mock.ResetServers()
 
38
 
 
39
        ds := newDataServer()
 
40
        mock.AddServer(ds)
 
41
 
 
42
        cli, err := createTestClient(t)
 
43
        if err != nil {
 
44
                t.Error(err)
 
45
                return
 
46
        }
 
47
 
 
48
        servers, err := cli.Servers(true)
 
49
        if err != nil {
 
50
                t.Error(err)
 
51
                return
 
52
        }
 
53
 
 
54
        if len(servers) != 1 {
 
55
                t.Errorf("invalid len: %v", servers)
 
56
                return
 
57
        }
 
58
 
 
59
        s := servers[0]
 
60
 
 
61
        if s.String() == "" {
 
62
                t.Error("Empty string representation")
 
63
                return
 
64
        }
 
65
 
 
66
        checkv := func(v, wants string) {
 
67
                if v != wants {
 
68
                        t.Errorf("value %s, wants %s", v, wants)
 
69
                }
 
70
        }
 
71
        checkv(s.Name(), "name")
 
72
        checkv(s.URI(), "uri")
 
73
        checkv(s.Status(), "status")
 
74
        checkv(s.UUID(), "uuid")
 
75
 
 
76
        checkg := func(s Server, k, wants string) {
 
77
                if v, ok := s.Get(k); !ok || v != wants {
 
78
                        t.Errorf("value of Get(%q) = %q, %v; wants %s", k, v, ok, wants)
 
79
                }
 
80
        }
 
81
        checkg(s, "key1", "value1")
 
82
        checkg(s, "key2", "value2")
 
83
 
 
84
        // refresh
 
85
        ds.Name = "name1"
 
86
        ds.URI = "uri1"
 
87
        ds.Status = "status1"
 
88
        ds.Meta["key1"] = "value11"
 
89
        ds.Meta["key2"] = "value22"
 
90
        ds.Meta["key3"] = "value33"
 
91
        ds.Context = true
 
92
        ds.CPU = 100
 
93
        ds.CPUsInsteadOfCores = true
 
94
        ds.CPUModel = "cpu_model"
 
95
        if err := s.Refresh(); err != nil {
 
96
                t.Error(err)
 
97
                return
 
98
        }
 
99
        checkv(s.Name(), "name1")
 
100
        checkv(s.URI(), "uri1")
 
101
        checkv(s.Status(), "status1")
 
102
        checkg(s, "key1", "value11")
 
103
        checkg(s, "key2", "value22")
 
104
        checkg(s, "key3", "value33")
 
105
        if v := s.Context(); v != true {
 
106
                t.Errorf("Server.Context() failed")
 
107
        }
 
108
        if v := s.CPU(); v != 100 {
 
109
                t.Errorf("Server.CPU() failed")
 
110
        }
 
111
        if v := s.CPUsInsteadOfCores(); v != true {
 
112
                t.Errorf("Server.CPUsInsteadOfCores() failed")
 
113
        }
 
114
        if v := s.CPUModel(); v != "cpu_model" {
 
115
                t.Errorf("Server.CPUModel() failed")
 
116
        }
 
117
 
 
118
        // failed refresh
 
119
        mock.ResetServers()
 
120
        if err := s.Refresh(); err == nil {
 
121
                t.Error("Server refresh must fail")
 
122
                return
 
123
        }
 
124
 
 
125
        mock.ResetServers()
 
126
}
 
127
 
 
128
func TestClientServer(t *testing.T) {
 
129
        mock.ResetServers()
 
130
 
 
131
        ds := newDataServer()
 
132
        mock.AddServer(ds)
 
133
 
 
134
        cli, err := createTestClient(t)
 
135
        if err != nil {
 
136
                t.Error(err)
 
137
                return
 
138
        }
 
139
 
 
140
        if s, err := cli.Server(""); err == nil {
 
141
                t.Errorf("Server() returned valid result for empty uuid: %#v", s)
 
142
                return
 
143
        }
 
144
 
 
145
        s, err := cli.Server("uuid")
 
146
        if err != nil {
 
147
                t.Error(err)
 
148
                return
 
149
        }
 
150
 
 
151
        if s.String() == "" {
 
152
                t.Error("Empty string representation")
 
153
        }
 
154
 
 
155
        checkv := func(v, wants string) {
 
156
                if v != wants {
 
157
                        t.Errorf("value %s, wants %s", v, wants)
 
158
                }
 
159
        }
 
160
        checkv(s.Name(), "name")
 
161
        checkv(s.URI(), "uri")
 
162
        checkv(s.Status(), "status")
 
163
        checkv(s.UUID(), "uuid")
 
164
 
 
165
        checkg := func(s Server, k, wants string) {
 
166
                if v, ok := s.Get(k); !ok || v != wants {
 
167
                        t.Errorf("value of Get(%q) = %q, %v; wants %s", k, v, ok, wants)
 
168
                }
 
169
        }
 
170
        checkg(s, "key1", "value1")
 
171
        checkg(s, "key2", "value2")
 
172
 
 
173
        // refresh
 
174
        ds.Name = "name1"
 
175
        ds.URI = "uri1"
 
176
        ds.Status = "status1"
 
177
        ds.Meta["key1"] = "value11"
 
178
        ds.Meta["key2"] = "value22"
 
179
        ds.Meta["key3"] = "value33"
 
180
        if err := s.Refresh(); err != nil {
 
181
                t.Error(err)
 
182
        }
 
183
        checkv(s.Name(), "name1")
 
184
        checkv(s.URI(), "uri1")
 
185
        checkv(s.Status(), "status1")
 
186
        checkg(s, "key1", "value11")
 
187
        checkg(s, "key2", "value22")
 
188
        checkg(s, "key3", "value33")
 
189
 
 
190
        // failed refresh
 
191
        mock.ResetServers()
 
192
        if err := s.Refresh(); err == nil {
 
193
                t.Error("Server refresh must fail")
 
194
        }
 
195
}
 
196
 
 
197
func TestClientServerNotFound(t *testing.T) {
 
198
        mock.ResetServers()
 
199
 
 
200
        cli, err := createTestClient(t)
 
201
        if err != nil {
 
202
                t.Error(err)
 
203
                return
 
204
        }
 
205
 
 
206
        s, err := cli.Server("uuid1234567")
 
207
        if err == nil {
 
208
                t.Errorf("found server %#v", s)
 
209
        }
 
210
 
 
211
        t.Log(err)
 
212
        cs, ok := err.(*Error)
 
213
        if !ok {
 
214
                t.Error("error required to be gosigma.Error")
 
215
        }
 
216
        if cs.ServiceError.Message != "notfound" {
 
217
                t.Error("invalid error message from mock server")
 
218
        }
 
219
}
 
220
 
 
221
func TestClientServersShort(t *testing.T) {
 
222
        mock.ResetServers()
 
223
 
 
224
        ds := newDataServer()
 
225
        mock.AddServer(ds)
 
226
 
 
227
        cli, err := createTestClient(t)
 
228
        if err != nil {
 
229
                t.Error(err)
 
230
                return
 
231
        }
 
232
 
 
233
        ss, err := cli.Servers(false)
 
234
        if err != nil {
 
235
                t.Error(err)
 
236
                return
 
237
        }
 
238
 
 
239
        if v, ok := ss[0].Get("key1"); ok || len(v) > 0 {
 
240
                t.Error("Error getting short server list")
 
241
        }
 
242
 
 
243
        ss, err = cli.Servers(true)
 
244
        if err != nil {
 
245
                t.Error(err)
 
246
        }
 
247
 
 
248
        if v, ok := ss[0].Get("key1"); !ok || len(v) == 0 {
 
249
                t.Error("Error getting detailed server list")
 
250
        }
 
251
 
 
252
        mock.ResetServers()
 
253
}
 
254
 
 
255
func TestClientStartServerInvalidUUID(t *testing.T) {
 
256
        mock.ResetServers()
 
257
 
 
258
        cli, err := createTestClient(t)
 
259
        if err != nil {
 
260
                t.Error(err)
 
261
                return
 
262
        }
 
263
 
 
264
        // No Server
 
265
        if err := cli.StartServer("uuid-123", nil); err == nil {
 
266
                t.Error("Start server must fail here")
 
267
        } else {
 
268
                t.Log("Start server:", err)
 
269
        }
 
270
 
 
271
        // No Server with empty non-nil avoid
 
272
        if err := cli.StartServer("uuid-123", []string{}); err == nil {
 
273
                t.Error("Start server must fail here")
 
274
        } else {
 
275
                t.Log("Start server:", err)
 
276
        }
 
277
 
 
278
        // No Server with non-empty non-nil avoid
 
279
        if err := cli.StartServer("uuid-123", []string{"non-uuid"}); err == nil {
 
280
                t.Error("Start server must fail here")
 
281
        } else {
 
282
                t.Log("Start server:", err)
 
283
        }
 
284
}
 
285
 
 
286
func TestClientStartServer(t *testing.T) {
 
287
        mock.ResetServers()
 
288
 
 
289
        ds := newDataServer()
 
290
        ds.Status = "stopped"
 
291
        mock.AddServer(ds)
 
292
 
 
293
        cli, err := createTestClient(t)
 
294
        if err != nil {
 
295
                t.Error(err)
 
296
                return
 
297
        }
 
298
 
 
299
        s, err := cli.Server("uuid")
 
300
        if err != nil {
 
301
                t.Error(err)
 
302
                return
 
303
        }
 
304
 
 
305
        if err := s.Start(); err != nil {
 
306
                t.Error(err)
 
307
                return
 
308
        }
 
309
 
 
310
        for i := 0; i < 10 && s.Status() != ServerRunning; i++ {
 
311
                if err := s.Refresh(); err != nil {
 
312
                        t.Error(err)
 
313
                        return
 
314
                }
 
315
        }
 
316
 
 
317
        if s.Status() != ServerRunning {
 
318
                t.Error("Server status must be running")
 
319
        }
 
320
}
 
321
 
 
322
func TestClientStopServer(t *testing.T) {
 
323
        mock.ResetServers()
 
324
 
 
325
        ds := newDataServer()
 
326
        ds.Status = "running"
 
327
        mock.AddServer(ds)
 
328
 
 
329
        cli, err := createTestClient(t)
 
330
        if err != nil {
 
331
                t.Error(err)
 
332
                return
 
333
        }
 
334
 
 
335
        s, err := cli.Server("uuid")
 
336
        if err != nil {
 
337
                t.Error(err)
 
338
                return
 
339
        }
 
340
 
 
341
        if err := s.Stop(); err != nil {
 
342
                t.Error(err)
 
343
                return
 
344
        }
 
345
 
 
346
        for i := 0; i < 10 && s.Status() != ServerStopped; i++ {
 
347
                if err := s.Refresh(); err != nil {
 
348
                        t.Error(err)
 
349
                        return
 
350
                }
 
351
        }
 
352
 
 
353
        if s.Status() != ServerStopped {
 
354
                t.Error("Server status must be stopped")
 
355
        }
 
356
}
 
357
 
 
358
func TestClientCreateServer(t *testing.T) {
 
359
        mock.ResetServers()
 
360
 
 
361
        cli, err := createTestClient(t)
 
362
        if err != nil {
 
363
                t.Error(err)
 
364
                return
 
365
        }
 
366
 
 
367
        var c Components
 
368
        c.SetName("test")
 
369
        c.SetCPU(2000)
 
370
        c.SetMem(2147483648)
 
371
        c.SetSMP(20)
 
372
        c.SetVNCPassword("testserver")
 
373
        c.NetworkDHCP4("virtio")
 
374
        c.NetworkManual4("virtio")
 
375
        c.NetworkStatic4("virtio", "ipaddr")
 
376
        c.NetworkVLan("virtio", "vlanid")
 
377
        c.AttachDrive(1, "0:0", "virtio", "uuid")
 
378
 
 
379
        s, err := cli.CreateServer(c)
 
380
        if err != nil {
 
381
                t.Error(err)
 
382
                return
 
383
        }
 
384
 
 
385
        if s.Name() != "test" {
 
386
                t.Error("Invalid name")
 
387
        }
 
388
        if s.CPU() != 2000 {
 
389
                t.Error("Invalid cpu")
 
390
        }
 
391
        if s.Mem() != 2147483648 {
 
392
                t.Error("Invalid mem")
 
393
        }
 
394
        if s.SMP() != 20 {
 
395
                t.Error("Invalid mem")
 
396
        }
 
397
        if s.Status() != ServerStopped {
 
398
                t.Error("Server status must be stopped")
 
399
        }
 
400
        if s.VNCPassword() != "testserver" {
 
401
                t.Error("VNCPassword invalid")
 
402
        }
 
403
        if v := s.IPv4(); len(v) != 0 {
 
404
                t.Error("IPv4 invalid:", v)
 
405
        }
 
406
 
 
407
        nics := s.NICs()
 
408
        if len(nics) != 4 {
 
409
                t.Errorf("NICs error: %#v", nics)
 
410
        }
 
411
 
 
412
        n := nics[0]
 
413
        if c := n.IPv4().Conf(); c != "dhcp" {
 
414
                t.Errorf("NIC.Conf [0]: %q", c)
 
415
        }
 
416
        if n.Model() != "virtio" {
 
417
                t.Errorf("NIC.Model [0]: %q", n.Model())
 
418
        }
 
419
        if n.MAC() != "" {
 
420
                t.Errorf("NIC.MAC [0]: %q", n.MAC())
 
421
        }
 
422
        if v := n.VLAN(); v != nil {
 
423
                t.Errorf("NIC.VLAN [0] must be nil, %v", v)
 
424
        }
 
425
 
 
426
        n = nics[1]
 
427
        if c := n.IPv4().Conf(); c != "manual" {
 
428
                t.Errorf("NIC.Conf [1]: %q", c)
 
429
        }
 
430
        if n.Model() != "virtio" {
 
431
                t.Errorf("NIC.Model [1]: %q", n.Model())
 
432
        }
 
433
        if n.MAC() != "" {
 
434
                t.Errorf("NIC.MAC [1]: %q", n.MAC())
 
435
        }
 
436
        if v := n.VLAN(); v != nil {
 
437
                t.Errorf("NIC.VLAN [1] must be nil, %v", v)
 
438
        }
 
439
 
 
440
        n = nics[2]
 
441
        if c := n.IPv4().Conf(); c != "static" {
 
442
                t.Errorf("NIC.Conf [2]: %q", c)
 
443
        }
 
444
        if n.Model() != "virtio" {
 
445
                t.Errorf("NIC.Model [2]: %q", n.Model())
 
446
        }
 
447
        if n.MAC() != "" {
 
448
                t.Errorf("NIC.MAC [2]: %q", n.MAC())
 
449
        }
 
450
        if v := n.VLAN(); v != nil {
 
451
                t.Errorf("NIC.VLAN [2] must be nil, %v", v)
 
452
        }
 
453
 
 
454
        n = nics[3]
 
455
        if v := n.IPv4(); v != nil {
 
456
                t.Errorf("NIC.IPV4 [3]: %q", v)
 
457
        }
 
458
        if n.Model() != "virtio" {
 
459
                t.Errorf("NIC.Model [3]: %q", n.Model())
 
460
        }
 
461
        if n.MAC() != "" {
 
462
                t.Errorf("NIC.MAC [3]: %q", n.MAC())
 
463
        }
 
464
        if v := n.VLAN(); v == nil {
 
465
                t.Error("NIC.VLAN [3] must be not nil")
 
466
        } else if vv := v.UUID(); vv != "vlanid" {
 
467
                t.Errorf("NIC.VLAN [3]: %q", vv)
 
468
        }
 
469
 
 
470
        drives := s.Drives()
 
471
        if len(drives) != 1 {
 
472
                t.Errorf("Drives error: %#v", drives)
 
473
        }
 
474
 
 
475
        dd := drives[0]
 
476
        if v := dd.BootOrder(); v != 1 {
 
477
                t.Errorf("ServerDrive.BootOrder: %#v", v)
 
478
        }
 
479
        if v := dd.Channel(); v != "0:0" {
 
480
                t.Errorf("ServerDrive.BootOrder: %#v", v)
 
481
        }
 
482
        if v := dd.Device(); v != "virtio" {
 
483
                t.Errorf("ServerDrive.Device: %#v", v)
 
484
        }
 
485
        if v := dd.UUID(); v != "uuid" {
 
486
                t.Errorf("ServerDrive.UUID: %#v", v)
 
487
        }
 
488
        if v := dd.URI(); v != "/api/2.0/drives/uuid/" {
 
489
                t.Errorf("ServerDrive.URI: %#v", v)
 
490
        }
 
491
        if v := dd.String(); v != `{BootOrder: 1, Channel: "0:0", Device: "virtio", UUID: "uuid"}` {
 
492
                t.Errorf("ServerDrive.String: %#v", v)
 
493
        }
 
494
 
 
495
        ddd := dd.Drive()
 
496
        if v := ddd.UUID(); v != "uuid" {
 
497
                t.Errorf("Drive.UUID: %#v", v)
 
498
        }
 
499
        if v := ddd.URI(); v != data.MakeDriveResource("uuid").URI {
 
500
                t.Errorf("Drive.URI: %#v", v)
 
501
        }
 
502
        if v := ddd.Name(); v != "" {
 
503
                t.Errorf("Drive.Name: %#v", v)
 
504
        }
 
505
        if v := ddd.Status(); v != "" {
 
506
                t.Errorf("Drive.Status: %#v", v)
 
507
        }
 
508
        if v := ddd.Media(); v != "" {
 
509
                t.Errorf("Drive.Media: %#v", v)
 
510
        }
 
511
        if v := ddd.StorageType(); v != "" {
 
512
                t.Errorf("Drive.StorageType: %#v", v)
 
513
        }
 
514
        if v := ddd.Size(); v != 0 {
 
515
                t.Errorf("Drive.Size: %#v", v)
 
516
        }
 
517
}
 
518
 
 
519
func TestServerIPv4(t *testing.T) {
 
520
        s := &server{obj: &data.Server{
 
521
                NICs: []data.NIC{
 
522
                        data.NIC{},
 
523
                        data.NIC{Runtime: &data.RuntimeNetwork{}},
 
524
                },
 
525
        }}
 
526
 
 
527
        if ips := s.IPv4(); len(ips) != 0 {
 
528
                t.Errorf("invalid Server.IPv4(): %v", ips)
 
529
        }
 
530
 
 
531
        nic0 := data.NIC{Runtime: &data.RuntimeNetwork{
 
532
                IPv4: data.MakeIPResource("0.1.2.3"),
 
533
        }}
 
534
        s.obj.NICs = append(s.obj.NICs, nic0)
 
535
 
 
536
        if ips := s.IPv4(); len(ips) != 1 || ips[0] != "0.1.2.3" {
 
537
                t.Errorf("invalid Server.IPv4(): %v", ips)
 
538
        }
 
539
 
 
540
        nic1 := data.NIC{Runtime: &data.RuntimeNetwork{
 
541
                IPv4: data.MakeIPResource("0.2.3.4"),
 
542
        }}
 
543
        s.obj.NICs = append(s.obj.NICs, nic1)
 
544
 
 
545
        if ips := s.IPv4(); len(ips) != 2 || ips[0] != "0.1.2.3" || ips[1] != "0.2.3.4" {
 
546
                t.Errorf("invalid Server.IPv4(): %v", ips)
 
547
        }
 
548
}