← 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/disks_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/disks_test.go
 
1
// Copyright 2014 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package gce_test
 
5
 
 
6
import (
 
7
        jc "github.com/juju/testing/checkers"
 
8
        gc "gopkg.in/check.v1"
 
9
        "gopkg.in/juju/names.v2"
 
10
 
 
11
        "github.com/juju/juju/instance"
 
12
        "github.com/juju/juju/provider/gce"
 
13
        "github.com/juju/juju/provider/gce/google"
 
14
        "github.com/juju/juju/storage"
 
15
)
 
16
 
 
17
type storageProviderSuite struct {
 
18
        gce.BaseSuite
 
19
        provider storage.Provider
 
20
}
 
21
 
 
22
var _ = gc.Suite(&storageProviderSuite{})
 
23
 
 
24
func (s *storageProviderSuite) SetUpTest(c *gc.C) {
 
25
        s.BaseSuite.SetUpTest(c)
 
26
 
 
27
        var err error
 
28
        s.provider, err = s.Env.StorageProvider("gce")
 
29
        c.Assert(err, jc.ErrorIsNil)
 
30
}
 
31
 
 
32
func (s *storageProviderSuite) TestValidateConfig(c *gc.C) {
 
33
        // ValidateConfig performs no validation at all yet, this test
 
34
        // it is just here to make sure that the placeholder will
 
35
        // accept a config.
 
36
        cfg := &storage.Config{}
 
37
        err := s.provider.ValidateConfig(cfg)
 
38
        c.Check(err, jc.ErrorIsNil)
 
39
}
 
40
 
 
41
func (s *storageProviderSuite) TestBlockStorageSupport(c *gc.C) {
 
42
        supports := s.provider.Supports(storage.StorageKindBlock)
 
43
        c.Check(supports, jc.IsTrue)
 
44
}
 
45
 
 
46
func (s *storageProviderSuite) TestFSStorageSupport(c *gc.C) {
 
47
        supports := s.provider.Supports(storage.StorageKindFilesystem)
 
48
        c.Check(supports, jc.IsFalse)
 
49
}
 
50
 
 
51
func (s *storageProviderSuite) TestFSSource(c *gc.C) {
 
52
        sConfig := &storage.Config{}
 
53
        _, err := s.provider.FilesystemSource(sConfig)
 
54
        c.Check(err, gc.ErrorMatches, "filesystems not supported")
 
55
}
 
56
 
 
57
func (s *storageProviderSuite) TestVolumeSource(c *gc.C) {
 
58
        storageCfg := &storage.Config{}
 
59
        _, err := s.provider.VolumeSource(storageCfg)
 
60
        c.Check(err, jc.ErrorIsNil)
 
61
}
 
62
 
 
63
type volumeSourceSuite struct {
 
64
        gce.BaseSuite
 
65
        source           storage.VolumeSource
 
66
        params           []storage.VolumeParams
 
67
        instId           instance.Id
 
68
        attachmentParams *storage.VolumeAttachmentParams
 
69
}
 
70
 
 
71
var _ = gc.Suite(&volumeSourceSuite{})
 
72
 
 
73
func (s *volumeSourceSuite) SetUpTest(c *gc.C) {
 
74
        s.BaseSuite.SetUpTest(c)
 
75
 
 
76
        provider, err := s.Env.StorageProvider("gce")
 
77
        c.Assert(err, jc.ErrorIsNil)
 
78
        s.source, err = provider.VolumeSource(&storage.Config{})
 
79
        c.Check(err, jc.ErrorIsNil)
 
80
 
 
81
        inst := gce.NewInstance(s.BaseInstance, s.Env)
 
82
        vTag := names.NewVolumeTag("0")
 
83
        mTag := names.NewMachineTag("0")
 
84
        s.instId = inst.Id()
 
85
        s.attachmentParams = &storage.VolumeAttachmentParams{
 
86
                AttachmentParams: storage.AttachmentParams{
 
87
                        Provider:   "gce",
 
88
                        Machine:    mTag,
 
89
                        InstanceId: s.instId,
 
90
                },
 
91
                VolumeId: s.BaseDisk.Name,
 
92
                Volume:   names.NewVolumeTag("0"),
 
93
        }
 
94
        s.params = []storage.VolumeParams{{
 
95
                Tag:        vTag,
 
96
                Size:       1024,
 
97
                Provider:   "gce",
 
98
                Attachment: s.attachmentParams,
 
99
        }}
 
100
 
 
101
}
 
