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