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.
20 from yardstick import ssh
21 from yardstick.benchmark import contexts
22 from yardstick.benchmark.contexts import base
23 from yardstick.benchmark.contexts.standalone import model
24 from yardstick.benchmark.contexts.standalone import sriov
27 class SriovContextTestCase(unittest.TestCase):
29 NODES_SAMPLE = "nodes_sample.yaml"
30 NODES_SRIOV_SAMPLE = "nodes_sriov_sample.yaml"
31 NODES_DUPLICATE_SAMPLE = "nodes_duplicate_sample.yaml"
34 'name': contexts.CONTEXT_STANDALONESRIOV,
35 'task_id': '1234567890',
43 'mgmt': {'cidr': '152.16.100.10/24'},
45 'phy_port': "0000:05:00.0",
46 'vpci': "0000:00:07.0",
47 'cidr': '152.16.100.10/24',
49 'mac': "00:00:00:00:00:01",
50 'vf_pci': {'vf_pci': 0},
51 'gateway_ip': '152.16.100.20'},
53 'phy_port': "0000:05:00.1",
54 'vpci': "0000:00:08.0",
55 'cidr': '152.16.40.10/24',
57 'vf_pci': {'vf_pci': 0},
58 'mac': "00:00:00:00:00:01",
59 'gateway_ip': '152.16.100.20'},
65 'task_id': '1234567890',
66 'file': self._get_file_abspath(self.NODES_SRIOV_SAMPLE),
68 self.sriov = sriov.SriovContext()
69 self.addCleanup(self._remove_contexts)
72 def _remove_contexts():
73 for context in base.Context.list:
74 context._delete_context()
75 base.Context.list = []
77 @mock.patch.object(model, 'StandaloneContextHelper')
78 @mock.patch.object(model, 'Libvirt')
79 @mock.patch.object(model, 'Server')
80 def test___init__(self, mock_helper, mock_libvirt, mock_server):
81 # pylint: disable=unused-argument
82 # NOTE(ralonsoh): this test doesn't cover function execution.
83 self.sriov.helper = mock_helper
84 self.sriov.vnf_node = mock_server
85 self.assertIsNone(self.sriov.file_path)
86 self.assertTrue(self.sriov.first_run)
89 self.sriov.helper.parse_pod_file = mock.Mock(return_value=[{}, {}, {}])
90 self.assertIsNone(self.sriov.init(self.ATTRS))
92 @mock.patch.object(ssh, 'SSH', return_value=(0, "a", ""))
93 def test_deploy(self, *args):
94 # NOTE(ralonsoh): this test doesn't cover function execution.
95 self.sriov.vm_deploy = False
96 self.assertIsNone(self.sriov.deploy())
98 self.sriov.vm_deploy = True
99 self.sriov.host_mgmt = {}
100 self.sriov.install_req_libs = mock.Mock()
101 self.sriov.get_nic_details = mock.Mock(return_value={})
102 self.sriov.setup_sriov_context = mock.Mock(return_value={})
103 self.sriov.wait_for_vnfs_to_start = mock.Mock(return_value={})
104 self.assertIsNone(self.sriov.deploy())
106 @mock.patch.object(ssh, 'SSH', return_value=(0, "a", ""))
107 @mock.patch.object(model, 'Libvirt')
108 def test_undeploy(self, mock_libvirt, mock_ssh):
109 # pylint: disable=unused-argument
110 # NOTE(ralonsoh): the pylint exception should be removed.
111 self.sriov.vm_deploy = False
112 self.assertIsNone(self.sriov.undeploy())
114 self.sriov.vm_deploy = True
115 self.sriov.connection = mock_ssh
116 self.sriov.vm_names = ['vm-0', 'vm-1']
117 self.sriov.drivers = ['vm-0', 'vm-1']
118 self.assertIsNone(self.sriov.undeploy())
120 def _get_file_abspath(self, filename):
121 curr_path = os.path.dirname(os.path.abspath(__file__))
122 file_path = os.path.join(curr_path, filename)
125 def test__get_server_with_dic_attr_name(self):
127 self.sriov.init(self.attrs)
129 attr_name = {'name': 'foo.bar'}
130 result = self.sriov._get_server(attr_name)
132 self.assertEqual(result, None)
134 def test__get_server_not_found(self):
136 self.sriov.helper.parse_pod_file = mock.Mock(return_value=[{}, {}, {}])
137 self.sriov.init(self.attrs)
139 attr_name = 'bar.foo'
140 result = self.sriov._get_server(attr_name)
142 self.assertEqual(result, None)
144 def test__get_server_mismatch(self):
146 self.sriov.init(self.attrs)
148 attr_name = 'bar.foo1'
149 result = self.sriov._get_server(attr_name)
151 self.assertEqual(result, None)
153 def test__get_server_duplicate(self):
155 self.attrs['file'] = self._get_file_abspath(self.NODES_DUPLICATE_SAMPLE)
157 self.sriov.init(self.attrs)
159 attr_name = 'node1.foo-12345678'
160 with self.assertRaises(ValueError):
161 self.sriov._get_server(attr_name)
163 def test__get_server_found(self):
165 self.sriov.init(self.attrs)
167 attr_name = 'node1.foo-12345678'
168 result = self.sriov._get_server(attr_name)
170 self.assertEqual(result['ip'], '10.229.47.137')
171 self.assertEqual(result['name'], 'node1.foo-12345678')
172 self.assertEqual(result['user'], 'root')
173 self.assertEqual(result['key_filename'], '/root/.yardstick_key')
175 def test__get_physical_node_for_server(self):
177 attrs.update({'servers': {'server1': {}}})
178 self.sriov.init(attrs)
180 # When server is not from this context
181 result = self.sriov._get_physical_node_for_server('server1.another-context')
182 self.assertIsNone(result)
184 # When node_name is not from this context
185 result = self.sriov._get_physical_node_for_server('fake.foo-12345678')
186 self.assertIsNone(result)
188 result = self.sriov._get_physical_node_for_server('server1.foo-12345678')
189 self.assertEqual(result, 'node5.foo')
191 def test__get_server_no_task_id(self):
192 self.attrs['flags'] = {'no_setup': True}
193 self.sriov.init(self.attrs)
195 attr_name = 'node1.foo'
196 result = self.sriov._get_server(attr_name)
198 self.assertEqual(result['ip'], '10.229.47.137')
199 self.assertEqual(result['name'], 'node1.foo')
200 self.assertEqual(result['user'], 'root')
201 self.assertEqual(result['key_filename'], '/root/.yardstick_key')
203 # TODO(elfoley): Split this test
204 # There are at least two sets of inputs/outputs
205 def test__get_network(self):
209 'segmentation_id': 'seg54',
210 'network_type': 'type_a',
211 'physical_network': 'phys',
217 self.sriov.networks = {
223 self.assertIsNone(self.sriov._get_network(attr_name))
225 attr_name = {'vld_id': 'vld777'}
226 self.assertIsNone(self.sriov._get_network(attr_name))
228 self.assertIsNone(self.sriov._get_network(None))
231 self.assertIsNone(self.sriov._get_network(attr_name))
233 attr_name = {'vld_id': 'vld999'}
237 "segmentation_id": None,
238 "network_type": None,
239 "physical_network": None,
241 result = self.sriov._get_network(attr_name)
242 self.assertDictEqual(result, expected)
246 result = self.sriov._get_network(attr_name)
247 self.assertDictEqual(result, expected)
249 def test_configure_nics_for_sriov(self):
250 with mock.patch("yardstick.ssh.SSH") as ssh:
251 ssh_mock = mock.Mock(autospec=ssh.SSH)
253 mock.Mock(return_value=(0, "a", ""))
254 ssh.return_value = ssh_mock
255 self.sriov.vm_deploy = True
256 self.sriov.connection = ssh_mock
257 self.sriov.vm_names = ['vm-0', 'vm-1']
258 self.sriov.drivers = []
259 self.sriov.networks = self.NETWORKS
260 self.sriov.helper.get_mac_address = mock.Mock(return_value="")
261 self.sriov._get_vf_data = mock.Mock(return_value="")
262 self.assertIsNone(self.sriov.configure_nics_for_sriov())
264 @mock.patch.object(ssh, 'SSH', return_value=(0, "a", ""))
265 @mock.patch.object(model.Libvirt, 'add_sriov_interfaces',
266 return_value='out_xml')
267 def test__enable_interfaces(self, mock_add_sriov, mock_ssh):
268 self.sriov.vm_deploy = True
269 self.sriov.connection = mock_ssh
270 self.sriov.vm_names = ['vm-0', 'vm-1']
271 self.sriov.drivers = []
272 self.sriov.networks = self.NETWORKS
275 self.sriov._enable_interfaces(0, 0, ['private_0'], 'test'))
276 mock_add_sriov.assert_called_once_with(
277 '0000:00:0a.0', 0, self.NETWORKS['private_0']['mac'], 'test')
279 @mock.patch.object(model.StandaloneContextHelper, 'check_update_key')
280 @mock.patch.object(model.Libvirt, 'build_vm_xml')
281 @mock.patch.object(model.Libvirt, 'check_if_vm_exists_and_delete')
282 @mock.patch.object(model.Libvirt, 'write_file')
283 @mock.patch.object(model.Libvirt, 'virsh_create_vm')
284 def test_setup_sriov_context(self, mock_create_vm, mock_write_file, mock_check,
285 mock_build_vm_xml, mock_check_update_key):
286 self.sriov.servers = {
289 'mgmt': {'cidr': '152.16.100.10/24'},
290 'xe0': ['private_0'],
295 connection = mock.Mock()
296 self.sriov.connection = connection
297 self.sriov.host_mgmt = {'ip': '1.2.3.4'}
298 self.sriov.vm_flavor = 'flavor'
299 self.sriov.networks = 'networks'
300 self.sriov.configure_nics_for_sriov = mock.Mock()
301 self.sriov._name_task_id = 'fake_name'
302 cfg = '/tmp/vm_sriov_0.xml'
304 mac = '00:00:00:00:00:01'
305 xml_out = mock.Mock()
306 mock_build_vm_xml.return_value = (xml_out, mac)
307 mock_check_update_key.return_value = 'node_2'
308 cdrom_img = '/var/lib/libvirt/images/cdrom-0.img'
310 with mock.patch.object(self.sriov, 'vnf_node') as mock_vnf_node, \
311 mock.patch.object(self.sriov, '_enable_interfaces') as \
312 mock_enable_interfaces:
313 mock_enable_interfaces.return_value = 'out_xml'
314 mock_vnf_node.generate_vnf_instance = mock.Mock(
315 return_value='node_1')
316 nodes_out = self.sriov.setup_sriov_context()
317 mock_check_update_key.assert_called_once_with(connection, 'node_1', vm_name,
318 self.sriov._name_task_id, cdrom_img,
320 self.assertEqual(['node_2'], nodes_out)
321 mock_vnf_node.generate_vnf_instance.assert_called_once_with(
322 'flavor', 'networks', '1.2.3.4', 'vnf_0',
323 self.sriov.servers['vnf_0'], '00:00:00:00:00:01')
324 mock_build_vm_xml.assert_called_once_with(
325 connection, 'flavor', vm_name, 0, cdrom_img)
326 mock_create_vm.assert_called_once_with(connection, cfg)
327 mock_check.assert_called_once_with(vm_name, connection)
328 mock_write_file.assert_called_once_with(cfg, 'out_xml')
329 mock_enable_interfaces.assert_has_calls([
330 mock.call(0, mock.ANY, ['private_0'], mock.ANY),
331 mock.call(0, mock.ANY, ['public_0'], mock.ANY)], any_order=True)
333 def test__get_vf_data(self):
334 with mock.patch("yardstick.ssh.SSH") as ssh:
335 ssh_mock = mock.Mock(autospec=ssh.SSH)
337 mock.Mock(return_value=(0, "a", ""))
339 mock.Mock(return_value=(0, "a", ""))
340 ssh.return_value = ssh_mock
341 self.sriov.vm_deploy = True
342 self.sriov.connection = ssh_mock
343 self.sriov.vm_names = ['vm-0', 'vm-1']
344 self.sriov.drivers = []
345 self.sriov.servers = {
348 'mgmt': {'cidr': '152.16.100.10/24'},
349 'xe0': ['private_0'],
354 self.sriov.networks = self.NETWORKS
355 self.sriov.helper.get_virtual_devices = mock.Mock(
356 return_value={'0000:00:01.0': ''})
357 self.assertIsNotNone(self.sriov._get_vf_data(
358 '0000:00:01.0', '00:00:00:00:00:01', 'if0'))