102
 
 
103
func (s *volumeSourceSuite) TestCreateVolumesNoInstance(c *gc.C) {
 
104
        res, err := s.source.CreateVolumes(s.params)
 
105
        c.Check(err, jc.ErrorIsNil)
 
106
        c.Check(res, gc.HasLen, 1)
 
107
        expectedErr := "cannot obtain \"spam\" from instance cache: cannot attach to non-running instance spam"
 
108
        c.Assert(res[0].Error, gc.ErrorMatches, expectedErr)
 
109
 
 
110
}
 
111
 
 
112
func (s *volumeSourceSuite) TestCreateVolumesNoDiskCreated(c *gc.C) {
 
113
        s.FakeConn.Insts = []google.Instance{*s.BaseInstance}
 
114
        res, err := s.source.CreateVolumes(s.params)
 
115
        c.Check(err, jc.ErrorIsNil)
 
116
        c.Check(res, gc.HasLen, 1)
 
117
        c.Assert(res[0].Error, gc.ErrorMatches, "unexpected number of disks created: 0")
 
118
 
 
119
}
 
120
 
 
121
func (s *volumeSourceSuite) TestCreateVolumes(c *gc.C) {
 
122
        s.FakeConn.Insts = []google.Instance{*s.BaseInstance}
 
123
        s.FakeConn.GoogleDisks = []*google.Disk{s.BaseDisk}
 
124
        s.FakeConn.GoogleDisk = s.BaseDisk
 
125
        s.FakeConn.AttachedDisk = &google.AttachedDisk{
 
126
                VolumeName: s.BaseDisk.Name,
 
127
                DeviceName: "home-zone-1234567",
 
128
                Mode:       "READ_WRITE",
 
129
        }
 
130
        res, err := s.source.CreateVolumes(s.params)
 
131
        c.Check(err, jc.ErrorIsNil)
 
132
        c.Check(res, gc.HasLen, 1)
 
133
        // Volume was created
 
134
        c.Assert(res[0].Error, jc.ErrorIsNil)
 
135
        c.Assert(res[0].Volume.VolumeId, gc.Equals, s.BaseDisk.Name)
 
136
        c.Assert(res[0].Volume.HardwareId, gc.Equals, "")
 
137
 
 
138
        // Volume was also attached as indicated by Attachment in params.
 
139
        c.Assert(res[0].VolumeAttachment.DeviceName, gc.Equals, "")
 
140
        c.Assert(res[0].VolumeAttachment.DeviceLink, gc.Equals, "/dev/disk/by-id/google-home-zone-1234567")
 
141
        c.Assert(res[0].VolumeAttachment.Machine.String(), gc.Equals, "machine-0")
 
142
        c.Assert(res[0].VolumeAttachment.ReadOnly, jc.IsFalse)
 
143
        c.Assert(res[0].VolumeAttachment.Volume.String(), gc.Equals, "volume-0")
 
144
 
 
145
        // Internals where properly called
 
146
        // Disk Creation
 
147
        createCalled, call := s.FakeConn.WasCalled("CreateDisks")
 
148
        c.Check(call, gc.HasLen, 1)
 
149
        c.Assert(createCalled, jc.IsTrue)
 
150
        c.Assert(call[0].ZoneName, gc.Equals, "home-zone")
 
151
        c.Assert(call[0].Disks[0].Name, jc.HasPrefix, "home-zone--")
 
152
 
 
153
        // Instance existence Checking
 
154
        instanceDisksCalled, call := s.FakeConn.WasCalled("InstanceDisks")
 
155
        c.Check(call, gc.HasLen, 1)
 
156
        c.Assert(instanceDisksCalled, jc.IsTrue)
 
157
        c.Assert(call[0].ZoneName, gc.Equals, "home-zone")
 
158
        c.Assert(call[0].InstanceId, gc.Equals, string(s.instId))
 
159
 
 
160
        // Disk Was attached
 
161
        attachCalled, call := s.FakeConn.WasCalled("AttachDisk")
 
162
        c.Check(call, gc.HasLen, 1)
 
163
        c.Assert(attachCalled, jc.IsTrue)
 
164
        c.Assert(call[0].ZoneName, gc.Equals, "home-zone")
 
165
        c.Assert(call[0].VolumeName, jc.HasPrefix, "home-zone--")
 
166
        c.Assert(call[0].InstanceId, gc.Equals, string(s.instId))
 
167
}
 
