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
|
package elb_test
import (
"time"
"github.com/goamz/goamz/aws"
"github.com/goamz/goamz/elb"
. "gopkg.in/check.v1"
)
type S struct {
HTTPSuite
elb *elb.ELB
}
var _ = Suite(&S{})
func (s *S) SetUpSuite(c *C) {
s.HTTPSuite.SetUpSuite(c)
auth := aws.Auth{AccessKey: "abc", SecretKey: "123"}
s.elb = elb.New(auth, aws.Region{ELBEndpoint: testServer.URL})
}
func (s *S) TestCreateLoadBalancer(c *C) {
testServer.PrepareResponse(200, nil, CreateLoadBalancer)
createLB := &elb.CreateLoadBalancer{
Name: "testlb",
AvailabilityZones: []string{"us-east-1a", "us-east-1b"},
Listeners: []elb.Listener{
{
InstancePort: 80,
InstanceProtocol: "http",
Protocol: "http",
LoadBalancerPort: 80,
},
},
}
resp, err := s.elb.CreateLoadBalancer(createLB)
c.Assert(err, IsNil)
defer s.elb.DeleteLoadBalancer(createLB.Name)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), Equals, "2012-06-01")
c.Assert(values.Get("Action"), Equals, "CreateLoadBalancer")
c.Assert(values.Get("Timestamp"), Not(Equals), "")
c.Assert(values.Get("LoadBalancerName"), Equals, "testlb")
c.Assert(values.Get("AvailabilityZones.member.1"), Equals, "us-east-1a")
c.Assert(values.Get("AvailabilityZones.member.2"), Equals, "us-east-1b")
c.Assert(values.Get("Listeners.member.1.InstancePort"), Equals, "80")
c.Assert(values.Get("Listeners.member.1.InstanceProtocol"), Equals, "http")
c.Assert(values.Get("Listeners.member.1.Protocol"), Equals, "http")
c.Assert(values.Get("Listeners.member.1.LoadBalancerPort"), Equals, "80")
c.Assert(resp.DNSName, Equals, "testlb-339187009.us-east-1.elb.amazonaws.com")
}
func (s *S) TestCreateLoadBalancerWithSubnetsAndMoreListeners(c *C) {
testServer.PrepareResponse(200, nil, CreateLoadBalancer)
createLB := &elb.CreateLoadBalancer{
Name: "testlb",
Listeners: []elb.Listener{
{
InstancePort: 80,
InstanceProtocol: "http",
Protocol: "http",
LoadBalancerPort: 80,
},
{
InstancePort: 8080,
InstanceProtocol: "http",
Protocol: "http",
LoadBalancerPort: 8080,
},
},
Subnets: []string{"subnetid-1", "subnetid-2"},
SecurityGroups: []string{"sg-1", "sg-2"},
}
_, err := s.elb.CreateLoadBalancer(createLB)
c.Assert(err, IsNil)
defer s.elb.DeleteLoadBalancer(createLB.Name)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Listeners.member.1.InstancePort"), Equals, "80")
c.Assert(values.Get("Listeners.member.1.LoadBalancerPort"), Equals, "80")
c.Assert(values.Get("Listeners.member.2.InstancePort"), Equals, "8080")
c.Assert(values.Get("Listeners.member.2.LoadBalancerPort"), Equals, "8080")
c.Assert(values.Get("Subnets.member.1"), Equals, "subnetid-1")
c.Assert(values.Get("Subnets.member.2"), Equals, "subnetid-2")
c.Assert(values.Get("SecurityGroups.member.1"), Equals, "sg-1")
c.Assert(values.Get("SecurityGroups.member.2"), Equals, "sg-2")
}
func (s *S) TestCreateLoadBalancerWithWrongParamsCombination(c *C) {
testServer.PrepareResponse(400, nil, CreateLoadBalancerBadRequest)
createLB := &elb.CreateLoadBalancer{
Name: "testlb",
AvailabilityZones: []string{"us-east-1a", "us-east-1b"},
Listeners: []elb.Listener{
{
InstancePort: 80,
InstanceProtocol: "http",
Protocol: "http",
LoadBalancerPort: 80,
},
},
Subnets: []string{"subnetid-1", "subnetid2"},
}
resp, err := s.elb.CreateLoadBalancer(createLB)
c.Assert(resp, IsNil)
c.Assert(err, NotNil)
e, ok := err.(*elb.Error)
c.Assert(ok, Equals, true)
c.Assert(e.Message, Equals, "Only one of SubnetIds or AvailabilityZones may be specified")
c.Assert(e.Code, Equals, "ValidationError")
}
func (s *S) TestDeleteLoadBalancer(c *C) {
testServer.PrepareResponse(200, nil, DeleteLoadBalancer)
resp, err := s.elb.DeleteLoadBalancer("testlb")
c.Assert(err, IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), Equals, "2012-06-01")
c.Assert(values.Get("Timestamp"), Not(Equals), "")
c.Assert(values.Get("Action"), Equals, "DeleteLoadBalancer")
c.Assert(values.Get("LoadBalancerName"), Equals, "testlb")
c.Assert(resp.RequestId, Equals, "8d7223db-49d7-11e2-bba9-35ba56032fe1")
}
func (s *S) TestRegisterInstancesWithLoadBalancer(c *C) {
testServer.PrepareResponse(200, nil, RegisterInstancesWithLoadBalancer)
resp, err := s.elb.RegisterInstancesWithLoadBalancer([]string{"i-b44db8ca", "i-461ecf38"}, "testlb")
c.Assert(err, IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), Equals, "2012-06-01")
c.Assert(values.Get("Timestamp"), Not(Equals), "")
c.Assert(values.Get("Action"), Equals, "RegisterInstancesWithLoadBalancer")
c.Assert(values.Get("LoadBalancerName"), Equals, "testlb")
c.Assert(values.Get("Instances.member.1.InstanceId"), Equals, "i-b44db8ca")
c.Assert(values.Get("Instances.member.2.InstanceId"), Equals, "i-461ecf38")
c.Assert(resp.InstanceIds, DeepEquals, []string{"i-b44db8ca", "i-461ecf38"})
}
func (s *S) TestRegisterInstancesWithLoadBalancerBadRequest(c *C) {
testServer.PrepareResponse(400, nil, RegisterInstancesWithLoadBalancerBadRequest)
resp, err := s.elb.RegisterInstancesWithLoadBalancer([]string{"i-b44db8ca", "i-461ecf38"}, "absentLB")
c.Assert(resp, IsNil)
c.Assert(err, NotNil)
e, ok := err.(*elb.Error)
c.Assert(ok, Equals, true)
c.Assert(e.Message, Equals, "There is no ACTIVE Load Balancer named 'absentLB'")
c.Assert(e.Code, Equals, "LoadBalancerNotFound")
}
func (s *S) TestDeregisterInstancesFromLoadBalancer(c *C) {
testServer.PrepareResponse(200, nil, DeregisterInstancesFromLoadBalancer)
resp, err := s.elb.DeregisterInstancesFromLoadBalancer([]string{"i-b44db8ca", "i-461ecf38"}, "testlb")
c.Assert(err, IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), Equals, "2012-06-01")
c.Assert(values.Get("Timestamp"), Not(Equals), "")
c.Assert(values.Get("Action"), Equals, "DeregisterInstancesFromLoadBalancer")
c.Assert(values.Get("LoadBalancerName"), Equals, "testlb")
c.Assert(values.Get("Instances.member.1.InstanceId"), Equals, "i-b44db8ca")
c.Assert(values.Get("Instances.member.2.InstanceId"), Equals, "i-461ecf38")
c.Assert(resp.RequestId, Equals, "d6490837-49fd-11e2-bba9-35ba56032fe1")
}
func (s *S) TestDeregisterInstancesFromLoadBalancerBadRequest(c *C) {
testServer.PrepareResponse(400, nil, DeregisterInstancesFromLoadBalancerBadRequest)
resp, err := s.elb.DeregisterInstancesFromLoadBalancer([]string{"i-b44db8ca", "i-461ecf38"}, "testlb")
c.Assert(resp, IsNil)
c.Assert(err, NotNil)
e, ok := err.(*elb.Error)
c.Assert(ok, Equals, true)
c.Assert(e.Message, Equals, "There is no ACTIVE Load Balancer named 'absentlb'")
c.Assert(e.Code, Equals, "LoadBalancerNotFound")
}
func (s *S) TestDescribeLoadBalancers(c *C) {
testServer.PrepareResponse(200, nil, DescribeLoadBalancers)
resp, err := s.elb.DescribeLoadBalancers()
c.Assert(err, IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), Equals, "2012-06-01")
c.Assert(values.Get("Timestamp"), Not(Equals), "")
c.Assert(values.Get("Action"), Equals, "DescribeLoadBalancers")
t, _ := time.Parse(time.RFC3339, "2012-12-27T11:51:52.970Z")
expected := &elb.DescribeLoadBalancerResp{
[]elb.LoadBalancerDescription{
{
AvailabilityZones: []string{"us-east-1a"},
BackendServerDescriptions: []elb.BackendServerDescriptions(nil),
CanonicalHostedZoneName: "testlb-2087227216.us-east-1.elb.amazonaws.com",
CanonicalHostedZoneNameId: "Z3DZXE0Q79N41H",
CreatedTime: t,
DNSName: "testlb-2087227216.us-east-1.elb.amazonaws.com",
HealthCheck: elb.HealthCheck{
HealthyThreshold: 10,
Interval: 30,
Target: "TCP:80",
Timeout: 5,
UnhealthyThreshold: 2,
},
Instances: []elb.Instance(nil),
ListenerDescriptions: []elb.ListenerDescription{
{
Listener: elb.Listener{
Protocol: "HTTP",
LoadBalancerPort: 80,
InstanceProtocol: "HTTP",
InstancePort: 80,
},
},
},
LoadBalancerName: "testlb",
//Policies: elb.Policies(nil),
Scheme: "internet-facing",
SecurityGroups: []string(nil),
SourceSecurityGroup: elb.SourceSecurityGroup{
GroupName: "amazon-elb-sg",
OwnerAlias: "amazon-elb",
},
Subnets: []string(nil),
},
},
}
c.Assert(resp, DeepEquals, expected)
}
func (s *S) TestDescribeLoadBalancersByName(c *C) {
testServer.PrepareResponse(200, nil, DescribeLoadBalancers)
s.elb.DescribeLoadBalancers("somelb")
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), Equals, "2012-06-01")
c.Assert(values.Get("Timestamp"), Not(Equals), "")
c.Assert(values.Get("Action"), Equals, "DescribeLoadBalancers")
c.Assert(values.Get("LoadBalancerNames.member.1"), Equals, "somelb")
}
func (s *S) TestDescribeLoadBalancersBadRequest(c *C) {
testServer.PrepareResponse(400, nil, DescribeLoadBalancersBadRequest)
resp, err := s.elb.DescribeLoadBalancers()
c.Assert(resp, IsNil)
c.Assert(err, NotNil)
c.Assert(err, ErrorMatches, `^Cannot find Load Balancer absentlb \(LoadBalancerNotFound\)$`)
}
func (s *S) TestDescribeInstanceHealth(c *C) {
testServer.PrepareResponse(200, nil, DescribeInstanceHealth)
resp, err := s.elb.DescribeInstanceHealth("testlb", "i-b44db8ca")
c.Assert(err, IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), Equals, "2012-06-01")
c.Assert(values.Get("Timestamp"), Not(Equals), "")
c.Assert(values.Get("Action"), Equals, "DescribeInstanceHealth")
c.Assert(values.Get("LoadBalancerName"), Equals, "testlb")
c.Assert(values.Get("Instances.member.1.InstanceId"), Equals, "i-b44db8ca")
c.Assert(len(resp.InstanceStates) > 0, Equals, true)
c.Assert(resp.InstanceStates[0].Description, Equals, "Instance registration is still in progress.")
c.Assert(resp.InstanceStates[0].InstanceId, Equals, "i-b44db8ca")
c.Assert(resp.InstanceStates[0].State, Equals, "OutOfService")
c.Assert(resp.InstanceStates[0].ReasonCode, Equals, "ELB")
}
func (s *S) TestDescribeInstanceHealthBadRequest(c *C) {
testServer.PrepareResponse(400, nil, DescribeInstanceHealthBadRequest)
resp, err := s.elb.DescribeInstanceHealth("testlb", "i-foooo")
c.Assert(err, NotNil)
c.Assert(resp, IsNil)
c.Assert(err, ErrorMatches, ".*i-foooo.*(InvalidInstance).*")
}
func (s *S) TestConfigureHealthCheck(c *C) {
testServer.PrepareResponse(200, nil, ConfigureHealthCheck)
hc := elb.HealthCheck{
HealthyThreshold: 10,
Interval: 30,
Target: "HTTP:80/",
Timeout: 5,
UnhealthyThreshold: 2,
}
resp, err := s.elb.ConfigureHealthCheck("testlb", &hc)
c.Assert(err, IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), Equals, "2012-06-01")
c.Assert(values.Get("Timestamp"), Not(Equals), "")
c.Assert(values.Get("Action"), Equals, "ConfigureHealthCheck")
c.Assert(values.Get("LoadBalancerName"), Equals, "testlb")
c.Assert(values.Get("HealthCheck.HealthyThreshold"), Equals, "10")
c.Assert(values.Get("HealthCheck.Interval"), Equals, "30")
c.Assert(values.Get("HealthCheck.Target"), Equals, "HTTP:80/")
c.Assert(values.Get("HealthCheck.Timeout"), Equals, "5")
c.Assert(values.Get("HealthCheck.UnhealthyThreshold"), Equals, "2")
c.Assert(resp.HealthCheck.HealthyThreshold, Equals, 10)
c.Assert(resp.HealthCheck.Interval, Equals, 30)
c.Assert(resp.HealthCheck.Target, Equals, "HTTP:80/")
c.Assert(resp.HealthCheck.Timeout, Equals, 5)
c.Assert(resp.HealthCheck.UnhealthyThreshold, Equals, 2)
}
func (s *S) TestConfigureHealthCheckBadRequest(c *C) {
testServer.PrepareResponse(400, nil, ConfigureHealthCheckBadRequest)
hc := elb.HealthCheck{
HealthyThreshold: 10,
Interval: 30,
Target: "HTTP:80/",
Timeout: 5,
UnhealthyThreshold: 2,
}
resp, err := s.elb.ConfigureHealthCheck("foolb", &hc)
c.Assert(resp, IsNil)
c.Assert(err, NotNil)
c.Assert(err, ErrorMatches, ".*foolb.*(LoadBalancerNotFound).*")
}
func (s *S) TestAddTags(c *C) {
testServer.PrepareResponse(200, nil, AddTagsSuccessResponse)
tagsToAdd := map[string]string{
"my-key": "my-value",
"my-super-silly-tag": "its-another-valid-value",
}
resp, err := s.elb.AddTags("my-elb", tagsToAdd)
c.Assert(err, IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), Equals, "2012-06-01")
c.Assert(values.Get("Action"), Equals, "AddTags")
c.Assert(values.Get("Timestamp"), Not(Equals), "")
c.Assert(values.Get("LoadBalancerNames.member.1"), Equals, "my-elb")
c.Assert(values.Get("Tags.member.1.Key"), Equals, "my-super-silly-tag")
c.Assert(values.Get("Tags.member.1.Value"), Equals, "its-another-valid-value")
c.Assert(values.Get("Tags.member.2.Key"), Equals, "my-key")
c.Assert(values.Get("Tags.member.2.Value"), Equals, "my-value")
c.Assert(resp.RequestId, Equals, "360e81f7-1100-11e4-b6ed-0f30SOME-SAUCY-EXAMPLE")
}
func (s *S) TestAddBadTags(c *C) {
testServer.PrepareResponse(400, nil, TagsBadRequest)
tagsToAdd := map[string]string{
"my-first-key": "an invalid value",
}
resp, err := s.elb.AddTags("my-bad-elb", tagsToAdd)
c.Assert(resp, IsNil)
c.Assert(err, ErrorMatches, ".*(InvalidParameterValue).*")
}
func (s *S) TestRemoveTags(c *C) {
testServer.PrepareResponse(200, nil, RemoveTagsSuccessResponse)
tagKeysToRemove := []string{"a-key-one", "a-key-two"}
resp, err := s.elb.RemoveTags("my-test-elb-1", tagKeysToRemove)
c.Assert(err, IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), Equals, "2012-06-01")
c.Assert(values.Get("Action"), Equals, "RemoveTags")
c.Assert(values.Get("Timestamp"), Not(Equals), "")
c.Assert(values.Get("LoadBalancerNames.member.1"), Equals, "my-test-elb-1")
c.Assert([]string{values.Get("Tags.member.1.Key"), values.Get("Tags.member.2.Key")}, DeepEquals, tagKeysToRemove)
c.Assert(resp.RequestId, Equals, "83c88b9d-12b7-11e3-8b82-87b12DIFFEXAMPLE")
}
func (s *S) TestRemoveTagsFailure(c *C) {
testServer.PrepareResponse(400, nil, TagsBadRequest)
resp, err := s.elb.RemoveTags("my-test-elb", []string{"non-existant-tag"})
c.Assert(resp, IsNil)
c.Assert(err, ErrorMatches, ".*(InvalidParameterValue).*")
}
|
