OLD | NEW |
1 // Nova double testing service - internal direct API tests | 1 // Nova double testing service - internal direct API tests |
2 | 2 |
3 package novaservice | 3 package novaservice |
4 | 4 |
5 import ( | 5 import ( |
6 "fmt" | 6 "fmt" |
7 . "launchpad.net/gocheck" | 7 . "launchpad.net/gocheck" |
8 "launchpad.net/goose/nova" | 8 "launchpad.net/goose/nova" |
9 "strings" | 9 "strings" |
10 ) | 10 ) |
11 | 11 |
12 type NovaServiceSuite struct { | 12 type NovaSuite struct { |
13 » service NovaService | 13 » service *Nova |
14 endpointNoVersion string | 14 endpointNoVersion string |
15 endpoint string | 15 endpoint string |
16 } | 16 } |
17 | 17 |
18 var baseURL = "/v2/" | 18 var baseURL = "/v2/" |
19 var token = "token" | 19 var token = "token" |
20 var hostname = "http://example.com/" | 20 var hostname = "http://example.com/" |
21 | 21 |
22 var _ = Suite(&NovaServiceSuite{}) | 22 var _ = Suite(&NovaSuite{}) |
23 | 23 |
24 func (s *NovaServiceSuite) SetUpSuite(c *C) { | 24 func (s *NovaSuite) SetUpSuite(c *C) { |
25 s.service = New(hostname, baseURL, token) | 25 s.service = New(hostname, baseURL, token) |
26 s.endpointNoVersion = hostname + token | 26 s.endpointNoVersion = hostname + token |
27 s.endpoint = hostname + strings.TrimLeft(baseURL, "/") + token | 27 s.endpoint = hostname + strings.TrimLeft(baseURL, "/") + token |
28 } | 28 } |
29 | 29 |
30 func (s *NovaServiceSuite) ensureNoFlavor(c *C, flavor nova.FlavorDetail) { | 30 func (s *NovaSuite) ensureNoFlavor(c *C, flavor nova.FlavorDetail) { |
31 » _, err := s.service.getFlavor(flavor.Id) | 31 » _, err := s.service.flavor(flavor.Id) |
32 c.Assert(err, ErrorMatches, fmt.Sprintf("no such flavor %q", flavor.Id)) | 32 c.Assert(err, ErrorMatches, fmt.Sprintf("no such flavor %q", flavor.Id)) |
33 } | 33 } |
34 | 34 |
35 func (s *NovaServiceSuite) ensureNoServer(c *C, server nova.ServerDetail) { | 35 func (s *NovaSuite) ensureNoServer(c *C, server nova.ServerDetail) { |
36 » _, err := s.service.getServer(server.Id) | 36 » _, err := s.service.server(server.Id) |
37 c.Assert(err, ErrorMatches, fmt.Sprintf("no such server %q", server.Id)) | 37 c.Assert(err, ErrorMatches, fmt.Sprintf("no such server %q", server.Id)) |
38 } | 38 } |
39 | 39 |
40 func (s *NovaServiceSuite) ensureNoGroup(c *C, group nova.SecurityGroup) { | 40 func (s *NovaSuite) ensureNoGroup(c *C, group nova.SecurityGroup) { |
41 » _, err := s.service.getSecurityGroup(group.Id) | 41 » _, err := s.service.securityGroup(group.Id) |
42 c.Assert(err, ErrorMatches, fmt.Sprintf("no such security group %d", gro
up.Id)) | 42 c.Assert(err, ErrorMatches, fmt.Sprintf("no such security group %d", gro
up.Id)) |
43 } | 43 } |
44 | 44 |
45 func (s *NovaServiceSuite) ensureNoRule(c *C, rule nova.SecurityGroupRule) { | 45 func (s *NovaSuite) ensureNoRule(c *C, rule nova.SecurityGroupRule) { |
46 » _, err := s.service.getSecurityGroupRule(rule.Id) | 46 » _, err := s.service.securityGroupRule(rule.Id) |
47 c.Assert(err, ErrorMatches, fmt.Sprintf("no such security group rule %d"
, rule.Id)) | 47 c.Assert(err, ErrorMatches, fmt.Sprintf("no such security group rule %d"
, rule.Id)) |
48 } | 48 } |
49 | 49 |
50 func (s *NovaServiceSuite) ensureNoIP(c *C, ip nova.FloatingIP) { | 50 func (s *NovaSuite) ensureNoIP(c *C, ip nova.FloatingIP) { |
51 » _, err := s.service.getFloatingIP(ip.Id) | 51 » _, err := s.service.floatingIP(ip.Id) |
52 c.Assert(err, ErrorMatches, fmt.Sprintf("no such floating IP %d", ip.Id)
) | 52 c.Assert(err, ErrorMatches, fmt.Sprintf("no such floating IP %d", ip.Id)
) |
53 } | 53 } |
54 | 54 |
55 func (s *NovaServiceSuite) createFlavor(c *C, flavor nova.FlavorDetail) { | 55 func (s *NovaSuite) createFlavor(c *C, flavor nova.FlavorDetail) { |
56 s.ensureNoFlavor(c, flavor) | 56 s.ensureNoFlavor(c, flavor) |
57 err := s.service.addFlavor(flavor) | 57 err := s.service.addFlavor(flavor) |
58 c.Assert(err, IsNil) | 58 c.Assert(err, IsNil) |
59 } | 59 } |
60 | 60 |
61 func (s *NovaServiceSuite) createServer(c *C, server nova.ServerDetail) { | 61 func (s *NovaSuite) createServer(c *C, server nova.ServerDetail) { |
62 s.ensureNoServer(c, server) | 62 s.ensureNoServer(c, server) |
63 err := s.service.addServer(server) | 63 err := s.service.addServer(server) |
64 c.Assert(err, IsNil) | 64 c.Assert(err, IsNil) |
65 } | 65 } |
66 | 66 |
67 func (s *NovaServiceSuite) createGroup(c *C, group nova.SecurityGroup) { | 67 func (s *NovaSuite) createGroup(c *C, group nova.SecurityGroup) { |
68 s.ensureNoGroup(c, group) | 68 s.ensureNoGroup(c, group) |
69 err := s.service.addSecurityGroup(group) | 69 err := s.service.addSecurityGroup(group) |
70 c.Assert(err, IsNil) | 70 c.Assert(err, IsNil) |
71 } | 71 } |
72 | 72 |
73 func (s *NovaServiceSuite) createIP(c *C, ip nova.FloatingIP) { | 73 func (s *NovaSuite) createIP(c *C, ip nova.FloatingIP) { |
74 s.ensureNoIP(c, ip) | 74 s.ensureNoIP(c, ip) |
75 err := s.service.addFloatingIP(ip) | 75 err := s.service.addFloatingIP(ip) |
76 c.Assert(err, IsNil) | 76 c.Assert(err, IsNil) |
77 } | 77 } |
78 | 78 |
79 func (s *NovaServiceSuite) deleteFlavor(c *C, flavor nova.FlavorDetail) { | 79 func (s *NovaSuite) deleteFlavor(c *C, flavor nova.FlavorDetail) { |
80 err := s.service.removeFlavor(flavor.Id) | 80 err := s.service.removeFlavor(flavor.Id) |
81 c.Assert(err, IsNil) | 81 c.Assert(err, IsNil) |
82 s.ensureNoFlavor(c, flavor) | 82 s.ensureNoFlavor(c, flavor) |
83 } | 83 } |
84 | 84 |
85 func (s *NovaServiceSuite) deleteServer(c *C, server nova.ServerDetail) { | 85 func (s *NovaSuite) deleteServer(c *C, server nova.ServerDetail) { |
86 err := s.service.removeServer(server.Id) | 86 err := s.service.removeServer(server.Id) |
87 c.Assert(err, IsNil) | 87 c.Assert(err, IsNil) |
88 s.ensureNoServer(c, server) | 88 s.ensureNoServer(c, server) |
89 } | 89 } |
90 | 90 |
91 func (s *NovaServiceSuite) deleteGroup(c *C, group nova.SecurityGroup) { | 91 func (s *NovaSuite) deleteGroup(c *C, group nova.SecurityGroup) { |
92 err := s.service.removeSecurityGroup(group.Id) | 92 err := s.service.removeSecurityGroup(group.Id) |
93 c.Assert(err, IsNil) | 93 c.Assert(err, IsNil) |
94 s.ensureNoGroup(c, group) | 94 s.ensureNoGroup(c, group) |
95 } | 95 } |
96 | 96 |
97 func (s *NovaServiceSuite) deleteRule(c *C, rule nova.SecurityGroupRule) { | 97 func (s *NovaSuite) deleteRule(c *C, rule nova.SecurityGroupRule) { |
98 err := s.service.removeSecurityGroupRule(rule.Id) | 98 err := s.service.removeSecurityGroupRule(rule.Id) |
99 c.Assert(err, IsNil) | 99 c.Assert(err, IsNil) |
100 s.ensureNoRule(c, rule) | 100 s.ensureNoRule(c, rule) |
101 } | 101 } |
102 | 102 |
103 func (s *NovaServiceSuite) deleteIP(c *C, ip nova.FloatingIP) { | 103 func (s *NovaSuite) deleteIP(c *C, ip nova.FloatingIP) { |
104 err := s.service.removeFloatingIP(ip.Id) | 104 err := s.service.removeFloatingIP(ip.Id) |
105 c.Assert(err, IsNil) | 105 c.Assert(err, IsNil) |
106 s.ensureNoIP(c, ip) | 106 s.ensureNoIP(c, ip) |
107 } | 107 } |
108 | 108 |
109 func (s *NovaServiceSuite) TestAddRemoveFlavor(c *C) { | 109 func (s *NovaSuite) TestAddRemoveFlavor(c *C) { |
110 flavor := nova.FlavorDetail{Id: "test"} | 110 flavor := nova.FlavorDetail{Id: "test"} |
111 s.createFlavor(c, flavor) | 111 s.createFlavor(c, flavor) |
112 s.deleteFlavor(c, flavor) | 112 s.deleteFlavor(c, flavor) |
113 } | 113 } |
114 | 114 |
115 func (s *NovaServiceSuite) TestBuildLinksAndAddFlavor(c *C) { | 115 func (s *NovaSuite) TestBuildLinksAndAddFlavor(c *C) { |
116 flavor := nova.FlavorDetail{Id: "test"} | 116 flavor := nova.FlavorDetail{Id: "test"} |
117 s.service.buildFlavorLinks(&flavor) | 117 s.service.buildFlavorLinks(&flavor) |
118 s.createFlavor(c, flavor) | 118 s.createFlavor(c, flavor) |
119 defer s.deleteFlavor(c, flavor) | 119 defer s.deleteFlavor(c, flavor) |
120 » fl, _ := s.service.getFlavor(flavor.Id) | 120 » fl, _ := s.service.flavor(flavor.Id) |
121 url := "/flavors/" + flavor.Id | 121 url := "/flavors/" + flavor.Id |
122 links := []nova.Link{ | 122 links := []nova.Link{ |
123 nova.Link{Href: s.endpoint + url, Rel: "self"}, | 123 nova.Link{Href: s.endpoint + url, Rel: "self"}, |
124 nova.Link{Href: s.endpointNoVersion + url, Rel: "bookmark"}, | 124 nova.Link{Href: s.endpointNoVersion + url, Rel: "bookmark"}, |
125 } | 125 } |
126 c.Assert(fl.Links, DeepEquals, links) | 126 c.Assert(fl.Links, DeepEquals, links) |
127 } | 127 } |
128 | 128 |
129 func (s *NovaServiceSuite) TestAddFlavorWithLinks(c *C) { | 129 func (s *NovaSuite) TestAddFlavorWithLinks(c *C) { |
130 flavor := nova.FlavorDetail{ | 130 flavor := nova.FlavorDetail{ |
131 Id: "test", | 131 Id: "test", |
132 Links: []nova.Link{ | 132 Links: []nova.Link{ |
133 nova.Link{Href: "href", Rel: "rel"}, | 133 nova.Link{Href: "href", Rel: "rel"}, |
134 }, | 134 }, |
135 } | 135 } |
136 s.createFlavor(c, flavor) | 136 s.createFlavor(c, flavor) |
137 defer s.deleteFlavor(c, flavor) | 137 defer s.deleteFlavor(c, flavor) |
138 » fl, _ := s.service.getFlavor(flavor.Id) | 138 » fl, _ := s.service.flavor(flavor.Id) |
139 c.Assert(*fl, DeepEquals, flavor) | 139 c.Assert(*fl, DeepEquals, flavor) |
140 } | 140 } |
141 | 141 |
142 func (s *NovaServiceSuite) TestAddFlavorTwiceFails(c *C) { | 142 func (s *NovaSuite) TestAddFlavorTwiceFails(c *C) { |
143 flavor := nova.FlavorDetail{Id: "test"} | 143 flavor := nova.FlavorDetail{Id: "test"} |
144 s.createFlavor(c, flavor) | 144 s.createFlavor(c, flavor) |
145 defer s.deleteFlavor(c, flavor) | 145 defer s.deleteFlavor(c, flavor) |
146 err := s.service.addFlavor(flavor) | 146 err := s.service.addFlavor(flavor) |
147 c.Assert(err, ErrorMatches, `a flavor with id "test" already exists`) | 147 c.Assert(err, ErrorMatches, `a flavor with id "test" already exists`) |
148 } | 148 } |
149 | 149 |
150 func (s *NovaServiceSuite) TestRemoveFlavorTwiceFails(c *C) { | 150 func (s *NovaSuite) TestRemoveFlavorTwiceFails(c *C) { |
151 flavor := nova.FlavorDetail{Id: "test"} | 151 flavor := nova.FlavorDetail{Id: "test"} |
152 s.createFlavor(c, flavor) | 152 s.createFlavor(c, flavor) |
153 s.deleteFlavor(c, flavor) | 153 s.deleteFlavor(c, flavor) |
154 err := s.service.removeFlavor(flavor.Id) | 154 err := s.service.removeFlavor(flavor.Id) |
155 c.Assert(err, ErrorMatches, `no such flavor "test"`) | 155 c.Assert(err, ErrorMatches, `no such flavor "test"`) |
156 } | 156 } |
157 | 157 |
158 func (s *NovaServiceSuite) TestAllFlavors(c *C) { | 158 func (s *NovaSuite) TestAllFlavors(c *C) { |
159 flavors := s.service.allFlavors() | 159 flavors := s.service.allFlavors() |
160 c.Assert(flavors, HasLen, 0) | 160 c.Assert(flavors, HasLen, 0) |
161 flavors = []nova.FlavorDetail{ | 161 flavors = []nova.FlavorDetail{ |
162 nova.FlavorDetail{Id: "fl1"}, | 162 nova.FlavorDetail{Id: "fl1"}, |
163 nova.FlavorDetail{Id: "fl2"}, | 163 nova.FlavorDetail{Id: "fl2"}, |
164 } | 164 } |
165 s.createFlavor(c, flavors[0]) | 165 s.createFlavor(c, flavors[0]) |
166 defer s.deleteFlavor(c, flavors[0]) | 166 defer s.deleteFlavor(c, flavors[0]) |
167 s.createFlavor(c, flavors[1]) | 167 s.createFlavor(c, flavors[1]) |
168 defer s.deleteFlavor(c, flavors[1]) | 168 defer s.deleteFlavor(c, flavors[1]) |
169 fl := s.service.allFlavors() | 169 fl := s.service.allFlavors() |
170 c.Assert(fl, HasLen, len(flavors)) | 170 c.Assert(fl, HasLen, len(flavors)) |
171 if fl[0].Id != flavors[0].Id { | 171 if fl[0].Id != flavors[0].Id { |
172 fl[0], fl[1] = fl[1], fl[0] | 172 fl[0], fl[1] = fl[1], fl[0] |
173 } | 173 } |
174 c.Assert(fl, DeepEquals, flavors) | 174 c.Assert(fl, DeepEquals, flavors) |
175 } | 175 } |
176 | 176 |
177 func (s *NovaServiceSuite) TestAllFlavorsAsEntities(c *C) { | 177 func (s *NovaSuite) TestAllFlavorsAsEntities(c *C) { |
178 entities := s.service.allFlavorsAsEntities() | 178 entities := s.service.allFlavorsAsEntities() |
179 c.Assert(entities, HasLen, 0) | 179 c.Assert(entities, HasLen, 0) |
180 entities = []nova.Entity{ | 180 entities = []nova.Entity{ |
181 nova.Entity{Id: "fl1"}, | 181 nova.Entity{Id: "fl1"}, |
182 nova.Entity{Id: "fl2"}, | 182 nova.Entity{Id: "fl2"}, |
183 } | 183 } |
184 flavors := []nova.FlavorDetail{ | 184 flavors := []nova.FlavorDetail{ |
185 nova.FlavorDetail{Id: entities[0].Id}, | 185 nova.FlavorDetail{Id: entities[0].Id}, |
186 nova.FlavorDetail{Id: entities[1].Id}, | 186 nova.FlavorDetail{Id: entities[1].Id}, |
187 } | 187 } |
188 s.createFlavor(c, flavors[0]) | 188 s.createFlavor(c, flavors[0]) |
189 defer s.deleteFlavor(c, flavors[0]) | 189 defer s.deleteFlavor(c, flavors[0]) |
190 s.createFlavor(c, flavors[1]) | 190 s.createFlavor(c, flavors[1]) |
191 defer s.deleteFlavor(c, flavors[1]) | 191 defer s.deleteFlavor(c, flavors[1]) |
192 ent := s.service.allFlavorsAsEntities() | 192 ent := s.service.allFlavorsAsEntities() |
193 c.Assert(ent, HasLen, len(entities)) | 193 c.Assert(ent, HasLen, len(entities)) |
194 if ent[0].Id != entities[0].Id { | 194 if ent[0].Id != entities[0].Id { |
195 ent[0], ent[1] = ent[1], ent[0] | 195 ent[0], ent[1] = ent[1], ent[0] |
196 } | 196 } |
197 c.Assert(ent, DeepEquals, entities) | 197 c.Assert(ent, DeepEquals, entities) |
198 } | 198 } |
199 | 199 |
200 func (s *NovaServiceSuite) TestGetFlavor(c *C) { | 200 func (s *NovaSuite) TestGetFlavor(c *C) { |
201 flavor := nova.FlavorDetail{ | 201 flavor := nova.FlavorDetail{ |
202 Id: "test", | 202 Id: "test", |
203 Name: "flavor", | 203 Name: "flavor", |
204 RAM: 128, | 204 RAM: 128, |
205 VCPUs: 2, | 205 VCPUs: 2, |
206 Disk: 123, | 206 Disk: 123, |
207 } | 207 } |
208 s.createFlavor(c, flavor) | 208 s.createFlavor(c, flavor) |
209 defer s.deleteFlavor(c, flavor) | 209 defer s.deleteFlavor(c, flavor) |
210 » fl, _ := s.service.getFlavor(flavor.Id) | 210 » fl, _ := s.service.flavor(flavor.Id) |
211 c.Assert(*fl, DeepEquals, flavor) | 211 c.Assert(*fl, DeepEquals, flavor) |
212 } | 212 } |
213 | 213 |
214 func (s *NovaServiceSuite) TestGetFlavorAsEntity(c *C) { | 214 func (s *NovaSuite) TestGetFlavorAsEntity(c *C) { |
215 entity := nova.Entity{ | 215 entity := nova.Entity{ |
216 Id: "test", | 216 Id: "test", |
217 Name: "flavor", | 217 Name: "flavor", |
218 } | 218 } |
219 flavor := nova.FlavorDetail{ | 219 flavor := nova.FlavorDetail{ |
220 Id: entity.Id, | 220 Id: entity.Id, |
221 Name: entity.Name, | 221 Name: entity.Name, |
222 } | 222 } |
223 s.createFlavor(c, flavor) | 223 s.createFlavor(c, flavor) |
224 defer s.deleteFlavor(c, flavor) | 224 defer s.deleteFlavor(c, flavor) |
225 » ent, _ := s.service.getFlavorAsEntity(flavor.Id) | 225 » ent, _ := s.service.flavorAsEntity(flavor.Id) |
226 c.Assert(*ent, DeepEquals, entity) | 226 c.Assert(*ent, DeepEquals, entity) |
227 } | 227 } |
228 | 228 |
229 func (s *NovaServiceSuite) TestAddRemoveServer(c *C) { | 229 func (s *NovaSuite) TestAddRemoveServer(c *C) { |
230 server := nova.ServerDetail{Id: "test"} | 230 server := nova.ServerDetail{Id: "test"} |
231 s.createServer(c, server) | 231 s.createServer(c, server) |
232 s.deleteServer(c, server) | 232 s.deleteServer(c, server) |
233 } | 233 } |
234 | 234 |
235 func (s *NovaServiceSuite) TestBuildLinksAndAddServer(c *C) { | 235 func (s *NovaSuite) TestBuildLinksAndAddServer(c *C) { |
236 server := nova.ServerDetail{Id: "test"} | 236 server := nova.ServerDetail{Id: "test"} |
237 s.service.buildServerLinks(&server) | 237 s.service.buildServerLinks(&server) |
238 s.createServer(c, server) | 238 s.createServer(c, server) |
239 defer s.deleteServer(c, server) | 239 defer s.deleteServer(c, server) |
240 » sr, _ := s.service.getServer(server.Id) | 240 » sr, _ := s.service.server(server.Id) |
241 url := "/servers/" + server.Id | 241 url := "/servers/" + server.Id |
242 links := []nova.Link{ | 242 links := []nova.Link{ |
243 nova.Link{Href: s.endpoint + url, Rel: "self"}, | 243 nova.Link{Href: s.endpoint + url, Rel: "self"}, |
244 nova.Link{Href: s.endpointNoVersion + url, Rel: "bookmark"}, | 244 nova.Link{Href: s.endpointNoVersion + url, Rel: "bookmark"}, |
245 } | 245 } |
246 c.Assert(sr.Links, DeepEquals, links) | 246 c.Assert(sr.Links, DeepEquals, links) |
247 } | 247 } |
248 | 248 |
249 func (s *NovaServiceSuite) TestAddServerWithLinks(c *C) { | 249 func (s *NovaSuite) TestAddServerWithLinks(c *C) { |
250 server := nova.ServerDetail{ | 250 server := nova.ServerDetail{ |
251 Id: "test", | 251 Id: "test", |
252 Links: []nova.Link{ | 252 Links: []nova.Link{ |
253 nova.Link{Href: "href", Rel: "rel"}, | 253 nova.Link{Href: "href", Rel: "rel"}, |
254 }, | 254 }, |
255 } | 255 } |
256 s.createServer(c, server) | 256 s.createServer(c, server) |
257 defer s.deleteServer(c, server) | 257 defer s.deleteServer(c, server) |
258 » sr, _ := s.service.getServer(server.Id) | 258 » sr, _ := s.service.server(server.Id) |
259 c.Assert(*sr, DeepEquals, server) | 259 c.Assert(*sr, DeepEquals, server) |
260 } | 260 } |
261 | 261 |
262 func (s *NovaServiceSuite) TestAddServerTwiceFails(c *C) { | 262 func (s *NovaSuite) TestAddServerTwiceFails(c *C) { |
263 server := nova.ServerDetail{Id: "test"} | 263 server := nova.ServerDetail{Id: "test"} |
264 s.createServer(c, server) | 264 s.createServer(c, server) |
265 defer s.deleteServer(c, server) | 265 defer s.deleteServer(c, server) |
266 err := s.service.addServer(server) | 266 err := s.service.addServer(server) |
267 c.Assert(err, ErrorMatches, `a server with id "test" already exists`) | 267 c.Assert(err, ErrorMatches, `a server with id "test" already exists`) |
268 } | 268 } |
269 | 269 |
270 func (s *NovaServiceSuite) TestRemoveServerTwiceFails(c *C) { | 270 func (s *NovaSuite) TestRemoveServerTwiceFails(c *C) { |
271 server := nova.ServerDetail{Id: "test"} | 271 server := nova.ServerDetail{Id: "test"} |
272 s.createServer(c, server) | 272 s.createServer(c, server) |
273 s.deleteServer(c, server) | 273 s.deleteServer(c, server) |
274 err := s.service.removeServer(server.Id) | 274 err := s.service.removeServer(server.Id) |
275 c.Assert(err, ErrorMatches, `no such server "test"`) | 275 c.Assert(err, ErrorMatches, `no such server "test"`) |
276 } | 276 } |
277 | 277 |
278 func (s *NovaServiceSuite) TestAllServers(c *C) { | 278 func (s *NovaSuite) TestAllServers(c *C) { |
279 servers := s.service.allServers() | 279 servers := s.service.allServers() |
280 c.Assert(servers, HasLen, 0) | 280 c.Assert(servers, HasLen, 0) |
281 servers = []nova.ServerDetail{ | 281 servers = []nova.ServerDetail{ |
282 nova.ServerDetail{Id: "sr1"}, | 282 nova.ServerDetail{Id: "sr1"}, |
283 nova.ServerDetail{Id: "sr2"}, | 283 nova.ServerDetail{Id: "sr2"}, |
284 } | 284 } |
285 s.createServer(c, servers[0]) | 285 s.createServer(c, servers[0]) |
286 defer s.deleteServer(c, servers[1]) | 286 defer s.deleteServer(c, servers[1]) |
287 s.createServer(c, servers[1]) | 287 s.createServer(c, servers[1]) |
288 defer s.deleteServer(c, servers[0]) | 288 defer s.deleteServer(c, servers[0]) |
289 sr := s.service.allServers() | 289 sr := s.service.allServers() |
290 c.Assert(sr, HasLen, len(servers)) | 290 c.Assert(sr, HasLen, len(servers)) |
291 if sr[0].Id != servers[0].Id { | 291 if sr[0].Id != servers[0].Id { |
292 sr[0], sr[1] = sr[1], sr[0] | 292 sr[0], sr[1] = sr[1], sr[0] |
293 } | 293 } |
294 c.Assert(sr, DeepEquals, servers) | 294 c.Assert(sr, DeepEquals, servers) |
295 } | 295 } |
296 | 296 |
297 func (s *NovaServiceSuite) TestAllServersAsEntities(c *C) { | 297 func (s *NovaSuite) TestAllServersAsEntities(c *C) { |
298 entities := s.service.allServersAsEntities() | 298 entities := s.service.allServersAsEntities() |
299 c.Assert(entities, HasLen, 0) | 299 c.Assert(entities, HasLen, 0) |
300 entities = []nova.Entity{ | 300 entities = []nova.Entity{ |
301 nova.Entity{Id: "sr1"}, | 301 nova.Entity{Id: "sr1"}, |
302 nova.Entity{Id: "sr2"}, | 302 nova.Entity{Id: "sr2"}, |
303 } | 303 } |
304 servers := []nova.ServerDetail{ | 304 servers := []nova.ServerDetail{ |
305 nova.ServerDetail{Id: entities[0].Id}, | 305 nova.ServerDetail{Id: entities[0].Id}, |
306 nova.ServerDetail{Id: entities[1].Id}, | 306 nova.ServerDetail{Id: entities[1].Id}, |
307 } | 307 } |
308 s.createServer(c, servers[0]) | 308 s.createServer(c, servers[0]) |
309 defer s.deleteServer(c, servers[0]) | 309 defer s.deleteServer(c, servers[0]) |
310 s.createServer(c, servers[1]) | 310 s.createServer(c, servers[1]) |
311 defer s.deleteServer(c, servers[1]) | 311 defer s.deleteServer(c, servers[1]) |
312 ent := s.service.allServersAsEntities() | 312 ent := s.service.allServersAsEntities() |
313 c.Assert(ent, HasLen, len(entities)) | 313 c.Assert(ent, HasLen, len(entities)) |
314 if ent[0].Id != entities[0].Id { | 314 if ent[0].Id != entities[0].Id { |
315 ent[0], ent[1] = ent[1], ent[0] | 315 ent[0], ent[1] = ent[1], ent[0] |
316 } | 316 } |
317 c.Assert(ent, DeepEquals, entities) | 317 c.Assert(ent, DeepEquals, entities) |
318 } | 318 } |
319 | 319 |
320 func (s *NovaServiceSuite) TestGetServer(c *C) { | 320 func (s *NovaSuite) TestGetServer(c *C) { |
321 server := nova.ServerDetail{ | 321 server := nova.ServerDetail{ |
322 Id: "test", | 322 Id: "test", |
323 Name: "server", | 323 Name: "server", |
324 AddressIPv4: "1.2.3.4", | 324 AddressIPv4: "1.2.3.4", |
325 AddressIPv6: "1::fff", | 325 AddressIPv6: "1::fff", |
326 Created: "1/1/1", | 326 Created: "1/1/1", |
327 Flavor: nova.Entity{Id: "fl1", Name: "flavor1"}, | 327 Flavor: nova.Entity{Id: "fl1", Name: "flavor1"}, |
328 Image: nova.Entity{Id: "im1", Name: "image1"}, | 328 Image: nova.Entity{Id: "im1", Name: "image1"}, |
329 HostId: "myhost", | 329 HostId: "myhost", |
330 Progress: 123, | 330 Progress: 123, |
331 Status: "st", | 331 Status: "st", |
332 TenantId: "tenant", | 332 TenantId: "tenant", |
333 Updated: "2/3/4", | 333 Updated: "2/3/4", |
334 UserId: "user", | 334 UserId: "user", |
335 } | 335 } |
336 s.createServer(c, server) | 336 s.createServer(c, server) |
337 defer s.deleteServer(c, server) | 337 defer s.deleteServer(c, server) |
338 » sr, _ := s.service.getServer(server.Id) | 338 » sr, _ := s.service.server(server.Id) |
339 c.Assert(*sr, DeepEquals, server) | 339 c.Assert(*sr, DeepEquals, server) |
340 } | 340 } |
341 | 341 |
342 func (s *NovaServiceSuite) TestGetServerAsEntity(c *C) { | 342 func (s *NovaSuite) TestGetServerAsEntity(c *C) { |
343 entity := nova.Entity{ | 343 entity := nova.Entity{ |
344 Id: "test", | 344 Id: "test", |
345 Name: "server", | 345 Name: "server", |
346 } | 346 } |
347 server := nova.ServerDetail{ | 347 server := nova.ServerDetail{ |
348 Id: entity.Id, | 348 Id: entity.Id, |
349 Name: entity.Name, | 349 Name: entity.Name, |
350 } | 350 } |
351 s.createServer(c, server) | 351 s.createServer(c, server) |
352 defer s.deleteServer(c, server) | 352 defer s.deleteServer(c, server) |
353 » ent, _ := s.service.getServerAsEntity(server.Id) | 353 » ent, _ := s.service.serverAsEntity(server.Id) |
354 c.Assert(*ent, DeepEquals, entity) | 354 c.Assert(*ent, DeepEquals, entity) |
355 } | 355 } |
356 | 356 |
357 func (s *NovaServiceSuite) TestAddRemoveSecurityGroup(c *C) { | 357 func (s *NovaSuite) TestAddRemoveSecurityGroup(c *C) { |
358 group := nova.SecurityGroup{Id: 1} | 358 group := nova.SecurityGroup{Id: 1} |
359 s.createGroup(c, group) | 359 s.createGroup(c, group) |
360 s.deleteGroup(c, group) | 360 s.deleteGroup(c, group) |
361 } | 361 } |
362 | 362 |
363 func (s *NovaServiceSuite) TestAddSecurityGroupWithRules(c *C) { | 363 func (s *NovaSuite) TestAddSecurityGroupWithRules(c *C) { |
364 group := nova.SecurityGroup{ | 364 group := nova.SecurityGroup{ |
365 Id: 1, | 365 Id: 1, |
366 Name: "test", | 366 Name: "test", |
367 Rules: []nova.SecurityGroupRule{ | 367 Rules: []nova.SecurityGroupRule{ |
368 nova.SecurityGroupRule{Id: 10, ParentGroupId: 1}, | 368 nova.SecurityGroupRule{Id: 10, ParentGroupId: 1}, |
369 nova.SecurityGroupRule{Id: 20, ParentGroupId: 1}, | 369 nova.SecurityGroupRule{Id: 20, ParentGroupId: 1}, |
370 }, | 370 }, |
371 } | 371 } |
372 s.createGroup(c, group) | 372 s.createGroup(c, group) |
373 defer s.deleteGroup(c, group) | 373 defer s.deleteGroup(c, group) |
374 » gr, _ := s.service.getSecurityGroup(group.Id) | 374 » gr, _ := s.service.securityGroup(group.Id) |
375 c.Assert(*gr, DeepEquals, group) | 375 c.Assert(*gr, DeepEquals, group) |
376 } | 376 } |
377 | 377 |
378 func (s *NovaServiceSuite) TestAddSecurityGroupTwiceFails(c *C) { | 378 func (s *NovaSuite) TestAddSecurityGroupTwiceFails(c *C) { |
379 group := nova.SecurityGroup{Id: 1, Name: "test"} | 379 group := nova.SecurityGroup{Id: 1, Name: "test"} |
380 s.createGroup(c, group) | 380 s.createGroup(c, group) |
381 defer s.deleteGroup(c, group) | 381 defer s.deleteGroup(c, group) |
382 err := s.service.addSecurityGroup(group) | 382 err := s.service.addSecurityGroup(group) |
383 c.Assert(err, ErrorMatches, "a security group with id 1 already exists") | 383 c.Assert(err, ErrorMatches, "a security group with id 1 already exists") |
384 } | 384 } |
385 | 385 |
386 func (s *NovaServiceSuite) TestRemoveSecurityGroupTwiceFails(c *C) { | 386 func (s *NovaSuite) TestRemoveSecurityGroupTwiceFails(c *C) { |
387 group := nova.SecurityGroup{Id: 1, Name: "test"} | 387 group := nova.SecurityGroup{Id: 1, Name: "test"} |
388 s.createGroup(c, group) | 388 s.createGroup(c, group) |
389 s.deleteGroup(c, group) | 389 s.deleteGroup(c, group) |
390 err := s.service.removeSecurityGroup(group.Id) | 390 err := s.service.removeSecurityGroup(group.Id) |
391 c.Assert(err, ErrorMatches, "no such security group 1") | 391 c.Assert(err, ErrorMatches, "no such security group 1") |
392 } | 392 } |
393 | 393 |
394 func (s *NovaServiceSuite) TestAllSecurityGroups(c *C) { | 394 func (s *NovaSuite) TestAllSecurityGroups(c *C) { |
395 groups := s.service.allSecurityGroups() | 395 groups := s.service.allSecurityGroups() |
396 c.Assert(groups, HasLen, 0) | 396 c.Assert(groups, HasLen, 0) |
397 groups = []nova.SecurityGroup{ | 397 groups = []nova.SecurityGroup{ |
398 nova.SecurityGroup{Id: 1, Name: "one"}, | 398 nova.SecurityGroup{Id: 1, Name: "one"}, |
399 nova.SecurityGroup{Id: 2, Name: "two"}, | 399 nova.SecurityGroup{Id: 2, Name: "two"}, |
400 } | 400 } |
401 s.createGroup(c, groups[0]) | 401 s.createGroup(c, groups[0]) |
402 defer s.deleteGroup(c, groups[0]) | 402 defer s.deleteGroup(c, groups[0]) |
403 s.createGroup(c, groups[1]) | 403 s.createGroup(c, groups[1]) |
404 defer s.deleteGroup(c, groups[1]) | 404 defer s.deleteGroup(c, groups[1]) |
405 gr := s.service.allSecurityGroups() | 405 gr := s.service.allSecurityGroups() |
406 c.Assert(gr, HasLen, len(groups)) | 406 c.Assert(gr, HasLen, len(groups)) |
407 if gr[0].Id != groups[0].Id { | 407 if gr[0].Id != groups[0].Id { |
408 gr[0], gr[1] = gr[1], gr[0] | 408 gr[0], gr[1] = gr[1], gr[0] |
409 } | 409 } |
410 c.Assert(gr, DeepEquals, groups) | 410 c.Assert(gr, DeepEquals, groups) |
411 } | 411 } |
412 | 412 |
413 func (s *NovaServiceSuite) TestGetSecurityGroup(c *C) { | 413 func (s *NovaSuite) TestGetSecurityGroup(c *C) { |
414 group := nova.SecurityGroup{ | 414 group := nova.SecurityGroup{ |
415 Id: 42, | 415 Id: 42, |
416 TenantId: "tenant", | 416 TenantId: "tenant", |
417 Name: "group", | 417 Name: "group", |
418 Description: "desc", | 418 Description: "desc", |
419 Rules: []nova.SecurityGroupRule{}, | 419 Rules: []nova.SecurityGroupRule{}, |
420 } | 420 } |
421 s.createGroup(c, group) | 421 s.createGroup(c, group) |
422 defer s.deleteGroup(c, group) | 422 defer s.deleteGroup(c, group) |
423 » gr, _ := s.service.getSecurityGroup(group.Id) | 423 » gr, _ := s.service.securityGroup(group.Id) |
424 c.Assert(*gr, DeepEquals, group) | 424 c.Assert(*gr, DeepEquals, group) |
425 } | 425 } |
426 | 426 |
427 func (s *NovaServiceSuite) TestAddHasRemoveSecurityGroupRule(c *C) { | 427 func (s *NovaSuite) TestAddHasRemoveSecurityGroupRule(c *C) { |
428 group := nova.SecurityGroup{Id: 1} | 428 group := nova.SecurityGroup{Id: 1} |
429 ri := nova.RuleInfo{ParentGroupId: group.Id} | 429 ri := nova.RuleInfo{ParentGroupId: group.Id} |
430 rule := nova.SecurityGroupRule{Id: 10, ParentGroupId: group.Id} | 430 rule := nova.SecurityGroupRule{Id: 10, ParentGroupId: group.Id} |
431 s.ensureNoGroup(c, group) | 431 s.ensureNoGroup(c, group) |
432 s.ensureNoRule(c, rule) | 432 s.ensureNoRule(c, rule) |
433 ok := s.service.hasSecurityGroupRule(group.Id, rule.Id) | 433 ok := s.service.hasSecurityGroupRule(group.Id, rule.Id) |
434 c.Assert(ok, Equals, false) | 434 c.Assert(ok, Equals, false) |
435 s.createGroup(c, group) | 435 s.createGroup(c, group) |
436 err := s.service.addSecurityGroupRule(rule.Id, ri) | 436 err := s.service.addSecurityGroupRule(rule.Id, ri) |
437 c.Assert(err, IsNil) | 437 c.Assert(err, IsNil) |
438 ok = s.service.hasSecurityGroupRule(group.Id, rule.Id) | 438 ok = s.service.hasSecurityGroupRule(group.Id, rule.Id) |
439 c.Assert(ok, Equals, true) | 439 c.Assert(ok, Equals, true) |
440 s.deleteGroup(c, group) | 440 s.deleteGroup(c, group) |
441 ok = s.service.hasSecurityGroupRule(-1, rule.Id) | 441 ok = s.service.hasSecurityGroupRule(-1, rule.Id) |
442 c.Assert(ok, Equals, true) | 442 c.Assert(ok, Equals, true) |
443 ok = s.service.hasSecurityGroupRule(group.Id, rule.Id) | 443 ok = s.service.hasSecurityGroupRule(group.Id, rule.Id) |
444 c.Assert(ok, Equals, false) | 444 c.Assert(ok, Equals, false) |
445 s.deleteRule(c, rule) | 445 s.deleteRule(c, rule) |
446 ok = s.service.hasSecurityGroupRule(-1, rule.Id) | 446 ok = s.service.hasSecurityGroupRule(-1, rule.Id) |
447 c.Assert(ok, Equals, false) | 447 c.Assert(ok, Equals, false) |
448 } | 448 } |
449 | 449 |
450 func (s *NovaServiceSuite) TestAddGetIngressSecurityGroupRule(c *C) { | 450 func (s *NovaSuite) TestAddGetIngressSecurityGroupRule(c *C) { |
451 group := nova.SecurityGroup{Id: 1} | 451 group := nova.SecurityGroup{Id: 1} |
452 s.createGroup(c, group) | 452 s.createGroup(c, group) |
453 defer s.deleteGroup(c, group) | 453 defer s.deleteGroup(c, group) |
454 ri := nova.RuleInfo{ | 454 ri := nova.RuleInfo{ |
455 FromPort: 1234, | 455 FromPort: 1234, |
456 ToPort: 4321, | 456 ToPort: 4321, |
457 IPProtocol: "tcp", | 457 IPProtocol: "tcp", |
458 Cidr: "1.2.3.4/5", | 458 Cidr: "1.2.3.4/5", |
459 ParentGroupId: group.Id, | 459 ParentGroupId: group.Id, |
460 } | 460 } |
461 rule := nova.SecurityGroupRule{ | 461 rule := nova.SecurityGroupRule{ |
462 Id: 10, | 462 Id: 10, |
463 ParentGroupId: group.Id, | 463 ParentGroupId: group.Id, |
464 FromPort: &ri.FromPort, | 464 FromPort: &ri.FromPort, |
465 ToPort: &ri.ToPort, | 465 ToPort: &ri.ToPort, |
466 IPProtocol: &ri.IPProtocol, | 466 IPProtocol: &ri.IPProtocol, |
467 IPRange: make(map[string]string), | 467 IPRange: make(map[string]string), |
468 } | 468 } |
469 rule.IPRange["cidr"] = ri.Cidr | 469 rule.IPRange["cidr"] = ri.Cidr |
470 s.ensureNoRule(c, rule) | 470 s.ensureNoRule(c, rule) |
471 err := s.service.addSecurityGroupRule(rule.Id, ri) | 471 err := s.service.addSecurityGroupRule(rule.Id, ri) |
472 c.Assert(err, IsNil) | 472 c.Assert(err, IsNil) |
473 defer s.deleteRule(c, rule) | 473 defer s.deleteRule(c, rule) |
474 » ru, err := s.service.getSecurityGroupRule(rule.Id) | 474 » ru, err := s.service.securityGroupRule(rule.Id) |
475 c.Assert(err, IsNil) | 475 c.Assert(err, IsNil) |
476 c.Assert(ru.Id, Equals, rule.Id) | 476 c.Assert(ru.Id, Equals, rule.Id) |
477 c.Assert(ru.ParentGroupId, Equals, rule.ParentGroupId) | 477 c.Assert(ru.ParentGroupId, Equals, rule.ParentGroupId) |
478 c.Assert(*ru.FromPort, Equals, *rule.FromPort) | 478 c.Assert(*ru.FromPort, Equals, *rule.FromPort) |
479 c.Assert(*ru.ToPort, Equals, *rule.ToPort) | 479 c.Assert(*ru.ToPort, Equals, *rule.ToPort) |
480 c.Assert(*ru.IPProtocol, Equals, *rule.IPProtocol) | 480 c.Assert(*ru.IPProtocol, Equals, *rule.IPProtocol) |
481 c.Assert(ru.IPRange, DeepEquals, rule.IPRange) | 481 c.Assert(ru.IPRange, DeepEquals, rule.IPRange) |
482 } | 482 } |
483 | 483 |
484 func (s *NovaServiceSuite) TestAddGetGroupSecurityGroupRule(c *C) { | 484 func (s *NovaSuite) TestAddGetGroupSecurityGroupRule(c *C) { |
485 srcGroup := nova.SecurityGroup{Id: 1, Name: "source", TenantId: "tenant"
} | 485 srcGroup := nova.SecurityGroup{Id: 1, Name: "source", TenantId: "tenant"
} |
486 tgtGroup := nova.SecurityGroup{Id: 2, Name: "target"} | 486 tgtGroup := nova.SecurityGroup{Id: 2, Name: "target"} |
487 s.createGroup(c, srcGroup) | 487 s.createGroup(c, srcGroup) |
488 defer s.deleteGroup(c, srcGroup) | 488 defer s.deleteGroup(c, srcGroup) |
489 s.createGroup(c, tgtGroup) | 489 s.createGroup(c, tgtGroup) |
490 defer s.deleteGroup(c, tgtGroup) | 490 defer s.deleteGroup(c, tgtGroup) |
491 ri := nova.RuleInfo{ | 491 ri := nova.RuleInfo{ |
492 FromPort: 1234, | 492 FromPort: 1234, |
493 ToPort: 4321, | 493 ToPort: 4321, |
494 IPProtocol: "tcp", | 494 IPProtocol: "tcp", |
495 GroupId: &srcGroup.Id, | 495 GroupId: &srcGroup.Id, |
496 ParentGroupId: tgtGroup.Id, | 496 ParentGroupId: tgtGroup.Id, |
497 } | 497 } |
498 rule := nova.SecurityGroupRule{ | 498 rule := nova.SecurityGroupRule{ |
499 Id: 10, | 499 Id: 10, |
500 ParentGroupId: tgtGroup.Id, | 500 ParentGroupId: tgtGroup.Id, |
501 FromPort: &ri.FromPort, | 501 FromPort: &ri.FromPort, |
502 ToPort: &ri.ToPort, | 502 ToPort: &ri.ToPort, |
503 IPProtocol: &ri.IPProtocol, | 503 IPProtocol: &ri.IPProtocol, |
504 Group: &nova.SecurityGroupRef{ | 504 Group: &nova.SecurityGroupRef{ |
505 TenantId: srcGroup.TenantId, | 505 TenantId: srcGroup.TenantId, |
506 Name: srcGroup.Name, | 506 Name: srcGroup.Name, |
507 }, | 507 }, |
508 } | 508 } |
509 s.ensureNoRule(c, rule) | 509 s.ensureNoRule(c, rule) |
510 err := s.service.addSecurityGroupRule(rule.Id, ri) | 510 err := s.service.addSecurityGroupRule(rule.Id, ri) |
511 c.Assert(err, IsNil) | 511 c.Assert(err, IsNil) |
512 defer s.deleteRule(c, rule) | 512 defer s.deleteRule(c, rule) |
513 » ru, err := s.service.getSecurityGroupRule(rule.Id) | 513 » ru, err := s.service.securityGroupRule(rule.Id) |
514 c.Assert(err, IsNil) | 514 c.Assert(err, IsNil) |
515 c.Assert(ru.Id, Equals, rule.Id) | 515 c.Assert(ru.Id, Equals, rule.Id) |
516 c.Assert(ru.ParentGroupId, Equals, rule.ParentGroupId) | 516 c.Assert(ru.ParentGroupId, Equals, rule.ParentGroupId) |
517 c.Assert(*ru.FromPort, Equals, *rule.FromPort) | 517 c.Assert(*ru.FromPort, Equals, *rule.FromPort) |
518 c.Assert(*ru.ToPort, Equals, *rule.ToPort) | 518 c.Assert(*ru.ToPort, Equals, *rule.ToPort) |
519 c.Assert(*ru.IPProtocol, Equals, *rule.IPProtocol) | 519 c.Assert(*ru.IPProtocol, Equals, *rule.IPProtocol) |
520 c.Assert(*ru.Group, DeepEquals, *rule.Group) | 520 c.Assert(*ru.Group, DeepEquals, *rule.Group) |
521 } | 521 } |
522 | 522 |
523 func (s *NovaServiceSuite) TestAddSecurityGroupRuleTwiceFails(c *C) { | 523 func (s *NovaSuite) TestAddSecurityGroupRuleTwiceFails(c *C) { |
524 group := nova.SecurityGroup{Id: 1} | 524 group := nova.SecurityGroup{Id: 1} |
525 s.createGroup(c, group) | 525 s.createGroup(c, group) |
526 defer s.deleteGroup(c, group) | 526 defer s.deleteGroup(c, group) |
527 ri := nova.RuleInfo{ParentGroupId: group.Id} | 527 ri := nova.RuleInfo{ParentGroupId: group.Id} |
528 rule := nova.SecurityGroupRule{Id: 10} | 528 rule := nova.SecurityGroupRule{Id: 10} |
529 s.ensureNoRule(c, rule) | 529 s.ensureNoRule(c, rule) |
530 err := s.service.addSecurityGroupRule(rule.Id, ri) | 530 err := s.service.addSecurityGroupRule(rule.Id, ri) |
531 c.Assert(err, IsNil) | 531 c.Assert(err, IsNil) |
532 defer s.deleteRule(c, rule) | 532 defer s.deleteRule(c, rule) |
533 err = s.service.addSecurityGroupRule(rule.Id, ri) | 533 err = s.service.addSecurityGroupRule(rule.Id, ri) |
534 c.Assert(err, ErrorMatches, "a security group rule with id 10 already ex
ists") | 534 c.Assert(err, ErrorMatches, "a security group rule with id 10 already ex
ists") |
535 } | 535 } |
536 | 536 |
537 func (s *NovaServiceSuite) TestAddSecurityGroupRuleToParentTwiceFails(c *C) { | 537 func (s *NovaSuite) TestAddSecurityGroupRuleToParentTwiceFails(c *C) { |
538 group := nova.SecurityGroup{ | 538 group := nova.SecurityGroup{ |
539 Id: 1, | 539 Id: 1, |
540 Rules: []nova.SecurityGroupRule{ | 540 Rules: []nova.SecurityGroupRule{ |
541 nova.SecurityGroupRule{Id: 10}, | 541 nova.SecurityGroupRule{Id: 10}, |
542 }, | 542 }, |
543 } | 543 } |
544 s.createGroup(c, group) | 544 s.createGroup(c, group) |
545 defer s.deleteGroup(c, group) | 545 defer s.deleteGroup(c, group) |
546 ri := nova.RuleInfo{ParentGroupId: group.Id} | 546 ri := nova.RuleInfo{ParentGroupId: group.Id} |
547 rule := nova.SecurityGroupRule{Id: 10} | 547 rule := nova.SecurityGroupRule{Id: 10} |
548 err := s.service.addSecurityGroupRule(rule.Id, ri) | 548 err := s.service.addSecurityGroupRule(rule.Id, ri) |
549 c.Assert(err, ErrorMatches, "cannot add twice rule 10 to security group
1") | 549 c.Assert(err, ErrorMatches, "cannot add twice rule 10 to security group
1") |
550 } | 550 } |
551 | 551 |
552 func (s *NovaServiceSuite) TestAddSecurityGroupRuleWithInvalidParentFails(c *C)
{ | 552 func (s *NovaSuite) TestAddSecurityGroupRuleWithInvalidParentFails(c *C) { |
553 invalidGroup := nova.SecurityGroup{Id: 1} | 553 invalidGroup := nova.SecurityGroup{Id: 1} |
554 s.ensureNoGroup(c, invalidGroup) | 554 s.ensureNoGroup(c, invalidGroup) |
555 ri := nova.RuleInfo{ParentGroupId: invalidGroup.Id} | 555 ri := nova.RuleInfo{ParentGroupId: invalidGroup.Id} |
556 rule := nova.SecurityGroupRule{Id: 10} | 556 rule := nova.SecurityGroupRule{Id: 10} |
557 s.ensureNoRule(c, rule) | 557 s.ensureNoRule(c, rule) |
558 err := s.service.addSecurityGroupRule(rule.Id, ri) | 558 err := s.service.addSecurityGroupRule(rule.Id, ri) |
559 c.Assert(err, ErrorMatches, "no such security group 1") | 559 c.Assert(err, ErrorMatches, "no such security group 1") |
560 } | 560 } |
561 | 561 |
562 func (s *NovaServiceSuite) TestAddGroupSecurityGroupRuleWithInvalidSourceFails(c
*C) { | 562 func (s *NovaSuite) TestAddGroupSecurityGroupRuleWithInvalidSourceFails(c *C) { |
563 group := nova.SecurityGroup{Id: 1} | 563 group := nova.SecurityGroup{Id: 1} |
564 s.createGroup(c, group) | 564 s.createGroup(c, group) |
565 defer s.deleteGroup(c, group) | 565 defer s.deleteGroup(c, group) |
566 invalidGroupId := 42 | 566 invalidGroupId := 42 |
567 ri := nova.RuleInfo{ | 567 ri := nova.RuleInfo{ |
568 ParentGroupId: group.Id, | 568 ParentGroupId: group.Id, |
569 GroupId: &invalidGroupId, | 569 GroupId: &invalidGroupId, |
570 } | 570 } |
571 rule := nova.SecurityGroupRule{Id: 10} | 571 rule := nova.SecurityGroupRule{Id: 10} |
572 s.ensureNoRule(c, rule) | 572 s.ensureNoRule(c, rule) |
573 err := s.service.addSecurityGroupRule(rule.Id, ri) | 573 err := s.service.addSecurityGroupRule(rule.Id, ri) |
574 c.Assert(err, ErrorMatches, "unknown source security group 42") | 574 c.Assert(err, ErrorMatches, "unknown source security group 42") |
575 } | 575 } |
576 | 576 |
577 func (s *NovaServiceSuite) TestAddSecurityGroupRuleUpdatesParent(c *C) { | 577 func (s *NovaSuite) TestAddSecurityGroupRuleUpdatesParent(c *C) { |
578 group := nova.SecurityGroup{Id: 1} | 578 group := nova.SecurityGroup{Id: 1} |
579 s.createGroup(c, group) | 579 s.createGroup(c, group) |
580 defer s.deleteGroup(c, group) | 580 defer s.deleteGroup(c, group) |
581 ri := nova.RuleInfo{ParentGroupId: group.Id} | 581 ri := nova.RuleInfo{ParentGroupId: group.Id} |
582 rule := nova.SecurityGroupRule{Id: 10, ParentGroupId: group.Id} | 582 rule := nova.SecurityGroupRule{Id: 10, ParentGroupId: group.Id} |
583 s.ensureNoRule(c, rule) | 583 s.ensureNoRule(c, rule) |
584 err := s.service.addSecurityGroupRule(rule.Id, ri) | 584 err := s.service.addSecurityGroupRule(rule.Id, ri) |
585 c.Assert(err, IsNil) | 585 c.Assert(err, IsNil) |
586 defer s.deleteRule(c, rule) | 586 defer s.deleteRule(c, rule) |
587 group.Rules = []nova.SecurityGroupRule{rule} | 587 group.Rules = []nova.SecurityGroupRule{rule} |
588 » gr, err := s.service.getSecurityGroup(group.Id) | 588 » gr, err := s.service.securityGroup(group.Id) |
589 c.Assert(err, IsNil) | 589 c.Assert(err, IsNil) |
590 c.Assert(*gr, DeepEquals, group) | 590 c.Assert(*gr, DeepEquals, group) |
591 } | 591 } |
592 | 592 |
593 func (s *NovaServiceSuite) TestRemoveSecurityGroupRuleTwiceFails(c *C) { | 593 func (s *NovaSuite) TestRemoveSecurityGroupRuleTwiceFails(c *C) { |
594 group := nova.SecurityGroup{Id: 1} | 594 group := nova.SecurityGroup{Id: 1} |
595 s.createGroup(c, group) | 595 s.createGroup(c, group) |
596 defer s.deleteGroup(c, group) | 596 defer s.deleteGroup(c, group) |
597 ri := nova.RuleInfo{ParentGroupId: group.Id} | 597 ri := nova.RuleInfo{ParentGroupId: group.Id} |
598 rule := nova.SecurityGroupRule{Id: 10} | 598 rule := nova.SecurityGroupRule{Id: 10} |
599 s.ensureNoRule(c, rule) | 599 s.ensureNoRule(c, rule) |
600 err := s.service.addSecurityGroupRule(rule.Id, ri) | 600 err := s.service.addSecurityGroupRule(rule.Id, ri) |
601 c.Assert(err, IsNil) | 601 c.Assert(err, IsNil) |
602 s.deleteRule(c, rule) | 602 s.deleteRule(c, rule) |
603 err = s.service.removeSecurityGroupRule(rule.Id) | 603 err = s.service.removeSecurityGroupRule(rule.Id) |
604 c.Assert(err, ErrorMatches, "no such security group rule 10") | 604 c.Assert(err, ErrorMatches, "no such security group rule 10") |
605 } | 605 } |
606 | 606 |
607 func (s *NovaServiceSuite) TestAddHasRemoveServerSecurityGroup(c *C) { | 607 func (s *NovaSuite) TestAddHasRemoveServerSecurityGroup(c *C) { |
608 server := nova.ServerDetail{Id: "sr1"} | 608 server := nova.ServerDetail{Id: "sr1"} |
609 group := nova.SecurityGroup{Id: 1} | 609 group := nova.SecurityGroup{Id: 1} |
610 s.ensureNoServer(c, server) | 610 s.ensureNoServer(c, server) |
611 s.ensureNoGroup(c, group) | 611 s.ensureNoGroup(c, group) |
612 ok := s.service.hasServerSecurityGroup(server.Id, group.Id) | 612 ok := s.service.hasServerSecurityGroup(server.Id, group.Id) |
613 c.Assert(ok, Equals, false) | 613 c.Assert(ok, Equals, false) |
614 s.createServer(c, server) | 614 s.createServer(c, server) |
615 defer s.deleteServer(c, server) | 615 defer s.deleteServer(c, server) |
616 ok = s.service.hasServerSecurityGroup(server.Id, group.Id) | 616 ok = s.service.hasServerSecurityGroup(server.Id, group.Id) |
617 c.Assert(ok, Equals, false) | 617 c.Assert(ok, Equals, false) |
618 s.createGroup(c, group) | 618 s.createGroup(c, group) |
619 defer s.deleteGroup(c, group) | 619 defer s.deleteGroup(c, group) |
620 ok = s.service.hasServerSecurityGroup(server.Id, group.Id) | 620 ok = s.service.hasServerSecurityGroup(server.Id, group.Id) |
621 c.Assert(ok, Equals, false) | 621 c.Assert(ok, Equals, false) |
622 err := s.service.addServerSecurityGroup(server.Id, group.Id) | 622 err := s.service.addServerSecurityGroup(server.Id, group.Id) |
623 c.Assert(err, IsNil) | 623 c.Assert(err, IsNil) |
624 ok = s.service.hasServerSecurityGroup(server.Id, group.Id) | 624 ok = s.service.hasServerSecurityGroup(server.Id, group.Id) |
625 c.Assert(ok, Equals, true) | 625 c.Assert(ok, Equals, true) |
626 err = s.service.removeServerSecurityGroup(server.Id, group.Id) | 626 err = s.service.removeServerSecurityGroup(server.Id, group.Id) |
627 c.Assert(err, IsNil) | 627 c.Assert(err, IsNil) |
628 ok = s.service.hasServerSecurityGroup(server.Id, group.Id) | 628 ok = s.service.hasServerSecurityGroup(server.Id, group.Id) |
629 c.Assert(ok, Equals, false) | 629 c.Assert(ok, Equals, false) |
630 } | 630 } |
631 | 631 |
632 func (s *NovaServiceSuite) TestAddServerSecurityGroupWithInvalidServerFails(c *C
) { | 632 func (s *NovaSuite) TestAddServerSecurityGroupWithInvalidServerFails(c *C) { |
633 server := nova.ServerDetail{Id: "sr1"} | 633 server := nova.ServerDetail{Id: "sr1"} |
634 group := nova.SecurityGroup{Id: 1} | 634 group := nova.SecurityGroup{Id: 1} |
635 s.ensureNoServer(c, server) | 635 s.ensureNoServer(c, server) |
636 s.createGroup(c, group) | 636 s.createGroup(c, group) |
637 defer s.deleteGroup(c, group) | 637 defer s.deleteGroup(c, group) |
638 err := s.service.addServerSecurityGroup(server.Id, group.Id) | 638 err := s.service.addServerSecurityGroup(server.Id, group.Id) |
639 c.Assert(err, ErrorMatches, `no such server "sr1"`) | 639 c.Assert(err, ErrorMatches, `no such server "sr1"`) |
640 } | 640 } |
641 | 641 |
642 func (s *NovaServiceSuite) TestAddServerSecurityGroupWithInvalidGroupFails(c *C)
{ | 642 func (s *NovaSuite) TestAddServerSecurityGroupWithInvalidGroupFails(c *C) { |
643 group := nova.SecurityGroup{Id: 1} | 643 group := nova.SecurityGroup{Id: 1} |
644 server := nova.ServerDetail{Id: "sr1"} | 644 server := nova.ServerDetail{Id: "sr1"} |
645 s.ensureNoGroup(c, group) | 645 s.ensureNoGroup(c, group) |
646 s.createServer(c, server) | 646 s.createServer(c, server) |
647 defer s.deleteServer(c, server) | 647 defer s.deleteServer(c, server) |
648 err := s.service.addServerSecurityGroup(server.Id, group.Id) | 648 err := s.service.addServerSecurityGroup(server.Id, group.Id) |
649 c.Assert(err, ErrorMatches, "no such security group 1") | 649 c.Assert(err, ErrorMatches, "no such security group 1") |
650 } | 650 } |
651 | 651 |
652 func (s *NovaServiceSuite) TestAddServerSecurityGroupTwiceFails(c *C) { | 652 func (s *NovaSuite) TestAddServerSecurityGroupTwiceFails(c *C) { |
653 server := nova.ServerDetail{Id: "sr1"} | 653 server := nova.ServerDetail{Id: "sr1"} |
654 group := nova.SecurityGroup{Id: 1} | 654 group := nova.SecurityGroup{Id: 1} |
655 s.createServer(c, server) | 655 s.createServer(c, server) |
656 defer s.deleteServer(c, server) | 656 defer s.deleteServer(c, server) |
657 s.createGroup(c, group) | 657 s.createGroup(c, group) |
658 defer s.deleteGroup(c, group) | 658 defer s.deleteGroup(c, group) |
659 err := s.service.addServerSecurityGroup(server.Id, group.Id) | 659 err := s.service.addServerSecurityGroup(server.Id, group.Id) |
660 c.Assert(err, IsNil) | 660 c.Assert(err, IsNil) |
661 err = s.service.addServerSecurityGroup(server.Id, group.Id) | 661 err = s.service.addServerSecurityGroup(server.Id, group.Id) |
662 c.Assert(err, ErrorMatches, `server "sr1" already belongs to group 1`) | 662 c.Assert(err, ErrorMatches, `server "sr1" already belongs to group 1`) |
663 err = s.service.removeServerSecurityGroup(server.Id, group.Id) | 663 err = s.service.removeServerSecurityGroup(server.Id, group.Id) |
664 c.Assert(err, IsNil) | 664 c.Assert(err, IsNil) |
665 } | 665 } |
666 | 666 |
667 func (s *NovaServiceSuite) TestRemoveServerSecurityGroupWithInvalidServerFails(c
*C) { | 667 func (s *NovaSuite) TestRemoveServerSecurityGroupWithInvalidServerFails(c *C) { |
668 server := nova.ServerDetail{Id: "sr1"} | 668 server := nova.ServerDetail{Id: "sr1"} |
669 group := nova.SecurityGroup{Id: 1} | 669 group := nova.SecurityGroup{Id: 1} |
670 s.createServer(c, server) | 670 s.createServer(c, server) |
671 s.createGroup(c, group) | 671 s.createGroup(c, group) |
672 defer s.deleteGroup(c, group) | 672 defer s.deleteGroup(c, group) |
673 err := s.service.addServerSecurityGroup(server.Id, group.Id) | 673 err := s.service.addServerSecurityGroup(server.Id, group.Id) |
674 c.Assert(err, IsNil) | 674 c.Assert(err, IsNil) |
675 s.deleteServer(c, server) | 675 s.deleteServer(c, server) |
676 err = s.service.removeServerSecurityGroup(server.Id, group.Id) | 676 err = s.service.removeServerSecurityGroup(server.Id, group.Id) |
677 c.Assert(err, ErrorMatches, `no such server "sr1"`) | 677 c.Assert(err, ErrorMatches, `no such server "sr1"`) |
678 s.createServer(c, server) | 678 s.createServer(c, server) |
679 defer s.deleteServer(c, server) | 679 defer s.deleteServer(c, server) |
680 err = s.service.removeServerSecurityGroup(server.Id, group.Id) | 680 err = s.service.removeServerSecurityGroup(server.Id, group.Id) |
681 c.Assert(err, IsNil) | 681 c.Assert(err, IsNil) |
682 } | 682 } |
683 | 683 |
684 func (s *NovaServiceSuite) TestRemoveServerSecurityGroupWithInvalidGroupFails(c
*C) { | 684 func (s *NovaSuite) TestRemoveServerSecurityGroupWithInvalidGroupFails(c *C) { |
685 group := nova.SecurityGroup{Id: 1} | 685 group := nova.SecurityGroup{Id: 1} |
686 server := nova.ServerDetail{Id: "sr1"} | 686 server := nova.ServerDetail{Id: "sr1"} |
687 s.createGroup(c, group) | 687 s.createGroup(c, group) |
688 s.createServer(c, server) | 688 s.createServer(c, server) |
689 defer s.deleteServer(c, server) | 689 defer s.deleteServer(c, server) |
690 err := s.service.addServerSecurityGroup(server.Id, group.Id) | 690 err := s.service.addServerSecurityGroup(server.Id, group.Id) |
691 c.Assert(err, IsNil) | 691 c.Assert(err, IsNil) |
692 s.deleteGroup(c, group) | 692 s.deleteGroup(c, group) |
693 err = s.service.removeServerSecurityGroup(server.Id, group.Id) | 693 err = s.service.removeServerSecurityGroup(server.Id, group.Id) |
694 c.Assert(err, ErrorMatches, "no such security group 1") | 694 c.Assert(err, ErrorMatches, "no such security group 1") |
695 s.createGroup(c, group) | 695 s.createGroup(c, group) |
696 defer s.deleteGroup(c, group) | 696 defer s.deleteGroup(c, group) |
697 err = s.service.removeServerSecurityGroup(server.Id, group.Id) | 697 err = s.service.removeServerSecurityGroup(server.Id, group.Id) |
698 c.Assert(err, IsNil) | 698 c.Assert(err, IsNil) |
699 } | 699 } |
700 | 700 |
701 func (s *NovaServiceSuite) TestRemoveServerSecurityGroupTwiceFails(c *C) { | 701 func (s *NovaSuite) TestRemoveServerSecurityGroupTwiceFails(c *C) { |
702 server := nova.ServerDetail{Id: "sr1"} | 702 server := nova.ServerDetail{Id: "sr1"} |
703 group := nova.SecurityGroup{Id: 1} | 703 group := nova.SecurityGroup{Id: 1} |
704 s.createServer(c, server) | 704 s.createServer(c, server) |
705 defer s.deleteServer(c, server) | 705 defer s.deleteServer(c, server) |
706 s.createGroup(c, group) | 706 s.createGroup(c, group) |
707 defer s.deleteGroup(c, group) | 707 defer s.deleteGroup(c, group) |
708 err := s.service.addServerSecurityGroup(server.Id, group.Id) | 708 err := s.service.addServerSecurityGroup(server.Id, group.Id) |
709 c.Assert(err, IsNil) | 709 c.Assert(err, IsNil) |
710 err = s.service.removeServerSecurityGroup(server.Id, group.Id) | 710 err = s.service.removeServerSecurityGroup(server.Id, group.Id) |
711 c.Assert(err, IsNil) | 711 c.Assert(err, IsNil) |
712 err = s.service.removeServerSecurityGroup(server.Id, group.Id) | 712 err = s.service.removeServerSecurityGroup(server.Id, group.Id) |
713 c.Assert(err, ErrorMatches, `server "sr1" does not belong to group 1`) | 713 c.Assert(err, ErrorMatches, `server "sr1" does not belong to group 1`) |
714 } | 714 } |
715 | 715 |
716 func (s *NovaServiceSuite) TestAddHasRemoveFloatingIP(c *C) { | 716 func (s *NovaSuite) TestAddHasRemoveFloatingIP(c *C) { |
717 ip := nova.FloatingIP{Id: 1, IP: "1.2.3.4"} | 717 ip := nova.FloatingIP{Id: 1, IP: "1.2.3.4"} |
718 s.ensureNoIP(c, ip) | 718 s.ensureNoIP(c, ip) |
719 ok := s.service.hasFloatingIP(ip.IP) | 719 ok := s.service.hasFloatingIP(ip.IP) |
720 c.Assert(ok, Equals, false) | 720 c.Assert(ok, Equals, false) |
721 s.createIP(c, ip) | 721 s.createIP(c, ip) |
722 ok = s.service.hasFloatingIP("invalid IP") | 722 ok = s.service.hasFloatingIP("invalid IP") |
723 c.Assert(ok, Equals, false) | 723 c.Assert(ok, Equals, false) |
724 ok = s.service.hasFloatingIP(ip.IP) | 724 ok = s.service.hasFloatingIP(ip.IP) |
725 c.Assert(ok, Equals, true) | 725 c.Assert(ok, Equals, true) |
726 s.deleteIP(c, ip) | 726 s.deleteIP(c, ip) |
727 ok = s.service.hasFloatingIP(ip.IP) | 727 ok = s.service.hasFloatingIP(ip.IP) |
728 c.Assert(ok, Equals, false) | 728 c.Assert(ok, Equals, false) |
729 } | 729 } |
730 | 730 |
731 func (s *NovaServiceSuite) TestAddFloatingIPTwiceFails(c *C) { | 731 func (s *NovaSuite) TestAddFloatingIPTwiceFails(c *C) { |
732 ip := nova.FloatingIP{Id: 1} | 732 ip := nova.FloatingIP{Id: 1} |
733 s.createIP(c, ip) | 733 s.createIP(c, ip) |
734 defer s.deleteIP(c, ip) | 734 defer s.deleteIP(c, ip) |
735 err := s.service.addFloatingIP(ip) | 735 err := s.service.addFloatingIP(ip) |
736 c.Assert(err, ErrorMatches, "a floating IP with id 1 already exists") | 736 c.Assert(err, ErrorMatches, "a floating IP with id 1 already exists") |
737 } | 737 } |
738 | 738 |
739 func (s *NovaServiceSuite) TestRemoveFloatingIPTwiceFails(c *C) { | 739 func (s *NovaSuite) TestRemoveFloatingIPTwiceFails(c *C) { |
740 ip := nova.FloatingIP{Id: 1} | 740 ip := nova.FloatingIP{Id: 1} |
741 s.createIP(c, ip) | 741 s.createIP(c, ip) |
742 s.deleteIP(c, ip) | 742 s.deleteIP(c, ip) |
743 err := s.service.removeFloatingIP(ip.Id) | 743 err := s.service.removeFloatingIP(ip.Id) |
744 c.Assert(err, ErrorMatches, "no such floating IP 1") | 744 c.Assert(err, ErrorMatches, "no such floating IP 1") |
745 } | 745 } |
746 | 746 |
747 func (s *NovaServiceSuite) TestAllFloatingIPs(c *C) { | 747 func (s *NovaSuite) TestAllFloatingIPs(c *C) { |
748 fips := s.service.allFloatingIPs() | 748 fips := s.service.allFloatingIPs() |
749 c.Assert(fips, HasLen, 0) | 749 c.Assert(fips, HasLen, 0) |
750 fips = []nova.FloatingIP{ | 750 fips = []nova.FloatingIP{ |
751 nova.FloatingIP{Id: 1}, | 751 nova.FloatingIP{Id: 1}, |
752 nova.FloatingIP{Id: 2}, | 752 nova.FloatingIP{Id: 2}, |
753 } | 753 } |
754 s.createIP(c, fips[0]) | 754 s.createIP(c, fips[0]) |
755 defer s.deleteIP(c, fips[0]) | 755 defer s.deleteIP(c, fips[0]) |
756 s.createIP(c, fips[1]) | 756 s.createIP(c, fips[1]) |
757 defer s.deleteIP(c, fips[1]) | 757 defer s.deleteIP(c, fips[1]) |
758 ips := s.service.allFloatingIPs() | 758 ips := s.service.allFloatingIPs() |
759 c.Assert(ips, HasLen, len(fips)) | 759 c.Assert(ips, HasLen, len(fips)) |
760 if ips[0].Id != fips[0].Id { | 760 if ips[0].Id != fips[0].Id { |
761 ips[0], ips[1] = ips[1], ips[0] | 761 ips[0], ips[1] = ips[1], ips[0] |
762 } | 762 } |
763 c.Assert(ips, DeepEquals, fips) | 763 c.Assert(ips, DeepEquals, fips) |
764 } | 764 } |
765 | 765 |
766 func (s *NovaServiceSuite) TestGetFloatingIP(c *C) { | 766 func (s *NovaSuite) TestGetFloatingIP(c *C) { |
767 fip := nova.FloatingIP{ | 767 fip := nova.FloatingIP{ |
768 Id: 1, | 768 Id: 1, |
769 IP: "1.2.3.4", | 769 IP: "1.2.3.4", |
770 Pool: "pool", | 770 Pool: "pool", |
771 InstanceId: "sr1", | 771 InstanceId: "sr1", |
772 FixedIP: "4.3.2.1", | 772 FixedIP: "4.3.2.1", |
773 } | 773 } |
774 s.createIP(c, fip) | 774 s.createIP(c, fip) |
775 defer s.deleteIP(c, fip) | 775 defer s.deleteIP(c, fip) |
776 » ip, _ := s.service.getFloatingIP(fip.Id) | 776 » ip, _ := s.service.floatingIP(fip.Id) |
777 c.Assert(*ip, DeepEquals, fip) | 777 c.Assert(*ip, DeepEquals, fip) |
778 } | 778 } |
779 | 779 |
780 func (s *NovaServiceSuite) TestAddHasRemoveServerFloatingIP(c *C) { | 780 func (s *NovaSuite) TestAddHasRemoveServerFloatingIP(c *C) { |
781 server := nova.ServerDetail{Id: "sr1"} | 781 server := nova.ServerDetail{Id: "sr1"} |
782 fip := nova.FloatingIP{Id: 1, IP: "1.2.3.4"} | 782 fip := nova.FloatingIP{Id: 1, IP: "1.2.3.4"} |
783 s.ensureNoServer(c, server) | 783 s.ensureNoServer(c, server) |
784 s.ensureNoIP(c, fip) | 784 s.ensureNoIP(c, fip) |
785 ok := s.service.hasServerFloatingIP(server.Id, fip.IP) | 785 ok := s.service.hasServerFloatingIP(server.Id, fip.IP) |
786 c.Assert(ok, Equals, false) | 786 c.Assert(ok, Equals, false) |
787 s.createServer(c, server) | 787 s.createServer(c, server) |
788 defer s.deleteServer(c, server) | 788 defer s.deleteServer(c, server) |
789 ok = s.service.hasServerFloatingIP(server.Id, fip.IP) | 789 ok = s.service.hasServerFloatingIP(server.Id, fip.IP) |
790 c.Assert(ok, Equals, false) | 790 c.Assert(ok, Equals, false) |
791 s.createIP(c, fip) | 791 s.createIP(c, fip) |
792 defer s.deleteIP(c, fip) | 792 defer s.deleteIP(c, fip) |
793 ok = s.service.hasServerFloatingIP(server.Id, fip.IP) | 793 ok = s.service.hasServerFloatingIP(server.Id, fip.IP) |
794 c.Assert(ok, Equals, false) | 794 c.Assert(ok, Equals, false) |
795 err := s.service.addServerFloatingIP(server.Id, fip.Id) | 795 err := s.service.addServerFloatingIP(server.Id, fip.Id) |
796 c.Assert(err, IsNil) | 796 c.Assert(err, IsNil) |
797 ok = s.service.hasServerFloatingIP(server.Id, fip.IP) | 797 ok = s.service.hasServerFloatingIP(server.Id, fip.IP) |
798 c.Assert(ok, Equals, true) | 798 c.Assert(ok, Equals, true) |
799 err = s.service.removeServerFloatingIP(server.Id, fip.Id) | 799 err = s.service.removeServerFloatingIP(server.Id, fip.Id) |
800 c.Assert(err, IsNil) | 800 c.Assert(err, IsNil) |
801 ok = s.service.hasServerFloatingIP(server.Id, fip.IP) | 801 ok = s.service.hasServerFloatingIP(server.Id, fip.IP) |
802 c.Assert(ok, Equals, false) | 802 c.Assert(ok, Equals, false) |
803 } | 803 } |
804 | 804 |
805 func (s *NovaServiceSuite) TestAddServerFloatingIPWithInvalidServerFails(c *C) { | 805 func (s *NovaSuite) TestAddServerFloatingIPWithInvalidServerFails(c *C) { |
806 server := nova.ServerDetail{Id: "sr1"} | 806 server := nova.ServerDetail{Id: "sr1"} |
807 fip := nova.FloatingIP{Id: 1} | 807 fip := nova.FloatingIP{Id: 1} |
808 s.ensureNoServer(c, server) | 808 s.ensureNoServer(c, server) |
809 s.createIP(c, fip) | 809 s.createIP(c, fip) |
810 defer s.deleteIP(c, fip) | 810 defer s.deleteIP(c, fip) |
811 err := s.service.addServerFloatingIP(server.Id, fip.Id) | 811 err := s.service.addServerFloatingIP(server.Id, fip.Id) |
812 c.Assert(err, ErrorMatches, `no such server "sr1"`) | 812 c.Assert(err, ErrorMatches, `no such server "sr1"`) |
813 } | 813 } |
814 | 814 |
815 func (s *NovaServiceSuite) TestAddServerFloatingIPWithInvalidIPFails(c *C) { | 815 func (s *NovaSuite) TestAddServerFloatingIPWithInvalidIPFails(c *C) { |
816 fip := nova.FloatingIP{Id: 1} | 816 fip := nova.FloatingIP{Id: 1} |
817 server := nova.ServerDetail{Id: "sr1"} | 817 server := nova.ServerDetail{Id: "sr1"} |
818 s.ensureNoIP(c, fip) | 818 s.ensureNoIP(c, fip) |
819 s.createServer(c, server) | 819 s.createServer(c, server) |
820 defer s.deleteServer(c, server) | 820 defer s.deleteServer(c, server) |
821 err := s.service.addServerFloatingIP(server.Id, fip.Id) | 821 err := s.service.addServerFloatingIP(server.Id, fip.Id) |
822 c.Assert(err, ErrorMatches, "no such floating IP 1") | 822 c.Assert(err, ErrorMatches, "no such floating IP 1") |
823 } | 823 } |
824 | 824 |
825 func (s *NovaServiceSuite) TestAddServerFloatingIPTwiceFails(c *C) { | 825 func (s *NovaSuite) TestAddServerFloatingIPTwiceFails(c *C) { |
826 server := nova.ServerDetail{Id: "sr1"} | 826 server := nova.ServerDetail{Id: "sr1"} |
827 fip := nova.FloatingIP{Id: 1} | 827 fip := nova.FloatingIP{Id: 1} |
828 s.createServer(c, server) | 828 s.createServer(c, server) |
829 defer s.deleteServer(c, server) | 829 defer s.deleteServer(c, server) |
830 s.createIP(c, fip) | 830 s.createIP(c, fip) |
831 defer s.deleteIP(c, fip) | 831 defer s.deleteIP(c, fip) |
832 err := s.service.addServerFloatingIP(server.Id, fip.Id) | 832 err := s.service.addServerFloatingIP(server.Id, fip.Id) |
833 c.Assert(err, IsNil) | 833 c.Assert(err, IsNil) |
834 err = s.service.addServerFloatingIP(server.Id, fip.Id) | 834 err = s.service.addServerFloatingIP(server.Id, fip.Id) |
835 c.Assert(err, ErrorMatches, `server "sr1" already has floating IP 1`) | 835 c.Assert(err, ErrorMatches, `server "sr1" already has floating IP 1`) |
836 err = s.service.removeServerFloatingIP(server.Id, fip.Id) | 836 err = s.service.removeServerFloatingIP(server.Id, fip.Id) |
837 c.Assert(err, IsNil) | 837 c.Assert(err, IsNil) |
838 } | 838 } |
839 | 839 |
840 func (s *NovaServiceSuite) TestRemoveServerFloatingIPWithInvalidServerFails(c *C
) { | 840 func (s *NovaSuite) TestRemoveServerFloatingIPWithInvalidServerFails(c *C) { |
841 server := nova.ServerDetail{Id: "sr1"} | 841 server := nova.ServerDetail{Id: "sr1"} |
842 fip := nova.FloatingIP{Id: 1} | 842 fip := nova.FloatingIP{Id: 1} |
843 s.createServer(c, server) | 843 s.createServer(c, server) |
844 s.createIP(c, fip) | 844 s.createIP(c, fip) |
845 defer s.deleteIP(c, fip) | 845 defer s.deleteIP(c, fip) |
846 err := s.service.addServerFloatingIP(server.Id, fip.Id) | 846 err := s.service.addServerFloatingIP(server.Id, fip.Id) |
847 c.Assert(err, IsNil) | 847 c.Assert(err, IsNil) |
848 s.deleteServer(c, server) | 848 s.deleteServer(c, server) |
849 err = s.service.removeServerFloatingIP(server.Id, fip.Id) | 849 err = s.service.removeServerFloatingIP(server.Id, fip.Id) |
850 c.Assert(err, ErrorMatches, `no such server "sr1"`) | 850 c.Assert(err, ErrorMatches, `no such server "sr1"`) |
851 s.createServer(c, server) | 851 s.createServer(c, server) |
852 defer s.deleteServer(c, server) | 852 defer s.deleteServer(c, server) |
853 err = s.service.removeServerFloatingIP(server.Id, fip.Id) | 853 err = s.service.removeServerFloatingIP(server.Id, fip.Id) |
854 c.Assert(err, IsNil) | 854 c.Assert(err, IsNil) |
855 } | 855 } |
856 | 856 |
857 func (s *NovaServiceSuite) TestRemoveServerFloatingIPWithInvalidIPFails(c *C) { | 857 func (s *NovaSuite) TestRemoveServerFloatingIPWithInvalidIPFails(c *C) { |
858 fip := nova.FloatingIP{Id: 1} | 858 fip := nova.FloatingIP{Id: 1} |
859 server := nova.ServerDetail{Id: "sr1"} | 859 server := nova.ServerDetail{Id: "sr1"} |
860 s.createIP(c, fip) | 860 s.createIP(c, fip) |
861 s.createServer(c, server) | 861 s.createServer(c, server) |
862 defer s.deleteServer(c, server) | 862 defer s.deleteServer(c, server) |
863 err := s.service.addServerFloatingIP(server.Id, fip.Id) | 863 err := s.service.addServerFloatingIP(server.Id, fip.Id) |
864 c.Assert(err, IsNil) | 864 c.Assert(err, IsNil) |
865 s.deleteIP(c, fip) | 865 s.deleteIP(c, fip) |
866 err = s.service.removeServerFloatingIP(server.Id, fip.Id) | 866 err = s.service.removeServerFloatingIP(server.Id, fip.Id) |
867 c.Assert(err, ErrorMatches, "no such floating IP 1") | 867 c.Assert(err, ErrorMatches, "no such floating IP 1") |
868 s.createIP(c, fip) | 868 s.createIP(c, fip) |
869 defer s.deleteIP(c, fip) | 869 defer s.deleteIP(c, fip) |
870 err = s.service.removeServerFloatingIP(server.Id, fip.Id) | 870 err = s.service.removeServerFloatingIP(server.Id, fip.Id) |
871 c.Assert(err, IsNil) | 871 c.Assert(err, IsNil) |
872 } | 872 } |
873 | 873 |
874 func (s *NovaServiceSuite) TestRemoveServerFloatingIPTwiceFails(c *C) { | 874 func (s *NovaSuite) TestRemoveServerFloatingIPTwiceFails(c *C) { |
875 server := nova.ServerDetail{Id: "sr1"} | 875 server := nova.ServerDetail{Id: "sr1"} |
876 fip := nova.FloatingIP{Id: 1} | 876 fip := nova.FloatingIP{Id: 1} |
877 s.createServer(c, server) | 877 s.createServer(c, server) |
878 defer s.deleteServer(c, server) | 878 defer s.deleteServer(c, server) |
879 s.createIP(c, fip) | 879 s.createIP(c, fip) |
880 defer s.deleteIP(c, fip) | 880 defer s.deleteIP(c, fip) |
881 err := s.service.addServerFloatingIP(server.Id, fip.Id) | 881 err := s.service.addServerFloatingIP(server.Id, fip.Id) |
882 c.Assert(err, IsNil) | 882 c.Assert(err, IsNil) |
883 err = s.service.removeServerFloatingIP(server.Id, fip.Id) | 883 err = s.service.removeServerFloatingIP(server.Id, fip.Id) |
884 c.Assert(err, IsNil) | 884 c.Assert(err, IsNil) |
885 err = s.service.removeServerFloatingIP(server.Id, fip.Id) | 885 err = s.service.removeServerFloatingIP(server.Id, fip.Id) |
886 c.Assert(err, ErrorMatches, `server "sr1" does not have floating IP 1`) | 886 c.Assert(err, ErrorMatches, `server "sr1" does not have floating IP 1`) |
887 } | 887 } |
OLD | NEW |