1 ##############################################################################
2 # Copyright (c) 2015 Ericsson AB and others.
4 # All rights reserved. This program and the accompanying materials
5 # are made available under the terms of the Apache License, Version 2.0
6 # which accompanies this distribution, and is available at
7 # http://www.apache.org/licenses/LICENSE-2.0
8 ##############################################################################
10 from collections import OrderedDict
17 from yardstick.benchmark.contexts import base
18 from yardstick.benchmark.contexts import heat
19 from yardstick.benchmark.contexts import model
20 from yardstick.common import constants as consts
21 from yardstick.common import exceptions as y_exc
22 from yardstick.common import openstack_utils
23 from yardstick.common import yaml_loader
24 from yardstick import ssh
27 LOG = logging.getLogger(__name__)
30 class HeatContextTestCase(unittest.TestCase):
37 "ip": "10.229.47.137",
39 "key_filename": "/root/.yardstick_key"
44 "ip": "10.229.47.139",
46 "key_filename": "/root/.yardstick_key"
51 def __init__(self, *args, **kwargs):
53 super(HeatContextTestCase, self).__init__(*args, **kwargs)
56 self.test_context = heat.HeatContext()
57 self.addCleanup(self._remove_contexts)
58 self.mock_context = mock.Mock(spec=heat.HeatContext())
60 def _remove_contexts(self):
61 if self.test_context in self.test_context.list:
62 self.test_context._delete_context()
64 def test___init__(self):
65 self.assertIsNone(self.test_context._name)
66 self.assertIsNone(self.test_context._task_id)
67 self.assertFalse(self.test_context._flags.no_setup)
68 self.assertFalse(self.test_context._flags.no_teardown)
69 self.assertIsNone(self.test_context.stack)
70 self.assertEqual(self.test_context.networks, OrderedDict())
71 self.assertEqual(self.test_context.servers, [])
72 self.assertEqual(self.test_context.placement_groups, [])
73 self.assertEqual(self.test_context.server_groups, [])
74 self.assertIsNone(self.test_context.keypair_name)
75 self.assertIsNone(self.test_context.secgroup_name)
76 self.assertEqual(self.test_context._server_map, {})
77 self.assertIsNone(self.test_context._image)
78 self.assertIsNone(self.test_context._flavor)
79 self.assertIsNone(self.test_context._user)
80 self.assertIsNone(self.test_context.template_file)
81 self.assertIsNone(self.test_context.heat_parameters)
82 self.assertIsNone(self.test_context.key_filename)
84 @mock.patch.object(yaml_loader, 'read_yaml_file')
85 @mock.patch('yardstick.benchmark.contexts.heat.PlacementGroup')
86 @mock.patch('yardstick.benchmark.contexts.heat.ServerGroup')
87 @mock.patch('yardstick.benchmark.contexts.heat.Network')
88 @mock.patch('yardstick.benchmark.contexts.heat.Server')
89 def test_init(self, mock_server, mock_network, mock_sg, mock_pg,
92 mock_read_yaml.return_value = self.HEAT_POD_SAMPLE
93 pgs = {'pgrp1': {'policy': 'availability'}}
94 sgs = {'servergroup1': {'policy': 'affinity'}}
95 networks = {'bar': {'cidr': '10.0.1.0/24'}}
96 servers = {'baz': {'floating_ip': True, 'placement': 'pgrp1'}}
97 attrs = {'name': 'foo',
99 'task_id': '1234567890',
100 'placement_groups': pgs,
101 'server_groups': sgs,
102 'networks': networks,
105 with mock.patch.object(openstack_utils, 'get_shade_client'), \
106 mock.patch.object(openstack_utils, 'get_shade_operator_client'):
107 self.test_context.init(attrs)
109 self.assertFalse(self.test_context._flags.no_setup)
110 self.assertFalse(self.test_context._flags.no_teardown)
111 self.assertEqual(self.test_context._name, "foo")
112 self.assertEqual(self.test_context._task_id, '1234567890')
113 self.assertEqual(self.test_context.name, "foo-12345678")
114 self.assertEqual(self.test_context.keypair_name, "foo-12345678-key")
115 self.assertEqual(self.test_context.secgroup_name, "foo-12345678-secgroup")
117 mock_pg.assert_called_with('pgrp1', self.test_context,
118 pgs['pgrp1']['policy'])
119 mock_sg.assert_called_with('servergroup1', self.test_context,
120 sgs['servergroup1']['policy'])
121 self.assertEqual(len(self.test_context.placement_groups), 1)
122 self.assertEqual(len(self.test_context.server_groups), 1)
124 mock_network.assert_called_with(
125 'bar', self.test_context, networks['bar'])
126 self.assertEqual(len(self.test_context.networks), 1)
128 mock_server.assert_called_with('baz', self.test_context,
130 self.assertEqual(len(self.test_context.servers), 1)
132 def test_init_no_name_or_task_id(self):
134 self.assertRaises(KeyError, self.test_context.init, attrs)
137 self.test_context._name = 'foo'
138 self.test_context._task_id = '1234567890'
139 self.test_context._name_task_id = '{}-{}'.format(
140 self.test_context._name, self.test_context._task_id[:8])
141 self.assertEqual(self.test_context.name, 'foo-12345678')
142 self.assertEqual(self.test_context.assigned_name, 'foo')
144 def test_name_flags(self):
145 self.test_context._flags = base.Flags(
146 **{"no_setup": True, "no_teardown": True})
147 self.test_context._name = 'foo'
148 self.test_context._task_id = '1234567890'
150 self.assertEqual(self.test_context.name, 'foo')
151 self.assertEqual(self.test_context.assigned_name, 'foo')
153 def test_init_no_setup_no_teardown(self):
155 attrs = {'name': 'foo',
156 'task_id': '1234567890',
157 'placement_groups': {},
168 with mock.patch.object(openstack_utils, 'get_shade_client'), \
169 mock.patch.object(openstack_utils, 'get_shade_operator_client'):
170 self.test_context.init(attrs)
172 self.assertTrue(self.test_context._flags.no_setup)
173 self.assertTrue(self.test_context._flags.no_teardown)
175 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
176 def test__add_resources_to_template_no_servers(self, mock_template):
177 self.test_context._name = 'ctx'
178 self.test_context._task_id = '1234567890'
179 self.test_context._name_task_id = '{}-{}'.format(
180 self.test_context._name, self.test_context._task_id[:8])
181 self.test_context.keypair_name = "ctx-key"
182 self.test_context.secgroup_name = "ctx-secgroup"
183 self.test_context.key_uuid = "2f2e4997-0a8e-4eb7-9fa4-f3f8fbbc393b"
184 netattrs = {'cidr': '10.0.0.0/24', 'provider': None,
185 'external_network': 'ext_net'}
187 self.test_context.networks = OrderedDict(
188 {"mynet": model.Network("mynet", self.test_context,
191 self.test_context._add_resources_to_template(mock_template)
192 mock_template.add_keypair.assert_called_with(
195 mock_template.add_security_group.assert_called_with("ctx-secgroup")
196 mock_template.add_network.assert_called_with(
197 "ctx-12345678-mynet", 'physnet1', None, None, None, None)
198 mock_template.add_router.assert_called_with(
199 "ctx-12345678-mynet-router",
200 netattrs["external_network"],
201 "ctx-12345678-mynet-subnet")
202 mock_template.add_router_interface.assert_called_with(
203 "ctx-12345678-mynet-router-if0",
204 "ctx-12345678-mynet-router",
205 "ctx-12345678-mynet-subnet")
207 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
208 def test_attrs_get(self, *args):
209 image, flavor, user = expected_tuple = 'foo1', 'foo2', 'foo3'
210 self.assertNotEqual(self.test_context.image, image)
211 self.assertNotEqual(self.test_context.flavor, flavor)
212 self.assertNotEqual(self.test_context.user, user)
213 self.test_context._image = image
214 self.test_context._flavor = flavor
215 self.test_context._user = user
216 attr_tuple = self.test_context.image, self.test_context.flavor, self.test_context.user
217 self.assertEqual(attr_tuple, expected_tuple)
219 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
220 def test_attrs_set_negative(self, *args):
221 with self.assertRaises(AttributeError):
222 self.test_context.image = 'foo'
224 with self.assertRaises(AttributeError):
225 self.test_context.flavor = 'foo'
227 with self.assertRaises(AttributeError):
228 self.test_context.user = 'foo'
230 def test__create_new_stack(self):
231 template = mock.Mock()
232 self.test_context._create_new_stack(template)
233 template.create.assert_called_once()
235 def test__create_new_stack_stack_create_failed(self):
236 template = mock.Mock()
237 template.create.side_effect = y_exc.HeatTemplateError
239 self.assertRaises(y_exc.HeatTemplateError,
240 self.test_context._create_new_stack,
243 def test__create_new_stack_keyboard_interrupt(self):
244 template = mock.Mock()
245 template.create.side_effect = KeyboardInterrupt
246 self.assertRaises(y_exc.StackCreationInterrupt,
247 self.test_context._create_new_stack,
250 @mock.patch.object(os.path, 'exists', return_value=True)
251 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
252 @mock.patch.object(heat.HeatContext, '_create_new_stack')
253 def test_deploy_stack_creation_failed(self, mock_create,
254 mock_resources_template, mock_path_exists):
255 self.test_context._name = 'foo'
256 self.test_context._task_id = '1234567890'
257 self.test_context._name_task_id = 'foo-12345678'
258 mock_create.side_effect = y_exc.HeatTemplateError
259 self.assertRaises(y_exc.HeatTemplateError,
260 self.test_context.deploy)
262 mock_path_exists.assert_called()
263 mock_resources_template.assert_called_once()
265 @mock.patch.object(os.path, 'exists', return_value=False)
266 @mock.patch.object(ssh.SSH, 'gen_keys')
267 @mock.patch.object(heat, 'HeatTemplate')
268 def test_deploy(self, mock_template, mock_genkeys, mock_path_exists):
269 self.test_context._name = 'foo'
270 self.test_context._task_id = '1234567890'
271 self.test_context._name_task_id = '{}-{}'.format(
272 self.test_context._name, self.test_context._task_id[:8])
273 self.test_context.template_file = '/bar/baz/some-heat-file'
274 self.test_context.heat_parameters = {'image': 'cirros'}
275 self.test_context.get_neutron_info = mock.MagicMock()
276 self.test_context.deploy()
278 mock_template.assert_called_with(
279 'foo-12345678', template_file='/bar/baz/some-heat-file',
280 heat_parameters={'image': 'cirros'},
281 os_cloud_config=self.test_context._flags.os_cloud_config)
282 self.assertIsNotNone(self.test_context.stack)
283 key_filename = ''.join(
284 [consts.YARDSTICK_ROOT_PATH,
285 'yardstick/resources/files/yardstick_key-',
286 self.test_context._name_task_id])
287 mock_genkeys.assert_called_once_with(key_filename)
288 mock_path_exists.assert_any_call(key_filename)
290 @mock.patch.object(heat, 'HeatTemplate')
291 @mock.patch.object(os.path, 'exists', return_value=False)
292 @mock.patch.object(ssh.SSH, 'gen_keys')
293 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack')
294 @mock.patch.object(heat.HeatContext, '_create_new_stack')
295 def test_deploy_no_setup(self, mock_create_new_stack,
296 mock_retrieve_existing_stack, mock_genkeys, mock_path_exists,
298 self.test_context._name = 'foo'
299 self.test_context._task_id = '1234567890'
300 self.test_context.template_file = '/bar/baz/some-heat-file'
301 self.test_context.heat_parameters = {'image': 'cirros'}
302 self.test_context.get_neutron_info = mock.MagicMock()
303 self.test_context._flags.no_setup = True
304 self.test_context.deploy()
306 mock_create_new_stack.assert_not_called()
307 mock_retrieve_existing_stack.assert_called_with(self.test_context.name)
308 self.assertIsNotNone(self.test_context.stack)
309 key_filename = ''.join(
310 [consts.YARDSTICK_ROOT_PATH,
311 'yardstick/resources/files/yardstick_key-',
312 self.test_context._name])
313 mock_genkeys.assert_called_once_with(key_filename)
314 mock_path_exists.assert_any_call(key_filename)
316 @mock.patch.object(heat, 'HeatTemplate')
317 @mock.patch.object(os.path, 'exists', return_value=False)
318 @mock.patch.object(ssh.SSH, 'gen_keys')
319 @mock.patch.object(heat.HeatContext, '_create_new_stack')
320 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack',
322 def test_deploy_try_retrieve_context_does_not_exist(self,
323 mock_retrieve_stack, mock_create_new_stack, mock_genkeys,
324 mock_path_exists, *args):
325 self.test_context._name = 'demo'
326 self.test_context._task_id = '1234567890'
327 self.test_context._flags.no_setup = True
328 self.test_context.template_file = '/bar/baz/some-heat-file'
329 self.test_context.get_neutron_info = mock.MagicMock()
330 self.test_context.deploy()
332 mock_retrieve_stack.assert_called_once_with(self.test_context._name)
333 mock_create_new_stack.assert_called()
334 key_filename = ''.join(
335 [consts.YARDSTICK_ROOT_PATH,
336 'yardstick/resources/files/yardstick_key-',
337 self.test_context._name])
338 mock_genkeys.assert_called_once_with(key_filename)
339 mock_path_exists.assert_any_call(key_filename)
341 @mock.patch.object(heat, 'HeatTemplate', return_value='heat_template')
342 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
343 @mock.patch.object(os.path, 'exists', return_value=False)
344 @mock.patch.object(ssh.SSH, 'gen_keys')
345 def test_deploy_ssh_key_before_adding_resources(self, mock_genkeys,
346 mock_path_exists, mock_add_resources, *args):
347 mock_manager = mock.Mock()
348 mock_manager.attach_mock(mock_add_resources,
349 '_add_resources_to_template')
350 mock_manager.attach_mock(mock_genkeys, 'gen_keys')
351 mock_manager.reset_mock()
352 self.test_context._name_task_id = 'demo-12345678'
353 self.test_context.get_neutron_info = mock.Mock()
354 with mock.patch.object(self.test_context, '_create_new_stack') as \
356 mock.patch.object(self.test_context, 'get_neutron_info') as \
358 self.test_context.deploy()
360 mock_neutron_info.assert_called_once()
361 mock_create_stack.assert_called_once()
362 key_filename = ''.join(
363 [consts.YARDSTICK_ROOT_PATH,
364 'yardstick/resources/files/yardstick_key-',
365 self.test_context._name_task_id])
366 mock_genkeys.assert_called_once_with(key_filename)
367 mock_path_exists.assert_any_call(key_filename)
369 mock_call_gen_keys = mock.call.gen_keys(key_filename)
370 mock_call_add_resources = (
371 mock.call._add_resources_to_template('heat_template'))
372 self.assertTrue(mock_manager.mock_calls.index(mock_call_gen_keys) <
373 mock_manager.mock_calls.index(mock_call_add_resources))
375 def test_check_for_context(self):
377 # check that the context exists
379 def test_add_server_port(self):
380 network1 = mock.MagicMock()
381 network2 = mock.MagicMock()
382 self.test_context._name = 'foo'
383 self.test_context._task_id = '1234567890'
384 self.test_context._name_task_id = '{}-{}'.format(
385 self.test_context._name, self.test_context._task_id[:8])
386 self.test_context.stack = mock.MagicMock()
387 self.test_context.networks = {
391 self.test_context.stack.outputs = {
392 u'b': u'10.20.30.45',
394 u'foo-12345678-a-subnet-cidr': u'10.20.0.0/15',
395 u'foo-12345678-a-subnet-gateway_ip': u'10.20.30.1',
396 u'b-mac_address': u'00:01',
397 u'b-device_id': u'dev21',
398 u'b-network_id': u'net789',
399 u'd': u'40.30.20.15',
401 u'foo-12345678-c-subnet-cidr': u'40.30.0.0/18',
402 u'foo-12345678-c-subnet-gateway_ip': u'40.30.20.254',
403 u'd-mac_address': u'00:10',
404 u'd-device_id': u'dev43',
405 u'd-network_id': u'net987',
406 u'e': u'40.30.20.15',
408 u'e-mac_address': u'00:10',
409 u'e-device_id': u'dev43',
410 u'e-network_id': u'net987',
412 server = mock.MagicMock()
413 server.private_ip = None
414 server.ports = OrderedDict([
415 ('a', [{'stack_name': 'b', 'port': 'port_a'}]),
416 ('c', [{'stack_name': 'd', 'port': 'port_c'},
417 {'stack_name': 'e', 'port': 'port_f'}]),
421 "private_ip": '10.20.30.45',
423 "subnet_cidr": '10.20.0.0/15',
424 "network": '10.20.0.0',
425 "netmask": '255.254.0.0',
427 "gateway_ip": '10.20.30.1',
428 "mac_address": '00:01',
429 "device_id": 'dev21',
430 "network_id": 'net789',
432 "local_mac": '00:01',
433 "local_ip": '10.20.30.45',
435 self.test_context.add_server_port(server)
436 self.assertEqual(server.private_ip, '10.20.30.45')
437 self.assertEqual(len(server.interfaces), 3)
438 self.assertDictEqual(server.interfaces['port_a'], expected)
440 @mock.patch('yardstick.benchmark.contexts.heat.os')
441 @mock.patch.object(heat.HeatContext, '_delete_key_file')
442 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
443 def test_undeploy(self, mock_template, mock_delete_key, *args):
444 self.test_context.stack = mock_template
445 self.test_context._name = 'foo'
446 self.test_context._task_id = '1234567890'
447 self.test_context._name_task_id = '{}-{}'.format(
448 self.test_context._name, self.test_context._task_id[:8])
449 # mock_os.path.exists.return_value = True
450 self.test_context.key_filename = 'foo/bar/foobar'
451 self.test_context.undeploy()
452 mock_delete_key.assert_called()
453 mock_template.delete.assert_called_once()
455 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
456 def test_undeploy_no_teardown(self, mock_template):
457 self.test_context.stack = mock_template
458 self.test_context._name = 'foo'
459 self.test_context._task_id = '1234567890'
460 self.test_context._flags.no_teardown = True
461 self.test_context.undeploy()
463 mock_template.delete.assert_not_called()
465 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
466 @mock.patch('yardstick.benchmark.contexts.heat.os')
467 def test_undeploy_key_filename(self, mock_os, mock_template):
468 self.test_context.stack = mock_template
469 self.test_context._name = 'foo'
470 self.test_context._task_id = '1234567890'
471 self.test_context._name_task_id = '{}-{}'.format(
472 self.test_context._name, self.test_context._task_id)
473 mock_os.path.exists.return_value = True
474 self.test_context.key_filename = 'foo/bar/foobar'
475 self.assertIsNone(self.test_context.undeploy())
477 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
478 def test__get_server_found_dict(self, *args):
480 Use HeatContext._get_server to get a server that matches
481 based on a dictionary input.
483 foo2_server = mock.Mock()
484 foo2_server.key_filename = None
485 foo2_server.private_ip = '10.0.0.2'
486 foo2_server.public_ip = '127.0.0.2'
487 foo2_server.context.user = 'oof'
489 baz3_server = mock.Mock()
490 baz3_server.key_filename = None
491 baz3_server.private_ip = '10.0.0.3'
492 baz3_server.public_ip = '127.0.0.3'
493 baz3_server.context.user = 'zab'
495 self.test_context._name = 'bar'
496 self.test_context._task_id = '1234567890'
497 self.test_context._name_task_id = '{}-{}'.format(
498 self.test_context._name, self.test_context._task_id[:8])
499 self.test_context._user = 'bot'
500 self.test_context.stack = mock.Mock()
501 self.test_context.stack.outputs = {
502 'private_ip': '10.0.0.1',
503 'public_ip': '127.0.0.1',
505 self.test_context._server_map = {
511 'name': 'foo.bar-12345678',
512 'private_ip_attr': 'private_ip',
513 'public_ip_attr': 'public_ip',
515 self.test_context.key_uuid = 'foo-42'
516 result = self.test_context._get_server(attr_name)
517 self.assertEqual(result['user'], 'bot')
518 self.assertEqual(result['ip'], '127.0.0.1')
519 self.assertEqual(result['private_ip'], '10.0.0.1')
521 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
522 def test__get_server_found_dict_no_attrs(self, *args):
524 Use HeatContext._get_server to get a server that matches
525 based on a dictionary input.
527 foo2_server = mock.Mock()
528 foo2_server.private_ip = '10.0.0.2'
529 foo2_server.public_ip = '127.0.0.2'
530 foo2_server.context.user = 'oof'
532 baz3_server = mock.Mock()
533 baz3_server.private_ip = '10.0.0.3'
534 baz3_server.public_ip = '127.0.0.3'
535 baz3_server.context.user = 'zab'
537 self.test_context._name = 'bar'
538 self.test_context._task_id = '1234567890'
539 self.test_context._name_task_id = '{}-{}'.format(
540 self.test_context._name, self.test_context._task_id[:8])
541 self.test_context._user = 'bot'
542 self.test_context.stack = mock.Mock()
543 self.test_context.stack.outputs = {
544 'private_ip': '10.0.0.1',
545 'public_ip': '127.0.0.1',
547 self.test_context._server_map = {
553 'name': 'foo.bar-12345678',
556 self.test_context.key_uuid = 'foo-42'
557 result = self.test_context._get_server(attr_name)
558 self.assertEqual(result['user'], 'bot')
559 # no private ip attr mapping in the map results in None value in the result
560 self.assertIsNone(result['private_ip'])
561 # no public ip attr mapping in the map results in no value in the result
562 self.assertNotIn('ip', result)
564 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
565 def test__get_server_found_not_dict(self, *args):
567 Use HeatContext._get_server to get a server that matches
568 based on a non-dictionary input
570 foo2_server = mock.Mock()
571 foo2_server.private_ip = '10.0.0.2'
572 foo2_server.public_ip = '127.0.0.2'
573 foo2_server.context.user = 'oof'
575 baz3_server = mock.Mock()
576 baz3_server.private_ip = '10.0.0.3'
577 baz3_server.public_ip = None
578 baz3_server.context.user = 'zab'
580 self.test_context._name = 'bar1'
581 self.test_context._task_id = '1234567890'
582 self.test_context._name_task_id = 'bar1-12345678'
583 self.test_context.stack = mock.Mock()
584 self.test_context.stack.outputs = {
585 'private_ip': '10.0.0.1',
586 'public_ip': '127.0.0.1',
588 self.test_context.generate_routing_table = mock.MagicMock(return_value=[])
590 self.test_context._server_map = {
596 result = self.test_context._get_server(attr_name)
597 self.assertEqual(result['user'], 'zab')
598 self.assertEqual(result['private_ip'], '10.0.0.3')
599 # no public_ip on the server results in no value in the result
600 self.assertNotIn('public_ip', result)
602 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
603 def test__get_server_none_found_not_dict(self, *args):
605 Use HeatContext._get_server to not get a server due to
606 None value associated with the match to a non-dictionary
609 foo2_server = mock.Mock()
610 foo2_server.private_ip = '10.0.0.2'
611 foo2_server.public_ip = '127.0.0.2'
612 foo2_server.context.user = 'oof'
614 baz3_server = mock.Mock()
615 baz3_server.private_ip = '10.0.0.3'
616 baz3_server.public_ip = None
617 baz3_server.context.user = 'zab'
619 self.test_context._name = 'bar1'
620 self.test_context.stack = mock.Mock()
621 self.test_context.stack.outputs = {
622 'private_ip': '10.0.0.1',
623 'public_ip': '127.0.0.1',
625 self.test_context._server_map = {
631 self.test_context.key_uuid = 'foo-42'
633 result = self.test_context._get_server(attr_name)
634 self.assertIsNone(result)
636 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
637 def test__get_server_not_found_dict(self, *args):
639 Use HeatContext._get_server to not get a server for lack
640 of a match to a dictionary input
642 foo2_server = mock.Mock()
643 foo2_server.private_ip = '10.0.0.2'
644 foo2_server.public_ip = '127.0.0.2'
645 foo2_server.context.user = 'oof'
647 baz3_server = mock.Mock()
648 baz3_server.private_ip = '10.0.0.3'
649 baz3_server.public_ip = None
650 baz3_server.context.user = 'zab'
652 self.test_context._name = 'bar1'
653 self.test_context._task_id = '1235467890'
654 self.test_context._name_task_id = '{}-{}'.format(
655 self.test_context._name, self.test_context._task_id[:8])
656 self.test_context.stack = mock.Mock()
657 self.test_context.stack.outputs = {
658 'private_ip': '10.0.0.1',
659 'public_ip': '127.0.0.1',
661 self.test_context._server_map = {
666 self.test_context.key_uuid = 'foo-42'
669 'private_ip_attr': 'private_ip',
670 'public_ip_attr': 'public_ip',
672 result = self.test_context._get_server(attr_name)
673 self.assertIsNone(result)
675 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
676 def test__get_server_not_found_not_dict(self, *args):
678 Use HeatContext._get_server to not get a server for lack
679 of a match to a non-dictionary input
681 foo2_server = mock.Mock()
682 foo2_server.private_ip = '10.0.0.2'
683 foo2_server.public_ip = '127.0.0.2'
684 foo2_server.context.user = 'oof'
686 baz3_server = mock.Mock()
687 baz3_server.private_ip = '10.0.0.3'
688 baz3_server.public_ip = None
689 baz3_server.context.user = 'zab'
691 self.mock_context._name = 'bar1'
692 self.test_context.stack = mock.Mock()
693 self.mock_context.stack.outputs = {
694 'private_ip': '10.0.0.1',
695 'public_ip': '127.0.0.1',
697 self.mock_context._server_map = {
702 self.test_context.key_uuid = 'foo-42'
703 attr_name = 'foo.wow4'
704 result = self.test_context._get_server(attr_name)
705 self.assertIsNone(result)
707 # TODO: Split this into more granular tests
708 def test__get_network(self):
709 network1 = mock.MagicMock()
710 network1.name = 'net_1'
711 network1.vld_id = 'vld111'
712 network1.segmentation_id = 'seg54'
713 network1.network_type = 'type_a'
714 network1.physical_network = 'phys'
716 network2 = mock.MagicMock()
717 network2.name = 'net_2'
718 network2.segmentation_id = 'seg45'
719 network2.network_type = 'type_b'
720 network2.physical_network = 'virt'
722 self.test_context.networks = {
728 self.assertIsNone(self.test_context._get_network(attr_name))
731 self.assertIsNone(self.test_context._get_network(attr_name))
733 attr_name = {'network_type': 'nosuch'}
734 self.assertIsNone(self.test_context._get_network(attr_name))
737 self.assertIsNone(self.test_context._get_network(attr_name))
739 attr_name = {'segmentation_id': 'seg45'}
742 "segmentation_id": 'seg45',
743 "network_type": 'type_b',
744 "physical_network": 'virt',
746 result = self.test_context._get_network(attr_name)
747 self.assertDictEqual(result, expected)
752 "segmentation_id": 'seg54',
753 "network_type": 'type_a',
754 "physical_network": 'phys',
756 result = self.test_context._get_network(attr_name)
757 self.assertDictEqual(result, expected)
759 def _get_file_abspath(self, filename):
760 curr_path = os.path.dirname(os.path.abspath(__file__))
761 file_path = os.path.join(curr_path, filename)
764 def test__get_physical_nodes(self):
765 self.test_context.nodes = {}
766 nodes = self.test_context._get_physical_nodes()
767 self.assertEquals(nodes, {})
769 @mock.patch.object(yaml_loader, 'read_yaml_file')
770 def test__get_physical_node_for_server(self, mock_read_yaml):
771 attrs = {'name': 'foo',
772 'task_id': '12345678',
774 'servers': {'vnf': {}},
775 'networks': {'mgmt': {'cidr': '10.0.1.0/24'}}
778 with mock.patch.object(openstack_utils, 'get_shade_client'), \
779 mock.patch.object(openstack_utils, 'get_shade_operator_client'):
780 mock_read_yaml.return_value = self.HEAT_POD_SAMPLE
781 self.test_context.init(attrs)
783 with mock.patch('yardstick.common.openstack_utils.get_server') as mock_get_server:
784 mock_get_server.return_value = {'vnf': {}}
786 # When server is not from this context
787 result = self.test_context._get_physical_node_for_server('node1.foo-context')
788 self.assertIsNone(result)
790 # When node_name is not from this context
791 result = self.test_context._get_physical_node_for_server('fake.foo-12345678')
792 self.assertIsNone(result)
794 mock_munch = mock.Mock()
795 mock_munch.toDict = mock.Mock(return_value={
796 'OS-EXT-SRV-ATTR:hypervisor_hostname': 'hypervisor_hostname'
798 mock_get_server.return_value = mock_munch
800 hypervisor = mock.Mock()
801 hypervisor.hypervisor_hostname = 'hypervisor_hostname'
802 hypervisor.host_ip = '10.229.47.137'
804 self.test_context.operator_client.list_hypervisors = mock.Mock(
805 return_value=[hypervisor])
807 mock_get_server.return_value = mock_munch
809 result = self.test_context._get_physical_node_for_server('vnf.foo-12345678')
810 self.assertEqual(result, 'node1.foo')