Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code | Sign in
(1412)

Side by Side Diff: testservices/novaservice/service_test.go

Issue 6910055: Removed the interface and renamed get methods. (Closed)
Patch Set: Removed the interface and renamed get methods. Created 11 years, 3 months ago
Left:
Right:
Use n/p to move between diff chunks; N/P to move between comments. Please Sign in to add in-line comments.
Jump to:
View unified diff | Download patch
« no previous file with comments | « testservices/novaservice/service_http_test.go ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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 }
OLDNEW
« no previous file with comments | « testservices/novaservice/service_http_test.go ('k') | no next file » | no next file with comments »

Powered by Google App Engine
RSS Feeds Recent Issues | This issue
This is Rietveld f62528b