← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/joyent/gosdc/cloudapi/local_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/joyent/gosdc/cloudapi/local_test.go
 
1
//
 
2
// gosdc - Go library to interact with the Joyent CloudAPI
 
3
//
 
4
//
 
5
// Copyright (c) 2013 Joyent Inc.
 
6
//
 
7
// Written by Daniele Stroppa <daniele.stroppa@joyent.com>
 
8
//
 
9
 
 
10
package cloudapi_test
 
11
 
 
12
import (
 
13
        "io/ioutil"
 
14
        "net/http"
 
15
        "net/http/httptest"
 
16
        "os"
 
17
        "strings"
 
18
        "time"
 
19
 
 
20
        gc "launchpad.net/gocheck"
 
21
 
 
22
        "github.com/joyent/gocommon/client"
 
23
        "github.com/joyent/gosdc/cloudapi"
 
24
        lc "github.com/joyent/gosdc/localservices/cloudapi"
 
25
        "github.com/joyent/gosign/auth"
 
26
)
 
27
 
 
28
var privateKey []byte
 
29
 
 
30
func registerLocalTests(keyName string) {
 
31
        var localKeyFile string
 
32
        if keyName == "" {
 
33
                localKeyFile = os.Getenv("HOME") + "/.ssh/id_rsa"
 
34
        } else {
 
35
                localKeyFile = keyName
 
36
        }
 
37
        privateKey, _ = ioutil.ReadFile(localKeyFile)
 
38
 
 
39
        gc.Suite(&LocalTests{})
 
40
}
 
41
 
 
42
type LocalTests struct {
 
43
        //LocalTests
 
44
        creds      *auth.Credentials
 
45
        testClient *cloudapi.Client
 
46
        Server     *httptest.Server
 
47
        Mux        *http.ServeMux
 
48
        oldHandler http.Handler
 
49
        cloudapi   *lc.CloudAPI
 
50
}
 
51
 
 
52
func (s *LocalTests) SetUpSuite(c *gc.C) {
 
53
        // Set up the HTTP server.
 
54
        s.Server = httptest.NewServer(nil)
 
55
        s.oldHandler = s.Server.Config.Handler
 
56
        s.Mux = http.NewServeMux()
 
57
        s.Server.Config.Handler = s.Mux
 
58
 
 
59
        // Set up a Joyent CloudAPI service.
 
60
        authentication, err := auth.NewAuth("localtest", string(privateKey), "rsa-sha256")
 
61
        c.Assert(err, gc.IsNil)
 
62
 
 
63
        s.creds = &auth.Credentials{
 
64
                UserAuthentication: authentication,
 
65
                SdcKeyId:           "",
 
66
                SdcEndpoint:        auth.Endpoint{URL: s.Server.URL},
 
67
        }
 
68
        s.cloudapi = lc.New(s.creds.SdcEndpoint.URL, s.creds.UserAuthentication.User)
 
69
        s.cloudapi.SetupHTTP(s.Mux)
 
70
}
 
71
 
 
72
func (s *LocalTests) TearDownSuite(c *gc.C) {
 
73
        s.Mux = nil
 
74
        s.Server.Config.Handler = s.oldHandler
 
75
        s.Server.Close()
 
76
}
 
77
 
 
78
func (s *LocalTests) SetUpTest(c *gc.C) {
 
79
        client := client.NewClient(s.creds.SdcEndpoint.URL, cloudapi.DefaultAPIVersion, s.creds, &cloudapi.Logger)
 
80
        c.Assert(client, gc.NotNil)
 
81
        s.testClient = cloudapi.New(client)
 
82
        c.Assert(s.testClient, gc.NotNil)
 
83
}
 
84
 
 
85
// Helper method to create a test key in the user account
 
86
func (s *LocalTests) createKey(c *gc.C) {
 
87
        key, err := s.testClient.CreateKey(cloudapi.CreateKeyOpts{Name: "fake-key", Key: testKey})
 
88
        c.Assert(err, gc.IsNil)
 
89
        c.Assert(key, gc.DeepEquals, &cloudapi.Key{Name: "fake-key", Fingerprint: "", Key: testKey})
 
90
}
 
