← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/provider/maas/maas2_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/maas/maas2_test.go
 
1
// Copyright 2016 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package maas
 
5
 
 
6
import (
 
7
        "github.com/juju/errors"
 
8
        "github.com/juju/gomaasapi"
 
9
        "github.com/juju/testing"
 
10
        jc "github.com/juju/testing/checkers"
 
11
        "github.com/juju/utils/set"
 
12
        gc "gopkg.in/check.v1"
 
13
 
 
14
        "github.com/juju/juju/cloud"
 
15
        "github.com/juju/juju/environs"
 
16
        "github.com/juju/juju/environs/config"
 
17
        coretesting "github.com/juju/juju/testing"
 
18
        "github.com/juju/juju/version"
 
19
)
 
20
 
 
21
type maas2Suite struct {
 
22
        baseProviderSuite
 
23
}
 
24
 
 
25
func (suite *maas2Suite) injectController(controller gomaasapi.Controller) {
 
26
        mockGetController := func(maasServer, apiKey string) (gomaasapi.Controller, error) {
 
27
                return controller, nil
 
28
        }
 
29
        suite.PatchValue(&GetMAAS2Controller, mockGetController)
 
30
}
 
31
 
 
32
func (suite *maas2Suite) makeEnviron(c *gc.C, controller gomaasapi.Controller) *maasEnviron {
 
33
        if controller != nil {
 
34
                suite.injectController(controller)
 
35
        }
 
36
        testAttrs := coretesting.Attrs{}
 
37
        for k, v := range maasEnvAttrs {
 
38
                testAttrs[k] = v
 
39
        }
 
40
        testAttrs["agent-version"] = version.Current.String()
 
41
 
 
42
        cred := cloud.NewCredential(cloud.OAuth1AuthType, map[string]string{
 
43
                "maas-oauth": "a:b:c",
 
44
        })
 
45
        cloud := environs.CloudSpec{
 
46
                Type:       "maas",
 
47
                Name:       "maas",
 
48
                Endpoint:   "http://any-old-junk.invalid/",
 
49
                Credential: &cred,
 
50
        }
 
51
 
 
52
        attrs := coretesting.FakeConfig().Merge(testAttrs)
 
53
        suite.controllerUUID = coretesting.FakeControllerConfig().ControllerUUID()
 
54
        cfg, err := config.New(config.NoDefaults, attrs)
 
55
        c.Assert(err, jc.ErrorIsNil)
 
56
        env, err := NewEnviron(cloud, cfg)
 
57
        c.Assert(err, jc.ErrorIsNil)
 
58
        c.Assert(env, gc.NotNil)
 
59
        return env
 
60
}
 
61
 
 
62
type fakeController struct {
 
63
        gomaasapi.Controller
 
64
        *testing.Stub
 
65
 
 
66
        bootResources      []gomaasapi.BootResource
 
67
        bootResourcesError error
 
68
        machines           []gomaasapi.Machine
 
69
        machinesError      error
 
70
        machinesArgsCheck  func(gomaasapi.MachinesArgs)
 
71
        zones              []gomaasapi.Zone
 
72
        zonesError         error
 
73
        spaces             []gomaasapi.Space
 
74
        spacesError        error
 
75
 
 
76
        allocateMachine          gomaasapi.Machine
 
77
        allocateMachineMatches   gomaasapi.ConstraintMatches
 
78
        allocateMachineError     error
 
79
        allocateMachineArgsCheck func(gomaasapi.AllocateMachineArgs)
 
80
 
 
81
        files []gomaasapi.File
 
82
 
 
83
        devices []gomaasapi.Device
 
84
}
 
85
 
 
86
func newFakeController() *fakeController {
 
87
        return &fakeController{Stub: &testing.Stub{}}
 
88
}
 
89
 
 
90
func newFakeControllerWithErrors(errors ...error) *fakeController {
 
91
        controller := newFakeController()
 
92
        controller.SetErrors(errors...)
 
93
        return controller
 
94
}
 
95
 
 
96
func newFakeControllerWithFiles(files ...gomaasapi.File) *fakeController {
 
97
        return &fakeController{Stub: &testing.Stub{}, files: files}
 
98
}
 
99
 
 
100
func (c *fakeController) Devices(args gomaasapi.DevicesArgs) ([]gomaasapi.Device, error) {
 
101
        c.MethodCall(c, "Devices", args)
 
102
        return c.devices, c.NextErr()
 
103
}
 
