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
|
package elb_test
import (
"github.com/AdRoll/goamz/aws"
"github.com/AdRoll/goamz/elb"
"gopkg.in/check.v1"
"time"
)
type S struct {
HTTPSuite
elb *elb.ELB
}
var _ = check.Suite(&S{})
func (s *S) SetUpSuite(c *check.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 *check.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, check.IsNil)
defer s.elb.DeleteLoadBalancer(createLB.Name)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), check.Equals, "2012-06-01")
c.Assert(values.Get("Action"), check.Equals, "CreateLoadBalancer")
c.Assert(values.Get("Timestamp"), check.Not(check.Equals), "")
c.Assert(values.Get("LoadBalancerName"), check.Equals, "testlb")
c.Assert(values.Get("AvailabilityZones.member.1"), check.Equals, "us-east-1a")
c.Assert(values.Get("AvailabilityZones.member.2"), check.Equals, "us-east-1b")
c.Assert(values.Get("Listeners.member.1.InstancePort"), check.Equals, "80")
c.Assert(values.Get("Listeners.member.1.InstanceProtocol"), check.Equals, "http")
c.Assert(values.Get("Listeners.member.1.Protocol"), check.Equals, "http")
c.Assert(values.Get("Listeners.member.1.LoadBalancerPort"), check.Equals, "80")
c.Assert(values.Get("Signature"), check.Not(check.Equals), "")
c.Assert(resp.DNSName, check.Equals, "testlb-339187009.us-east-1.elb.amazonaws.com")
}
func (s *S) TestCreateLoadBalancerWithSubnetsAndMoreListeners(c *check.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, check.IsNil)
defer s.elb.DeleteLoadBalancer(createLB.Name)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Listeners.member.1.InstancePort"), check.Equals, "80")
c.Assert(values.Get("Listeners.member.1.LoadBalancerPort"), check.Equals, "80")
c.Assert(values.Get("Listeners.member.2.InstancePort"), check.Equals, "8080")
c.Assert(values.Get("Listeners.member.2.LoadBalancerPort"), check.Equals, "8080")
c.Assert(values.Get("Subnets.member.1"), check.Equals, "subnetid-1")
c.Assert(values.Get("Subnets.member.2"), check.Equals, "subnetid-2")
c.Assert(values.Get("SecurityGroups.member.1"), check.Equals, "sg-1")
c.Assert(values.Get("SecurityGroups.member.2"), check.Equals, "sg-2")
}
func (s *S) TestCreateLoadBalancerWithWrongParamsCombination(c *check.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, check.IsNil)
c.Assert(err, check.NotNil)
e, ok := err.(*elb.Error)
c.Assert(ok, check.Equals, true)
c.Assert(e.Message, check.Equals, "Only one of SubnetIds or AvailabilityZones may be specified")
c.Assert(e.Code, check.Equals, "ValidationError")
}
func (s *S) TestDeleteLoadBalancer(c *check.C) {
testServer.PrepareResponse(200, nil, DeleteLoadBalancer)
resp, err := s.elb.DeleteLoadBalancer("testlb")
c.Assert(err, check.IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), check.Equals, "2012-06-01")
c.Assert(values.Get("Signature"), check.Not(check.Equals), "")
c.Assert(values.Get("Timestamp"), check.Not(check.Equals), "")
c.Assert(values.Get("Action"), check.Equals, "DeleteLoadBalancer")
c.Assert(values.Get("LoadBalancerName"), check.Equals, "testlb")
c.Assert(resp.RequestId, check.Equals, "8d7223db-49d7-11e2-bba9-35ba56032fe1")
}
func (s *S) TestRegisterInstancesWithLoadBalancer(c *check.C) {
testServer.PrepareResponse(200, nil, RegisterInstancesWithLoadBalancer)
resp, err := s.elb.RegisterInstancesWithLoadBalancer([]string{"i-b44db8ca", "i-461ecf38"}, "testlb")
c.Assert(err, check.IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), check.Equals, "2012-06-01")
c.Assert(values.Get("Signature"), check.Not(check.Equals), "")
c.Assert(values.Get("Timestamp"), check.Not(check.Equals), "")
c.Assert(values.Get("Action"), check.Equals, "RegisterInstancesWithLoadBalancer")
c.Assert(values.Get("LoadBalancerName"), check.Equals, "testlb")
c.Assert(values.Get("Instances.member.1.InstanceId"), check.Equals, "i-b44db8ca")
c.Assert(values.Get("Instances.member.2.InstanceId"), check.Equals, "i-461ecf38")
c.Assert(resp.InstanceIds, check.DeepEquals, []string{"i-b44db8ca", "i-461ecf38"})
}
func (s *S) TestRegisterInstancesWithLoadBalancerBadRequest(c *check.C) {
testServer.PrepareResponse(400, nil, RegisterInstancesWithLoadBalancerBadRequest)
resp, err := s.elb.RegisterInstancesWithLoadBalancer([]string{"i-b44db8ca", "i-461ecf38"}, "absentLB")
c.Assert(resp, check.IsNil)
c.Assert(err, check.NotNil)
e, ok := err.(*elb.Error)
c.Assert(ok, check.Equals, true)
c.Assert(e.Message, check.Equals, "There is no ACTIVE Load Balancer named 'absentLB'")
c.Assert(e.Code, check.Equals, "LoadBalancerNotFound")
}
func (s *S) TestDeregisterInstancesFromLoadBalancer(c *check.C) {
testServer.PrepareResponse(200, nil, DeregisterInstancesFromLoadBalancer)
resp, err := s.elb.DeregisterInstancesFromLoadBalancer([]string{"i-b44db8ca", "i-461ecf38"}, "testlb")
c.Assert(err, check.IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), check.Equals, "2012-06-01")
c.Assert(values.Get("Signature"), check.Not(check.Equals), "")
c.Assert(values.Get("Timestamp"), check.Not(check.Equals), "")
c.Assert(values.Get("Action"), check.Equals, "DeregisterInstancesFromLoadBalancer")
c.Assert(values.Get("LoadBalancerName"), check.Equals, "testlb")
c.Assert(values.Get("Instances.member.1.InstanceId"), check.Equals, "i-b44db8ca")
c.Assert(values.Get("Instances.member.2.InstanceId"), check.Equals, "i-461ecf38")
c.Assert(resp.RequestId, check.Equals, "d6490837-49fd-11e2-bba9-35ba56032fe1")
}
func (s *S) TestDeregisterInstancesFromLoadBalancerBadRequest(c *check.C) {
testServer.PrepareResponse(400, nil, DeregisterInstancesFromLoadBalancerBadRequest)
resp, err := s.elb.DeregisterInstancesFromLoadBalancer([]string{"i-b44db8ca", "i-461ecf38"}, "testlb")
c.Assert(resp, check.IsNil)
c.Assert(err, check.NotNil)
e, ok := err.(*elb.Error)
c.Assert(ok, check.Equals, true)
c.Assert(e.Message, check.Equals, "There is no ACTIVE Load Balancer named 'absentlb'")
c.Assert(e.Code, check.Equals, "LoadBalancerNotFound")
}
func (s *S) TestDescribeLoadBalancers(c *check.C) {
testServer.PrepareResponse(200, nil, DescribeLoadBalancers)
resp, err := s.elb.DescribeLoadBalancers()
c.Assert(err, check.IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), check.Equals, "2012-06-01")
c.Assert(values.Get("Signature"), check.Not(check.Equals), "")
c.Assert(values.Get("Timestamp"), check.Not(check.Equals), "")
c.Assert(values.Get("Action"), check.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, check.DeepEquals, expected)
}
func (s *S) TestDescribeLoadBalancersByName(c *check.C) {
testServer.PrepareResponse(200, nil, DescribeLoadBalancers)
s.elb.DescribeLoadBalancers("somelb")
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), check.Equals, "2012-06-01")
c.Assert(values.Get("Signature"), check.Not(check.Equals), "")
c.Assert(values.Get("Timestamp"), check.Not(check.Equals), "")
c.Assert(values.Get("Action"), check.Equals, "DescribeLoadBalancers")
c.Assert(values.Get("LoadBalancerNames.member.1"), check.Equals, "somelb")
}
func (s *S) TestDescribeLoadBalancersBadRequest(c *check.C) {
testServer.PrepareResponse(400, nil, DescribeLoadBalancersBadRequest)
resp, err := s.elb.DescribeLoadBalancers()
c.Assert(resp, check.IsNil)
c.Assert(err, check.NotNil)
c.Assert(err, check.ErrorMatches, `^Cannot find Load Balancer absentlb \(LoadBalancerNotFound\)$`)
}
func (s *S) TestDescribeInstanceHealth(c *check.C) {
testServer.PrepareResponse(200, nil, DescribeInstanceHealth)
resp, err := s.elb.DescribeInstanceHealth("testlb", "i-b44db8ca")
c.Assert(err, check.IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), check.Equals, "2012-06-01")
c.Assert(values.Get("Signature"), check.Not(check.Equals), "")
c.Assert(values.Get("Timestamp"), check.Not(check.Equals), "")
c.Assert(values.Get("Action"), check.Equals, "DescribeInstanceHealth")
c.Assert(values.Get("LoadBalancerName"), check.Equals, "testlb")
c.Assert(values.Get("Instances.member.1.InstanceId"), check.Equals, "i-b44db8ca")
c.Assert(len(resp.InstanceStates) > 0, check.Equals, true)
c.Assert(resp.InstanceStates[0].Description, check.Equals, "Instance registration is still in progress.")
c.Assert(resp.InstanceStates[0].InstanceId, check.Equals, "i-b44db8ca")
c.Assert(resp.InstanceStates[0].State, check.Equals, "OutOfService")
c.Assert(resp.InstanceStates[0].ReasonCode, check.Equals, "ELB")
}
func (s *S) TestDescribeInstanceHealthBadRequest(c *check.C) {
testServer.PrepareResponse(400, nil, DescribeInstanceHealthBadRequest)
resp, err := s.elb.DescribeInstanceHealth("testlb", "i-foooo")
c.Assert(err, check.NotNil)
c.Assert(resp, check.IsNil)
c.Assert(err, check.ErrorMatches, ".*i-foooo.*(InvalidInstance).*")
}
func (s *S) TestConfigureHealthCheck(c *check.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, check.IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), check.Equals, "2012-06-01")
c.Assert(values.Get("Signature"), check.Not(check.Equals), "")
c.Assert(values.Get("Timestamp"), check.Not(check.Equals), "")
c.Assert(values.Get("Action"), check.Equals, "ConfigureHealthCheck")
c.Assert(values.Get("LoadBalancerName"), check.Equals, "testlb")
c.Assert(values.Get("HealthCheck.HealthyThreshold"), check.Equals, "10")
c.Assert(values.Get("HealthCheck.Interval"), check.Equals, "30")
c.Assert(values.Get("HealthCheck.Target"), check.Equals, "HTTP:80/")
c.Assert(values.Get("HealthCheck.Timeout"), check.Equals, "5")
c.Assert(values.Get("HealthCheck.UnhealthyThreshold"), check.Equals, "2")
c.Assert(resp.HealthCheck.HealthyThreshold, check.Equals, 10)
c.Assert(resp.HealthCheck.Interval, check.Equals, 30)
c.Assert(resp.HealthCheck.Target, check.Equals, "HTTP:80/")
c.Assert(resp.HealthCheck.Timeout, check.Equals, 5)
c.Assert(resp.HealthCheck.UnhealthyThreshold, check.Equals, 2)
}
func (s *S) TestConfigureHealthCheckBadRequest(c *check.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, check.IsNil)
c.Assert(err, check.NotNil)
c.Assert(err, check.ErrorMatches, ".*foolb.*(LoadBalancerNotFound).*")
}
func (s *S) TestDescribeLoadBalancerAttributes(c *check.C) {
testServer.PrepareResponse(200, nil, DescribeLoadBalancerAttributes)
resp, err := s.elb.DescribeLoadBalancerAttributes("my-test-loadbalancer")
c.Assert(err, check.IsNil)
values := testServer.WaitRequest().URL.Query()
c.Assert(values.Get("Version"), check.Equals, "2012-06-01")
c.Assert(values.Get("Signature"), check.Not(check.Equals), "")
c.Assert(values.Get("Timestamp"), check.Not(check.Equals), "")
c.Assert(values.Get("Action"), check.Equals, "DescribeLoadBalancerAttributes")
c.Assert(values.Get("LoadBalancerName"), check.Equals, "my-test-loadbalancer")
c.Assert(resp.AccessLogEnabled, check.Equals, true)
c.Assert(resp.AccessLogS3Bucket, check.Equals, "my-loadbalancer-logs")
c.Assert(resp.AccessLogS3Prefix, check.Equals, "testprefix")
c.Assert(resp.AccessLogEmitInterval, check.Equals, 5)
c.Assert(resp.IdleTimeout, check.Equals, 30)
c.Assert(resp.CrossZoneLoadbalancing, check.Equals, true)
c.Assert(resp.ConnectionDrainingTimeout, check.Equals, 60)
c.Assert(resp.ConnectionDrainingEnabled, check.Equals, true)
}
|