91
 
 
92
func (s *LocalTests) deleteKey(c *gc.C) {
 
93
        err := s.testClient.DeleteKey("fake-key")
 
94
        c.Assert(err, gc.IsNil)
 
95
}
 
96
 
 
97
// Helper method to create a test virtual machine in the user account
 
98
func (s *LocalTests) createMachine(c *gc.C) *cloudapi.Machine {
 
99
        machine, err := s.testClient.CreateMachine(cloudapi.CreateMachineOpts{Package: localPackageName, Image: localImageId})
 
100
        c.Assert(err, gc.IsNil)
 
101
        c.Assert(machine, gc.NotNil)
 
102
 
 
103
        // wait for machine to be provisioned
 
104
        for !s.pollMachineState(c, machine.Id, "running") {
 
105
                time.Sleep(1 * time.Second)
 
106
        }
 
107
 
 
108
        return machine
 
109
}
 
110
 
 
111
// Helper method to test the state of a given VM
 
112
func (s *LocalTests) pollMachineState(c *gc.C, machineId, state string) bool {
 
113
        machineConfig, err := s.testClient.GetMachine(machineId)
 
114
        c.Assert(err, gc.IsNil)
 
115
        return strings.EqualFold(machineConfig.State, state)
 
116
}
 
117
 
 
118
// Helper method to delete a test virtual machine once the test has executed
 
119
func (s *LocalTests) deleteMachine(c *gc.C, machineId string) {
 
120
        err := s.testClient.StopMachine(machineId)
 
121
        c.Assert(err, gc.IsNil)
 
122
 
 
123
        // wait for machine to be stopped
 
124
        for !s.pollMachineState(c, machineId, "stopped") {
 
125
                time.Sleep(1 * time.Second)
 
126
        }
 
127
 
 
128
        err = s.testClient.DeleteMachine(machineId)
 
129
        c.Assert(err, gc.IsNil)
 
130
}
 
131
 
 
132
// Helper method to list virtual machine according to the specified filter
 
133
func (s *LocalTests) listMachines(c *gc.C, filter *cloudapi.Filter) {
 
134
        var contains bool
 
135
        testMachine := s.createMachine(c)
 
136
        defer s.deleteMachine(c, testMachine.Id)
 
137
 
 
138
        machines, err := s.testClient.ListMachines(filter)
 
139
        c.Assert(err, gc.IsNil)
 
140
        c.Assert(machines, gc.NotNil)
 
141
        for _, m := range machines {
 
142
                if m.Id == testMachine.Id {
 
143
                        contains = true
 
144
                        break
 
145
                }
 
146
        }
 
147
 
 
148
        // result
 
149
        if !contains {
 
150
                c.Fatalf("Obtained machines [%s] do not contain test machine [%s]", machines, *testMachine)
 
151
        }
 
152
}
 
153
 
 
154
// Helper method to create a test firewall rule
 
155
func (s *LocalTests) createFirewallRule(c *gc.C) *cloudapi.FirewallRule {
 
156
        fwRule, err := s.testClient.CreateFirewallRule(cloudapi.CreateFwRuleOpts{Enabled: false, Rule: testFwRule})
 
157
        c.Assert(err, gc.IsNil)
 
158
        c.Assert(fwRule, gc.NotNil)
 
159
        c.Assert(fwRule.Rule, gc.Equals, testFwRule)
 
160
        c.Assert(fwRule.Enabled, gc.Equals, false)
 
161
        time.Sleep(10 * time.Second)
 
162
 
 
163
        return fwRule
 
164
}
 
165
 
 
166
// Helper method to a test firewall rule
 
167
func (s *LocalTests) deleteFwRule(c *gc.C, fwRuleId string) {
 
168
        err := s.testClient.DeleteFirewallRule(fwRuleId)
 
169
        c.Assert(err, gc.IsNil)
 
170
}
 
171
 
 
172
// Keys API
 
173
func (s *LocalTests) TestCreateKey(c *gc.C) {
 
174
        s.createKey(c)
 
175
        s.deleteKey(c)
 
176
}
 