104
 
 
105
func (c *fakeController) Machines(args gomaasapi.MachinesArgs) ([]gomaasapi.Machine, error) {
 
106
        if c.machinesArgsCheck != nil {
 
107
                c.machinesArgsCheck(args)
 
108
        }
 
109
        if c.machinesError != nil {
 
110
                return nil, c.machinesError
 
111
        }
 
112
        if len(args.SystemIDs) > 0 {
 
113
                result := []gomaasapi.Machine{}
 
114
                systemIds := set.NewStrings(args.SystemIDs...)
 
115
                for _, machine := range c.machines {
 
116
                        if systemIds.Contains(machine.SystemID()) {
 
117
                                result = append(result, machine)
 
118
                        }
 
119
                }
 
120
                return result, nil
 
121
        }
 
122
        return c.machines, nil
 
123
}
 
124
 
 
125
func (c *fakeController) AllocateMachine(args gomaasapi.AllocateMachineArgs) (gomaasapi.Machine, gomaasapi.ConstraintMatches, error) {
 
126
        if c.allocateMachineArgsCheck != nil {
 
127
                c.allocateMachineArgsCheck(args)
 
128
        }
 
129
        if c.allocateMachineError != nil {
 
130
                return nil, c.allocateMachineMatches, c.allocateMachineError
 
131
        }
 
132
        return c.allocateMachine, c.allocateMachineMatches, nil
 
133
}
 
134
 
 
135
func (c *fakeController) BootResources() ([]gomaasapi.BootResource, error) {
 
136
        if c.bootResourcesError != nil {
 
137
                return nil, c.bootResourcesError
 
138
        }
 
139
        return c.bootResources, nil
 
140
}
 
141
 
 
142
func (c *fakeController) Zones() ([]gomaasapi.Zone, error) {
 
143
        if c.zonesError != nil {
 
144
                return nil, c.zonesError
 
145
        }
 
146
        return c.zones, nil
 
147
}
 
148
 
 
149
func (c *fakeController) Spaces() ([]gomaasapi.Space, error) {
 
150
        if c.spacesError != nil {
 
151
                return nil, c.spacesError
 
152
        }
 
153
        return c.spaces, nil
 
154
}
 
155
 
 
156
func (c *fakeController) Files(prefix string) ([]gomaasapi.File, error) {
 
157
        c.MethodCall(c, "Files", prefix)
 
158
        return c.files, c.NextErr()
 
159
}
 
160
 
 
161
func (c *fakeController) GetFile(filename string) (gomaasapi.File, error) {
 
162
        c.MethodCall(c, "GetFile", filename)
 
163
        err := c.NextErr()
 
164
        if err != nil {
 
165
                return nil, err
 
166
        }
 
167
        // Try to find the file by name (needed for testing RemoveAll)
 
168
        for _, file := range c.files {
 
169
                if file.Filename() == filename {
 
170
                        return file, nil
 
171
                }
 
172
        }
 
173
        // The test forgot to set up matching files!
 
174
        return nil, errors.Errorf("no file named %v found - did you set up your test correctly?", filename)
 
175
}
 
176
 
 
177
func (c *fakeController) AddFile(args gomaasapi.AddFileArgs) error {
 
178
        c.MethodCall(c, "AddFile", args)
 
179
        return c.NextErr()
 
180
}
 
181
 
 
182
func (c *fakeController) ReleaseMachines(args gomaasapi.ReleaseMachinesArgs) error {
 
183
        c.MethodCall(c, "ReleaseMachines", args)
 
184
        return c.NextErr()
 
185
}
 
186
 
 
187
type fakeBootResource struct {
 
188
        gomaasapi.BootResource
 
189
        name         string
 
190
        architecture string
 
191
}
 
192
 
 
193
func (r *fakeBootResource) Name() string {
 
194
        return r.name
 
195
}
 
196
 
 
197
func (r *fakeBootResource) Architecture() string {
 
198
        return r.architecture
 
199
}
 
200
 
 
201
type fakeMachine struct {
 
202
        gomaasapi.Machine
 
203
        *testing.Stub
 
204
 
 
205
        zoneName      string
 
206
        hostname      string
 
207
        systemID      string
 
208
        ipAddresses   []string
 
209
        statusName    string
 
210
        statusMessage string
 
211
        cpuCount      int
 
212
        memory        int
 
213
        architecture  string
 
214
        interfaceSet  []gomaasapi.Interface
 
215
        tags          []string
 
216
        createDevice  gomaasapi.Device
 
217
}
 
218
 
 
219
func newFakeMachine(systemID, architecture, statusName string) *fakeMachine {
 
220
        return &fakeMachine{
 
221
                Stub:         &testing.Stub{},
 
222
                systemID:     systemID,
 
223
                architecture: architecture,
 
224
                statusName:   statusName,
 
225
        }
 
226
}
 
