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')
 246     def test__enable_interfaces(self, mock_libvirt, mock_ssh):
 247         # pylint: disable=unused-argument
 248         # NOTE(ralonsoh): the pylint exception should be removed.
 249         self.sriov.vm_deploy = True
 250         self.sriov.connection = mock_ssh
 251         self.sriov.vm_names = ['vm_0', 'vm_1']
 252         self.sriov.drivers = []
 253         self.sriov.networks = self.NETWORKS
 254         self.sriov.get_vf_data = mock.Mock(return_value="")
 255         self.assertIsNone(self.sriov._enable_interfaces(
 256             0, 0, ["private_0"], 'test'))
 257
 258     @mock.patch.object(model.Libvirt, 'build_vm_xml')
 259     @mock.patch.object(model.Libvirt, 'check_if_vm_exists_and_delete')
 260     @mock.patch.object(model.Libvirt, 'write_file')
 261     @mock.patch.object(model.Libvirt, 'virsh_create_vm')
 262     def test_setup_sriov_context(self, mock_create_vm, mock_write_file,
 263                                  mock_check, mock_build_vm_xml):
 264         self.sriov.servers = {
 265             'vnf_0': {
 266                 'network_ports': {
 267                     'mgmt': {'cidr': '152.16.100.10/24'},
 268                     'xe0': ['private_0'],
 269                     'xe1': ['public_0']
 270                 }
 271             }
 272         }
 273         connection = mock.Mock()
 274         self.sriov.connection = connection
 275         self.sriov.host_mgmt = {'ip': '1.2.3.4'}
 276         self.sriov.vm_flavor = 'flavor'
 277         self.sriov.networks = 'networks'
 278         self.sriov.configure_nics_for_sriov = mock.Mock()
 279         cfg = '/tmp/vm_sriov_0.xml'
 280         vm_name = 'vm_0'
 281         xml_out = mock.Mock()
 282         mock_build_vm_xml.return_value = (xml_out, '00:00:00:00:00:01')
 283
 284         with mock.patch.object(self.sriov, 'vnf_node') as mock_vnf_node, \
 285                 mock.patch.object(self.sriov, '_enable_interfaces'):
 286             mock_vnf_node.generate_vnf_instance = mock.Mock(
 287                 return_value='node')
 288             nodes_out = self.sriov.setup_sriov_context()
 289         self.assertEqual(['node'], nodes_out)
 290         mock_vnf_node.generate_vnf_instance.assert_called_once_with(
 291             'flavor', 'networks', '1.2.3.4', 'vnf_0',
 292             self.sriov.servers['vnf_0'], '00:00:00:00:00:01')
 293         mock_build_vm_xml.assert_called_once_with(
 294             connection, 'flavor', vm_name, 0)
 295         mock_create_vm.assert_called_once_with(connection, cfg)
 296         mock_check.assert_called_once_with(vm_name, connection)
 297         mock_write_file.assert_called_once_with(cfg, xml_out)
 298
 299     def test__get_vf_data(self):
 300         with mock.patch("yardstick.ssh.SSH") as ssh:
 301             ssh_mock = mock.Mock(autospec=ssh.SSH)
 302             ssh_mock.execute = \
 303                 mock.Mock(return_value=(0, "a", ""))
 304             ssh_mock.put = \
 305                 mock.Mock(return_value=(0, "a", ""))
 306             ssh.return_value = ssh_mock
 307         self.sriov.vm_deploy = True
 308         self.sriov.connection = ssh_mock
 309         self.sriov.vm_names = ['vm_0', 'vm_1']
 310         self.sriov.drivers = []
 311         self.sriov.servers = {
 312             'vnf_0': {
 313                 'network_ports': {
 314                     'mgmt': {'cidr': '152.16.100.10/24'},
 315                     'xe0': ['private_0'],
 316                     'xe1': ['public_0']
 317                 }
 318             }
 319         }
 320         self.sriov.networks = self.NETWORKS
 321         self.sriov.helper.get_virtual_devices = mock.Mock(
 322             return_value={'0000:00:01.0': ''})
 323         self.assertIsNotNone(self.sriov._get_vf_data(
 324             '0000:00:01.0', '00:00:00:00:00:01', 'if0'))