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

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