1 ##############################################################################
2 # Copyright (c) 2015 Ericsson AB and others.
4 # All rights reserved. This program and the accompanying materials
5 # are made available under the terms of the Apache License, Version 2.0
6 # which accompanies this distribution, and is available at
7 # http://www.apache.org/licenses/LICENSE-2.0
8 ##############################################################################
10 from collections import OrderedDict
17 from yardstick.benchmark.contexts import base
18 from yardstick.benchmark.contexts import heat
19 from yardstick.benchmark.contexts import model
20 from yardstick.common import constants as consts
21 from yardstick.common import exceptions as y_exc
22 from yardstick.common import openstack_utils
23 from yardstick.common import yaml_loader
24 from yardstick import ssh
27 LOG = logging.getLogger(__name__)
30 class HeatContextTestCase(unittest.TestCase):
37 "ip": "10.229.47.137",
39 "key_filename": "/root/.yardstick_key"
44 "ip": "10.229.47.139",
46 "key_filename": "/root/.yardstick_key"
51 def __init__(self, *args, **kwargs):
53 super(HeatContextTestCase, self).__init__(*args, **kwargs)
56 self.test_context = heat.HeatContext()
57 self.addCleanup(self._remove_contexts)
58 self.mock_context = mock.Mock(spec=heat.HeatContext())
60 def _remove_contexts(self):
61 if self.test_context in self.test_context.list:
62 self.test_context._delete_context()
64 def test___init__(self):
65 self.assertIsNone(self.test_context._name)
66 self.assertIsNone(self.test_context._task_id)
67 self.assertFalse(self.test_context._flags.no_setup)
68 self.assertFalse(self.test_context._flags.no_teardown)
69 self.assertIsNone(self.test_context.stack)
70 self.assertEqual(self.test_context.networks, OrderedDict())
71 self.assertEqual(self.test_context.servers, [])
72 self.assertEqual(self.test_context.placement_groups, [])
73 self.assertEqual(self.test_context.server_groups, [])
74 self.assertIsNone(self.test_context.keypair_name)
75 self.assertIsNone(self.test_context.secgroup_name)
76 self.assertIsNone(self.test_context.security_group)
77 self.assertEqual(self.test_context._server_map, {})
78 self.assertIsNone(self.test_context._image)
79 self.assertIsNone(self.test_context._flavor)
80 self.assertIsNone(self.test_context._user)
81 self.assertIsNone(self.test_context.template_file)
82 self.assertIsNone(self.test_context.heat_parameters)
83 self.assertIsNone(self.test_context.key_filename)
84 self.assertTrue(self.test_context.yardstick_gen_key_file)
86 @mock.patch.object(yaml_loader, 'read_yaml_file')
87 @mock.patch('yardstick.benchmark.contexts.heat.PlacementGroup')
88 @mock.patch('yardstick.benchmark.contexts.heat.ServerGroup')
89 @mock.patch('yardstick.benchmark.contexts.heat.Network')
90 @mock.patch('yardstick.benchmark.contexts.heat.Server')
91 def test_init(self, mock_server, mock_network, mock_sg, mock_pg,
94 mock_read_yaml.return_value = self.HEAT_POD_SAMPLE
95 pgs = {'pgrp1': {'policy': 'availability'}}
96 sgs = {'servergroup1': {'policy': 'affinity'}}
97 networks = {'bar': {'cidr': '10.0.1.0/24'}}
98 servers = {'baz': {'floating_ip': True, 'placement': 'pgrp1'}}
99 attrs = {'name': 'foo',
101 'task_id': '1234567890',
102 'placement_groups': pgs,
103 'server_groups': sgs,
104 'networks': networks,
107 with mock.patch.object(openstack_utils, 'get_shade_client'), \
108 mock.patch.object(openstack_utils, 'get_shade_operator_client'):
109 self.test_context.init(attrs)
111 self.assertFalse(self.test_context._flags.no_setup)
112 self.assertFalse(self.test_context._flags.no_teardown)
113 self.assertEqual(self.test_context._name, "foo")
114 self.assertEqual(self.test_context._task_id, '1234567890')
115 self.assertEqual(self.test_context.name, "foo-12345678")
116 self.assertEqual(self.test_context.keypair_name, "foo-12345678-key")
117 self.assertEqual(self.test_context.secgroup_name, "foo-12345678-secgroup")
119 mock_pg.assert_called_with('pgrp1', self.test_context,
120 pgs['pgrp1']['policy'])
121 mock_sg.assert_called_with('servergroup1', self.test_context,
122 sgs['servergroup1']['policy'])
123 self.assertEqual(len(self.test_context.placement_groups), 1)
124 self.assertEqual(len(self.test_context.server_groups), 1)
126 mock_network.assert_called_with(
127 'bar', self.test_context, networks['bar'])
128 self.assertEqual(len(self.test_context.networks), 1)
130 mock_server.assert_called_with('baz', self.test_context,
132 self.assertEqual(len(self.test_context.servers), 1)
134 def test_init_no_name_or_task_id(self):
136 self.assertRaises(KeyError, self.test_context.init, attrs)
139 self.test_context._name = 'foo'
140 self.test_context._task_id = '1234567890'
141 self.test_context._name_task_id = '{}-{}'.format(
142 self.test_context._name, self.test_context._task_id[:8])
143 self.assertEqual(self.test_context.name, 'foo-12345678')
144 self.assertEqual(self.test_context.assigned_name, 'foo')
146 def test_name_flags(self):
147 self.test_context._flags = base.Flags(
148 **{"no_setup": True, "no_teardown": True})
149 self.test_context._name = 'foo'
150 self.test_context._task_id = '1234567890'
152 self.assertEqual(self.test_context.name, 'foo')
153 self.assertEqual(self.test_context.assigned_name, 'foo')
155 def test_init_no_setup_no_teardown(self):
157 attrs = {'name': 'foo',
158 'task_id': '1234567890',
159 'placement_groups': {},
170 with mock.patch.object(openstack_utils, 'get_shade_client'), \
171 mock.patch.object(openstack_utils, 'get_shade_operator_client'):
172 self.test_context.init(attrs)
174 self.assertTrue(self.test_context._flags.no_setup)
175 self.assertTrue(self.test_context._flags.no_teardown)
177 def test_init_key_filename(self):
178 attrs = {'name': 'foo',
180 'task_id': '1234567890',
184 'heat_template': "/root/clearwater.yaml",
185 'key_filename': '/etc/yardstick/yardstick.pem'}
187 with mock.patch.object(openstack_utils, 'get_shade_client'), \
188 mock.patch.object(openstack_utils, 'get_shade_operator_client'):
189 self.test_context.init(attrs)
191 self.assertIsNotNone(self.test_context.key_filename)
192 self.assertFalse(self.test_context.yardstick_gen_key_file)
194 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
195 def test__add_resources_to_template_no_servers(self, mock_template):
196 self.test_context._name = 'ctx'
197 self.test_context._task_id = '1234567890'
198 self.test_context._name_task_id = '{}-{}'.format(
199 self.test_context._name, self.test_context._task_id[:8])
200 self.test_context.keypair_name = "ctx-key"
201 self.test_context.secgroup_name = "ctx-secgroup"
202 self.test_context.key_uuid = "2f2e4997-0a8e-4eb7-9fa4-f3f8fbbc393b"
203 netattrs = {'cidr': '10.0.0.0/24', 'provider': None,
204 'external_network': 'ext_net'}
206 self.test_context.networks = OrderedDict(
207 {"mynet": model.Network("mynet", self.test_context,
210 self.test_context._add_resources_to_template(mock_template)
211 mock_template.add_keypair.assert_called_with(
214 mock_template.add_security_group.assert_called_with("ctx-secgroup", None)
215 mock_template.add_network.assert_called_with(
216 "ctx-12345678-mynet", 'physnet1', None, None, None, None)
217 mock_template.add_router.assert_called_with(
218 "ctx-12345678-mynet-router",
219 netattrs["external_network"],
220 "ctx-12345678-mynet-subnet")
221 mock_template.add_router_interface.assert_called_with(
222 "ctx-12345678-mynet-router-if0",
223 "ctx-12345678-mynet-router",
224 "ctx-12345678-mynet-subnet")
226 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
227 def test_attrs_get(self, *args):
228 image, flavor, user = expected_tuple = 'foo1', 'foo2', 'foo3'
229 self.assertNotEqual(self.test_context.image, image)
230 self.assertNotEqual(self.test_context.flavor, flavor)
231 self.assertNotEqual(self.test_context.user, user)
232 self.test_context._image = image
233 self.test_context._flavor = flavor
234 self.test_context._user = user
235 attr_tuple = self.test_context.image, self.test_context.flavor, self.test_context.user
236 self.assertEqual(attr_tuple, expected_tuple)
238 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
239 def test_attrs_set_negative(self, *args):
240 with self.assertRaises(AttributeError):
241 self.test_context.image = 'foo'
243 with self.assertRaises(AttributeError):
244 self.test_context.flavor = 'foo'
246 with self.assertRaises(AttributeError):
247 self.test_context.user = 'foo'
249 def test__create_new_stack(self):
250 template = mock.Mock()
251 self.test_context._create_new_stack(template)
252 template.create.assert_called_once()
254 def test__create_new_stack_stack_create_failed(self):
255 template = mock.Mock()
256 template.create.side_effect = y_exc.HeatTemplateError
258 self.assertRaises(y_exc.HeatTemplateError,
259 self.test_context._create_new_stack,
262 def test__create_new_stack_keyboard_interrupt(self):
263 template = mock.Mock()
264 template.create.side_effect = KeyboardInterrupt
265 self.assertRaises(y_exc.StackCreationInterrupt,
266 self.test_context._create_new_stack,
269 @mock.patch.object(os.path, 'exists', return_value=True)
270 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
271 @mock.patch.object(heat.HeatContext, '_create_new_stack')
272 def test_deploy_stack_creation_failed(self, mock_create,
273 mock_resources_template, mock_path_exists):
274 self.test_context._name = 'foo'
275 self.test_context._task_id = '1234567890'
276 self.test_context._name_task_id = 'foo-12345678'
277 mock_create.side_effect = y_exc.HeatTemplateError
278 self.assertRaises(y_exc.HeatTemplateError,
279 self.test_context.deploy)
281 mock_path_exists.assert_called()
282 mock_resources_template.assert_called_once()
284 @mock.patch.object(os.path, 'exists', return_value=False)
285 @mock.patch.object(ssh.SSH, 'gen_keys')
286 @mock.patch.object(heat, 'HeatTemplate')
287 def test_deploy(self, mock_template, mock_genkeys, mock_path_exists):
288 self.test_context._name = 'foo'
289 self.test_context._task_id = '1234567890'
290 self.test_context._name_task_id = '{}-{}'.format(
291 self.test_context._name, self.test_context._task_id[:8])
292 self.test_context.template_file = '/bar/baz/some-heat-file'
293 self.test_context.heat_parameters = {'image': 'cirros'}
294 self.test_context.get_neutron_info = mock.MagicMock()
295 self.test_context.deploy()
297 mock_template.assert_called_with(
298 'foo-12345678', template_file='/bar/baz/some-heat-file',
299 heat_parameters={'image': 'cirros'},
300 os_cloud_config=self.test_context._flags.os_cloud_config)
301 self.assertIsNotNone(self.test_context.stack)
302 key_filename = ''.join(
303 [consts.YARDSTICK_ROOT_PATH,
304 'yardstick/resources/files/yardstick_key-',
305 self.test_context._name_task_id])
306 mock_genkeys.assert_called_once_with(key_filename)
307 mock_path_exists.assert_any_call(key_filename)
309 @mock.patch.object(heat, 'HeatTemplate')
310 @mock.patch.object(os.path, 'exists', return_value=False)
311 @mock.patch.object(ssh.SSH, 'gen_keys')
312 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack')
313 @mock.patch.object(heat.HeatContext, '_create_new_stack')
314 def test_deploy_no_setup(self, mock_create_new_stack,
315 mock_retrieve_existing_stack, mock_genkeys, mock_path_exists,
317 self.test_context._name = 'foo'
318 self.test_context._task_id = '1234567890'
319 self.test_context.template_file = '/bar/baz/some-heat-file'
320 self.test_context.heat_parameters = {'image': 'cirros'}
321 self.test_context.get_neutron_info = mock.MagicMock()
322 self.test_context._flags.no_setup = True
323 self.test_context.deploy()
325 mock_create_new_stack.assert_not_called()
326 mock_retrieve_existing_stack.assert_called_with(self.test_context.name)
327 self.assertIsNotNone(self.test_context.stack)
328 key_filename = ''.join(
329 [consts.YARDSTICK_ROOT_PATH,
330 'yardstick/resources/files/yardstick_key-',
331 self.test_context._name])
332 mock_genkeys.assert_called_once_with(key_filename)
333 mock_path_exists.assert_any_call(key_filename)
335 @mock.patch.object(heat, 'HeatTemplate')
336 @mock.patch.object(os.path, 'exists', return_value=False)
337 @mock.patch.object(ssh.SSH, 'gen_keys')
338 @mock.patch.object(heat.HeatContext, '_create_new_stack')
339 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack',
341 def test_deploy_try_retrieve_context_does_not_exist(self,
342 mock_retrieve_stack, mock_create_new_stack, mock_genkeys,
343 mock_path_exists, *args):
344 self.test_context._name = 'demo'
345 self.test_context._task_id = '1234567890'
346 self.test_context._flags.no_setup = True
347 self.test_context.template_file = '/bar/baz/some-heat-file'
348 self.test_context.get_neutron_info = mock.MagicMock()
349 self.test_context.deploy()
351 mock_retrieve_stack.assert_called_once_with(self.test_context._name)
352 mock_create_new_stack.assert_called()
353 key_filename = ''.join(
354 [consts.YARDSTICK_ROOT_PATH,
355 'yardstick/resources/files/yardstick_key-',
356 self.test_context._name])
357 mock_genkeys.assert_called_once_with(key_filename)
358 mock_path_exists.assert_any_call(key_filename)
360 @mock.patch.object(heat, 'HeatTemplate', return_value='heat_template')
361 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
362 @mock.patch.object(os.path, 'exists', return_value=False)
363 @mock.patch.object(ssh.SSH, 'gen_keys')
364 def test_deploy_ssh_key_before_adding_resources(self, mock_genkeys,
365 mock_path_exists, mock_add_resources, *args):
366 mock_manager = mock.Mock()
367 mock_manager.attach_mock(mock_add_resources,
368 '_add_resources_to_template')
369 mock_manager.attach_mock(mock_genkeys, 'gen_keys')
370 mock_manager.reset_mock()
371 self.test_context._name_task_id = 'demo-12345678'
372 self.test_context.get_neutron_info = mock.Mock()
373 with mock.patch.object(self.test_context, '_create_new_stack') as \
375 mock.patch.object(self.test_context, 'get_neutron_info') as \
377 self.test_context.deploy()
379 mock_neutron_info.assert_called_once()
380 mock_create_stack.assert_called_once()
381 key_filename = ''.join(
382 [consts.YARDSTICK_ROOT_PATH,
383 'yardstick/resources/files/yardstick_key-',
384 self.test_context._name_task_id])
385 mock_genkeys.assert_called_once_with(key_filename)
386 mock_path_exists.assert_any_call(key_filename)
388 mock_call_gen_keys = mock.call.gen_keys(key_filename)
389 mock_call_add_resources = (
390 mock.call._add_resources_to_template('heat_template'))
391 self.assertTrue(mock_manager.mock_calls.index(mock_call_gen_keys) <
392 mock_manager.mock_calls.index(mock_call_add_resources))
394 @mock.patch.object(heat, 'HeatTemplate')
395 @mock.patch.object(ssh.SSH, 'gen_keys')
396 @mock.patch.object(heat.HeatContext, '_create_new_stack')
397 def test_deploy_with_key_filename_provided(self, mock_create_new_stack,
398 mock_gen_keys, *args):
399 self.test_context._name = 'foo'
400 self.test_context._task_id = '1234567890'
401 self.test_context._name_task_id = '{}-{}'.format(
402 self.test_context._name, self.test_context._task_id[:8])
403 self.test_context.template_file = '/bar/baz/some-heat-file'
404 self.test_context.heat_parameters = {'image': 'cirros'}
405 self.test_context.yardstick_gen_key_file = False
406 self.test_context.key_filename = '/etc/yardstick/yardstick.pem'
407 self.test_context.get_neutron_info = mock.MagicMock()
408 self.test_context.deploy()
410 mock_create_new_stack.assert_called()
411 mock_gen_keys.assert_not_called()
413 def test_check_for_context(self):
415 # check that the context exists
417 def test_add_server_port(self):
418 network1 = mock.MagicMock()
419 network2 = mock.MagicMock()
420 self.test_context._name = 'foo'
421 self.test_context._task_id = '1234567890'
422 self.test_context._name_task_id = '{}-{}'.format(
423 self.test_context._name, self.test_context._task_id[:8])
424 self.test_context.stack = mock.MagicMock()
425 self.test_context.networks = {
429 self.test_context.stack.outputs = {
430 u'b': u'10.20.30.45',
432 u'foo-12345678-a-subnet-cidr': u'10.20.0.0/15',
433 u'foo-12345678-a-subnet-gateway_ip': u'10.20.30.1',
434 u'b-mac_address': u'00:01',
435 u'b-device_id': u'dev21',
436 u'b-network_id': u'net789',
437 u'd': u'40.30.20.15',
439 u'foo-12345678-c-subnet-cidr': u'40.30.0.0/18',
440 u'foo-12345678-c-subnet-gateway_ip': u'40.30.20.254',
441 u'd-mac_address': u'00:10',
442 u'd-device_id': u'dev43',
443 u'd-network_id': u'net987',
444 u'e': u'40.30.20.15',
446 u'e-mac_address': u'00:10',
447 u'e-device_id': u'dev43',
448 u'e-network_id': u'net987',
450 server = mock.MagicMock()
451 server.private_ip = None
452 server.ports = OrderedDict([
453 ('a', [{'stack_name': 'b', 'port': 'port_a'}]),
454 ('c', [{'stack_name': 'd', 'port': 'port_c'},
455 {'stack_name': 'e', 'port': 'port_f'}]),
459 "private_ip": '10.20.30.45',
461 "subnet_cidr": '10.20.0.0/15',
462 "network": '10.20.0.0',
463 "netmask": '255.254.0.0',
465 "gateway_ip": '10.20.30.1',
466 "mac_address": '00:01',
467 "device_id": 'dev21',
468 "network_id": 'net789',
470 "local_mac": '00:01',
471 "local_ip": '10.20.30.45',
473 self.test_context.add_server_port(server)
474 self.assertEqual(server.private_ip, '10.20.30.45')
475 self.assertEqual(len(server.interfaces), 3)
476 self.assertDictEqual(server.interfaces['port_a'], expected)
478 @mock.patch('yardstick.benchmark.contexts.heat.os')
479 @mock.patch.object(heat.HeatContext, '_delete_key_file')
480 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
481 def test_undeploy(self, mock_template, mock_delete_key, *args):
482 self.test_context.stack = mock_template
483 self.test_context._name = 'foo'
484 self.test_context._task_id = '1234567890'
485 self.test_context._name_task_id = '{}-{}'.format(
486 self.test_context._name, self.test_context._task_id[:8])
487 # mock_os.path.exists.return_value = True
488 self.test_context.key_filename = 'foo/bar/foobar'
489 self.test_context.undeploy()
490 mock_delete_key.assert_called()
491 mock_template.delete.assert_called_once()
493 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
494 def test_undeploy_no_teardown(self, mock_template):
495 self.test_context.stack = mock_template
496 self.test_context._name = 'foo'
497 self.test_context._task_id = '1234567890'
498 self.test_context._flags.no_teardown = True
499 self.test_context.undeploy()
501 mock_template.delete.assert_not_called()
503 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
504 @mock.patch('yardstick.benchmark.contexts.heat.os')
505 def test_undeploy_key_filename(self, mock_os, mock_template):
506 self.test_context.stack = mock_template
507 self.test_context._name = 'foo'
508 self.test_context._task_id = '1234567890'
509 self.test_context._name_task_id = '{}-{}'.format(
510 self.test_context._name, self.test_context._task_id)
511 mock_os.path.exists.return_value = True
512 self.test_context.key_filename = 'foo/bar/foobar'
513 self.assertIsNone(self.test_context.undeploy())
515 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
516 def test__get_server_found_dict(self, *args):
518 Use HeatContext._get_server to get a server that matches
519 based on a dictionary input.
521 foo2_server = mock.Mock()
522 foo2_server.key_filename = None
523 foo2_server.private_ip = '10.0.0.2'
524 foo2_server.public_ip = '127.0.0.2'
525 foo2_server.context.user = 'oof'
527 baz3_server = mock.Mock()
528 baz3_server.key_filename = None
529 baz3_server.private_ip = '10.0.0.3'
530 baz3_server.public_ip = '127.0.0.3'
531 baz3_server.context.user = 'zab'
533 self.test_context._name = 'bar'
534 self.test_context._task_id = '1234567890'
535 self.test_context._name_task_id = '{}-{}'.format(
536 self.test_context._name, self.test_context._task_id[:8])
537 self.test_context._user = 'bot'
538 self.test_context.stack = mock.Mock()
539 self.test_context.stack.outputs = {
540 'private_ip': '10.0.0.1',
541 'public_ip': '127.0.0.1',
543 self.test_context._server_map = {
549 'name': 'foo.bar-12345678',
550 'private_ip_attr': 'private_ip',
551 'public_ip_attr': 'public_ip',
553 self.test_context.key_uuid = 'foo-42'
554 result = self.test_context._get_server(attr_name)
555 self.assertEqual(result['user'], 'bot')
556 self.assertEqual(result['ip'], '127.0.0.1')
557 self.assertEqual(result['private_ip'], '10.0.0.1')
559 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
560 def test__get_server_found_dict_no_attrs(self, *args):
562 Use HeatContext._get_server to get a server that matches
563 based on a dictionary input.
565 foo2_server = mock.Mock()
566 foo2_server.private_ip = '10.0.0.2'
567 foo2_server.public_ip = '127.0.0.2'
568 foo2_server.context.user = 'oof'
570 baz3_server = mock.Mock()
571 baz3_server.private_ip = '10.0.0.3'
572 baz3_server.public_ip = '127.0.0.3'
573 baz3_server.context.user = 'zab'
575 self.test_context._name = 'bar'
576 self.test_context._task_id = '1234567890'
577 self.test_context._name_task_id = '{}-{}'.format(
578 self.test_context._name, self.test_context._task_id[:8])
579 self.test_context._user = 'bot'
580 self.test_context.stack = mock.Mock()
581 self.test_context.stack.outputs = {
582 'private_ip': '10.0.0.1',
583 'public_ip': '127.0.0.1',
585 self.test_context._server_map = {
591 'name': 'foo.bar-12345678',
594 self.test_context.key_uuid = 'foo-42'
595 result = self.test_context._get_server(attr_name)
596 self.assertEqual(result['user'], 'bot')
597 # no private ip attr mapping in the map results in None value in the result
598 self.assertIsNone(result['private_ip'])
599 # no public ip attr mapping in the map results in no value in the result
600 self.assertNotIn('ip', result)
602 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
603 def test__get_server_found_not_dict(self, *args):
605 Use HeatContext._get_server to get a server that matches
606 based on a non-dictionary input
608 foo2_server = mock.Mock()
609 foo2_server.private_ip = '10.0.0.2'
610 foo2_server.public_ip = '127.0.0.2'
611 foo2_server.context.user = 'oof'
613 baz3_server = mock.Mock()
614 baz3_server.private_ip = '10.0.0.3'
615 baz3_server.public_ip = None
616 baz3_server.context.user = 'zab'
618 self.test_context._name = 'bar1'
619 self.test_context._task_id = '1234567890'
620 self.test_context._name_task_id = 'bar1-12345678'
621 self.test_context.stack = mock.Mock()
622 self.test_context.stack.outputs = {
623 'private_ip': '10.0.0.1',
624 'public_ip': '127.0.0.1',
626 self.test_context.generate_routing_table = mock.MagicMock(return_value=[])
628 self.test_context._server_map = {
634 result = self.test_context._get_server(attr_name)
635 self.assertEqual(result['user'], 'zab')
636 self.assertEqual(result['private_ip'], '10.0.0.3')
637 # no public_ip on the server results in no value in the result
638 self.assertNotIn('public_ip', result)
640 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
641 def test__get_server_none_found_not_dict(self, *args):
643 Use HeatContext._get_server to not get a server due to
644 None value associated with the match to a non-dictionary
647 foo2_server = mock.Mock()
648 foo2_server.private_ip = '10.0.0.2'
649 foo2_server.public_ip = '127.0.0.2'
650 foo2_server.context.user = 'oof'
652 baz3_server = mock.Mock()
653 baz3_server.private_ip = '10.0.0.3'
654 baz3_server.public_ip = None
655 baz3_server.context.user = 'zab'
657 self.test_context._name = 'bar1'
658 self.test_context.stack = mock.Mock()
659 self.test_context.stack.outputs = {
660 'private_ip': '10.0.0.1',
661 'public_ip': '127.0.0.1',
663 self.test_context._server_map = {
669 self.test_context.key_uuid = 'foo-42'
671 result = self.test_context._get_server(attr_name)
672 self.assertIsNone(result)
674 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
675 def test__get_server_not_found_dict(self, *args):
677 Use HeatContext._get_server to not get a server for lack
678 of a match to a dictionary input
680 foo2_server = mock.Mock()
681 foo2_server.private_ip = '10.0.0.2'
682 foo2_server.public_ip = '127.0.0.2'
683 foo2_server.context.user = 'oof'
685 baz3_server = mock.Mock()
686 baz3_server.private_ip = '10.0.0.3'
687 baz3_server.public_ip = None
688 baz3_server.context.user = 'zab'
690 self.test_context._name = 'bar1'
691 self.test_context._task_id = '1235467890'
692 self.test_context._name_task_id = '{}-{}'.format(
693 self.test_context._name, self.test_context._task_id[:8])
694 self.test_context.stack = mock.Mock()
695 self.test_context.stack.outputs = {
696 'private_ip': '10.0.0.1',
697 'public_ip': '127.0.0.1',
699 self.test_context._server_map = {
704 self.test_context.key_uuid = 'foo-42'
707 'private_ip_attr': 'private_ip',
708 'public_ip_attr': 'public_ip',
710 result = self.test_context._get_server(attr_name)
711 self.assertIsNone(result)
713 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
714 def test__get_server_not_found_not_dict(self, *args):
716 Use HeatContext._get_server to not get a server for lack
717 of a match to a non-dictionary input
719 foo2_server = mock.Mock()
720 foo2_server.private_ip = '10.0.0.2'
721 foo2_server.public_ip = '127.0.0.2'
722 foo2_server.context.user = 'oof'
724 baz3_server = mock.Mock()
725 baz3_server.private_ip = '10.0.0.3'
726 baz3_server.public_ip = None
727 baz3_server.context.user = 'zab'
729 self.mock_context._name = 'bar1'
730 self.test_context.stack = mock.Mock()
731 self.mock_context.stack.outputs = {
732 'private_ip': '10.0.0.1',
733 'public_ip': '127.0.0.1',
735 self.mock_context._server_map = {
740 self.test_context.key_uuid = 'foo-42'
741 attr_name = 'foo.wow4'
742 result = self.test_context._get_server(attr_name)
743 self.assertIsNone(result)
745 # TODO: Split this into more granular tests
746 def test__get_network(self):
747 network1 = mock.MagicMock()
748 network1.name = 'net_1'
749 network1.vld_id = 'vld111'
750 network1.segmentation_id = 'seg54'
751 network1.network_type = 'type_a'
752 network1.physical_network = 'phys'
754 network2 = mock.MagicMock()
755 network2.name = 'net_2'
756 network2.segmentation_id = 'seg45'
757 network2.network_type = 'type_b'
758 network2.physical_network = 'virt'
760 self.test_context.networks = {
766 self.assertIsNone(self.test_context._get_network(attr_name))
769 self.assertIsNone(self.test_context._get_network(attr_name))
771 attr_name = {'network_type': 'nosuch'}
772 self.assertIsNone(self.test_context._get_network(attr_name))
775 self.assertIsNone(self.test_context._get_network(attr_name))
777 attr_name = {'segmentation_id': 'seg45'}
780 "segmentation_id": 'seg45',
781 "network_type": 'type_b',
782 "physical_network": 'virt',
784 result = self.test_context._get_network(attr_name)
785 self.assertDictEqual(result, expected)
790 "segmentation_id": 'seg54',
791 "network_type": 'type_a',
792 "physical_network": 'phys',
794 result = self.test_context._get_network(attr_name)
795 self.assertDictEqual(result, expected)
797 def _get_file_abspath(self, filename):
798 curr_path = os.path.dirname(os.path.abspath(__file__))
799 file_path = os.path.join(curr_path, filename)
802 def test__get_physical_nodes(self):
803 self.test_context.nodes = {}
804 nodes = self.test_context._get_physical_nodes()
805 self.assertEquals(nodes, {})
807 @mock.patch.object(yaml_loader, 'read_yaml_file')
808 def test__get_physical_node_for_server(self, mock_read_yaml):
809 attrs = {'name': 'foo',
810 'task_id': '12345678',
812 'servers': {'vnf': {}},
813 'networks': {'mgmt': {'cidr': '10.0.1.0/24'}}
816 with mock.patch.object(openstack_utils, 'get_shade_client'), \
817 mock.patch.object(openstack_utils, 'get_shade_operator_client'):
818 mock_read_yaml.return_value = self.HEAT_POD_SAMPLE
819 self.test_context.init(attrs)
821 with mock.patch('yardstick.common.openstack_utils.get_server') as mock_get_server:
822 mock_get_server.return_value = {'vnf': {}}
824 # When server is not from this context
825 result = self.test_context._get_physical_node_for_server('node1.foo-context')
826 self.assertIsNone(result)
828 # When node_name is not from this context
829 result = self.test_context._get_physical_node_for_server('fake.foo-12345678')
830 self.assertIsNone(result)
832 mock_munch = mock.Mock()
833 mock_munch.toDict = mock.Mock(return_value={
834 'OS-EXT-SRV-ATTR:hypervisor_hostname': 'hypervisor_hostname'
836 mock_get_server.return_value = mock_munch
838 hypervisor = mock.Mock()
839 hypervisor.hypervisor_hostname = 'hypervisor_hostname'
840 hypervisor.host_ip = '10.229.47.137'
842 self.test_context.operator_client.list_hypervisors = mock.Mock(
843 return_value=[hypervisor])
845 mock_get_server.return_value = mock_munch
847 result = self.test_context._get_physical_node_for_server('vnf.foo-12345678')
848 self.assertEqual(result, 'node1.foo')