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