227
 
 
228
func (m *fakeMachine) Tags() []string {
 
229
        return m.tags
 
230
}
 
231
 
 
232
func (m *fakeMachine) CPUCount() int {
 
233
        return m.cpuCount
 
234
}
 
235
 
 
236
func (m *fakeMachine) Memory() int {
 
237
        return m.memory
 
238
}
 
239
 
 
240
func (m *fakeMachine) Architecture() string {
 
241
        return m.architecture
 
242
}
 
243
 
 
244
func (m *fakeMachine) SystemID() string {
 
245
        return m.systemID
 
246
}
 
247
 
 
248
func (m *fakeMachine) Hostname() string {
 
249
        return m.hostname
 
250
}
 
251
 
 
252
func (m *fakeMachine) IPAddresses() []string {
 
253
        return m.ipAddresses
 
254
}
 
255
 
 
256
func (m *fakeMachine) StatusName() string {
 
257
        return m.statusName
 
258
}
 
259
 
 
260
func (m *fakeMachine) StatusMessage() string {
 
261
        return m.statusMessage
 
262
}
 
263
 
 
264
func (m *fakeMachine) Zone() gomaasapi.Zone {
 
265
        return fakeZone{name: m.zoneName}
 
266
}
 
267
 
 
268
func (m *fakeMachine) InterfaceSet() []gomaasapi.Interface {
 
269
        return m.interfaceSet
 
270
}
 
271
 
 
272
func (m *fakeMachine) Start(args gomaasapi.StartArgs) error {
 
273
        m.MethodCall(m, "Start", args)
 
274
        return m.NextErr()
 
275
}
 
276
 
 
277
func (m *fakeMachine) CreateDevice(args gomaasapi.CreateMachineDeviceArgs) (gomaasapi.Device, error) {
 
278
        m.MethodCall(m, "CreateDevice", args)
 
279
        return m.createDevice, m.NextErr()
 
280
}
 
281
 
 
282
type fakeZone struct {
 
283
        gomaasapi.Zone
 
284
        name string
 
285
}
 
286
 
 
287
func (z fakeZone) Name() string {
 
288
        return z.name
 
289
}
 
290
 
 
291
type fakeSpace struct {
 
292
        gomaasapi.Space
 
293
        name    string
 
294
        id      int
 
295
        subnets []gomaasapi.Subnet
 
296
}
 
297
 
 
298
func (s fakeSpace) Name() string {
 
299
        return s.name
 
300
}
 
301
 
 
302
func (s fakeSpace) ID() int {
 
303
        return s.id
 
304
}
 
305
 
 
306
func (s fakeSpace) Subnets() []gomaasapi.Subnet {
 
307
        return s.subnets
 
308
}
 
309
 
 
310
type fakeSubnet struct {
 
311
        gomaasapi.Subnet
 
312
        id         int
 
313
        space      string
 
314
        vlan       gomaasapi.VLAN
 
315
        gateway    string
 
316
        cidr       string
 
317
        dnsServers []string
 
318
}
 
319
 
 
320
func (s fakeSubnet) ID() int {
 
321
        return s.id
 
322
}
 
323
 
 
324
func (s fakeSubnet) Space() string {
 
325
        return s.space
 
326
}
 
327
 
 
328
func (s fakeSubnet) VLAN() gomaasapi.VLAN {
 
329
        return s.vlan
 
330
}
 
331
 
 
332
func (s fakeSubnet) Gateway() string {
 
333
        return s.gateway
 
334
}
 
335
 
 
336
func (s fakeSubnet) CIDR() string {
 
337
        return s.cidr
 
338
}
 
339
 
 
340
func (s fakeSubnet) DNSServers() []string {
 
341
        return s.dnsServers
 
342
}
 
343
 
 
344
type fakeVLAN struct {
 
345
        gomaasapi.VLAN
 
346
        id  int
 
347
        vid int
 
348
        mtu int
 
349
}
 
350
 
 
351
func (v fakeVLAN) ID() int {
 
352
        return v.id
 
353
}
 
354
 
 
355
func (v fakeVLAN) VID() int {
 
356
        return v.vid
 
357
}
 
358
 
 
359
func (v fakeVLAN) MTU() int {
 
360
        return v.mtu
 
361
}
 
362
 
 
363
type fakeInterface struct {
 
364
        gomaasapi.Interface
 
365
        *testing.Stub
 
366
 
 
367
        id         int
 
368
        name       string
 
369
        parents    []string
 
370
        children   []string
 
371
        type_      string
 
372
        enabled    bool
 
373
        vlan       gomaasapi.VLAN
 
374
        links      []gomaasapi.Link
 
375
        macAddress string
 
376
}
 
