← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/provider/gce/google/testing_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/juju/juju/provider/gce/google/testing_test.go
 
1
// Copyright 2014 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package google
 
5
 
 
6
import (
 
7
        "google.golang.org/api/compute/v1"
 
8
        gc "gopkg.in/check.v1"
 
9
 
 
10
        "github.com/juju/juju/network"
 
11
        "github.com/juju/juju/testing"
 
12
)
 
13
 
 
14
type BaseSuite struct {
 
15
        testing.BaseSuite
 
16
 
 
17
        Credentials *Credentials
 
18
        ConnCfg     ConnectionConfig
 
19
        Conn        *Connection
 
20
        FakeConn    *fakeConn
 
21
 
 
22
        DiskSpec         DiskSpec
 
23
        AttachedDisk     compute.AttachedDisk
 
24
        NetworkSpec      NetworkSpec
 
25
        NetworkInterface compute.NetworkInterface
 
26
        Addresses        []network.Address
 
27
        RawMetadata      compute.Metadata
 
28
        Metadata         map[string]string
 
29
        RawInstance      compute.Instance
 
30
        RawInstanceFull  compute.Instance
 
31
        InstanceSpec     InstanceSpec
 
32
        Instance         Instance
 
33
}
 
34
 
 
35
var _ = gc.Suite(&BaseSuite{})
 
36
 
 
37
func (s *BaseSuite) SetUpTest(c *gc.C) {
 
38
        s.BaseSuite.SetUpTest(c)
 
39
 
 
40
        s.Credentials = &Credentials{
 
41
                ClientID:    "spam",
 
42
                ClientEmail: "user@mail.com",
 
43
                PrivateKey:  []byte("<some-key>"),
 
44
                JSONKey: []byte(`
 
45
{
 
46
    "private_key_id": "mnopq",
 
47
    "private_key": "<some-key>",
 
48
    "client_email": "user@mail.com",
 
49
    "client_id": "spam",
 
50
    "type": "service_account"
 
51
}`[1:]),
 
52
        }
 
53
        s.ConnCfg = ConnectionConfig{
 
54
                Region:    "a",
 
55
                ProjectID: "spam",
 
56
        }
 
57
        fake := &fakeConn{}
 
58
        s.Conn = &Connection{
 
59
                raw:       fake,
 
60
                region:    "a",
 
61
                projectID: "spam",
 
62
        }
 
63
        s.FakeConn = fake
 
64
 
 
65
        s.DiskSpec = DiskSpec{
 
66
                Series:     "trusty",
 
67
                SizeHintGB: 15,
 
68
                ImageURL:   "some/image/path",
 
69
                Boot:       true,
 
70
                Scratch:    false,
 
71
                Readonly:   false,
 
72
                AutoDelete: true,
 
73
        }
 
74
        s.AttachedDisk = compute.AttachedDisk{
 
75
                Type:       "PERSISTENT",
 
76
                Boot:       true,
 
77
                Mode:       "READ_WRITE",
 
78
                AutoDelete: true,
 
79
                InitializeParams: &compute.AttachedDiskInitializeParams{
 
80
                        DiskSizeGb:  10,
 
81
                        SourceImage: "some/image/path",
 
82
                },
 
83
        }
 
84
        s.NetworkSpec = NetworkSpec{
 
85
                Name: "somenetwork",
 
86
        }
 
87
        s.NetworkInterface = compute.NetworkInterface{
 
88
                Network:   "global/networks/somenetwork",
 
89
                NetworkIP: "10.0.0.1",
 
90
                AccessConfigs: []*compute.AccessConfig{{
 
91
                        Name: "somenetif",
 
92
                        Type: NetworkAccessOneToOneNAT,
 
93
                }},
 
94
        }
 
95
        s.Addresses = []network.Address{{
 
96
                Value: "10.0.0.1",
 
97
                Type:  network.IPv4Address,
 
98
                Scope: network.ScopeCloudLocal,
 
99
        }}
 
100
        s.RawMetadata = compute.Metadata{Items: []*compute.MetadataItems{{
 
101
                Key:   "eggs",
 
102
                Value: "steak",
 
103
        }}}
 
104
        s.Metadata = map[string]string{
 
105
                "eggs": "steak",
 
106
        }
 
107
        s.RawInstance = compute.Instance{
 
108
                Name:              "spam",
 
109
                Status:            StatusRunning,
 
110
                NetworkInterfaces: []*compute.NetworkInterface{&s.NetworkInterface},
 
111
                Metadata:          &s.RawMetadata,
 
112
                Disks:             []*compute.AttachedDisk{&s.AttachedDisk},
 
113
                Tags:              &compute.Tags{Items: []string{"spam"}},
 
114
        }
 
115
        s.RawInstanceFull = s.RawInstance
 
116
        s.RawInstanceFull.Zone = "a-zone"
 
117
        s.RawInstanceFull.Status = StatusRunning
 
118
        s.RawInstanceFull.MachineType = "zones/a-zone/machineTypes/mtype"
 
119
        s.InstanceSpec = InstanceSpec{
 
120
                ID:                "spam",
 
121
                Type:              "mtype",
 
122
                Disks:             []DiskSpec{s.DiskSpec},
 
123
                Network:           s.NetworkSpec,
 
124
                NetworkInterfaces: []string{"somenetif"},
 
125
                Metadata:          s.Metadata,
 
126
                Tags:              []string{"spam"},
 
127
        }
 
128
        s.Instance = Instance{
 
129
                InstanceSummary: InstanceSummary{
 
130
                        ID:        "spam",
 
131
                        ZoneName:  "a-zone",
 
132
                        Status:    StatusRunning,
 
133
                        Metadata:  s.Metadata,
 
134
                        Addresses: s.Addresses,
 
135
                },
 
136
                spec: &s.InstanceSpec,
 
137
        }
 
138
}
 