177
 
 
178
func (s *LocalTests) TestListKeys(c *gc.C) {
 
179
        s.createKey(c)
 
180
        defer s.deleteKey(c)
 
181
 
 
182
        keys, err := s.testClient.ListKeys()
 
183
        c.Assert(err, gc.IsNil)
 
184
        c.Assert(keys, gc.NotNil)
 
185
        fakeKey := cloudapi.Key{Name: "fake-key", Fingerprint: "", Key: testKey}
 
186
        for _, k := range keys {
 
187
                if c.Check(k, gc.DeepEquals, fakeKey) {
 
188
                        c.SucceedNow()
 
189
                }
 
190
        }
 
191
        c.Fatalf("Obtained keys [%s] do not contain test key [%s]", keys, fakeKey)
 
192
}
 
193
 
 
194
func (s *LocalTests) TestGetKeyByName(c *gc.C) {
 
195
        s.createKey(c)
 
196
        defer s.deleteKey(c)
 
197
 
 
198
        key, err := s.testClient.GetKey("fake-key")
 
199
        c.Assert(err, gc.IsNil)
 
200
        c.Assert(key, gc.NotNil)
 
201
        c.Assert(key, gc.DeepEquals, &cloudapi.Key{Name: "fake-key", Fingerprint: "", Key: testKey})
 
202
}
 
203
 
 
204
/*func (s *LocalTests) TestGetKeyByFingerprint(c *gc.C) {
 
205
        s.createKey(c)
 
206
        defer s.deleteKey(c)
 
207
 
 
208
        key, err := s.testClient.GetKey(testKeyFingerprint)
 
209
        c.Assert(err, gc.IsNil)
 
210
        c.Assert(key, gc.NotNil)
 
211
        c.Assert(key, gc.DeepEquals, &cloudapi.Key{Name: "fake-key", Fingerprint: testKeyFingerprint, Key: testKey})
 
212
} */
 
213
 
 
214
func (s *LocalTests) TestDeleteKey(c *gc.C) {
 
215
        s.createKey(c)
 
216
 
 
217
        s.deleteKey(c)
 
218
}
 
219
 
 
220
// Packages API
 
221
func (s *LocalTests) TestListPackages(c *gc.C) {
 
222
        pkgs, err := s.testClient.ListPackages(nil)
 
223
        c.Assert(err, gc.IsNil)
 
224
        c.Assert(pkgs, gc.NotNil)
 
225
        for _, pkg := range pkgs {
 
226
                c.Check(pkg.Name, gc.FitsTypeOf, string(""))
 
227
                c.Check(pkg.Memory, gc.FitsTypeOf, int(0))
 
228
                c.Check(pkg.Disk, gc.FitsTypeOf, int(0))
 
229
                c.Check(pkg.Swap, gc.FitsTypeOf, int(0))
 
230
                c.Check(pkg.VCPUs, gc.FitsTypeOf, int(0))
 
231
                c.Check(pkg.Default, gc.FitsTypeOf, bool(false))
 
232
                c.Check(pkg.Id, gc.FitsTypeOf, string(""))
 
233
                c.Check(pkg.Version, gc.FitsTypeOf, string(""))
 
234
                c.Check(pkg.Description, gc.FitsTypeOf, string(""))
 
235
                c.Check(pkg.Group, gc.FitsTypeOf, string(""))
 
236
        }
 
237
}
 
238
 
 
239
func (s *LocalTests) TestListPackagesWithFilter(c *gc.C) {
 
240
        filter := cloudapi.NewFilter()
 
241
        filter.Set("memory", "1024")
 
242
        pkgs, err := s.testClient.ListPackages(filter)
 
243
        c.Assert(err, gc.IsNil)
 
244
        c.Assert(pkgs, gc.NotNil)
 
245
        for _, pkg := range pkgs {
 
246
                c.Check(pkg.Name, gc.FitsTypeOf, string(""))
 
247
                c.Check(pkg.Memory, gc.Equals, 1024)
 
248
                c.Check(pkg.Disk, gc.FitsTypeOf, int(0))
 
249
                c.Check(pkg.Swap, gc.FitsTypeOf, int(0))
 
250
                c.Check(pkg.VCPUs, gc.FitsTypeOf, int(0))
 
251
                c.Check(pkg.Default, gc.FitsTypeOf, bool(false))
 
252
                c.Check(pkg.Id, gc.FitsTypeOf, string(""))
 
253
                c.Check(pkg.Version, gc.FitsTypeOf, string(""))
 
254
                c.Check(pkg.Description, gc.FitsTypeOf, string(""))
 
255
                c.Check(pkg.Group, gc.FitsTypeOf, string(""))
 
256
        }
 
257
}
 
