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