LEFT | RIGHT |
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 } |
LEFT | RIGHT |