139
 
 
140
func (s *BaseSuite) NewWaitError(op *compute.Operation, cause error) error {
 
141
        return waitError{op, cause}
 
142
}
 
143
 
 
144
type fakeCall struct {
 
145
        FuncName string
 
146
 
 
147
        ProjectID    string
 
148
        Region       string
 
149
        ZoneName     string
 
150
        Name         string
 
151
        ID           string
 
152
        Prefix       string
 
153
        Statuses     []string
 
154
        Instance     *compute.Instance
 
155
        InstValue    compute.Instance
 
156
        Firewall     *compute.Firewall
 
157
        InstanceId   string
 
158
        AttachedDisk *compute.AttachedDisk
 
159
        DeviceName   string
 
160
        ComputeDisk  *compute.Disk
 
161
}
 
162
 
 
163
type fakeConn struct {
 
164
        Calls []fakeCall
 
165
 
 
166
        Project       *compute.Project
 
167
        Instance      *compute.Instance
 
168
        Instances     []*compute.Instance
 
169
        Firewall      *compute.Firewall
 
170
        Zones         []*compute.Zone
 
171
        Err           error
 
172
        FailOnCall    int
 
173
        Disks         []*compute.Disk
 
174
        Disk          *compute.Disk
 
175
        AttachedDisks []*compute.AttachedDisk
 
176
}
 
177
 
 
178
func (rc *fakeConn) GetProject(projectID string) (*compute.Project, error) {
 
179
        call := fakeCall{
 
180
                FuncName:  "GetProject",
 
181
                ProjectID: projectID,
 
182
        }
 
183
        rc.Calls = append(rc.Calls, call)
 
184
 
 
185
        err := rc.Err
 
186
        if len(rc.Calls) != rc.FailOnCall+1 {
 
187
                err = nil
 
188
        }
 
189
        return rc.Project, err
 
190
}
 
191
 
 
192
func (rc *fakeConn) GetInstance(projectID, zone, id string) (*compute.Instance, error) {
 
193
        call := fakeCall{
 
194
                FuncName:  "GetInstance",
 
195
                ProjectID: projectID,
 
196
                ZoneName:  zone,
 
197
                ID:        id,
 
198
        }
 
199
        rc.Calls = append(rc.Calls, call)
 
200
 
 
201
        err := rc.Err
 
202
        if len(rc.Calls) != rc.FailOnCall+1 {
 
203
                err = nil
 
204
        }
 
205
        return rc.Instance, err
 
206
}
 
207
 
 
208
func (rc *fakeConn) ListInstances(projectID, prefix string, statuses ...string) ([]*compute.Instance, error) {
 
209
        call := fakeCall{
 
210
                FuncName:  "ListInstances",
 
211
                ProjectID: projectID,
 
212
                Prefix:    prefix,
 
213
                Statuses:  statuses,
 
214
        }
 
215
        rc.Calls = append(rc.Calls, call)
 
216
 
 
217
        err := rc.Err
 
218
        if len(rc.Calls) != rc.FailOnCall+1 {
 
219
                err = nil
 
220
        }
 
221
        return rc.Instances, err
 
222
}
 
