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