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.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
  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,
  91                   mock_read_yaml):
  92
  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',
  99                  'file': 'pod.yaml',
 100                  'task_id': '1234567890',
 101                  'placement_groups': pgs,
 102                  'server_groups': sgs,
 103                  'networks': networks,
 104                  'servers': servers}
 105
 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)
 109
 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")
 117
 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)
 124
 125         mock_network.assert_called_with(
 126             'bar', self.test_context, networks['bar'])
 127         self.assertEqual(len(self.test_context.networks), 1)
 128
 129         mock_server.assert_called_with('baz', self.test_context,
 130                                        servers['baz'])
 131         self.assertEqual(len(self.test_context.servers), 1)
 132
 133     def test_init_no_name_or_task_id(self):
 134         attrs = {}
 135         self.assertRaises(KeyError, self.test_context.init, attrs)
 136
 137     def test_name(self):
 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')
 144
 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'
 150
 151         self.assertEqual(self.test_context.name, 'foo')
 152         self.assertEqual(self.test_context.assigned_name, 'foo')
 153
 154     def test_init_no_setup_no_teardown(self):
 155
 156         attrs = {'name': 'foo',
 157                  'task_id': '1234567890',
 158                  'placement_groups': {},
 159                  'server_groups': {},
 160                  'networks': {},
 161                  'servers': {},
 162                  'file': "pod.yaml",
 163                  'flags': {
 164                      'no_setup': True,
 165                      'no_teardown': True,
 166                      },
 167                 }
 168
 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)
 172
 173         self.assertTrue(self.test_context._flags.no_setup)
 174         self.assertTrue(self.test_context._flags.no_teardown)
 175
 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'}
 187
 188         self.test_context.networks = OrderedDict(
 189             {"mynet": model.Network("mynet", self.test_context,
 190                                            netattrs)})
 191
 192         self.test_context._add_resources_to_template(mock_template)
 193         mock_template.add_keypair.assert_called_with(
 194             "ctx-key",
 195             "ctx-12345678")
 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")
 207
 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)
 219
 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'
 224
 225         with self.assertRaises(AttributeError):
 226             self.test_context.flavor = 'foo'
 227
 228         with self.assertRaises(AttributeError):
 229             self.test_context.user = 'foo'
 230
 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()
 235
 236     def test__create_new_stack_stack_create_failed(self):
 237         template = mock.Mock()
 238         template.create.side_effect = y_exc.HeatTemplateError
 239
 240         self.assertRaises(y_exc.HeatTemplateError,
 241                           self.test_context._create_new_stack,
 242                           template)
 243
 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,
 249                           template)
 250
 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)
 262
 263         mock_path_exists.assert_called()
 264         mock_resources_template.assert_called_once()
 265
 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()
 278
 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)
 290
 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,
 298             *args):
 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()
 306
 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)
 316
 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',
 322                        return_value=None)
 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()
 332
 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)
 341
 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 \
 356                 mock_create_stack, \
 357                 mock.patch.object(self.test_context, 'get_neutron_info') as \
 358                 mock_neutron_info:
 359             self.test_context.deploy()
 360
 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)
 369
 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))
 375
 376     def test_check_for_context(self):
 377         pass
 378         # check that the context exists
 379
 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 = {
 389             'a': network1,
 390             'c': network2,
 391         }
 392         self.test_context.stack.outputs = {
 393             u'b': u'10.20.30.45',
 394             u'b-subnet_id': 1,
 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',
 401             u'd-subnet_id': 2,
 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',
 408             u'e-subnet_id': 2,
 409             u'e-mac_address': u'00:10',
 410             u'e-device_id': u'dev43',
 411             u'e-network_id': u'net987',
 412         }
 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'}]),
 419         ])
 420
 421         expected = {
 422             "private_ip": '10.20.30.45',
 423             "subnet_id": 1,
 424             "subnet_cidr": '10.20.0.0/15',
 425             "network": '10.20.0.0',
 426             "netmask": '255.254.0.0',
 427             "name": "port_a",
 428             "gateway_ip": '10.20.30.1',
 429             "mac_address": '00:01',
 430             "device_id": 'dev21',
 431             "network_id": 'net789',
 432             "network_name": 'a',
 433             "local_mac": '00:01',
 434             "local_ip": '10.20.30.45',
 435         }
 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)
 440
 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()
 455
 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()
 463
 464         mock_template.delete.assert_not_called()
 465
 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())
 477
 478     @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
 479     def test__get_server_found_dict(self, *args):
 480         """
 481         Use HeatContext._get_server to get a server that matches
 482         based on a dictionary input.
 483         """
 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'
 489
 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'
 495
 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',
 505         }
 506         self.test_context._server_map = {
 507             'baz3': baz3_server,
 508             'foo2': foo2_server,
 509         }
 510
 511         attr_name = {
 512             'name': 'foo.bar-12345678',
 513             'private_ip_attr': 'private_ip',
 514             'public_ip_attr': 'public_ip',
 515         }
 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')
 521
 522     @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
 523     def test__get_server_found_dict_no_attrs(self, *args):
 524         """
 525         Use HeatContext._get_server to get a server that matches
 526         based on a dictionary input.
 527         """
 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'
 532
 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'
 537
 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',
 547         }
 548         self.test_context._server_map = {
 549             'baz3': baz3_server,
 550             'foo2': foo2_server,
 551         }
 552
 553         attr_name = {
 554             'name': 'foo.bar-12345678',
 555         }
 556
 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)
 564
 565     @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
 566     def test__get_server_found_not_dict(self, *args):
 567         """
 568         Use HeatContext._get_server to get a server that matches
 569         based on a non-dictionary input
 570         """
 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'
 575
 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'
 580
 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',
 588         }
 589         self.test_context.generate_routing_table = mock.MagicMock(return_value=[])
 590
 591         self.test_context._server_map = {
 592             'baz3': baz3_server,
 593             'foo2': foo2_server,
 594         }
 595
 596         attr_name = 'baz3'
 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)
 602
 603     @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
 604     def test__get_server_none_found_not_dict(self, *args):
 605         """
 606         Use HeatContext._get_server to not get a server due to
 607         None value associated with the match to a non-dictionary
 608         input
 609         """
 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'
 614
 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'
 619
 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',
 625         }
 626         self.test_context._server_map = {
 627             'baz3': baz3_server,
 628             'foo2': foo2_server,
 629             'wow4': None,
 630         }
 631
 632         self.test_context.key_uuid = 'foo-42'
 633         attr_name = 'wow4'
 634         result = self.test_context._get_server(attr_name)
 635         self.assertIsNone(result)
 636
 637     @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
 638     def test__get_server_not_found_dict(self, *args):
 639         """
 640         Use HeatContext._get_server to not get a server for lack
 641         of a match to a dictionary input
 642         """
 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'
 647
 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'
 652
 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',
 661         }
 662         self.test_context._server_map = {
 663             'baz3': baz3_server,
 664             'foo2': foo2_server,
 665         }
 666
 667         self.test_context.key_uuid = 'foo-42'
 668         attr_name = {
 669             'name': 'foo.wow4',
 670             'private_ip_attr': 'private_ip',
 671             'public_ip_attr': 'public_ip',
 672         }
 673         result = self.test_context._get_server(attr_name)
 674         self.assertIsNone(result)
 675
 676     @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
 677     def test__get_server_not_found_not_dict(self, *args):
 678         """
 679         Use HeatContext._get_server to not get a server for lack
 680         of a match to a non-dictionary input
 681         """
 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'
 686
 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'
 691
 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',
 697         }
 698         self.mock_context._server_map = {
 699             'baz3': baz3_server,
 700             'foo2': foo2_server,
 701         }
 702
 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)
 707
 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'
 716
 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'
 722
 723         self.test_context.networks = {
 724             'a': network1,
 725             'b': network2,
 726         }
 727
 728         attr_name = None
 729         self.assertIsNone(self.test_context._get_network(attr_name))
 730
 731         attr_name = {}
 732         self.assertIsNone(self.test_context._get_network(attr_name))
 733
 734         attr_name = {'network_type': 'nosuch'}
 735         self.assertIsNone(self.test_context._get_network(attr_name))
 736
 737         attr_name = 'vld777'
 738         self.assertIsNone(self.test_context._get_network(attr_name))
 739
 740         attr_name = {'segmentation_id': 'seg45'}
 741         expected = {
 742             "name": 'net_2',
 743             "segmentation_id": 'seg45',
 744             "network_type": 'type_b',
 745             "physical_network": 'virt',
 746         }
 747         result = self.test_context._get_network(attr_name)
 748         self.assertDictEqual(result, expected)
 749
 750         attr_name = 'a'
 751         expected = {
 752             "name": 'net_1',
 753             "segmentation_id": 'seg54',
 754             "network_type": 'type_a',
 755             "physical_network": 'phys',
 756         }
 757         result = self.test_context._get_network(attr_name)
 758         self.assertDictEqual(result, expected)
 759
 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)
 763         return file_path
 764
 765     def test__get_physical_nodes(self):
 766         self.test_context.nodes = {}
 767         nodes = self.test_context._get_physical_nodes()
 768         self.assertEquals(nodes, {})
 769
 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',
 774                  'file': "pod.yaml",
 775                  'servers': {'vnf': {}},
 776                  'networks': {'mgmt': {'cidr': '10.0.1.0/24'}}
 777                  }
 778
 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)
 783
 784         with mock.patch('yardstick.common.openstack_utils.get_server') as mock_get_server:
 785             mock_get_server.return_value = {'vnf': {}}
 786
 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)
 790
 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)
 794
 795             mock_munch = mock.Mock()
 796             mock_munch.toDict = mock.Mock(return_value={
 797                 'OS-EXT-SRV-ATTR:hypervisor_hostname': 'hypervisor_hostname'
 798             })
 799             mock_get_server.return_value = mock_munch
 800
 801             hypervisor = mock.Mock()
 802             hypervisor.hypervisor_hostname = 'hypervisor_hostname'
 803             hypervisor.host_ip = '10.229.47.137'
 804
 805             self.test_context.operator_client.list_hypervisors = mock.Mock(
 806                 return_value=[hypervisor])
 807
 808             mock_get_server.return_value = mock_munch
 809
 810             result = self.test_context._get_physical_node_for_server('vnf.foo-12345678')
 811             self.assertEqual(result, 'node1.foo')