223
 
 
224
func (rc *fakeConn) AddInstance(projectID, zoneName string, spec *compute.Instance) error {
 
225
        call := fakeCall{
 
226
                FuncName:  "AddInstance",
 
227
                ProjectID: projectID,
 
228
                ZoneName:  zoneName,
 
229
                Instance:  spec,
 
230
                InstValue: *spec,
 
231
        }
 
232
        rc.Calls = append(rc.Calls, call)
 
233
 
 
234
        err := rc.Err
 
235
        if len(rc.Calls) != rc.FailOnCall+1 {
 
236
                err = nil
 
237
        }
 
238
        return err
 
239
}
 
240
 
 
241
func (rc *fakeConn) RemoveInstance(projectID, zone, id string) error {
 
242
        call := fakeCall{
 
243
                FuncName:  "RemoveInstance",
 
244
                ProjectID: projectID,
 
245
                ID:        id,
 
246
                ZoneName:  zone,
 
247
        }
 
248
        rc.Calls = append(rc.Calls, call)
 
249
 
 
250
        err := rc.Err
 
251
        if len(rc.Calls) != rc.FailOnCall+1 {
 
252
                err = nil
 
253
        }
 
254
        return err
 
255
}
 
256
 
 
257
func (rc *fakeConn) GetFirewall(projectID, name string) (*compute.Firewall, error) {
 
258
        call := fakeCall{
 
259
                FuncName:  "GetFirewall",
 
260
                ProjectID: projectID,
 
261
                Name:      name,
 
262
        }
 
263
        rc.Calls = append(rc.Calls, call)
 
264
 
 
265
        err := rc.Err
 
266
        if len(rc.Calls) != rc.FailOnCall+1 {
 
267
                err = nil
 
268
        }
 
269
        return rc.Firewall, err
 
270
}
 
271
 
 
272
func (rc *fakeConn) AddFirewall(projectID string, firewall *compute.Firewall) error {
 
273
        call := fakeCall{
 
274
                FuncName:  "AddFirewall",
 
275
                ProjectID: projectID,
 
276
                Firewall:  firewall,
 
277
        }
 
278
        rc.Calls = append(rc.Calls, call)
 
279
 
 
280
        err := rc.Err
 
281
        if len(rc.Calls) != rc.FailOnCall+1 {
 
282
                err = nil
 
283
        }
 
284
        return err
 
285
}
 
286
 
 
287
func (rc *fakeConn) UpdateFirewall(projectID, name string, firewall *compute.Firewall) error {
 
288
        call := fakeCall{
 
289
                FuncName:  "UpdateFirewall",
 
290
                ProjectID: projectID,
 
291
                Name:      name,
 
292
                Firewall:  firewall,
 
293
        }
 
294
        rc.Calls = append(rc.Calls, call)
 
295
 
 
296
        err := rc.Err
 
297
        if len(rc.Calls) != rc.FailOnCall+1 {
 
298
                err = nil
 
299
        }
 
300
        return err
 
301
}
 
302
 
 
303
func (rc *fakeConn) RemoveFirewall(projectID, name string) error {
 
304
        call := fakeCall{
 
305
                FuncName:  "RemoveFirewall",
 
306
                ProjectID: projectID,
 
307
                Name:      name,
 
308
        }
 
309
        rc.Calls = append(rc.Calls, call)
 
310
 
 
311
        err := rc.Err
 
312
        if len(rc.Calls) != rc.FailOnCall+1 {
 
313
                err = nil
 
314
        }
 
315
        return err
 
316
}
 
317
 
 
318
func (rc *fakeConn) ListAvailabilityZones(projectID, region string) ([]*compute.Zone, error) {
 
319
        call := fakeCall{
 
320
                FuncName:  "ListAvailabilityZones",
 
321
                ProjectID: projectID,
 
322
                Region:    region,
 
323
        }
 
324
        rc.Calls = append(rc.Calls, call)
 
325
 
 
326
        err := rc.Err
 
327
        if len(rc.Calls) != rc.FailOnCall+1 {
 
328
                err = nil
 
329
        }
 
330
        return rc.Zones, err
 
331
}
 