258
 
 
259
func (s *LocalTests) TestGetPackageFromName(c *gc.C) {
 
260
        key, err := s.testClient.GetPackage(localPackageName)
 
261
        c.Assert(err, gc.IsNil)
 
262
        c.Assert(key, gc.NotNil)
 
263
        c.Assert(key, gc.DeepEquals, &cloudapi.Package{
 
264
                Name:    "Small",
 
265
                Memory:  1024,
 
266
                Disk:    16384,
 
267
                Swap:    2048,
 
268
                VCPUs:   1,
 
269
                Default: true,
 
270
                Id:      "11223344-1212-abab-3434-aabbccddeeff",
 
271
                Version: "1.0.2",
 
272
        })
 
273
}
 
274
 
 
275
func (s *LocalTests) TestGetPackageFromId(c *gc.C) {
 
276
        key, err := s.testClient.GetPackage(localPackageId)
 
277
        c.Assert(err, gc.IsNil)
 
278
        c.Assert(key, gc.NotNil)
 
279
        c.Assert(key, gc.DeepEquals, &cloudapi.Package{
 
280
                Name:    "Small",
 
281
                Memory:  1024,
 
282
                Disk:    16384,
 
283
                Swap:    2048,
 
284
                VCPUs:   1,
 
285
                Default: true,
 
286
                Id:      "11223344-1212-abab-3434-aabbccddeeff",
 
287
                Version: "1.0.2",
 
288
        })
 
289
}
 
290
 
 
291
// Images API
 
292
func (s *LocalTests) TestListImages(c *gc.C) {
 
293
        imgs, err := s.testClient.ListImages(nil)
 
294
        c.Assert(err, gc.IsNil)
 
295
        c.Assert(imgs, gc.NotNil)
 
296
        for _, img := range imgs {
 
297
                c.Check(img.Id, gc.FitsTypeOf, string(""))
 
298
                c.Check(img.Name, gc.FitsTypeOf, string(""))
 
299
                c.Check(img.OS, gc.FitsTypeOf, string(""))
 
300
                c.Check(img.Version, gc.FitsTypeOf, string(""))
 
301
                c.Check(img.Type, gc.FitsTypeOf, string(""))
 
302
                c.Check(img.Description, gc.FitsTypeOf, string(""))
 
303
                c.Check(img.Requirements, gc.FitsTypeOf, map[string]interface{}{"key": "value"})
 
304
                c.Check(img.Homepage, gc.FitsTypeOf, string(""))
 
305
                c.Check(img.PublishedAt, gc.FitsTypeOf, string(""))
 
306
                c.Check(img.Public, gc.FitsTypeOf, string(""))
 
307
                c.Check(img.State, gc.FitsTypeOf, string(""))
 
308
                c.Check(img.Tags, gc.FitsTypeOf, map[string]string{"key": "value"})
 
309
                c.Check(img.EULA, gc.FitsTypeOf, string(""))
 
310
                c.Check(img.ACL, gc.FitsTypeOf, []string{"", ""})
 
311
        }
 
312
}
 
