diff options
Diffstat (limited to 'yardstick/tests/unit/benchmark/contexts/test_heat.py')
-rw-r--r-- | yardstick/tests/unit/benchmark/contexts/test_heat.py | 893 |
1 files changed, 893 insertions, 0 deletions
diff --git a/yardstick/tests/unit/benchmark/contexts/test_heat.py b/yardstick/tests/unit/benchmark/contexts/test_heat.py new file mode 100644 index 000000000..96946cded --- /dev/null +++ b/yardstick/tests/unit/benchmark/contexts/test_heat.py @@ -0,0 +1,893 @@ +############################################################################## +# Copyright (c) 2015 Ericsson AB and others. +# +# All rights reserved. This program and the accompanying materials +# are made available under the terms of the Apache License, Version 2.0 +# which accompanies this distribution, and is available at +# http://www.apache.org/licenses/LICENSE-2.0 +############################################################################## + +from collections import OrderedDict +import logging +import os + +import mock +import unittest +import collections + +from yardstick.benchmark.contexts import base +from yardstick.benchmark.contexts import heat +from yardstick.benchmark.contexts import model +from yardstick.common import constants as consts +from yardstick.common import exceptions as y_exc +from yardstick.common import openstack_utils +from yardstick.common import yaml_loader +from yardstick import ssh + + +LOG = logging.getLogger(__name__) + + +class HeatContextTestCase(unittest.TestCase): + + HEAT_POD_SAMPLE = { + "nodes": [ + { + "name": "node1", + "role": "Controller", + "ip": "10.229.47.137", + "user": "root", + "key_filename": "/root/.yardstick_key" + }, + { + "name": "node2", + "role": "Compute", + "ip": "10.229.47.139", + "user": "root", + "key_filename": "/root/.yardstick_key" + } + ] + } + + def __init__(self, *args, **kwargs): + + super(HeatContextTestCase, self).__init__(*args, **kwargs) + + def setUp(self): + self.test_context = heat.HeatContext() + self.addCleanup(self._remove_contexts) + self.mock_context = mock.Mock(spec=heat.HeatContext()) + + def _remove_contexts(self): + if self.test_context in self.test_context.list: + self.test_context._delete_context() + + def test___init__(self): + self.assertIsNone(self.test_context._name) + self.assertIsNone(self.test_context._task_id) + self.assertFalse(self.test_context._flags.no_setup) + self.assertFalse(self.test_context._flags.no_teardown) + self.assertIsNone(self.test_context.stack) + self.assertEqual(self.test_context.networks, OrderedDict()) + self.assertEqual(self.test_context.servers, []) + self.assertEqual(self.test_context.placement_groups, []) + self.assertEqual(self.test_context.server_groups, []) + self.assertIsNone(self.test_context.keypair_name) + self.assertIsNone(self.test_context.secgroup_name) + self.assertIsNone(self.test_context.security_group) + self.assertEqual(self.test_context._server_map, {}) + self.assertIsNone(self.test_context._image) + self.assertIsNone(self.test_context._flavor) + self.assertIsNone(self.test_context._user) + self.assertIsNone(self.test_context.template_file) + self.assertIsNone(self.test_context.heat_parameters) + self.assertIsNone(self.test_context.key_filename) + self.assertTrue(self.test_context.yardstick_gen_key_file) + + @mock.patch.object(yaml_loader, 'read_yaml_file') + @mock.patch('yardstick.benchmark.contexts.heat.PlacementGroup') + @mock.patch('yardstick.benchmark.contexts.heat.ServerGroup') + @mock.patch('yardstick.benchmark.contexts.heat.Network') + @mock.patch('yardstick.benchmark.contexts.heat.Server') + def test_init(self, mock_server, mock_network, mock_sg, mock_pg, + mock_read_yaml): + + mock_read_yaml.return_value = self.HEAT_POD_SAMPLE + pgs = {'pgrp1': {'policy': 'availability'}} + sgs = {'servergroup1': {'policy': 'affinity'}} + networks = {'bar': {'cidr': '10.0.1.0/24'}} + servers = {'baz': {'floating_ip': True, 'placement': 'pgrp1'}} + attrs = {'name': 'foo', + 'file': 'pod.yaml', + 'task_id': '1234567890', + 'placement_groups': pgs, + 'server_groups': sgs, + 'networks': networks, + 'servers': servers} + + with mock.patch.object(openstack_utils, 'get_shade_client'), \ + mock.patch.object(openstack_utils, 'get_shade_operator_client'): + self.test_context.init(attrs) + + self.assertFalse(self.test_context._flags.no_setup) + self.assertFalse(self.test_context._flags.no_teardown) + self.assertEqual(self.test_context._name, "foo") + self.assertEqual(self.test_context._task_id, '1234567890') + self.assertEqual(self.test_context.name, "foo-12345678") + self.assertEqual(self.test_context.keypair_name, "foo-12345678-key") + self.assertEqual(self.test_context.secgroup_name, "foo-12345678-secgroup") + + mock_pg.assert_called_with('pgrp1', self.test_context, + pgs['pgrp1']['policy']) + mock_sg.assert_called_with('servergroup1', self.test_context, + sgs['servergroup1']['policy']) + self.assertEqual(len(self.test_context.placement_groups), 1) + self.assertEqual(len(self.test_context.server_groups), 1) + + mock_network.assert_called_with( + 'bar', self.test_context, networks['bar']) + self.assertEqual(len(self.test_context.networks), 1) + + mock_server.assert_called_with('baz', self.test_context, + servers['baz']) + self.assertEqual(len(self.test_context.servers), 1) + + def test_init_no_name_or_task_id(self): + attrs = {} + self.assertRaises(KeyError, self.test_context.init, attrs) + + def test_name(self): + self.test_context._name = 'foo' + self.test_context._task_id = '1234567890' + self.test_context._name_task_id = '{}-{}'.format( + self.test_context._name, self.test_context._task_id[:8]) + self.assertEqual(self.test_context.name, 'foo-12345678') + self.assertEqual(self.test_context.assigned_name, 'foo') + + def test_name_flags(self): + self.test_context._flags = base.Flags( + **{"no_setup": True, "no_teardown": True}) + self.test_context._name = 'foo' + self.test_context._task_id = '1234567890' + + self.assertEqual(self.test_context.name, 'foo') + self.assertEqual(self.test_context.assigned_name, 'foo') + + def test_init_no_setup_no_teardown(self): + + attrs = {'name': 'foo', + 'task_id': '1234567890', + 'placement_groups': {}, + 'server_groups': {}, + 'networks': {}, + 'servers': {}, + 'file': "pod.yaml", + 'flags': { + 'no_setup': True, + 'no_teardown': True, + }, + } + + with mock.patch.object(openstack_utils, 'get_shade_client'), \ + mock.patch.object(openstack_utils, 'get_shade_operator_client'): + self.test_context.init(attrs) + + self.assertTrue(self.test_context._flags.no_setup) + self.assertTrue(self.test_context._flags.no_teardown) + + def test_init_key_filename(self): + attrs = {'name': 'foo', + 'file': 'pod.yaml', + 'task_id': '1234567890', + 'server_groups': {}, + 'networks': {}, + 'servers': {}, + 'heat_template': "/root/clearwater.yaml", + 'key_filename': '/etc/yardstick/yardstick.pem'} + + with mock.patch.object(openstack_utils, 'get_shade_client'), \ + mock.patch.object(openstack_utils, 'get_shade_operator_client'): + self.test_context.init(attrs) + + self.assertIsNotNone(self.test_context.key_filename) + self.assertFalse(self.test_context.yardstick_gen_key_file) + + @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate') + def test__add_resources_to_template_no_servers(self, mock_template): + self.test_context._name = 'ctx' + self.test_context._task_id = '1234567890' + self.test_context._name_task_id = '{}-{}'.format( + self.test_context._name, self.test_context._task_id[:8]) + self.test_context.keypair_name = "ctx-key" + self.test_context.secgroup_name = "ctx-secgroup" + self.test_context.key_uuid = "2f2e4997-0a8e-4eb7-9fa4-f3f8fbbc393b" + netattrs = {'cidr': '10.0.0.0/24', 'provider': None, + 'external_network': 'ext_net'} + + self.test_context.networks = OrderedDict( + {"mynet": model.Network("mynet", self.test_context, + netattrs)}) + + self.test_context._add_resources_to_template(mock_template) + mock_template.add_keypair.assert_called_with( + "ctx-key", + "ctx-12345678") + mock_template.add_security_group.assert_called_with("ctx-secgroup", None) + mock_template.add_network.assert_called_with( + "ctx-12345678-mynet", 'physnet1', None, None, None, None) + mock_template.add_router.assert_called_with( + "ctx-12345678-mynet-router", + netattrs["external_network"], + "ctx-12345678-mynet-subnet") + mock_template.add_router_interface.assert_called_with( + "ctx-12345678-mynet-router-if0", + "ctx-12345678-mynet-router", + "ctx-12345678-mynet-subnet") + + @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate') + def test_attrs_get(self, *args): + image, flavor, user = expected_tuple = 'foo1', 'foo2', 'foo3' + self.assertNotEqual(self.test_context.image, image) + self.assertNotEqual(self.test_context.flavor, flavor) + self.assertNotEqual(self.test_context.user, user) + self.test_context._image = image + self.test_context._flavor = flavor + self.test_context._user = user + attr_tuple = self.test_context.image, self.test_context.flavor, self.test_context.user + self.assertEqual(attr_tuple, expected_tuple) + + @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate') + def test_attrs_set_negative(self, *args): + with self.assertRaises(AttributeError): + self.test_context.image = 'foo' + + with self.assertRaises(AttributeError): + self.test_context.flavor = 'foo' + + with self.assertRaises(AttributeError): + self.test_context.user = 'foo' + + def test__create_new_stack(self): + template = mock.Mock() + self.test_context._create_new_stack(template) + template.create.assert_called_once() + + def test__create_new_stack_stack_create_failed(self): + template = mock.Mock() + template.create.side_effect = y_exc.HeatTemplateError + + self.assertRaises(y_exc.HeatTemplateError, + self.test_context._create_new_stack, + template) + + def test__create_new_stack_keyboard_interrupt(self): + template = mock.Mock() + template.create.side_effect = KeyboardInterrupt + self.assertRaises(y_exc.StackCreationInterrupt, + self.test_context._create_new_stack, + template) + + @mock.patch.object(os.path, 'exists', return_value=True) + @mock.patch.object(heat.HeatContext, '_add_resources_to_template') + @mock.patch.object(heat.HeatContext, '_create_new_stack') + def test_deploy_stack_creation_failed(self, mock_create, + mock_resources_template, mock_path_exists): + self.test_context._name = 'foo' + self.test_context._task_id = '1234567890' + self.test_context._name_task_id = 'foo-12345678' + mock_create.side_effect = y_exc.HeatTemplateError + self.assertRaises(y_exc.HeatTemplateError, + self.test_context.deploy) + + mock_path_exists.assert_called() + mock_resources_template.assert_called_once() + + @mock.patch.object(os.path, 'exists', return_value=False) + @mock.patch.object(ssh.SSH, 'gen_keys') + @mock.patch.object(heat, 'HeatTemplate') + def test_deploy(self, mock_template, mock_genkeys, mock_path_exists): + self.test_context._name = 'foo' + self.test_context._task_id = '1234567890' + self.test_context._name_task_id = '{}-{}'.format( + self.test_context._name, self.test_context._task_id[:8]) + self.test_context.template_file = '/bar/baz/some-heat-file' + self.test_context.heat_parameters = {'image': 'cirros'} + self.test_context.get_neutron_info = mock.MagicMock() + self.test_context.deploy() + + mock_template.assert_called_with( + 'foo-12345678', template_file='/bar/baz/some-heat-file', + heat_parameters={'image': 'cirros'}, + os_cloud_config=self.test_context._flags.os_cloud_config) + self.assertIsNotNone(self.test_context.stack) + key_filename = ''.join( + [consts.YARDSTICK_ROOT_PATH, + 'yardstick/resources/files/yardstick_key-', + self.test_context._name_task_id]) + mock_genkeys.assert_called_once_with(key_filename) + mock_path_exists.assert_any_call(key_filename) + + @mock.patch.object(heat, 'HeatTemplate') + @mock.patch.object(os.path, 'exists', return_value=False) + @mock.patch.object(ssh.SSH, 'gen_keys') + @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack') + @mock.patch.object(heat.HeatContext, '_create_new_stack') + def test_deploy_no_setup(self, mock_create_new_stack, + mock_retrieve_existing_stack, mock_genkeys, mock_path_exists, + *args): + self.test_context._name = 'foo' + self.test_context._task_id = '1234567890' + self.test_context.template_file = '/bar/baz/some-heat-file' + self.test_context.heat_parameters = {'image': 'cirros'} + self.test_context.get_neutron_info = mock.MagicMock() + self.test_context._flags.no_setup = True + self.test_context.deploy() + + mock_create_new_stack.assert_not_called() + mock_retrieve_existing_stack.assert_called_with(self.test_context.name) + self.assertIsNotNone(self.test_context.stack) + key_filename = ''.join( + [consts.YARDSTICK_ROOT_PATH, + 'yardstick/resources/files/yardstick_key-', + self.test_context._name]) + mock_genkeys.assert_called_once_with(key_filename) + mock_path_exists.assert_any_call(key_filename) + + @mock.patch.object(heat, 'HeatTemplate') + @mock.patch.object(os.path, 'exists', return_value=False) + @mock.patch.object(ssh.SSH, 'gen_keys') + @mock.patch.object(heat.HeatContext, '_create_new_stack') + @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack', + return_value=None) + def test_deploy_try_retrieve_context_does_not_exist(self, + mock_retrieve_stack, mock_create_new_stack, mock_genkeys, + mock_path_exists, *args): + self.test_context._name = 'demo' + self.test_context._task_id = '1234567890' + self.test_context._flags.no_setup = True + self.test_context.template_file = '/bar/baz/some-heat-file' + self.test_context.get_neutron_info = mock.MagicMock() + self.test_context.deploy() + + mock_retrieve_stack.assert_called_once_with(self.test_context._name) + mock_create_new_stack.assert_called() + key_filename = ''.join( + [consts.YARDSTICK_ROOT_PATH, + 'yardstick/resources/files/yardstick_key-', + self.test_context._name]) + mock_genkeys.assert_called_once_with(key_filename) + mock_path_exists.assert_any_call(key_filename) + + @mock.patch.object(heat, 'HeatTemplate', return_value='heat_template') + @mock.patch.object(heat.HeatContext, '_add_resources_to_template') + @mock.patch.object(os.path, 'exists', return_value=False) + @mock.patch.object(ssh.SSH, 'gen_keys') + def test_deploy_ssh_key_before_adding_resources(self, mock_genkeys, + mock_path_exists, mock_add_resources, *args): + mock_manager = mock.Mock() + mock_manager.attach_mock(mock_add_resources, + '_add_resources_to_template') + mock_manager.attach_mock(mock_genkeys, 'gen_keys') + mock_manager.reset_mock() + self.test_context._name_task_id = 'demo-12345678' + self.test_context.get_neutron_info = mock.Mock() + with mock.patch.object(self.test_context, '_create_new_stack') as \ + mock_create_stack, \ + mock.patch.object(self.test_context, 'get_neutron_info') as \ + mock_neutron_info: + self.test_context.deploy() + + mock_neutron_info.assert_called_once() + mock_create_stack.assert_called_once() + key_filename = ''.join( + [consts.YARDSTICK_ROOT_PATH, + 'yardstick/resources/files/yardstick_key-', + self.test_context._name_task_id]) + mock_genkeys.assert_called_once_with(key_filename) + mock_path_exists.assert_any_call(key_filename) + + mock_call_gen_keys = mock.call.gen_keys(key_filename) + mock_call_add_resources = ( + mock.call._add_resources_to_template('heat_template')) + self.assertTrue(mock_manager.mock_calls.index(mock_call_gen_keys) < + mock_manager.mock_calls.index(mock_call_add_resources)) + + @mock.patch.object(heat, 'HeatTemplate') + @mock.patch.object(ssh.SSH, 'gen_keys') + @mock.patch.object(heat.HeatContext, '_create_new_stack') + def test_deploy_with_key_filename_provided(self, mock_create_new_stack, + mock_gen_keys, *args): + self.test_context._name = 'foo' + self.test_context._task_id = '1234567890' + self.test_context._name_task_id = '{}-{}'.format( + self.test_context._name, self.test_context._task_id[:8]) + self.test_context.template_file = '/bar/baz/some-heat-file' + self.test_context.heat_parameters = {'image': 'cirros'} + self.test_context.yardstick_gen_key_file = False + self.test_context.key_filename = '/etc/yardstick/yardstick.pem' + self.test_context.get_neutron_info = mock.MagicMock() + self.test_context.deploy() + + mock_create_new_stack.assert_called() + mock_gen_keys.assert_not_called() + + def test_check_for_context(self): + pass + # check that the context exists + + def test_add_server_port(self): + network1 = mock.MagicMock() + network2 = mock.MagicMock() + self.test_context._name = 'foo' + self.test_context._task_id = '1234567890' + self.test_context._name_task_id = '{}-{}'.format( + self.test_context._name, self.test_context._task_id[:8]) + self.test_context.stack = mock.MagicMock() + self.test_context.networks = { + 'a': network1, + 'c': network2, + } + self.test_context.stack.outputs = { + u'b': u'10.20.30.45', + u'b-subnet_id': 1, + u'foo-12345678-a-subnet-cidr': u'10.20.0.0/15', + u'foo-12345678-a-subnet-gateway_ip': u'10.20.30.1', + u'b-mac_address': u'00:01', + u'b-device_id': u'dev21', + u'b-network_id': u'net789', + u'd': u'40.30.20.15', + u'd-subnet_id': 2, + u'foo-12345678-c-subnet-cidr': u'40.30.0.0/18', + u'foo-12345678-c-subnet-gateway_ip': u'40.30.20.254', + u'd-mac_address': u'00:10', + u'd-device_id': u'dev43', + u'd-network_id': u'net987', + u'e': u'40.30.20.15', + u'e-subnet_id': 2, + u'e-mac_address': u'00:10', + u'e-device_id': u'dev43', + u'e-network_id': u'net987', + } + server = mock.MagicMock() + server.private_ip = None + server.ports = OrderedDict([ + ('a', [{'stack_name': 'b', 'port': 'port_a'}]), + ('c', [{'stack_name': 'd', 'port': 'port_c'}, + {'stack_name': 'e', 'port': 'port_f'}]), + ]) + + expected = { + "private_ip": '10.20.30.45', + "subnet_id": 1, + "subnet_cidr": '10.20.0.0/15', + "network": '10.20.0.0', + "netmask": '255.254.0.0', + "name": "port_a", + "gateway_ip": '10.20.30.1', + "mac_address": '00:01', + "device_id": 'dev21', + "network_id": 'net789', + "network_name": 'a', + "local_mac": '00:01', + "local_ip": '10.20.30.45', + } + self.test_context.add_server_port(server) + self.assertEqual(server.private_ip, '10.20.30.45') + self.assertEqual(len(server.interfaces), 3) + self.assertDictEqual(server.interfaces['port_a'], expected) + + @mock.patch('yardstick.benchmark.contexts.heat.os') + @mock.patch.object(heat.HeatContext, '_delete_key_file') + @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate') + def test_undeploy(self, mock_template, mock_delete_key, *args): + self.test_context.stack = mock_template + self.test_context._name = 'foo' + self.test_context._task_id = '1234567890' + self.test_context._name_task_id = '{}-{}'.format( + self.test_context._name, self.test_context._task_id[:8]) + # mock_os.path.exists.return_value = True + self.test_context.key_filename = 'foo/bar/foobar' + self.test_context.undeploy() + mock_delete_key.assert_called() + mock_template.delete.assert_called_once() + + @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate') + def test_undeploy_no_teardown(self, mock_template): + self.test_context.stack = mock_template + self.test_context._name = 'foo' + self.test_context._task_id = '1234567890' + self.test_context._flags.no_teardown = True + self.test_context.undeploy() + + mock_template.delete.assert_not_called() + + @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate') + @mock.patch('yardstick.benchmark.contexts.heat.os') + def test_undeploy_key_filename(self, mock_os, mock_template): + self.test_context.stack = mock_template + self.test_context._name = 'foo' + self.test_context._task_id = '1234567890' + self.test_context._name_task_id = '{}-{}'.format( + self.test_context._name, self.test_context._task_id) + mock_os.path.exists.return_value = True + self.test_context.key_filename = 'foo/bar/foobar' + self.assertIsNone(self.test_context.undeploy()) + + @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources") + def test__get_server_found_dict(self, *args): + """ + Use HeatContext._get_server to get a server that matches + based on a dictionary input. + """ + foo2_server = mock.Mock() + foo2_server.key_filename = None + foo2_server.private_ip = '10.0.0.2' + foo2_server.public_ip = '127.0.0.2' + foo2_server.context.user = 'oof' + + baz3_server = mock.Mock() + baz3_server.key_filename = None + baz3_server.private_ip = '10.0.0.3' + baz3_server.public_ip = '127.0.0.3' + baz3_server.context.user = 'zab' + + self.test_context._name = 'bar' + self.test_context._task_id = '1234567890' + self.test_context._name_task_id = '{}-{}'.format( + self.test_context._name, self.test_context._task_id[:8]) + self.test_context._user = 'bot' + self.test_context.stack = mock.Mock() + self.test_context.stack.outputs = { + 'private_ip': '10.0.0.1', + 'public_ip': '127.0.0.1', + } + self.test_context._server_map = { + 'baz3': baz3_server, + 'foo2': foo2_server, + } + + attr_name = { + 'name': 'foo.bar-12345678', + 'private_ip_attr': 'private_ip', + 'public_ip_attr': 'public_ip', + } + self.test_context.key_uuid = 'foo-42' + result = self.test_context._get_server(attr_name) + self.assertEqual(result['user'], 'bot') + self.assertEqual(result['ip'], '127.0.0.1') + self.assertEqual(result['private_ip'], '10.0.0.1') + + @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources") + def test__get_server_found_dict_no_attrs(self, *args): + """ + Use HeatContext._get_server to get a server that matches + based on a dictionary input. + """ + foo2_server = mock.Mock() + foo2_server.private_ip = '10.0.0.2' + foo2_server.public_ip = '127.0.0.2' + foo2_server.context.user = 'oof' + + baz3_server = mock.Mock() + baz3_server.private_ip = '10.0.0.3' + baz3_server.public_ip = '127.0.0.3' + baz3_server.context.user = 'zab' + + self.test_context._name = 'bar' + self.test_context._task_id = '1234567890' + self.test_context._name_task_id = '{}-{}'.format( + self.test_context._name, self.test_context._task_id[:8]) + self.test_context._user = 'bot' + self.test_context.stack = mock.Mock() + self.test_context.stack.outputs = { + 'private_ip': '10.0.0.1', + 'public_ip': '127.0.0.1', + } + self.test_context._server_map = { + 'baz3': baz3_server, + 'foo2': foo2_server, + } + + attr_name = { + 'name': 'foo.bar-12345678', + } + + self.test_context.key_uuid = 'foo-42' + result = self.test_context._get_server(attr_name) + self.assertEqual(result['user'], 'bot') + # no private ip attr mapping in the map results in None value in the result + self.assertIsNone(result['private_ip']) + # no public ip attr mapping in the map results in no value in the result + self.assertNotIn('ip', result) + + @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources") + def test__get_server_found_not_dict(self, *args): + """ + Use HeatContext._get_server to get a server that matches + based on a non-dictionary input + """ + foo2_server = mock.Mock() + foo2_server.private_ip = '10.0.0.2' + foo2_server.public_ip = '127.0.0.2' + foo2_server.context.user = 'oof' + + baz3_server = mock.Mock() + baz3_server.private_ip = '10.0.0.3' + baz3_server.public_ip = None + baz3_server.context.user = 'zab' + + self.test_context._name = 'bar1' + self.test_context._task_id = '1234567890' + self.test_context._name_task_id = 'bar1-12345678' + self.test_context.stack = mock.Mock() + self.test_context.stack.outputs = { + 'private_ip': '10.0.0.1', + 'public_ip': '127.0.0.1', + } + self.test_context.generate_routing_table = mock.MagicMock(return_value=[]) + + self.test_context._server_map = { + 'baz3': baz3_server, + 'foo2': foo2_server, + } + + attr_name = 'baz3' + result = self.test_context._get_server(attr_name) + self.assertEqual(result['user'], 'zab') + self.assertEqual(result['private_ip'], '10.0.0.3') + # no public_ip on the server results in no value in the result + self.assertNotIn('public_ip', result) + + @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources") + def test__get_server_none_found_not_dict(self, *args): + """ + Use HeatContext._get_server to not get a server due to + None value associated with the match to a non-dictionary + input + """ + foo2_server = mock.Mock() + foo2_server.private_ip = '10.0.0.2' + foo2_server.public_ip = '127.0.0.2' + foo2_server.context.user = 'oof' + + baz3_server = mock.Mock() + baz3_server.private_ip = '10.0.0.3' + baz3_server.public_ip = None + baz3_server.context.user = 'zab' + + self.test_context._name = 'bar1' + self.test_context.stack = mock.Mock() + self.test_context.stack.outputs = { + 'private_ip': '10.0.0.1', + 'public_ip': '127.0.0.1', + } + self.test_context._server_map = { + 'baz3': baz3_server, + 'foo2': foo2_server, + 'wow4': None, + } + + self.test_context.key_uuid = 'foo-42' + attr_name = 'wow4' + result = self.test_context._get_server(attr_name) + self.assertIsNone(result) + + @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources") + def test__get_server_not_found_dict(self, *args): + """ + Use HeatContext._get_server to not get a server for lack + of a match to a dictionary input + """ + foo2_server = mock.Mock() + foo2_server.private_ip = '10.0.0.2' + foo2_server.public_ip = '127.0.0.2' + foo2_server.context.user = 'oof' + + baz3_server = mock.Mock() + baz3_server.private_ip = '10.0.0.3' + baz3_server.public_ip = None + baz3_server.context.user = 'zab' + + self.test_context._name = 'bar1' + self.test_context._task_id = '1235467890' + self.test_context._name_task_id = '{}-{}'.format( + self.test_context._name, self.test_context._task_id[:8]) + self.test_context.stack = mock.Mock() + self.test_context.stack.outputs = { + 'private_ip': '10.0.0.1', + 'public_ip': '127.0.0.1', + } + self.test_context._server_map = { + 'baz3': baz3_server, + 'foo2': foo2_server, + } + + self.test_context.key_uuid = 'foo-42' + attr_name = { + 'name': 'foo.wow4', + 'private_ip_attr': 'private_ip', + 'public_ip_attr': 'public_ip', + } + result = self.test_context._get_server(attr_name) + self.assertIsNone(result) + + @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources") + def test__get_server_not_found_not_dict(self, *args): + """ + Use HeatContext._get_server to not get a server for lack + of a match to a non-dictionary input + """ + foo2_server = mock.Mock() + foo2_server.private_ip = '10.0.0.2' + foo2_server.public_ip = '127.0.0.2' + foo2_server.context.user = 'oof' + + baz3_server = mock.Mock() + baz3_server.private_ip = '10.0.0.3' + baz3_server.public_ip = None + baz3_server.context.user = 'zab' + + self.mock_context._name = 'bar1' + self.test_context.stack = mock.Mock() + self.mock_context.stack.outputs = { + 'private_ip': '10.0.0.1', + 'public_ip': '127.0.0.1', + } + self.mock_context._server_map = { + 'baz3': baz3_server, + 'foo2': foo2_server, + } + + self.test_context.key_uuid = 'foo-42' + attr_name = 'foo.wow4' + result = self.test_context._get_server(attr_name) + self.assertIsNone(result) + + @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources") + def test__get_server_found_dict_found_interfaces_dict(self, *args): + """ + Use HeatContext._get_server to get a server that matches + based on a dictionary input. + """ + self.test_context._name = 'bar' + self.test_context._task_id = '1234567890' + self.test_context._name_task_id = '{}-{}'.format( + self.test_context._name, self.test_context._task_id[:8]) + self.test_context._user = 'bot' + self.test_context.stack = mock.Mock() + self.test_context.stack.outputs = { + 'private_ip': '10.0.0.1', + 'public_ip': '127.0.0.1', + 'local_mac_addr': '64:00:6a:18:0f:d6', + 'private_netmask': '255.255.255.0', + 'private_net_name': 'private_network', + 'private_net_gateway': '127.0.0.254' + } + + attr_name = { + 'name': 'foo.bar-12345678', + 'private_ip_attr': 'private_ip', + 'public_ip_attr': 'public_ip', + 'interfaces': { + 'data_net': { + 'local_ip': 'private_ip', + 'local_mac': 'local_mac_addr', + 'netmask': 'private_netmask', + 'network': 'private_net_name', + 'gateway_ip': 'private_net_gateway' + } + } + } + self.test_context.key_uuid = 'foo-42' + result = self.test_context._get_server(attr_name) + self.assertIsInstance(result['interfaces'], collections.Mapping) + for key in attr_name.get("interfaces").keys(): + self.assertEqual(result['interfaces'][key]['local_ip'], '10.0.0.1') + self.assertEqual(result['interfaces'][key]['local_mac'], '64:00:6a:18:0f:d6') + self.assertEqual(result['interfaces'][key]['netmask'], '255.255.255.0') + self.assertEqual(result['interfaces'][key]['gateway_ip'], '127.0.0.254') + + # TODO: Split this into more granular tests + def test__get_network(self): + network1 = mock.MagicMock() + network1.name = 'net_1' + network1.vld_id = 'vld111' + network1.segmentation_id = 'seg54' + network1.network_type = 'type_a' + network1.physical_network = 'phys' + + network2 = mock.MagicMock() + network2.name = 'net_2' + network2.segmentation_id = 'seg45' + network2.network_type = 'type_b' + network2.physical_network = 'virt' + + self.test_context.networks = { + 'a': network1, + 'b': network2, + } + + attr_name = None + self.assertIsNone(self.test_context._get_network(attr_name)) + + attr_name = {} + self.assertIsNone(self.test_context._get_network(attr_name)) + + attr_name = {'network_type': 'nosuch'} + self.assertIsNone(self.test_context._get_network(attr_name)) + + attr_name = 'vld777' + self.assertIsNone(self.test_context._get_network(attr_name)) + + attr_name = {'segmentation_id': 'seg45'} + expected = { + "name": 'net_2', + "segmentation_id": 'seg45', + "network_type": 'type_b', + "physical_network": 'virt', + } + result = self.test_context._get_network(attr_name) + self.assertDictEqual(result, expected) + + attr_name = 'a' + expected = { + "name": 'net_1', + "segmentation_id": 'seg54', + "network_type": 'type_a', + "physical_network": 'phys', + } + result = self.test_context._get_network(attr_name) + self.assertDictEqual(result, expected) + + def _get_file_abspath(self, filename): + curr_path = os.path.dirname(os.path.abspath(__file__)) + file_path = os.path.join(curr_path, filename) + return file_path + + def test__get_physical_nodes(self): + self.test_context.nodes = {} + nodes = self.test_context._get_physical_nodes() + self.assertEquals(nodes, {}) + + @mock.patch.object(yaml_loader, 'read_yaml_file') + def test__get_physical_node_for_server(self, mock_read_yaml): + attrs = {'name': 'foo', + 'task_id': '12345678', + 'file': "pod.yaml", + 'servers': {'vnf': {}}, + 'networks': {'mgmt': {'cidr': '10.0.1.0/24'}} + } + + with mock.patch.object(openstack_utils, 'get_shade_client'), \ + mock.patch.object(openstack_utils, 'get_shade_operator_client'): + mock_read_yaml.return_value = self.HEAT_POD_SAMPLE + self.test_context.init(attrs) + + with mock.patch('yardstick.common.openstack_utils.get_server') as mock_get_server: + mock_get_server.return_value = {'vnf': {}} + + # When server is not from this context + result = self.test_context._get_physical_node_for_server('node1.foo-context') + self.assertIsNone(result) + + # When node_name is not from this context + result = self.test_context._get_physical_node_for_server('fake.foo-12345678') + self.assertIsNone(result) + + mock_munch = mock.Mock() + mock_munch.toDict = mock.Mock(return_value={ + 'OS-EXT-SRV-ATTR:hypervisor_hostname': 'hypervisor_hostname' + }) + mock_get_server.return_value = mock_munch + + hypervisor = mock.Mock() + hypervisor.hypervisor_hostname = 'hypervisor_hostname' + hypervisor.host_ip = '10.229.47.137' + + self.test_context.operator_client.list_hypervisors = mock.Mock( + return_value=[hypervisor]) + + mock_get_server.return_value = mock_munch + + result = self.test_context._get_physical_node_for_server('vnf.foo-12345678') + self.assertEqual(result, 'node1.foo') |