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)
85 @mock.patch.object(yaml_loader, 'read_yaml_file')
86 @mock.patch('yardstick.benchmark.contexts.heat.PlacementGroup')
87 @mock.patch('yardstick.benchmark.contexts.heat.ServerGroup')
88 @mock.patch('yardstick.benchmark.contexts.heat.Network')
89 @mock.patch('yardstick.benchmark.contexts.heat.Server')
90 def test_init(self, mock_server, mock_network, mock_sg, mock_pg,
93 mock_read_yaml.return_value = self.HEAT_POD_SAMPLE
94 pgs = {'pgrp1': {'policy': 'availability'}}
95 sgs = {'servergroup1': {'policy': 'affinity'}}
96 networks = {'bar': {'cidr': '10.0.1.0/24'}}
97 servers = {'baz': {'floating_ip': True, 'placement': 'pgrp1'}}
98 attrs = {'name': 'foo',
100 'task_id': '1234567890',
101 'placement_groups': pgs,
102 'server_groups': sgs,
103 'networks': networks,
106 with mock.patch.object(openstack_utils, 'get_shade_client'), \
107 mock.patch.object(openstack_utils, 'get_shade_operator_client'):
108 self.test_context.init(attrs)
110 self.assertFalse(self.test_context._flags.no_setup)
111 self.assertFalse(self.test_context._flags.no_teardown)
112 self.assertEqual(self.test_context._name, "foo")
113 self.assertEqual(self.test_context._task_id, '1234567890')
114 self.assertEqual(self.test_context.name, "foo-12345678")
115 self.assertEqual(self.test_context.keypair_name, "foo-12345678-key")
116 self.assertEqual(self.test_context.secgroup_name, "foo-12345678-secgroup")
118 mock_pg.assert_called_with('pgrp1', self.test_context,
119 pgs['pgrp1']['policy'])
120 mock_sg.assert_called_with('servergroup1', self.test_context,
121 sgs['servergroup1']['policy'])
122 self.assertEqual(len(self.test_context.placement_groups), 1)
123 self.assertEqual(len(self.test_context.server_groups), 1)
125 mock_network.assert_called_with(
126 'bar', self.test_context, networks['bar'])
127 self.assertEqual(len(self.test_context.networks), 1)
129 mock_server.assert_called_with('baz', self.test_context,
131 self.assertEqual(len(self.test_context.servers), 1)
133 def test_init_no_name_or_task_id(self):
135 self.assertRaises(KeyError, self.test_context.init, attrs)
138 self.test_context._name = 'foo'
139 self.test_context._task_id = '1234567890'
140 self.test_context._name_task_id = '{}-{}'.format(
141 self.test_context._name, self.test_context._task_id[:8])
142 self.assertEqual(self.test_context.name, 'foo-12345678')
143 self.assertEqual(self.test_context.assigned_name, 'foo')
145 def test_name_flags(self):
146 self.test_context._flags = base.Flags(
147 **{"no_setup": True, "no_teardown": True})
148 self.test_context._name = 'foo'
149 self.test_context._task_id = '1234567890'
151 self.assertEqual(self.test_context.name, 'foo')
152 self.assertEqual(self.test_context.assigned_name, 'foo')
154 def test_init_no_setup_no_teardown(self):
156 attrs = {'name': 'foo',
157 'task_id': '1234567890',
158 'placement_groups': {},
169 with mock.patch.object(openstack_utils, 'get_shade_client'), \
170 mock.patch.object(openstack_utils, 'get_shade_operator_client'):
171 self.test_context.init(attrs)
173 self.assertTrue(self.test_context._flags.no_setup)
174 self.assertTrue(self.test_context._flags.no_teardown)
176 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
177 def test__add_resources_to_template_no_servers(self, mock_template):
178 self.test_context._name = 'ctx'
179 self.test_context._task_id = '1234567890'
180 self.test_context._name_task_id = '{}-{}'.format(
181 self.test_context._name, self.test_context._task_id[:8])
182 self.test_context.keypair_name = "ctx-key"
183 self.test_context.secgroup_name = "ctx-secgroup"
184 self.test_context.key_uuid = "2f2e4997-0a8e-4eb7-9fa4-f3f8fbbc393b"
185 netattrs = {'cidr': '10.0.0.0/24', 'provider': None,
186 'external_network': 'ext_net'}
188 self.test_context.networks = OrderedDict(
189 {"mynet": model.Network("mynet", self.test_context,
192 self.test_context._add_resources_to_template(mock_template)
193 mock_template.add_keypair.assert_called_with(
196 mock_template.add_security_group.assert_called_with("ctx-secgroup", None)
197 mock_template.add_network.assert_called_with(
198 "ctx-12345678-mynet", 'physnet1', None, None, None, None)
199 mock_template.add_router.assert_called_with(
200 "ctx-12345678-mynet-router",
201 netattrs["external_network"],
202 "ctx-12345678-mynet-subnet")
203 mock_template.add_router_interface.assert_called_with(
204 "ctx-12345678-mynet-router-if0",
205 "ctx-12345678-mynet-router",
206 "ctx-12345678-mynet-subnet")
208 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
209 def test_attrs_get(self, *args):
210 image, flavor, user = expected_tuple = 'foo1', 'foo2', 'foo3'
211 self.assertNotEqual(self.test_context.image, image)
212 self.assertNotEqual(self.test_context.flavor, flavor)
213 self.assertNotEqual(self.test_context.user, user)
214 self.test_context._image = image
215 self.test_context._flavor = flavor
216 self.test_context._user = user
217 attr_tuple = self.test_context.image, self.test_context.flavor, self.test_context.user
218 self.assertEqual(attr_tuple, expected_tuple)
220 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
221 def test_attrs_set_negative(self, *args):
222 with self.assertRaises(AttributeError):
223 self.test_context.image = 'foo'
225 with self.assertRaises(AttributeError):
226 self.test_context.flavor = 'foo'
228 with self.assertRaises(AttributeError):
229 self.test_context.user = 'foo'
231 def test__create_new_stack(self):
232 template = mock.Mock()
233 self.test_context._create_new_stack(template)
234 template.create.assert_called_once()
236 def test__create_new_stack_stack_create_failed(self):
237 template = mock.Mock()
238 template.create.side_effect = y_exc.HeatTemplateError
240 self.assertRaises(y_exc.HeatTemplateError,
241 self.test_context._create_new_stack,
244 def test__create_new_stack_keyboard_interrupt(self):
245 template = mock.Mock()
246 template.create.side_effect = KeyboardInterrupt
247 self.assertRaises(y_exc.StackCreationInterrupt,
248 self.test_context._create_new_stack,
251 @mock.patch.object(os.path, 'exists', return_value=True)
252 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
253 @mock.patch.object(heat.HeatContext, '_create_new_stack')
254 def test_deploy_stack_creation_failed(self, mock_create,
255 mock_resources_template, mock_path_exists):
256 self.test_context._name = 'foo'
257 self.test_context._task_id = '1234567890'
258 self.test_context._name_task_id = 'foo-12345678'
259 mock_create.side_effect = y_exc.HeatTemplateError
260 self.assertRaises(y_exc.HeatTemplateError,
261 self.test_context.deploy)
263 mock_path_exists.assert_called()
264 mock_resources_template.assert_called_once()
266 @mock.patch.object(os.path, 'exists', return_value=False)
267 @mock.patch.object(ssh.SSH, 'gen_keys')
268 @mock.patch.object(heat, 'HeatTemplate')
269 def test_deploy(self, mock_template, mock_genkeys, mock_path_exists):
270 self.test_context._name = 'foo'
271 self.test_context._task_id = '1234567890'
272 self.test_context._name_task_id = '{}-{}'.format(
273 self.test_context._name, self.test_context._task_id[:8])
274 self.test_context.template_file = '/bar/baz/some-heat-file'
275 self.test_context.heat_parameters = {'image': 'cirros'}
276 self.test_context.get_neutron_info = mock.MagicMock()
277 self.test_context.deploy()
279 mock_template.assert_called_with(
280 'foo-12345678', template_file='/bar/baz/some-heat-file',
281 heat_parameters={'image': 'cirros'},
282 os_cloud_config=self.test_context._flags.os_cloud_config)
283 self.assertIsNotNone(self.test_context.stack)
284 key_filename = ''.join(
285 [consts.YARDSTICK_ROOT_PATH,
286 'yardstick/resources/files/yardstick_key-',
287 self.test_context._name_task_id])
288 mock_genkeys.assert_called_once_with(key_filename)
289 mock_path_exists.assert_any_call(key_filename)
291 @mock.patch.object(heat, 'HeatTemplate')
292 @mock.patch.object(os.path, 'exists', return_value=False)
293 @mock.patch.object(ssh.SSH, 'gen_keys')
294 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack')
295 @mock.patch.object(heat.HeatContext, '_create_new_stack')
296 def test_deploy_no_setup(self, mock_create_new_stack,
297 mock_retrieve_existing_stack, mock_genkeys, mock_path_exists,
299 self.test_context._name = 'foo'
300 self.test_context._task_id = '1234567890'
301 self.test_context.template_file = '/bar/baz/some-heat-file'
302 self.test_context.heat_parameters = {'image': 'cirros'}
303 self.test_context.get_neutron_info = mock.MagicMock()
304 self.test_context._flags.no_setup = True
305 self.test_context.deploy()
307 mock_create_new_stack.assert_not_called()
308 mock_retrieve_existing_stack.assert_called_with(self.test_context.name)
309 self.assertIsNotNone(self.test_context.stack)
310 key_filename = ''.join(
311 [consts.YARDSTICK_ROOT_PATH,
312 'yardstick/resources/files/yardstick_key-',
313 self.test_context._name])
314 mock_genkeys.assert_called_once_with(key_filename)
315 mock_path_exists.assert_any_call(key_filename)
317 @mock.patch.object(heat, 'HeatTemplate')
318 @mock.patch.object(os.path, 'exists', return_value=False)
319 @mock.patch.object(ssh.SSH, 'gen_keys')
320 @mock.patch.object(heat.HeatContext, '_create_new_stack')
321 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack',
323 def test_deploy_try_retrieve_context_does_not_exist(self,
324 mock_retrieve_stack, mock_create_new_stack, mock_genkeys,
325 mock_path_exists, *args):
326 self.test_context._name = 'demo'
327 self.test_context._task_id = '1234567890'
328 self.test_context._flags.no_setup = True
329 self.test_context.template_file = '/bar/baz/some-heat-file'
330 self.test_context.get_neutron_info = mock.MagicMock()
331 self.test_context.deploy()
333 mock_retrieve_stack.assert_called_once_with(self.test_context._name)
334 mock_create_new_stack.assert_called()
335 key_filename = ''.join(
336 [consts.YARDSTICK_ROOT_PATH,
337 'yardstick/resources/files/yardstick_key-',
338 self.test_context._name])
339 mock_genkeys.assert_called_once_with(key_filename)
340 mock_path_exists.assert_any_call(key_filename)
342 @mock.patch.object(heat, 'HeatTemplate', return_value='heat_template')
343 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
344 @mock.patch.object(os.path, 'exists', return_value=False)
345 @mock.patch.object(ssh.SSH, 'gen_keys')
346 def test_deploy_ssh_key_before_adding_resources(self, mock_genkeys,
347 mock_path_exists, mock_add_resources, *args):
348 mock_manager = mock.Mock()
349 mock_manager.attach_mock(mock_add_resources,
350 '_add_resources_to_template')
351 mock_manager.attach_mock(mock_genkeys, 'gen_keys')
352 mock_manager.reset_mock()
353 self.test_context._name_task_id = 'demo-12345678'
354 self.test_context.get_neutron_info = mock.Mock()
355 with mock.patch.object(self.test_context, '_create_new_stack') as \
357 mock.patch.object(self.test_context, 'get_neutron_info') as \
359 self.test_context.deploy()
361 mock_neutron_info.assert_called_once()
362 mock_create_stack.assert_called_once()
363 key_filename = ''.join(
364 [consts.YARDSTICK_ROOT_PATH,
365 'yardstick/resources/files/yardstick_key-',
366 self.test_context._name_task_id])
367 mock_genkeys.assert_called_once_with(key_filename)
368 mock_path_exists.assert_any_call(key_filename)
370 mock_call_gen_keys = mock.call.gen_keys(key_filename)
371 mock_call_add_resources = (
372 mock.call._add_resources_to_template('heat_template'))
373 self.assertTrue(mock_manager.mock_calls.index(mock_call_gen_keys) <
374 mock_manager.mock_calls.index(mock_call_add_resources))
376 def test_check_for_context(self):
378 # check that the context exists
380 def test_add_server_port(self):
381 network1 = mock.MagicMock()
382 network2 = mock.MagicMock()
383 self.test_context._name = 'foo'
384 self.test_context._task_id = '1234567890'
385 self.test_context._name_task_id = '{}-{}'.format(
386 self.test_context._name, self.test_context._task_id[:8])
387 self.test_context.stack = mock.MagicMock()
388 self.test_context.networks = {
392 self.test_context.stack.outputs = {
393 u'b': u'10.20.30.45',
395 u'foo-12345678-a-subnet-cidr': u'10.20.0.0/15',
396 u'foo-12345678-a-subnet-gateway_ip': u'10.20.30.1',
397 u'b-mac_address': u'00:01',
398 u'b-device_id': u'dev21',
399 u'b-network_id': u'net789',
400 u'd': u'40.30.20.15',
402 u'foo-12345678-c-subnet-cidr': u'40.30.0.0/18',
403 u'foo-12345678-c-subnet-gateway_ip': u'40.30.20.254',
404 u'd-mac_address': u'00:10',
405 u'd-device_id': u'dev43',
406 u'd-network_id': u'net987',
407 u'e': u'40.30.20.15',
409 u'e-mac_address': u'00:10',
410 u'e-device_id': u'dev43',
411 u'e-network_id': u'net987',
413 server = mock.MagicMock()
414 server.private_ip = None
415 server.ports = OrderedDict([
416 ('a', [{'stack_name': 'b', 'port': 'port_a'}]),
417 ('c', [{'stack_name': 'd', 'port': 'port_c'},
418 {'stack_name': 'e', 'port': 'port_f'}]),
422 "private_ip": '10.20.30.45',
424 "subnet_cidr": '10.20.0.0/15',
425 "network": '10.20.0.0',
426 "netmask": '255.254.0.0',
428 "gateway_ip": '10.20.30.1',
429 "mac_address": '00:01',
430 "device_id": 'dev21',
431 "network_id": 'net789',
433 "local_mac": '00:01',
434 "local_ip": '10.20.30.45',
436 self.test_context.add_server_port(server)
437 self.assertEqual(server.private_ip, '10.20.30.45')
438 self.assertEqual(len(server.interfaces), 3)
439 self.assertDictEqual(server.interfaces['port_a'], expected)
441 @mock.patch('yardstick.benchmark.contexts.heat.os')
442 @mock.patch.object(heat.HeatContext, '_delete_key_file')
443 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
444 def test_undeploy(self, mock_template, mock_delete_key, *args):
445 self.test_context.stack = mock_template
446 self.test_context._name = 'foo'
447 self.test_context._task_id = '1234567890'
448 self.test_context._name_task_id = '{}-{}'.format(
449 self.test_context._name, self.test_context._task_id[:8])
450 # mock_os.path.exists.return_value = True
451 self.test_context.key_filename = 'foo/bar/foobar'
452 self.test_context.undeploy()
453 mock_delete_key.assert_called()
454 mock_template.delete.assert_called_once()
456 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
457 def test_undeploy_no_teardown(self, mock_template):
458 self.test_context.stack = mock_template
459 self.test_context._name = 'foo'
460 self.test_context._task_id = '1234567890'
461 self.test_context._flags.no_teardown = True
462 self.test_context.undeploy()
464 mock_template.delete.assert_not_called()
466 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
467 @mock.patch('yardstick.benchmark.contexts.heat.os')
468 def test_undeploy_key_filename(self, mock_os, mock_template):
469 self.test_context.stack = mock_template
470 self.test_context._name = 'foo'
471 self.test_context._task_id = '1234567890'
472 self.test_context._name_task_id = '{}-{}'.format(
473 self.test_context._name, self.test_context._task_id)
474 mock_os.path.exists.return_value = True
475 self.test_context.key_filename = 'foo/bar/foobar'
476 self.assertIsNone(self.test_context.undeploy())
478 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
479 def test__get_server_found_dict(self, *args):
481 Use HeatContext._get_server to get a server that matches
482 based on a dictionary input.
484 foo2_server = mock.Mock()
485 foo2_server.key_filename = None
486 foo2_server.private_ip = '10.0.0.2'
487 foo2_server.public_ip = '127.0.0.2'
488 foo2_server.context.user = 'oof'
490 baz3_server = mock.Mock()
491 baz3_server.key_filename = None
492 baz3_server.private_ip = '10.0.0.3'
493 baz3_server.public_ip = '127.0.0.3'
494 baz3_server.context.user = 'zab'
496 self.test_context._name = 'bar'
497 self.test_context._task_id = '1234567890'
498 self.test_context._name_task_id = '{}-{}'.format(
499 self.test_context._name, self.test_context._task_id[:8])
500 self.test_context._user = 'bot'
501 self.test_context.stack = mock.Mock()
502 self.test_context.stack.outputs = {
503 'private_ip': '10.0.0.1',
504 'public_ip': '127.0.0.1',
506 self.test_context._server_map = {
512 'name': 'foo.bar-12345678',
513 'private_ip_attr': 'private_ip',
514 'public_ip_attr': 'public_ip',
516 self.test_context.key_uuid = 'foo-42'
517 result = self.test_context._get_server(attr_name)
518 self.assertEqual(result['user'], 'bot')
519 self.assertEqual(result['ip'], '127.0.0.1')
520 self.assertEqual(result['private_ip'], '10.0.0.1')
522 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
523 def test__get_server_found_dict_no_attrs(self, *args):
525 Use HeatContext._get_server to get a server that matches
526 based on a dictionary input.
528 foo2_server = mock.Mock()
529 foo2_server.private_ip = '10.0.0.2'
530 foo2_server.public_ip = '127.0.0.2'
531 foo2_server.context.user = 'oof'
533 baz3_server = mock.Mock()
534 baz3_server.private_ip = '10.0.0.3'
535 baz3_server.public_ip = '127.0.0.3'
536 baz3_server.context.user = 'zab'
538 self.test_context._name = 'bar'
539 self.test_context._task_id = '1234567890'
540 self.test_context._name_task_id = '{}-{}'.format(
541 self.test_context._name, self.test_context._task_id[:8])
542 self.test_context._user = 'bot'
543 self.test_context.stack = mock.Mock()
544 self.test_context.stack.outputs = {
545 'private_ip': '10.0.0.1',
546 'public_ip': '127.0.0.1',
548 self.test_context._server_map = {
554 'name': 'foo.bar-12345678',
557 self.test_context.key_uuid = 'foo-42'
558 result = self.test_context._get_server(attr_name)
559 self.assertEqual(result['user'], 'bot')
560 # no private ip attr mapping in the map results in None value in the result
561 self.assertIsNone(result['private_ip'])
562 # no public ip attr mapping in the map results in no value in the result
563 self.assertNotIn('ip', result)
565 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
566 def test__get_server_found_not_dict(self, *args):
568 Use HeatContext._get_server to get a server that matches
569 based on a non-dictionary input
571 foo2_server = mock.Mock()
572 foo2_server.private_ip = '10.0.0.2'
573 foo2_server.public_ip = '127.0.0.2'
574 foo2_server.context.user = 'oof'
576 baz3_server = mock.Mock()
577 baz3_server.private_ip = '10.0.0.3'
578 baz3_server.public_ip = None
579 baz3_server.context.user = 'zab'
581 self.test_context._name = 'bar1'
582 self.test_context._task_id = '1234567890'
583 self.test_context._name_task_id = 'bar1-12345678'
584 self.test_context.stack = mock.Mock()
585 self.test_context.stack.outputs = {
586 'private_ip': '10.0.0.1',
587 'public_ip': '127.0.0.1',
589 self.test_context.generate_routing_table = mock.MagicMock(return_value=[])
591 self.test_context._server_map = {
597 result = self.test_context._get_server(attr_name)
598 self.assertEqual(result['user'], 'zab')
599 self.assertEqual(result['private_ip'], '10.0.0.3')
600 # no public_ip on the server results in no value in the result
601 self.assertNotIn('public_ip', result)
603 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
604 def test__get_server_none_found_not_dict(self, *args):
606 Use HeatContext._get_server to not get a server due to
607 None value associated with the match to a non-dictionary
610 foo2_server = mock.Mock()
611 foo2_server.private_ip = '10.0.0.2'
612 foo2_server.public_ip = '127.0.0.2'
613 foo2_server.context.user = 'oof'
615 baz3_server = mock.Mock()
616 baz3_server.private_ip = '10.0.0.3'
617 baz3_server.public_ip = None
618 baz3_server.context.user = 'zab'
620 self.test_context._name = 'bar1'
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._server_map = {
632 self.test_context.key_uuid = 'foo-42'
634 result = self.test_context._get_server(attr_name)
635 self.assertIsNone(result)
637 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
638 def test__get_server_not_found_dict(self, *args):
640 Use HeatContext._get_server to not get a server for lack
641 of a match to a dictionary input
643 foo2_server = mock.Mock()
644 foo2_server.private_ip = '10.0.0.2'
645 foo2_server.public_ip = '127.0.0.2'
646 foo2_server.context.user = 'oof'
648 baz3_server = mock.Mock()
649 baz3_server.private_ip = '10.0.0.3'
650 baz3_server.public_ip = None
651 baz3_server.context.user = 'zab'
653 self.test_context._name = 'bar1'
654 self.test_context._task_id = '1235467890'
655 self.test_context._name_task_id = '{}-{}'.format(
656 self.test_context._name, self.test_context._task_id[:8])
657 self.test_context.stack = mock.Mock()
658 self.test_context.stack.outputs = {
659 'private_ip': '10.0.0.1',
660 'public_ip': '127.0.0.1',
662 self.test_context._server_map = {
667 self.test_context.key_uuid = 'foo-42'
670 'private_ip_attr': 'private_ip',
671 'public_ip_attr': 'public_ip',
673 result = self.test_context._get_server(attr_name)
674 self.assertIsNone(result)
676 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
677 def test__get_server_not_found_not_dict(self, *args):
679 Use HeatContext._get_server to not get a server for lack
680 of a match to a non-dictionary input
682 foo2_server = mock.Mock()
683 foo2_server.private_ip = '10.0.0.2'
684 foo2_server.public_ip = '127.0.0.2'
685 foo2_server.context.user = 'oof'
687 baz3_server = mock.Mock()
688 baz3_server.private_ip = '10.0.0.3'
689 baz3_server.public_ip = None
690 baz3_server.context.user = 'zab'
692 self.mock_context._name = 'bar1'
693 self.test_context.stack = mock.Mock()
694 self.mock_context.stack.outputs = {
695 'private_ip': '10.0.0.1',
696 'public_ip': '127.0.0.1',
698 self.mock_context._server_map = {
703 self.test_context.key_uuid = 'foo-42'
704 attr_name = 'foo.wow4'
705 result = self.test_context._get_server(attr_name)
706 self.assertIsNone(result)
708 # TODO: Split this into more granular tests
709 def test__get_network(self):
710 network1 = mock.MagicMock()
711 network1.name = 'net_1'
712 network1.vld_id = 'vld111'
713 network1.segmentation_id = 'seg54'
714 network1.network_type = 'type_a'
715 network1.physical_network = 'phys'
717 network2 = mock.MagicMock()
718 network2.name = 'net_2'
719 network2.segmentation_id = 'seg45'
720 network2.network_type = 'type_b'
721 network2.physical_network = 'virt'
723 self.test_context.networks = {
729 self.assertIsNone(self.test_context._get_network(attr_name))
732 self.assertIsNone(self.test_context._get_network(attr_name))
734 attr_name = {'network_type': 'nosuch'}
735 self.assertIsNone(self.test_context._get_network(attr_name))
738 self.assertIsNone(self.test_context._get_network(attr_name))
740 attr_name = {'segmentation_id': 'seg45'}
743 "segmentation_id": 'seg45',
744 "network_type": 'type_b',
745 "physical_network": 'virt',
747 result = self.test_context._get_network(attr_name)
748 self.assertDictEqual(result, expected)
753 "segmentation_id": 'seg54',
754 "network_type": 'type_a',
755 "physical_network": 'phys',
757 result = self.test_context._get_network(attr_name)
758 self.assertDictEqual(result, expected)
760 def _get_file_abspath(self, filename):
761 curr_path = os.path.dirname(os.path.abspath(__file__))
762 file_path = os.path.join(curr_path, filename)
765 def test__get_physical_nodes(self):
766 self.test_context.nodes = {}
767 nodes = self.test_context._get_physical_nodes()
768 self.assertEquals(nodes, {})
770 @mock.patch.object(yaml_loader, 'read_yaml_file')
771 def test__get_physical_node_for_server(self, mock_read_yaml):
772 attrs = {'name': 'foo',
773 'task_id': '12345678',
775 'servers': {'vnf': {}},
776 'networks': {'mgmt': {'cidr': '10.0.1.0/24'}}
779 with mock.patch.object(openstack_utils, 'get_shade_client'), \
780 mock.patch.object(openstack_utils, 'get_shade_operator_client'):
781 mock_read_yaml.return_value = self.HEAT_POD_SAMPLE
782 self.test_context.init(attrs)
784 with mock.patch('yardstick.common.openstack_utils.get_server') as mock_get_server:
785 mock_get_server.return_value = {'vnf': {}}
787 # When server is not from this context
788 result = self.test_context._get_physical_node_for_server('node1.foo-context')
789 self.assertIsNone(result)
791 # When node_name is not from this context
792 result = self.test_context._get_physical_node_for_server('fake.foo-12345678')
793 self.assertIsNone(result)
795 mock_munch = mock.Mock()
796 mock_munch.toDict = mock.Mock(return_value={
797 'OS-EXT-SRV-ATTR:hypervisor_hostname': 'hypervisor_hostname'
799 mock_get_server.return_value = mock_munch
801 hypervisor = mock.Mock()
802 hypervisor.hypervisor_hostname = 'hypervisor_hostname'
803 hypervisor.host_ip = '10.229.47.137'
805 self.test_context.operator_client.list_hypervisors = mock.Mock(
806 return_value=[hypervisor])
808 mock_get_server.return_value = mock_munch
810 result = self.test_context._get_physical_node_for_server('vnf.foo-12345678')
811 self.assertEqual(result, 'node1.foo')