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.benchmark.contexts.standalone import ovs_dpdk
23 class OvsDpdkContextTestCase(unittest.TestCase):
25 NODES_SAMPLE = "nodes_sample.yaml"
26 NODES_ovs_dpdk_SAMPLE = "nodes_ovs_dpdk_sample.yaml"
27 NODES_DUPLICATE_SAMPLE = "nodes_duplicate_sample.yaml"
30 'mgmt': {'cidr': '152.16.100.10/24'},
32 'phy_port': "0000:05:00.0",
33 'vpci': "0000:00:07.0",
34 'cidr': '152.16.100.10/24',
36 'mac': "00:00:00:00:00:01",
37 'vf_pci': {'vf_pci': 0},
38 'gateway_ip': '152.16.100.20'},
40 'phy_port': "0000:05:00.1",
41 'vpci': "0000:00:08.0",
42 'cidr': '152.16.40.10/24',
44 'vf_pci': {'vf_pci': 0},
45 'mac': "00:00:00:00:00:01",
46 'gateway_ip': '152.16.100.20'},
52 'task_id': '1234567890',
53 'file': self._get_file_abspath(self.NODES_ovs_dpdk_SAMPLE)
55 self.ovs_dpdk = ovs_dpdk.OvsDpdkContext()
56 self.addCleanup(self._remove_contexts)
58 def _remove_contexts(self):
59 if self.ovs_dpdk in self.ovs_dpdk.list:
60 self.ovs_dpdk._delete_context()
62 @mock.patch('yardstick.benchmark.contexts.standalone.model.Server')
63 @mock.patch('yardstick.benchmark.contexts.standalone.model.StandaloneContextHelper')
64 def test___init__(self, mock_helper, mock_server):
65 self.ovs_dpdk.helper = mock_helper
66 self.ovs_dpdk.vnf_node = mock_server
67 self.assertIsNone(self.ovs_dpdk.file_path)
68 self.assertTrue(self.ovs_dpdk.first_run)
72 'name': 'StandaloneOvsDpdk',
73 'task_id': '1234567890',
80 self.ovs_dpdk.helper.parse_pod_file = mock.Mock(
81 return_value=[{}, {}, {}])
82 self.assertIsNone(self.ovs_dpdk.init(ATTRS))
84 def test_setup_ovs(self):
85 with mock.patch("yardstick.ssh.SSH") as ssh:
86 ssh_mock = mock.Mock(autospec=ssh.SSH)
88 mock.Mock(return_value=(0, "a", ""))
89 ssh.return_value = ssh_mock
90 self.ovs_dpdk.connection = ssh_mock
91 self.ovs_dpdk.networks = self.NETWORKS
92 self.ovs_dpdk.ovs_properties = {}
93 self.assertIsNone(self.ovs_dpdk.setup_ovs())
95 def test_start_ovs_serverswitch(self):
96 with mock.patch("yardstick.ssh.SSH") as ssh:
97 ssh_mock = mock.Mock(autospec=ssh.SSH)
99 mock.Mock(return_value=(0, "a", ""))
100 ssh.return_value = ssh_mock
101 self.ovs_dpdk.connection = ssh_mock
102 self.ovs_dpdk.networks = self.NETWORKS
103 self.ovs_dpdk.ovs_properties = {}
104 self.ovs_dpdk.wait_for_vswitchd = 0
105 self.assertIsNone(self.ovs_dpdk.start_ovs_serverswitch())
107 def test_setup_ovs_bridge_add_flows(self):
108 with mock.patch("yardstick.ssh.SSH") as ssh:
109 ssh_mock = mock.Mock(autospec=ssh.SSH)
111 mock.Mock(return_value=(0, "a", ""))
112 ssh.return_value = ssh_mock
113 self.ovs_dpdk.connection = ssh_mock
114 self.ovs_dpdk.networks = self.NETWORKS
115 self.ovs_dpdk.ovs_properties = {
116 'version': {'ovs': '2.7.0'}
118 self.ovs_dpdk.wait_for_vswitchd = 0
119 self.assertIsNone(self.ovs_dpdk.setup_ovs_bridge_add_flows())
121 @mock.patch("yardstick.ssh.SSH")
122 def test_cleanup_ovs_dpdk_env(self, mock_ssh):
123 mock_ssh.execute.return_value = 0, "a", ""
124 self.ovs_dpdk.connection = mock_ssh
125 self.ovs_dpdk.networks = self.NETWORKS
126 self.ovs_dpdk.ovs_properties = {
127 'version': {'ovs': '2.7.0'}
129 self.ovs_dpdk.wait_for_vswitchd = 0
130 self.assertIsNone(self.ovs_dpdk.cleanup_ovs_dpdk_env())
132 @mock.patch('yardstick.benchmark.contexts.standalone.model.OvsDeploy')
133 def test_check_ovs_dpdk_env(self, mock_ovs):
134 with mock.patch("yardstick.ssh.SSH") as ssh:
135 ssh_mock = mock.Mock(autospec=ssh.SSH)
137 mock.Mock(return_value=(1, "a", ""))
138 ssh.return_value = ssh_mock
139 self.ovs_dpdk.connection = ssh_mock
140 self.ovs_dpdk.networks = self.NETWORKS
141 self.ovs_dpdk.ovs_properties = {
142 'version': {'ovs': '2.7.0', 'dpdk': '16.11.1'}
144 self.ovs_dpdk.wait_for_vswitchd = 0
145 self.ovs_dpdk.cleanup_ovs_dpdk_env = mock.Mock()
146 self.assertIsNone(self.ovs_dpdk.check_ovs_dpdk_env())
147 self.ovs_dpdk.ovs_properties = {
148 'version': {'ovs': '2.0.0'}
150 self.ovs_dpdk.wait_for_vswitchd = 0
151 self.cleanup_ovs_dpdk_env = mock.Mock()
152 mock_ovs.deploy = mock.Mock()
153 # NOTE(elfoley): Check for a specific Exception
154 self.assertRaises(Exception, self.ovs_dpdk.check_ovs_dpdk_env)
156 @mock.patch('yardstick.ssh.SSH')
157 def test_deploy(self, mock_ssh):
158 mock_ssh.execute.return_value = 0, "a", ""
160 self.ovs_dpdk.vm_deploy = False
161 self.assertIsNone(self.ovs_dpdk.deploy())
163 self.ovs_dpdk.vm_deploy = True
164 self.ovs_dpdk.host_mgmt = {}
165 self.ovs_dpdk.install_req_libs = mock.Mock()
166 self.ovs_dpdk.helper.get_nic_details = mock.Mock(return_value={})
167 self.ovs_dpdk.check_ovs_dpdk_env = mock.Mock(return_value={})
168 self.ovs_dpdk.setup_ovs = mock.Mock(return_value={})
169 self.ovs_dpdk.start_ovs_serverswitch = mock.Mock(return_value={})
170 self.ovs_dpdk.setup_ovs_bridge_add_flows = mock.Mock(return_value={})
171 self.ovs_dpdk.setup_ovs_dpdk_context = mock.Mock(return_value={})
172 self.ovs_dpdk.wait_for_vnfs_to_start = mock.Mock(return_value={})
173 # TODO(elfoley): This test should check states/sideeffects instead of
175 self.assertIsNone(self.ovs_dpdk.deploy())
177 @mock.patch('yardstick.benchmark.contexts.standalone.model.Libvirt')
178 @mock.patch('yardstick.ssh.SSH')
179 def test_undeploy(self, mock_ssh, *args):
180 mock_ssh.execute.return_value = 0, "a", ""
182 self.ovs_dpdk.vm_deploy = False
183 self.assertIsNone(self.ovs_dpdk.undeploy())
185 self.ovs_dpdk.vm_deploy = True
186 self.ovs_dpdk.connection = mock_ssh
187 self.ovs_dpdk.vm_names = ['vm_0', 'vm_1']
188 self.ovs_dpdk.drivers = ['vm_0', 'vm_1']
189 self.ovs_dpdk.cleanup_ovs_dpdk_env = mock.Mock()
190 self.ovs_dpdk.networks = self.NETWORKS
191 self.assertIsNone(self.ovs_dpdk.undeploy())
193 def _get_file_abspath(self, filename):
194 curr_path = os.path.dirname(os.path.abspath(__file__))
195 file_path = os.path.join(curr_path, filename)
198 def test__get_server_with_dic_attr_name(self):
200 self.ovs_dpdk.init(self.attrs)
202 attr_name = {'name': 'foo.bar'}
203 result = self.ovs_dpdk._get_server(attr_name)
205 self.assertEqual(result, None)
207 def test__get_server_not_found(self):
209 self.ovs_dpdk.helper.parse_pod_file = mock.Mock(
210 return_value=[{}, {}, {}])
211 self.ovs_dpdk.init(self.attrs)
213 attr_name = 'bar.foo'
214 result = self.ovs_dpdk._get_server(attr_name)
216 self.assertEqual(result, None)
218 def test__get_server_mismatch(self):
220 self.ovs_dpdk.init(self.attrs)
222 attr_name = 'bar.foo1'
223 result = self.ovs_dpdk._get_server(attr_name)
225 self.assertEqual(result, None)
227 def test__get_server_duplicate(self):
229 self.attrs['file'] = self._get_file_abspath(self.NODES_DUPLICATE_SAMPLE)
231 self.ovs_dpdk.init(self.attrs)
233 attr_name = 'node1.foo-12345678'
234 with self.assertRaises(ValueError):
235 self.ovs_dpdk._get_server(attr_name)
237 def test__get_server_found(self):
239 self.ovs_dpdk.init(self.attrs)
241 attr_name = 'node1.foo-12345678'
242 result = self.ovs_dpdk._get_server(attr_name)
244 self.assertEqual(result['ip'], '10.229.47.137')
245 self.assertEqual(result['name'], 'node1.foo-12345678')
246 self.assertEqual(result['user'], 'root')
247 self.assertEqual(result['key_filename'], '/root/.yardstick_key')
249 # TODO(elfoley): Split this test for networks that exist and networks that
251 def test__get_network(self):
255 'segmentation_id': 'seg54',
256 'network_type': 'type_a',
257 'physical_network': 'phys',
263 self.ovs_dpdk.networks = {
268 # Tests for networks that do not exist
270 self.assertIsNone(self.ovs_dpdk._get_network(attr_name))
272 attr_name = {'vld_id': 'vld777'}
273 self.assertIsNone(self.ovs_dpdk._get_network(attr_name))
275 self.assertIsNone(self.ovs_dpdk._get_network(None))
277 # TODO(elfoley): Split this test
279 self.assertIsNone(self.ovs_dpdk._get_network(attr_name))
281 # Tests for networks that exist
282 attr_name = {'vld_id': 'vld999'}
286 "segmentation_id": None,
287 "network_type": None,
288 "physical_network": None,
290 result = self.ovs_dpdk._get_network(attr_name)
291 self.assertDictEqual(result, expected)
295 result = self.ovs_dpdk._get_network(attr_name)
296 self.assertDictEqual(result, expected)
298 def test_configure_nics_for_ovs_dpdk(self):
299 with mock.patch("yardstick.ssh.SSH") as ssh:
300 ssh_mock = mock.Mock(autospec=ssh.SSH)
302 mock.Mock(return_value=(0, "a", ""))
303 ssh.return_value = ssh_mock
304 self.ovs_dpdk.vm_deploy = True
305 self.ovs_dpdk.connection = ssh_mock
306 self.ovs_dpdk.vm_names = ['vm_0', 'vm_1']
307 self.ovs_dpdk.drivers = []
308 self.ovs_dpdk.networks = self.NETWORKS
309 self.ovs_dpdk.helper.get_mac_address = mock.Mock(return_value="")
310 self.ovs_dpdk.get_vf_datas = mock.Mock(return_value="")
311 self.assertIsNone(self.ovs_dpdk.configure_nics_for_ovs_dpdk())
313 @mock.patch('yardstick.benchmark.contexts.standalone.ovs_dpdk.Libvirt')
314 def test__enable_interfaces(self, *args):
315 with mock.patch("yardstick.ssh.SSH") as ssh:
316 ssh_mock = mock.Mock(autospec=ssh.SSH)
318 mock.Mock(return_value=(0, "a", ""))
319 ssh.return_value = ssh_mock
320 self.ovs_dpdk.vm_deploy = True
321 self.ovs_dpdk.connection = ssh_mock
322 self.ovs_dpdk.vm_names = ['vm_0', 'vm_1']
323 self.ovs_dpdk.drivers = []
324 self.ovs_dpdk.networks = self.NETWORKS
325 self.ovs_dpdk.get_vf_datas = mock.Mock(return_value="")
326 self.assertIsNone(self.ovs_dpdk._enable_interfaces(
327 0, ["private_0"], 'test'))
329 @mock.patch('yardstick.benchmark.contexts.standalone.model.Server')
330 @mock.patch('yardstick.benchmark.contexts.standalone.ovs_dpdk.Libvirt')
331 def test_setup_ovs_dpdk_context(self, mock_libvirt, *args):
332 with mock.patch("yardstick.ssh.SSH") as ssh:
333 ssh_mock = mock.Mock(autospec=ssh.SSH)
335 mock.Mock(return_value=(0, "a", ""))
337 mock.Mock(return_value=(0, "a", ""))
338 ssh.return_value = ssh_mock
339 self.ovs_dpdk.vm_deploy = True
340 self.ovs_dpdk.connection = ssh_mock
341 self.ovs_dpdk.vm_names = ['vm_0', 'vm_1']
342 self.ovs_dpdk.drivers = []
343 self.ovs_dpdk.servers = {
346 'mgmt': {'cidr': '152.16.100.10/24'},
347 'xe0': ['private_0'],
352 self.ovs_dpdk.networks = self.NETWORKS
353 self.ovs_dpdk.host_mgmt = {}
354 self.ovs_dpdk.flavor = {}
355 self.ovs_dpdk.configure_nics_for_ovs_dpdk = mock.Mock(return_value="")
356 mock_libvirt.build_vm_xml.return_value = [6, "00:00:00:00:00:01"]
357 self.ovs_dpdk._enable_interfaces = mock.Mock(return_value="")
358 mock_libvirt.virsh_create_vm.return_value = ""
359 mock_libvirt.pin_vcpu_for_perf.return_value = ""
360 self.ovs_dpdk.vnf_node.generate_vnf_instance = mock.Mock(
363 self.assertIsNotNone(self.ovs_dpdk.setup_ovs_dpdk_context())