1 # Copyright 2012-2013 GRNET S.A. All rights reserved.
3 # Redistribution and use in source and binary forms, with or
4 # without modification, are permitted provided that the following
7 # 1. Redistributions of source code must retain the above
8 # copyright notice, this list of conditions and the following
11 # 2. Redistributions in binary form must reproduce the above
12 # copyright notice, this list of conditions and the following
13 # disclaimer in the documentation and/or other materials
14 # provided with the distribution.
16 # THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
17 # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
20 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
23 # USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
24 # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
26 # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 # POSSIBILITY OF SUCH DAMAGE.
29 # The views and conclusions contained in the software and
30 # documentation are those of the authors and should not be
31 # interpreted as representing official policies, either expressed
32 # or implied, of GRNET S.A.
33 from mock import patch, Mock
34 from unittest import TestCase
35 from json import loads
37 from kamaki.clients import Client, ClientError
39 img_ref = "1m4g3-r3f3r3nc3"
42 vm_send = dict(server=dict(
46 metadata=dict(os="debian", users="root")))
47 vm_recv = dict(server=dict(
49 updated="2013-03-01T10:04:00.637152+00:00",
53 created="2013-03-01T10:04:00.087324+00:00",
55 adminPass="n0n3sh@11p@55",
59 metadata=dict(values=dict(os="debian", users="root"))))
60 img_recv = dict(image=dict(
62 updated="2013-02-26T11:10:14+00:00",
64 created="2013-02-26T11:03:29+00:00",
67 metadata=dict(values=dict(
68 partition_table="msdos",
76 description="Debian 6.0.7 (Squeeze) Base System"))))
77 vm_list = dict(servers=dict(values=[
78 dict(name='n1', id=1),
79 dict(name='n2', id=2)]))
82 class Cyclades(TestCase):
84 def assert_dicts_are_equal(self, d1, d2):
85 for k, v in d1.items():
86 self.assertTrue(k in d2)
87 if isinstance(v, dict):
88 self.assert_dicts_are_equal(v, d2[k])
90 self.assertEqual(unicode(v), unicode(d2[k]))
93 """FR stands for Fake Response"""
103 """Set up a Cyclades thorough test"""
105 self.url = 'http://cyclades.example.com'
106 self.token = 'cyc14d3s70k3n'
107 from kamaki.clients.cyclades import CycladesClient
108 self.client = CycladesClient(self.url, self.token)
109 from kamaki.clients.connection.kamakicon import KamakiHTTPConnection
110 self.C = KamakiHTTPConnection
113 self.FR.status_code = 200
114 self.FR.json = vm_recv
116 def test_create_server(self):
117 self.client.get_image_details = Mock(return_value=img_recv['image'])
118 with patch.object(Client, 'request', side_effect=ClientError(
119 'REQUEST ENTITY TOO LARGE',
123 self.client.create_server,
124 vm_name, fid, img_ref)
129 return_value=self.FR()) as perform_req:
132 self.client.create_server,
133 vm_name, fid, img_ref)
134 self.FR.status_code = 202
135 r = self.client.create_server(vm_name, fid, img_ref)
136 self.assertEqual(self.client.http_client.url, self.url)
137 self.assertEqual(self.client.http_client.path, '/servers')
138 (method, data, a_headers, a_params) = perform_req.call_args[0]
139 self.assert_dicts_are_equal(loads(data), vm_send)
140 self.assert_dicts_are_equal(r, vm_recv['server'])
141 prsn = 'Personality string (does not work with real servers)'
142 self.client.create_server(vm_name, fid, img_ref, prsn)
143 (method, data, a_headers, a_params) = perform_req.call_args[0]
145 self.assertTrue('personality' in data['server'])
146 self.assertEqual(prsn, data['server']['personality'])
148 def test_list_servers(self):
149 self.FR.json = vm_list
153 return_value=self.FR()) as perform_req:
154 r = self.client.list_servers()
155 self.assertEqual(self.client.http_client.url, self.url)
156 self.assertEqual(self.client.http_client.path, '/servers')
157 (method, data, a_headers, a_params) = perform_req.call_args[0]
158 self.assert_dicts_are_equal(dict(values=r), vm_list['servers'])
159 r = self.client.list_servers(detail=True)
160 self.assertEqual(self.client.http_client.url, self.url)
161 self.assertEqual(self.client.http_client.path, '/servers/detail')
162 from kamaki.clients.cyclades_rest_api import CycladesClientApi
166 return_value=self.FR()) as servers_get:
167 self.client.list_servers(changes_since=True)
168 self.assertTrue(servers_get.call_args[1]['changes_since'])
170 def test_get_server_details(self):
171 vm_id = vm_recv['server']['id']
172 with patch.object(self.C, 'perform_request', return_value=self.FR()):
173 r = self.client.get_server_details(vm_id)
174 self.assertEqual(self.client.http_client.url, self.url)
176 self.client.http_client.path,
177 '/servers/%s' % vm_id)
178 self.assert_dicts_are_equal(r, vm_recv['server'])
180 def test_update_server_name(self):
181 vm_id = vm_recv['server']['id']
182 new_name = vm_name + '_new'
183 self.FR.status_code = 204
187 return_value=self.FR()) as perform_req:
188 self.client.update_server_name(vm_id, new_name)
189 self.assertEqual(self.client.http_client.url, self.url)
191 self.client.http_client.path,
192 '/servers/%s' % vm_id)
193 (method, data, a_headers, a_params) = perform_req.call_args[0]
194 self.assert_dicts_are_equal(
195 dict(server=dict(name=new_name)),
198 def test_reboot_server(self):
199 vm_id = vm_recv['server']['id']
200 self.FR.status_code = 202
204 return_value=self.FR()) as perform_req:
205 self.client.reboot_server(vm_id)
206 self.assertEqual(self.client.http_client.url, self.url)
208 self.client.http_client.path,
209 '/servers/%s/action' % vm_id)
210 (method, data, a_headers, a_params) = perform_req.call_args[0]
211 self.assert_dicts_are_equal(
212 dict(reboot=dict(type='SOFT')),
215 def test_create_server_metadata(self):
216 vm_id = vm_recv['server']['id']
217 metadata = dict(m1='v1', m2='v2', m3='v3')
218 self.FR.json = dict(meta=vm_recv['server'])
222 return_value=self.FR()) as perform_req:
225 self.client.create_server_metadata,
226 vm_id, 'key', 'value')
227 self.FR.status_code = 201
228 for k, v in metadata.items():
229 r = self.client.create_server_metadata(vm_id, k, v)
230 self.assertEqual(self.client.http_client.url, self.url)
232 self.client.http_client.path,
233 '/servers/%s/meta/%s' % (vm_id, k))
234 (method, data, a_headers, a_params) = perform_req.call_args[0]
235 self.assertEqual(dict(meta={k: v}), loads(data))
236 self.assert_dicts_are_equal(r, vm_recv['server'])
238 def test_get_server_metadata(self):
239 vm_id = vm_recv['server']['id']
240 metadata = dict(m1='v1', m2='v2', m3='v3')
241 with patch.object(self.C, 'perform_request', return_value=self.FR()):
242 self.FR.json = dict(metadata=dict(values=metadata))
243 r = self.client.get_server_metadata(vm_id)
244 self.assertEqual(self.client.http_client.url, self.url)
246 self.client.http_client.path,
247 '/servers/%s/meta' % vm_id)
248 self.assert_dicts_are_equal(r, metadata)
250 for k, v in metadata.items():
251 self.FR.json = dict(meta={k: v})
252 r = self.client.get_server_metadata(vm_id, k)
253 self.assertEqual(self.client.http_client.url, self.url)
255 self.client.http_client.path,
256 '/servers/%s/meta/%s' % (vm_id, k))
257 self.assert_dicts_are_equal(r, {k: v})
260 def test_update_server_metadata(self):
261 r1 = self.client.create_server_metadata(
265 self.assertTrue('mymeta3'in r1)
266 r2 = self.client.update_server_metadata(
269 self.assertTrue(r2['mymeta3'], 'val3')
271 def test_delete_server_metadata(self):
272 r1 = self.client.create_server_metadata(
276 self.assertTrue('mymeta' in r1)
277 self.client.delete_server_metadata(self.server1['id'], 'mymeta')
279 self.client.get_server_metadata(self.server1['id'], 'mymeta')
280 raise ClientError('Wrong Error', status=100)
281 except ClientError as err:
282 self.assertEqual(err.status, 404)
284 def test_list_flavors(self):
285 r = self.client.list_flavors()
286 self.assertTrue(len(r) > 1)
287 r = self.client.list_flavors(detail=True)
288 self.assertTrue('SNF:disk_template' in r[0])
290 def test_get_flavor_details(self):
291 r = self.client.get_flavor_details(self.flavorid)
292 self.assert_dicts_are_equal(self._flavor_details, r)
294 def test_list_images(self):
295 r = self.client.list_images()
296 self.assertTrue(len(r) > 1)
297 r = self.client.list_images(detail=True)
298 for detailed_img in r:
299 if detailed_img['id'] == self.img:
301 self.assert_dicts_are_equal(detailed_img, self.img_details)
303 def test_get_image_details(self):
304 r = self.client.get_image_details(self.img)
305 self.assert_dicts_are_equal(r, self.img_details)
307 def test_get_image_metadata(self):
308 r = self.client.get_image_metadata(self.img)
309 self.assert_dicts_are_equal(
310 self.img_details['metadata']['values'], r)
311 for key, val in self.img_details['metadata']['values'].items():
312 r = self.client.get_image_metadata(self.img, key)
313 self.assertEqual(r[key], val)
315 def test_shutdown_server(self):
316 self.client.shutdown_server(self.server1['id'])
317 self._wait_for_status(self.server1['id'], 'ACTIVE')
318 r = self.client.get_server_details(self.server1['id'])
319 self.assertEqual(r['status'], 'STOPPED')
321 def test_start_server(self):
322 self.client.start_server(self.server1['id'])
323 self._wait_for_status(self.server1['id'], 'STOPPED')
324 r = self.client.get_server_details(self.server1['id'])
325 self.assertEqual(r['status'], 'ACTIVE')
327 def test_get_server_console(self):
328 r = self.client.get_server_console(self.server2['id'])
329 self.assertTrue('host' in r)
330 self.assertTrue('password' in r)
331 self.assertTrue('port' in r)
332 self.assertTrue('type' in r)
334 def test_get_firewall_profile(self):
335 self._wait_for_status(self.server1['id'], 'BUILD')
336 fprofile = self.client.get_firewall_profile(self.server1['id'])
337 self.assertTrue(fprofile in self.PROFILES)
339 def test_set_firewall_profile(self):
340 self._wait_for_status(self.server1['id'], 'BUILD')
341 PROFILES = ['DISABLED', 'ENABLED', 'DISABLED', 'PROTECTED']
342 fprofile = self.client.get_firewall_profile(self.server1['id'])
345 for counter, fprofile in enumerate(PROFILES):
348 nprofile = PROFILES[npos]
350 nprofile = PROFILES[0]
351 print('\tprofile swap %s: %s -> %s' % (npos, fprofile, nprofile))
352 self.client.set_firewall_profile(self.server1['id'], nprofile)
354 self.client.reboot_server(self.server1['id'], hard=True)
356 self._wait_for_status(self.server1['id'], 'REBOOT')
358 changed = self.client.get_firewall_profile(self.server1['id'])
360 self.assertEqual(changed, nprofile)
361 except AssertionError as err:
363 print('\tFAIL in swap #%s' % npos)
369 def test_get_server_stats(self):
370 r = self.client.get_server_stats(self.server1['id'])
371 it = ('cpuBar', 'cpuTimeSeries', 'netBar', 'netTimeSeries', 'refresh')
373 self.assertTrue(term in r)
375 def test_create_network(self):
376 print('\twith no params')
377 self.network1 = self._create_network(self.netname1)
378 self._wait_for_network(self.network1['id'], 'ACTIVE')
379 n1id = self.network1['id']
380 self.network1 = self.client.get_network_details(n1id)
381 nets = self.client.list_networks(self.network1['id'])
382 chosen = [net for net in nets if net['id'] == n1id][0]
383 chosen.pop('updated')
384 net1 = dict(self.network1)
386 self.assert_dicts_are_equal(chosen, net1)
387 for param, val in dict(
388 cidr='192.168.0.0/24',
389 gateway='192.168.0.1',
392 print('\tdelete %s to avoid max net limit' % n1id)
393 self._delete_network(n1id)
394 kwargs = {param: val}
395 print('\twith %s=%s' % (param, val))
396 self.network1 = self._create_network(self.netname1, **kwargs)
397 n1id = self.network1['id']
398 self._wait_for_network(n1id, 'ACTIVE')
399 self.network1 = self.client.get_network_details(n1id)
400 self.assertEqual(self.network1[param], val)
402 def test_connect_server(self):
403 self.client.connect_server(self.server1['id'], self.network1['id'])
404 self.assertTrue(self._wait_for_nic(
408 def test_disconnect_server(self):
409 self.client.disconnect_server(self.server1['id'], self.network1['id'])
410 self.assertTrue(self._wait_for_nic(
415 def _test_0260_wait_for_second_network(self):
416 self.server1 = self._create_server(
420 self.network2 = self._create_network(self.netname2)
421 self._wait_for_status(self.server1['id'], 'BUILD')
422 self._wait_for_network(self.network2['id'], 'ACTIVE')
423 self._test_0280_list_server_nics()
425 def _test_0280_list_server_nics(self):
426 r = self.client.list_server_nics(self.server1['id'])
428 self.client.connect_server(self.server1['id'], self.network2['id'])
429 self.assertTrue(self._wait_for_nic(
432 r = self.client.list_server_nics(self.server1['id'])
433 self.assertTrue(len(r) > len0)
435 def test_list_networks(self):
436 r = self.client.list_networks()
437 self.assertTrue(len(r) > 1)
438 ids = [net['id'] for net in r]
439 names = [net['name'] for net in r]
440 self.assertTrue('1' in ids)
441 #self.assertTrue('public' in names)
442 self.assertTrue(self.network1['id'] in ids)
443 self.assertTrue(self.network1['name'] in names)
445 r = self.client.list_networks(detail=True)
446 ids = [net['id'] for net in r]
447 names = [net['name'] for net in r]
449 self.assertTrue(net['id'] in ids)
450 self.assertTrue(net['name'] in names)
451 for term in ('status', 'updated', 'created'):
452 self.assertTrue(term in net.keys())
454 def test_get_network_details(self):
455 r = self.client.get_network_details(self.network1['id'])
456 net1 = dict(self.network1)
458 net1.pop('updated', None)
459 net1.pop('attachments')
461 r.pop('updated', None)
463 self.assert_dicts_are_equal(net1, r)
465 def test_update_network_name(self):
466 updated_name = self.netname2 + '_upd'
467 self.client.update_network_name(self.network2['id'], updated_name)
470 r = self.client.get_network_details(self.network2['id'])
471 if r['name'] == updated_name:
474 self.do_with_progress_bar(
476 'Network %s name is changing:' % self.network2['id'],
479 r = self.client.get_network_details(self.network2['id'])
480 self.assertEqual(r['name'], updated_name)
482 def test_delete_image(self):
483 images = self.client.list_images()
484 self.client.delete_image(images[2]['id'])
486 r = self.client.get_image_details(images[2]['id'], success=(400))
487 except ClientError as err:
488 self.assertEqual(err.status, 404)
490 def test_create_image_metadata(self):
491 r = self.client.create_image_metadata(self.img, 'mykey', 'myval')
492 self.assertEqual(r['mykey'], 'myval')
494 def test_update_image_metadata(self):
495 r = self.client.create_image_metadata(self.img, 'mykey0', 'myval')
496 r = self.client.update_image_metadata(self.img, 'mykey0', 'myval0')
497 self.assertEqual(r['mykey0'], 'myval0')
499 def test_delete_image_metadata(self):
500 self.client.create_image_metadata(self.img, 'mykey1', 'myval1')
501 self.client.delete_image_metadata(self.img, 'mykey1')
502 r = self.client.get_image_metadata(self.img)
503 self.assertNotEqual('mykey1' in r)