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 sriov
  22
  23
  24 class SriovContextTestCase(unittest.TestCase):
  25
  26     NODES_SAMPLE = "nodes_sample.yaml"
  27     NODES_SRIOV_SAMPLE = "nodes_sriov_sample.yaml"
  28     NODES_DUPLICATE_SAMPLE = "nodes_duplicate_sample.yaml"
  29
  30     ATTRS = {
  31         'name': 'StandaloneSriov',
  32         'task_id': '1234567890',
  33         'file': 'pod',
  34         'flavor': {},
  35         'servers': {},
  36         'networks': {},
  37     }
  38
  39     NETWORKS = {
  40         'mgmt': {'cidr': '152.16.100.10/24'},
  41         'private_0': {
  42             'phy_port': "0000:05:00.0",
  43             'vpci': "0000:00:07.0",
  44             'cidr': '152.16.100.10/24',
  45             'interface': 'if0',
  46             'mac': "00:00:00:00:00:01",
  47             'vf_pci': {'vf_pci': 0},
  48             'gateway_ip': '152.16.100.20'},
  49         'public_0': {
  50             'phy_port': "0000:05:00.1",
  51             'vpci': "0000:00:08.0",
  52             'cidr': '152.16.40.10/24',
  53             'interface': 'if0',
  54             'vf_pci': {'vf_pci': 0},
  55             'mac': "00:00:00:00:00:01",
  56             'gateway_ip': '152.16.100.20'},
  57     }
  58
  59     def setUp(self):
  60         self.attrs = {
  61             'name': 'foo',
  62             'task_id': '1234567890',
  63             'file': self._get_file_abspath(self.NODES_SRIOV_SAMPLE)
  64         }
  65         self.sriov = sriov.SriovContext()
  66         self.addCleanup(self._remove_contexts)
  67
  68     def _remove_contexts(self):
  69         if self.sriov in self.sriov.list:
  70             self.sriov._delete_context()
  71
  72     @mock.patch('yardstick.benchmark.contexts.standalone.sriov.Libvirt')
  73     @mock.patch('yardstick.benchmark.contexts.standalone.model.StandaloneContextHelper')
  74     @mock.patch('yardstick.benchmark.contexts.standalone.model.Server')
  75     def test___init__(self, mock_helper, mock_server, *args):
  76         # NOTE(ralonsoh): this test doesn't cover function execution.
  77         self.sriov.helper = mock_helper
  78         self.sriov.vnf_node = mock_server
  79         self.assertIsNone(self.sriov.file_path)
  80         self.assertTrue(self.sriov.first_run)
  81
  82     def test_init(self):
  83         self.sriov.helper.parse_pod_file = mock.Mock(return_value=[{}, {}, {}])
  84         self.assertIsNone(self.sriov.init(self.ATTRS))
  85
  86     @mock.patch.object(ssh, 'SSH', return_value=(0, "a", ""))
  87     def test_deploy(self, *args):
  88         # NOTE(ralonsoh): this test doesn't cover function execution.
  89         self.sriov.vm_deploy = False
  90         self.assertIsNone(self.sriov.deploy())
  91
  92         self.sriov.vm_deploy = True
  93         self.sriov.host_mgmt = {}
  94         self.sriov.install_req_libs = mock.Mock()
  95         self.sriov.get_nic_details = mock.Mock(return_value={})
  96         self.sriov.setup_sriov_context = mock.Mock(return_value={})
  97         self.sriov.wait_for_vnfs_to_start = mock.Mock(return_value={})
  98         self.assertIsNone(self.sriov.deploy())
  99
 100     @mock.patch('yardstick.benchmark.contexts.standalone.sriov.Libvirt')
 101     @mock.patch.object(ssh, 'SSH', return_value=(0, "a", ""))
 102     def test_undeploy(self, mock_ssh, *args):
 103         self.sriov.vm_deploy = False
 104         self.assertIsNone(self.sriov.undeploy())
 105
 106         self.sriov.vm_deploy = True
 107         self.sriov.connection = mock_ssh
 108         self.sriov.vm_names = ['vm_0', 'vm_1']
 109         self.sriov.drivers = ['vm_0', 'vm_1']
 110         self.assertIsNone(self.sriov.undeploy())
 111
 112     def _get_file_abspath(self, filename):
 113         curr_path = os.path.dirname(os.path.abspath(__file__))
 114         file_path = os.path.join(curr_path, filename)
 115         return file_path
 116
 117     def test__get_server_with_dic_attr_name(self):
 118
 119         self.sriov.init(self.attrs)
 120
 121         attr_name = {'name': 'foo.bar'}
 122         result = self.sriov._get_server(attr_name)
 123
 124         self.assertEqual(result, None)
 125
 126     def test__get_server_not_found(self):
 127
 128         self.sriov.helper.parse_pod_file = mock.Mock(return_value=[{}, {}, {}])
 129         self.sriov.init(self.attrs)
 130
 131         attr_name = 'bar.foo'
 132         result = self.sriov._get_server(attr_name)
 133
 134         self.assertEqual(result, None)
 135
 136     def test__get_server_mismatch(self):
 137
 138         self.sriov.init(self.attrs)
 139
 140         attr_name = 'bar.foo1'
 141         result = self.sriov._get_server(attr_name)
 142
 143         self.assertEqual(result, None)
 144
 145     def test__get_server_duplicate(self):
 146
 147         self.attrs['file'] = self._get_file_abspath(self.NODES_DUPLICATE_SAMPLE)
 148
 149         self.sriov.init(self.attrs)
 150
 151         attr_name = 'node1.foo-12345678'
 152         with self.assertRaises(ValueError):
 153             self.sriov._get_server(attr_name)
 154
 155     def test__get_server_found(self):
 156
 157         self.sriov.init(self.attrs)
 158
 159         attr_name = 'node1.foo-12345678'
 160         result = self.sriov._get_server(attr_name)
 161
 162         self.assertEqual(result['ip'], '10.229.47.137')
 163         self.assertEqual(result['name'], 'node1.foo-12345678')
 164         self.assertEqual(result['user'], 'root')
 165         self.assertEqual(result['key_filename'], '/root/.yardstick_key')
 166
 167     def test__get_server_no_task_id(self):
 168         self.attrs['flags'] = {'no_setup': True}
 169         self.sriov.init(self.attrs)
 170
 171         attr_name = 'node1.foo'
 172         result = self.sriov._get_server(attr_name)
 173
 174         self.assertEqual(result['ip'], '10.229.47.137')
 175         self.assertEqual(result['name'], 'node1.foo')
 176         self.assertEqual(result['user'], 'root')
 177         self.assertEqual(result['key_filename'], '/root/.yardstick_key')
 178
 179     # TODO(elfoley): Split this test
 180     # There are at least two sets of inputs/outputs
 181     def test__get_network(self):
 182         network1 = {
 183             'name': 'net_1',
 184             'vld_id': 'vld111',
 185             'segmentation_id': 'seg54',
 186             'network_type': 'type_a',
 187             'physical_network': 'phys',
 188         }
 189         network2 = {
 190             'name': 'net_2',
 191             'vld_id': 'vld999',
 192         }
 193         self.sriov.networks = {
 194             'a': network1,
 195             'b': network2,
 196         }
 197
 198         attr_name = {}
 199         self.assertIsNone(self.sriov._get_network(attr_name))
 200
 201         attr_name = {'vld_id': 'vld777'}
 202         self.assertIsNone(self.sriov._get_network(attr_name))
 203
 204         self.assertIsNone(self.sriov._get_network(None))
 205
 206         attr_name = 'vld777'
 207         self.assertIsNone(self.sriov._get_network(attr_name))
 208
 209         attr_name = {'vld_id': 'vld999'}
 210         expected = {
 211             "name": 'net_2',
 212             "vld_id": 'vld999',
 213             "segmentation_id": None,
 214             "network_type": None,
 215             "physical_network": None,
 216         }
 217         result = self.sriov._get_network(attr_name)
 218         self.assertDictEqual(result, expected)
 219
 220         attr_name = 'a'
 221         expected = network1
 222         result = self.sriov._get_network(attr_name)
 223         self.assertDictEqual(result, expected)
 224
 225     def test_configure_nics_for_sriov(self):
 226         with mock.patch("yardstick.ssh.SSH") as ssh:
 227             ssh_mock = mock.Mock(autospec=ssh.SSH)
 228             ssh_mock.execute = \
 229                 mock.Mock(return_value=(0, "a", ""))
 230             ssh.return_value = ssh_mock
 231         self.sriov.vm_deploy = True
 232         self.sriov.connection = ssh_mock
 233         self.sriov.vm_names = ['vm_0', 'vm_1']
 234         self.sriov.drivers = []
 235         self.sriov.networks = self.NETWORKS
 236         self.sriov.helper.get_mac_address = mock.Mock(return_value="")
 237         self.sriov._get_vf_data = mock.Mock(return_value="")
 238         self.assertIsNone(self.sriov.configure_nics_for_sriov())
 239
 240     @mock.patch('yardstick.benchmark.contexts.standalone.sriov.Libvirt')
 241     @mock.patch.object(ssh, 'SSH')
 242     def test__enable_interfaces(self, mock_ssh, *args):
 243         mock_ssh.return_value = 0, "a", ""
 244
 245         self.sriov.vm_deploy = True
 246         self.sriov.connection = mock_ssh
 247         self.sriov.vm_names = ['vm_0', 'vm_1']
 248         self.sriov.drivers = []
 249         self.sriov.networks = self.NETWORKS
 250         self.sriov.get_vf_data = mock.Mock(return_value="")
 251         self.assertIsNone(self.sriov._enable_interfaces(
 252             0, 0, ["private_0"], 'test'))
 253
 254     @mock.patch('yardstick.benchmark.contexts.standalone.model.Server')
 255     @mock.patch('yardstick.benchmark.contexts.standalone.sriov.Libvirt')
 256     def test_setup_sriov_context(self, mock_libvirt, *args):
 257         with mock.patch("yardstick.ssh.SSH") as ssh:
 258             ssh_mock = mock.Mock(autospec=ssh.SSH)
 259             ssh_mock.execute = \
 260                 mock.Mock(return_value=(0, "a", ""))
 261             ssh_mock.put = \
 262                 mock.Mock(return_value=(0, "a", ""))
 263             ssh.return_value = ssh_mock
 264         self.sriov.vm_deploy = True
 265         self.sriov.connection = ssh_mock
 266         self.sriov.vm_names = ['vm_0', 'vm_1']
 267         self.sriov.drivers = []
 268         self.sriov.servers = {
 269             'vnf_0': {
 270                 'network_ports': {
 271                     'mgmt': {'cidr': '152.16.100.10/24'},
 272                     'xe0': ['private_0'],
 273                     'xe1': ['public_0']
 274                 }
 275             }
 276         }
 277         self.sriov.networks = self.NETWORKS
 278         self.sriov.host_mgmt = {}
 279         self.sriov.flavor = {}
 280         self.sriov.configure_nics_for_sriov = mock.Mock(return_value="")
 281         mock_libvirt.build_vm_xml = mock.Mock(
 282             return_value=[6, "00:00:00:00:00:01"])
 283         self.sriov._enable_interfaces = mock.Mock(return_value="")
 284         self.sriov.vnf_node.generate_vnf_instance = mock.Mock(return_value={})
 285         self.assertIsNotNone(self.sriov.setup_sriov_context())
 286
 287     def test__get_vf_data(self):
 288         with mock.patch("yardstick.ssh.SSH") as ssh:
 289             ssh_mock = mock.Mock(autospec=ssh.SSH)
 290             ssh_mock.execute = \
 291                 mock.Mock(return_value=(0, "a", ""))
 292             ssh_mock.put = \
 293                 mock.Mock(return_value=(0, "a", ""))
 294             ssh.return_value = ssh_mock
 295         self.sriov.vm_deploy = True
 296         self.sriov.connection = ssh_mock
 297         self.sriov.vm_names = ['vm_0', 'vm_1']
 298         self.sriov.drivers = []
 299         self.sriov.servers = {
 300             'vnf_0': {
 301                 'network_ports': {
 302                     'mgmt': {'cidr': '152.16.100.10/24'},
 303                     'xe0': ['private_0'],
 304                     'xe1': ['public_0']
 305                 }
 306             }
 307         }
 308         self.sriov.networks = self.NETWORKS
 309         self.sriov.helper.get_virtual_devices = mock.Mock(
 310             return_value={'0000:00:01.0': ''})
 311         self.assertIsNotNone(self.sriov._get_vf_data(
 312             '0000:00:01.0', '00:00:00:00:00:01', 'if0'))