4
"launchpad.net/goamz/aws"
5
"launchpad.net/goamz/ec2"
6
"launchpad.net/goamz/testutil"
7
. "launchpad.net/gocheck"
11
func Test(t *testing.T) {
21
var testServer = testutil.NewHTTPServer()
23
func (s *S) SetUpSuite(c *C) {
25
auth := aws.Auth{"abc", "123"}
26
s.ec2 = ec2.New(auth, aws.Region{EC2Endpoint: testServer.URL})
29
func (s *S) TearDownTest(c *C) {
33
func (s *S) TestRunInstancesErrorDump(c *C) {
34
testServer.Response(400, nil, ErrorDump)
36
options := ec2.RunInstances{
37
ImageId: "ami-a6f504cf", // Ubuntu Maverick, i386, instance store
38
InstanceType: "t1.micro", // Doesn't work with micro, results in 400.
41
msg := `AMIs with an instance-store root device are not supported for the instance type 't1\.micro'\.`
43
resp, err := s.ec2.RunInstances(&options)
45
testServer.WaitRequest()
48
c.Assert(err, ErrorMatches, msg+` \(UnsupportedOperation\)`)
50
ec2err, ok := err.(*ec2.Error)
51
c.Assert(ok, Equals, true)
52
c.Assert(ec2err.StatusCode, Equals, 400)
53
c.Assert(ec2err.Code, Equals, "UnsupportedOperation")
54
c.Assert(ec2err.Message, Matches, msg)
55
c.Assert(ec2err.RequestId, Equals, "0503f4e9-bbd6-483c-b54f-c4ae9f3b30f4")
58
func (s *S) TestRunInstancesErrorWithoutXML(c *C) {
59
testServer.Response(500, nil, "")
60
options := ec2.RunInstances{ImageId: "image-id"}
62
resp, err := s.ec2.RunInstances(&options)
64
testServer.WaitRequest()
67
c.Assert(err, ErrorMatches, "500 Internal Server Error")
69
ec2err, ok := err.(*ec2.Error)
70
c.Assert(ok, Equals, true)
71
c.Assert(ec2err.StatusCode, Equals, 500)
72
c.Assert(ec2err.Code, Equals, "")
73
c.Assert(ec2err.Message, Equals, "500 Internal Server Error")
74
c.Assert(ec2err.RequestId, Equals, "")
77
func (s *S) TestRunInstancesExample(c *C) {
78
testServer.Response(200, nil, RunInstancesExample)
80
options := ec2.RunInstances{
83
InstanceType: "inst-type",
84
SecurityGroups: []ec2.SecurityGroup{{Name: "g1"}, {Id: "g2"}, {Name: "g3"}, {Id: "g4"}},
85
UserData: []byte("1234"),
86
KernelId: "kernel-id",
87
RamdiskId: "ramdisk-id",
89
PlacementGroupName: "group",
91
SubnetId: "subnet-id",
92
DisableAPITermination: true,
93
ShutdownBehavior: "terminate",
94
PrivateIPAddress: "10.0.0.25",
96
resp, err := s.ec2.RunInstances(&options)
98
req := testServer.WaitRequest()
99
c.Assert(req.Form["Action"], DeepEquals, []string{"RunInstances"})
100
c.Assert(req.Form["ImageId"], DeepEquals, []string{"image-id"})
101
c.Assert(req.Form["MinCount"], DeepEquals, []string{"1"})
102
c.Assert(req.Form["MaxCount"], DeepEquals, []string{"1"})
103
c.Assert(req.Form["KeyName"], DeepEquals, []string{"my-keys"})
104
c.Assert(req.Form["InstanceType"], DeepEquals, []string{"inst-type"})
105
c.Assert(req.Form["SecurityGroup.1"], DeepEquals, []string{"g1"})
106
c.Assert(req.Form["SecurityGroup.2"], DeepEquals, []string{"g3"})
107
c.Assert(req.Form["SecurityGroupId.1"], DeepEquals, []string{"g2"})
108
c.Assert(req.Form["SecurityGroupId.2"], DeepEquals, []string{"g4"})
109
c.Assert(req.Form["UserData"], DeepEquals, []string{"MTIzNA=="})
110
c.Assert(req.Form["KernelId"], DeepEquals, []string{"kernel-id"})
111
c.Assert(req.Form["RamdiskId"], DeepEquals, []string{"ramdisk-id"})
112
c.Assert(req.Form["Placement.AvailabilityZone"], DeepEquals, []string{"zone"})
113
c.Assert(req.Form["Placement.GroupName"], DeepEquals, []string{"group"})
114
c.Assert(req.Form["Monitoring.Enabled"], DeepEquals, []string{"true"})
115
c.Assert(req.Form["SubnetId"], DeepEquals, []string{"subnet-id"})
116
c.Assert(req.Form["DisableApiTermination"], DeepEquals, []string{"true"})
117
c.Assert(req.Form["InstanceInitiatedShutdownBehavior"], DeepEquals, []string{"terminate"})
118
c.Assert(req.Form["PrivateIpAddress"], DeepEquals, []string{"10.0.0.25"})
121
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
122
c.Assert(resp.ReservationId, Equals, "r-47a5402e")
123
c.Assert(resp.OwnerId, Equals, "999988887777")
124
c.Assert(resp.SecurityGroups, DeepEquals, []ec2.SecurityGroup{{Name: "default", Id: "sg-67ad940e"}})
125
c.Assert(resp.Instances, HasLen, 3)
127
i0 := resp.Instances[0]
128
c.Assert(i0.InstanceId, Equals, "i-2ba64342")
129
c.Assert(i0.InstanceType, Equals, "m1.small")
130
c.Assert(i0.ImageId, Equals, "ami-60a54009")
131
c.Assert(i0.Monitoring, Equals, "enabled")
132
c.Assert(i0.KeyName, Equals, "example-key-name")
133
c.Assert(i0.AMILaunchIndex, Equals, 0)
134
c.Assert(i0.VirtType, Equals, "paravirtual")
135
c.Assert(i0.Hypervisor, Equals, "xen")
137
i1 := resp.Instances[1]
138
c.Assert(i1.InstanceId, Equals, "i-2bc64242")
139
c.Assert(i1.InstanceType, Equals, "m1.small")
140
c.Assert(i1.ImageId, Equals, "ami-60a54009")
141
c.Assert(i1.Monitoring, Equals, "enabled")
142
c.Assert(i1.KeyName, Equals, "example-key-name")
143
c.Assert(i1.AMILaunchIndex, Equals, 1)
144
c.Assert(i1.VirtType, Equals, "paravirtual")
145
c.Assert(i1.Hypervisor, Equals, "xen")
147
i2 := resp.Instances[2]
148
c.Assert(i2.InstanceId, Equals, "i-2be64332")
149
c.Assert(i2.InstanceType, Equals, "m1.small")
150
c.Assert(i2.ImageId, Equals, "ami-60a54009")
151
c.Assert(i2.Monitoring, Equals, "enabled")
152
c.Assert(i2.KeyName, Equals, "example-key-name")
153
c.Assert(i2.AMILaunchIndex, Equals, 2)
154
c.Assert(i2.VirtType, Equals, "paravirtual")
155
c.Assert(i2.Hypervisor, Equals, "xen")
158
func (s *S) TestTerminateInstancesExample(c *C) {
159
testServer.Response(200, nil, TerminateInstancesExample)
161
resp, err := s.ec2.TerminateInstances([]string{"i-1", "i-2"})
163
req := testServer.WaitRequest()
164
c.Assert(req.Form["Action"], DeepEquals, []string{"TerminateInstances"})
165
c.Assert(req.Form["InstanceId.1"], DeepEquals, []string{"i-1"})
166
c.Assert(req.Form["InstanceId.2"], DeepEquals, []string{"i-2"})
167
c.Assert(req.Form["UserData"], IsNil)
168
c.Assert(req.Form["KernelId"], IsNil)
169
c.Assert(req.Form["RamdiskId"], IsNil)
170
c.Assert(req.Form["Placement.AvailabilityZone"], IsNil)
171
c.Assert(req.Form["Placement.GroupName"], IsNil)
172
c.Assert(req.Form["Monitoring.Enabled"], IsNil)
173
c.Assert(req.Form["SubnetId"], IsNil)
174
c.Assert(req.Form["DisableApiTermination"], IsNil)
175
c.Assert(req.Form["InstanceInitiatedShutdownBehavior"], IsNil)
176
c.Assert(req.Form["PrivateIpAddress"], IsNil)
179
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
180
c.Assert(resp.StateChanges, HasLen, 1)
181
c.Assert(resp.StateChanges[0].InstanceId, Equals, "i-3ea74257")
182
c.Assert(resp.StateChanges[0].CurrentState.Code, Equals, 32)
183
c.Assert(resp.StateChanges[0].CurrentState.Name, Equals, "shutting-down")
184
c.Assert(resp.StateChanges[0].PreviousState.Code, Equals, 16)
185
c.Assert(resp.StateChanges[0].PreviousState.Name, Equals, "running")
188
func (s *S) TestDescribeInstancesExample1(c *C) {
189
testServer.Response(200, nil, DescribeInstancesExample1)
191
filter := ec2.NewFilter()
192
filter.Add("key1", "value1")
193
filter.Add("key2", "value2", "value3")
195
resp, err := s.ec2.Instances([]string{"i-1", "i-2"}, nil)
197
req := testServer.WaitRequest()
198
c.Assert(req.Form["Action"], DeepEquals, []string{"DescribeInstances"})
199
c.Assert(req.Form["InstanceId.1"], DeepEquals, []string{"i-1"})
200
c.Assert(req.Form["InstanceId.2"], DeepEquals, []string{"i-2"})
203
c.Assert(resp.RequestId, Equals, "98e3c9a4-848c-4d6d-8e8a-b1bdEXAMPLE")
204
c.Assert(resp.Reservations, HasLen, 2)
206
r0 := resp.Reservations[0]
207
c.Assert(r0.ReservationId, Equals, "r-b27e30d9")
208
c.Assert(r0.OwnerId, Equals, "999988887777")
209
c.Assert(r0.RequesterId, Equals, "854251627541")
210
c.Assert(r0.SecurityGroups, DeepEquals, []ec2.SecurityGroup{{Name: "default", Id: "sg-67ad940e"}})
211
c.Assert(r0.Instances, HasLen, 1)
213
r0i := r0.Instances[0]
214
c.Assert(r0i.InstanceId, Equals, "i-c5cd56af")
215
c.Assert(r0i.PrivateDNSName, Equals, "domU-12-31-39-10-56-34.compute-1.internal")
216
c.Assert(r0i.DNSName, Equals, "ec2-174-129-165-232.compute-1.amazonaws.com")
217
c.Assert(r0i.AvailZone, Equals, "us-east-1b")
220
func (s *S) TestDescribeInstancesExample2(c *C) {
221
testServer.Response(200, nil, DescribeInstancesExample2)
223
filter := ec2.NewFilter()
224
filter.Add("key1", "value1")
225
filter.Add("key2", "value2", "value3")
227
resp, err := s.ec2.Instances([]string{"i-1", "i-2"}, filter)
229
req := testServer.WaitRequest()
230
c.Assert(req.Form["Action"], DeepEquals, []string{"DescribeInstances"})
231
c.Assert(req.Form["InstanceId.1"], DeepEquals, []string{"i-1"})
232
c.Assert(req.Form["InstanceId.2"], DeepEquals, []string{"i-2"})
233
c.Assert(req.Form["Filter.1.Name"], DeepEquals, []string{"key1"})
234
c.Assert(req.Form["Filter.1.Value.1"], DeepEquals, []string{"value1"})
235
c.Assert(req.Form["Filter.1.Value.2"], IsNil)
236
c.Assert(req.Form["Filter.2.Name"], DeepEquals, []string{"key2"})
237
c.Assert(req.Form["Filter.2.Value.1"], DeepEquals, []string{"value2"})
238
c.Assert(req.Form["Filter.2.Value.2"], DeepEquals, []string{"value3"})
241
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
242
c.Assert(resp.Reservations, HasLen, 1)
244
r0 := resp.Reservations[0]
245
r0i := r0.Instances[0]
246
c.Assert(r0i.State.Code, Equals, 16)
247
c.Assert(r0i.State.Name, Equals, "running")
251
c.Assert(r0t0.Key, Equals, "webserver")
252
c.Assert(r0t0.Value, Equals, "")
253
c.Assert(r0t1.Key, Equals, "stack")
254
c.Assert(r0t1.Value, Equals, "Production")
257
func (s *S) TestDescribeImagesExample(c *C) {
258
testServer.Response(200, nil, DescribeImagesExample)
260
filter := ec2.NewFilter()
261
filter.Add("key1", "value1")
262
filter.Add("key2", "value2", "value3")
264
resp, err := s.ec2.Images([]string{"ami-1", "ami-2"}, filter)
266
req := testServer.WaitRequest()
267
c.Assert(req.Form["Action"], DeepEquals, []string{"DescribeImages"})
268
c.Assert(req.Form["ImageId.1"], DeepEquals, []string{"ami-1"})
269
c.Assert(req.Form["ImageId.2"], DeepEquals, []string{"ami-2"})
270
c.Assert(req.Form["Filter.1.Name"], DeepEquals, []string{"key1"})
271
c.Assert(req.Form["Filter.1.Value.1"], DeepEquals, []string{"value1"})
272
c.Assert(req.Form["Filter.1.Value.2"], IsNil)
273
c.Assert(req.Form["Filter.2.Name"], DeepEquals, []string{"key2"})
274
c.Assert(req.Form["Filter.2.Value.1"], DeepEquals, []string{"value2"})
275
c.Assert(req.Form["Filter.2.Value.2"], DeepEquals, []string{"value3"})
278
c.Assert(resp.RequestId, Equals, "4a4a27a2-2e7c-475d-b35b-ca822EXAMPLE")
279
c.Assert(resp.Images, HasLen, 1)
282
c.Assert(i0.Id, Equals, "ami-a2469acf")
283
c.Assert(i0.Type, Equals, "machine")
284
c.Assert(i0.Name, Equals, "example-marketplace-amzn-ami.1")
285
c.Assert(i0.Description, Equals, "Amazon Linux AMI i386 EBS")
286
c.Assert(i0.Location, Equals, "aws-marketplace/example-marketplace-amzn-ami.1")
287
c.Assert(i0.State, Equals, "available")
288
c.Assert(i0.Public, Equals, true)
289
c.Assert(i0.OwnerId, Equals, "123456789999")
290
c.Assert(i0.OwnerAlias, Equals, "aws-marketplace")
291
c.Assert(i0.Architecture, Equals, "i386")
292
c.Assert(i0.KernelId, Equals, "aki-805ea7e9")
293
c.Assert(i0.RootDeviceType, Equals, "ebs")
294
c.Assert(i0.RootDeviceName, Equals, "/dev/sda1")
295
c.Assert(i0.VirtualizationType, Equals, "paravirtual")
296
c.Assert(i0.Hypervisor, Equals, "xen")
298
c.Assert(i0.BlockDevices, HasLen, 1)
299
c.Assert(i0.BlockDevices[0].DeviceName, Equals, "/dev/sda1")
300
c.Assert(i0.BlockDevices[0].SnapshotId, Equals, "snap-787e9403")
301
c.Assert(i0.BlockDevices[0].VolumeSize, Equals, int64(8))
302
c.Assert(i0.BlockDevices[0].DeleteOnTermination, Equals, true)
305
func (s *S) TestCreateSnapshotExample(c *C) {
306
testServer.Response(200, nil, CreateSnapshotExample)
308
resp, err := s.ec2.CreateSnapshot("vol-4d826724", "Daily Backup")
310
req := testServer.WaitRequest()
311
c.Assert(req.Form["Action"], DeepEquals, []string{"CreateSnapshot"})
312
c.Assert(req.Form["VolumeId"], DeepEquals, []string{"vol-4d826724"})
313
c.Assert(req.Form["Description"], DeepEquals, []string{"Daily Backup"})
316
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
317
c.Assert(resp.Snapshot.Id, Equals, "snap-78a54011")
318
c.Assert(resp.Snapshot.VolumeId, Equals, "vol-4d826724")
319
c.Assert(resp.Snapshot.Status, Equals, "pending")
320
c.Assert(resp.Snapshot.StartTime, Equals, "2008-05-07T12:51:50.000Z")
321
c.Assert(resp.Snapshot.Progress, Equals, "60%")
322
c.Assert(resp.Snapshot.OwnerId, Equals, "111122223333")
323
c.Assert(resp.Snapshot.VolumeSize, Equals, "10")
324
c.Assert(resp.Snapshot.Description, Equals, "Daily Backup")
327
func (s *S) TestDeleteSnapshotsExample(c *C) {
328
testServer.Response(200, nil, DeleteSnapshotExample)
330
resp, err := s.ec2.DeleteSnapshots([]string{"snap-78a54011"})
332
req := testServer.WaitRequest()
333
c.Assert(req.Form["Action"], DeepEquals, []string{"DeleteSnapshot"})
334
c.Assert(req.Form["SnapshotId.1"], DeepEquals, []string{"snap-78a54011"})
337
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
340
func (s *S) TestDescribeSnapshotsExample(c *C) {
341
testServer.Response(200, nil, DescribeSnapshotsExample)
343
filter := ec2.NewFilter()
344
filter.Add("key1", "value1")
345
filter.Add("key2", "value2", "value3")
347
resp, err := s.ec2.Snapshots([]string{"snap-1", "snap-2"}, filter)
349
req := testServer.WaitRequest()
350
c.Assert(req.Form["Action"], DeepEquals, []string{"DescribeSnapshots"})
351
c.Assert(req.Form["SnapshotId.1"], DeepEquals, []string{"snap-1"})
352
c.Assert(req.Form["SnapshotId.2"], DeepEquals, []string{"snap-2"})
353
c.Assert(req.Form["Filter.1.Name"], DeepEquals, []string{"key1"})
354
c.Assert(req.Form["Filter.1.Value.1"], DeepEquals, []string{"value1"})
355
c.Assert(req.Form["Filter.1.Value.2"], IsNil)
356
c.Assert(req.Form["Filter.2.Name"], DeepEquals, []string{"key2"})
357
c.Assert(req.Form["Filter.2.Value.1"], DeepEquals, []string{"value2"})
358
c.Assert(req.Form["Filter.2.Value.2"], DeepEquals, []string{"value3"})
361
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
362
c.Assert(resp.Snapshots, HasLen, 1)
364
s0 := resp.Snapshots[0]
365
c.Assert(s0.Id, Equals, "snap-1a2b3c4d")
366
c.Assert(s0.VolumeId, Equals, "vol-8875daef")
367
c.Assert(s0.VolumeSize, Equals, "15")
368
c.Assert(s0.Status, Equals, "pending")
369
c.Assert(s0.StartTime, Equals, "2010-07-29T04:12:01.000Z")
370
c.Assert(s0.Progress, Equals, "30%")
371
c.Assert(s0.OwnerId, Equals, "111122223333")
372
c.Assert(s0.Description, Equals, "Daily Backup")
374
c.Assert(s0.Tags, HasLen, 1)
375
c.Assert(s0.Tags[0].Key, Equals, "Purpose")
376
c.Assert(s0.Tags[0].Value, Equals, "demo_db_14_backup")
379
func (s *S) TestCreateSecurityGroupExample(c *C) {
380
testServer.Response(200, nil, CreateSecurityGroupExample)
382
resp, err := s.ec2.CreateSecurityGroup("websrv", "Web Servers")
384
req := testServer.WaitRequest()
385
c.Assert(req.Form["Action"], DeepEquals, []string{"CreateSecurityGroup"})
386
c.Assert(req.Form["GroupName"], DeepEquals, []string{"websrv"})
387
c.Assert(req.Form["GroupDescription"], DeepEquals, []string{"Web Servers"})
390
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
391
c.Assert(resp.Name, Equals, "websrv")
392
c.Assert(resp.Id, Equals, "sg-67ad940e")
395
func (s *S) TestDescribeSecurityGroupsExample(c *C) {
396
testServer.Response(200, nil, DescribeSecurityGroupsExample)
398
resp, err := s.ec2.SecurityGroups([]ec2.SecurityGroup{{Name: "WebServers"}, {Name: "RangedPortsBySource"}}, nil)
400
req := testServer.WaitRequest()
401
c.Assert(req.Form["Action"], DeepEquals, []string{"DescribeSecurityGroups"})
402
c.Assert(req.Form["GroupName.1"], DeepEquals, []string{"WebServers"})
403
c.Assert(req.Form["GroupName.2"], DeepEquals, []string{"RangedPortsBySource"})
406
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
407
c.Assert(resp.Groups, HasLen, 2)
410
c.Assert(g0.OwnerId, Equals, "999988887777")
411
c.Assert(g0.Name, Equals, "WebServers")
412
c.Assert(g0.Id, Equals, "sg-67ad940e")
413
c.Assert(g0.Description, Equals, "Web Servers")
414
c.Assert(g0.IPPerms, HasLen, 1)
416
g0ipp := g0.IPPerms[0]
417
c.Assert(g0ipp.Protocol, Equals, "tcp")
418
c.Assert(g0ipp.FromPort, Equals, 80)
419
c.Assert(g0ipp.ToPort, Equals, 80)
420
c.Assert(g0ipp.SourceIPs, DeepEquals, []string{"0.0.0.0/0"})
423
c.Assert(g1.OwnerId, Equals, "999988887777")
424
c.Assert(g1.Name, Equals, "RangedPortsBySource")
425
c.Assert(g1.Id, Equals, "sg-76abc467")
426
c.Assert(g1.Description, Equals, "Group A")
427
c.Assert(g1.IPPerms, HasLen, 1)
429
g1ipp := g1.IPPerms[0]
430
c.Assert(g1ipp.Protocol, Equals, "tcp")
431
c.Assert(g1ipp.FromPort, Equals, 6000)
432
c.Assert(g1ipp.ToPort, Equals, 7000)
433
c.Assert(g1ipp.SourceIPs, IsNil)
436
func (s *S) TestDescribeSecurityGroupsExampleWithFilter(c *C) {
437
testServer.Response(200, nil, DescribeSecurityGroupsExample)
439
filter := ec2.NewFilter()
440
filter.Add("ip-permission.protocol", "tcp")
441
filter.Add("ip-permission.from-port", "22")
442
filter.Add("ip-permission.to-port", "22")
443
filter.Add("ip-permission.group-name", "app_server_group", "database_group")
445
_, err := s.ec2.SecurityGroups(nil, filter)
447
req := testServer.WaitRequest()
448
c.Assert(req.Form["Action"], DeepEquals, []string{"DescribeSecurityGroups"})
449
c.Assert(req.Form["Filter.1.Name"], DeepEquals, []string{"ip-permission.from-port"})
450
c.Assert(req.Form["Filter.1.Value.1"], DeepEquals, []string{"22"})
451
c.Assert(req.Form["Filter.2.Name"], DeepEquals, []string{"ip-permission.group-name"})
452
c.Assert(req.Form["Filter.2.Value.1"], DeepEquals, []string{"app_server_group"})
453
c.Assert(req.Form["Filter.2.Value.2"], DeepEquals, []string{"database_group"})
454
c.Assert(req.Form["Filter.3.Name"], DeepEquals, []string{"ip-permission.protocol"})
455
c.Assert(req.Form["Filter.3.Value.1"], DeepEquals, []string{"tcp"})
456
c.Assert(req.Form["Filter.4.Name"], DeepEquals, []string{"ip-permission.to-port"})
457
c.Assert(req.Form["Filter.4.Value.1"], DeepEquals, []string{"22"})
462
func (s *S) TestDescribeSecurityGroupsDumpWithGroup(c *C) {
463
testServer.Response(200, nil, DescribeSecurityGroupsDump)
465
resp, err := s.ec2.SecurityGroups(nil, nil)
467
req := testServer.WaitRequest()
468
c.Assert(req.Form["Action"], DeepEquals, []string{"DescribeSecurityGroups"})
470
c.Check(resp.Groups, HasLen, 1)
471
c.Check(resp.Groups[0].IPPerms, HasLen, 2)
473
ipp0 := resp.Groups[0].IPPerms[0]
474
c.Assert(ipp0.SourceIPs, IsNil)
475
c.Check(ipp0.Protocol, Equals, "icmp")
476
c.Assert(ipp0.SourceGroups, HasLen, 1)
477
c.Check(ipp0.SourceGroups[0].OwnerId, Equals, "12345")
478
c.Check(ipp0.SourceGroups[0].Name, Equals, "default")
479
c.Check(ipp0.SourceGroups[0].Id, Equals, "sg-67ad940e")
481
ipp1 := resp.Groups[0].IPPerms[1]
482
c.Check(ipp1.Protocol, Equals, "tcp")
483
c.Assert(ipp0.SourceIPs, IsNil)
484
c.Assert(ipp0.SourceGroups, HasLen, 1)
485
c.Check(ipp1.SourceGroups[0].Id, Equals, "sg-76abc467")
486
c.Check(ipp1.SourceGroups[0].OwnerId, Equals, "12345")
487
c.Check(ipp1.SourceGroups[0].Name, Equals, "other")
490
func (s *S) TestDeleteSecurityGroupExample(c *C) {
491
testServer.Response(200, nil, DeleteSecurityGroupExample)
493
resp, err := s.ec2.DeleteSecurityGroup(ec2.SecurityGroup{Name: "websrv"})
494
req := testServer.WaitRequest()
496
c.Assert(req.Form["Action"], DeepEquals, []string{"DeleteSecurityGroup"})
497
c.Assert(req.Form["GroupName"], DeepEquals, []string{"websrv"})
498
c.Assert(req.Form["GroupId"], IsNil)
500
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
503
func (s *S) TestDeleteSecurityGroupExampleWithId(c *C) {
504
testServer.Response(200, nil, DeleteSecurityGroupExample)
506
// ignore return and error - we're only want to check the parameter handling.
507
s.ec2.DeleteSecurityGroup(ec2.SecurityGroup{Id: "sg-67ad940e", Name: "ignored"})
508
req := testServer.WaitRequest()
510
c.Assert(req.Form["GroupName"], IsNil)
511
c.Assert(req.Form["GroupId"], DeepEquals, []string{"sg-67ad940e"})
514
func (s *S) TestAuthorizeSecurityGroupExample1(c *C) {
515
testServer.Response(200, nil, AuthorizeSecurityGroupIngressExample)
517
perms := []ec2.IPPerm{{
521
SourceIPs: []string{"205.192.0.0/16", "205.159.0.0/16"},
523
resp, err := s.ec2.AuthorizeSecurityGroup(ec2.SecurityGroup{Name: "websrv"}, perms)
525
req := testServer.WaitRequest()
527
c.Assert(req.Form["Action"], DeepEquals, []string{"AuthorizeSecurityGroupIngress"})
528
c.Assert(req.Form["GroupName"], DeepEquals, []string{"websrv"})
529
c.Assert(req.Form["IpPermissions.1.IpProtocol"], DeepEquals, []string{"tcp"})
530
c.Assert(req.Form["IpPermissions.1.FromPort"], DeepEquals, []string{"80"})
531
c.Assert(req.Form["IpPermissions.1.ToPort"], DeepEquals, []string{"80"})
532
c.Assert(req.Form["IpPermissions.1.IpRanges.1.CidrIp"], DeepEquals, []string{"205.192.0.0/16"})
533
c.Assert(req.Form["IpPermissions.1.IpRanges.2.CidrIp"], DeepEquals, []string{"205.159.0.0/16"})
536
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
539
func (s *S) TestAuthorizeSecurityGroupExample1WithId(c *C) {
540
testServer.Response(200, nil, AuthorizeSecurityGroupIngressExample)
542
perms := []ec2.IPPerm{{
546
SourceIPs: []string{"205.192.0.0/16", "205.159.0.0/16"},
548
// ignore return and error - we're only want to check the parameter handling.
549
s.ec2.AuthorizeSecurityGroup(ec2.SecurityGroup{Id: "sg-67ad940e", Name: "ignored"}, perms)
551
req := testServer.WaitRequest()
553
c.Assert(req.Form["GroupName"], IsNil)
554
c.Assert(req.Form["GroupId"], DeepEquals, []string{"sg-67ad940e"})
557
func (s *S) TestAuthorizeSecurityGroupExample2(c *C) {
558
testServer.Response(200, nil, AuthorizeSecurityGroupIngressExample)
560
perms := []ec2.IPPerm{{
564
SourceGroups: []ec2.UserSecurityGroup{
565
{OwnerId: "999988887777", Name: "OtherAccountGroup"},
569
resp, err := s.ec2.AuthorizeSecurityGroup(ec2.SecurityGroup{Name: "websrv"}, perms)
571
req := testServer.WaitRequest()
573
c.Assert(req.Form["Action"], DeepEquals, []string{"AuthorizeSecurityGroupIngress"})
574
c.Assert(req.Form["GroupName"], DeepEquals, []string{"websrv"})
575
c.Assert(req.Form["IpPermissions.1.IpProtocol"], DeepEquals, []string{"tcp"})
576
c.Assert(req.Form["IpPermissions.1.FromPort"], DeepEquals, []string{"80"})
577
c.Assert(req.Form["IpPermissions.1.ToPort"], DeepEquals, []string{"81"})
578
c.Assert(req.Form["IpPermissions.1.Groups.1.UserId"], DeepEquals, []string{"999988887777"})
579
c.Assert(req.Form["IpPermissions.1.Groups.1.GroupName"], DeepEquals, []string{"OtherAccountGroup"})
580
c.Assert(req.Form["IpPermissions.1.Groups.2.UserId"], IsNil)
581
c.Assert(req.Form["IpPermissions.1.Groups.2.GroupName"], IsNil)
582
c.Assert(req.Form["IpPermissions.1.Groups.2.GroupId"], DeepEquals, []string{"sg-67ad940e"})
585
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
588
func (s *S) TestRevokeSecurityGroupExample(c *C) {
589
// RevokeSecurityGroup is implemented by the same code as AuthorizeSecurityGroup
590
// so there's no need to duplicate all the tests.
591
testServer.Response(200, nil, RevokeSecurityGroupIngressExample)
593
resp, err := s.ec2.RevokeSecurityGroup(ec2.SecurityGroup{Name: "websrv"}, nil)
595
req := testServer.WaitRequest()
597
c.Assert(req.Form["Action"], DeepEquals, []string{"RevokeSecurityGroupIngress"})
598
c.Assert(req.Form["GroupName"], DeepEquals, []string{"websrv"})
600
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
603
func (s *S) TestCreateTags(c *C) {
604
testServer.Response(200, nil, CreateTagsExample)
606
resp, err := s.ec2.CreateTags([]string{"ami-1a2b3c4d", "i-7f4d3a2b"}, []ec2.Tag{{"webserver", ""}, {"stack", "Production"}})
608
req := testServer.WaitRequest()
609
c.Assert(req.Form["ResourceId.1"], DeepEquals, []string{"ami-1a2b3c4d"})
610
c.Assert(req.Form["ResourceId.2"], DeepEquals, []string{"i-7f4d3a2b"})
611
c.Assert(req.Form["Tag.1.Key"], DeepEquals, []string{"webserver"})
612
c.Assert(req.Form["Tag.1.Value"], DeepEquals, []string{""})
613
c.Assert(req.Form["Tag.2.Key"], DeepEquals, []string{"stack"})
614
c.Assert(req.Form["Tag.2.Value"], DeepEquals, []string{"Production"})
617
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
620
func (s *S) TestStartInstances(c *C) {
621
testServer.Response(200, nil, StartInstancesExample)
623
resp, err := s.ec2.StartInstances("i-10a64379")
624
req := testServer.WaitRequest()
626
c.Assert(req.Form["Action"], DeepEquals, []string{"StartInstances"})
627
c.Assert(req.Form["InstanceId.1"], DeepEquals, []string{"i-10a64379"})
630
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
632
s0 := resp.StateChanges[0]
633
c.Assert(s0.InstanceId, Equals, "i-10a64379")
634
c.Assert(s0.CurrentState.Code, Equals, 0)
635
c.Assert(s0.CurrentState.Name, Equals, "pending")
636
c.Assert(s0.PreviousState.Code, Equals, 80)
637
c.Assert(s0.PreviousState.Name, Equals, "stopped")
640
func (s *S) TestStopInstances(c *C) {
641
testServer.Response(200, nil, StopInstancesExample)
643
resp, err := s.ec2.StopInstances("i-10a64379")
644
req := testServer.WaitRequest()
646
c.Assert(req.Form["Action"], DeepEquals, []string{"StopInstances"})
647
c.Assert(req.Form["InstanceId.1"], DeepEquals, []string{"i-10a64379"})
650
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
652
s0 := resp.StateChanges[0]
653
c.Assert(s0.InstanceId, Equals, "i-10a64379")
654
c.Assert(s0.CurrentState.Code, Equals, 64)
655
c.Assert(s0.CurrentState.Name, Equals, "stopping")
656
c.Assert(s0.PreviousState.Code, Equals, 16)
657
c.Assert(s0.PreviousState.Name, Equals, "running")
660
func (s *S) TestRebootInstances(c *C) {
661
testServer.Response(200, nil, RebootInstancesExample)
663
resp, err := s.ec2.RebootInstances("i-10a64379")
664
req := testServer.WaitRequest()
666
c.Assert(req.Form["Action"], DeepEquals, []string{"RebootInstances"})
667
c.Assert(req.Form["InstanceId.1"], DeepEquals, []string{"i-10a64379"})
670
c.Assert(resp.RequestId, Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
673
func (s *S) TestSignatureWithEndpointPath(c *C) {
675
defer ec2.FakeTime(false)
677
testServer.Response(200, nil, RebootInstancesExample)
679
// https://bugs.launchpad.net/goamz/+bug/1022749
680
ec2 := ec2.New(s.ec2.Auth, aws.Region{EC2Endpoint: testServer.URL + "/services/Cloud"})
682
_, err := ec2.RebootInstances("i-10a64379")
685
req := testServer.WaitRequest()
686
c.Assert(req.Form["Signature"], DeepEquals, []string{"gdG/vEm+c6ehhhfkrJy3+wuVzw/rzKR42TYelMwti7M="})
added
removed
src/launchpad.net/goamz/ec2/ec2_test.go
