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         'file': 'pod',
  33         'flavor': {},
  34         'servers': {},
  35         'networks': {},
  36     }
  37
  38     NETWORKS = {
  39         'mgmt': {'cidr': '152.16.100.10/24'},
  40         'private_0': {
  41             'phy_port': "0000:05:00.0",
  42             'vpci': "0000:00:07.0",
  43             'cidr': '152.16.100.10/24',
  44             'interface': 'if0',
  45             'mac': "00:00:00:00:00:01",
  46             'vf_pci': {'vf_pci': 0},
  47             'gateway_ip': '152.16.100.20'},
  48         'public_0': {
  49             'phy_port': "0000:05:00.1",
  50             'vpci': "0000:00:08.0",
  51             'cidr': '152.16.40.10/24',
  52             'interface': 'if0',
  53             'vf_pci': {'vf_pci': 0},
  54             'mac': "00:00:00:00:00:01",
  55             'gateway_ip': '152.16.100.20'},
  56     }
  57
  58     def setUp(self):
  59         self.sriov = sriov.SriovContext()
  60
  61     @mock.patch('yardstick.benchmark.contexts.standalone.sriov.Libvirt')
  62     @mock.patch('yardstick.benchmark.contexts.standalone.model.StandaloneContextHelper')
  63     @mock.patch('yardstick.benchmark.contexts.standalone.model.Server')
  64     def test___init__(self, mock_helper, mock_server, *args):
  65         # NOTE(ralonsoh): this test doesn't cover function execution.
  66         self.sriov.helper = mock_helper
  67         self.sriov.vnf_node = mock_server
  68         self.assertIsNone(self.sriov.file_path)
  69         self.assertTrue(self.sriov.first_run)
  70
  71     def test_init(self):
  72         self.sriov.helper.parse_pod_file = mock.Mock(return_value=[{}, {}, {}])
  73         self.assertIsNone(self.sriov.init(self.ATTRS))
  74
  75     @mock.patch.object(ssh, 'SSH', return_value=(0, "a", ""))
  76     def test_deploy(self, *args):
  77         # NOTE(ralonsoh): this test doesn't cover function execution.
  78         self.sriov.vm_deploy = False
  79         self.assertIsNone(self.sriov.deploy())
  80
  81         self.sriov.vm_deploy = True
  82         self.sriov.host_mgmt = {}
  83         self.sriov.install_req_libs = mock.Mock()
  84         self.sriov.get_nic_details = mock.Mock(return_value={})
  85         self.sriov.setup_sriov_context = mock.Mock(return_value={})
  86         self.sriov.wait_for_vnfs_to_start = mock.Mock(return_value={})
  87         self.assertIsNone(self.sriov.deploy())
  88
  89     @mock.patch('yardstick.benchmark.contexts.standalone.sriov.Libvirt')
  90     @mock.patch.object(ssh, 'SSH', return_value=(0, "a", ""))
  91     def test_undeploy(self, mock_ssh, *args):
  92         self.sriov.vm_deploy = False
  93         self.assertIsNone(self.sriov.undeploy())
  94
  95         self.sriov.vm_deploy = True
  96         self.sriov.connection = mock_ssh
  97         self.sriov.vm_names = ['vm_0', 'vm_1']
  98         self.sriov.drivers = ['vm_0', 'vm_1']
  99         self.assertIsNone(self.sriov.undeploy())
 100
 101     def _get_file_abspath(self, filename):
 102         curr_path = os.path.dirname(os.path.abspath(__file__))
 103         file_path = os.path.join(curr_path, filename)
 104         return file_path
 105
 106     def test__get_server_with_dic_attr_name(self):
 107
 108         attrs = {
 109             'name': 'foo',
 110             'file': self._get_file_abspath(self.NODES_SRIOV_SAMPLE)
 111         }
 112
 113         self.sriov.init(attrs)
 114
 115         attr_name = {'name': 'foo.bar'}
 116         result = self.sriov._get_server(attr_name)
 117
 118         self.assertEqual(result, None)
 119
 120     def test__get_server_not_found(self):
 121
 122         attrs = {
 123             'name': 'foo',
 124             'file': self._get_file_abspath(self.NODES_SRIOV_SAMPLE)
 125         }
 126
 127         self.sriov.helper.parse_pod_file = mock.Mock(return_value=[{}, {}, {}])
 128         self.sriov.init(attrs)
 129
 130         attr_name = 'bar.foo'
 131         result = self.sriov._get_server(attr_name)
 132
 133         self.assertEqual(result, None)
 134
 135     def test__get_server_mismatch(self):
 136
 137         attrs = {
 138             'name': 'foo',
 139             'file': self._get_file_abspath(self.NODES_SRIOV_SAMPLE)
 140         }
 141
 142         self.sriov.init(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         attrs = {
 152             'name': 'foo',
 153             'file': self._get_file_abspath(self.NODES_DUPLICATE_SAMPLE)
 154         }
 155
 156         self.sriov.init(attrs)
 157
 158         attr_name = 'node1.foo'
 159         with self.assertRaises(ValueError):
 160             self.sriov._get_server(attr_name)
 161
 162     def test__get_server_found(self):
 163
 164         attrs = {
 165             'name': 'foo',
 166             'file': self._get_file_abspath(self.NODES_SRIOV_SAMPLE)
 167         }
 168
 169         self.sriov.init(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'))