← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/altoros/gosigma/live_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/live_test.go
 
1
// Copyright 2014 ALTOROS
 
2
// Licensed under the AGPLv3, see LICENSE file for details.
 
3
 
 
4
package gosigma
 
5
 
 
6
import (
 
7
        "errors"
 
8
        "flag"
 
9
        "strings"
 
10
        "testing"
 
11
        "time"
 
12
)
 
13
 
 
14
var live = flag.String("live", "", "run live tests against CloudSigma endpoint, specify credentials in form -live=user:pass")
 
15
var suid = flag.String("suid", "", "uuid of server at CloudSigma to run server specific tests")
 
16
var duid = flag.String("duid", "", "uuid of drive at CloudSigma to run drive specific tests")
 
17
var vlan = flag.String("vlan", "", "uuid of vlan at CloudSigma to run server specific tests")
 
18
var sshkey = flag.String("sshkey", "", "public ssh key to run server specific tests")
 
19
var force = flag.Bool("force", false, "force start/stop live tests")
 
20
var lib = flag.Bool("lib", false, "duid is library drive")
 
21
var size = flag.Uint64("size", 0, "size for operations: TestLiveDriveResize")
 
22
 
 
23
func libFlag() LibrarySpec {
 
24
        if *lib {
 
25
                return LibraryMedia
 
26
        }
 
27
        return LibraryAccount
 
28
}
 
29
 
 
30
func parseCredentials() (u string, p string, e error) {
 
31
        if *live == "" {
 
32
                return
 
33
        }
 
34
 
 
35
        parts := strings.SplitN(*live, ":", 2)
 
36
        if len(parts) != 2 || parts[0] == "" {
 
37
                e = errors.New("Invalid credentials: " + *live)
 
38
                return
 
39
        }
 
40
 
 
41
        u, p = parts[0], parts[1]
 
42
 
 
43
        return
 
44
}
 
45
 
 
46
func skipTest(t *testing.T, e error) {
 
47
        if e == nil {
 
48
                t.SkipNow()
 
49
        } else {
 
50
                t.Error(e)
 
51
        }
 
52
}
 
53
 
 
54
func TestLiveServers(t *testing.T) {
 
55
        u, p, err := parseCredentials()
 
56
        if u == "" {
 
57
                skipTest(t, err)
 
58
                return
 
59
        }
 
60
 
 
61
        cli, err := NewClient(DefaultRegion, u, p, nil)
 
62
        if err != nil {
 
63
                t.Error(err)
 
64
                return
 
65
        }
 
66
 
 
67
        if *trace {
 
68
                cli.Logger(t)
 
69
        }
 
70
 
 
71
        ii, err := cli.Servers(false)
 
72
        if err != nil {
 
73
                t.Error(err)
 
74
                return
 
75
        }
 
76
        t.Logf("%v", ii)
 
77
}
 
78
 
 
79
func TestLiveServerGet(t *testing.T) {
 
80
        u, p, err := parseCredentials()
 
81
        if u == "" {
 
82
                skipTest(t, err)
 
83
                return
 
84
        }
 
85
 
 
86
        if *suid == "" {
 
87
                t.Skip("-suid=<server-uuid> must be specified")
 
88
                return
 
89
        }
 
90
 
 
91
        cli, err := NewClient(DefaultRegion, u, p, nil)
 
92
        if err != nil {
 
93
                t.Error(err)
 
94
                return
 
95
        }
 
96
 
 
97
        if *trace {
 
98
                cli.Logger(t)
 
99
        }
 
100
 
 
101
        s, err := cli.Server(*suid)
 
102
        if err != nil {
 
103
                t.Error(err)
 
104
                return
 
105
        }
 
106
        t.Logf("%v", s)
 
107
}
 
108
 
 
109
func TestLiveServerStart(t *testing.T) {
 
110
        u, p, err := parseCredentials()
 
111
        if u == "" {
 
112
                skipTest(t, err)
 
113
                return
 
114
        }
 
115
 
 
116
        if *suid == "" {
 
117
                t.Skip("-suid=<server-uuid> must be specified")
 
118
                return
 
119
        }
 
120
 
 
121
        cli, err := NewClient(DefaultRegion, u, p, nil)
 
122
        if err != nil {
 
123
                t.Error(err)
 
124
                return
 
125
        }
 
126
 
 
127
        if *trace {
 
128
                cli.Logger(t)
 
129
        }
 
130
 
 
131
        s, err := cli.Server(*suid)
 
132
        if err != nil {
 
133
                t.Error(err)
 
134
                return
 
135
        }
 
136
 
 
137
        if s.Status() != ServerStopped && !*force {
 
138
                t.Skip("wrong server status", s.Status())
 
139
                return
 
140
        }
 
141
 
 
142
        if err := s.Start(); err != nil {
 
143
                t.Error(err)
 
144
        }
 
145
}
 
