forked from goamz/goamz
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathec2_test.go
1134 lines (910 loc) · 48 KB
/
ec2_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
package ec2_test
import (
"github.com/goamz/goamz/aws"
"github.com/goamz/goamz/ec2"
"github.com/goamz/goamz/testutil"
"github.com/motain/gocheck"
"testing"
)
func Test(t *testing.T) {
gocheck.TestingT(t)
}
var _ = gocheck.Suite(&S{})
type S struct {
ec2 *ec2.EC2
}
var testServer = testutil.NewHTTPServer()
func (s *S) SetUpSuite(c *gocheck.C) {
testServer.Start()
auth := aws.Auth{AccessKey: "abc", SecretKey: "123"}
s.ec2 = ec2.NewWithClient(
auth,
aws.Region{EC2Endpoint: testServer.URL},
testutil.DefaultClient,
)
}
func (s *S) TearDownTest(c *gocheck.C) {
testServer.Flush()
}
func (s *S) TestRunInstancesErrorDump(c *gocheck.C) {
testServer.Response(400, nil, ErrorDump)
options := ec2.RunInstancesOptions{
ImageId: "ami-a6f504cf", // Ubuntu Maverick, i386, instance store
InstanceType: "t1.micro", // Doesn't work with micro, results in 400.
}
msg := `AMIs with an instance-store root device are not supported for the instance type 't1\.micro'\.`
resp, err := s.ec2.RunInstances(&options)
testServer.WaitRequest()
c.Assert(resp, gocheck.IsNil)
c.Assert(err, gocheck.ErrorMatches, msg+` \(UnsupportedOperation\)`)
ec2err, ok := err.(*ec2.Error)
c.Assert(ok, gocheck.Equals, true)
c.Assert(ec2err.StatusCode, gocheck.Equals, 400)
c.Assert(ec2err.Code, gocheck.Equals, "UnsupportedOperation")
c.Assert(ec2err.Message, gocheck.Matches, msg)
c.Assert(ec2err.RequestId, gocheck.Equals, "0503f4e9-bbd6-483c-b54f-c4ae9f3b30f4")
}
func (s *S) TestRunInstancesErrorWithoutXML(c *gocheck.C) {
testServer.Responses(5, 500, nil, "")
options := ec2.RunInstancesOptions{ImageId: "image-id"}
resp, err := s.ec2.RunInstances(&options)
testServer.WaitRequest()
c.Assert(resp, gocheck.IsNil)
c.Assert(err, gocheck.ErrorMatches, "500 Internal Server Error")
ec2err, ok := err.(*ec2.Error)
c.Assert(ok, gocheck.Equals, true)
c.Assert(ec2err.StatusCode, gocheck.Equals, 500)
c.Assert(ec2err.Code, gocheck.Equals, "")
c.Assert(ec2err.Message, gocheck.Equals, "500 Internal Server Error")
c.Assert(ec2err.RequestId, gocheck.Equals, "")
}
func (s *S) TestRunInstancesExample(c *gocheck.C) {
testServer.Response(200, nil, RunInstancesExample)
options := ec2.RunInstancesOptions{
KeyName: "my-keys",
ImageId: "image-id",
InstanceType: "inst-type",
SecurityGroups: []ec2.SecurityGroup{{Name: "g1"}, {Id: "g2"}, {Name: "g3"}, {Id: "g4"}},
UserData: []byte("1234"),
KernelId: "kernel-id",
RamdiskId: "ramdisk-id",
AvailabilityZone: "zone",
PlacementGroupName: "group",
Monitoring: true,
SubnetId: "subnet-id",
DisableAPITermination: true,
ShutdownBehavior: "terminate",
PrivateIPAddress: "10.0.0.25",
BlockDevices: []ec2.BlockDeviceMapping{
{DeviceName: "/dev/sdb", VirtualName: "ephemeral0"},
{DeviceName: "/dev/sdc", SnapshotId: "snap-a08912c9", DeleteOnTermination: true},
},
}
resp, err := s.ec2.RunInstances(&options)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"RunInstances"})
c.Assert(req.Form["ImageId"], gocheck.DeepEquals, []string{"image-id"})
c.Assert(req.Form["MinCount"], gocheck.DeepEquals, []string{"1"})
c.Assert(req.Form["MaxCount"], gocheck.DeepEquals, []string{"1"})
c.Assert(req.Form["KeyName"], gocheck.DeepEquals, []string{"my-keys"})
c.Assert(req.Form["InstanceType"], gocheck.DeepEquals, []string{"inst-type"})
c.Assert(req.Form["SecurityGroup.1"], gocheck.DeepEquals, []string{"g1"})
c.Assert(req.Form["SecurityGroup.2"], gocheck.DeepEquals, []string{"g3"})
c.Assert(req.Form["SecurityGroupId.1"], gocheck.DeepEquals, []string{"g2"})
c.Assert(req.Form["SecurityGroupId.2"], gocheck.DeepEquals, []string{"g4"})
c.Assert(req.Form["UserData"], gocheck.DeepEquals, []string{"MTIzNA=="})
c.Assert(req.Form["KernelId"], gocheck.DeepEquals, []string{"kernel-id"})
c.Assert(req.Form["RamdiskId"], gocheck.DeepEquals, []string{"ramdisk-id"})
c.Assert(req.Form["Placement.AvailabilityZone"], gocheck.DeepEquals, []string{"zone"})
c.Assert(req.Form["Placement.GroupName"], gocheck.DeepEquals, []string{"group"})
c.Assert(req.Form["Monitoring.Enabled"], gocheck.DeepEquals, []string{"true"})
c.Assert(req.Form["SubnetId"], gocheck.DeepEquals, []string{"subnet-id"})
c.Assert(req.Form["DisableApiTermination"], gocheck.DeepEquals, []string{"true"})
c.Assert(req.Form["InstanceInitiatedShutdownBehavior"], gocheck.DeepEquals, []string{"terminate"})
c.Assert(req.Form["PrivateIpAddress"], gocheck.DeepEquals, []string{"10.0.0.25"})
c.Assert(req.Form["BlockDeviceMapping.1.DeviceName"], gocheck.DeepEquals, []string{"/dev/sdb"})
c.Assert(req.Form["BlockDeviceMapping.1.VirtualName"], gocheck.DeepEquals, []string{"ephemeral0"})
c.Assert(req.Form["BlockDeviceMapping.2.Ebs.SnapshotId"], gocheck.DeepEquals, []string{"snap-a08912c9"})
c.Assert(req.Form["BlockDeviceMapping.2.Ebs.DeleteOnTermination"], gocheck.DeepEquals, []string{"true"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
c.Assert(resp.ReservationId, gocheck.Equals, "r-47a5402e")
c.Assert(resp.OwnerId, gocheck.Equals, "999988887777")
c.Assert(resp.SecurityGroups, gocheck.DeepEquals, []ec2.SecurityGroup{{Name: "default", Id: "sg-67ad940e"}})
c.Assert(resp.Instances, gocheck.HasLen, 3)
i0 := resp.Instances[0]
c.Assert(i0.InstanceId, gocheck.Equals, "i-2ba64342")
c.Assert(i0.InstanceType, gocheck.Equals, "m1.small")
c.Assert(i0.ImageId, gocheck.Equals, "ami-60a54009")
c.Assert(i0.Monitoring, gocheck.Equals, "enabled")
c.Assert(i0.KeyName, gocheck.Equals, "example-key-name")
c.Assert(i0.AMILaunchIndex, gocheck.Equals, 0)
c.Assert(i0.VirtualizationType, gocheck.Equals, "paravirtual")
c.Assert(i0.Hypervisor, gocheck.Equals, "xen")
i1 := resp.Instances[1]
c.Assert(i1.InstanceId, gocheck.Equals, "i-2bc64242")
c.Assert(i1.InstanceType, gocheck.Equals, "m1.small")
c.Assert(i1.ImageId, gocheck.Equals, "ami-60a54009")
c.Assert(i1.Monitoring, gocheck.Equals, "enabled")
c.Assert(i1.KeyName, gocheck.Equals, "example-key-name")
c.Assert(i1.AMILaunchIndex, gocheck.Equals, 1)
c.Assert(i1.VirtualizationType, gocheck.Equals, "paravirtual")
c.Assert(i1.Hypervisor, gocheck.Equals, "xen")
i2 := resp.Instances[2]
c.Assert(i2.InstanceId, gocheck.Equals, "i-2be64332")
c.Assert(i2.InstanceType, gocheck.Equals, "m1.small")
c.Assert(i2.ImageId, gocheck.Equals, "ami-60a54009")
c.Assert(i2.Monitoring, gocheck.Equals, "enabled")
c.Assert(i2.KeyName, gocheck.Equals, "example-key-name")
c.Assert(i2.AMILaunchIndex, gocheck.Equals, 2)
c.Assert(i2.VirtualizationType, gocheck.Equals, "paravirtual")
c.Assert(i2.Hypervisor, gocheck.Equals, "xen")
}
func (s *S) TestTerminateInstancesExample(c *gocheck.C) {
testServer.Response(200, nil, TerminateInstancesExample)
resp, err := s.ec2.TerminateInstances([]string{"i-1", "i-2"})
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"TerminateInstances"})
c.Assert(req.Form["InstanceId.1"], gocheck.DeepEquals, []string{"i-1"})
c.Assert(req.Form["InstanceId.2"], gocheck.DeepEquals, []string{"i-2"})
c.Assert(req.Form["UserData"], gocheck.IsNil)
c.Assert(req.Form["KernelId"], gocheck.IsNil)
c.Assert(req.Form["RamdiskId"], gocheck.IsNil)
c.Assert(req.Form["Placement.AvailabilityZone"], gocheck.IsNil)
c.Assert(req.Form["Placement.GroupName"], gocheck.IsNil)
c.Assert(req.Form["Monitoring.Enabled"], gocheck.IsNil)
c.Assert(req.Form["SubnetId"], gocheck.IsNil)
c.Assert(req.Form["DisableApiTermination"], gocheck.IsNil)
c.Assert(req.Form["InstanceInitiatedShutdownBehavior"], gocheck.IsNil)
c.Assert(req.Form["PrivateIpAddress"], gocheck.IsNil)
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
c.Assert(resp.StateChanges, gocheck.HasLen, 1)
c.Assert(resp.StateChanges[0].InstanceId, gocheck.Equals, "i-3ea74257")
c.Assert(resp.StateChanges[0].CurrentState.Code, gocheck.Equals, 32)
c.Assert(resp.StateChanges[0].CurrentState.Name, gocheck.Equals, "shutting-down")
c.Assert(resp.StateChanges[0].PreviousState.Code, gocheck.Equals, 16)
c.Assert(resp.StateChanges[0].PreviousState.Name, gocheck.Equals, "running")
}
func (s *S) TestDescribeInstancesExample1(c *gocheck.C) {
testServer.Response(200, nil, DescribeInstancesExample1)
filter := ec2.NewFilter()
filter.Add("key1", "value1")
filter.Add("key2", "value2", "value3")
resp, err := s.ec2.DescribeInstances([]string{"i-1", "i-2"}, nil)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DescribeInstances"})
c.Assert(req.Form["InstanceId.1"], gocheck.DeepEquals, []string{"i-1"})
c.Assert(req.Form["InstanceId.2"], gocheck.DeepEquals, []string{"i-2"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "98e3c9a4-848c-4d6d-8e8a-b1bdEXAMPLE")
c.Assert(resp.Reservations, gocheck.HasLen, 2)
r0 := resp.Reservations[0]
c.Assert(r0.ReservationId, gocheck.Equals, "r-b27e30d9")
c.Assert(r0.OwnerId, gocheck.Equals, "999988887777")
c.Assert(r0.RequesterId, gocheck.Equals, "854251627541")
c.Assert(r0.SecurityGroups, gocheck.DeepEquals, []ec2.SecurityGroup{{Name: "default", Id: "sg-67ad940e"}})
c.Assert(r0.Instances, gocheck.HasLen, 1)
r0i := r0.Instances[0]
c.Assert(r0i.InstanceId, gocheck.Equals, "i-c5cd56af")
c.Assert(r0i.PrivateDNSName, gocheck.Equals, "domU-12-31-39-10-56-34.compute-1.internal")
c.Assert(r0i.DNSName, gocheck.Equals, "ec2-174-129-165-232.compute-1.amazonaws.com")
c.Assert(r0i.AvailabilityZone, gocheck.Equals, "us-east-1b")
c.Assert(r0i.IPAddress, gocheck.Equals, "174.129.165.232")
c.Assert(r0i.PrivateIPAddress, gocheck.Equals, "10.198.85.190")
}
func (s *S) TestDescribeInstancesExample2(c *gocheck.C) {
testServer.Response(200, nil, DescribeInstancesExample2)
filter := ec2.NewFilter()
filter.Add("key1", "value1")
filter.Add("key2", "value2", "value3")
resp, err := s.ec2.DescribeInstances([]string{"i-1", "i-2"}, filter)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DescribeInstances"})
c.Assert(req.Form["InstanceId.1"], gocheck.DeepEquals, []string{"i-1"})
c.Assert(req.Form["InstanceId.2"], gocheck.DeepEquals, []string{"i-2"})
c.Assert(req.Form["Filter.1.Name"], gocheck.DeepEquals, []string{"key1"})
c.Assert(req.Form["Filter.1.Value.1"], gocheck.DeepEquals, []string{"value1"})
c.Assert(req.Form["Filter.1.Value.2"], gocheck.IsNil)
c.Assert(req.Form["Filter.2.Name"], gocheck.DeepEquals, []string{"key2"})
c.Assert(req.Form["Filter.2.Value.1"], gocheck.DeepEquals, []string{"value2"})
c.Assert(req.Form["Filter.2.Value.2"], gocheck.DeepEquals, []string{"value3"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
c.Assert(resp.Reservations, gocheck.HasLen, 1)
r0 := resp.Reservations[0]
r0i := r0.Instances[0]
c.Assert(r0i.State.Code, gocheck.Equals, 16)
c.Assert(r0i.State.Name, gocheck.Equals, "running")
r0t0 := r0i.Tags[0]
r0t1 := r0i.Tags[1]
c.Assert(r0t0.Key, gocheck.Equals, "webserver")
c.Assert(r0t0.Value, gocheck.Equals, "")
c.Assert(r0t1.Key, gocheck.Equals, "stack")
c.Assert(r0t1.Value, gocheck.Equals, "Production")
}
func (s *S) TestDescribeInstanceStatusExample(c *gocheck.C) {
testServer.Response(200, nil, DescribeInstanceStatusExample)
resp, err := s.ec2.DescribeInstanceStatus(&ec2.DescribeInstanceStatusOptions{}, nil)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DescribeInstanceStatus"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
c.Assert(resp.InstanceStatusSet, gocheck.HasLen, 1)
c.Assert(resp.NextToken, gocheck.Equals, "exampleToken")
i0 := resp.InstanceStatusSet[0]
c.Assert(i0.InstanceId, gocheck.Equals, "i-c7cd56ad")
c.Assert(i0.AvailabilityZone, gocheck.Equals, "us-east-1b")
c.Assert(i0.Events, gocheck.HasLen, 1)
e0 := i0.Events[0]
c.Assert(e0.Code, gocheck.Equals, "instance-reboot")
c.Assert(e0.Description, gocheck.Equals, "example description")
c.Assert(e0.NotBefore, gocheck.Equals, "2010-08-17T01:15:18.000Z")
c.Assert(e0.NotAfter, gocheck.Equals, "2010-08-17T01:15:18.000Z")
c.Assert(i0.InstanceState.Code, gocheck.Equals, 16)
c.Assert(i0.InstanceState.Name, gocheck.Equals, "running")
c.Assert(i0.SystemStatus.Status, gocheck.Equals, "ok")
c.Assert(i0.SystemStatus.Details.Name, gocheck.Equals, "reachability")
c.Assert(i0.SystemStatus.Details.Status, gocheck.Equals, "passed")
c.Assert(i0.SystemStatus.Details.ImpairedSince, gocheck.Equals, "2010-08-17T01:15:18.000Z")
c.Assert(i0.InstanceStatus.Status, gocheck.Equals, "ok")
c.Assert(i0.InstanceStatus.Details.Name, gocheck.Equals, "reachability")
c.Assert(i0.InstanceStatus.Details.Status, gocheck.Equals, "passed")
c.Assert(i0.InstanceStatus.Details.ImpairedSince, gocheck.Equals, "2010-08-17T01:15:18.000Z")
}
func (s *S) TestDescribeAddressesPublicIPExample(c *gocheck.C) {
testServer.Response(200, nil, DescribeAddressesExample)
filter := ec2.NewFilter()
filter.Add("key1", "value1")
filter.Add("key2", "value2", "value3")
resp, err := s.ec2.DescribeAddresses([]string{"192.0.2.1", "198.51.100.2", "203.0.113.41"}, []string{}, nil)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DescribeAddresses"})
c.Assert(req.Form["PublicIp.1"], gocheck.DeepEquals, []string{"192.0.2.1"})
c.Assert(req.Form["PublicIp.2"], gocheck.DeepEquals, []string{"198.51.100.2"})
c.Assert(req.Form["PublicIp.3"], gocheck.DeepEquals, []string{"203.0.113.41"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
c.Assert(resp.Addresses, gocheck.HasLen, 3)
r0 := resp.Addresses[0]
c.Assert(r0.PublicIp, gocheck.Equals, "192.0.2.1")
c.Assert(r0.Domain, gocheck.Equals, "standard")
c.Assert(r0.InstanceId, gocheck.Equals, "i-f15ebb98")
r0i := resp.Addresses[1]
c.Assert(r0i.PublicIp, gocheck.Equals, "198.51.100.2")
c.Assert(r0i.Domain, gocheck.Equals, "standard")
c.Assert(r0i.InstanceId, gocheck.Equals, "")
r0ii := resp.Addresses[2]
c.Assert(r0ii.PublicIp, gocheck.Equals, "203.0.113.41")
c.Assert(r0ii.Domain, gocheck.Equals, "vpc")
c.Assert(r0ii.InstanceId, gocheck.Equals, "i-64600030")
c.Assert(r0ii.AssociationId, gocheck.Equals, "eipassoc-f0229899")
c.Assert(r0ii.AllocationId, gocheck.Equals, "eipalloc-08229861")
c.Assert(r0ii.NetworkInterfaceOwnerId, gocheck.Equals, "053230519467")
c.Assert(r0ii.NetworkInterfaceId, gocheck.Equals, "eni-ef229886")
c.Assert(r0ii.PrivateIpAddress, gocheck.Equals, "10.0.0.228")
}
func (s *S) TestDescribeAddressesAllocationIDExample(c *gocheck.C) {
testServer.Response(200, nil, DescribeAddressesAllocationIdExample)
filter := ec2.NewFilter()
filter.Add("key1", "value1")
filter.Add("key2", "value2", "value3")
resp, err := s.ec2.DescribeAddresses([]string{}, []string{"eipalloc-08229861", "eipalloc-08364752"}, nil)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DescribeAddresses"})
c.Assert(req.Form["AllocationId.1"], gocheck.DeepEquals, []string{"eipalloc-08229861"})
c.Assert(req.Form["AllocationId.2"], gocheck.DeepEquals, []string{"eipalloc-08364752"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
c.Assert(resp.Addresses, gocheck.HasLen, 2)
r0 := resp.Addresses[0]
c.Assert(r0.PublicIp, gocheck.Equals, "203.0.113.41")
c.Assert(r0.AllocationId, gocheck.Equals, "eipalloc-08229861")
c.Assert(r0.Domain, gocheck.Equals, "vpc")
c.Assert(r0.InstanceId, gocheck.Equals, "i-64600030")
c.Assert(r0.AssociationId, gocheck.Equals, "eipassoc-f0229899")
c.Assert(r0.NetworkInterfaceId, gocheck.Equals, "eni-ef229886")
c.Assert(r0.NetworkInterfaceOwnerId, gocheck.Equals, "053230519467")
c.Assert(r0.PrivateIpAddress, gocheck.Equals, "10.0.0.228")
r1 := resp.Addresses[1]
c.Assert(r1.PublicIp, gocheck.Equals, "146.54.2.230")
c.Assert(r1.AllocationId, gocheck.Equals, "eipalloc-08364752")
c.Assert(r1.Domain, gocheck.Equals, "vpc")
c.Assert(r1.InstanceId, gocheck.Equals, "i-64693456")
c.Assert(r1.AssociationId, gocheck.Equals, "eipassoc-f0348693")
c.Assert(r1.NetworkInterfaceId, gocheck.Equals, "eni-da764039")
c.Assert(r1.NetworkInterfaceOwnerId, gocheck.Equals, "053230519467")
c.Assert(r1.PrivateIpAddress, gocheck.Equals, "10.0.0.102")
}
func (s *S) TestCreateImageExample(c *gocheck.C) {
testServer.Response(200, nil, CreateImageExample)
options := &ec2.CreateImage{
InstanceId: "i-123456",
Name: "foo",
Description: "Test CreateImage",
NoReboot: true,
BlockDevices: []ec2.BlockDeviceMapping{
{DeviceName: "/dev/sdb", VirtualName: "ephemeral0"},
{DeviceName: "/dev/sdc", SnapshotId: "snap-a08912c9", DeleteOnTermination: true},
},
}
resp, err := s.ec2.CreateImage(options)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"CreateImage"})
c.Assert(req.Form["InstanceId"], gocheck.DeepEquals, []string{options.InstanceId})
c.Assert(req.Form["Name"], gocheck.DeepEquals, []string{options.Name})
c.Assert(req.Form["Description"], gocheck.DeepEquals, []string{options.Description})
c.Assert(req.Form["NoReboot"], gocheck.DeepEquals, []string{"true"})
c.Assert(req.Form["BlockDeviceMapping.1.DeviceName"], gocheck.DeepEquals, []string{"/dev/sdb"})
c.Assert(req.Form["BlockDeviceMapping.1.VirtualName"], gocheck.DeepEquals, []string{"ephemeral0"})
c.Assert(req.Form["BlockDeviceMapping.2.DeviceName"], gocheck.DeepEquals, []string{"/dev/sdc"})
c.Assert(req.Form["BlockDeviceMapping.2.Ebs.SnapshotId"], gocheck.DeepEquals, []string{"snap-a08912c9"})
c.Assert(req.Form["BlockDeviceMapping.2.Ebs.DeleteOnTermination"], gocheck.DeepEquals, []string{"true"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
c.Assert(resp.ImageId, gocheck.Equals, "ami-4fa54026")
}
func (s *S) TestDescribeImagesExample(c *gocheck.C) {
testServer.Response(200, nil, DescribeImagesExample)
filter := ec2.NewFilter()
filter.Add("key1", "value1")
filter.Add("key2", "value2", "value3")
resp, err := s.ec2.Images([]string{"ami-1", "ami-2"}, filter)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DescribeImages"})
c.Assert(req.Form["ImageId.1"], gocheck.DeepEquals, []string{"ami-1"})
c.Assert(req.Form["ImageId.2"], gocheck.DeepEquals, []string{"ami-2"})
c.Assert(req.Form["Filter.1.Name"], gocheck.DeepEquals, []string{"key1"})
c.Assert(req.Form["Filter.1.Value.1"], gocheck.DeepEquals, []string{"value1"})
c.Assert(req.Form["Filter.1.Value.2"], gocheck.IsNil)
c.Assert(req.Form["Filter.2.Name"], gocheck.DeepEquals, []string{"key2"})
c.Assert(req.Form["Filter.2.Value.1"], gocheck.DeepEquals, []string{"value2"})
c.Assert(req.Form["Filter.2.Value.2"], gocheck.DeepEquals, []string{"value3"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "4a4a27a2-2e7c-475d-b35b-ca822EXAMPLE")
c.Assert(resp.Images, gocheck.HasLen, 1)
i0 := resp.Images[0]
c.Assert(i0.Id, gocheck.Equals, "ami-a2469acf")
c.Assert(i0.Type, gocheck.Equals, "machine")
c.Assert(i0.Name, gocheck.Equals, "example-marketplace-amzn-ami.1")
c.Assert(i0.Description, gocheck.Equals, "Amazon Linux AMI i386 EBS")
c.Assert(i0.Location, gocheck.Equals, "aws-marketplace/example-marketplace-amzn-ami.1")
c.Assert(i0.State, gocheck.Equals, "available")
c.Assert(i0.Public, gocheck.Equals, true)
c.Assert(i0.OwnerId, gocheck.Equals, "123456789999")
c.Assert(i0.OwnerAlias, gocheck.Equals, "aws-marketplace")
c.Assert(i0.Architecture, gocheck.Equals, "i386")
c.Assert(i0.KernelId, gocheck.Equals, "aki-805ea7e9")
c.Assert(i0.RootDeviceType, gocheck.Equals, "ebs")
c.Assert(i0.RootDeviceName, gocheck.Equals, "/dev/sda1")
c.Assert(i0.VirtualizationType, gocheck.Equals, "paravirtual")
c.Assert(i0.Hypervisor, gocheck.Equals, "xen")
c.Assert(i0.Tags, gocheck.HasLen, 1)
c.Assert(i0.Tags[0].Key, gocheck.Equals, "Purpose")
c.Assert(i0.Tags[0].Value, gocheck.Equals, "EXAMPLE")
c.Assert(i0.BlockDevices, gocheck.HasLen, 1)
c.Assert(i0.BlockDevices[0].DeviceName, gocheck.Equals, "/dev/sda1")
c.Assert(i0.BlockDevices[0].SnapshotId, gocheck.Equals, "snap-787e9403")
c.Assert(i0.BlockDevices[0].VolumeSize, gocheck.Equals, int64(8))
c.Assert(i0.BlockDevices[0].DeleteOnTermination, gocheck.Equals, true)
testServer.Response(200, nil, DescribeImagesExample)
resp2, err := s.ec2.ImagesByOwners([]string{"ami-1", "ami-2"}, []string{"123456789999", "id2"}, filter)
req2 := testServer.WaitRequest()
c.Assert(req2.Form["Action"], gocheck.DeepEquals, []string{"DescribeImages"})
c.Assert(req2.Form["ImageId.1"], gocheck.DeepEquals, []string{"ami-1"})
c.Assert(req2.Form["ImageId.2"], gocheck.DeepEquals, []string{"ami-2"})
c.Assert(req2.Form["Owner.1"], gocheck.DeepEquals, []string{"123456789999"})
c.Assert(req2.Form["Owner.2"], gocheck.DeepEquals, []string{"id2"})
c.Assert(req2.Form["Filter.1.Name"], gocheck.DeepEquals, []string{"key1"})
c.Assert(req2.Form["Filter.1.Value.1"], gocheck.DeepEquals, []string{"value1"})
c.Assert(req2.Form["Filter.1.Value.2"], gocheck.IsNil)
c.Assert(req2.Form["Filter.2.Name"], gocheck.DeepEquals, []string{"key2"})
c.Assert(req2.Form["Filter.2.Value.1"], gocheck.DeepEquals, []string{"value2"})
c.Assert(req2.Form["Filter.2.Value.2"], gocheck.DeepEquals, []string{"value3"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp2.RequestId, gocheck.Equals, "4a4a27a2-2e7c-475d-b35b-ca822EXAMPLE")
c.Assert(resp2.Images, gocheck.HasLen, 1)
i1 := resp2.Images[0]
c.Assert(i1.Id, gocheck.Equals, "ami-a2469acf")
c.Assert(i1.Type, gocheck.Equals, "machine")
c.Assert(i1.Name, gocheck.Equals, "example-marketplace-amzn-ami.1")
c.Assert(i1.Description, gocheck.Equals, "Amazon Linux AMI i386 EBS")
c.Assert(i1.Location, gocheck.Equals, "aws-marketplace/example-marketplace-amzn-ami.1")
c.Assert(i1.State, gocheck.Equals, "available")
c.Assert(i1.Public, gocheck.Equals, true)
c.Assert(i1.OwnerId, gocheck.Equals, "123456789999")
c.Assert(i1.OwnerAlias, gocheck.Equals, "aws-marketplace")
c.Assert(i1.Architecture, gocheck.Equals, "i386")
c.Assert(i1.KernelId, gocheck.Equals, "aki-805ea7e9")
c.Assert(i1.RootDeviceType, gocheck.Equals, "ebs")
c.Assert(i1.RootDeviceName, gocheck.Equals, "/dev/sda1")
c.Assert(i1.VirtualizationType, gocheck.Equals, "paravirtual")
c.Assert(i1.Hypervisor, gocheck.Equals, "xen")
c.Assert(i1.BlockDevices, gocheck.HasLen, 1)
c.Assert(i1.BlockDevices[0].DeviceName, gocheck.Equals, "/dev/sda1")
c.Assert(i1.BlockDevices[0].SnapshotId, gocheck.Equals, "snap-787e9403")
c.Assert(i1.BlockDevices[0].VolumeSize, gocheck.Equals, int64(8))
c.Assert(i1.BlockDevices[0].DeleteOnTermination, gocheck.Equals, true)
}
func (s *S) TestImageAttributeExample(c *gocheck.C) {
testServer.Response(200, nil, ImageAttributeExample)
resp, err := s.ec2.ImageAttribute("ami-61a54008", "launchPermission")
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DescribeImageAttribute"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
c.Assert(resp.ImageId, gocheck.Equals, "ami-61a54008")
c.Assert(resp.Group, gocheck.Equals, "all")
c.Assert(resp.UserIds[0], gocheck.Equals, "495219933132")
}
func (s *S) TestCreateSnapshotExample(c *gocheck.C) {
testServer.Response(200, nil, CreateSnapshotExample)
resp, err := s.ec2.CreateSnapshot("vol-4d826724", "Daily Backup")
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"CreateSnapshot"})
c.Assert(req.Form["VolumeId"], gocheck.DeepEquals, []string{"vol-4d826724"})
c.Assert(req.Form["Description"], gocheck.DeepEquals, []string{"Daily Backup"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
c.Assert(resp.Snapshot.Id, gocheck.Equals, "snap-78a54011")
c.Assert(resp.Snapshot.VolumeId, gocheck.Equals, "vol-4d826724")
c.Assert(resp.Snapshot.Status, gocheck.Equals, "pending")
c.Assert(resp.Snapshot.StartTime, gocheck.Equals, "2008-05-07T12:51:50.000Z")
c.Assert(resp.Snapshot.Progress, gocheck.Equals, "60%")
c.Assert(resp.Snapshot.OwnerId, gocheck.Equals, "111122223333")
c.Assert(resp.Snapshot.VolumeSize, gocheck.Equals, "10")
c.Assert(resp.Snapshot.Description, gocheck.Equals, "Daily Backup")
}
func (s *S) TestDeleteSnapshotsExample(c *gocheck.C) {
testServer.Response(200, nil, DeleteSnapshotExample)
resp, err := s.ec2.DeleteSnapshots([]string{"snap-78a54011"})
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DeleteSnapshot"})
c.Assert(req.Form["SnapshotId.1"], gocheck.DeepEquals, []string{"snap-78a54011"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
}
func (s *S) TestDescribeSnapshotsExample(c *gocheck.C) {
testServer.Response(200, nil, DescribeSnapshotsExample)
filter := ec2.NewFilter()
filter.Add("key1", "value1")
filter.Add("key2", "value2", "value3")
resp, err := s.ec2.Snapshots([]string{"snap-1", "snap-2"}, filter)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DescribeSnapshots"})
c.Assert(req.Form["SnapshotId.1"], gocheck.DeepEquals, []string{"snap-1"})
c.Assert(req.Form["SnapshotId.2"], gocheck.DeepEquals, []string{"snap-2"})
c.Assert(req.Form["Filter.1.Name"], gocheck.DeepEquals, []string{"key1"})
c.Assert(req.Form["Filter.1.Value.1"], gocheck.DeepEquals, []string{"value1"})
c.Assert(req.Form["Filter.1.Value.2"], gocheck.IsNil)
c.Assert(req.Form["Filter.2.Name"], gocheck.DeepEquals, []string{"key2"})
c.Assert(req.Form["Filter.2.Value.1"], gocheck.DeepEquals, []string{"value2"})
c.Assert(req.Form["Filter.2.Value.2"], gocheck.DeepEquals, []string{"value3"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
c.Assert(resp.Snapshots, gocheck.HasLen, 1)
s0 := resp.Snapshots[0]
c.Assert(s0.Id, gocheck.Equals, "snap-1a2b3c4d")
c.Assert(s0.VolumeId, gocheck.Equals, "vol-8875daef")
c.Assert(s0.VolumeSize, gocheck.Equals, "15")
c.Assert(s0.Status, gocheck.Equals, "pending")
c.Assert(s0.StartTime, gocheck.Equals, "2010-07-29T04:12:01.000Z")
c.Assert(s0.Progress, gocheck.Equals, "30%")
c.Assert(s0.OwnerId, gocheck.Equals, "111122223333")
c.Assert(s0.Description, gocheck.Equals, "Daily Backup")
c.Assert(s0.Tags, gocheck.HasLen, 1)
c.Assert(s0.Tags[0].Key, gocheck.Equals, "Purpose")
c.Assert(s0.Tags[0].Value, gocheck.Equals, "demo_db_14_backup")
}
func (s *S) TestModifyImageAttributeExample(c *gocheck.C) {
testServer.Response(200, nil, ModifyImageAttributeExample)
options := ec2.ModifyImageAttribute{
Description: "Test Description",
}
resp, err := s.ec2.ModifyImageAttribute("ami-4fa54026", &options)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"ModifyImageAttribute"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
}
func (s *S) TestModifyImageAttributeExample_complex(c *gocheck.C) {
testServer.Response(200, nil, ModifyImageAttributeExample)
options := ec2.ModifyImageAttribute{
AddUsers: []string{"u1", "u2"},
RemoveUsers: []string{"u3"},
AddGroups: []string{"g1", "g3"},
RemoveGroups: []string{"g2"},
Description: "Test Description",
}
resp, err := s.ec2.ModifyImageAttribute("ami-4fa54026", &options)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"ModifyImageAttribute"})
c.Assert(req.Form["LaunchPermission.Add.1.UserId"], gocheck.DeepEquals, []string{"u1"})
c.Assert(req.Form["LaunchPermission.Add.2.UserId"], gocheck.DeepEquals, []string{"u2"})
c.Assert(req.Form["LaunchPermission.Remove.1.UserId"], gocheck.DeepEquals, []string{"u3"})
c.Assert(req.Form["LaunchPermission.Add.1.Group"], gocheck.DeepEquals, []string{"g1"})
c.Assert(req.Form["LaunchPermission.Add.2.Group"], gocheck.DeepEquals, []string{"g3"})
c.Assert(req.Form["LaunchPermission.Remove.1.Group"], gocheck.DeepEquals, []string{"g2"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
}
func (s *S) TestCopyImageExample(c *gocheck.C) {
testServer.Response(200, nil, CopyImageExample)
options := ec2.CopyImage{
SourceRegion: "us-west-2",
SourceImageId: "ami-1a2b3c4d",
Description: "Test Description",
}
resp, err := s.ec2.CopyImage(&options)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"CopyImage"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "60bc441d-fa2c-494d-b155-5d6a3EXAMPLE")
}
func (s *S) TestCreateKeyPairExample(c *gocheck.C) {
testServer.Response(200, nil, CreateKeyPairExample)
resp, err := s.ec2.CreateKeyPair("foo")
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"CreateKeyPair"})
c.Assert(req.Form["KeyName"], gocheck.DeepEquals, []string{"foo"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
c.Assert(resp.KeyName, gocheck.Equals, "foo")
c.Assert(resp.KeyFingerprint, gocheck.Equals, "00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00")
}
func (s *S) TestDeleteKeyPairExample(c *gocheck.C) {
testServer.Response(200, nil, DeleteKeyPairExample)
resp, err := s.ec2.DeleteKeyPair("foo")
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DeleteKeyPair"})
c.Assert(req.Form["KeyName"], gocheck.DeepEquals, []string{"foo"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
}
func (s *S) TestCreateSecurityGroupExample(c *gocheck.C) {
testServer.Response(200, nil, CreateSecurityGroupExample)
resp, err := s.ec2.CreateSecurityGroup(ec2.SecurityGroup{Name: "websrv", Description: "Web Servers"})
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"CreateSecurityGroup"})
c.Assert(req.Form["GroupName"], gocheck.DeepEquals, []string{"websrv"})
c.Assert(req.Form["GroupDescription"], gocheck.DeepEquals, []string{"Web Servers"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
c.Assert(resp.Name, gocheck.Equals, "websrv")
c.Assert(resp.Id, gocheck.Equals, "sg-67ad940e")
}
func (s *S) TestDescribeSecurityGroupsExample(c *gocheck.C) {
testServer.Response(200, nil, DescribeSecurityGroupsExample)
resp, err := s.ec2.SecurityGroups([]ec2.SecurityGroup{{Name: "WebServers"}, {Name: "RangedPortsBySource"}}, nil)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DescribeSecurityGroups"})
c.Assert(req.Form["GroupName.1"], gocheck.DeepEquals, []string{"WebServers"})
c.Assert(req.Form["GroupName.2"], gocheck.DeepEquals, []string{"RangedPortsBySource"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
c.Assert(resp.Groups, gocheck.HasLen, 2)
g0 := resp.Groups[0]
c.Assert(g0.OwnerId, gocheck.Equals, "999988887777")
c.Assert(g0.Name, gocheck.Equals, "WebServers")
c.Assert(g0.Id, gocheck.Equals, "sg-67ad940e")
c.Assert(g0.Description, gocheck.Equals, "Web Servers")
c.Assert(g0.IPPerms, gocheck.HasLen, 1)
g0ipp := g0.IPPerms[0]
c.Assert(g0ipp.Protocol, gocheck.Equals, "tcp")
c.Assert(g0ipp.FromPort, gocheck.Equals, 80)
c.Assert(g0ipp.ToPort, gocheck.Equals, 80)
c.Assert(g0ipp.SourceIPs, gocheck.DeepEquals, []string{"0.0.0.0/0"})
g1 := resp.Groups[1]
c.Assert(g1.OwnerId, gocheck.Equals, "999988887777")
c.Assert(g1.Name, gocheck.Equals, "RangedPortsBySource")
c.Assert(g1.Id, gocheck.Equals, "sg-76abc467")
c.Assert(g1.Description, gocheck.Equals, "Group A")
c.Assert(g1.IPPerms, gocheck.HasLen, 1)
g1ipp := g1.IPPerms[0]
c.Assert(g1ipp.Protocol, gocheck.Equals, "tcp")
c.Assert(g1ipp.FromPort, gocheck.Equals, 6000)
c.Assert(g1ipp.ToPort, gocheck.Equals, 7000)
c.Assert(g1ipp.SourceIPs, gocheck.IsNil)
}
func (s *S) TestDescribeSecurityGroupsExampleWithFilter(c *gocheck.C) {
testServer.Response(200, nil, DescribeSecurityGroupsExample)
filter := ec2.NewFilter()
filter.Add("ip-permission.protocol", "tcp")
filter.Add("ip-permission.from-port", "22")
filter.Add("ip-permission.to-port", "22")
filter.Add("ip-permission.group-name", "app_server_group", "database_group")
_, err := s.ec2.SecurityGroups(nil, filter)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DescribeSecurityGroups"})
c.Assert(req.Form["Filter.1.Name"], gocheck.DeepEquals, []string{"ip-permission.from-port"})
c.Assert(req.Form["Filter.1.Value.1"], gocheck.DeepEquals, []string{"22"})
c.Assert(req.Form["Filter.2.Name"], gocheck.DeepEquals, []string{"ip-permission.group-name"})
c.Assert(req.Form["Filter.2.Value.1"], gocheck.DeepEquals, []string{"app_server_group"})
c.Assert(req.Form["Filter.2.Value.2"], gocheck.DeepEquals, []string{"database_group"})
c.Assert(req.Form["Filter.3.Name"], gocheck.DeepEquals, []string{"ip-permission.protocol"})
c.Assert(req.Form["Filter.3.Value.1"], gocheck.DeepEquals, []string{"tcp"})
c.Assert(req.Form["Filter.4.Name"], gocheck.DeepEquals, []string{"ip-permission.to-port"})
c.Assert(req.Form["Filter.4.Value.1"], gocheck.DeepEquals, []string{"22"})
c.Assert(err, gocheck.IsNil)
}
func (s *S) TestDescribeSecurityGroupsDumpWithGroup(c *gocheck.C) {
testServer.Response(200, nil, DescribeSecurityGroupsDump)
resp, err := s.ec2.SecurityGroups(nil, nil)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DescribeSecurityGroups"})
c.Assert(err, gocheck.IsNil)
c.Check(resp.Groups, gocheck.HasLen, 1)
c.Check(resp.Groups[0].IPPerms, gocheck.HasLen, 2)
ipp0 := resp.Groups[0].IPPerms[0]
c.Assert(ipp0.SourceIPs, gocheck.IsNil)
c.Check(ipp0.Protocol, gocheck.Equals, "icmp")
c.Assert(ipp0.SourceGroups, gocheck.HasLen, 1)
c.Check(ipp0.SourceGroups[0].OwnerId, gocheck.Equals, "12345")
c.Check(ipp0.SourceGroups[0].Name, gocheck.Equals, "default")
c.Check(ipp0.SourceGroups[0].Id, gocheck.Equals, "sg-67ad940e")
ipp1 := resp.Groups[0].IPPerms[1]
c.Check(ipp1.Protocol, gocheck.Equals, "tcp")
c.Assert(ipp0.SourceIPs, gocheck.IsNil)
c.Assert(ipp0.SourceGroups, gocheck.HasLen, 1)
c.Check(ipp1.SourceGroups[0].Id, gocheck.Equals, "sg-76abc467")
c.Check(ipp1.SourceGroups[0].OwnerId, gocheck.Equals, "12345")
c.Check(ipp1.SourceGroups[0].Name, gocheck.Equals, "other")
}
func (s *S) TestDeleteSecurityGroupExample(c *gocheck.C) {
testServer.Response(200, nil, DeleteSecurityGroupExample)
resp, err := s.ec2.DeleteSecurityGroup(ec2.SecurityGroup{Name: "websrv"})
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"DeleteSecurityGroup"})
c.Assert(req.Form["GroupName"], gocheck.DeepEquals, []string{"websrv"})
c.Assert(req.Form["GroupId"], gocheck.IsNil)
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
}
func (s *S) TestDeleteSecurityGroupExampleWithId(c *gocheck.C) {
testServer.Response(200, nil, DeleteSecurityGroupExample)
// ignore return and error - we're only want to check the parameter handling.
s.ec2.DeleteSecurityGroup(ec2.SecurityGroup{Id: "sg-67ad940e", Name: "ignored"})
req := testServer.WaitRequest()
c.Assert(req.Form["GroupName"], gocheck.IsNil)
c.Assert(req.Form["GroupId"], gocheck.DeepEquals, []string{"sg-67ad940e"})
}
func (s *S) TestAuthorizeSecurityGroupExample1(c *gocheck.C) {
testServer.Response(200, nil, AuthorizeSecurityGroupIngressExample)
perms := []ec2.IPPerm{{
Protocol: "tcp",
FromPort: 80,
ToPort: 80,
SourceIPs: []string{"205.192.0.0/16", "205.159.0.0/16"},
}}
resp, err := s.ec2.AuthorizeSecurityGroup(ec2.SecurityGroup{Name: "websrv"}, perms)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"AuthorizeSecurityGroupIngress"})
c.Assert(req.Form["GroupName"], gocheck.DeepEquals, []string{"websrv"})
c.Assert(req.Form["IpPermissions.1.IpProtocol"], gocheck.DeepEquals, []string{"tcp"})
c.Assert(req.Form["IpPermissions.1.FromPort"], gocheck.DeepEquals, []string{"80"})
c.Assert(req.Form["IpPermissions.1.ToPort"], gocheck.DeepEquals, []string{"80"})
c.Assert(req.Form["IpPermissions.1.IpRanges.1.CidrIp"], gocheck.DeepEquals, []string{"205.192.0.0/16"})
c.Assert(req.Form["IpPermissions.1.IpRanges.2.CidrIp"], gocheck.DeepEquals, []string{"205.159.0.0/16"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
}
func (s *S) TestAuthorizeSecurityGroupExample1WithId(c *gocheck.C) {
testServer.Response(200, nil, AuthorizeSecurityGroupIngressExample)
perms := []ec2.IPPerm{{
Protocol: "tcp",
FromPort: 80,
ToPort: 80,
SourceIPs: []string{"205.192.0.0/16", "205.159.0.0/16"},
}}
// ignore return and error - we're only want to check the parameter handling.
s.ec2.AuthorizeSecurityGroup(ec2.SecurityGroup{Id: "sg-67ad940e", Name: "ignored"}, perms)
req := testServer.WaitRequest()
c.Assert(req.Form["GroupName"], gocheck.IsNil)
c.Assert(req.Form["GroupId"], gocheck.DeepEquals, []string{"sg-67ad940e"})
}
func (s *S) TestAuthorizeSecurityGroupExample2(c *gocheck.C) {
testServer.Response(200, nil, AuthorizeSecurityGroupIngressExample)
perms := []ec2.IPPerm{{
Protocol: "tcp",
FromPort: 80,
ToPort: 81,
SourceGroups: []ec2.UserSecurityGroup{
{OwnerId: "999988887777", Name: "OtherAccountGroup"},
{Id: "sg-67ad940e"},
},
}}
resp, err := s.ec2.AuthorizeSecurityGroup(ec2.SecurityGroup{Name: "websrv"}, perms)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"AuthorizeSecurityGroupIngress"})
c.Assert(req.Form["GroupName"], gocheck.DeepEquals, []string{"websrv"})
c.Assert(req.Form["IpPermissions.1.IpProtocol"], gocheck.DeepEquals, []string{"tcp"})
c.Assert(req.Form["IpPermissions.1.FromPort"], gocheck.DeepEquals, []string{"80"})
c.Assert(req.Form["IpPermissions.1.ToPort"], gocheck.DeepEquals, []string{"81"})
c.Assert(req.Form["IpPermissions.1.Groups.1.UserId"], gocheck.DeepEquals, []string{"999988887777"})
c.Assert(req.Form["IpPermissions.1.Groups.1.GroupName"], gocheck.DeepEquals, []string{"OtherAccountGroup"})
c.Assert(req.Form["IpPermissions.1.Groups.2.UserId"], gocheck.IsNil)
c.Assert(req.Form["IpPermissions.1.Groups.2.GroupName"], gocheck.IsNil)
c.Assert(req.Form["IpPermissions.1.Groups.2.GroupId"], gocheck.DeepEquals, []string{"sg-67ad940e"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
}
func (s *S) TestRevokeSecurityGroupExample(c *gocheck.C) {
// RevokeSecurityGroup is implemented by the same code as AuthorizeSecurityGroup
// so there's no need to duplicate all the tests.
testServer.Response(200, nil, RevokeSecurityGroupIngressExample)
resp, err := s.ec2.RevokeSecurityGroup(ec2.SecurityGroup{Name: "websrv"}, nil)
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"RevokeSecurityGroupIngress"})
c.Assert(req.Form["GroupName"], gocheck.DeepEquals, []string{"websrv"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
}
func (s *S) TestCreateTags(c *gocheck.C) {
testServer.Response(200, nil, CreateTagsExample)
resp, err := s.ec2.CreateTags([]string{"ami-1a2b3c4d", "i-7f4d3a2b"}, []ec2.Tag{{"webserver", ""}, {"stack", "Production"}})
req := testServer.WaitRequest()
c.Assert(req.Form["ResourceId.1"], gocheck.DeepEquals, []string{"ami-1a2b3c4d"})
c.Assert(req.Form["ResourceId.2"], gocheck.DeepEquals, []string{"i-7f4d3a2b"})
c.Assert(req.Form["Tag.1.Key"], gocheck.DeepEquals, []string{"webserver"})
c.Assert(req.Form["Tag.1.Value"], gocheck.DeepEquals, []string{""})
c.Assert(req.Form["Tag.2.Key"], gocheck.DeepEquals, []string{"stack"})
c.Assert(req.Form["Tag.2.Value"], gocheck.DeepEquals, []string{"Production"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
}
func (s *S) TestStartInstances(c *gocheck.C) {
testServer.Response(200, nil, StartInstancesExample)
resp, err := s.ec2.StartInstances("i-10a64379")
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"StartInstances"})
c.Assert(req.Form["InstanceId.1"], gocheck.DeepEquals, []string{"i-10a64379"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
s0 := resp.StateChanges[0]
c.Assert(s0.InstanceId, gocheck.Equals, "i-10a64379")
c.Assert(s0.CurrentState.Code, gocheck.Equals, 0)
c.Assert(s0.CurrentState.Name, gocheck.Equals, "pending")
c.Assert(s0.PreviousState.Code, gocheck.Equals, 80)
c.Assert(s0.PreviousState.Name, gocheck.Equals, "stopped")
}
func (s *S) TestStopInstances(c *gocheck.C) {
testServer.Response(200, nil, StopInstancesExample)
resp, err := s.ec2.StopInstances("i-10a64379")
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"StopInstances"})
c.Assert(req.Form["InstanceId.1"], gocheck.DeepEquals, []string{"i-10a64379"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
s0 := resp.StateChanges[0]
c.Assert(s0.InstanceId, gocheck.Equals, "i-10a64379")
c.Assert(s0.CurrentState.Code, gocheck.Equals, 64)
c.Assert(s0.CurrentState.Name, gocheck.Equals, "stopping")
c.Assert(s0.PreviousState.Code, gocheck.Equals, 16)
c.Assert(s0.PreviousState.Name, gocheck.Equals, "running")
}
func (s *S) TestRebootInstances(c *gocheck.C) {
testServer.Response(200, nil, RebootInstancesExample)
resp, err := s.ec2.RebootInstances("i-10a64379")
req := testServer.WaitRequest()
c.Assert(req.Form["Action"], gocheck.DeepEquals, []string{"RebootInstances"})
c.Assert(req.Form["InstanceId.1"], gocheck.DeepEquals, []string{"i-10a64379"})
c.Assert(err, gocheck.IsNil)
c.Assert(resp.RequestId, gocheck.Equals, "59dbff89-35bd-4eac-99ed-be587EXAMPLE")
}
func (s *S) TestSignatureWithEndpointPath(c *gocheck.C) {
ec2.FakeTime(true)
defer ec2.FakeTime(false)
testServer.Response(200, nil, RebootInstancesExample)
// https://bugs.launchpad.net/goamz/+bug/1022749
ec2 := ec2.NewWithClient(s.ec2.Auth, aws.Region{EC2Endpoint: testServer.URL + "/services/Cloud"}, testutil.DefaultClient)
_, err := ec2.RebootInstances("i-10a64379")
c.Assert(err, gocheck.IsNil)
req := testServer.WaitRequest()
c.Assert(req.Form["Signature"], gocheck.DeepEquals, []string{"VVoC6Y6xfES+KvZo+789thP8+tye4F6fOKBiKmXk4S4="})
}