377
 
 
378
func (v *fakeInterface) ID() int {
 
379
        return v.id
 
380
}
 
381
 
 
382
func (v *fakeInterface) Name() string {
 
383
        return v.name
 
384
}
 
385
 
 
386
func (v *fakeInterface) Parents() []string {
 
387
        return v.parents
 
388
}
 
389
 
 
390
func (v *fakeInterface) Children() []string {
 
391
        return v.children
 
392
}
 
393
 
 
394
func (v *fakeInterface) Type() string {
 
395
        return v.type_
 
396
}
 
397
 
 
398
func (v *fakeInterface) EffectiveMTU() int {
 
399
        return 1500
 
400
}
 
401
 
 
402
func (v *fakeInterface) Enabled() bool {
 
403
        return v.enabled
 
404
}
 
405
 
 
406
func (v *fakeInterface) VLAN() gomaasapi.VLAN {
 
407
        return v.vlan
 
408
}
 
409
 
 
410
func (v *fakeInterface) Links() []gomaasapi.Link {
 
411
        return v.links
 
412
}
 
413
 
 
414
func (v *fakeInterface) MACAddress() string {
 
415
        return v.macAddress
 
416
}
 
417
 
 
418
func (v *fakeInterface) LinkSubnet(args gomaasapi.LinkSubnetArgs) error {
 
419
        v.MethodCall(v, "LinkSubnet", args)
 
420
        return v.NextErr()
 
421
}
 
422
 
 
423
type fakeLink struct {
 
424
        gomaasapi.Link
 
425
        id        int
 
426
        mode      string
 
427
        subnet    gomaasapi.Subnet
 
428
        ipAddress string
 
429
}
 
430
 
 
431
func (l *fakeLink) ID() int {
 
432
        return l.id
 
433
}
 
434
 
 
435
func (l *fakeLink) Mode() string {
 
436
        return l.mode
 
437
}
 
438
 
 
439
func (l *fakeLink) Subnet() gomaasapi.Subnet {
 
440
        return l.subnet
 
441
}
 
442
 
 
443
func (l *fakeLink) IPAddress() string {
 
444
        return l.ipAddress
 
445
}
 
446
 
 
447
type fakeFile struct {
 
448
        gomaasapi.File
 
449
        name     string
 
450
        url      string
 
451
        contents []byte
 
452
        deleted  bool
 
453
        error    error
 
454
}
 
455
 
 
456
func (f *fakeFile) Filename() string {
 
457
        return f.name
 
458
}
 
459
 
 
460
func (f *fakeFile) AnonymousURL() string {
 
461
        return f.url
 
462
}
 
463
 
 
464
func (f *fakeFile) Delete() error {
 
465
        f.deleted = true
 
466
        return f.error
 
467
}
 
468
 
 
469
func (f *fakeFile) ReadAll() ([]byte, error) {
 
470
        if f.error != nil {
 
471
                return nil, f.error
 
472
        }
 
473
        return f.contents, nil
 
474
}
 
475
 
 
476
type fakeBlockDevice struct {
 
477
        gomaasapi.BlockDevice
 
478
        name string
 
479
        path string
 
480
        size uint64
 
481
}
 
482
 
 
483
func (bd fakeBlockDevice) Name() string {
 
484
        return bd.name
 
485
}
 
486
 
 
487
func (bd fakeBlockDevice) Path() string {
 
488
        return bd.path
 
489
}
 
490
 
 
491
func (bd fakeBlockDevice) Size() uint64 {
 
492
        return bd.size
 
493
}
 
494
 
 
495
type fakeDevice struct {
 
496
        gomaasapi.Device
 
497
        *testing.Stub
 
498
 
 
499
        interfaceSet []gomaasapi.Interface
 
500
        systemID     string
 
501
        interface_   gomaasapi.Interface
 
502
}
 
503
 
 
504
func (d *fakeDevice) InterfaceSet() []gomaasapi.Interface {
 
505
        return d.interfaceSet
 
506
}
 
507
 
 
508
func (d *fakeDevice) SystemID() string {
 
509
        return d.systemID
 
510
}
 
511
 
 
512
func (d *fakeDevice) CreateInterface(args gomaasapi.CreateInterfaceArgs) (gomaasapi.Interface, error) {
 
513
        d.MethodCall(d, "CreateInterface", args)
 
514
        d.interfaceSet = append(d.interfaceSet, d.interface_)
 
515
        return d.interface_, d.NextErr()
 
516
}
 
517
 
 
518
func (d *fakeDevice) Delete() error {
 
519
        d.MethodCall(d, "Delete")
 
520
        return d.NextErr()
 
521
}