1 # Copyright (c) 2016-2017 Intel Corporation
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
7 # http://www.apache.org/licenses/LICENSE-2.0
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.
22 from xml.etree import ElementTree
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
31 XML_SAMPLE = """<?xml version="1.0"?>
38 XML_SAMPLE_INTERFACE = """<?xml version="1.0"?>
48 class ModelLibvirtTestCase(unittest.TestCase):
50 XML_STR = model.VM_TEMPLATE.format(
52 random_uuid=uuid.uuid4(),
53 mac_addr="00:01:02:03:04:05",
54 memory=2048, vcpu=2, cpu=2,
57 vm_image="/var/lib/libvirt/images/yardstick-nsb-image.img",
58 cpuset=2 - 10, cputune='')
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)
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)
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')
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')
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')
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')
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),
119 self.assertEqual('0x{}'.format(self.pci_address.slot),
121 self.assertEqual('0x{}'.format(self.pci_address.function),
122 result.get('function'))
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)
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',
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'))
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'))
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'))
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'))
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)
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'))
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"
214 mac = "00:11:22:33:44:55"
216 user_config = [" - name: {user_name}",
217 " ssh_authorized_keys:",
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:
225 model.Libvirt.gen_cdrom_image(self.mock_ssh, file_path, hostname, user, key_filename,
227 mock_file.assert_called_with(".".join([key_filename, "pub"]), "r")
228 self.assertEqual(result, pub_key_str)
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,
239 mock.call("rm {0} {1} {2}".format(meta_data, user_data, network_data))
242 def test_create_snapshot_qemu(self):
243 self.mock_ssh.execute = mock.Mock(return_value=(0, 0, 0))
245 vm_image = '/var/lib/libvirt/images/%s.qcow2' % index
246 base_image = '/tmp/base_image'
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))
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)])
264 vm_image = '/var/lib/libvirt/images/%s.qcow2' % index
265 base_image = '/tmp/base_image'
266 mock_normpath.return_value = base_image
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))
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,
282 @mock.patch.object(model.Libvirt, 'gen_cdrom_image')
283 def test_check_update_key(self, mock_gen_cdrom_image):
286 'key_filename': '/home/ubuntu/id_rsa',
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,
299 mock_gen_cdrom_image.assert_called_once_with(self.mock_ssh, cdrom_img, hostname,
300 node.get('user'), key_filename, mac, ip)
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'
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)
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)])
315 vm_image = '/var/lib/libvirt/images/%s.qcow2' % index
316 base_image = '/tmp/base_image'
318 with self.assertRaises(exceptions.LibvirtQemuImageCreateError):
319 model.Libvirt.create_snapshot_qemu(self.mock_ssh, index,
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))
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',
337 flavor = {'ram': '1024',
338 'extra_specs': extra_specs,
341 mac = model.StandaloneContextHelper.get_mac_address(0x00)
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)
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')
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)
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)
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)
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)
390 class StandaloneContextHelperTestCase(unittest.TestCase):
392 NODE_SAMPLE = "nodes_sample.yaml"
393 NODE_SRIOV_SAMPLE = "nodes_sriov_sample.yaml"
396 'mgmt': {'cidr': '152.16.100.10/24'},
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'},
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'}
410 self.helper = model.StandaloneContextHelper()
412 def test___init__(self):
413 self.assertIsNone(self.helper.file_path)
415 def test_install_req_libs(self):
416 with mock.patch("yardstick.ssh.SSH") as ssh:
417 ssh_mock = mock.Mock(autospec=ssh.SSH)
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)
425 def test_get_kernel_module(self):
426 with mock.patch("yardstick.ssh.SSH") as ssh:
427 ssh_mock = mock.Mock(autospec=ssh.SSH)
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)
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')
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)
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')
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)
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)
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)
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))
477 def test_get_mac_address(self):
478 status = model.StandaloneContextHelper.get_mac_address()
479 self.assertIsNotNone(status)
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)
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)
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)
511 class ServerTestCase(unittest.TestCase):
514 'mgmt': {'cidr': '152.16.100.10/24'},
516 'phy_port': "0000:05:00.0",
517 'vpci': "0000:00:07.0",
520 'cidr': '152.16.100.10/24',
521 'gateway_ip': '152.16.100.20'},
523 'phy_port': "0000:05:00.1",
524 'vpci': "0000:00:08.0",
527 'cidr': '152.16.40.10/24',
528 'gateway_ip': '152.16.100.20'}
532 self.server = model.Server()
534 def test___init__(self):
535 self.assertIsNotNone(self.server)
537 def test_build_vnf_interfaces(self):
540 'mgmt': {'cidr': '152.16.100.10/24'},
541 'xe0': ['private_0'],
545 status = model.Server.build_vnf_interfaces(vnf, self.NETWORKS)
546 self.assertIsNotNone(status)
548 def test_generate_vnf_instance(self):
551 'mgmt': {'cidr': '152.16.100.10/24'},
552 'xe0': ['private_0'],
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)
561 class OvsDeployTestCase(unittest.TestCase):
563 OVS_DETAILS = {'version': {'ovs': 'ovs_version', 'dpdk': 'dpdk_version'}}
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',
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()
576 self.addCleanup(self._stop_mock)
578 def _stop_mock(self):
579 self._mock_ssh.stop()
580 self._mock_path_isfile.stop()
581 self._mock_path_join.stop()
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",
588 self.ovs_deploy.prerequisite()
589 mock_install_req_libs.assert_called_once_with(
590 self.ovs_deploy.connection, pkgs)
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
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)
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']
614 with mock.patch.object(self.ovs_deploy.connection, 'put') as \
616 mock.patch.object(self.ovs_deploy.connection, 'execute') as \
618 mock.patch.object(self.ovs_deploy, 'prerequisite'):
619 mock_execute.return_value = (0, 0, 0)
620 self.ovs_deploy.ovs_deploy()
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)
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', '')])