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