313
 
 
314
func (s *LocalTests) TestListImagesWithFilter(c *gc.C) {
 
315
        filter := cloudapi.NewFilter()
 
316
        filter.Set("os", "smartos")
 
317
        imgs, err := s.testClient.ListImages(filter)
 
318
        c.Assert(err, gc.IsNil)
 
319
        c.Assert(imgs, gc.NotNil)
 
320
        for _, img := range imgs {
 
321
                c.Check(img.Id, gc.FitsTypeOf, string(""))
 
322
                c.Check(img.Name, gc.FitsTypeOf, string(""))
 
323
                c.Check(img.OS, gc.Equals, "smartos")
 
324
                c.Check(img.Version, gc.FitsTypeOf, string(""))
 
325
                c.Check(img.Type, gc.FitsTypeOf, string(""))
 
326
                c.Check(img.Description, gc.FitsTypeOf, string(""))
 
327
                c.Check(img.Requirements, gc.FitsTypeOf, map[string]interface{}{"key": "value"})
 
328
                c.Check(img.Homepage, gc.FitsTypeOf, string(""))
 
329
                c.Check(img.PublishedAt, gc.FitsTypeOf, string(""))
 
330
                c.Check(img.Public, gc.FitsTypeOf, string(""))
 
331
                c.Check(img.State, gc.FitsTypeOf, string(""))
 
332
                c.Check(img.Tags, gc.FitsTypeOf, map[string]string{"key": "value"})
 
333
                c.Check(img.EULA, gc.FitsTypeOf, string(""))
 
334
                c.Check(img.ACL, gc.FitsTypeOf, []string{"", ""})
 
335
        }
 
336
}
 
337
 
 
338
// TODO Add test for deleteImage, exportImage and CreateMachineFormIMage
 
339
 
 
340
func (s *LocalTests) TestGetImage(c *gc.C) {
 
341
        img, err := s.testClient.GetImage(localImageId)
 
342
        c.Assert(err, gc.IsNil)
 
343
        c.Assert(img, gc.NotNil)
 
344
        c.Assert(img, gc.DeepEquals, &cloudapi.Image{
 
345
                Id:          "12345678-a1a1-b2b2-c3c3-098765432100",
 
346
                Name:        "SmartOS Std",
 
347
                OS:          "smartos",
 
348
                Version:     "13.3.1",
 
349
                Type:        "smartmachine",
 
350
                Description: "Test SmartOS image (32 bit)",
 
351
                Homepage:    "http://test.joyent.com/Standard_Instance",
 
352
                PublishedAt: "2014-01-08T17:42:31Z",
 
353
                Public:      "true",
 
354
                State:       "active",
 
355
        })
 
356
}
 
357
 
 
358
// Tests for Machine API
 
359
func (s *LocalTests) TestCreateMachine(c *gc.C) {
 
360
        testMachine := s.createMachine(c)
 
361
        defer s.deleteMachine(c, testMachine.Id)
 
362
 
 
363
        c.Assert(testMachine.Type, gc.Equals, "smartmachine")
 
364
        c.Assert(testMachine.Memory, gc.Equals, 1024)
 
365
        c.Assert(testMachine.Disk, gc.Equals, 16384)
 
366
        c.Assert(testMachine.Package, gc.Equals, localPackageName)
 
367
        c.Assert(testMachine.Image, gc.Equals, localImageId)
 
368
}
 
369
 
 
370
func (s *LocalTests) TestListMachines(c *gc.C) {
 
371
        s.listMachines(c, nil)
 
372
}
 
373
 
 
374
func (s *LocalTests) TestListMachinesWithFilter(c *gc.C) {
 
375
        filter := cloudapi.NewFilter()
 
376
        filter.Set("memory", "1024")
 
377
 
 
378
        s.listMachines(c, filter)
 
379
}
 
380
 
 
381
/*func (s *LocalTests) TestCountMachines(c *gc.C) {
 
382
        testMachine := s.createMachine(c)
 
383
        defer s.deleteMachine(c, testMachine.Id)
 
384
 
 
385
        count, err := s.testClient.CountMachines()
 
386
        c.Assert(err, gc.IsNil)
 
387
        c.Assert(count >= 1, gc.Equals, true)
 
388
}*/
 
389
 
 
390
func (s *LocalTests) TestGetMachine(c *gc.C) {
 
391
        testMachine := s.createMachine(c)
 
392
        defer s.deleteMachine(c, testMachine.Id)
 
393
 
 
394
        machine, err := s.testClient.GetMachine(testMachine.Id)
 
395
        c.Assert(err, gc.IsNil)
 
396
        c.Assert(machine, gc.NotNil)
 
397
        c.Assert(machine.Equals(*testMachine), gc.Equals, true)
 
398
}
 