146
 
 
147
func TestLiveServerStartWait(t *testing.T) {
 
148
        u, p, err := parseCredentials()
 
149
        if u == "" {
 
150
                skipTest(t, err)
 
151
                return
 
152
        }
 
153
 
 
154
        if *suid == "" {
 
155
                t.Skip("-suid=<server-uuid> must be specified")
 
156
                return
 
157
        }
 
158
 
 
159
        cli, err := NewClient(DefaultRegion, u, p, nil)
 
160
        if err != nil {
 
161
                t.Error(err)
 
162
                return
 
163
        }
 
164
 
 
165
        if *trace {
 
166
                cli.Logger(t)
 
167
        }
 
168
 
 
169
        s, err := cli.Server(*suid)
 
170
        if err != nil {
 
171
                t.Error(err)
 
172
                return
 
173
        }
 
174
 
 
175
        if s.Status() != ServerStopped && !*force {
 
176
                t.Skip("wrong server status", s.Status())
 
177
                return
 
178
        }
 
179
 
 
180
        if err := s.StartWait(); err != nil {
 
181
                t.Error(err)
 
182
        }
 
183
}
 
184
 
 
185
func TestLiveServerStop(t *testing.T) {
 
186
        u, p, err := parseCredentials()
 
187
        if u == "" {
 
188
                skipTest(t, err)
 
189
                return
 
190
        }
 
191
 
 
192
        if *suid == "" {
 
193
                t.Skip("-suid=<server-uuid> must be specified")
 
194
                return
 
195
        }
 
196
 
 
197
        cli, err := NewClient(DefaultRegion, u, p, nil)
 
198
        if err != nil {
 
199
                t.Error(err)
 
200
                return
 
201
        }
 
202
 
 
203
        if *trace {
 
204
                cli.Logger(t)
 
205
        }
 
206
 
 
207
        s, err := cli.Server(*suid)
 
208
        if err != nil {
 
209
                t.Error(err)
 
210
                return
 
211
        }
 
212
 
 
213
        if s.Status() != ServerRunning && !*force {
 
214
                t.Skip("wrong server status", s.Status())
 
215
                return
 
216
        }
 
217
 
 
218
        if err := s.Stop(); err != nil {
 
219
                t.Error(err)
 
220
        }
 
221
}
 
222
 
 
223
func TestLiveDriveGet(t *testing.T) {
 
224
        u, p, err := parseCredentials()
 
225
        if u == "" {
 
226
                skipTest(t, err)
 
227
                return
 
228
        }
 
229
 
 
230
        if *duid == "" {
 
231
                t.Skip("-duid=<drive-uuid> must be specified")
 
232
                return
 
233
        }
 
234
 
 
235
        cli, err := NewClient(DefaultRegion, u, p, nil)
 
236
        if err != nil {
 
237
                t.Error(err)
 
238
                return
 
239
        }
 
240
 
 
241
        if *trace {
 
242
                cli.Logger(t)
 
243
        }
 
244
 
 
245
        d, err := cli.Drive(*duid, libFlag())
 
246
        if err != nil {
 
247
                t.Error(err)
 
248
                return
 
249
        }
 
250
        t.Logf("%v", d)
 
251
}
 
252
 
 
253
func TestLiveDriveList(t *testing.T) {
 
254
        u, p, err := parseCredentials()
 
255
        if u == "" {
 
256
                skipTest(t, err)
 
257
                return
 
258
        }
 
259
 
 
260
        cli, err := NewClient(DefaultRegion, u, p, nil)
 
261
        if err != nil {
 
262
                t.Error(err)
 
263
                return
 
264
        }
 
265
 
 
266
        if *trace {
 
267
                cli.Logger(t)
 
268
        }
 
269
 
 
270
        dd, err := cli.Drives(true, libFlag())
 
271
        if err != nil {
 
272
                t.Error(err)
 
273
                return
 
274
        }
 
275
 
 
276
        for _, d := range dd {
 
277
                t.Logf("%v", d)
 
278
        }
 
279
}
 
280
 
 
281
func TestLiveDriveClone(t *testing.T) {
 
282
        u, p, err := parseCredentials()
 
283
        if u == "" {
 
284
                skipTest(t, err)
 
285
                return
 
286
        }
 
287
 
 
288
        if *duid == "" {
 
289
                t.Skip("-duid=<drive-uuid> must be specified")
 
290
                return
 
291
        }
 
292
 
 
293
        cli, err := NewClient(DefaultRegion, u, p, nil)
 
294
        if err != nil {
 
295
                t.Error(err)
 
296
                return
 
297
        }
 
298
 
 
299
        if *trace {
 
300
                cli.Logger(t)
 
301
        }
 
302
 
 
303
        d, err := cli.Drive(*duid, libFlag())
 
304
        if err != nil {
 
305
                t.Error(err)
 
306
                return
 
307
        }
 
308
 
 
309
        var cloneParams CloneParams
 
310
        cloneParams.Name = "LiveTest-" + time.Now().Format("15-04-05-999999999")
 
311
        newDrive, err := d.CloneWait(cloneParams, nil)
 
312
        if err != nil {
 
313
                t.Error(err)
 
314
                return
 
315
        }
 
316
        t.Logf("%v", newDrive)
 
317
}
 
