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