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 import ssh
26 LOG = logging.getLogger(__name__)
29 class HeatContextTestCase(unittest.TestCase):
36 "ip": "10.229.47.137",
38 "key_filename": "/root/.yardstick_key"
43 "ip": "10.229.47.139",
45 "key_filename": "/root/.yardstick_key"
50 def __init__(self, *args, **kwargs):
52 super(HeatContextTestCase, self).__init__(*args, **kwargs)
55 self.test_context = heat.HeatContext()
56 self.addCleanup(self._remove_contexts)
57 self.mock_context = mock.Mock(spec=heat.HeatContext())
59 def _remove_contexts(self):
60 if self.test_context in self.test_context.list:
61 self.test_context._delete_context()
63 def test___init__(self):
64 self.assertIsNone(self.test_context._name)
65 self.assertIsNone(self.test_context._task_id)
66 self.assertFalse(self.test_context._flags.no_setup)
67 self.assertFalse(self.test_context._flags.no_teardown)
68 self.assertIsNone(self.test_context.stack)
69 self.assertEqual(self.test_context.networks, OrderedDict())
70 self.assertEqual(self.test_context.servers, [])
71 self.assertEqual(self.test_context.placement_groups, [])
72 self.assertEqual(self.test_context.server_groups, [])
73 self.assertIsNone(self.test_context.keypair_name)
74 self.assertIsNone(self.test_context.secgroup_name)
75 self.assertEqual(self.test_context._server_map, {})
76 self.assertIsNone(self.test_context._image)
77 self.assertIsNone(self.test_context._flavor)
78 self.assertIsNone(self.test_context._user)
79 self.assertIsNone(self.test_context.template_file)
80 self.assertIsNone(self.test_context.heat_parameters)
81 self.assertIsNone(self.test_context.key_filename)
83 @mock.patch('yardstick.common.utils.read_yaml_file')
84 @mock.patch('yardstick.benchmark.contexts.heat.PlacementGroup')
85 @mock.patch('yardstick.benchmark.contexts.heat.ServerGroup')
86 @mock.patch('yardstick.benchmark.contexts.heat.Network')
87 @mock.patch('yardstick.benchmark.contexts.heat.Server')
88 def test_init(self, mock_server, mock_network, mock_sg, mock_pg, mock_read_yaml):
90 mock_read_yaml.return_value = self.HEAT_POD_SAMPLE
91 pgs = {'pgrp1': {'policy': 'availability'}}
92 sgs = {'servergroup1': {'policy': 'affinity'}}
93 networks = {'bar': {'cidr': '10.0.1.0/24'}}
94 servers = {'baz': {'floating_ip': True, 'placement': 'pgrp1'}}
95 attrs = {'name': 'foo',
97 'task_id': '1234567890',
98 'placement_groups': pgs,
100 'networks': networks,
103 with mock.patch.object(openstack_utils, 'get_shade_client'), \
104 mock.patch.object(openstack_utils, 'get_shade_operator_client'):
105 self.test_context.init(attrs)
107 self.assertFalse(self.test_context._flags.no_setup)
108 self.assertFalse(self.test_context._flags.no_teardown)
109 self.assertEqual(self.test_context._name, "foo")
110 self.assertEqual(self.test_context._task_id, '1234567890')
111 self.assertEqual(self.test_context.name, "foo-12345678")
112 self.assertEqual(self.test_context.keypair_name, "foo-12345678-key")
113 self.assertEqual(self.test_context.secgroup_name, "foo-12345678-secgroup")
115 mock_pg.assert_called_with('pgrp1', self.test_context,
116 pgs['pgrp1']['policy'])
117 mock_sg.assert_called_with('servergroup1', self.test_context,
118 sgs['servergroup1']['policy'])
119 self.assertEqual(len(self.test_context.placement_groups), 1)
120 self.assertEqual(len(self.test_context.server_groups), 1)
122 mock_network.assert_called_with(
123 'bar', self.test_context, networks['bar'])
124 self.assertEqual(len(self.test_context.networks), 1)
126 mock_server.assert_called_with('baz', self.test_context,
128 self.assertEqual(len(self.test_context.servers), 1)
130 def test_init_no_name_or_task_id(self):
132 self.assertRaises(KeyError, self.test_context.init, attrs)
135 self.test_context._name = 'foo'
136 self.test_context._task_id = '1234567890'
137 self.test_context._name_task_id = '{}-{}'.format(
138 self.test_context._name, self.test_context._task_id[:8])
139 self.assertEqual(self.test_context.name, 'foo-12345678')
140 self.assertEqual(self.test_context.assigned_name, 'foo')
142 def test_name_flags(self):
143 self.test_context._flags = base.Flags(
144 **{"no_setup": True, "no_teardown": True})
145 self.test_context._name = 'foo'
146 self.test_context._task_id = '1234567890'
148 self.assertEqual(self.test_context.name, 'foo')
149 self.assertEqual(self.test_context.assigned_name, 'foo')
151 def test_init_no_setup_no_teardown(self):
153 attrs = {'name': 'foo',
154 'task_id': '1234567890',
155 'placement_groups': {},
166 with mock.patch.object(openstack_utils, 'get_shade_client'), \
167 mock.patch.object(openstack_utils, 'get_shade_operator_client'):
168 self.test_context.init(attrs)
170 self.assertTrue(self.test_context._flags.no_setup)
171 self.assertTrue(self.test_context._flags.no_teardown)
173 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
174 def test__add_resources_to_template_no_servers(self, mock_template):
175 self.test_context._name = 'ctx'
176 self.test_context._task_id = '1234567890'
177 self.test_context._name_task_id = '{}-{}'.format(
178 self.test_context._name, self.test_context._task_id[:8])
179 self.test_context.keypair_name = "ctx-key"
180 self.test_context.secgroup_name = "ctx-secgroup"
181 self.test_context.key_uuid = "2f2e4997-0a8e-4eb7-9fa4-f3f8fbbc393b"
182 netattrs = {'cidr': '10.0.0.0/24', 'provider': None,
183 'external_network': 'ext_net'}
185 self.test_context.networks = OrderedDict(
186 {"mynet": model.Network("mynet", self.test_context,
189 self.test_context._add_resources_to_template(mock_template)
190 mock_template.add_keypair.assert_called_with(
193 mock_template.add_security_group.assert_called_with("ctx-secgroup")
194 mock_template.add_network.assert_called_with(
195 "ctx-12345678-mynet", 'physnet1', None, None, None, None)
196 mock_template.add_router.assert_called_with(
197 "ctx-12345678-mynet-router",
198 netattrs["external_network"],
199 "ctx-12345678-mynet-subnet")
200 mock_template.add_router_interface.assert_called_with(
201 "ctx-12345678-mynet-router-if0",
202 "ctx-12345678-mynet-router",
203 "ctx-12345678-mynet-subnet")
205 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
206 def test_attrs_get(self, *args):
207 image, flavor, user = expected_tuple = 'foo1', 'foo2', 'foo3'
208 self.assertNotEqual(self.test_context.image, image)
209 self.assertNotEqual(self.test_context.flavor, flavor)
210 self.assertNotEqual(self.test_context.user, user)
211 self.test_context._image = image
212 self.test_context._flavor = flavor
213 self.test_context._user = user
214 attr_tuple = self.test_context.image, self.test_context.flavor, self.test_context.user
215 self.assertEqual(attr_tuple, expected_tuple)
217 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
218 def test_attrs_set_negative(self, *args):
219 with self.assertRaises(AttributeError):
220 self.test_context.image = 'foo'
222 with self.assertRaises(AttributeError):
223 self.test_context.flavor = 'foo'
225 with self.assertRaises(AttributeError):
226 self.test_context.user = 'foo'
228 def test__create_new_stack(self):
229 template = mock.Mock()
230 self.test_context._create_new_stack(template)
231 template.create.assert_called_once()
233 def test__create_new_stack_stack_create_failed(self):
234 template = mock.Mock()
235 template.create.side_effect = y_exc.HeatTemplateError
237 self.assertRaises(y_exc.HeatTemplateError,
238 self.test_context._create_new_stack,
241 def test__create_new_stack_keyboard_interrupt(self):
242 template = mock.Mock()
243 template.create.side_effect = KeyboardInterrupt
244 self.assertRaises(y_exc.StackCreationInterrupt,
245 self.test_context._create_new_stack,
248 @mock.patch.object(os.path, 'exists', return_value=True)
249 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
250 @mock.patch.object(heat.HeatContext, '_create_new_stack')
251 def test_deploy_stack_creation_failed(self, mock_create,
252 mock_resources_template, mock_path_exists):
253 self.test_context._name = 'foo'
254 self.test_context._task_id = '1234567890'
255 self.test_context._name_task_id = 'foo-12345678'
256 mock_create.side_effect = y_exc.HeatTemplateError
257 self.assertRaises(y_exc.HeatTemplateError,
258 self.test_context.deploy)
260 mock_path_exists.assert_called()
261 mock_resources_template.assert_called_once()
263 @mock.patch.object(os.path, 'exists', return_value=False)
264 @mock.patch.object(ssh.SSH, 'gen_keys')
265 @mock.patch.object(heat, 'HeatTemplate')
266 def test_deploy(self, mock_template, mock_genkeys, mock_path_exists):
267 self.test_context._name = 'foo'
268 self.test_context._task_id = '1234567890'
269 self.test_context._name_task_id = '{}-{}'.format(
270 self.test_context._name, self.test_context._task_id[:8])
271 self.test_context.template_file = '/bar/baz/some-heat-file'
272 self.test_context.heat_parameters = {'image': 'cirros'}
273 self.test_context.get_neutron_info = mock.MagicMock()
274 self.test_context.deploy()
276 mock_template.assert_called_with(
277 'foo-12345678', template_file='/bar/baz/some-heat-file',
278 heat_parameters={'image': 'cirros'},
279 os_cloud_config=self.test_context._flags.os_cloud_config)
280 self.assertIsNotNone(self.test_context.stack)
281 key_filename = ''.join(
282 [consts.YARDSTICK_ROOT_PATH,
283 'yardstick/resources/files/yardstick_key-',
284 self.test_context._name_task_id])
285 mock_genkeys.assert_called_once_with(key_filename)
286 mock_path_exists.assert_any_call(key_filename)
288 @mock.patch.object(heat, 'HeatTemplate')
289 @mock.patch.object(os.path, 'exists', return_value=False)
290 @mock.patch.object(ssh.SSH, 'gen_keys')
291 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack')
292 @mock.patch.object(heat.HeatContext, '_create_new_stack')
293 def test_deploy_no_setup(self, mock_create_new_stack,
294 mock_retrieve_existing_stack, mock_genkeys, mock_path_exists,
296 self.test_context._name = 'foo'
297 self.test_context._task_id = '1234567890'
298 self.test_context.template_file = '/bar/baz/some-heat-file'
299 self.test_context.heat_parameters = {'image': 'cirros'}
300 self.test_context.get_neutron_info = mock.MagicMock()
301 self.test_context._flags.no_setup = True
302 self.test_context.deploy()
304 mock_create_new_stack.assert_not_called()
305 mock_retrieve_existing_stack.assert_called_with(self.test_context.name)
306 self.assertIsNotNone(self.test_context.stack)
307 key_filename = ''.join(
308 [consts.YARDSTICK_ROOT_PATH,
309 'yardstick/resources/files/yardstick_key-',
310 self.test_context._name])
311 mock_genkeys.assert_called_once_with(key_filename)
312 mock_path_exists.assert_any_call(key_filename)
314 @mock.patch.object(heat, 'HeatTemplate')
315 @mock.patch.object(os.path, 'exists', return_value=False)
316 @mock.patch.object(ssh.SSH, 'gen_keys')
317 @mock.patch.object(heat.HeatContext, '_create_new_stack')
318 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack',
320 def test_deploy_try_retrieve_context_does_not_exist(self,
321 mock_retrieve_stack, mock_create_new_stack, mock_genkeys,
322 mock_path_exists, *args):
323 self.test_context._name = 'demo'
324 self.test_context._task_id = '1234567890'
325 self.test_context._flags.no_setup = True
326 self.test_context.template_file = '/bar/baz/some-heat-file'
327 self.test_context.get_neutron_info = mock.MagicMock()
328 self.test_context.deploy()
330 mock_retrieve_stack.assert_called_once_with(self.test_context._name)
331 mock_create_new_stack.assert_called()
332 key_filename = ''.join(
333 [consts.YARDSTICK_ROOT_PATH,
334 'yardstick/resources/files/yardstick_key-',
335 self.test_context._name])
336 mock_genkeys.assert_called_once_with(key_filename)
337 mock_path_exists.assert_any_call(key_filename)
339 @mock.patch.object(heat, 'HeatTemplate', return_value='heat_template')
340 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
341 @mock.patch.object(os.path, 'exists', return_value=False)
342 @mock.patch.object(ssh.SSH, 'gen_keys')
343 def test_deploy_ssh_key_before_adding_resources(self, mock_genkeys,
344 mock_path_exists, mock_add_resources, *args):
345 mock_manager = mock.Mock()
346 mock_manager.attach_mock(mock_add_resources,
347 '_add_resources_to_template')
348 mock_manager.attach_mock(mock_genkeys, 'gen_keys')
349 mock_manager.reset_mock()
350 self.test_context._name_task_id = 'demo-12345678'
351 self.test_context.get_neutron_info = mock.Mock()
352 with mock.patch.object(self.test_context, '_create_new_stack') as \
354 mock.patch.object(self.test_context, 'get_neutron_info') as \
356 self.test_context.deploy()
358 mock_neutron_info.assert_called_once()
359 mock_create_stack.assert_called_once()
360 key_filename = ''.join(
361 [consts.YARDSTICK_ROOT_PATH,
362 'yardstick/resources/files/yardstick_key-',
363 self.test_context._name_task_id])
364 mock_genkeys.assert_called_once_with(key_filename)
365 mock_path_exists.assert_any_call(key_filename)
367 mock_call_gen_keys = mock.call.gen_keys(key_filename)
368 mock_call_add_resources = (
369 mock.call._add_resources_to_template('heat_template'))
370 self.assertTrue(mock_manager.mock_calls.index(mock_call_gen_keys) <
371 mock_manager.mock_calls.index(mock_call_add_resources))
373 def test_check_for_context(self):
375 # check that the context exists
377 def test_add_server_port(self):
378 network1 = mock.MagicMock()
379 network2 = mock.MagicMock()
380 self.test_context._name = 'foo'
381 self.test_context._task_id = '1234567890'
382 self.test_context._name_task_id = '{}-{}'.format(
383 self.test_context._name, self.test_context._task_id[:8])
384 self.test_context.stack = mock.MagicMock()
385 self.test_context.networks = {
389 self.test_context.stack.outputs = {
390 u'b': u'10.20.30.45',
392 u'foo-12345678-a-subnet-cidr': u'10.20.0.0/15',
393 u'foo-12345678-a-subnet-gateway_ip': u'10.20.30.1',
394 u'b-mac_address': u'00:01',
395 u'b-device_id': u'dev21',
396 u'b-network_id': u'net789',
397 u'd': u'40.30.20.15',
399 u'foo-12345678-c-subnet-cidr': u'40.30.0.0/18',
400 u'foo-12345678-c-subnet-gateway_ip': u'40.30.20.254',
401 u'd-mac_address': u'00:10',
402 u'd-device_id': u'dev43',
403 u'd-network_id': u'net987',
404 u'e': u'40.30.20.15',
406 u'e-mac_address': u'00:10',
407 u'e-device_id': u'dev43',
408 u'e-network_id': u'net987',
410 server = mock.MagicMock()
411 server.private_ip = None
412 server.ports = OrderedDict([
413 ('a', [{'stack_name': 'b', 'port': 'port_a'}]),
414 ('c', [{'stack_name': 'd', 'port': 'port_c'},
415 {'stack_name': 'e', 'port': 'port_f'}]),
419 "private_ip": '10.20.30.45',
421 "subnet_cidr": '10.20.0.0/15',
422 "network": '10.20.0.0',
423 "netmask": '255.254.0.0',
425 "gateway_ip": '10.20.30.1',
426 "mac_address": '00:01',
427 "device_id": 'dev21',
428 "network_id": 'net789',
430 "local_mac": '00:01',
431 "local_ip": '10.20.30.45',
433 self.test_context.add_server_port(server)
434 self.assertEqual(server.private_ip, '10.20.30.45')
435 self.assertEqual(len(server.interfaces), 3)
436 self.assertDictEqual(server.interfaces['port_a'], expected)
438 @mock.patch('yardstick.benchmark.contexts.heat.os')
439 @mock.patch.object(heat.HeatContext, '_delete_key_file')
440 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
441 def test_undeploy(self, mock_template, mock_delete_key, *args):
442 self.test_context.stack = mock_template
443 self.test_context._name = 'foo'
444 self.test_context._task_id = '1234567890'
445 self.test_context._name_task_id = '{}-{}'.format(
446 self.test_context._name, self.test_context._task_id[:8])
447 # mock_os.path.exists.return_value = True
448 self.test_context.key_filename = 'foo/bar/foobar'
449 self.test_context.undeploy()
450 mock_delete_key.assert_called()
451 mock_template.delete.assert_called_once()
453 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
454 def test_undeploy_no_teardown(self, mock_template):
455 self.test_context.stack = mock_template
456 self.test_context._name = 'foo'
457 self.test_context._task_id = '1234567890'
458 self.test_context._flags.no_teardown = True
459 self.test_context.undeploy()
461 mock_template.delete.assert_not_called()
463 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
464 @mock.patch('yardstick.benchmark.contexts.heat.os')
465 def test_undeploy_key_filename(self, mock_os, mock_template):
466 self.test_context.stack = mock_template
467 self.test_context._name = 'foo'
468 self.test_context._task_id = '1234567890'
469 self.test_context._name_task_id = '{}-{}'.format(
470 self.test_context._name, self.test_context._task_id)
471 mock_os.path.exists.return_value = True
472 self.test_context.key_filename = 'foo/bar/foobar'
473 self.assertIsNone(self.test_context.undeploy())
475 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
476 def test__get_server_found_dict(self, *args):
478 Use HeatContext._get_server to get a server that matches
479 based on a dictionary input.
481 foo2_server = mock.Mock()
482 foo2_server.key_filename = None
483 foo2_server.private_ip = '10.0.0.2'
484 foo2_server.public_ip = '127.0.0.2'
485 foo2_server.context.user = 'oof'
487 baz3_server = mock.Mock()
488 baz3_server.key_filename = None
489 baz3_server.private_ip = '10.0.0.3'
490 baz3_server.public_ip = '127.0.0.3'
491 baz3_server.context.user = 'zab'
493 self.test_context._name = 'bar'
494 self.test_context._task_id = '1234567890'
495 self.test_context._name_task_id = '{}-{}'.format(
496 self.test_context._name, self.test_context._task_id[:8])
497 self.test_context._user = 'bot'
498 self.test_context.stack = mock.Mock()
499 self.test_context.stack.outputs = {
500 'private_ip': '10.0.0.1',
501 'public_ip': '127.0.0.1',
503 self.test_context._server_map = {
509 'name': 'foo.bar-12345678',
510 'private_ip_attr': 'private_ip',
511 'public_ip_attr': 'public_ip',
513 self.test_context.key_uuid = 'foo-42'
514 result = self.test_context._get_server(attr_name)
515 self.assertEqual(result['user'], 'bot')
516 self.assertEqual(result['ip'], '127.0.0.1')
517 self.assertEqual(result['private_ip'], '10.0.0.1')
519 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
520 def test__get_server_found_dict_no_attrs(self, *args):
522 Use HeatContext._get_server to get a server that matches
523 based on a dictionary input.
525 foo2_server = mock.Mock()
526 foo2_server.private_ip = '10.0.0.2'
527 foo2_server.public_ip = '127.0.0.2'
528 foo2_server.context.user = 'oof'
530 baz3_server = mock.Mock()
531 baz3_server.private_ip = '10.0.0.3'
532 baz3_server.public_ip = '127.0.0.3'
533 baz3_server.context.user = 'zab'
535 self.test_context._name = 'bar'
536 self.test_context._task_id = '1234567890'
537 self.test_context._name_task_id = '{}-{}'.format(
538 self.test_context._name, self.test_context._task_id[:8])
539 self.test_context._user = 'bot'
540 self.test_context.stack = mock.Mock()
541 self.test_context.stack.outputs = {
542 'private_ip': '10.0.0.1',
543 'public_ip': '127.0.0.1',
545 self.test_context._server_map = {
551 'name': 'foo.bar-12345678',
554 self.test_context.key_uuid = 'foo-42'
555 result = self.test_context._get_server(attr_name)
556 self.assertEqual(result['user'], 'bot')
557 # no private ip attr mapping in the map results in None value in the result
558 self.assertIsNone(result['private_ip'])
559 # no public ip attr mapping in the map results in no value in the result
560 self.assertNotIn('ip', result)
562 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
563 def test__get_server_found_not_dict(self, *args):
565 Use HeatContext._get_server to get a server that matches
566 based on a non-dictionary input
568 foo2_server = mock.Mock()
569 foo2_server.private_ip = '10.0.0.2'
570 foo2_server.public_ip = '127.0.0.2'
571 foo2_server.context.user = 'oof'
573 baz3_server = mock.Mock()
574 baz3_server.private_ip = '10.0.0.3'
575 baz3_server.public_ip = None
576 baz3_server.context.user = 'zab'
578 self.test_context._name = 'bar1'
579 self.test_context._task_id = '1234567890'
580 self.test_context._name_task_id = 'bar1-12345678'
581 self.test_context.stack = mock.Mock()
582 self.test_context.stack.outputs = {
583 'private_ip': '10.0.0.1',
584 'public_ip': '127.0.0.1',
586 self.test_context.generate_routing_table = mock.MagicMock(return_value=[])
588 self.test_context._server_map = {
594 result = self.test_context._get_server(attr_name)
595 self.assertEqual(result['user'], 'zab')
596 self.assertEqual(result['private_ip'], '10.0.0.3')
597 # no public_ip on the server results in no value in the result
598 self.assertNotIn('public_ip', result)
600 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
601 def test__get_server_none_found_not_dict(self, *args):
603 Use HeatContext._get_server to not get a server due to
604 None value associated with the match to a non-dictionary
607 foo2_server = mock.Mock()
608 foo2_server.private_ip = '10.0.0.2'
609 foo2_server.public_ip = '127.0.0.2'
610 foo2_server.context.user = 'oof'
612 baz3_server = mock.Mock()
613 baz3_server.private_ip = '10.0.0.3'
614 baz3_server.public_ip = None
615 baz3_server.context.user = 'zab'
617 self.test_context._name = 'bar1'
618 self.test_context.stack = mock.Mock()
619 self.test_context.stack.outputs = {
620 'private_ip': '10.0.0.1',
621 'public_ip': '127.0.0.1',
623 self.test_context._server_map = {
629 self.test_context.key_uuid = 'foo-42'
631 result = self.test_context._get_server(attr_name)
632 self.assertIsNone(result)
634 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
635 def test__get_server_not_found_dict(self, *args):
637 Use HeatContext._get_server to not get a server for lack
638 of a match to a dictionary input
640 foo2_server = mock.Mock()
641 foo2_server.private_ip = '10.0.0.2'
642 foo2_server.public_ip = '127.0.0.2'
643 foo2_server.context.user = 'oof'
645 baz3_server = mock.Mock()
646 baz3_server.private_ip = '10.0.0.3'
647 baz3_server.public_ip = None
648 baz3_server.context.user = 'zab'
650 self.test_context._name = 'bar1'
651 self.test_context._task_id = '1235467890'
652 self.test_context._name_task_id = '{}-{}'.format(
653 self.test_context._name, self.test_context._task_id[:8])
654 self.test_context.stack = mock.Mock()
655 self.test_context.stack.outputs = {
656 'private_ip': '10.0.0.1',
657 'public_ip': '127.0.0.1',
659 self.test_context._server_map = {
664 self.test_context.key_uuid = 'foo-42'
667 'private_ip_attr': 'private_ip',
668 'public_ip_attr': 'public_ip',
670 result = self.test_context._get_server(attr_name)
671 self.assertIsNone(result)
673 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
674 def test__get_server_not_found_not_dict(self, *args):
676 Use HeatContext._get_server to not get a server for lack
677 of a match to a non-dictionary input
679 foo2_server = mock.Mock()
680 foo2_server.private_ip = '10.0.0.2'
681 foo2_server.public_ip = '127.0.0.2'
682 foo2_server.context.user = 'oof'
684 baz3_server = mock.Mock()
685 baz3_server.private_ip = '10.0.0.3'
686 baz3_server.public_ip = None
687 baz3_server.context.user = 'zab'
689 self.mock_context._name = 'bar1'
690 self.test_context.stack = mock.Mock()
691 self.mock_context.stack.outputs = {
692 'private_ip': '10.0.0.1',
693 'public_ip': '127.0.0.1',
695 self.mock_context._server_map = {
700 self.test_context.key_uuid = 'foo-42'
701 attr_name = 'foo.wow4'
702 result = self.test_context._get_server(attr_name)
703 self.assertIsNone(result)
705 # TODO: Split this into more granular tests
706 def test__get_network(self):
707 network1 = mock.MagicMock()
708 network1.name = 'net_1'
709 network1.vld_id = 'vld111'
710 network1.segmentation_id = 'seg54'
711 network1.network_type = 'type_a'
712 network1.physical_network = 'phys'
714 network2 = mock.MagicMock()
715 network2.name = 'net_2'
716 network2.segmentation_id = 'seg45'
717 network2.network_type = 'type_b'
718 network2.physical_network = 'virt'
720 self.test_context.networks = {
726 self.assertIsNone(self.test_context._get_network(attr_name))
729 self.assertIsNone(self.test_context._get_network(attr_name))
731 attr_name = {'network_type': 'nosuch'}
732 self.assertIsNone(self.test_context._get_network(attr_name))
735 self.assertIsNone(self.test_context._get_network(attr_name))
737 attr_name = {'segmentation_id': 'seg45'}
740 "segmentation_id": 'seg45',
741 "network_type": 'type_b',
742 "physical_network": 'virt',
744 result = self.test_context._get_network(attr_name)
745 self.assertDictEqual(result, expected)
750 "segmentation_id": 'seg54',
751 "network_type": 'type_a',
752 "physical_network": 'phys',
754 result = self.test_context._get_network(attr_name)
755 self.assertDictEqual(result, expected)
757 def _get_file_abspath(self, filename):
758 curr_path = os.path.dirname(os.path.abspath(__file__))
759 file_path = os.path.join(curr_path, filename)
762 def test__get_physical_nodes(self):
763 self.test_context.nodes = {}
764 nodes = self.test_context._get_physical_nodes()
765 self.assertEquals(nodes, {})
767 @mock.patch('yardstick.common.utils.read_yaml_file')
768 def test__get_physical_node_for_server(self, mock_read_yaml):
769 attrs = {'name': 'foo',
770 'task_id': '12345678',
772 'servers': {'vnf': {}},
773 'networks': {'mgmt': {'cidr': '10.0.1.0/24'}}
776 with mock.patch.object(openstack_utils, 'get_shade_client'), \
777 mock.patch.object(openstack_utils, 'get_shade_operator_client'):
778 mock_read_yaml.return_value = self.HEAT_POD_SAMPLE
779 self.test_context.init(attrs)
781 with mock.patch('yardstick.common.openstack_utils.get_server') as mock_get_server:
782 mock_get_server.return_value = {'vnf': {}}
784 # When server is not from this context
785 result = self.test_context._get_physical_node_for_server('node1.foo-context')
786 self.assertIsNone(result)
788 # When node_name is not from this context
789 result = self.test_context._get_physical_node_for_server('fake.foo-12345678')
790 self.assertIsNone(result)
792 mock_munch = mock.Mock()
793 mock_munch.toDict = mock.Mock(return_value={
794 'OS-EXT-SRV-ATTR:hypervisor_hostname': 'hypervisor_hostname'
796 mock_get_server.return_value = mock_munch
798 hypervisor = mock.Mock()
799 hypervisor.hypervisor_hostname = 'hypervisor_hostname'
800 hypervisor.host_ip = '10.229.47.137'
802 self.test_context.operator_client.list_hypervisors = mock.Mock(
803 return_value=[hypervisor])
805 mock_get_server.return_value = mock_munch
807 result = self.test_context._get_physical_node_for_server('vnf.foo-12345678')
808 self.assertEqual(result, 'node1.foo')