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

Delta Between Two Patch Sets: nova/nova_test.go

Issue 6877054: First part of the nova service double. (Closed)
Left Patch Set: First part of the nova service double. Created 11 years, 3 months ago
Right Patch Set: First part of the nova service double. 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:
Left: Side by side diff | Download
Right: Side by side diff | Download
« no previous file with change/comment | « nova/nova.go ('k') | testservices/novaservice/novaservice.go » ('j') | no next file with change/comment »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
LEFTRIGHT
1 package nova_test 1 package nova_test
2 2
3 import ( 3 import (
4 "flag" 4 "flag"
5 . "launchpad.net/gocheck" 5 . "launchpad.net/gocheck"
6 "launchpad.net/goose/client" 6 "launchpad.net/goose/client"
7 "launchpad.net/goose/identity" 7 "launchpad.net/goose/identity"
8 "launchpad.net/goose/nova" 8 "launchpad.net/goose/nova"
9 "testing" 9 "testing"
10 "time" 10 "time"
11 ) 11 )
12 12
13 const (
14 // Known, pre-existing image details to use when creating a test server instance.
15 testImageId = "0f602ea9-c09e-440c-9e29-cfae5635afa3" // smoser-cloud-i mages/ubuntu-quantal-12.10-i386-server-20121017
16 testFlavourId = "1" // m1.tiny
17 // A made up name we use for the test server instance.
18 testImageName = "nova_test_server"
19 )
20
13 func Test(t *testing.T) { TestingT(t) } 21 func Test(t *testing.T) { TestingT(t) }
14 22
15 var live = flag.Bool("live", false, "Include live OpenStack (Canonistack) tests" ) 23 var live = flag.Bool("live", false, "Include live OpenStack (Canonistack) tests" )
16 24
17 type NovaSuite struct { 25 type NovaSuite struct {
18 » nova *nova.Client 26 » nova *nova.Client
19 » testServerId string 27 » testServer *nova.Entity
20 » userId string 28 » userId string
21 » tenantId string 29 » tenantId string
22 } 30 }
23 31
24 func (s *NovaSuite) SetUpSuite(c *C) { 32 func (s *NovaSuite) SetUpSuite(c *C) {
25 if !*live { 33 if !*live {
26 c.Skip("-live not provided") 34 c.Skip("-live not provided")
27 } 35 }
28 36
29 cred, err := identity.CompleteCredentialsFromEnv() 37 cred, err := identity.CompleteCredentialsFromEnv()
30 c.Assert(err, IsNil) 38 c.Assert(err, IsNil)
31 client := client.NewClient(cred, identity.AuthUserPass) 39 client := client.NewClient(cred, identity.AuthUserPass)
32 c.Assert(err, IsNil)
33 err = client.Authenticate()
34 c.Assert(err, IsNil)
35 c.Logf("client authenticated")
36 s.nova = nova.New(client) 40 s.nova = nova.New(client)
41 s.testServer, err = s.createInstance(c, testImageName)
42 c.Assert(err, IsNil)
43 s.waitTestServerToStart(c)
44 // These will not be filled in until a client has authorised which will happen creating the instance above.
37 s.userId = client.UserId 45 s.userId = client.UserId
38 s.tenantId = client.TenantId 46 s.tenantId = client.TenantId
39 } 47 }
40 48
49 func (s *NovaSuite) TearDownSuite(c *C) {
50 if *live {
51 if s.testServer != nil {
52 err := s.nova.DeleteServer(s.testServer.Id)
53 c.Check(err, IsNil)
54 }
55 }
56 }
57
58 func (s *NovaSuite) createInstance(c *C, name string) (instance *nova.Entity, er r error) {
59 opts := nova.RunServerOpts{
60 Name: name,
61 FlavorId: testFlavourId,
62 ImageId: testImageId,
63 UserData: nil,
64 }
65 instance, err = s.nova.RunServer(opts)
66 if err != nil {
67 return nil, err
68 }
69 return instance, nil
70 }
71
41 var suite = Suite(&NovaSuite{}) 72 var suite = Suite(&NovaSuite{})
42 73
43 func (n *NovaSuite) TestListFlavors(c *C) { 74 // Assert that the server record matches the details of the test server image.
44 » flavors, err := n.nova.ListFlavors() 75 func (s *NovaSuite) assertServerDetails(c *C, sr *nova.ServerDetail) {
76 » c.Assert(sr.Id, Equals, s.testServer.Id)
77 » c.Assert(sr.Name, Equals, testImageName)
78 » c.Assert(sr.Flavor.Id, Equals, testFlavourId)
79 » c.Assert(sr.Image.Id, Equals, testImageId)
80 }
81
82 func (s *NovaSuite) TestListFlavors(c *C) {
83 » flavors, err := s.nova.ListFlavors()
45 c.Assert(err, IsNil) 84 c.Assert(err, IsNil)
46 if len(flavors) < 1 { 85 if len(flavors) < 1 {
47 c.Fatalf("no flavors to list") 86 c.Fatalf("no flavors to list")
48 } 87 }
49 for _, f := range flavors { 88 for _, f := range flavors {
50 c.Assert(f.Id, Not(Equals), "") 89 c.Assert(f.Id, Not(Equals), "")
51 c.Assert(f.Name, Not(Equals), "") 90 c.Assert(f.Name, Not(Equals), "")
52 for _, l := range f.Links { 91 for _, l := range f.Links {
53 c.Assert(l.Href, Matches, "https?://.*") 92 c.Assert(l.Href, Matches, "https?://.*")
54 c.Assert(l.Rel, Matches, "self|bookmark") 93 c.Assert(l.Rel, Matches, "self|bookmark")
55 } 94 }
56 } 95 }
57 } 96 }
58 97
59 func (n *NovaSuite) TestListFlavorsDetail(c *C) { 98 func (s *NovaSuite) TestListFlavorsDetail(c *C) {
60 » flavors, err := n.nova.ListFlavorsDetail() 99 » flavors, err := s.nova.ListFlavorsDetail()
61 c.Assert(err, IsNil) 100 c.Assert(err, IsNil)
62 if len(flavors) < 1 { 101 if len(flavors) < 1 {
63 c.Fatalf("no flavors (details) to list") 102 c.Fatalf("no flavors (details) to list")
64 } 103 }
65 for _, f := range flavors { 104 for _, f := range flavors {
66 c.Assert(f.Name, Not(Equals), "") 105 c.Assert(f.Name, Not(Equals), "")
67 c.Assert(f.Id, Not(Equals), "") 106 c.Assert(f.Id, Not(Equals), "")
68 if f.RAM < 0 || f.VCPUs < 0 || f.Disk < 0 { 107 if f.RAM < 0 || f.VCPUs < 0 || f.Disk < 0 {
69 c.Fatalf("invalid flavor found: %#v", f) 108 c.Fatalf("invalid flavor found: %#v", f)
70 } 109 }
71 } 110 }
72 } 111 }
73 112
74 func (n *NovaSuite) TestListServers(c *C) { 113 func (s *NovaSuite) TestListServers(c *C) {
75 » servers, err := n.nova.ListServers() 114 » servers, err := s.nova.ListServers(nil)
76 c.Assert(err, IsNil) 115 c.Assert(err, IsNil)
77 foundTest := false 116 foundTest := false
78 for _, sr := range servers { 117 for _, sr := range servers {
79 c.Assert(sr.Id, Not(Equals), "") 118 c.Assert(sr.Id, Not(Equals), "")
80 c.Assert(sr.Name, Not(Equals), "") 119 c.Assert(sr.Name, Not(Equals), "")
81 » » if sr.Id == n.testServerId { 120 » » if sr.Id == s.testServer.Id {
82 » » » c.Assert(sr.Name, Equals, "test_server1") 121 » » » c.Assert(sr.Name, Equals, testImageName)
83 foundTest = true 122 foundTest = true
84 } 123 }
85 for _, l := range sr.Links { 124 for _, l := range sr.Links {
86 c.Assert(l.Href, Matches, "https?://.*") 125 c.Assert(l.Href, Matches, "https?://.*")
87 c.Assert(l.Rel, Matches, "self|bookmark") 126 c.Assert(l.Rel, Matches, "self|bookmark")
88 } 127 }
89 } 128 }
90 if !foundTest { 129 if !foundTest {
91 » » c.Fatalf("test server (%s) not found in server list", n.testServ erId) 130 » » c.Fatalf("test server (%s) not found in server list", s.testServ er.Id)
92 » } 131 » }
93 } 132 }
94 133
95 func (n *NovaSuite) TestListServersDetail(c *C) { 134 func (s *NovaSuite) TestListServersWithFilter(c *C) {
96 » servers, err := n.nova.ListServersDetail() 135 » inst, err := s.createInstance(c, "filtered_server")
136 » c.Assert(err, IsNil)
137 » defer s.nova.DeleteServer(inst.Id)
138 » filter := nova.NewFilter()
139 » filter.Add(nova.FilterServer, "filtered_server")
140 » // The server will still be building when we make the API call.
141 » filter.Add(nova.FilterStatus, nova.StatusBuild)
142 » servers, err := s.nova.ListServers(filter)
143 » c.Assert(err, IsNil)
144 » found := false
145 » for _, sr := range servers {
146 » » if sr.Id == inst.Id {
147 » » » c.Assert(sr.Name, Equals, "filtered_server")
148 » » » found = true
149 » » }
150 » }
151 » if !found {
152 » » c.Fatalf("server (%s) not found in filtered server list %v", ins t.Id, servers)
153 » }
154 }
155
156 func (s *NovaSuite) TestListServersDetail(c *C) {
157 » servers, err := s.nova.ListServersDetail(nil)
97 c.Assert(err, IsNil) 158 c.Assert(err, IsNil)
98 if len(servers) < 1 { 159 if len(servers) < 1 {
99 c.Fatalf("no servers to list (expected at least 1)") 160 c.Fatalf("no servers to list (expected at least 1)")
100 } 161 }
101 foundTest := false 162 foundTest := false
102 for _, sr := range servers { 163 for _, sr := range servers {
103 c.Assert(sr.Created, Matches, `\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{ 2}.*`) 164 c.Assert(sr.Created, Matches, `\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{ 2}.*`)
104 c.Assert(sr.Updated, Matches, `\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{ 2}.*`) 165 c.Assert(sr.Updated, Matches, `\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{ 2}.*`)
105 c.Assert(sr.Id, Not(Equals), "") 166 c.Assert(sr.Id, Not(Equals), "")
106 c.Assert(sr.HostId, Not(Equals), "") 167 c.Assert(sr.HostId, Not(Equals), "")
107 » » c.Assert(sr.TenantId, Equals, n.tenantId) 168 » » c.Assert(sr.TenantId, Equals, s.tenantId)
108 » » c.Assert(sr.UserId, Equals, n.userId) 169 » » c.Assert(sr.UserId, Equals, s.userId)
109 c.Assert(sr.Status, Not(Equals), "") 170 c.Assert(sr.Status, Not(Equals), "")
110 c.Assert(sr.Name, Not(Equals), "") 171 c.Assert(sr.Name, Not(Equals), "")
111 » » if sr.Id == n.testServerId { 172 » » if sr.Id == s.testServer.Id {
112 » » » c.Assert(sr.Name, Equals, "test_server1") 173 » » » s.assertServerDetails(c, &sr)
113 » » » c.Assert(sr.Flavor.Id, Equals, "1")
114 » » » c.Assert(sr.Image.Id, Equals, "3fc0ef0b-82a9-4f44-a797-a 43f0f73b20e")
115 foundTest = true 174 foundTest = true
116 } 175 }
117 for _, l := range sr.Links { 176 for _, l := range sr.Links {
118 c.Assert(l.Href, Matches, "https?://.*") 177 c.Assert(l.Href, Matches, "https?://.*")
119 c.Assert(l.Rel, Matches, "self|bookmark") 178 c.Assert(l.Rel, Matches, "self|bookmark")
120 } 179 }
121 c.Assert(sr.Flavor.Id, Not(Equals), "") 180 c.Assert(sr.Flavor.Id, Not(Equals), "")
122 for _, f := range sr.Flavor.Links { 181 for _, f := range sr.Flavor.Links {
123 c.Assert(f.Href, Matches, "https?://.*") 182 c.Assert(f.Href, Matches, "https?://.*")
124 c.Assert(f.Rel, Matches, "self|bookmark") 183 c.Assert(f.Rel, Matches, "self|bookmark")
125 } 184 }
126 c.Assert(sr.Image.Id, Not(Equals), "") 185 c.Assert(sr.Image.Id, Not(Equals), "")
127 for _, i := range sr.Image.Links { 186 for _, i := range sr.Image.Links {
128 c.Assert(i.Href, Matches, "https?://.*") 187 c.Assert(i.Href, Matches, "https?://.*")
129 c.Assert(i.Rel, Matches, "self|bookmark") 188 c.Assert(i.Rel, Matches, "self|bookmark")
130 } 189 }
131 } 190 }
132 if !foundTest { 191 if !foundTest {
133 » » c.Fatalf("test server (%s) not found in server list (details)", n.testServerId) 192 » » c.Fatalf("test server (%s) not found in server list (details)", s.testServer.Id)
134 » } 193 » }
135 } 194 }
136 195
137 func (n *NovaSuite) TestListSecurityGroups(c *C) { 196 func (s *NovaSuite) TestListServersDetailWithFilter(c *C) {
138 » groups, err := n.nova.ListSecurityGroups() 197 » inst, err := s.createInstance(c, "filtered_server")
198 » c.Assert(err, IsNil)
199 » defer s.nova.DeleteServer(inst.Id)
200 » filter := nova.NewFilter()
201 » filter.Add(nova.FilterServer, "filtered_server")
202 » // The server will still be building when we make the API call.
203 » filter.Add(nova.FilterStatus, nova.StatusBuild)
204 » servers, err := s.nova.ListServersDetail(filter)
205 » c.Assert(err, IsNil)
206 » found := false
207 » for _, sr := range servers {
208 » » if sr.Id == inst.Id {
209 » » » c.Assert(sr.Name, Equals, "filtered_server")
210 » » » found = true
211 » » }
212 » }
213 » if !found {
214 » » c.Fatalf("server (%s) not found in filtered server details %v", inst.Id, servers)
215 » }
216 }
217
218 func (s *NovaSuite) TestListSecurityGroups(c *C) {
219 » groups, err := s.nova.ListSecurityGroups()
139 c.Assert(err, IsNil) 220 c.Assert(err, IsNil)
140 if len(groups) < 1 { 221 if len(groups) < 1 {
141 c.Fatalf("no security groups found (expected at least 1)") 222 c.Fatalf("no security groups found (expected at least 1)")
142 } 223 }
143 for _, g := range groups { 224 for _, g := range groups {
144 » » c.Assert(g.TenantId, Equals, n.tenantId) 225 » » c.Assert(g.TenantId, Equals, s.tenantId)
145 c.Assert(g.Name, Not(Equals), "") 226 c.Assert(g.Name, Not(Equals), "")
146 c.Assert(g.Description, Not(Equals), "") 227 c.Assert(g.Description, Not(Equals), "")
147 c.Assert(g.Rules, NotNil) 228 c.Assert(g.Rules, NotNil)
148 } 229 }
149 } 230 }
150 231
151 func (n *NovaSuite) TestCreateAndDeleteSecurityGroup(c *C) { 232 func (s *NovaSuite) TestCreateAndDeleteSecurityGroup(c *C) {
152 » group, err := n.nova.CreateSecurityGroup("test_secgroup", "test_desc") 233 » group, err := s.nova.CreateSecurityGroup("test_secgroup", "test_desc")
153 » c.Check(err, IsNil) 234 » c.Assert(err, IsNil)
154 c.Check(group.Name, Equals, "test_secgroup") 235 c.Check(group.Name, Equals, "test_secgroup")
155 c.Check(group.Description, Equals, "test_desc") 236 c.Check(group.Description, Equals, "test_desc")
156 237
157 » groups, err := n.nova.ListSecurityGroups() 238 » groups, err := s.nova.ListSecurityGroups()
158 found := false 239 found := false
159 for _, g := range groups { 240 for _, g := range groups {
160 if g.Id == group.Id { 241 if g.Id == group.Id {
161 found = true 242 found = true
162 break 243 break
163 } 244 }
164 } 245 }
165 if found { 246 if found {
166 » » err = n.nova.DeleteSecurityGroup(group.Id) 247 » » err = s.nova.DeleteSecurityGroup(group.Id)
167 c.Check(err, IsNil) 248 c.Check(err, IsNil)
168 } else { 249 } else {
169 c.Fatalf("test security group (%d) not found", group.Id) 250 c.Fatalf("test security group (%d) not found", group.Id)
170 } 251 }
171 } 252 }
172 253
173 func (n *NovaSuite) TestCreateAndDeleteSecurityGroupRules(c *C) { 254 func (s *NovaSuite) TestCreateAndDeleteSecurityGroupRules(c *C) {
174 » group1, err := n.nova.CreateSecurityGroup("test_secgroup1", "test_desc") 255 » group1, err := s.nova.CreateSecurityGroup("test_secgroup1", "test_desc")
175 » c.Check(err, IsNil) 256 » c.Assert(err, IsNil)
176 » group2, err := n.nova.CreateSecurityGroup("test_secgroup2", "test_desc") 257 » group2, err := s.nova.CreateSecurityGroup("test_secgroup2", "test_desc")
177 » c.Check(err, IsNil) 258 » c.Assert(err, IsNil)
178 259
179 // First type of rule - port range + protocol 260 // First type of rule - port range + protocol
180 ri := nova.RuleInfo{ 261 ri := nova.RuleInfo{
181 IPProtocol: "tcp", 262 IPProtocol: "tcp",
182 FromPort: 1234, 263 FromPort: 1234,
183 ToPort: 4321, 264 ToPort: 4321,
184 Cidr: "10.0.0.0/8", 265 Cidr: "10.0.0.0/8",
185 ParentGroupId: group1.Id, 266 ParentGroupId: group1.Id,
186 } 267 }
187 » rule, err := n.nova.CreateSecurityGroupRule(ri) 268 » rule, err := s.nova.CreateSecurityGroupRule(ri)
188 » c.Check(err, IsNil) 269 » c.Assert(err, IsNil)
189 c.Check(*rule.FromPort, Equals, 1234) 270 c.Check(*rule.FromPort, Equals, 1234)
190 c.Check(*rule.ToPort, Equals, 4321) 271 c.Check(*rule.ToPort, Equals, 4321)
191 c.Check(rule.ParentGroupId, Equals, group1.Id) 272 c.Check(rule.ParentGroupId, Equals, group1.Id)
192 c.Check(*rule.IPProtocol, Equals, "tcp") 273 c.Check(*rule.IPProtocol, Equals, "tcp")
193 c.Check(rule.Group, IsNil) 274 c.Check(rule.Group, IsNil)
194 » err = n.nova.DeleteSecurityGroupRule(rule.Id) 275 » err = s.nova.DeleteSecurityGroupRule(rule.Id)
195 c.Check(err, IsNil) 276 c.Check(err, IsNil)
196 277
197 // Second type of rule - inherited from another group 278 // Second type of rule - inherited from another group
198 ri = nova.RuleInfo{ 279 ri = nova.RuleInfo{
199 GroupId: &group2.Id, 280 GroupId: &group2.Id,
200 ParentGroupId: group1.Id, 281 ParentGroupId: group1.Id,
201 } 282 }
202 » rule, err = n.nova.CreateSecurityGroupRule(ri) 283 » rule, err = s.nova.CreateSecurityGroupRule(ri)
203 » c.Check(err, IsNil) 284 » c.Assert(err, IsNil)
204 c.Check(rule.ParentGroupId, Equals, group1.Id) 285 c.Check(rule.ParentGroupId, Equals, group1.Id)
205 c.Check(rule.Group, NotNil) 286 c.Check(rule.Group, NotNil)
206 » c.Check(rule.Group.TenantId, Equals, n.tenantId) 287 » c.Check(rule.Group.TenantId, Equals, s.tenantId)
207 c.Check(rule.Group.Name, Equals, "test_secgroup2") 288 c.Check(rule.Group.Name, Equals, "test_secgroup2")
208 » err = n.nova.DeleteSecurityGroupRule(rule.Id) 289 » err = s.nova.DeleteSecurityGroupRule(rule.Id)
209 » c.Check(err, IsNil) 290 » c.Check(err, IsNil)
210 291
211 » err = n.nova.DeleteSecurityGroup(group1.Id) 292 » err = s.nova.DeleteSecurityGroup(group1.Id)
212 » c.Check(err, IsNil) 293 » c.Check(err, IsNil)
213 » err = n.nova.DeleteSecurityGroup(group2.Id) 294 » err = s.nova.DeleteSecurityGroup(group2.Id)
214 » c.Check(err, IsNil) 295 » c.Check(err, IsNil)
215 } 296 }
216 297
217 func (n *NovaSuite) TestGetServer(c *C) { 298 func (s *NovaSuite) TestGetServer(c *C) {
218 » server, err := n.nova.GetServer(n.testServerId) 299 » server, err := s.nova.GetServer(s.testServer.Id)
219 » c.Assert(err, IsNil) 300 » c.Assert(err, IsNil)
220 » c.Assert(server.Id, Equals, n.testServerId) 301 » s.assertServerDetails(c, server)
221 » c.Assert(server.Name, Equals, "test_server1") 302 }
222 » c.Assert(server.Flavor.Id, Equals, "1") 303
223 » c.Assert(server.Image.Id, Equals, "3fc0ef0b-82a9-4f44-a797-a43f0f73b20e" ) 304 func (s *NovaSuite) waitTestServerToStart(c *C) {
224 }
225
226 func (n *NovaSuite) waitTestServerToStart(c *C) {
227 // Wait until the test server is actually running 305 // Wait until the test server is actually running
228 » c.Logf("waiting the test server %s to start...", n.testServerId) 306 » c.Logf("waiting the test server %s to start...", s.testServer.Id)
229 for { 307 for {
230 » » server, err := n.nova.GetServer(n.testServerId) 308 » » server, err := s.nova.GetServer(s.testServer.Id)
231 » » c.Check(err, IsNil) 309 » » c.Assert(err, IsNil)
232 » » if server.Status == "ACTIVE" { 310 » » if server.Status != "aa" { //}nova.StatusActive {
233 break 311 break
234 } 312 }
235 // There's a rate limit of max 10 POSTs per minute! 313 // There's a rate limit of max 10 POSTs per minute!
236 time.Sleep(10 * time.Second) 314 time.Sleep(10 * time.Second)
237 } 315 }
238 c.Logf("started") 316 c.Logf("started")
239 } 317 }
240 318
241 func (n *NovaSuite) TestServerAddGetRemoveSecurityGroup(c *C) { 319 func (s *NovaSuite) TestServerAddGetRemoveSecurityGroup(c *C) {
242 » group, err := n.nova.CreateSecurityGroup("test_server_secgroup", "test d esc") 320 » group, err := s.nova.CreateSecurityGroup("test_server_secgroup", "test d esc")
243 » c.Assert(err, IsNil) 321 » c.Assert(err, IsNil)
244 322
245 » n.waitTestServerToStart(c) 323 » s.waitTestServerToStart(c)
246 » err = n.nova.AddServerSecurityGroup(n.testServerId, group.Name) 324 » err = s.nova.AddServerSecurityGroup(s.testServer.Id, group.Name)
247 » c.Check(err, IsNil) 325 » c.Assert(err, IsNil)
248 » groups, err := n.nova.GetServerSecurityGroups(n.testServerId) 326 » groups, err := s.nova.GetServerSecurityGroups(s.testServer.Id)
249 » c.Check(err, IsNil) 327 » c.Assert(err, IsNil)
250 found := false 328 found := false
251 for _, g := range groups { 329 for _, g := range groups {
252 if g.Id == group.Id || g.Name == group.Name { 330 if g.Id == group.Id || g.Name == group.Name {
253 found = true 331 found = true
254 break 332 break
255 } 333 }
256 } 334 }
257 » err = n.nova.RemoveServerSecurityGroup(n.testServerId, group.Name) 335 » err = s.nova.RemoveServerSecurityGroup(s.testServer.Id, group.Name)
258 » c.Check(err, IsNil) 336 » c.Check(err, IsNil)
259 337
260 » err = n.nova.DeleteSecurityGroup(group.Id) 338 » err = s.nova.DeleteSecurityGroup(group.Id)
261 c.Assert(err, IsNil) 339 c.Assert(err, IsNil)
262 340
263 if !found { 341 if !found {
264 c.Fail() 342 c.Fail()
265 } 343 }
266 } 344 }
267 345
268 func (n *NovaSuite) TestFloatingIPs(c *C) { 346 func (s *NovaSuite) TestFloatingIPs(c *C) {
269 » ip, err := n.nova.AllocateFloatingIP() 347 » ip, err := s.nova.AllocateFloatingIP()
270 c.Assert(err, IsNil) 348 c.Assert(err, IsNil)
271 c.Check(ip.IP, Not(Equals), "") 349 c.Check(ip.IP, Not(Equals), "")
272 c.Check(ip.Pool, Not(Equals), "") 350 c.Check(ip.Pool, Not(Equals), "")
273 c.Check(ip.FixedIP, IsNil) 351 c.Check(ip.FixedIP, IsNil)
274 c.Check(ip.InstanceId, IsNil) 352 c.Check(ip.InstanceId, IsNil)
275 353
276 » ips, err := n.nova.ListFloatingIPs() 354 » ips, err := s.nova.ListFloatingIPs()
277 » c.Check(err, IsNil) 355 » c.Assert(err, IsNil)
278 if len(ips) < 1 { 356 if len(ips) < 1 {
279 c.Errorf("no floating IPs found (expected at least 1)") 357 c.Errorf("no floating IPs found (expected at least 1)")
280 } else { 358 } else {
281 found := false 359 found := false
282 for _, i := range ips { 360 for _, i := range ips {
283 c.Check(i.IP, Not(Equals), "") 361 c.Check(i.IP, Not(Equals), "")
284 c.Check(i.Pool, Not(Equals), "") 362 c.Check(i.Pool, Not(Equals), "")
285 if i.Id == ip.Id { 363 if i.Id == ip.Id {
286 c.Check(i.IP, Equals, ip.IP) 364 c.Check(i.IP, Equals, ip.IP)
287 c.Check(i.Pool, Equals, ip.Pool) 365 c.Check(i.Pool, Equals, ip.Pool)
288 found = true 366 found = true
289 } 367 }
290 } 368 }
291 if !found { 369 if !found {
292 c.Errorf("expected to find added floating IP: %#v", ip) 370 c.Errorf("expected to find added floating IP: %#v", ip)
293 } 371 }
294 372
295 » » fip, err := n.nova.GetFloatingIP(ip.Id) 373 » » fip, err := s.nova.GetFloatingIP(ip.Id)
296 » » c.Check(err, IsNil) 374 » » c.Assert(err, IsNil)
297 c.Check(fip.Id, Equals, ip.Id) 375 c.Check(fip.Id, Equals, ip.Id)
298 c.Check(fip.IP, Equals, ip.IP) 376 c.Check(fip.IP, Equals, ip.IP)
299 c.Check(fip.Pool, Equals, ip.Pool) 377 c.Check(fip.Pool, Equals, ip.Pool)
300 } 378 }
301 » err = n.nova.DeleteFloatingIP(ip.Id) 379 » err = s.nova.DeleteFloatingIP(ip.Id)
302 » c.Check(err, IsNil) 380 » c.Check(err, IsNil)
303 } 381 }
304 382
305 func (n *NovaSuite) TestServerFloatingIPs(c *C) { 383 func (s *NovaSuite) TestServerFloatingIPs(c *C) {
306 » ip, err := n.nova.AllocateFloatingIP() 384 » ip, err := s.nova.AllocateFloatingIP()
307 c.Assert(err, IsNil) 385 c.Assert(err, IsNil)
308 c.Check(ip.IP, Matches, `\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}`) 386 c.Check(ip.IP, Matches, `\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}`)
309 387
310 » n.waitTestServerToStart(c) 388 » s.waitTestServerToStart(c)
311 » err = n.nova.AddServerFloatingIP(n.testServerId, ip.IP) 389 » err = s.nova.AddServerFloatingIP(s.testServer.Id, ip.IP)
312 » c.Check(err, IsNil) 390 » c.Assert(err, IsNil)
313 391
314 » fip, err := n.nova.GetFloatingIP(ip.Id) 392 » fip, err := s.nova.GetFloatingIP(ip.Id)
315 » c.Check(err, IsNil) 393 » c.Assert(err, IsNil)
316 c.Check(fip.FixedIP, Matches, `\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}`) 394 c.Check(fip.FixedIP, Matches, `\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}`)
317 » c.Check(fip.InstanceId, Equals, n.testServerId) 395 » c.Check(fip.InstanceId, Equals, s.testServer.Id)
318 396
319 » err = n.nova.RemoveServerFloatingIP(n.testServerId, ip.IP) 397 » err = s.nova.RemoveServerFloatingIP(s.testServer.Id, ip.IP)
320 » c.Check(err, IsNil) 398 » c.Check(err, IsNil)
321 » fip, err = n.nova.GetFloatingIP(ip.Id) 399 » fip, err = s.nova.GetFloatingIP(ip.Id)
322 » c.Check(err, IsNil) 400 » c.Assert(err, IsNil)
323 c.Check(fip.FixedIP, IsNil) 401 c.Check(fip.FixedIP, IsNil)
324 c.Check(fip.InstanceId, IsNil) 402 c.Check(fip.InstanceId, IsNil)
325 403
326 » err = n.nova.DeleteFloatingIP(ip.Id) 404 » err = s.nova.DeleteFloatingIP(ip.Id)
327 » c.Check(err, IsNil) 405 » c.Check(err, IsNil)
328 } 406 }
LEFTRIGHT

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