318
 
 
319
func TestLiveServerClone(t *testing.T) {
 
320
        u, p, err := parseCredentials()
 
321
        if u == "" {
 
322
                skipTest(t, err)
 
323
                return
 
324
        }
 
325
 
 
326
        if *duid == "" {
 
327
                t.Skip("-duid=<drive-uuid> must be specified")
 
328
                return
 
329
        }
 
330
 
 
331
        if *vlan == "" {
 
332
                t.Skip("-vlan=<vlan-uuid> must be specified")
 
333
                return
 
334
        }
 
335
 
 
336
        if *sshkey == "" {
 
337
                t.Skip("-sshkey=<ssh-public-key> must be specified")
 
338
                return
 
339
        }
 
340
 
 
341
        cli, err := NewClient(DefaultRegion, u, p, nil)
 
342
        if err != nil {
 
343
                t.Error(err)
 
344
                return
 
345
        }
 
346
 
 
347
        if *trace {
 
348
                cli.Logger(t)
 
349
        }
 
350
 
 
351
        originalDrive, err := cli.Drive(*duid, libFlag())
 
352
        if err != nil {
 
353
                t.Error(err)
 
354
                return
 
355
        }
 
356
 
 
357
        stamp := time.Now().Format("15-04-05-999999999")
 
358
 
 
359
        var cloneParams CloneParams
 
360
        cloneParams.Name = "LiveTest-drv-" + stamp
 
361
        newDrive, err := originalDrive.CloneWait(cloneParams, nil)
 
362
        if err != nil {
 
363
                t.Error(err)
 
364
                return
 
365
        }
 
366
 
 
367
        var c Components
 
368
        c.SetName("LiveTest-srv-" + stamp)
 
369
        c.SetCPU(2000)
 
370
        c.SetMem(2 * Gigabyte)
 
371
        c.SetVNCPassword("test-vnc-password")
 
372
        c.SetSSHPublicKey(*sshkey)
 
373
        c.SetDescription("test-description")
 
374
        c.AttachDrive(1, "0:0", "virtio", newDrive.UUID())
 
375
        c.NetworkDHCP4(ModelVirtio)
 
376
        c.NetworkVLan(ModelVirtio, *vlan)
 
377
 
 
378
        s, err := cli.CreateServer(c)
 
379
 
 
380
        if err != nil {
 
381
                t.Error(err)
 
382
                return
 
383
        }
 
384
 
 
385
        t.Logf("%v", s)
 
386
}
 
387
 
 
388
func TestLiveServerRemove(t *testing.T) {
 
389
        u, p, err := parseCredentials()
 
390
        if u == "" {
 
391
                skipTest(t, err)
 
392
                return
 
393
        }
 
394
 
 
395
        if *suid == "" {
 
396
                t.Skip("-suid=<server-uuid> must be specified")
 
397
                return
 
398
        }
 
399
 
 
400
        cli, err := NewClient(DefaultRegion, u, p, nil)
 
401
        if err != nil {
 
402
                t.Error("create client", err)
 
403
                return
 
404
        }
 
405
 
 
406
        if *trace {
 
407
                cli.Logger(t)
 
408
        }
 
409
 
 
410
        s, err := cli.Server(*suid)
 
411
        if err != nil {
 
412
                t.Error("query server:", err)
 
413
                return
 
414
        }
 
415
 
 
416
        if s.Status() != ServerStopped {
 
417
                if err := s.StopWait(); err != nil {
 
418
                        t.Error("stop server:", err)
 
419
                        return
 
420
                }
 
421
        }
 
422
 
 
423
        err = s.Remove(RecurseAllDrives)
 
424
        if err != nil {
 
425
                t.Error(err)
 
426
                return
 
427
        }
 
428
 
 
429
        t.Log("Server deleted")
 
430
}
 
431
 
 
432
func TestLiveDriveResize(t *testing.T) {
 
433
        u, p, err := parseCredentials()
 
434
        if u == "" {
 
435
                skipTest(t, err)
 
436
                return
 
437
        }
 
438
 
 
439
        if *duid == "" {
 
440
                t.Skip("-duid=<drive-uuid> must be specified")
 
441
                return
 
442
        }
 
443
 
 
444
        if *size == 0 {
 
445
                t.Skip("-size=<drive-size> must be specified")
 
446
                return
 
447
        }
 
448
 
 
449
        cli, err := NewClient(DefaultRegion, u, p, nil)
 
450
        if err != nil {
 
451
                t.Error(err)
 
452
                return
 
453
        }
 
454
 
 
455
        if *trace {
 
456
                cli.Logger(t)
 
457
        }
 
458
 
 
459
        d, err := cli.Drive(*duid, libFlag())
 
460
        if err != nil {
 
461
                t.Error(err)
 
462
                return
 
463
        }
 
464
 
 
465
        t.Logf("Current drive size: %d", d.Size())
 
466
        if err := d.ResizeWait(*size); err != nil {
 
467
                t.Error(err)
 
468
                return
 
469
        }
 
470
        t.Logf("Resulting drive size: %d", d.Size())
 
471
        t.Logf("%v", d)
 
472
}