1
2
3
4 package hcn
5
6 import (
7 "encoding/json"
8 "fmt"
9 "testing"
10 )
11
12 func TestCreateDeleteLoadBalancer(t *testing.T) {
13 network, err := CreateTestOverlayNetwork()
14 if err != nil {
15 t.Fatal(err)
16 }
17 endpoint, err := HcnCreateTestEndpoint(network)
18 if err != nil {
19 t.Fatal(err)
20 }
21 loadBalancer, err := HcnCreateTestLoadBalancer(endpoint)
22 if err != nil {
23 t.Fatal(err)
24 }
25 jsonString, err := json.Marshal(loadBalancer)
26 if err != nil {
27 t.Fatal(err)
28 }
29 fmt.Printf("LoadBalancer JSON:\n%s \n", jsonString)
30
31 err = loadBalancer.Delete()
32 if err != nil {
33 t.Fatal(err)
34 }
35 err = endpoint.Delete()
36 if err != nil {
37 t.Fatal(err)
38 }
39 err = network.Delete()
40 if err != nil {
41 t.Fatal(err)
42 }
43 }
44
45 func TestGetLoadBalancerById(t *testing.T) {
46 network, err := CreateTestOverlayNetwork()
47 if err != nil {
48 t.Fatal(err)
49 }
50 endpoint, err := HcnCreateTestEndpoint(network)
51 if err != nil {
52 t.Fatal(err)
53 }
54 loadBalancer, err := HcnCreateTestLoadBalancer(endpoint)
55 if err != nil {
56 t.Fatal(err)
57 }
58 foundLB, err := GetLoadBalancerByID(loadBalancer.Id)
59 if err != nil {
60 t.Fatal(err)
61 }
62 if foundLB == nil {
63 t.Fatalf("No loadBalancer found")
64 }
65 err = loadBalancer.Delete()
66 if err != nil {
67 t.Fatal(err)
68 }
69 err = endpoint.Delete()
70 if err != nil {
71 t.Fatal(err)
72 }
73 err = network.Delete()
74 if err != nil {
75 t.Fatal(err)
76 }
77 }
78
79 func TestListLoadBalancer(t *testing.T) {
80 _, err := ListLoadBalancers()
81 if err != nil {
82 t.Fatal(err)
83 }
84 }
85
86 func TestLoadBalancerAddRemoveEndpoint(t *testing.T) {
87 network, err := CreateTestOverlayNetwork()
88 if err != nil {
89 t.Fatal(err)
90 }
91 endpoint, err := HcnCreateTestEndpoint(network)
92 if err != nil {
93 t.Fatal(err)
94 }
95 loadBalancer, err := HcnCreateTestLoadBalancer(endpoint)
96 if err != nil {
97 t.Fatal(err)
98 }
99
100 secondEndpoint, err := HcnCreateTestEndpoint(network)
101 if err != nil {
102 t.Fatal(err)
103 }
104 updatedLB, err := loadBalancer.AddEndpoint(secondEndpoint)
105 if err != nil {
106 t.Fatal(err)
107 }
108
109 if len(updatedLB.HostComputeEndpoints) != 2 {
110 t.Fatalf("Endpoint not added to loadBalancer")
111 }
112 updatedLB, err = loadBalancer.RemoveEndpoint(secondEndpoint)
113 if err != nil {
114 t.Fatal(err)
115 }
116 if len(updatedLB.HostComputeEndpoints) != 1 {
117 t.Fatalf("Endpoint not removed from loadBalancer")
118 }
119
120 err = loadBalancer.Delete()
121 if err != nil {
122 t.Fatal(err)
123 }
124 err = secondEndpoint.Delete()
125 if err != nil {
126 t.Fatal(err)
127 }
128 err = endpoint.Delete()
129 if err != nil {
130 t.Fatal(err)
131 }
132 err = network.Delete()
133 if err != nil {
134 t.Fatal(err)
135 }
136 }
137
138 func TestAddLoadBalancer(t *testing.T) {
139 network, err := CreateTestOverlayNetwork()
140 if err != nil {
141 t.Fatal(err)
142 }
143 endpoint, err := HcnCreateTestEndpoint(network)
144 if err != nil {
145 t.Fatal(err)
146 }
147
148 loadBalancer, err := AddLoadBalancer([]HostComputeEndpoint{*endpoint}, LoadBalancerFlagsNone, LoadBalancerPortMappingFlagsNone, "10.0.0.1", []string{"1.1.1.2", "1.1.1.3"}, 6, 8080, 80)
149 if err != nil {
150 t.Fatal(err)
151 }
152 foundLB, err := GetLoadBalancerByID(loadBalancer.Id)
153 if err != nil {
154 t.Fatal(err)
155 }
156 if foundLB == nil {
157 t.Fatal(fmt.Errorf("No loadBalancer found"))
158 }
159
160 err = loadBalancer.Delete()
161 if err != nil {
162 t.Fatal(err)
163 }
164 err = endpoint.Delete()
165 if err != nil {
166 t.Fatal(err)
167 }
168 err = network.Delete()
169 if err != nil {
170 t.Fatal(err)
171 }
172 }
173
174 func TestAddDSRLoadBalancer(t *testing.T) {
175 network, err := CreateTestOverlayNetwork()
176 if err != nil {
177 t.Fatal(err)
178 }
179 endpoint, err := HcnCreateTestEndpoint(network)
180 if err != nil {
181 t.Fatal(err)
182 }
183
184 portMappingFlags := LoadBalancerPortMappingFlagsPreserveDIP
185 loadBalancer, err := AddLoadBalancer([]HostComputeEndpoint{*endpoint}, LoadBalancerFlagsDSR, portMappingFlags, "10.0.0.1", []string{"1.1.1.2", "1.1.1.3"}, 6, 8080, 80)
186 if err != nil {
187 t.Fatal(err)
188 }
189 foundLB, err := GetLoadBalancerByID(loadBalancer.Id)
190 if err != nil {
191 t.Fatal(err)
192 }
193 if foundLB == nil {
194 t.Fatal(fmt.Errorf("No loadBalancer found"))
195 }
196 if foundLB.Flags != 1 {
197 t.Fatal(fmt.Errorf("IsDSR is not set"))
198 }
199
200 foundFlags := foundLB.PortMappings[0].Flags
201 if foundFlags&LoadBalancerPortMappingFlagsPreserveDIP == 0 {
202 t.Fatal(fmt.Errorf("PreserveDIP is not set"))
203 }
204
205 err = loadBalancer.Delete()
206 if err != nil {
207 t.Fatal(err)
208 }
209 err = endpoint.Delete()
210 if err != nil {
211 t.Fatal(err)
212 }
213 err = network.Delete()
214 if err != nil {
215 t.Fatal(err)
216 }
217 }
218
219 func TestAddILBLoadBalancer(t *testing.T) {
220 network, err := CreateTestOverlayNetwork()
221 if err != nil {
222 t.Fatal(err)
223 }
224 endpoint, err := HcnCreateTestEndpoint(network)
225 if err != nil {
226 t.Fatal(err)
227 }
228
229 loadBalancer, err := AddLoadBalancer([]HostComputeEndpoint{*endpoint}, LoadBalancerFlagsNone, LoadBalancerPortMappingFlagsILB, "10.0.0.1", []string{"1.1.1.2", "1.1.1.3"}, 6, 8080, 80)
230 if err != nil {
231 t.Fatal(err)
232 }
233 foundLB, err := GetLoadBalancerByID(loadBalancer.Id)
234 if err != nil {
235 t.Fatal(err)
236 }
237 if foundLB == nil {
238 t.Fatal(fmt.Errorf("No loadBalancer found"))
239 }
240
241 foundFlags := foundLB.PortMappings[0].Flags
242 if foundFlags&LoadBalancerPortMappingFlagsILB == 0 {
243 t.Fatal(fmt.Errorf("Loadbalancer is not ILB"))
244 }
245
246 err = loadBalancer.Delete()
247 if err != nil {
248 t.Fatal(err)
249 }
250 err = endpoint.Delete()
251 if err != nil {
252 t.Fatal(err)
253 }
254 err = network.Delete()
255 if err != nil {
256 t.Fatal(err)
257 }
258 }
259
View as plain text