Revision 257b931a kamaki/clients/test/cyclades.py
| b/kamaki/clients/test/cyclades.py | ||
|---|---|---|
| 73 | 73 |
os="debian", |
| 74 | 74 |
root_partition="1", |
| 75 | 75 |
description="Debian 6.0.7 (Squeeze) Base System")))) |
| 76 |
vm_list = dict(servers=dict(values=[ |
|
| 77 |
dict(name='n1', id=1), |
|
| 78 |
dict(name='n2', id=2)])) |
|
| 76 | 79 |
|
| 77 | 80 |
|
| 78 | 81 |
class Cyclades(TestCase): |
| 79 | 82 |
|
| 80 |
def assert_dicts_are_deeply_equal(self, d1, d2):
|
|
| 83 |
def assert_dicts_are_equal(self, d1, d2): |
|
| 81 | 84 |
for k, v in d1.items(): |
| 82 | 85 |
self.assertTrue(k in d2) |
| 83 | 86 |
if isinstance(v, dict): |
| 84 |
self.assert_dicts_are_deeply_equal(v, d2[k])
|
|
| 87 |
self.assert_dicts_are_equal(v, d2[k]) |
|
| 85 | 88 |
else: |
| 86 | 89 |
self.assertEqual(unicode(v), unicode(d2[k])) |
| 87 | 90 |
|
| ... | ... | |
| 106 | 109 |
self.C = KamakiHTTPConnection |
| 107 | 110 |
|
| 108 | 111 |
def tearDown(self): |
| 109 |
pass
|
|
| 112 |
self.FR.status_code = 200
|
|
| 110 | 113 |
|
| 111 | 114 |
def test_create_server(self): |
| 112 | 115 |
self.client.get_image_details = Mock(return_value=img_recv['image']) |
| ... | ... | |
| 131 | 134 |
self.assertEqual(self.client.http_client.url, self.url) |
| 132 | 135 |
self.assertEqual(self.client.http_client.path, '/servers') |
| 133 | 136 |
(method, data, a_headers, a_params) = perform_req.call_args[0] |
| 134 |
self.assert_dicts_are_deeply_equal(loads(data), vm_send)
|
|
| 135 |
self.assert_dicts_are_deeply_equal(r, vm_recv['server'])
|
|
| 137 |
self.assert_dicts_are_equal(loads(data), vm_send) |
|
| 138 |
self.assert_dicts_are_equal(r, vm_recv['server']) |
|
| 136 | 139 |
prsn = 'Personality string (does not work with real servers)' |
| 137 | 140 |
self.client.create_server(vm_name, fid, img_ref, prsn) |
| 138 | 141 |
(method, data, a_headers, a_params) = perform_req.call_args[0] |
| ... | ... | |
| 140 | 143 |
self.assertTrue('personality' in data['server'])
|
| 141 | 144 |
self.assertEqual(prsn, data['server']['personality']) |
| 142 | 145 |
|
| 143 |
""" |
|
| 144 | 146 |
def test_list_servers(self): |
| 147 |
self.FR.json = vm_list |
|
| 148 |
with patch.object( |
|
| 149 |
self.C, |
|
| 150 |
'perform_request', |
|
| 151 |
return_value=self.FR()) as perform_req: |
|
| 152 |
r = self.client.list_servers() |
|
| 153 |
self.assertEqual(self.client.http_client.url, self.url) |
|
| 154 |
self.assertEqual(self.client.http_client.path, '/servers') |
|
| 155 |
(method, data, a_headers, a_params) = perform_req.call_args[0] |
|
| 156 |
self.assert_dicts_are_equal(dict(values=r), vm_list['servers']) |
|
| 157 |
r = self.client.list_servers(detail=True) |
|
| 158 |
self.assertEqual(self.client.http_client.url, self.url) |
|
| 159 |
self.assertEqual(self.client.http_client.path, '/servers/detail') |
|
| 160 |
from kamaki.clients.cyclades_rest_api import CycladesClientApi |
|
| 161 |
with patch.object( |
|
| 162 |
CycladesClientApi, |
|
| 163 |
'servers_get', |
|
| 164 |
return_value=self.FR()) as servers_get: |
|
| 165 |
self.client.list_servers(changes_since=True) |
|
| 166 |
self.assertTrue(servers_get.call_args[1]['changes_since']) |
|
| 145 | 167 |
|
| 146 |
servers = self.client.list_servers() |
|
| 147 |
dservers = self.client.list_servers(detail=True) |
|
| 148 |
|
|
| 149 |
""detailed and simple are same size"" |
|
| 150 |
self.assertEqual(len(dservers), len(servers)) |
|
| 151 |
for i in range(len(servers)): |
|
| 152 |
for field in ( |
|
| 153 |
'created', |
|
| 154 |
'flavorRef', |
|
| 155 |
'hostId', |
|
| 156 |
'imageRef', |
|
| 157 |
'progress', |
|
| 158 |
'status', |
|
| 159 |
'updated'): |
|
| 160 |
self.assertFalse(field in servers[i]) |
|
| 161 |
self.assertTrue(field in dservers[i]) |
|
| 162 |
|
|
| 163 |
""detailed and simple contain same names"" |
|
| 164 |
names = sorted(map(lambda x: x["name"], servers)) |
|
| 165 |
dnames = sorted(map(lambda x: x["name"], dservers)) |
|
| 166 |
self.assertEqual(names, dnames) |
|
| 167 |
|
|
| 168 |
def _test_0030_wait_test_servers_to_build(self): |
|
| 169 |
self.server1 = self._create_server( |
|
| 170 |
self.servname1, |
|
| 171 |
self.flavorid, |
|
| 172 |
self.img) |
|
| 173 |
self._wait_for_status(self.server1['id'], 'BUILD') |
|
| 174 |
self._test_0040_get_server_details() |
|
| 175 |
|
|
| 168 |
""" |
|
| 176 | 169 |
def _test_0040_get_server_details(self): |
| 177 | 170 |
self.server1 = self._create_server( |
| 178 | 171 |
self.servname1, |
| ... | ... | |
| 203 | 196 |
'mymeta val') |
| 204 | 197 |
self.assertTrue('mymeta' in r1)
|
| 205 | 198 |
r2 = self.client.get_server_metadata(self.server1['id'], 'mymeta') |
| 206 |
self.assert_dicts_are_deeply_equal(r1, r2)
|
|
| 199 |
self.assert_dicts_are_equal(r1, r2) |
|
| 207 | 200 |
|
| 208 | 201 |
def test_get_server_metadata(self): |
| 209 | 202 |
self.client.create_server_metadata( |
| ... | ... | |
| 245 | 238 |
|
| 246 | 239 |
def test_get_flavor_details(self): |
| 247 | 240 |
r = self.client.get_flavor_details(self.flavorid) |
| 248 |
self.assert_dicts_are_deeply_equal(self._flavor_details, r)
|
|
| 241 |
self.assert_dicts_are_equal(self._flavor_details, r) |
|
| 249 | 242 |
|
| 250 | 243 |
def test_list_images(self): |
| 251 | 244 |
r = self.client.list_images() |
| ... | ... | |
| 254 | 247 |
for detailed_img in r: |
| 255 | 248 |
if detailed_img['id'] == self.img: |
| 256 | 249 |
break |
| 257 |
self.assert_dicts_are_deeply_equal(detailed_img, self.img_details)
|
|
| 250 |
self.assert_dicts_are_equal(detailed_img, self.img_details) |
|
| 258 | 251 |
|
| 259 | 252 |
def test_get_image_details(self): |
| 260 | 253 |
r = self.client.get_image_details(self.img) |
| 261 |
self.assert_dicts_are_deeply_equal(r, self.img_details)
|
|
| 254 |
self.assert_dicts_are_equal(r, self.img_details) |
|
| 262 | 255 |
|
| 263 | 256 |
def test_get_image_metadata(self): |
| 264 | 257 |
r = self.client.get_image_metadata(self.img) |
| 265 |
self.assert_dicts_are_deeply_equal(
|
|
| 258 |
self.assert_dicts_are_equal( |
|
| 266 | 259 |
self.img_details['metadata']['values'], r) |
| 267 | 260 |
for key, val in self.img_details['metadata']['values'].items(): |
| 268 | 261 |
r = self.client.get_image_metadata(self.img, key) |
| ... | ... | |
| 339 | 332 |
chosen.pop('updated')
|
| 340 | 333 |
net1 = dict(self.network1) |
| 341 | 334 |
net1.pop('updated')
|
| 342 |
self.assert_dicts_are_deeply_equal(chosen, net1)
|
|
| 335 |
self.assert_dicts_are_equal(chosen, net1) |
|
| 343 | 336 |
for param, val in dict( |
| 344 | 337 |
cidr='192.168.0.0/24', |
| 345 | 338 |
gateway='192.168.0.1', |
| ... | ... | |
| 416 | 409 |
r.pop('status')
|
| 417 | 410 |
r.pop('updated', None)
|
| 418 | 411 |
r.pop('attachments')
|
| 419 |
self.assert_dicts_are_deeply_equal(net1, r)
|
|
| 412 |
self.assert_dicts_are_equal(net1, r) |
|
| 420 | 413 |
|
| 421 | 414 |
def test_update_network_name(self): |
| 422 | 415 |
updated_name = self.netname2 + '_upd' |
Also available in: Unified diff