399
 
 
400
func (s *LocalTests) TestStopMachine(c *gc.C) {
 
401
        testMachine := s.createMachine(c)
 
402
        defer s.deleteMachine(c, testMachine.Id)
 
403
 
 
404
        err := s.testClient.StopMachine(testMachine.Id)
 
405
        c.Assert(err, gc.IsNil)
 
406
}
 
407
 
 
408
func (s *LocalTests) TestStartMachine(c *gc.C) {
 
409
        testMachine := s.createMachine(c)
 
410
        defer s.deleteMachine(c, testMachine.Id)
 
411
 
 
412
        err := s.testClient.StopMachine(testMachine.Id)
 
413
        c.Assert(err, gc.IsNil)
 
414
 
 
415
        // wait for machine to be stopped
 
416
        for !s.pollMachineState(c, testMachine.Id, "stopped") {
 
417
                time.Sleep(1 * time.Second)
 
418
        }
 
419
 
 
420
        err = s.testClient.StartMachine(testMachine.Id)
 
421
        c.Assert(err, gc.IsNil)
 
422
}
 
423
 
 
424
func (s *LocalTests) TestRebootMachine(c *gc.C) {
 
425
        testMachine := s.createMachine(c)
 
426
        defer s.deleteMachine(c, testMachine.Id)
 
427
 
 
428
        err := s.testClient.RebootMachine(testMachine.Id)
 
429
        c.Assert(err, gc.IsNil)
 
430
}
 
431
 
 
432
func (s *LocalTests) TestRenameMachine(c *gc.C) {
 
433
        testMachine := s.createMachine(c)
 
434
        defer s.deleteMachine(c, testMachine.Id)
 
435
 
 
436
        err := s.testClient.RenameMachine(testMachine.Id, "test-machine-renamed")
 
437
        c.Assert(err, gc.IsNil)
 
438
 
 
439
        renamed, err := s.testClient.GetMachine(testMachine.Id)
 
440
        c.Assert(err, gc.IsNil)
 
441
        c.Assert(renamed.Name, gc.Equals, "test-machine-renamed")
 
442
}
 
443
 
 
444
func (s *LocalTests) TestResizeMachine(c *gc.C) {
 
445
        testMachine := s.createMachine(c)
 
446
        defer s.deleteMachine(c, testMachine.Id)
 
447
 
 
448
        err := s.testClient.ResizeMachine(testMachine.Id, "Medium")
 
449
        c.Assert(err, gc.IsNil)
 
450
 
 
451
        resized, err := s.testClient.GetMachine(testMachine.Id)
 
452
        c.Assert(err, gc.IsNil)
 
453
        c.Assert(resized.Package, gc.Equals, "Medium")
 
454
}
 
455
 
 
456
func (s *LocalTests) TestListMachinesFirewallRules(c *gc.C) {
 
457
        testMachine := s.createMachine(c)
 
458
        defer s.deleteMachine(c, testMachine.Id)
 
459
 
 
460
        fwRules, err := s.testClient.ListMachineFirewallRules(testMachine.Id)
 
461
        c.Assert(err, gc.IsNil)
 
462
        c.Assert(fwRules, gc.NotNil)
 
463
}
 
464
 
 
465
func (s *LocalTests) TestEnableFirewallMachine(c *gc.C) {
 
466
        testMachine := s.createMachine(c)
 
467
        defer s.deleteMachine(c, testMachine.Id)
 
468
 
 
469
        err := s.testClient.EnableFirewallMachine(testMachine.Id)
 
470
        c.Assert(err, gc.IsNil)
 
471
}
 
472
 
 
473
func (s *LocalTests) TestDisableFirewallMachine(c *gc.C) {
 
474
        testMachine := s.createMachine(c)
 
475
        defer s.deleteMachine(c, testMachine.Id)
 
476
 
 
477
        err := s.testClient.DisableFirewallMachine(testMachine.Id)
 
478
        c.Assert(err, gc.IsNil)
 
479
}
 
480
 
 
481
func (s *LocalTests) TestDeleteMachine(c *gc.C) {
 
482
        testMachine := s.createMachine(c)
 
483
 
 
484
        s.deleteMachine(c, testMachine.Id)
 
485
}
 