168
 
 
169
func (s *volumeSourceSuite) TestDestroyVolumes(c *gc.C) {
 
170
        errs, err := s.source.DestroyVolumes([]string{"a--volume-name"})
 
171
        c.Check(err, jc.ErrorIsNil)
 
172
        c.Check(errs, gc.HasLen, 1)
 
173
        c.Assert(errs[0], jc.ErrorIsNil)
 
174
 
 
175
        destroyCalled, call := s.FakeConn.WasCalled("RemoveDisk")
 
176
        c.Check(call, gc.HasLen, 1)
 
177
        c.Assert(destroyCalled, jc.IsTrue)
 
178
        c.Assert(call[0].ZoneName, gc.Equals, "a")
 
179
        c.Assert(call[0].ID, gc.Equals, "a--volume-name")
 
180
}
 
181
 
 
182
func (s *volumeSourceSuite) TestListVolumes(c *gc.C) {
 
183
        s.FakeConn.GoogleDisks = []*google.Disk{s.BaseDisk}
 
184
        s.FakeConn.Zones = []google.AvailabilityZone{google.NewZone("home-zone", "Ready", "", "")}
 
185
        vols, err := s.source.ListVolumes()
 
186
        c.Check(err, jc.ErrorIsNil)
 
187
        c.Assert(vols, gc.HasLen, 1)
 
188
 
 
189
        azsCalled, call := s.FakeConn.WasCalled("AvailabilityZones")
 
190
        c.Check(call, gc.HasLen, 1)
 
191
        c.Assert(azsCalled, jc.IsTrue)
 
192
        c.Assert(call[0].Region, gc.Equals, "")
 
193
 
 
194
        disksCalled, call := s.FakeConn.WasCalled("Disks")
 
195
        c.Check(call, gc.HasLen, 1)
 
196
        c.Assert(disksCalled, jc.IsTrue)
 
197
        c.Assert(call[0].ZoneName, gc.Equals, "home-zone")
 
198
}
 
199
 
 
200
func (s *volumeSourceSuite) TestListVolumesOnlyListsCurrentModelUUID(c *gc.C) {
 
201
        otherDisk := &google.Disk{
 
202
                Id:          1234568,
 
203
                Name:        "home-zone--566fe7b2-c026-4a86-a2cc-84cb7f9a4868",
 
204
                Zone:        "home-zone",
 
205
                Status:      google.StatusReady,
 
206
                Size:        1024,
 
207
                Description: "a-different-model-uuid",
 
208
        }
 
209
        s.FakeConn.GoogleDisks = []*google.Disk{s.BaseDisk, otherDisk}
 
210
        s.FakeConn.Zones = []google.AvailabilityZone{google.NewZone("home-zone", "Ready", "", "")}
 
211
        vols, err := s.source.ListVolumes()
 
212
        c.Check(err, jc.ErrorIsNil)
 
213
        c.Assert(vols, gc.HasLen, 1)
 
214
}
 
215
 
 
216
func (s *volumeSourceSuite) TestListVolumesListsEmptyUUIDVolumes(c *gc.C) {
 
217
        otherDisk := &google.Disk{
 
218
                Id:          1234568,
 
219
                Name:        "home-zone--566fe7b2-c026-4a86-a2cc-84cb7f9a4868",
 
220
                Zone:        "home-zone",
 
221
                Status:      google.StatusReady,
 
222
                Size:        1024,
 
223
                Description: "",
 
224
        }
 
225
        s.FakeConn.GoogleDisks = []*google.Disk{s.BaseDisk, otherDisk}
 
226
        s.FakeConn.Zones = []google.AvailabilityZone{google.NewZone("home-zone", "Ready", "", "")}
 
227
        vols, err := s.source.ListVolumes()
 
228
        c.Check(err, jc.ErrorIsNil)
 
229
        c.Assert(vols, gc.HasLen, 2)
 
230
}
 
