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.contexts.standalone import model
22 from yardstick.benchmark.contexts.standalone import sriov
25 class SriovContextTestCase(unittest.TestCase):
27 NODES_SAMPLE = "nodes_sample.yaml"
28 NODES_SRIOV_SAMPLE = "nodes_sriov_sample.yaml"
29 NODES_DUPLICATE_SAMPLE = "nodes_duplicate_sample.yaml"
32 'name': 'StandaloneSriov',
33 'task_id': '1234567890',
41 'mgmt': {'cidr': '152.16.100.10/24'},
43 'phy_port': "0000:05:00.0",
44 'vpci': "0000:00:07.0",
45 'cidr': '152.16.100.10/24',
47 'mac': "00:00:00:00:00:01",
48 'vf_pci': {'vf_pci': 0},
49 'gateway_ip': '152.16.100.20'},
51 'phy_port': "0000:05:00.1",
52 'vpci': "0000:00:08.0",
53 'cidr': '152.16.40.10/24',
55 'vf_pci': {'vf_pci': 0},
56 'mac': "00:00:00:00:00:01",
57 'gateway_ip': '152.16.100.20'},
63 'task_id': '1234567890',
64 'file': self._get_file_abspath(self.NODES_SRIOV_SAMPLE)
66 self.sriov = sriov.SriovContext()
67 self.addCleanup(self._remove_contexts)
69 def _remove_contexts(self):
70 if self.sriov in self.sriov.list:
71 self.sriov._delete_context()
73 @mock.patch.object(model, 'StandaloneContextHelper')
74 @mock.patch.object(model, 'Libvirt')
75 @mock.patch.object(model, 'Server')
76 def test___init__(self, mock_helper, mock_libvirt, mock_server):
77 # pylint: disable=unused-argument
78 # NOTE(ralonsoh): this test doesn't cover function execution.
79 self.sriov.helper = mock_helper
80 self.sriov.vnf_node = mock_server
81 self.assertIsNone(self.sriov.file_path)
82 self.assertTrue(self.sriov.first_run)
85 self.sriov.helper.parse_pod_file = mock.Mock(return_value=[{}, {}, {}])
86 self.assertIsNone(self.sriov.init(self.ATTRS))
88 @mock.patch.object(ssh, 'SSH', return_value=(0, "a", ""))
89 def test_deploy(self, *args):
90 # NOTE(ralonsoh): this test doesn't cover function execution.
91 self.sriov.vm_deploy = False
92 self.assertIsNone(self.sriov.deploy())
94 self.sriov.vm_deploy = True
95 self.sriov.host_mgmt = {}
96 self.sriov.install_req_libs = mock.Mock()
97 self.sriov.get_nic_details = mock.Mock(return_value={})
98 self.sriov.setup_sriov_context = mock.Mock(return_value={})
99 self.sriov.wait_for_vnfs_to_start = mock.Mock(return_value={})
100 self.assertIsNone(self.sriov.deploy())
102 @mock.patch.object(ssh, 'SSH', return_value=(0, "a", ""))
103 @mock.patch.object(model, 'Libvirt')
104 def test_undeploy(self, mock_libvirt, mock_ssh):
105 # pylint: disable=unused-argument
106 # NOTE(ralonsoh): the pylint exception should be removed.
107 self.sriov.vm_deploy = False
108 self.assertIsNone(self.sriov.undeploy())
110 self.sriov.vm_deploy = True
111 self.sriov.connection = mock_ssh
112 self.sriov.vm_names = ['vm_0', 'vm_1']
113 self.sriov.drivers = ['vm_0', 'vm_1']
114 self.assertIsNone(self.sriov.undeploy())
116 def _get_file_abspath(self, filename):
117 curr_path = os.path.dirname(os.path.abspath(__file__))
118 file_path = os.path.join(curr_path, filename)
121 def test__get_server_with_dic_attr_name(self):
123 self.sriov.init(self.attrs)
125 attr_name = {'name': 'foo.bar'}
126 result = self.sriov._get_server(attr_name)
128 self.assertEqual(result, None)
130 def test__get_server_not_found(self):
132 self.sriov.helper.parse_pod_file = mock.Mock(return_value=[{}, {}, {}])
133 self.sriov.init(self.attrs)
135 attr_name = 'bar.foo'
136 result = self.sriov._get_server(attr_name)
138 self.assertEqual(result, None)
140 def test__get_server_mismatch(self):
142 self.sriov.init(self.attrs)
144 attr_name = 'bar.foo1'
145 result = self.sriov._get_server(attr_name)
147 self.assertEqual(result, None)
149 def test__get_server_duplicate(self):
151 self.attrs['file'] = self._get_file_abspath(self.NODES_DUPLICATE_SAMPLE)
153 self.sriov.init(self.attrs)
155 attr_name = 'node1.foo-12345678'
156 with self.assertRaises(ValueError):
157 self.sriov._get_server(attr_name)
159 def test__get_server_found(self):
161 self.sriov.init(self.attrs)
163 attr_name = 'node1.foo-12345678'
164 result = self.sriov._get_server(attr_name)
166 self.assertEqual(result['ip'], '10.229.47.137')
167 self.assertEqual(result['name'], 'node1.foo-12345678')
168 self.assertEqual(result['user'], 'root')
169 self.assertEqual(result['key_filename'], '/root/.yardstick_key')
171 def test__get_server_no_task_id(self):
172 self.attrs['flags'] = {'no_setup': True}
173 self.sriov.init(self.attrs)
175 attr_name = 'node1.foo'
176 result = self.sriov._get_server(attr_name)
178 self.assertEqual(result['ip'], '10.229.47.137')
179 self.assertEqual(result['name'], 'node1.foo')
180 self.assertEqual(result['user'], 'root')
181 self.assertEqual(result['key_filename'], '/root/.yardstick_key')
183 # TODO(elfoley): Split this test
184 # There are at least two sets of inputs/outputs
185 def test__get_network(self):
189 'segmentation_id': 'seg54',
190 'network_type': 'type_a',
191 'physical_network': 'phys',
197 self.sriov.networks = {
203 self.assertIsNone(self.sriov._get_network(attr_name))
205 attr_name = {'vld_id': 'vld777'}
206 self.assertIsNone(self.sriov._get_network(attr_name))
208 self.assertIsNone(self.sriov._get_network(None))
211 self.assertIsNone(self.sriov._get_network(attr_name))
213 attr_name = {'vld_id': 'vld999'}
217 "segmentation_id": None,
218 "network_type": None,
219 "physical_network": None,
221 result = self.sriov._get_network(attr_name)
222 self.assertDictEqual(result, expected)
226 result = self.sriov._get_network(attr_name)
227 self.assertDictEqual(result, expected)
229 def test_configure_nics_for_sriov(self):
230 with mock.patch("yardstick.ssh.SSH") as ssh:
231 ssh_mock = mock.Mock(autospec=ssh.SSH)
233 mock.Mock(return_value=(0, "a", ""))
234 ssh.return_value = ssh_mock
235 self.sriov.vm_deploy = True
236 self.sriov.connection = ssh_mock
237 self.sriov.vm_names = ['vm_0', 'vm_1']
238 self.sriov.drivers = []
239 self.sriov.networks = self.NETWORKS
240 self.sriov.helper.get_mac_address = mock.Mock(return_value="")
241 self.sriov._get_vf_data = mock.Mock(return_value="")
242 self.assertIsNone(self.sriov.configure_nics_for_sriov())
244 @mock.patch.object(ssh, 'SSH', return_value=(0, "a", ""))
245 @mock.patch.object(model, 'Libvirt')
246 def test__enable_interfaces(self, mock_libvirt, mock_ssh):
247 # pylint: disable=unused-argument
248 # NOTE(ralonsoh): the pylint exception should be removed.
249 self.sriov.vm_deploy = True
250 self.sriov.connection = mock_ssh
251 self.sriov.vm_names = ['vm_0', 'vm_1']
252 self.sriov.drivers = []
253 self.sriov.networks = self.NETWORKS
254 self.sriov.get_vf_data = mock.Mock(return_value="")
255 self.assertIsNone(self.sriov._enable_interfaces(
256 0, 0, ["private_0"], 'test'))
258 @mock.patch.object(model.Libvirt, 'build_vm_xml')
259 @mock.patch.object(model.Libvirt, 'check_if_vm_exists_and_delete')
260 @mock.patch.object(model.Libvirt, 'write_file')
261 @mock.patch.object(model.Libvirt, 'virsh_create_vm')
262 def test_setup_sriov_context(self, mock_create_vm, mock_write_file,
263 mock_check, mock_build_vm_xml):
264 self.sriov.servers = {
267 'mgmt': {'cidr': '152.16.100.10/24'},
268 'xe0': ['private_0'],
273 connection = mock.Mock()
274 self.sriov.connection = connection
275 self.sriov.host_mgmt = {'ip': '1.2.3.4'}
276 self.sriov.vm_flavor = 'flavor'
277 self.sriov.networks = 'networks'
278 self.sriov.configure_nics_for_sriov = mock.Mock()
279 cfg = '/tmp/vm_sriov_0.xml'
281 xml_out = mock.Mock()
282 mock_build_vm_xml.return_value = (xml_out, '00:00:00:00:00:01')
284 with mock.patch.object(self.sriov, 'vnf_node') as mock_vnf_node, \
285 mock.patch.object(self.sriov, '_enable_interfaces'):
286 mock_vnf_node.generate_vnf_instance = mock.Mock(
288 nodes_out = self.sriov.setup_sriov_context()
289 self.assertEqual(['node'], nodes_out)
290 mock_vnf_node.generate_vnf_instance.assert_called_once_with(
291 'flavor', 'networks', '1.2.3.4', 'vnf_0',
292 self.sriov.servers['vnf_0'], '00:00:00:00:00:01')
293 mock_build_vm_xml.assert_called_once_with(
294 connection, 'flavor', vm_name, 0)
295 mock_create_vm.assert_called_once_with(connection, cfg)
296 mock_check.assert_called_once_with(vm_name, connection)
297 mock_write_file.assert_called_once_with(cfg, xml_out)
299 def test__get_vf_data(self):
300 with mock.patch("yardstick.ssh.SSH") as ssh:
301 ssh_mock = mock.Mock(autospec=ssh.SSH)
303 mock.Mock(return_value=(0, "a", ""))
305 mock.Mock(return_value=(0, "a", ""))
306 ssh.return_value = ssh_mock
307 self.sriov.vm_deploy = True
308 self.sriov.connection = ssh_mock
309 self.sriov.vm_names = ['vm_0', 'vm_1']
310 self.sriov.drivers = []
311 self.sriov.servers = {
314 'mgmt': {'cidr': '152.16.100.10/24'},
315 'xe0': ['private_0'],
320 self.sriov.networks = self.NETWORKS
321 self.sriov.helper.get_virtual_devices = mock.Mock(
322 return_value={'0000:00:01.0': ''})
323 self.assertIsNotNone(self.sriov._get_vf_data(
324 '0000:00:01.0', '00:00:00:00:00:01', 'if0'))