486
 
 
487
// FirewallRules API
 
488
func (s *LocalTests) TestCreateFirewallRule(c *gc.C) {
 
489
        testFwRule := s.createFirewallRule(c)
 
490
 
 
491
        // cleanup
 
492
        s.deleteFwRule(c, testFwRule.Id)
 
493
}
 
494
 
 
495
func (s *LocalTests) TestListFirewallRules(c *gc.C) {
 
496
        testFwRule := s.createFirewallRule(c)
 
497
        defer s.deleteFwRule(c, testFwRule.Id)
 
498
 
 
499
        rules, err := s.testClient.ListFirewallRules()
 
500
        c.Assert(err, gc.IsNil)
 
501
        c.Assert(rules, gc.NotNil)
 
502
}
 
503
 
 
504
func (s *LocalTests) TestGetFirewallRule(c *gc.C) {
 
505
        testFwRule := s.createFirewallRule(c)
 
506
        defer s.deleteFwRule(c, testFwRule.Id)
 
507
 
 
508
        fwRule, err := s.testClient.GetFirewallRule(testFwRule.Id)
 
509
        c.Assert(err, gc.IsNil)
 
510
        c.Assert(fwRule, gc.NotNil)
 
511
        c.Assert((*fwRule), gc.DeepEquals, (*testFwRule))
 
512
}
 
513
 
 
514
func (s *LocalTests) TestUpdateFirewallRule(c *gc.C) {
 
515
        testFwRule := s.createFirewallRule(c)
 
516
        defer s.deleteFwRule(c, testFwRule.Id)
 
517
 
 
518
        fwRule, err := s.testClient.UpdateFirewallRule(testFwRule.Id, cloudapi.CreateFwRuleOpts{Rule: testUpdatedFwRule})
 
519
        c.Assert(err, gc.IsNil)
 
520
        c.Assert(fwRule, gc.NotNil)
 
521
        c.Assert(fwRule.Rule, gc.Equals, testUpdatedFwRule)
 
522
}
 
523
 
 
524
func (s *LocalTests) TestEnableFirewallRule(c *gc.C) {
 
525
        testFwRule := s.createFirewallRule(c)
 
526
        defer s.deleteFwRule(c, testFwRule.Id)
 
527
 
 
528
        fwRule, err := s.testClient.EnableFirewallRule((*testFwRule).Id)
 
529
        c.Assert(err, gc.IsNil)
 
530
        c.Assert(fwRule, gc.NotNil)
 
531
}
 
532
 
 
533
func (s *LocalTests) TestDisableFirewallRule(c *gc.C) {
 
534
        testFwRule := s.createFirewallRule(c)
 
535
        defer s.deleteFwRule(c, testFwRule.Id)
 
536
 
 
537
        fwRule, err := s.testClient.DisableFirewallRule((*testFwRule).Id)
 
538
        c.Assert(err, gc.IsNil)
 
539
        c.Assert(fwRule, gc.NotNil)
 
540
}
 
541
 
 
542
func (s *LocalTests) TestDeleteFirewallRule(c *gc.C) {
 
543
        testFwRule := s.createFirewallRule(c)
 
544
 
 
545
        s.deleteFwRule(c, testFwRule.Id)
 
546
}
 
547
 
 
548
// Networks API
 
549
func (s *LocalTests) TestListNetworks(c *gc.C) {
 
550
        nets, err := s.testClient.ListNetworks()
 
551
        c.Assert(err, gc.IsNil)
 
552
        c.Assert(nets, gc.NotNil)
 
553
}
 
554
 
 
555
func (s *LocalTests) TestGetNetwork(c *gc.C) {
 
556
        net, err := s.testClient.GetNetwork(localNetworkId)
 
557
        c.Assert(err, gc.IsNil)
 
558
        c.Assert(net, gc.NotNil)
 
559
        c.Assert(net, gc.DeepEquals, &cloudapi.Network{
 
560
                Id:          localNetworkId,
 
561
                Name:        "Test-Joyent-Public",
 
562
                Public:      true,
 
563
                Description: "",
 
564
        })
 
565
}