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

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