332
 
 
333
func (rc *fakeConn) CreateDisk(project, zone string, spec *compute.Disk) error {
 
334
        call := fakeCall{
 
335
                FuncName:    "CreateDisk",
 
336
                ProjectID:   project,
 
337
                ZoneName:    zone,
 
338
                ComputeDisk: spec,
 
339
        }
 
340
        rc.Calls = append(rc.Calls, call)
 
341
 
 
342
        err := rc.Err
 
343
        if len(rc.Calls) != rc.FailOnCall+1 {
 
344
                err = nil
 
345
        }
 
346
        return err
 
347
}
 
348
 
 
349
func (rc *fakeConn) ListDisks(project, zone string) ([]*compute.Disk, error) {
 
350
        call := fakeCall{
 
351
                FuncName:  "ListDisks",
 
352
                ProjectID: project,
 
353
                ZoneName:  zone,
 
354
        }
 
355
        rc.Calls = append(rc.Calls, call)
 
356
 
 
357
        err := rc.Err
 
358
        if len(rc.Calls) != rc.FailOnCall+1 {
 
359
                err = nil
 
360
        }
 
361
        return rc.Disks, err
 
362
}
 
363
 
 
364
func (rc *fakeConn) RemoveDisk(project, zone, id string) error {
 
365
        call := fakeCall{
 
366
                FuncName:  "RemoveDisk",
 
367
                ProjectID: project,
 
368
                ZoneName:  zone,
 
369
                ID:        id,
 
370
        }
 
371
        rc.Calls = append(rc.Calls, call)
 
372
 
 
373
        err := rc.Err
 
374
        if len(rc.Calls) != rc.FailOnCall+1 {
 
375
                err = nil
 
376
        }
 
377
        return err
 
378
}
 
379
 
 
380
func (rc *fakeConn) GetDisk(project, zone, id string) (*compute.Disk, error) {
 
381
        call := fakeCall{
 
382
                FuncName:  "GetDisk",
 
383
                ProjectID: project,
 
384
                ZoneName:  zone,
 
385
                ID:        id,
 
386
        }
 
387
        rc.Calls = append(rc.Calls, call)
 
388
 
 
389
        err := rc.Err
 
390
        if len(rc.Calls) != rc.FailOnCall+1 {
 
391
                err = nil
 
392
        }
 
393
        return rc.Disk, err
 
394
}
 
395
 
 
396
func (rc *fakeConn) AttachDisk(project, zone, instanceId string, attachedDisk *compute.AttachedDisk) error {
 
397
        call := fakeCall{
 
398
                FuncName:     "AttachDisk",
 
399
                ProjectID:    project,
 
400
                ZoneName:     zone,
 
401
                InstanceId:   instanceId,
 
402
                AttachedDisk: attachedDisk,
 
403
        }
 
404
        rc.Calls = append(rc.Calls, call)
 
405
 
 
406
        err := rc.Err
 
407
        if len(rc.Calls) != rc.FailOnCall+1 {
 
408
                err = nil
 
409
        }
 
410
        return err
 
411
}
 
412
 
 
413
func (rc *fakeConn) DetachDisk(project, zone, instanceId, diskDeviceName string) error {
 
414
        call := fakeCall{
 
415
                FuncName:   "DetachDisk",
 
416
                ProjectID:  project,
 
417
                ZoneName:   zone,
 
418
                InstanceId: instanceId,
 
419
                DeviceName: diskDeviceName,
 
420
        }
 
421
        rc.Calls = append(rc.Calls, call)
 
422
 
 
423
        err := rc.Err
 
424
        if len(rc.Calls) != rc.FailOnCall+1 {
 
425
                err = nil
 
426
        }
 
427
        return err
 
428
}
 
429
 
 
430
func (rc *fakeConn) InstanceDisks(project, zone, instanceId string) ([]*compute.AttachedDisk, error) {
 
431
        call := fakeCall{
 
432
                FuncName:   "InstanceDisks",
 
433
                ProjectID:  project,
 
434
                ZoneName:   zone,
 
435
                InstanceId: instanceId,
 
436
        }
 
437
        rc.Calls = append(rc.Calls, call)
 
438
 
 
439
        err := rc.Err
 
440
        if len(rc.Calls) != rc.FailOnCall+1 {
 
441
                err = nil
 
442
        }
 
443
        return rc.AttachedDisks, err
 
444
}