231
 
 
232
func (s *volumeSourceSuite) TestListVolumesIgnoresNamesFormatteDifferently(c *gc.C) {
 
233
        otherDisk := &google.Disk{
 
234
                Id:          1234568,
 
235
                Name:        "juju-566fe7b2-c026-4a86-a2cc-84cb7f9a4868",
 
236
                Zone:        "home-zone",
 
237
                Status:      google.StatusReady,
 
238
                Size:        1024,
 
239
                Description: "",
 
240
        }
 
241
        s.FakeConn.GoogleDisks = []*google.Disk{s.BaseDisk, otherDisk}
 
242
        s.FakeConn.Zones = []google.AvailabilityZone{google.NewZone("home-zone", "Ready", "", "")}
 
243
        vols, err := s.source.ListVolumes()
 
244
        c.Check(err, jc.ErrorIsNil)
 
245
        c.Assert(vols, gc.HasLen, 1)
 
246
}
 
247
 
 
248
func (s *volumeSourceSuite) TestDescribeVolumes(c *gc.C) {
 
249
        s.FakeConn.GoogleDisk = s.BaseDisk
 
250
        volName := "home-zone--c930380d-8337-4bf5-b07a-9dbb5ae771e4"
 
251
        res, err := s.source.DescribeVolumes([]string{volName})
 
252
        c.Check(err, jc.ErrorIsNil)
 
253
        c.Assert(res, gc.HasLen, 1)
 
254
        c.Assert(res[0].VolumeInfo.Size, gc.Equals, uint64(1024))
 
255
        c.Assert(res[0].VolumeInfo.VolumeId, gc.Equals, volName)
 
256
 
 
257
        diskCalled, call := s.FakeConn.WasCalled("Disk")
 
258
        c.Check(call, gc.HasLen, 1)
 
259
        c.Assert(diskCalled, jc.IsTrue)
 
260
        c.Assert(call[0].ZoneName, gc.Equals, "home-zone")
 
261
        c.Assert(call[0].ID, gc.Equals, volName)
 
262
}
 
263
 
 
264
func (s *volumeSourceSuite) TestAttachVolumes(c *gc.C) {
 
265
        volName := "home-zone--c930380d-8337-4bf5-b07a-9dbb5ae771e4"
 
266
        attachments := []storage.VolumeAttachmentParams{*s.attachmentParams}
 
267
        s.FakeConn.AttachedDisk = &google.AttachedDisk{
 
268
                VolumeName: s.BaseDisk.Name,
 
269
                DeviceName: "home-zone-1234567",
 
270
                Mode:       "READ_WRITE",
 
271
        }
 
272
        res, err := s.source.AttachVolumes(attachments)
 
273
        c.Check(err, jc.ErrorIsNil)
 
274
        c.Assert(res, gc.HasLen, 1)
 
275
        c.Assert(res[0].VolumeAttachment.Volume.String(), gc.Equals, "volume-0")
 
276
        c.Assert(res[0].VolumeAttachment.Machine.String(), gc.Equals, "machine-0")
 
277
        c.Assert(res[0].VolumeAttachment.VolumeAttachmentInfo.DeviceName, gc.Equals, "home-zone-1234567")
 
278
 
 
279
        // Disk Was attached
 
280
        attachCalled, call := s.FakeConn.WasCalled("AttachDisk")
 
281
        c.Check(call, gc.HasLen, 1)
 
282
        c.Assert(attachCalled, jc.IsTrue)
 
283
        c.Assert(call[0].ZoneName, gc.Equals, "home-zone")
 
284
        c.Assert(call[0].VolumeName, gc.Equals, volName)
 
285
        c.Assert(call[0].InstanceId, gc.Equals, string(s.instId))
 
286
 
 
287
}
 
288
 
 
289
func (s *volumeSourceSuite) TestDetachVolumes(c *gc.C) {
 
290
        volName := "home-zone--c930380d-8337-4bf5-b07a-9dbb5ae771e4"
 
291
        attachments := []storage.VolumeAttachmentParams{*s.attachmentParams}
 
292
        errs, err := s.source.DetachVolumes(attachments)
 
293
        c.Check(err, jc.ErrorIsNil)
 
294
        c.Assert(errs, gc.HasLen, 1)
 
295
        c.Assert(errs[0], jc.ErrorIsNil)
 
296
 
 
297
        // Disk Was detached
 
298
        attachCalled, call := s.FakeConn.WasCalled("DetachDisk")
 
299
        c.Check(call, gc.HasLen, 1)
 
300
        c.Assert(attachCalled, jc.IsTrue)
 
301
        c.Assert(call[0].ZoneName, gc.Equals, "home-zone")
 
302
        c.Assert(call[0].InstanceId, gc.Equals, string(s.instId))
 
303
        c.Assert(call[0].VolumeName, gc.Equals, volName)
 
304
}