yardstick/tests/unit/benchmark/contexts/standalone/test_sriov.py

   1 # Copyright (c) 2016-2017 Intel Corporation
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #      http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import os
  16
  17 import mock
  18 import unittest
  19
  20 from yardstick import ssh
  21 from yardstick.benchmark.contexts.standalone import model
  22 from yardstick.benchmark.contexts.standalone import sriov
  23
  24
  25 class SriovContextTestCase(unittest.TestCase):
  26
  27     NODES_SAMPLE = "nodes_sample.yaml"
  28     NODES_SRIOV_SAMPLE = "nodes_sriov_sample.yaml"
  29     NODES_DUPLICATE_SAMPLE = "nodes_duplicate_sample.yaml"
  30
  31     ATTRS = {
  32         'name': 'StandaloneSriov',
  33         'task_id': '1234567890',
  34         'file': 'pod',
  35         'flavor': {},
  36         'servers': {},
  37         'networks': {},
  38     }
  39
  40     NETWORKS = {
  41         'mgmt': {'cidr': '152.16.100.10/24'},
  42         'private_0': {
  43             'phy_port': "0000:05:00.0",
  44             'vpci': "0000:00:07.0",
  45             'cidr': '152.16.100.10/24',
  46             'interface': 'if0',
  47             'mac': "00:00:00:00:00:01",
  48             'vf_pci': {'vf_pci': 0},
  49             'gateway_ip': '152.16.100.20'},
  50         'public_0': {
  51             'phy_port': "0000:05:00.1",
  52             'vpci': "0000:00:08.0",
  53             'cidr': '152.16.40.10/24',
  54             'interface': 'if0',
  55             'vf_pci': {'vf_pci': 0},
  56             'mac': "00:00:00:00:00:01",
  57             'gateway_ip': '152.16.100.20'},
  58     }
  59
  60     def setUp(self):
  61         self.attrs = {
  62             'name': 'foo',
  63             'task_id': '1234567890',
  64             'file': self._get_file_abspath(self.NODES_SRIOV_SAMPLE)
  65         }
  66         self.sriov = sriov.SriovContext()
  67         self.addCleanup(self._remove_contexts)
  68
  69     def _remove_contexts(self):
  70         if self.sriov in self.sriov.list:
  71             self.sriov._delete_context()
  72
  73     @mock.patch.object(model, 'StandaloneContextHelper')
  74     @mock.patch.object(model, 'Libvirt')
  75     @mock.patch.object(model, 'Server')
  76     def test___init__(self, mock_helper, mock_libvirt, mock_server):
  77         # pylint: disable=unused-argument
  78         # NOTE(ralonsoh): this test doesn't cover function execution.
  79         self.sriov.helper = mock_helper
  80         self.sriov.vnf_node = mock_server
  81         self.assertIsNone(self.sriov.file_path)
  82         self.assertTrue(self.sriov.first_run)
  83
  84     def test_init(self):
  85         self.sriov.helper.parse_pod_file = mock.Mock(return_value=[{}, {}, {}])
  86         self.assertIsNone(self.sriov.init(self.ATTRS))
  87
  88     @mock.patch.object(ssh, 'SSH', return_value=(0, "a", ""))
  89     def test_deploy(self, *args):
  90         # NOTE(ralonsoh): this test doesn't cover function execution.
  91         self.sriov.vm_deploy = False
  92         self.assertIsNone(self.sriov.deploy())
  93
  94         self.sriov.vm_deploy = True
  95         self.sriov.host_mgmt = {}
  96         self.sriov.install_req_libs = mock.Mock()
  97         self.sriov.get_nic_details = mock.Mock(return_value={})
  98         self.sriov.setup_sriov_context = mock.Mock(return_value={})
  99         self.sriov.wait_for_vnfs_to_start = mock.Mock(return_value={})
 100         self.assertIsNone(self.sriov.deploy())
 101
 102     @mock.patch.object(ssh, 'SSH', return_value=(0, "a", ""))
 103     @mock.patch.object(model, 'Libvirt')
 104     def test_undeploy(self, mock_libvirt, mock_ssh):
 105         # pylint: disable=unused-argument
 106         # NOTE(ralonsoh): the pylint exception should be removed.
 107         self.sriov.vm_deploy = False
 108         self.assertIsNone(self.sriov.undeploy())
 109
 110         self.sriov.vm_deploy = True
 111         self.sriov.connection = mock_ssh
 112         self.sriov.vm_names = ['vm_0', 'vm_1']
 113         self.sriov.drivers = ['vm_0', 'vm_1']
 114         self.assertIsNone(self.sriov.undeploy())
 115
 116     def _get_file_abspath(self, filename):
 117         curr_path = os.path.dirname(os.path.abspath(__file__))
 118         file_path = os.path.join(curr_path, filename)
 119         return file_path
 120
 121     def test__get_server_with_dic_attr_name(self):
 122
 123         self.sriov.init(self.attrs)
 124
 125         attr_name = {'name': 'foo.bar'}
 126         result = self.sriov._get_server(attr_name)
 127
 128         self.assertEqual(result, None)
 129
 130     def test__get_server_not_found(self):
 131
 132         self.sriov.helper.parse_pod_file = mock.Mock(return_value=[{}, {}, {}])
 133         self.sriov.init(self.attrs)
 134
 135         attr_name = 'bar.foo'
 136         result = self.sriov._get_server(attr_name)
 137
 138         self.assertEqual(result, None)
 139
 140     def test__get_server_mismatch(self):
 141
 142         self.sriov.init(self.attrs)
 143
 144         attr_name = 'bar.foo1'
 145         result = self.sriov._get_server(attr_name)
 146
 147         self.assertEqual(result, None)
 148
 149     def test__get_server_duplicate(self):
 150
 151         self.attrs['file'] = self._get_file_abspath(self.NODES_DUPLICATE_SAMPLE)
 152
 153         self.sriov.init(self.attrs)
 154
 155         attr_name = 'node1.foo-12345678'
 156         with self.assertRaises(ValueError):
 157             self.sriov._get_server(attr_name)
 158
 159     def test__get_server_found(self):
 160
 161         self.sriov.init(self.attrs)
 162
 163         attr_name = 'node1.foo-12345678'
 164         result = self.sriov._get_server(attr_name)
 165
 166         self.assertEqual(result['ip'], '10.229.47.137')
 167         self.assertEqual(result['name'], 'node1.foo-12345678')
 168         self.assertEqual(result['user'], 'root')
 169         self.assertEqual(result['key_filename'], '/root/.yardstick_key')
 170
 171     def test__get_server_no_task_id(self):
 172         self.attrs['flags'] = {'no_setup': True}
 173         self.sriov.init(self.attrs)
 174
 175         attr_name = 'node1.foo'
 176         result = self.sriov._get_server(attr_name)
 177
 178         self.assertEqual(result['ip'], '10.229.47.137')
 179         self.assertEqual(result['name'], 'node1.foo')
 180         self.assertEqual(result['user'], 'root')
 181         self.assertEqual(result['key_filename'], '/root/.yardstick_key')
 182
 183     # TODO(elfoley): Split this test
 184     # There are at least two sets of inputs/outputs
 185     def test__get_network(self):
 186         network1 = {
 187             'name': 'net_1',
 188             'vld_id': 'vld111',
 189             'segmentation_id': 'seg54',
 190             'network_type': 'type_a',
 191             'physical_network': 'phys',
 192         }
 193         network2 = {
 194             'name': 'net_2',
 195             'vld_id': 'vld999',
 196         }
 197         self.sriov.networks = {
 198             'a': network1,
 199             'b': network2,
 200         }
 201
 202         attr_name = {}
 203         self.assertIsNone(self.sriov._get_network(attr_name))
 204
 205         attr_name = {'vld_id': 'vld777'}
 206         self.assertIsNone(self.sriov._get_network(attr_name))
 207
 208         self.assertIsNone(self.sriov._get_network(None))
 209
 210         attr_name = 'vld777'
 211         self.assertIsNone(self.sriov._get_network(attr_name))
 212
 213         attr_name = {'vld_id': 'vld999'}
 214         expected = {
 215             "name": 'net_2',
 216             "vld_id": 'vld999',
 217             "segmentation_id": None,
 218             "network_type": None,
 219             "physical_network": None,
 220         }
 221         result = self.sriov._get_network(attr_name)
 222         self.assertDictEqual(result, expected)
 223
 224         attr_name = 'a'
 225         expected = network1
 226         result = self.sriov._get_network(attr_name)
 227         self.assertDictEqual(result, expected)
 228
 229     def test_configure_nics_for_sriov(self):
 230         with mock.patch("yardstick.ssh.SSH") as ssh:
 231             ssh_mock = mock.Mock(autospec=ssh.SSH)
 232             ssh_mock.execute = \
 233                 mock.Mock(return_value=(0, "a", ""))
 234             ssh.return_value = ssh_mock
 235         self.sriov.vm_deploy = True
 236         self.sriov.connection = ssh_mock
 237         self.sriov.vm_names = ['vm_0', 'vm_1']
 238         self.sriov.drivers = []
 239         self.sriov.networks = self.NETWORKS
 240         self.sriov.helper.get_mac_address = mock.Mock(return_value="")
 241         self.sriov._get_vf_data = mock.Mock(return_value="")
 242         self.assertIsNone(self.sriov.configure_nics_for_sriov())
 243
 244     @mock.patch.object(ssh, 'SSH', return_value=(0, "a", ""))
 245     @mock.patch.object(model.Libvirt, 'add_sriov_interfaces',
 246                        return_value='out_xml')
 247     def test__enable_interfaces(self, mock_add_sriov, mock_ssh):
 248         self.sriov.vm_deploy = True
 249         self.sriov.connection = mock_ssh
 250         self.sriov.vm_names = ['vm_0', 'vm_1']
 251         self.sriov.drivers = []
 252         self.sriov.networks = self.NETWORKS
 253         self.assertEqual(
 254             'out_xml',
 255             self.sriov._enable_interfaces(0, 0, ['private_0'], 'test'))
 256         mock_add_sriov.assert_called_once_with(
 257             '0000:00:0a.0', 0, self.NETWORKS['private_0']['mac'], 'test')
 258
 259     @mock.patch.object(model.Libvirt, 'build_vm_xml')
 260     @mock.patch.object(model.Libvirt, 'check_if_vm_exists_and_delete')
 261     @mock.patch.object(model.Libvirt, 'write_file')
 262     @mock.patch.object(model.Libvirt, 'virsh_create_vm')
 263     def test_setup_sriov_context(self, mock_create_vm, mock_write_file,
 264                                  mock_check, mock_build_vm_xml):
 265         self.sriov.servers = {
 266             'vnf_0': {
 267                 'network_ports': {
 268                     'mgmt': {'cidr': '152.16.100.10/24'},
 269                     'xe0': ['private_0'],
 270                     'xe1': ['public_0']
 271                 }
 272             }
 273         }
 274         connection = mock.Mock()
 275         self.sriov.connection = connection
 276         self.sriov.host_mgmt = {'ip': '1.2.3.4'}
 277         self.sriov.vm_flavor = 'flavor'
 278         self.sriov.networks = 'networks'
 279         self.sriov.configure_nics_for_sriov = mock.Mock()
 280         cfg = '/tmp/vm_sriov_0.xml'
 281         vm_name = 'vm_0'
 282         xml_out = mock.Mock()
 283         mock_build_vm_xml.return_value = (xml_out, '00:00:00:00:00:01')
 284
 285         with mock.patch.object(self.sriov, 'vnf_node') as mock_vnf_node, \
 286                 mock.patch.object(self.sriov, '_enable_interfaces') as \
 287                 mock_enable_interfaces:
 288             mock_enable_interfaces.return_value = 'out_xml'
 289             mock_vnf_node.generate_vnf_instance = mock.Mock(
 290                 return_value='node')
 291             nodes_out = self.sriov.setup_sriov_context()
 292         self.assertEqual(['node'], nodes_out)
 293         mock_vnf_node.generate_vnf_instance.assert_called_once_with(
 294             'flavor', 'networks', '1.2.3.4', 'vnf_0',
 295             self.sriov.servers['vnf_0'], '00:00:00:00:00:01')
 296         mock_build_vm_xml.assert_called_once_with(
 297             connection, 'flavor', vm_name, 0)
 298         mock_create_vm.assert_called_once_with(connection, cfg)
 299         mock_check.assert_called_once_with(vm_name, connection)
 300         mock_write_file.assert_called_once_with(cfg, 'out_xml')
 301         mock_enable_interfaces.assert_has_calls([
 302             mock.call(0, mock.ANY, ['private_0'], mock.ANY),
 303             mock.call(0, mock.ANY, ['public_0'], mock.ANY)], any_order=True)
 304
 305     def test__get_vf_data(self):
 306         with mock.patch("yardstick.ssh.SSH") as ssh:
 307             ssh_mock = mock.Mock(autospec=ssh.SSH)
 308             ssh_mock.execute = \
 309                 mock.Mock(return_value=(0, "a", ""))
 310             ssh_mock.put = \
 311                 mock.Mock(return_value=(0, "a", ""))
 312             ssh.return_value = ssh_mock
 313         self.sriov.vm_deploy = True
 314         self.sriov.connection = ssh_mock
 315         self.sriov.vm_names = ['vm_0', 'vm_1']
 316         self.sriov.drivers = []
 317         self.sriov.servers = {
 318             'vnf_0': {
 319                 'network_ports': {
 320                     'mgmt': {'cidr': '152.16.100.10/24'},
 321                     'xe0': ['private_0'],
 322                     'xe1': ['public_0']
 323                 }
 324             }
 325         }
 326         self.sriov.networks = self.NETWORKS
 327         self.sriov.helper.get_virtual_devices = mock.Mock(
 328             return_value={'0000:00:01.0': ''})
 329         self.assertIsNotNone(self.sriov._get_vf_data(
 330             '0000:00:01.0', '00:00:00:00:00:01', 'if0'))