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='')
  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         xml_ref = model.Libvirt.add_cdrom(cdrom_img, xml_ref)
 357         self.assertEqual(xml_out, xml_ref)
 358         mock_get_mac_address.assert_called_once_with(0x00)
 359         mock_create_snapshot_qemu.assert_called_once_with(
 360             connection, 100, 'images')
 361         mock_pin_vcpu_for_perf.assert_called_once_with(connection, '1')
 362
 363     # TODO: Edit this test to test state instead of output
 364     # update_interrupts_hugepages_perf does not return anything
 365     def test_update_interrupts_hugepages_perf(self):
 366         with mock.patch("yardstick.ssh.SSH") as ssh:
 367             ssh_mock = mock.Mock(autospec=ssh.SSH)
 368             ssh_mock.execute = \
 369                 mock.Mock(return_value=(0, "a", ""))
 370             ssh.return_value = ssh_mock
 371         # NOTE(ralonsoh): 'update_interrupts_hugepages_perf' always return
 372         # None, this check is trivial.
 373         #status = Libvirt.update_interrupts_hugepages_perf(ssh_mock)
 374         #self.assertIsNone(status)
 375         model.Libvirt.update_interrupts_hugepages_perf(ssh_mock)
 376
 377     @mock.patch.object(model, 'CpuSysCores')
 378     @mock.patch.object(model.Libvirt, 'update_interrupts_hugepages_perf')
 379     def test_pin_vcpu_for_perf(self, *args):
 380         # NOTE(ralonsoh): test mocked methods/variables.
 381         with mock.patch("yardstick.ssh.SSH") as ssh:
 382             ssh_mock = mock.Mock(autospec=ssh.SSH)
 383             ssh_mock.execute = \
 384                 mock.Mock(return_value=(0, "a", ""))
 385             ssh.return_value = ssh_mock
 386         status = model.Libvirt.pin_vcpu_for_perf(ssh_mock, 4)
 387         self.assertIsNotNone(status)
 388
 389
 390 class StandaloneContextHelperTestCase(unittest.TestCase):
 391
 392     NODE_SAMPLE = "nodes_sample.yaml"
 393     NODE_SRIOV_SAMPLE = "nodes_sriov_sample.yaml"
 394
 395     NETWORKS = {
 396         'mgmt': {'cidr': '152.16.100.10/24'},
 397         'private_0': {
 398             'phy_port': "0000:05:00.0",
 399             'vpci': "0000:00:07.0",
 400             'cidr': '152.16.100.10/24',
 401             'gateway_ip': '152.16.100.20'},
 402         'public_0': {
 403             'phy_port': "0000:05:00.1",
 404             'vpci': "0000:00:08.0",
 405             'cidr': '152.16.40.10/24',
 406             'gateway_ip': '152.16.100.20'}
 407     }
 408
 409     def setUp(self):
 410         self.helper = model.StandaloneContextHelper()
 411
 412     def test___init__(self):
 413         self.assertIsNone(self.helper.file_path)
 414
 415     def test_install_req_libs(self):
 416         with mock.patch("yardstick.ssh.SSH") as ssh:
 417             ssh_mock = mock.Mock(autospec=ssh.SSH)
 418             ssh_mock.execute = \
 419                 mock.Mock(return_value=(1, "a", ""))
 420             ssh.return_value = ssh_mock
 421         # NOTE(ralonsoh): this test doesn't cover function execution. This test
 422         # should also check mocked function calls.
 423         model.StandaloneContextHelper.install_req_libs(ssh_mock)
 424
 425     def test_get_kernel_module(self):
 426         with mock.patch("yardstick.ssh.SSH") as ssh:
 427             ssh_mock = mock.Mock(autospec=ssh.SSH)
 428             ssh_mock.execute = \
 429                 mock.Mock(return_value=(1, "i40e", ""))
 430             ssh.return_value = ssh_mock
 431         # NOTE(ralonsoh): this test doesn't cover function execution. This test
 432         # should also check mocked function calls.
 433         model.StandaloneContextHelper.get_kernel_module(
 434             ssh_mock, "05:00.0", None)
 435
 436     @mock.patch.object(model.StandaloneContextHelper, 'get_kernel_module')
 437     def test_get_nic_details(self, mock_get_kernel_module):
 438         with mock.patch("yardstick.ssh.SSH") as ssh:
 439             ssh_mock = mock.Mock(autospec=ssh.SSH)
 440             ssh_mock.execute = mock.Mock(return_value=(1, "i40e ixgbe", ""))
 441             ssh.return_value = ssh_mock
 442         mock_get_kernel_module.return_value = "i40e"
 443         # NOTE(ralonsoh): this test doesn't cover function execution. This test
 444         # should also check mocked function calls.
 445         model.StandaloneContextHelper.get_nic_details(
 446             ssh_mock, self.NETWORKS, 'dpdk-devbind.py')
 447
 448     def test_get_virtual_devices(self):
 449         pattern = "PCI_SLOT_NAME=0000:05:00.0"
 450         with mock.patch("yardstick.ssh.SSH") as ssh:
 451             ssh_mock = mock.Mock(autospec=ssh.SSH)
 452             ssh_mock.execute = \
 453                 mock.Mock(return_value=(1, pattern, ""))
 454             ssh.return_value = ssh_mock
 455         # NOTE(ralonsoh): this test doesn't cover function execution. This test
 456         # should also check mocked function calls.
 457         model.StandaloneContextHelper.get_virtual_devices(
 458             ssh_mock, '0000:00:05.0')
 459
 460     def _get_file_abspath(self, filename):
 461         curr_path = os.path.dirname(os.path.abspath(__file__))
 462         file_path = os.path.join(curr_path, filename)
 463         return file_path
 464
 465     def test_parse_pod_file(self):
 466         self.helper.file_path = self._get_file_abspath("dummy")
 467         self.assertRaises(IOError, self.helper.parse_pod_file,
 468                           self.helper.file_path)
 469
 470         self.helper.file_path = self._get_file_abspath(self.NODE_SAMPLE)
 471         self.assertRaises(TypeError, self.helper.parse_pod_file,
 472                           self.helper.file_path)
 473
 474         self.helper.file_path = self._get_file_abspath(self.NODE_SRIOV_SAMPLE)
 475         self.assertIsNotNone(self.helper.parse_pod_file(self.helper.file_path))
 476
 477     def test_get_mac_address(self):
 478         status = model.StandaloneContextHelper.get_mac_address()
 479         self.assertIsNotNone(status)
 480
 481     @mock.patch('yardstick.ssh.SSH')
 482     def test_get_mgmt_ip(self, *args):
 483         # NOTE(ralonsoh): test mocked methods/variables.
 484         with mock.patch("yardstick.ssh.SSH") as ssh:
 485             ssh_mock = mock.Mock(autospec=ssh.SSH)
 486             ssh_mock.execute = mock.Mock(
 487                 return_value=(1, "1.2.3.4 00:00:00:00:00:01", ""))
 488             ssh.return_value = ssh_mock
 489         # NOTE(ralonsoh): this test doesn't cover function execution. This test
 490         # should also check mocked function calls.
 491         status = model.StandaloneContextHelper.get_mgmt_ip(
 492             ssh_mock, "00:00:00:00:00:01", "1.1.1.1/24", {})
 493         self.assertIsNotNone(status)
 494
 495     @mock.patch('yardstick.ssh.SSH')
 496     def test_get_mgmt_ip_no(self, *args):
 497         # NOTE(ralonsoh): test mocked methods/variables.
 498         with mock.patch("yardstick.ssh.SSH") as ssh:
 499             ssh_mock = mock.Mock(autospec=ssh.SSH)
 500             ssh_mock.execute = \
 501                 mock.Mock(return_value=(1, "", ""))
 502             ssh.return_value = ssh_mock
 503         # NOTE(ralonsoh): this test doesn't cover function execution. This test
 504         # should also check mocked function calls.
 505         model.WAIT_FOR_BOOT = 0
 506         status = model.StandaloneContextHelper.get_mgmt_ip(
 507             ssh_mock, "99", "1.1.1.1/24", {})
 508         self.assertIsNone(status)
 509
 510
 511 class ServerTestCase(unittest.TestCase):
 512
 513     NETWORKS = {
 514         'mgmt': {'cidr': '152.16.100.10/24'},
 515         'private_0': {
 516             'phy_port': "0000:05:00.0",
 517             'vpci': "0000:00:07.0",
 518             'driver': 'i40e',
 519             'mac': '',
 520             'cidr': '152.16.100.10/24',
 521             'gateway_ip': '152.16.100.20'},
 522         'public_0': {
 523             'phy_port': "0000:05:00.1",
 524             'vpci': "0000:00:08.0",
 525             'driver': 'i40e',
 526             'mac': '',
 527             'cidr': '152.16.40.10/24',
 528             'gateway_ip': '152.16.100.20'}
 529     }
 530
 531     def setUp(self):
 532         self.server = model.Server()
 533
 534     def test___init__(self):
 535         self.assertIsNotNone(self.server)
 536
 537     def test_build_vnf_interfaces(self):
 538         vnf = {
 539             "network_ports": {
 540                 'mgmt': {'cidr': '152.16.100.10/24'},
 541                 'xe0': ['private_0'],
 542                 'xe1': ['public_0'],
 543             }
 544         }
 545         status = model.Server.build_vnf_interfaces(vnf, self.NETWORKS)
 546         self.assertIsNotNone(status)
 547
 548     def test_generate_vnf_instance(self):
 549         vnf = {
 550             "network_ports": {
 551                 'mgmt': {'cidr': '152.16.100.10/24'},
 552                 'xe0': ['private_0'],
 553                 'xe1': ['public_0'],
 554             }
 555         }
 556         status = self.server.generate_vnf_instance(
 557             {}, self.NETWORKS, '1.1.1.1/24', 'vm-0', vnf, '00:00:00:00:00:01')
 558         self.assertIsNotNone(status)
 559
 560
 561 class OvsDeployTestCase(unittest.TestCase):
 562
 563     OVS_DETAILS = {'version': {'ovs': 'ovs_version', 'dpdk': 'dpdk_version'}}
 564
 565     def setUp(self):
 566         self._mock_ssh = mock.patch.object(ssh, 'SSH')
 567         self.mock_ssh = self._mock_ssh.start()
 568         self.ovs_deploy = model.OvsDeploy(self.mock_ssh,
 569                                           '/tmp/dpdk-devbind.py',
 570                                           self.OVS_DETAILS)
 571         self._mock_path_isfile = mock.patch.object(os.path, 'isfile')
 572         self._mock_path_join = mock.patch.object(os.path, 'join')
 573         self.mock_path_isfile = self._mock_path_isfile.start()
 574         self.mock_path_join = self._mock_path_join.start()
 575
 576         self.addCleanup(self._stop_mock)
 577
 578     def _stop_mock(self):
 579         self._mock_ssh.stop()
 580         self._mock_path_isfile.stop()
 581         self._mock_path_join.stop()
 582
 583     @mock.patch.object(model.StandaloneContextHelper, 'install_req_libs')
 584     def test_prerequisite(self, mock_install_req_libs):
 585         pkgs = ["git", "build-essential", "pkg-config", "automake",
 586                 "autotools-dev", "libltdl-dev", "cmake", "libnuma-dev",
 587                 "libpcap-dev"]
 588         self.ovs_deploy.prerequisite()
 589         mock_install_req_libs.assert_called_once_with(
 590             self.ovs_deploy.connection, pkgs)
 591
 592     def test_ovs_deploy_no_file(self):
 593         self.mock_path_isfile.return_value = False
 594         mock_file = mock.Mock()
 595         self.mock_path_join.return_value = mock_file
 596
 597         self.ovs_deploy.ovs_deploy()
 598         self.mock_path_isfile.assert_called_once_with(mock_file)
 599         self.mock_path_join.assert_called_once_with(
 600             constants.YARDSTICK_ROOT_PATH,
 601             'yardstick/resources/scripts/install/',
 602             self.ovs_deploy.OVS_DEPLOY_SCRIPT)
 603
 604     @mock.patch.object(os.environ, 'get', return_value='test_proxy')
 605     def test_ovs_deploy(self, mock_env_get):
 606         self.mock_path_isfile.return_value = True
 607         mock_deploy_file = mock.Mock()
 608         mock_remove_ovs_deploy = mock.Mock()
 609         self.mock_path_join.side_effect = [mock_deploy_file,
 610                                            mock_remove_ovs_deploy]
 611         dpdk_version = self.OVS_DETAILS['version']['dpdk']
 612         ovs_version = self.OVS_DETAILS['version']['ovs']
 613
 614         with mock.patch.object(self.ovs_deploy.connection, 'put') as \
 615                 mock_put, \
 616                 mock.patch.object(self.ovs_deploy.connection, 'execute') as \
 617                 mock_execute, \
 618                 mock.patch.object(self.ovs_deploy, 'prerequisite'):
 619             mock_execute.return_value = (0, 0, 0)
 620             self.ovs_deploy.ovs_deploy()
 621
 622             self.mock_path_isfile.assert_called_once_with(mock_deploy_file)
 623             self.mock_path_join.assert_has_calls([
 624                 mock.call(constants.YARDSTICK_ROOT_PATH,
 625                           'yardstick/resources/scripts/install/',
 626                           self.ovs_deploy.OVS_DEPLOY_SCRIPT),
 627                 mock.call(self.ovs_deploy.bin_path,
 628                           self.ovs_deploy.OVS_DEPLOY_SCRIPT)
 629             ])
 630             mock_put.assert_called_once_with(mock_deploy_file,
 631                                              mock_remove_ovs_deploy)
 632             cmd = ("sudo -E %(remote_ovs_deploy)s --ovs='%(ovs_version)s' "
 633                    "--dpdk='%(dpdk_version)s' -p='%(proxy)s'" %
 634                    {'remote_ovs_deploy': mock_remove_ovs_deploy,
 635                     'ovs_version': ovs_version,
 636                     'dpdk_version': dpdk_version,
 637                     'proxy': 'test_proxy'})
 638             mock_execute.assert_called_once_with(cmd)
 639             mock_env_get.assert_has_calls([mock.call('http_proxy', '')])