yardstick/tests/unit/benchmark/contexts/standalone/test_model.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 copy
  16 import os
  17 import uuid
  18
  19 import mock
  20 import netaddr
  21 import unittest
  22 from xml.etree import ElementTree
  23
  24 from yardstick import ssh
  25 from yardstick.benchmark.contexts.standalone import model
  26 from yardstick.common import exceptions
  27 from yardstick import constants
  28 from yardstick.network_services import utils
  29
  30
  31 XML_SAMPLE = """<?xml version="1.0"?>
  32 <domain type="kvm">
  33     <devices>
  34     </devices>
  35 </domain>
  36 """
  37
  38 XML_SAMPLE_INTERFACE = """<?xml version="1.0"?>
  39 <domain type="kvm">
  40     <devices>
  41         <interface>
  42         </interface>
  43     </devices>
  44 </domain>
  45 """
  46
  47
  48 class ModelLibvirtTestCase(unittest.TestCase):
  49
  50     XML_STR = model.VM_TEMPLATE.format(
  51         vm_name="vm_name",
  52         random_uuid=uuid.uuid4(),
  53         mac_addr="00:01:02:03:04:05",
  54         memory=2048, vcpu=2, cpu=2,
  55         numa_cpus=0 - 10,
  56         socket=1, threads=1,
  57         vm_image="/var/lib/libvirt/images/yardstick-nsb-image.img",
  58         cpuset=2 - 10, cputune='', machine='pc')
  59
  60     def setUp(self):
  61         self.pci_address_str = '0001:04:03.2'
  62         self.pci_address = utils.PciAddress(self.pci_address_str)
  63         self.mac = '00:00:00:00:00:01'
  64         self._mock_ssh = mock.Mock()
  65         self.mock_ssh = self._mock_ssh.start()
  66         self.addCleanup(self._cleanup)
  67
  68     def _cleanup(self):
  69         self._mock_ssh.stop()
  70
  71     # TODO: Remove mocking of yardstick.ssh.SSH (here and elsewhere)
  72     # In this case, we are mocking a param to be passed into other methods
  73     # It can be a generic Mock() with return values set for the right methods
  74     def test_check_if_vm_exists_and_delete(self):
  75         with mock.patch("yardstick.ssh.SSH") as ssh:
  76             ssh_mock = mock.Mock(autospec=ssh.SSH)
  77             ssh_mock.execute = mock.Mock(return_value=(0, "a", ""))
  78             ssh.return_value = ssh_mock
  79         # NOTE(ralonsoh): this test doesn't cover function execution.
  80         model.Libvirt.check_if_vm_exists_and_delete('vm-0', ssh_mock)
  81
  82     def test_virsh_create_vm(self):
  83         self.mock_ssh.execute = mock.Mock(return_value=(0, 0, 0))
  84         model.Libvirt.virsh_create_vm(self.mock_ssh, 'vm-0')
  85         self.mock_ssh.execute.assert_called_once_with('virsh create vm-0')
  86
  87     def test_virsh_create_vm_error(self):
  88         self.mock_ssh.execute = mock.Mock(return_value=(1, 0, 'error_create'))
  89         with self.assertRaises(exceptions.LibvirtCreateError) as exc:
  90             model.Libvirt.virsh_create_vm(self.mock_ssh, 'vm-0')
  91         self.assertEqual('Error creating the virtual machine. Error: '
  92                          'error_create.', str(exc.exception))
  93         self.mock_ssh.execute.assert_called_once_with('virsh create vm-0')
  94
  95     def test_virsh_destroy_vm(self):
  96         self.mock_ssh.execute = mock.Mock(return_value=(0, 0, 0))
  97         model.Libvirt.virsh_destroy_vm('vm-0', self.mock_ssh)
  98         self.mock_ssh.execute.assert_called_once_with('virsh destroy vm-0')
  99
 100     @mock.patch.object(model, 'LOG')
 101     def test_virsh_destroy_vm_error(self, mock_logger):
 102         self.mock_ssh.execute = mock.Mock(return_value=(1, 0, 'error_destroy'))
 103         mock_logger.warning = mock.Mock()
 104         model.Libvirt.virsh_destroy_vm('vm-0', self.mock_ssh)
 105         mock_logger.warning.assert_called_once_with(
 106             'Error destroying VM %s. Error: %s', 'vm-0', 'error_destroy')
 107         self.mock_ssh.execute.assert_called_once_with('virsh destroy vm-0')
 108
 109     def test_add_interface_address(self):
 110         xml = ElementTree.ElementTree(
 111             element=ElementTree.fromstring(XML_SAMPLE_INTERFACE))
 112         interface = xml.find('devices').find('interface')
 113         result = model.Libvirt._add_interface_address(interface, self.pci_address)
 114         self.assertEqual('pci', result.get('type'))
 115         self.assertEqual('0x{}'.format(self.pci_address.domain),
 116                          result.get('domain'))
 117         self.assertEqual('0x{}'.format(self.pci_address.bus),
 118                          result.get('bus'))
 119         self.assertEqual('0x{}'.format(self.pci_address.slot),
 120                          result.get('slot'))
 121         self.assertEqual('0x{}'.format(self.pci_address.function),
 122                          result.get('function'))
 123
 124     def test_add_ovs_interfaces(self):
 125         xml_input = copy.deepcopy(XML_SAMPLE)
 126         xml_output = model.Libvirt.add_ovs_interface(
 127             '/usr/local', 0, self.pci_address_str, self.mac, xml_input, 4)
 128
 129         root = ElementTree.fromstring(xml_output)
 130         et_out = ElementTree.ElementTree(element=root)
 131         interface = et_out.find('devices').find('interface')
 132         self.assertEqual('vhostuser', interface.get('type'))
 133         mac = interface.find('mac')
 134         self.assertEqual(self.mac, mac.get('address'))
 135         source = interface.find('source')
 136         self.assertEqual('unix', source.get('type'))
 137         self.assertEqual('/usr/local/var/run/openvswitch/dpdkvhostuser0',
 138                          source.get('path'))
 139         self.assertEqual('client', source.get('mode'))
 140         _model = interface.find('model')
 141         self.assertEqual('virtio', _model.get('type'))
 142         driver = interface.find('driver')
 143         self.assertEqual('4', driver.get('queues'))
 144         host = driver.find('host')
 145         self.assertEqual('off', host.get('mrg_rxbuf'))
 146         self.assertIsNotNone(interface.find('address'))
 147
 148     def test_add_sriov_interfaces(self):
 149         xml_input = copy.deepcopy(XML_SAMPLE)
 150         vm_pci = '0001:05:04.2'
 151         xml_output = model.Libvirt.add_sriov_interfaces(
 152             vm_pci, self.pci_address_str, self.mac, xml_input)
 153         root = ElementTree.fromstring(xml_output)
 154         et_out = ElementTree.ElementTree(element=root)
 155         interface = et_out.find('devices').find('interface')
 156         self.assertEqual('yes', interface.get('managed'))
 157         self.assertEqual('hostdev', interface.get('type'))
 158         mac = interface.find('mac')
 159         self.assertEqual(self.mac, mac.get('address'))
 160         source = interface.find('source')
 161         source_address = source.find('address')
 162         self.assertIsNotNone(source.find('address'))
 163
 164         self.assertEqual('pci', source_address.get('type'))
 165         self.assertEqual('0x' + self.pci_address_str.split(':')[0],
 166                          source_address.get('domain'))
 167         self.assertEqual('0x' + self.pci_address_str.split(':')[1],
 168                          source_address.get('bus'))
 169         self.assertEqual('0x' + self.pci_address_str.split(':')[2].split('.')[0],
 170                          source_address.get('slot'))
 171         self.assertEqual('0x' + self.pci_address_str.split(':')[2].split('.')[1],
 172                          source_address.get('function'))
 173
 174         interface_address = interface.find('address')
 175         self.assertEqual('pci', interface_address.get('type'))
 176         self.assertEqual('0x' + vm_pci.split(':')[0],
 177                          interface_address.get('domain'))
 178         self.assertEqual('0x' + vm_pci.split(':')[1],
 179                          interface_address.get('bus'))
 180         self.assertEqual('0x' + vm_pci.split(':')[2].split('.')[0],
 181                          interface_address.get('slot'))
 182         self.assertEqual('0x' + vm_pci.split(':')[2].split('.')[1],
 183                          interface_address.get('function'))
 184
 185     def test_add_cdrom(self):
 186         xml_input = copy.deepcopy(XML_SAMPLE)
 187         xml_output = model.Libvirt.add_cdrom('/var/lib/libvirt/images/data.img', xml_input)
 188
 189         root = ElementTree.fromstring(xml_output)
 190         et_out = ElementTree.ElementTree(element=root)
 191         disk = et_out.find('devices').find('disk')
 192         self.assertEqual('file', disk.get('type'))
 193         self.assertEqual('cdrom', disk.get('device'))
 194         driver = disk.find('driver')
 195         self.assertEqual('qemu', driver.get('name'))
 196         self.assertEqual('raw', driver.get('type'))
 197         source = disk.find('source')
 198         self.assertEqual('/var/lib/libvirt/images/data.img', source.get('file'))
 199         target = disk.find('target')
 200         self.assertEqual('hdb', target.get('dev'))
 201         self.assertIsNotNone(disk.find('readonly'))
 202
 203     def test_gen_cdrom_image(self):
 204         self.mock_ssh.execute = mock.Mock(return_value=(0, 0, 0))
 205         root = ElementTree.fromstring(self.XML_STR)
 206         hostname = root.find('name').text
 207         meta_data = "/tmp/meta-data"
 208         user_data = "/tmp/user-data"
 209         network_data = "/tmp/network-config"
 210         file_path = "/tmp/cdrom-0.img"
 211         key_filename = "id_rsa"
 212         pub_key_str = "KEY"
 213         user = 'root'
 214         mac = "00:11:22:33:44:55"
 215         ip = "1.1.1.7/24"
 216         user_config = ["    - name: {user_name}",
 217                        "      ssh_authorized_keys:",
 218                        "        - {pub_key_str}"]
 219
 220         user_conf = os.linesep.join(user_config).format(pub_key_str=pub_key_str, user_name=user)
 221         with mock.patch('six.moves.builtins.open', mock.mock_open(read_data=pub_key_str),
 222                         create=True) as mock_file:
 223             with open(key_filename, "r") as h:
 224                 result = h.read()
 225             model.Libvirt.gen_cdrom_image(self.mock_ssh, file_path, hostname, user, key_filename,
 226                                           mac, ip)
 227             mock_file.assert_called_with(".".join([key_filename, "pub"]), "r")
 228         self.assertEqual(result, pub_key_str)
 229
 230         self.mock_ssh.execute.assert_has_calls([
 231             mock.call("touch %s" % meta_data),
 232             mock.call(model.USER_DATA_TEMPLATE.format(user_file=user_data, host=hostname,
 233                                                       user_config=user_conf)),
 234             mock.call(model.NETWORK_DATA_TEMPLATE.format(network_file=network_data,
 235                                                          mac_address=mac, ip_address=ip)),
 236             mock.call("genisoimage -output {0} -volid cidata"
 237                       " -joliet -r {1} {2} {3}".format(file_path, meta_data, user_data,
 238                                                        network_data)),
 239             mock.call("rm {0} {1} {2}".format(meta_data, user_data, network_data))
 240         ])
 241
 242     def test_create_snapshot_qemu(self):
 243         self.mock_ssh.execute = mock.Mock(return_value=(0, 0, 0))
 244         index = 1
 245         vm_image = '/var/lib/libvirt/images/%s.qcow2' % index
 246         base_image = '/tmp/base_image'
 247
 248         model.Libvirt.create_snapshot_qemu(self.mock_ssh, index, base_image)
 249         self.mock_ssh.execute.assert_has_calls([
 250             mock.call('rm -- "%s"' % vm_image),
 251             mock.call('test -r %s' % base_image),
 252             mock.call('qemu-img create -f qcow2 -o backing_file=%s %s' %
 253                       (base_image, vm_image))
 254         ])
 255
 256     @mock.patch.object(os.path, 'basename', return_value='base_image')
 257     @mock.patch.object(os.path, 'normpath')
 258     @mock.patch.object(os, 'access', return_value=True)
 259     def test_create_snapshot_qemu_no_image_remote(self,
 260             mock_os_access, mock_normpath, mock_basename):
 261         self.mock_ssh.execute = mock.Mock(
 262             side_effect=[(0, 0, 0), (1, 0, 0), (0, 0, 0), (0, 0, 0)])
 263         index = 1
 264         vm_image = '/var/lib/libvirt/images/%s.qcow2' % index
 265         base_image = '/tmp/base_image'
 266         mock_normpath.return_value = base_image
 267
 268         model.Libvirt.create_snapshot_qemu(self.mock_ssh, index, base_image)
 269         self.mock_ssh.execute.assert_has_calls([
 270             mock.call('rm -- "%s"' % vm_image),
 271             mock.call('test -r %s' % base_image),
 272             mock.call('mv -- "/tmp/%s" "%s"' % ('base_image', base_image)),
 273             mock.call('qemu-img create -f qcow2 -o backing_file=%s %s' %
 274                       (base_image, vm_image))
 275         ])
 276         mock_os_access.assert_called_once_with(base_image, os.R_OK)
 277         mock_normpath.assert_called_once_with(base_image)
 278         mock_basename.assert_has_calls([mock.call(base_image)])
 279         self.mock_ssh.put_file.assert_called_once_with(base_image,
 280                                                        '/tmp/base_image')
 281
 282     @mock.patch.object(model.Libvirt, 'gen_cdrom_image')
 283     def test_check_update_key(self, mock_gen_cdrom_image):
 284         node = {
 285             'user': 'defuser',
 286             'key_filename': '/home/ubuntu/id_rsa',
 287             'ip': '1.1.1.7',
 288             'netmask': '255.255.255.0'}
 289         cdrom_img = "/var/lib/libvirt/images/data.img"
 290         id_name = 'fake_name'
 291         key_filename = node.get('key_filename')
 292         root = ElementTree.fromstring(self.XML_STR)
 293         hostname = root.find('name').text
 294         mac = "00:11:22:33:44:55"
 295         ip = "{0}/{1}".format(node.get('ip'), node.get('netmask'))
 296         ip = "{0}/{1}".format(node.get('ip'), netaddr.IPNetwork(ip).prefixlen)
 297         model.StandaloneContextHelper.check_update_key(self.mock_ssh, node, hostname, id_name,
 298                                                        cdrom_img, mac)
 299         mock_gen_cdrom_image.assert_called_once_with(self.mock_ssh, cdrom_img, hostname,
 300                                                      node.get('user'), key_filename, mac, ip)
 301
 302     @mock.patch.object(os, 'access', return_value=False)
 303     def test_create_snapshot_qemu_no_image_local(self, mock_os_access):
 304         self.mock_ssh.execute = mock.Mock(side_effect=[(0, 0, 0), (1, 0, 0)])
 305         base_image = '/tmp/base_image'
 306
 307         with self.assertRaises(exceptions.LibvirtQemuImageBaseImageNotPresent):
 308             model.Libvirt.create_snapshot_qemu(self.mock_ssh, 3, base_image)
 309         mock_os_access.assert_called_once_with(base_image, os.R_OK)
 310
 311     def test_create_snapshot_qemu_error_qemuimg_command(self):
 312         self.mock_ssh.execute = mock.Mock(
 313             side_effect=[(0, 0, 0), (0, 0, 0), (1, 0, 0)])
 314         index = 1
 315         vm_image = '/var/lib/libvirt/images/%s.qcow2' % index
 316         base_image = '/tmp/base_image'
 317
 318         with self.assertRaises(exceptions.LibvirtQemuImageCreateError):
 319             model.Libvirt.create_snapshot_qemu(self.mock_ssh, index,
 320                                                base_image)
 321         self.mock_ssh.execute.assert_has_calls([
 322             mock.call('rm -- "%s"' % vm_image),
 323             mock.call('test -r %s' % base_image),
 324             mock.call('qemu-img create -f qcow2 -o backing_file=%s %s' %
 325                       (base_image, vm_image))
 326         ])
 327
 328     @mock.patch.object(model.Libvirt, 'pin_vcpu_for_perf', return_value='4,5')
 329     @mock.patch.object(model.Libvirt, 'create_snapshot_qemu',
 330                        return_value='qemu_image')
 331     def test_build_vm_xml(self, mock_create_snapshot_qemu,
 332                           mock_pin_vcpu_for_perf):
 333         extra_specs = {'hw:cpu_cores': '4',
 334                        'hw:cpu_sockets': '3',
 335                        'hw:cpu_threads': '2',
 336                        'cputune': 'cool'}
 337         flavor = {'ram': '1024',
 338                   'extra_specs': extra_specs,
 339                   'hw_socket': '1',
 340                   'images': 'images'}
 341         mac = model.StandaloneContextHelper.get_mac_address(0x00)
 342         _uuid = uuid.uuid4()
 343         connection = mock.Mock()
 344         cdrom_img = '/tmp/cdrom-0.img'
 345         with mock.patch.object(model.StandaloneContextHelper,
 346                                'get_mac_address', return_value=mac) as \
 347                 mock_get_mac_address, \
 348                 mock.patch.object(uuid, 'uuid4', return_value=_uuid):
 349             xml_out, mac = model.Libvirt.build_vm_xml(
 350                 connection, flavor, 'vm_name', 100, cdrom_img)
 351
 352         xml_ref = model.VM_TEMPLATE.format(vm_name='vm_name',
 353             random_uuid=_uuid, mac_addr=mac, memory='1024', vcpu='8', cpu='4',
 354             numa_cpus='0-7', socket='3', threads='2',
 355             vm_image='qemu_image', cpuset='4,5', cputune='cool',
 356             machine='pc-i440fx-xenial')
 357         xml_ref = model.Libvirt.add_cdrom(cdrom_img, xml_ref)
 358         self.assertEqual(xml_out, xml_ref)
 359         mock_get_mac_address.assert_called_once_with(0x00)
 360         mock_create_snapshot_qemu.assert_called_once_with(
 361             connection, 100, 'images')
 362         mock_pin_vcpu_for_perf.assert_called_once_with(connection, '1')
 363
 364     # TODO: Edit this test to test state instead of output
 365     # update_interrupts_hugepages_perf does not return anything
 366     def test_update_interrupts_hugepages_perf(self):
 367         with mock.patch("yardstick.ssh.SSH") as ssh:
 368             ssh_mock = mock.Mock(autospec=ssh.SSH)
 369             ssh_mock.execute = \
 370                 mock.Mock(return_value=(0, "a", ""))
 371             ssh.return_value = ssh_mock
 372         # NOTE(ralonsoh): 'update_interrupts_hugepages_perf' always return
 373         # None, this check is trivial.
 374         #status = Libvirt.update_interrupts_hugepages_perf(ssh_mock)
 375         #self.assertIsNone(status)
 376         model.Libvirt.update_interrupts_hugepages_perf(ssh_mock)
 377
 378     @mock.patch.object(model, 'CpuSysCores')
 379     @mock.patch.object(model.Libvirt, 'update_interrupts_hugepages_perf')
 380     def test_pin_vcpu_for_perf(self, *args):
 381         # NOTE(ralonsoh): test mocked methods/variables.
 382         with mock.patch("yardstick.ssh.SSH") as ssh:
 383             ssh_mock = mock.Mock(autospec=ssh.SSH)
 384             ssh_mock.execute = \
 385                 mock.Mock(return_value=(0, "a", ""))
 386             ssh.return_value = ssh_mock
 387         status = model.Libvirt.pin_vcpu_for_perf(ssh_mock, 4)
 388         self.assertIsNotNone(status)
 389
 390
 391 class StandaloneContextHelperTestCase(unittest.TestCase):
 392
 393     NODE_SAMPLE = "nodes_sample.yaml"
 394     NODE_SRIOV_SAMPLE = "nodes_sriov_sample.yaml"
 395
 396     NETWORKS = {
 397         'mgmt': {'cidr': '152.16.100.10/24'},
 398         'private_0': {
 399             'phy_port': "0000:05:00.0",
 400             'vpci': "0000:00:07.0",
 401             'cidr': '152.16.100.10/24',
 402             'gateway_ip': '152.16.100.20'},
 403         'public_0': {
 404             'phy_port': "0000:05:00.1",
 405             'vpci': "0000:00:08.0",
 406             'cidr': '152.16.40.10/24',
 407             'gateway_ip': '152.16.100.20'}
 408     }
 409
 410     def setUp(self):
 411         self.helper = model.StandaloneContextHelper()
 412
 413     def test___init__(self):
 414         self.assertIsNone(self.helper.file_path)
 415
 416     def test_install_req_libs(self):
 417         with mock.patch("yardstick.ssh.SSH") as ssh:
 418             ssh_mock = mock.Mock(autospec=ssh.SSH)
 419             ssh_mock.execute = \
 420                 mock.Mock(return_value=(1, "a", ""))
 421             ssh.return_value = ssh_mock
 422         # NOTE(ralonsoh): this test doesn't cover function execution. This test
 423         # should also check mocked function calls.
 424         model.StandaloneContextHelper.install_req_libs(ssh_mock)
 425
 426     def test_get_kernel_module(self):
 427         with mock.patch("yardstick.ssh.SSH") as ssh:
 428             ssh_mock = mock.Mock(autospec=ssh.SSH)
 429             ssh_mock.execute = \
 430                 mock.Mock(return_value=(1, "i40e", ""))
 431             ssh.return_value = ssh_mock
 432         # NOTE(ralonsoh): this test doesn't cover function execution. This test
 433         # should also check mocked function calls.
 434         model.StandaloneContextHelper.get_kernel_module(
 435             ssh_mock, "05:00.0", None)
 436
 437     @mock.patch.object(model.StandaloneContextHelper, 'get_kernel_module')
 438     def test_get_nic_details(self, mock_get_kernel_module):
 439         with mock.patch("yardstick.ssh.SSH") as ssh:
 440             ssh_mock = mock.Mock(autospec=ssh.SSH)
 441             ssh_mock.execute = mock.Mock(return_value=(1, "i40e ixgbe", ""))
 442             ssh.return_value = ssh_mock
 443         mock_get_kernel_module.return_value = "i40e"
 444         # NOTE(ralonsoh): this test doesn't cover function execution. This test
 445         # should also check mocked function calls.
 446         model.StandaloneContextHelper.get_nic_details(
 447             ssh_mock, self.NETWORKS, 'dpdk-devbind.py')
 448
 449     def test_get_virtual_devices(self):
 450         pattern = "PCI_SLOT_NAME=0000:05:00.0"
 451         with mock.patch("yardstick.ssh.SSH") as ssh:
 452             ssh_mock = mock.Mock(autospec=ssh.SSH)
 453             ssh_mock.execute = \
 454                 mock.Mock(return_value=(1, pattern, ""))
 455             ssh.return_value = ssh_mock
 456         # NOTE(ralonsoh): this test doesn't cover function execution. This test
 457         # should also check mocked function calls.
 458         model.StandaloneContextHelper.get_virtual_devices(
 459             ssh_mock, '0000:00:05.0')
 460
 461     def _get_file_abspath(self, filename):
 462         curr_path = os.path.dirname(os.path.abspath(__file__))
 463         file_path = os.path.join(curr_path, filename)
 464         return file_path
 465
 466     def test_parse_pod_file(self):
 467         self.helper.file_path = self._get_file_abspath("dummy")
 468         self.assertRaises(IOError, self.helper.parse_pod_file,
 469                           self.helper.file_path)
 470
 471         self.helper.file_path = self._get_file_abspath(self.NODE_SAMPLE)
 472         self.assertRaises(TypeError, self.helper.parse_pod_file,
 473                           self.helper.file_path)
 474
 475         self.helper.file_path = self._get_file_abspath(self.NODE_SRIOV_SAMPLE)
 476         self.assertIsNotNone(self.helper.parse_pod_file(self.helper.file_path))
 477
 478     def test_get_mac_address(self):
 479         status = model.StandaloneContextHelper.get_mac_address()
 480         self.assertIsNotNone(status)
 481
 482     @mock.patch('yardstick.ssh.SSH')
 483     def test_get_mgmt_ip(self, *args):
 484         # NOTE(ralonsoh): test mocked methods/variables.
 485         with mock.patch("yardstick.ssh.SSH") as ssh:
 486             ssh_mock = mock.Mock(autospec=ssh.SSH)
 487             ssh_mock.execute = mock.Mock(
 488                 return_value=(1, "1.2.3.4 00:00:00:00:00:01", ""))
 489             ssh.return_value = ssh_mock
 490         # NOTE(ralonsoh): this test doesn't cover function execution. This test
 491         # should also check mocked function calls.
 492         status = model.StandaloneContextHelper.get_mgmt_ip(
 493             ssh_mock, "00:00:00:00:00:01", "1.1.1.1/24", {})
 494         self.assertIsNotNone(status)
 495
 496     @mock.patch('yardstick.ssh.SSH')
 497     def test_get_mgmt_ip_no(self, *args):
 498         # NOTE(ralonsoh): test mocked methods/variables.
 499         with mock.patch("yardstick.ssh.SSH") as ssh:
 500             ssh_mock = mock.Mock(autospec=ssh.SSH)
 501             ssh_mock.execute = \
 502                 mock.Mock(return_value=(1, "", ""))
 503             ssh.return_value = ssh_mock
 504         # NOTE(ralonsoh): this test doesn't cover function execution. This test
 505         # should also check mocked function calls.
 506         model.WAIT_FOR_BOOT = 0
 507         status = model.StandaloneContextHelper.get_mgmt_ip(
 508             ssh_mock, "99", "1.1.1.1/24", {})
 509         self.assertIsNone(status)
 510
 511
 512 class ServerTestCase(unittest.TestCase):
 513
 514     NETWORKS = {
 515         'mgmt': {'cidr': '152.16.100.10/24'},
 516         'private_0': {
 517             'phy_port': "0000:05:00.0",
 518             'vpci': "0000:00:07.0",
 519             'driver': 'i40e',
 520             'mac': '',
 521             'cidr': '152.16.100.10/24',
 522             'gateway_ip': '152.16.100.20'},
 523         'public_0': {
 524             'phy_port': "0000:05:00.1",
 525             'vpci': "0000:00:08.0",
 526             'driver': 'i40e',
 527             'mac': '',
 528             'cidr': '152.16.40.10/24',
 529             'gateway_ip': '152.16.100.20'}
 530     }
 531
 532     def setUp(self):
 533         self.server = model.Server()
 534
 535     def test___init__(self):
 536         self.assertIsNotNone(self.server)
 537
 538     def test_build_vnf_interfaces(self):
 539         vnf = {
 540             "network_ports": {
 541                 'mgmt': {'cidr': '152.16.100.10/24'},
 542                 'xe0': ['private_0'],
 543                 'xe1': ['public_0'],
 544             }
 545         }
 546         status = model.Server.build_vnf_interfaces(vnf, self.NETWORKS)
 547         self.assertIsNotNone(status)
 548
 549     def test_generate_vnf_instance(self):
 550         vnf = {
 551             "network_ports": {
 552                 'mgmt': {'cidr': '152.16.100.10/24'},
 553                 'xe0': ['private_0'],
 554                 'xe1': ['public_0'],
 555             }
 556         }
 557         status = self.server.generate_vnf_instance(
 558             {}, self.NETWORKS, '1.1.1.1/24', 'vm-0', vnf, '00:00:00:00:00:01')
 559         self.assertIsNotNone(status)
 560
 561
 562 class OvsDeployTestCase(unittest.TestCase):
 563
 564     OVS_DETAILS = {'version': {'ovs': 'ovs_version', 'dpdk': 'dpdk_version'}}
 565
 566     def setUp(self):
 567         self._mock_ssh = mock.patch.object(ssh, 'SSH')
 568         self.mock_ssh = self._mock_ssh.start()
 569         self.ovs_deploy = model.OvsDeploy(self.mock_ssh,
 570                                           '/tmp/dpdk-devbind.py',
 571                                           self.OVS_DETAILS)
 572         self._mock_path_isfile = mock.patch.object(os.path, 'isfile')
 573         self._mock_path_join = mock.patch.object(os.path, 'join')
 574         self.mock_path_isfile = self._mock_path_isfile.start()
 575         self.mock_path_join = self._mock_path_join.start()
 576
 577         self.addCleanup(self._stop_mock)
 578
 579     def _stop_mock(self):
 580         self._mock_ssh.stop()
 581         self._mock_path_isfile.stop()
 582         self._mock_path_join.stop()
 583
 584     @mock.patch.object(model.StandaloneContextHelper, 'install_req_libs')
 585     def test_prerequisite(self, mock_install_req_libs):
 586         pkgs = ["git", "build-essential", "pkg-config", "automake",
 587                 "autotools-dev", "libltdl-dev", "cmake", "libnuma-dev",
 588                 "libpcap-dev"]
 589         self.ovs_deploy.prerequisite()
 590         mock_install_req_libs.assert_called_once_with(
 591             self.ovs_deploy.connection, pkgs)
 592
 593     def test_ovs_deploy_no_file(self):
 594         self.mock_path_isfile.return_value = False
 595         mock_file = mock.Mock()
 596         self.mock_path_join.return_value = mock_file
 597
 598         self.ovs_deploy.ovs_deploy()
 599         self.mock_path_isfile.assert_called_once_with(mock_file)
 600         self.mock_path_join.assert_called_once_with(
 601             constants.YARDSTICK_ROOT_PATH,
 602             'yardstick/resources/scripts/install/',
 603             self.ovs_deploy.OVS_DEPLOY_SCRIPT)
 604
 605     @mock.patch.object(os.environ, 'get', return_value='test_proxy')
 606     def test_ovs_deploy(self, mock_env_get):
 607         self.mock_path_isfile.return_value = True
 608         mock_deploy_file = mock.Mock()
 609         mock_remove_ovs_deploy = mock.Mock()
 610         self.mock_path_join.side_effect = [mock_deploy_file,
 611                                            mock_remove_ovs_deploy]
 612         dpdk_version = self.OVS_DETAILS['version']['dpdk']
 613         ovs_version = self.OVS_DETAILS['version']['ovs']
 614
 615         with mock.patch.object(self.ovs_deploy.connection, 'put') as \
 616                 mock_put, \
 617                 mock.patch.object(self.ovs_deploy.connection, 'execute') as \
 618                 mock_execute, \
 619                 mock.patch.object(self.ovs_deploy, 'prerequisite'):
 620             mock_execute.return_value = (0, 0, 0)
 621             self.ovs_deploy.ovs_deploy()
 622
 623             self.mock_path_isfile.assert_called_once_with(mock_deploy_file)
 624             self.mock_path_join.assert_has_calls([
 625                 mock.call(constants.YARDSTICK_ROOT_PATH,
 626                           'yardstick/resources/scripts/install/',
 627                           self.ovs_deploy.OVS_DEPLOY_SCRIPT),
 628                 mock.call(self.ovs_deploy.bin_path,
 629                           self.ovs_deploy.OVS_DEPLOY_SCRIPT)
 630             ])
 631             mock_put.assert_called_once_with(mock_deploy_file,
 632                                              mock_remove_ovs_deploy)
 633             cmd = ("sudo -E %(remote_ovs_deploy)s --ovs='%(ovs_version)s' "
 634                    "--dpdk='%(dpdk_version)s' -p='%(proxy)s'" %
 635                    {'remote_ovs_deploy': mock_remove_ovs_deploy,
 636                     'ovs_version': ovs_version,
 637                     'dpdk_version': dpdk_version,
 638                     'proxy': 'test_proxy'})
 639             mock_execute.assert_called_once_with(cmd)
 640             mock_env_get.assert_has_calls([mock.call('http_proxy', '')])