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