yardstick/tests/unit/benchmark/contexts/test_heat.py

   1 ##############################################################################
   2 # Copyright (c) 2015 Ericsson AB and others.
   3 #
   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 ##############################################################################
   9
  10 from collections import OrderedDict
  11 import logging
  12 import os
  13
  14 import mock
  15 import unittest
  16
  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
  25
  26
  27 LOG = logging.getLogger(__name__)
  28
  29
  30 class HeatContextTestCase(unittest.TestCase):
  31
  32     HEAT_POD_SAMPLE = {
  33         "nodes": [
  34             {
  35                 "name": "node1",
  36                 "role": "Controller",
  37                 "ip": "10.229.47.137",
  38                 "user": "root",
  39                 "key_filename": "/root/.yardstick_key"
  40             },
  41             {
  42                 "name": "node2",
  43                 "role": "Compute",
  44                 "ip": "10.229.47.139",
  45                 "user": "root",
  46                 "key_filename": "/root/.yardstick_key"
  47             }
  48         ]
  49     }
  50
  51     def __init__(self, *args, **kwargs):
  52
  53         super(HeatContextTestCase, self).__init__(*args, **kwargs)
  54
  55     def setUp(self):
  56         self.test_context = heat.HeatContext()
  57         self.addCleanup(self._remove_contexts)
  58         self.mock_context = mock.Mock(spec=heat.HeatContext())
  59
  60     def _remove_contexts(self):
  61         if self.test_context in self.test_context.list:
  62             self.test_context._delete_context()
  63
  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.assertEqual(self.test_context._server_map, {})
  77         self.assertIsNone(self.test_context._image)
  78         self.assertIsNone(self.test_context._flavor)
  79         self.assertIsNone(self.test_context._user)
  80         self.assertIsNone(self.test_context.template_file)
  81         self.assertIsNone(self.test_context.heat_parameters)
  82         self.assertIsNone(self.test_context.key_filename)
  83
  84     @mock.patch.object(yaml_loader, 'read_yaml_file')
  85     @mock.patch('yardstick.benchmark.contexts.heat.PlacementGroup')
  86     @mock.patch('yardstick.benchmark.contexts.heat.ServerGroup')
  87     @mock.patch('yardstick.benchmark.contexts.heat.Network')
  88     @mock.patch('yardstick.benchmark.contexts.heat.Server')
  89     def test_init(self, mock_server, mock_network, mock_sg, mock_pg,
  90                   mock_read_yaml):
  91
  92         mock_read_yaml.return_value = self.HEAT_POD_SAMPLE
  93         pgs = {'pgrp1': {'policy': 'availability'}}
  94         sgs = {'servergroup1': {'policy': 'affinity'}}
  95         networks = {'bar': {'cidr': '10.0.1.0/24'}}
  96         servers = {'baz': {'floating_ip': True, 'placement': 'pgrp1'}}
  97         attrs = {'name': 'foo',
  98                  'file': 'pod.yaml',
  99                  'task_id': '1234567890',
 100                  'placement_groups': pgs,
 101                  'server_groups': sgs,
 102                  'networks': networks,
 103                  'servers': servers}
 104
 105         with mock.patch.object(openstack_utils, 'get_shade_client'), \
 106              mock.patch.object(openstack_utils, 'get_shade_operator_client'):
 107             self.test_context.init(attrs)
 108
 109         self.assertFalse(self.test_context._flags.no_setup)
 110         self.assertFalse(self.test_context._flags.no_teardown)
 111         self.assertEqual(self.test_context._name, "foo")
 112         self.assertEqual(self.test_context._task_id, '1234567890')
 113         self.assertEqual(self.test_context.name, "foo-12345678")
 114         self.assertEqual(self.test_context.keypair_name, "foo-12345678-key")
 115         self.assertEqual(self.test_context.secgroup_name, "foo-12345678-secgroup")
 116
 117         mock_pg.assert_called_with('pgrp1', self.test_context,
 118                                    pgs['pgrp1']['policy'])
 119         mock_sg.assert_called_with('servergroup1', self.test_context,
 120                                    sgs['servergroup1']['policy'])
 121         self.assertEqual(len(self.test_context.placement_groups), 1)
 122         self.assertEqual(len(self.test_context.server_groups), 1)
 123
 124         mock_network.assert_called_with(
 125             'bar', self.test_context, networks['bar'])
 126         self.assertEqual(len(self.test_context.networks), 1)
 127
 128         mock_server.assert_called_with('baz', self.test_context,
 129                                        servers['baz'])
 130         self.assertEqual(len(self.test_context.servers), 1)
 131
 132     def test_init_no_name_or_task_id(self):
 133         attrs = {}
 134         self.assertRaises(KeyError, self.test_context.init, attrs)
 135
 136     def test_name(self):
 137         self.test_context._name = 'foo'
 138         self.test_context._task_id = '1234567890'
 139         self.test_context._name_task_id = '{}-{}'.format(
 140             self.test_context._name, self.test_context._task_id[:8])
 141         self.assertEqual(self.test_context.name, 'foo-12345678')
 142         self.assertEqual(self.test_context.assigned_name, 'foo')
 143
 144     def test_name_flags(self):
 145         self.test_context._flags = base.Flags(
 146             **{"no_setup": True, "no_teardown": True})
 147         self.test_context._name = 'foo'
 148         self.test_context._task_id = '1234567890'
 149
 150         self.assertEqual(self.test_context.name, 'foo')
 151         self.assertEqual(self.test_context.assigned_name, 'foo')
 152
 153     def test_init_no_setup_no_teardown(self):
 154
 155         attrs = {'name': 'foo',
 156                  'task_id': '1234567890',
 157                  'placement_groups': {},
 158                  'server_groups': {},
 159                  'networks': {},
 160                  'servers': {},
 161                  'file': "pod.yaml",
 162                  'flags': {
 163                      'no_setup': True,
 164                      'no_teardown': True,
 165                      },
 166                 }
 167
 168         with mock.patch.object(openstack_utils, 'get_shade_client'), \
 169              mock.patch.object(openstack_utils, 'get_shade_operator_client'):
 170             self.test_context.init(attrs)
 171
 172         self.assertTrue(self.test_context._flags.no_setup)
 173         self.assertTrue(self.test_context._flags.no_teardown)
 174
 175     @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
 176     def test__add_resources_to_template_no_servers(self, mock_template):
 177         self.test_context._name = 'ctx'
 178         self.test_context._task_id = '1234567890'
 179         self.test_context._name_task_id = '{}-{}'.format(
 180             self.test_context._name, self.test_context._task_id[:8])
 181         self.test_context.keypair_name = "ctx-key"
 182         self.test_context.secgroup_name = "ctx-secgroup"
 183         self.test_context.key_uuid = "2f2e4997-0a8e-4eb7-9fa4-f3f8fbbc393b"
 184         netattrs = {'cidr': '10.0.0.0/24', 'provider': None,
 185                     'external_network': 'ext_net'}
 186
 187         self.test_context.networks = OrderedDict(
 188             {"mynet": model.Network("mynet", self.test_context,
 189                                            netattrs)})
 190
 191         self.test_context._add_resources_to_template(mock_template)
 192         mock_template.add_keypair.assert_called_with(
 193             "ctx-key",
 194             "ctx-12345678")
 195         mock_template.add_security_group.assert_called_with("ctx-secgroup")
 196         mock_template.add_network.assert_called_with(
 197             "ctx-12345678-mynet", 'physnet1', None, None, None, None)
 198         mock_template.add_router.assert_called_with(
 199             "ctx-12345678-mynet-router",
 200             netattrs["external_network"],
 201             "ctx-12345678-mynet-subnet")
 202         mock_template.add_router_interface.assert_called_with(
 203             "ctx-12345678-mynet-router-if0",
 204             "ctx-12345678-mynet-router",
 205             "ctx-12345678-mynet-subnet")
 206
 207     @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
 208     def test_attrs_get(self, *args):
 209         image, flavor, user = expected_tuple = 'foo1', 'foo2', 'foo3'
 210         self.assertNotEqual(self.test_context.image, image)
 211         self.assertNotEqual(self.test_context.flavor, flavor)
 212         self.assertNotEqual(self.test_context.user, user)
 213         self.test_context._image = image
 214         self.test_context._flavor = flavor
 215         self.test_context._user = user
 216         attr_tuple = self.test_context.image, self.test_context.flavor, self.test_context.user
 217         self.assertEqual(attr_tuple, expected_tuple)
 218
 219     @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
 220     def test_attrs_set_negative(self, *args):
 221         with self.assertRaises(AttributeError):
 222             self.test_context.image = 'foo'
 223
 224         with self.assertRaises(AttributeError):
 225             self.test_context.flavor = 'foo'
 226
 227         with self.assertRaises(AttributeError):
 228             self.test_context.user = 'foo'
 229
 230     def test__create_new_stack(self):
 231         template = mock.Mock()
 232         self.test_context._create_new_stack(template)
 233         template.create.assert_called_once()
 234
 235     def test__create_new_stack_stack_create_failed(self):
 236         template = mock.Mock()
 237         template.create.side_effect = y_exc.HeatTemplateError
 238
 239         self.assertRaises(y_exc.HeatTemplateError,
 240                           self.test_context._create_new_stack,
 241                           template)
 242
 243     def test__create_new_stack_keyboard_interrupt(self):
 244         template = mock.Mock()
 245         template.create.side_effect = KeyboardInterrupt
 246         self.assertRaises(y_exc.StackCreationInterrupt,
 247                           self.test_context._create_new_stack,
 248                           template)
 249
 250     @mock.patch.object(os.path, 'exists', return_value=True)
 251     @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
 252     @mock.patch.object(heat.HeatContext, '_create_new_stack')
 253     def test_deploy_stack_creation_failed(self, mock_create,
 254             mock_resources_template, mock_path_exists):
 255         self.test_context._name = 'foo'
 256         self.test_context._task_id = '1234567890'
 257         self.test_context._name_task_id = 'foo-12345678'
 258         mock_create.side_effect = y_exc.HeatTemplateError
 259         self.assertRaises(y_exc.HeatTemplateError,
 260                           self.test_context.deploy)
 261
 262         mock_path_exists.assert_called()
 263         mock_resources_template.assert_called_once()
 264
 265     @mock.patch.object(os.path, 'exists', return_value=False)
 266     @mock.patch.object(ssh.SSH, 'gen_keys')
 267     @mock.patch.object(heat, 'HeatTemplate')
 268     def test_deploy(self, mock_template, mock_genkeys, mock_path_exists):
 269         self.test_context._name = 'foo'
 270         self.test_context._task_id = '1234567890'
 271         self.test_context._name_task_id = '{}-{}'.format(
 272             self.test_context._name, self.test_context._task_id[:8])
 273         self.test_context.template_file = '/bar/baz/some-heat-file'
 274         self.test_context.heat_parameters = {'image': 'cirros'}
 275         self.test_context.get_neutron_info = mock.MagicMock()
 276         self.test_context.deploy()
 277
 278         mock_template.assert_called_with(
 279             'foo-12345678', template_file='/bar/baz/some-heat-file',
 280             heat_parameters={'image': 'cirros'},
 281             os_cloud_config=self.test_context._flags.os_cloud_config)
 282         self.assertIsNotNone(self.test_context.stack)
 283         key_filename = ''.join(
 284             [consts.YARDSTICK_ROOT_PATH,
 285              'yardstick/resources/files/yardstick_key-',
 286              self.test_context._name_task_id])
 287         mock_genkeys.assert_called_once_with(key_filename)
 288         mock_path_exists.assert_any_call(key_filename)
 289
 290     @mock.patch.object(heat, 'HeatTemplate')
 291     @mock.patch.object(os.path, 'exists', return_value=False)
 292     @mock.patch.object(ssh.SSH, 'gen_keys')
 293     @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack')
 294     @mock.patch.object(heat.HeatContext, '_create_new_stack')
 295     def test_deploy_no_setup(self, mock_create_new_stack,
 296             mock_retrieve_existing_stack, mock_genkeys, mock_path_exists,
 297             *args):
 298         self.test_context._name = 'foo'
 299         self.test_context._task_id = '1234567890'
 300         self.test_context.template_file = '/bar/baz/some-heat-file'
 301         self.test_context.heat_parameters = {'image': 'cirros'}
 302         self.test_context.get_neutron_info = mock.MagicMock()
 303         self.test_context._flags.no_setup = True
 304         self.test_context.deploy()
 305
 306         mock_create_new_stack.assert_not_called()
 307         mock_retrieve_existing_stack.assert_called_with(self.test_context.name)
 308         self.assertIsNotNone(self.test_context.stack)
 309         key_filename = ''.join(
 310             [consts.YARDSTICK_ROOT_PATH,
 311              'yardstick/resources/files/yardstick_key-',
 312              self.test_context._name])
 313         mock_genkeys.assert_called_once_with(key_filename)
 314         mock_path_exists.assert_any_call(key_filename)
 315
 316     @mock.patch.object(heat, 'HeatTemplate')
 317     @mock.patch.object(os.path, 'exists', return_value=False)
 318     @mock.patch.object(ssh.SSH, 'gen_keys')
 319     @mock.patch.object(heat.HeatContext, '_create_new_stack')
 320     @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack',
 321                        return_value=None)
 322     def test_deploy_try_retrieve_context_does_not_exist(self,
 323             mock_retrieve_stack, mock_create_new_stack, mock_genkeys,
 324             mock_path_exists, *args):
 325         self.test_context._name = 'demo'
 326         self.test_context._task_id = '1234567890'
 327         self.test_context._flags.no_setup = True
 328         self.test_context.template_file = '/bar/baz/some-heat-file'
 329         self.test_context.get_neutron_info = mock.MagicMock()
 330         self.test_context.deploy()
 331
 332         mock_retrieve_stack.assert_called_once_with(self.test_context._name)
 333         mock_create_new_stack.assert_called()
 334         key_filename = ''.join(
 335             [consts.YARDSTICK_ROOT_PATH,
 336              'yardstick/resources/files/yardstick_key-',
 337              self.test_context._name])
 338         mock_genkeys.assert_called_once_with(key_filename)
 339         mock_path_exists.assert_any_call(key_filename)
 340
 341     @mock.patch.object(heat, 'HeatTemplate', return_value='heat_template')
 342     @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
 343     @mock.patch.object(os.path, 'exists', return_value=False)
 344     @mock.patch.object(ssh.SSH, 'gen_keys')
 345     def test_deploy_ssh_key_before_adding_resources(self, mock_genkeys,
 346             mock_path_exists, mock_add_resources, *args):
 347         mock_manager = mock.Mock()
 348         mock_manager.attach_mock(mock_add_resources,
 349                                  '_add_resources_to_template')
 350         mock_manager.attach_mock(mock_genkeys, 'gen_keys')
 351         mock_manager.reset_mock()
 352         self.test_context._name_task_id = 'demo-12345678'
 353         self.test_context.get_neutron_info = mock.Mock()
 354         with mock.patch.object(self.test_context, '_create_new_stack') as \
 355                 mock_create_stack, \
 356                 mock.patch.object(self.test_context, 'get_neutron_info') as \
 357                 mock_neutron_info:
 358             self.test_context.deploy()
 359
 360         mock_neutron_info.assert_called_once()
 361         mock_create_stack.assert_called_once()
 362         key_filename = ''.join(
 363             [consts.YARDSTICK_ROOT_PATH,
 364              'yardstick/resources/files/yardstick_key-',
 365              self.test_context._name_task_id])
 366         mock_genkeys.assert_called_once_with(key_filename)
 367         mock_path_exists.assert_any_call(key_filename)
 368
 369         mock_call_gen_keys = mock.call.gen_keys(key_filename)
 370         mock_call_add_resources = (
 371             mock.call._add_resources_to_template('heat_template'))
 372         self.assertTrue(mock_manager.mock_calls.index(mock_call_gen_keys) <
 373                         mock_manager.mock_calls.index(mock_call_add_resources))
 374
 375     def test_check_for_context(self):
 376         pass
 377         # check that the context exists
 378
 379     def test_add_server_port(self):
 380         network1 = mock.MagicMock()
 381         network2 = mock.MagicMock()
 382         self.test_context._name = 'foo'
 383         self.test_context._task_id = '1234567890'
 384         self.test_context._name_task_id = '{}-{}'.format(
 385             self.test_context._name, self.test_context._task_id[:8])
 386         self.test_context.stack = mock.MagicMock()
 387         self.test_context.networks = {
 388             'a': network1,
 389             'c': network2,
 390         }
 391         self.test_context.stack.outputs = {
 392             u'b': u'10.20.30.45',
 393             u'b-subnet_id': 1,
 394             u'foo-12345678-a-subnet-cidr': u'10.20.0.0/15',
 395             u'foo-12345678-a-subnet-gateway_ip': u'10.20.30.1',
 396             u'b-mac_address': u'00:01',
 397             u'b-device_id': u'dev21',
 398             u'b-network_id': u'net789',
 399             u'd': u'40.30.20.15',
 400             u'd-subnet_id': 2,
 401             u'foo-12345678-c-subnet-cidr': u'40.30.0.0/18',
 402             u'foo-12345678-c-subnet-gateway_ip': u'40.30.20.254',
 403             u'd-mac_address': u'00:10',
 404             u'd-device_id': u'dev43',
 405             u'd-network_id': u'net987',
 406             u'e': u'40.30.20.15',
 407             u'e-subnet_id': 2,
 408             u'e-mac_address': u'00:10',
 409             u'e-device_id': u'dev43',
 410             u'e-network_id': u'net987',
 411         }
 412         server = mock.MagicMock()
 413         server.private_ip = None
 414         server.ports = OrderedDict([
 415             ('a', [{'stack_name': 'b', 'port': 'port_a'}]),
 416             ('c', [{'stack_name': 'd', 'port': 'port_c'},
 417                    {'stack_name': 'e', 'port': 'port_f'}]),
 418         ])
 419
 420         expected = {
 421             "private_ip": '10.20.30.45',
 422             "subnet_id": 1,
 423             "subnet_cidr": '10.20.0.0/15',
 424             "network": '10.20.0.0',
 425             "netmask": '255.254.0.0',
 426             "name": "port_a",
 427             "gateway_ip": '10.20.30.1',
 428             "mac_address": '00:01',
 429             "device_id": 'dev21',
 430             "network_id": 'net789',
 431             "network_name": 'a',
 432             "local_mac": '00:01',
 433             "local_ip": '10.20.30.45',
 434         }
 435         self.test_context.add_server_port(server)
 436         self.assertEqual(server.private_ip, '10.20.30.45')
 437         self.assertEqual(len(server.interfaces), 3)
 438         self.assertDictEqual(server.interfaces['port_a'], expected)
 439
 440     @mock.patch('yardstick.benchmark.contexts.heat.os')
 441     @mock.patch.object(heat.HeatContext, '_delete_key_file')
 442     @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
 443     def test_undeploy(self, mock_template, mock_delete_key, *args):
 444         self.test_context.stack = mock_template
 445         self.test_context._name = 'foo'
 446         self.test_context._task_id = '1234567890'
 447         self.test_context._name_task_id = '{}-{}'.format(
 448             self.test_context._name, self.test_context._task_id[:8])
 449         # mock_os.path.exists.return_value = True
 450         self.test_context.key_filename = 'foo/bar/foobar'
 451         self.test_context.undeploy()
 452         mock_delete_key.assert_called()
 453         mock_template.delete.assert_called_once()
 454
 455     @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
 456     def test_undeploy_no_teardown(self, mock_template):
 457         self.test_context.stack = mock_template
 458         self.test_context._name = 'foo'
 459         self.test_context._task_id = '1234567890'
 460         self.test_context._flags.no_teardown = True
 461         self.test_context.undeploy()
 462
 463         mock_template.delete.assert_not_called()
 464
 465     @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
 466     @mock.patch('yardstick.benchmark.contexts.heat.os')
 467     def test_undeploy_key_filename(self, mock_os, mock_template):
 468         self.test_context.stack = mock_template
 469         self.test_context._name = 'foo'
 470         self.test_context._task_id = '1234567890'
 471         self.test_context._name_task_id = '{}-{}'.format(
 472             self.test_context._name, self.test_context._task_id)
 473         mock_os.path.exists.return_value = True
 474         self.test_context.key_filename = 'foo/bar/foobar'
 475         self.assertIsNone(self.test_context.undeploy())
 476
 477     @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
 478     def test__get_server_found_dict(self, *args):
 479         """
 480         Use HeatContext._get_server to get a server that matches
 481         based on a dictionary input.
 482         """
 483         foo2_server = mock.Mock()
 484         foo2_server.key_filename = None
 485         foo2_server.private_ip = '10.0.0.2'
 486         foo2_server.public_ip = '127.0.0.2'
 487         foo2_server.context.user = 'oof'
 488
 489         baz3_server = mock.Mock()
 490         baz3_server.key_filename = None
 491         baz3_server.private_ip = '10.0.0.3'
 492         baz3_server.public_ip = '127.0.0.3'
 493         baz3_server.context.user = 'zab'
 494
 495         self.test_context._name = 'bar'
 496         self.test_context._task_id = '1234567890'
 497         self.test_context._name_task_id = '{}-{}'.format(
 498             self.test_context._name, self.test_context._task_id[:8])
 499         self.test_context._user = 'bot'
 500         self.test_context.stack = mock.Mock()
 501         self.test_context.stack.outputs = {
 502             'private_ip': '10.0.0.1',
 503             'public_ip': '127.0.0.1',
 504         }
 505         self.test_context._server_map = {
 506             'baz3': baz3_server,
 507             'foo2': foo2_server,
 508         }
 509
 510         attr_name = {
 511             'name': 'foo.bar-12345678',
 512             'private_ip_attr': 'private_ip',
 513             'public_ip_attr': 'public_ip',
 514         }
 515         self.test_context.key_uuid = 'foo-42'
 516         result = self.test_context._get_server(attr_name)
 517         self.assertEqual(result['user'], 'bot')
 518         self.assertEqual(result['ip'], '127.0.0.1')
 519         self.assertEqual(result['private_ip'], '10.0.0.1')
 520
 521     @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
 522     def test__get_server_found_dict_no_attrs(self, *args):
 523         """
 524         Use HeatContext._get_server to get a server that matches
 525         based on a dictionary input.
 526         """
 527         foo2_server = mock.Mock()
 528         foo2_server.private_ip = '10.0.0.2'
 529         foo2_server.public_ip = '127.0.0.2'
 530         foo2_server.context.user = 'oof'
 531
 532         baz3_server = mock.Mock()
 533         baz3_server.private_ip = '10.0.0.3'
 534         baz3_server.public_ip = '127.0.0.3'
 535         baz3_server.context.user = 'zab'
 536
 537         self.test_context._name = 'bar'
 538         self.test_context._task_id = '1234567890'
 539         self.test_context._name_task_id = '{}-{}'.format(
 540             self.test_context._name, self.test_context._task_id[:8])
 541         self.test_context._user = 'bot'
 542         self.test_context.stack = mock.Mock()
 543         self.test_context.stack.outputs = {
 544             'private_ip': '10.0.0.1',
 545             'public_ip': '127.0.0.1',
 546         }
 547         self.test_context._server_map = {
 548             'baz3': baz3_server,
 549             'foo2': foo2_server,
 550         }
 551
 552         attr_name = {
 553             'name': 'foo.bar-12345678',
 554         }
 555
 556         self.test_context.key_uuid = 'foo-42'
 557         result = self.test_context._get_server(attr_name)
 558         self.assertEqual(result['user'], 'bot')
 559         # no private ip attr mapping in the map results in None value in the result
 560         self.assertIsNone(result['private_ip'])
 561         # no public ip attr mapping in the map results in no value in the result
 562         self.assertNotIn('ip', result)
 563
 564     @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
 565     def test__get_server_found_not_dict(self, *args):
 566         """
 567         Use HeatContext._get_server to get a server that matches
 568         based on a non-dictionary input
 569         """
 570         foo2_server = mock.Mock()
 571         foo2_server.private_ip = '10.0.0.2'
 572         foo2_server.public_ip = '127.0.0.2'
 573         foo2_server.context.user = 'oof'
 574
 575         baz3_server = mock.Mock()
 576         baz3_server.private_ip = '10.0.0.3'
 577         baz3_server.public_ip = None
 578         baz3_server.context.user = 'zab'
 579
 580         self.test_context._name = 'bar1'
 581         self.test_context._task_id = '1234567890'
 582         self.test_context._name_task_id = 'bar1-12345678'
 583         self.test_context.stack = mock.Mock()
 584         self.test_context.stack.outputs = {
 585             'private_ip': '10.0.0.1',
 586             'public_ip': '127.0.0.1',
 587         }
 588         self.test_context.generate_routing_table = mock.MagicMock(return_value=[])
 589
 590         self.test_context._server_map = {
 591             'baz3': baz3_server,
 592             'foo2': foo2_server,
 593         }
 594
 595         attr_name = 'baz3'
 596         result = self.test_context._get_server(attr_name)
 597         self.assertEqual(result['user'], 'zab')
 598         self.assertEqual(result['private_ip'], '10.0.0.3')
 599         # no public_ip on the server results in no value in the result
 600         self.assertNotIn('public_ip', result)
 601
 602     @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
 603     def test__get_server_none_found_not_dict(self, *args):
 604         """
 605         Use HeatContext._get_server to not get a server due to
 606         None value associated with the match to a non-dictionary
 607         input
 608         """
 609         foo2_server = mock.Mock()
 610         foo2_server.private_ip = '10.0.0.2'
 611         foo2_server.public_ip = '127.0.0.2'
 612         foo2_server.context.user = 'oof'
 613
 614         baz3_server = mock.Mock()
 615         baz3_server.private_ip = '10.0.0.3'
 616         baz3_server.public_ip = None
 617         baz3_server.context.user = 'zab'
 618
 619         self.test_context._name = 'bar1'
 620         self.test_context.stack = mock.Mock()
 621         self.test_context.stack.outputs = {
 622             'private_ip': '10.0.0.1',
 623             'public_ip': '127.0.0.1',
 624         }
 625         self.test_context._server_map = {
 626             'baz3': baz3_server,
 627             'foo2': foo2_server,
 628             'wow4': None,
 629         }
 630
 631         self.test_context.key_uuid = 'foo-42'
 632         attr_name = 'wow4'
 633         result = self.test_context._get_server(attr_name)
 634         self.assertIsNone(result)
 635
 636     @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
 637     def test__get_server_not_found_dict(self, *args):
 638         """
 639         Use HeatContext._get_server to not get a server for lack
 640         of a match to a dictionary input
 641         """
 642         foo2_server = mock.Mock()
 643         foo2_server.private_ip = '10.0.0.2'
 644         foo2_server.public_ip = '127.0.0.2'
 645         foo2_server.context.user = 'oof'
 646
 647         baz3_server = mock.Mock()
 648         baz3_server.private_ip = '10.0.0.3'
 649         baz3_server.public_ip = None
 650         baz3_server.context.user = 'zab'
 651
 652         self.test_context._name = 'bar1'
 653         self.test_context._task_id = '1235467890'
 654         self.test_context._name_task_id = '{}-{}'.format(
 655             self.test_context._name, self.test_context._task_id[:8])
 656         self.test_context.stack = mock.Mock()
 657         self.test_context.stack.outputs = {
 658             'private_ip': '10.0.0.1',
 659             'public_ip': '127.0.0.1',
 660         }
 661         self.test_context._server_map = {
 662             'baz3': baz3_server,
 663             'foo2': foo2_server,
 664         }
 665
 666         self.test_context.key_uuid = 'foo-42'
 667         attr_name = {
 668             'name': 'foo.wow4',
 669             'private_ip_attr': 'private_ip',
 670             'public_ip_attr': 'public_ip',
 671         }
 672         result = self.test_context._get_server(attr_name)
 673         self.assertIsNone(result)
 674
 675     @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
 676     def test__get_server_not_found_not_dict(self, *args):
 677         """
 678         Use HeatContext._get_server to not get a server for lack
 679         of a match to a non-dictionary input
 680         """
 681         foo2_server = mock.Mock()
 682         foo2_server.private_ip = '10.0.0.2'
 683         foo2_server.public_ip = '127.0.0.2'
 684         foo2_server.context.user = 'oof'
 685
 686         baz3_server = mock.Mock()
 687         baz3_server.private_ip = '10.0.0.3'
 688         baz3_server.public_ip = None
 689         baz3_server.context.user = 'zab'
 690
 691         self.mock_context._name = 'bar1'
 692         self.test_context.stack = mock.Mock()
 693         self.mock_context.stack.outputs = {
 694             'private_ip': '10.0.0.1',
 695             'public_ip': '127.0.0.1',
 696         }
 697         self.mock_context._server_map = {
 698             'baz3': baz3_server,
 699             'foo2': foo2_server,
 700         }
 701
 702         self.test_context.key_uuid = 'foo-42'
 703         attr_name = 'foo.wow4'
 704         result = self.test_context._get_server(attr_name)
 705         self.assertIsNone(result)
 706
 707     # TODO: Split this into more granular tests
 708     def test__get_network(self):
 709         network1 = mock.MagicMock()
 710         network1.name = 'net_1'
 711         network1.vld_id = 'vld111'
 712         network1.segmentation_id = 'seg54'
 713         network1.network_type = 'type_a'
 714         network1.physical_network = 'phys'
 715
 716         network2 = mock.MagicMock()
 717         network2.name = 'net_2'
 718         network2.segmentation_id = 'seg45'
 719         network2.network_type = 'type_b'
 720         network2.physical_network = 'virt'
 721
 722         self.test_context.networks = {
 723             'a': network1,
 724             'b': network2,
 725         }
 726
 727         attr_name = None
 728         self.assertIsNone(self.test_context._get_network(attr_name))
 729
 730         attr_name = {}
 731         self.assertIsNone(self.test_context._get_network(attr_name))
 732
 733         attr_name = {'network_type': 'nosuch'}
 734         self.assertIsNone(self.test_context._get_network(attr_name))
 735
 736         attr_name = 'vld777'
 737         self.assertIsNone(self.test_context._get_network(attr_name))
 738
 739         attr_name = {'segmentation_id': 'seg45'}
 740         expected = {
 741             "name": 'net_2',
 742             "segmentation_id": 'seg45',
 743             "network_type": 'type_b',
 744             "physical_network": 'virt',
 745         }
 746         result = self.test_context._get_network(attr_name)
 747         self.assertDictEqual(result, expected)
 748
 749         attr_name = 'a'
 750         expected = {
 751             "name": 'net_1',
 752             "segmentation_id": 'seg54',
 753             "network_type": 'type_a',
 754             "physical_network": 'phys',
 755         }
 756         result = self.test_context._get_network(attr_name)
 757         self.assertDictEqual(result, expected)
 758
 759     def _get_file_abspath(self, filename):
 760         curr_path = os.path.dirname(os.path.abspath(__file__))
 761         file_path = os.path.join(curr_path, filename)
 762         return file_path
 763
 764     def test__get_physical_nodes(self):
 765         self.test_context.nodes = {}
 766         nodes = self.test_context._get_physical_nodes()
 767         self.assertEquals(nodes, {})
 768
 769     @mock.patch.object(yaml_loader, 'read_yaml_file')
 770     def test__get_physical_node_for_server(self, mock_read_yaml):
 771         attrs = {'name': 'foo',
 772                  'task_id': '12345678',
 773                  'file': "pod.yaml",
 774                  'servers': {'vnf': {}},
 775                  'networks': {'mgmt': {'cidr': '10.0.1.0/24'}}
 776                  }
 777
 778         with mock.patch.object(openstack_utils, 'get_shade_client'), \
 779              mock.patch.object(openstack_utils, 'get_shade_operator_client'):
 780             mock_read_yaml.return_value = self.HEAT_POD_SAMPLE
 781             self.test_context.init(attrs)
 782
 783         with mock.patch('yardstick.common.openstack_utils.get_server') as mock_get_server:
 784             mock_get_server.return_value = {'vnf': {}}
 785
 786             # When server is not from this context
 787             result = self.test_context._get_physical_node_for_server('node1.foo-context')
 788             self.assertIsNone(result)
 789
 790             # When node_name is not from this context
 791             result = self.test_context._get_physical_node_for_server('fake.foo-12345678')
 792             self.assertIsNone(result)
 793
 794             mock_munch = mock.Mock()
 795             mock_munch.toDict = mock.Mock(return_value={
 796                 'OS-EXT-SRV-ATTR:hypervisor_hostname': 'hypervisor_hostname'
 797             })
 798             mock_get_server.return_value = mock_munch
 799
 800             hypervisor = mock.Mock()
 801             hypervisor.hypervisor_hostname = 'hypervisor_hostname'
 802             hypervisor.host_ip = '10.229.47.137'
 803
 804             self.test_context.operator_client.list_hypervisors = mock.Mock(
 805                 return_value=[hypervisor])
 806
 807             mock_get_server.return_value = mock_munch
 808
 809             result = self.test_context._get_physical_node_for_server('vnf.foo-12345678')
 810             self.assertEqual(result, 'node1.foo')