tests/unit/benchmark/contexts/test_ovsdpdk.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 from __future__ import absolute_import
  16 import os
  17 import mock
  18 import unittest
  19
  20 from yardstick.benchmark.contexts import ovsdpdk
  21
  22 NIC_INPUT = {
  23     'interface': {},
  24     'vports_mac': ['00:00:00:71:7d:25', '00:00:00:71:7d:26'],
  25     'pci': ['0000:06:00.0', '0000:06:00.1'],
  26     'phy_driver': 'i40e'}
  27 DRIVER = "i40e"
  28 NIC_DETAILS = {
  29     'interface': {0: 'enp6s0f0', 1: 'enp6s0f1'},
  30     'vports_mac': ['00:00:00:71:7d:25', '00:00:00:71:7d:26'],
  31     'pci': ['0000:06:00.0', '0000:06:00.1'],
  32     'phy_driver': 'i40e'}
  33
  34 CORRECT_FILE_PATH = "/etc/yardstick/nodes/pod_ovs.yaml"
  35 WRONG_FILE_PATH = "/etc/yardstick/wrong.yaml"
  36 SAMPLE_FILE = "ovs_sample_write_to_file.txt"
  37
  38 OVS = [{
  39     'auth_type': 'ssh_key',
  40     'name': 'ovs',
  41     'ssh_port': 22,
  42     'ip': '10.10.10.11',
  43     'key_filename': '/root/.ssh/id_rsa',
  44     'vports_mac': ['00:00:00:00:00:03', '00:00:00:00:00:04'],
  45     'vpath': '/usr/local/',
  46     'role': 'Ovsdpdk',
  47     'user': 'root',
  48     'images': '/var/lib/libvirt/images/ubuntu1.img',
  49     'flow': ['ovs-ofctl add-flow br0 in_port=1,action=output:3',
  50              'ovs-ofctl add-flow br0 in_port=3,action=output:1',
  51              'ovs-ofctl add-flow br0 in_port=4,action=output:2',
  52              'ovs-ofctl add-flow br0 in_port=2,action=output:4'],
  53     'phy_driver': 'i40e',
  54     'phy_ports': ['0000:06:00.0', '0000:06:00.1']}]
  55
  56 OVS_PASSWORD = [{
  57     'auth_type': 'password',
  58     'name': 'ovs',
  59     'vports_mac': ['00:00:00:00:00:03', '00:00:00:00:00:04'],
  60     'ip': '10.10.10.11',
  61     'role': 'Ovsdpdk',
  62     'user': 'root',
  63     'vpath': '/usr/local/',
  64     'images': '/var/lib/libvirt/images/ubuntu1.img',
  65     'flow': ['ovs-ofctl add-flow br0 in_port=1,action=output:3',
  66              'ovs-ofctl add-flow br0 in_port=3,action=output:1',
  67              'ovs-ofctl add-flow br0 in_port=4,action=output:2',
  68              'ovs-ofctl add-flow br0 in_port=2,action=output:4'],
  69     'phy_driver': 'i40e',
  70     'password': 'password',
  71     'phy_ports': ['0000:06:00.0', '0000:06:00.1']}]
  72
  73 #vfnic = "i40evf"
  74 PCIS = ['0000:06:00.0', '0000:06:00.1']
  75
  76
  77 class OvsdpdkTestCase(unittest.TestCase):
  78
  79     NODES_SAMPLE_SSH = "ovs_sample_ssh_key.yaml"
  80     NODES_SAMPLE_PASSWORD = "ovs_sample_password.yaml"
  81
  82     def setUp(self):
  83         self.test_context = ovsdpdk.Ovsdpdk()
  84
  85     def test_construct(self):
  86         self.assertIsNone(self.test_context.name)
  87         self.assertIsNone(self.test_context.file_path)
  88         self.assertEqual(self.test_context.nodes, [])
  89         self.assertEqual(self.test_context.ovs, [])
  90         self.assertFalse(self.test_context.vm_deploy)
  91         self.assertTrue(self.test_context.first_run)
  92         self.assertEqual(self.test_context.user, "")
  93         self.assertEqual(self.test_context.ssh_ip, "")
  94         self.assertEqual(self.test_context.passwd, "")
  95         self.assertEqual(self.test_context.ssh_port, "")
  96         self.assertEqual(self.test_context.auth_type, "")
  97
  98     def test_init(self):
  99         self.test_context.parse_pod_and_get_data = mock.Mock()
 100         self.test_context.file_path = CORRECT_FILE_PATH
 101         self.test_context.init()
 102         self.assertIsNone(self.test_context.init())
 103
 104     def test_successful_init_with_ssh(self):
 105         CORRECT_FILE_PATH = self._get_file_abspath(self.NODES_SAMPLE_SSH)
 106         self.test_context.parse_pod_and_get_data(CORRECT_FILE_PATH)
 107
 108     def test_successful_init_with_password(self):
 109         CORRECT_FILE_PATH = self._get_file_abspath(self.NODES_SAMPLE_PASSWORD)
 110         self.test_context.parse_pod_and_get_data(CORRECT_FILE_PATH)
 111
 112     def test_unsuccessful_init(self):
 113         self.assertRaises(
 114             IOError,
 115             lambda: self.test_context.parse_pod_and_get_data(WRONG_FILE_PATH))
 116
 117     def test_ssh_connection(self):
 118         with mock.patch("yardstick.ssh.SSH") as ssh:
 119             ssh_mock = mock.Mock(autospec=ssh.SSH)
 120             ssh_mock.execute = \
 121                 mock.Mock(return_value=(0, {}, ""))
 122             ssh.return_value = ssh_mock
 123
 124     @mock.patch('yardstick.network_services.utils.provision_tool', return_value="b")
 125     def test_ssh_connection(self, mock_prov):
 126         with mock.patch("yardstick.ssh.SSH") as ssh:
 127             ssh_mock = mock.Mock(autospec=ssh.SSH)
 128             ssh_mock.execute = \
 129                 mock.Mock(return_value=(1, "b", ""))
 130             ssh.return_value = ssh_mock
 131             mock_prov.provision_tool = mock.Mock()
 132             ovs_obj = ovsdpdk.Ovsdpdk()
 133             ovs_obj.connection = ssh_mock
 134             ovs_obj.ovs = OVS_PASSWORD
 135             self.assertIsNone(ovs_obj.ssh_remote_machine())
 136
 137     @mock.patch('yardstick.network_services.utils.provision_tool', return_value="b")
 138     def test_ssh_connection_ssh_key(self, mock_prov):
 139         with mock.patch("yardstick.ssh.SSH") as ssh:
 140             ssh_mock = mock.Mock(autospec=ssh.SSH)
 141             ssh_mock.execute = \
 142                 mock.Mock(return_value=(1, "b", ""))
 143             ssh.return_value = ssh_mock
 144             mock_prov.provision_tool = mock.Mock()
 145             ovs_obj = ovsdpdk.Ovsdpdk()
 146             ovs_obj.connection = ssh_mock
 147             ovs_obj.ovs = OVS
 148             ovs_obj.key_filename = '/root/.ssh/id_rsa'
 149             self.assertIsNone(ovs_obj.ssh_remote_machine())
 150
 151     def test_get_nic_details(self):
 152         with mock.patch("yardstick.ssh.SSH") as ssh:
 153             ssh_mock = mock.Mock(autospec=ssh.SSH)
 154             ssh_mock.execute = \
 155                 mock.Mock(return_value=(0, "eth0 eth1", ""))
 156             ssh.return_value = ssh_mock
 157             ovs_obj = ovsdpdk.Ovsdpdk()
 158             ovs_obj.ovs = OVS
 159             ovs_obj.connection = ssh_mock
 160             self.assertIsNotNone(ovs_obj.get_nic_details())
 161
 162     def test_install_req_libs(self):
 163         with mock.patch("yardstick.ssh.SSH") as ssh:
 164             ssh_mock = mock.Mock(autospec=ssh.SSH)
 165             ssh_mock.execute = \
 166                 mock.Mock(return_value=(0, {}, ""))
 167             ssh.return_value = ssh_mock
 168             ovs_obj = ovsdpdk.Ovsdpdk()
 169             ovs_obj.first_run = True
 170             ovs_obj.connection = ssh_mock
 171             self.assertIsNone(ovs_obj.install_req_libs())
 172
 173     def test_setup_ovs(self):
 174             with mock.patch("yardstick.ssh.SSH") as ssh:
 175                 ssh_mock = mock.Mock(autospec=ssh.SSH)
 176                 ssh_mock.execute = \
 177                     mock.Mock(return_value=(0, {}, ""))
 178                 ssh.return_value = ssh_mock
 179                 ovs_obj = ovsdpdk.Ovsdpdk()
 180                 ovs_obj.connection = ssh_mock
 181                 ovs_obj.ovs = OVS
 182                 self.assertIsNone(ovs_obj.setup_ovs({"eth0 eth1"}))
 183
 184     def test_start_ovs_serverswitch(self):
 185          with mock.patch("yardstick.ssh.SSH") as ssh:
 186              ssh_mock = mock.Mock(autospec=ssh.SSH)
 187              ssh_mock.execute = \
 188                   mock.Mock(return_value=(0, {}, ""))
 189              ssh.return_value = ssh_mock
 190              ovs_obj = ovsdpdk.Ovsdpdk()
 191              ovs_obj.connection = ssh_mock
 192              ovs_obj.ovs = OVS
 193              self.assertIsNone(ovs_obj.start_ovs_serverswitch())
 194
 195     def test_setup_ovs_bridge(self):
 196           with mock.patch("yardstick.ssh.SSH") as ssh:
 197               ssh_mock = mock.Mock(autospec=ssh.SSH)
 198               ssh_mock.execute = \
 199                    mock.Mock(return_value=(0, {}, ""))
 200               ssh.return_value = ssh_mock
 201               ovs_obj = ovsdpdk.Ovsdpdk()
 202               ovs_obj.connection = ssh_mock
 203               ovs_obj.ovs = OVS
 204               self.assertIsNone(ovs_obj.setup_ovs_bridge())
 205
 206     def test_add_oflows(self):
 207           with mock.patch("yardstick.ssh.SSH") as ssh:
 208               ssh_mock = mock.Mock(autospec=ssh.SSH)
 209               ssh_mock.execute = \
 210                    mock.Mock(return_value=(0, {}, ""))
 211               ssh.return_value = ssh_mock
 212               ovs_obj = ovsdpdk.Ovsdpdk()
 213               ovs_obj.connection = ssh_mock
 214               ovs_obj.ovs = OVS
 215               self.assertIsNone(ovs_obj.add_oflows())
 216
 217     def test_setup_ovs_context_vm_already_present(self):
 218         with mock.patch("yardstick.ssh.SSH") as ssh:
 219             ssh_mock = mock.Mock(autospec=ssh.SSH)
 220             ssh_mock.execute = \
 221                 mock.Mock(return_value=(0, {}, ""))
 222             ssh.return_value = ssh_mock
 223             ovs_obj = ovsdpdk.Ovsdpdk()
 224             ovs_obj.connection = ssh_mock
 225             ovs_obj.ovs = OVS
 226             mock_ovs = mock.Mock()
 227             ssh_mock.put = mock.Mock()
 228             ovs_obj.check_output = mock.Mock(return_value=(0, "vm1"))
 229             with mock.patch("yardstick.benchmark.contexts.ovsdpdk.time"):
 230                 self.assertIsNone(ovs_obj.setup_ovs_context(PCIS, NIC_DETAILS, DRIVER))
 231
 232     @mock.patch(
 233         'yardstick.benchmark.contexts.ovsdpdk',
 234         return_value="Domain vm1 created from /tmp/vm_ovs.xml")
 235     def test_is_vm_created(self, NIC_INPUT):
 236         with mock.patch("yardstick.ssh.SSH") as ssh:
 237             ssh_mock = mock.Mock(autospec=ssh.SSH)
 238             ssh_mock.execute = \
 239                 mock.Mock(return_value=(0, {}, ""))
 240             ssh_mock.put = \
 241             mock.Mock(return_value=(0, {}, ""))
 242             ssh.return_value = ssh_mock
 243             mock_ovs = mock.Mock()
 244             ret_create = mock.Mock()
 245             pcis = NIC_DETAILS['pci']
 246             driver = NIC_DETAILS['phy_driver']
 247             self.assertIsNotNone(
 248             mock_ovs.ovs_obj.setup_ovs_context(
 249                 pcis,
 250                 NIC_DETAILS,
 251                 driver))
 252
 253     def test_check_output(self):
 254         with mock.patch("yardstick.ssh.SSH") as ssh:
 255             cmd = "command"
 256             ssh_mock = mock.Mock(autospec=ssh.SSH)
 257             ssh_mock.execute = \
 258                 mock.Mock(return_value=(0, {}, ""))
 259             ssh.return_value = ssh_mock
 260             ovs_obj = ovsdpdk.Ovsdpdk()
 261             ovs_obj.connection = ssh_mock
 262             self.assertIsNotNone(ovs_obj.check_output(cmd, None))
 263
 264     def test_split_cpu_list_available(self):
 265         with mock.patch("itertools.chain") as iter1:
 266             iter1 = mock.Mock()
 267             print("{0}".format(iter1))
 268             ovs_obj = ovsdpdk.Ovsdpdk()
 269             self.assertIsNotNone(ovs_obj.split_cpu_list('0,5'))
 270
 271     def test_split_cpu_list_null(self):
 272         with mock.patch("itertools.chain") as iter1:
 273             iter1 = mock.Mock()
 274             print("{0}".format(iter1))
 275             ovs_obj = ovsdpdk.Ovsdpdk()
 276             self.assertEqual(ovs_obj.split_cpu_list([]), [])
 277
 278     def test_destroy_vm_successful(self):
 279         with mock.patch("yardstick.ssh.SSH") as ssh:
 280             ssh_mock = mock.Mock(autospec=ssh.SSH)
 281             ssh_mock.execute = \
 282                 mock.Mock(return_value=(0, {}, ""))
 283             ssh.return_value = ssh_mock
 284             ovs_obj = ovsdpdk.Ovsdpdk()
 285             ovs_obj.connection = ssh_mock
 286             ovs_obj.ovs = OVS
 287             ovs_obj.check_output = mock.Mock(return_value=(0, "vm1"))
 288             ssh_mock.execute = \
 289                 mock.Mock(return_value=(0, {}, ""))
 290             ssh_mock.execute = \
 291                 mock.Mock(return_value=(0, {}, ""))
 292             ssh_mock.execute = \
 293                 mock.Mock(return_value=(0, "0 i40e"))
 294             ssh_mock.execute = \
 295                 mock.Mock(return_value=(0, "0 i40e"))
 296             self.assertIsNone(ovs_obj.destroy_vm())
 297
 298     def test_destroy_vm_unsuccessful(self):
 299         with mock.patch("yardstick.ssh.SSH") as ssh:
 300             ssh_mock = mock.Mock(autospec=ssh.SSH)
 301             ssh_mock.execute = \
 302                 mock.Mock(return_value=(0, {}, ""))
 303             ssh.return_value = ssh_mock
 304             ovs_obj = ovsdpdk.Ovsdpdk()
 305             ovs_obj.connection = ssh_mock
 306             ovs_obj.ovs = OVS
 307             ovs_obj.check_output = mock.Mock(return_value=(1, {}))
 308             self.assertIsNone(ovs_obj.destroy_vm())
 309
 310     def test_read_from_file(self):
 311         CORRECT_FILE_PATH = self._get_file_abspath(self.NODES_SAMPLE_PASSWORD)
 312         ovs_obj = ovsdpdk.Ovsdpdk()
 313         self.assertIsNotNone(ovs_obj.read_from_file(CORRECT_FILE_PATH))
 314
 315     def test_write_to_file(self):
 316         ovs_obj = ovsdpdk.Ovsdpdk()
 317         self.assertIsNone(ovs_obj.write_to_file(SAMPLE_FILE, "some content"))
 318
 319     def _get_file_abspath(self, filename):
 320         curr_path = os.path.dirname(os.path.abspath(__file__))
 321         file_path = os.path.join(curr_path, filename)
 322         return file_path
 323
 324 if __name__ == '__main__':
 325     unittest.main()