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
11 from itertools import count
18 from yardstick.benchmark.contexts import base
19 from yardstick.benchmark.contexts import heat
20 from yardstick.benchmark.contexts import model
21 from yardstick.common import constants as consts
22 from yardstick.common import exceptions as y_exc
23 from yardstick import ssh
26 LOG = logging.getLogger(__name__)
29 class HeatContextTestCase(unittest.TestCase):
31 def __init__(self, *args, **kwargs):
32 super(HeatContextTestCase, self).__init__(*args, **kwargs)
33 self.name_iter = ('vnf{:03}'.format(x) for x in count(0, step=3))
36 self.test_context = heat.HeatContext()
37 self.addCleanup(self._remove_contexts)
38 self.mock_context = mock.Mock(spec=heat.HeatContext())
40 def _remove_contexts(self):
41 if self.test_context in self.test_context.list:
42 self.test_context._delete_context()
44 def test___init__(self):
45 self.assertIsNone(self.test_context._name)
46 self.assertIsNone(self.test_context._task_id)
47 self.assertFalse(self.test_context._flags.no_setup)
48 self.assertFalse(self.test_context._flags.no_teardown)
49 self.assertIsNone(self.test_context.stack)
50 self.assertEqual(self.test_context.networks, OrderedDict())
51 self.assertEqual(self.test_context.servers, [])
52 self.assertEqual(self.test_context.placement_groups, [])
53 self.assertEqual(self.test_context.server_groups, [])
54 self.assertIsNone(self.test_context.keypair_name)
55 self.assertIsNone(self.test_context.secgroup_name)
56 self.assertEqual(self.test_context._server_map, {})
57 self.assertIsNone(self.test_context._image)
58 self.assertIsNone(self.test_context._flavor)
59 self.assertIsNone(self.test_context._user)
60 self.assertIsNone(self.test_context.template_file)
61 self.assertIsNone(self.test_context.heat_parameters)
62 self.assertIsNone(self.test_context.key_filename)
64 @mock.patch('yardstick.benchmark.contexts.heat.PlacementGroup')
65 @mock.patch('yardstick.benchmark.contexts.heat.ServerGroup')
66 @mock.patch('yardstick.benchmark.contexts.heat.Network')
67 @mock.patch('yardstick.benchmark.contexts.heat.Server')
68 def test_init(self, mock_server, mock_network, mock_sg, mock_pg):
70 pgs = {'pgrp1': {'policy': 'availability'}}
71 sgs = {'servergroup1': {'policy': 'affinity'}}
72 networks = {'bar': {'cidr': '10.0.1.0/24'}}
73 servers = {'baz': {'floating_ip': True, 'placement': 'pgrp1'}}
74 attrs = {'name': 'foo',
75 'task_id': '1234567890',
76 'placement_groups': pgs,
81 self.test_context.init(attrs)
83 self.assertFalse(self.test_context._flags.no_setup)
84 self.assertFalse(self.test_context._flags.no_teardown)
85 self.assertEqual(self.test_context._name, "foo")
86 self.assertEqual(self.test_context._task_id, '1234567890')
87 self.assertEqual(self.test_context.name, "foo-12345678")
88 self.assertEqual(self.test_context.keypair_name, "foo-12345678-key")
89 self.assertEqual(self.test_context.secgroup_name, "foo-12345678-secgroup")
91 mock_pg.assert_called_with('pgrp1', self.test_context,
92 pgs['pgrp1']['policy'])
93 mock_sg.assert_called_with('servergroup1', self.test_context,
94 sgs['servergroup1']['policy'])
95 self.assertEqual(len(self.test_context.placement_groups), 1)
96 self.assertEqual(len(self.test_context.server_groups), 1)
98 mock_network.assert_called_with(
99 'bar', self.test_context, networks['bar'])
100 self.assertEqual(len(self.test_context.networks), 1)
102 mock_server.assert_called_with('baz', self.test_context,
104 self.assertEqual(len(self.test_context.servers), 1)
106 def test_init_no_name_or_task_id(self):
108 self.assertRaises(KeyError, self.test_context.init, attrs)
111 self.test_context._name = 'foo'
112 self.test_context._task_id = '1234567890'
113 self.test_context._name_task_id = '{}-{}'.format(
114 self.test_context._name, self.test_context._task_id[:8])
115 self.assertEqual(self.test_context.name, 'foo-12345678')
116 self.assertEqual(self.test_context.assigned_name, 'foo')
118 def test_name_flags(self):
119 self.test_context._flags = base.Flags(
120 **{"no_setup": True, "no_teardown": True})
121 self.test_context._name = 'foo'
122 self.test_context._task_id = '1234567890'
124 self.assertEqual(self.test_context.name, 'foo')
125 self.assertEqual(self.test_context.assigned_name, 'foo')
127 def test_init_no_setup_no_teardown(self):
129 attrs = {'name': 'foo',
130 'task_id': '1234567890',
131 'placement_groups': {},
141 self.test_context.init(attrs)
142 self.assertTrue(self.test_context._flags.no_setup)
143 self.assertTrue(self.test_context._flags.no_teardown)
145 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
146 def test__add_resources_to_template_no_servers(self, mock_template):
147 self.test_context._name = 'ctx'
148 self.test_context._task_id = '1234567890'
149 self.test_context._name_task_id = '{}-{}'.format(
150 self.test_context._name, self.test_context._task_id[:8])
151 self.test_context.keypair_name = "ctx-key"
152 self.test_context.secgroup_name = "ctx-secgroup"
153 self.test_context.key_uuid = "2f2e4997-0a8e-4eb7-9fa4-f3f8fbbc393b"
154 netattrs = {'cidr': '10.0.0.0/24', 'provider': None,
155 'external_network': 'ext_net'}
157 self.test_context.networks = OrderedDict(
158 {"mynet": model.Network("mynet", self.test_context,
161 self.test_context._add_resources_to_template(mock_template)
162 mock_template.add_keypair.assert_called_with(
165 mock_template.add_security_group.assert_called_with("ctx-secgroup")
166 mock_template.add_network.assert_called_with(
167 "ctx-12345678-mynet", 'physnet1', None, None, None, None)
168 mock_template.add_router.assert_called_with(
169 "ctx-12345678-mynet-router",
170 netattrs["external_network"],
171 "ctx-12345678-mynet-subnet")
172 mock_template.add_router_interface.assert_called_with(
173 "ctx-12345678-mynet-router-if0",
174 "ctx-12345678-mynet-router",
175 "ctx-12345678-mynet-subnet")
177 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
178 def test_attrs_get(self, *args):
179 image, flavor, user = expected_tuple = 'foo1', 'foo2', 'foo3'
180 self.assertNotEqual(self.test_context.image, image)
181 self.assertNotEqual(self.test_context.flavor, flavor)
182 self.assertNotEqual(self.test_context.user, user)
183 self.test_context._image = image
184 self.test_context._flavor = flavor
185 self.test_context._user = user
186 attr_tuple = self.test_context.image, self.test_context.flavor, self.test_context.user
187 self.assertEqual(attr_tuple, expected_tuple)
189 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
190 def test_attrs_set_negative(self, *args):
191 with self.assertRaises(AttributeError):
192 self.test_context.image = 'foo'
194 with self.assertRaises(AttributeError):
195 self.test_context.flavor = 'foo'
197 with self.assertRaises(AttributeError):
198 self.test_context.user = 'foo'
200 def test__create_new_stack(self):
201 template = mock.Mock()
202 self.test_context._create_new_stack(template)
203 template.create.assert_called_once()
205 def test__create_new_stack_stack_create_failed(self):
206 template = mock.Mock()
207 template.create.side_effect = y_exc.HeatTemplateError
209 self.assertRaises(y_exc.HeatTemplateError,
210 self.test_context._create_new_stack,
213 def test__create_new_stack_keyboard_interrupt(self):
214 template = mock.Mock()
215 template.create.side_effect = KeyboardInterrupt
216 self.assertRaises(y_exc.StackCreationInterrupt,
217 self.test_context._create_new_stack,
220 @mock.patch.object(os.path, 'exists', return_value=True)
221 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
222 @mock.patch.object(heat.HeatContext, '_create_new_stack')
223 def test_deploy_stack_creation_failed(self, mock_create,
224 mock_resources_template, mock_path_exists):
225 self.test_context._name = 'foo'
226 self.test_context._task_id = '1234567890'
227 self.test_context._name_task_id = 'foo-12345678'
228 mock_create.side_effect = y_exc.HeatTemplateError
229 self.assertRaises(y_exc.HeatTemplateError,
230 self.test_context.deploy)
232 mock_path_exists.assert_called_once()
233 mock_resources_template.assert_called_once()
235 @mock.patch.object(os.path, 'exists', return_value=False)
236 @mock.patch.object(ssh.SSH, 'gen_keys')
237 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
238 def test_deploy(self, mock_template, mock_genkeys, mock_path_exists):
239 self.test_context._name = 'foo'
240 self.test_context._task_id = '1234567890'
241 self.test_context._name_task_id = '{}-{}'.format(
242 self.test_context._name, self.test_context._task_id[:8])
243 self.test_context.template_file = '/bar/baz/some-heat-file'
244 self.test_context.heat_parameters = {'image': 'cirros'}
245 self.test_context.get_neutron_info = mock.MagicMock()
246 self.test_context.deploy()
248 mock_template.assert_called_with('foo-12345678',
249 '/bar/baz/some-heat-file',
251 self.assertIsNotNone(self.test_context.stack)
252 key_filename = ''.join(
253 [consts.YARDSTICK_ROOT_PATH,
254 'yardstick/resources/files/yardstick_key-',
255 self.test_context._name_task_id])
256 mock_genkeys.assert_called_once_with(key_filename)
257 mock_path_exists.assert_called_once_with(key_filename)
259 @mock.patch.object(heat, 'HeatTemplate')
260 @mock.patch.object(os.path, 'exists', return_value=False)
261 @mock.patch.object(ssh.SSH, 'gen_keys')
262 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack')
263 @mock.patch.object(heat.HeatContext, '_create_new_stack')
264 def test_deploy_no_setup(self, mock_create_new_stack,
265 mock_retrieve_existing_stack, mock_genkeys, mock_path_exists,
267 self.test_context._name = 'foo'
268 self.test_context._task_id = '1234567890'
269 self.test_context.template_file = '/bar/baz/some-heat-file'
270 self.test_context.heat_parameters = {'image': 'cirros'}
271 self.test_context.get_neutron_info = mock.MagicMock()
272 self.test_context._flags.no_setup = True
273 self.test_context.deploy()
275 mock_create_new_stack.assert_not_called()
276 mock_retrieve_existing_stack.assert_called_with(self.test_context.name)
277 self.assertIsNotNone(self.test_context.stack)
278 key_filename = ''.join(
279 [consts.YARDSTICK_ROOT_PATH,
280 'yardstick/resources/files/yardstick_key-',
281 self.test_context._name])
282 mock_genkeys.assert_called_once_with(key_filename)
283 mock_path_exists.assert_called_once_with(key_filename)
285 @mock.patch.object(heat, 'HeatTemplate')
286 @mock.patch.object(os.path, 'exists', return_value=False)
287 @mock.patch.object(ssh.SSH, 'gen_keys')
288 @mock.patch.object(heat.HeatContext, '_create_new_stack')
289 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack',
291 def test_deploy_try_retrieve_context_does_not_exist(self,
292 mock_retrieve_stack, mock_create_new_stack, mock_genkeys,
293 mock_path_exists, *args):
294 self.test_context._name = 'demo'
295 self.test_context._task_id = '1234567890'
296 self.test_context._flags.no_setup = True
297 self.test_context.template_file = '/bar/baz/some-heat-file'
298 self.test_context.get_neutron_info = mock.MagicMock()
300 self.test_context.deploy()
302 mock_retrieve_stack.assert_called_once_with(self.test_context._name)
303 mock_create_new_stack.assert_called()
304 key_filename = ''.join(
305 [consts.YARDSTICK_ROOT_PATH,
306 'yardstick/resources/files/yardstick_key-',
307 self.test_context._name])
308 mock_genkeys.assert_called_once_with(key_filename)
309 mock_path_exists.assert_called_once_with(key_filename)
311 @mock.patch.object(heat, 'HeatTemplate', return_value='heat_template')
312 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
313 @mock.patch.object(os.path, 'exists', return_value=False)
314 @mock.patch.object(ssh.SSH, 'gen_keys')
315 def test_deploy_ssh_key_before_adding_resources(self, mock_genkeys,
316 mock_path_exists, mock_add_resources, *args):
317 mock_manager = mock.Mock()
318 mock_manager.attach_mock(mock_add_resources,
319 '_add_resources_to_template')
320 mock_manager.attach_mock(mock_genkeys, 'gen_keys')
321 mock_manager.reset_mock()
322 self.test_context._name_task_id = 'demo-12345678'
323 self.test_context.get_neutron_info = mock.Mock()
324 with mock.patch.object(self.test_context, '_create_new_stack') as \
326 mock.patch.object(self.test_context, 'get_neutron_info') as \
328 self.test_context.deploy()
330 mock_neutron_info.assert_called_once()
331 mock_create_stack.assert_called_once()
332 key_filename = ''.join(
333 [consts.YARDSTICK_ROOT_PATH,
334 'yardstick/resources/files/yardstick_key-',
335 self.test_context._name_task_id])
336 mock_genkeys.assert_called_once_with(key_filename)
337 mock_path_exists.assert_called_with(key_filename)
339 mock_call_gen_keys = mock.call.gen_keys(key_filename)
340 mock_call_add_resources = (
341 mock.call._add_resources_to_template('heat_template'))
342 self.assertTrue(mock_manager.mock_calls.index(mock_call_gen_keys) <
343 mock_manager.mock_calls.index(mock_call_add_resources))
345 def test_check_for_context(self):
347 # check that the context exists
349 def test_add_server_port(self):
350 network1 = mock.MagicMock()
351 network2 = mock.MagicMock()
352 self.test_context._name = 'foo'
353 self.test_context._task_id = '1234567890'
354 self.test_context._name_task_id = '{}-{}'.format(
355 self.test_context._name, self.test_context._task_id[:8])
356 self.test_context.stack = mock.MagicMock()
357 self.test_context.networks = {
361 self.test_context.stack.outputs = {
362 u'b': u'10.20.30.45',
364 u'foo-12345678-a-subnet-cidr': u'10.20.0.0/15',
365 u'foo-12345678-a-subnet-gateway_ip': u'10.20.30.1',
366 u'b-mac_address': u'00:01',
367 u'b-device_id': u'dev21',
368 u'b-network_id': u'net789',
369 u'd': u'40.30.20.15',
371 u'foo-12345678-c-subnet-cidr': u'40.30.0.0/18',
372 u'foo-12345678-c-subnet-gateway_ip': u'40.30.20.254',
373 u'd-mac_address': u'00:10',
374 u'd-device_id': u'dev43',
375 u'd-network_id': u'net987',
376 u'e': u'40.30.20.15',
378 u'e-mac_address': u'00:10',
379 u'e-device_id': u'dev43',
380 u'e-network_id': u'net987',
382 server = mock.MagicMock()
383 server.private_ip = None
384 server.ports = OrderedDict([
385 ('a', [{'stack_name': 'b', 'port': 'port_a'}]),
386 ('c', [{'stack_name': 'd', 'port': 'port_c'},
387 {'stack_name': 'e', 'port': 'port_f'}]),
391 "private_ip": '10.20.30.45',
393 "subnet_cidr": '10.20.0.0/15',
394 "network": '10.20.0.0',
395 "netmask": '255.254.0.0',
397 "gateway_ip": '10.20.30.1',
398 "mac_address": '00:01',
399 "device_id": 'dev21',
400 "network_id": 'net789',
402 "local_mac": '00:01',
403 "local_ip": '10.20.30.45',
405 self.test_context.add_server_port(server)
406 self.assertEqual(server.private_ip, '10.20.30.45')
407 self.assertEqual(len(server.interfaces), 3)
408 self.assertDictEqual(server.interfaces['port_a'], expected)
410 @mock.patch('yardstick.benchmark.contexts.heat.os')
411 @mock.patch.object(heat.HeatContext, '_delete_key_file')
412 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
413 def test_undeploy(self, mock_template, mock_delete_key, *args):
414 self.test_context.stack = mock_template
415 self.test_context._name = 'foo'
416 self.test_context._task_id = '1234567890'
417 self.test_context._name_task_id = '{}-{}'.format(
418 self.test_context._name, self.test_context._task_id[:8])
419 # mock_os.path.exists.return_value = True
420 self.test_context.key_filename = 'foo/bar/foobar'
421 self.test_context.undeploy()
422 mock_delete_key.assert_called()
423 self.assertTrue(mock_template.delete.called)
425 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
426 def test_undeploy_no_teardown(self, mock_template):
427 self.test_context.stack = mock_template
428 self.test_context._name = 'foo'
429 self.test_context._task_id = '1234567890'
430 self.test_context._flags.no_teardown = True
431 self.test_context.undeploy()
433 mock_template.delete.assert_not_called()
435 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
436 @mock.patch('yardstick.benchmark.contexts.heat.os')
437 def test_undeploy_key_filename(self, mock_os, mock_template):
438 self.test_context.stack = mock_template
439 self.test_context._name = 'foo'
440 self.test_context._task_id = '1234567890'
441 self.test_context._name_task_id = '{}-{}'.format(
442 self.test_context._name, self.test_context._task_id)
443 mock_os.path.exists.return_value = True
444 self.test_context.key_filename = 'foo/bar/foobar'
445 self.assertIsNone(self.test_context.undeploy())
447 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
448 def test__get_server_found_dict(self, *args):
450 Use HeatContext._get_server to get a server that matches
451 based on a dictionary input.
453 foo2_server = mock.Mock()
454 foo2_server.key_filename = None
455 foo2_server.private_ip = '10.0.0.2'
456 foo2_server.public_ip = '127.0.0.2'
457 foo2_server.context.user = 'oof'
459 baz3_server = mock.Mock()
460 baz3_server.key_filename = None
461 baz3_server.private_ip = '10.0.0.3'
462 baz3_server.public_ip = '127.0.0.3'
463 baz3_server.context.user = 'zab'
465 self.test_context._name = 'bar'
466 self.test_context._task_id = '1234567890'
467 self.test_context._name_task_id = '{}-{}'.format(
468 self.test_context._name, self.test_context._task_id[:8])
469 self.test_context._user = 'bot'
470 self.test_context.stack = mock.Mock()
471 self.test_context.stack.outputs = {
472 'private_ip': '10.0.0.1',
473 'public_ip': '127.0.0.1',
475 self.test_context._server_map = {
481 'name': 'foo.bar-12345678',
482 'private_ip_attr': 'private_ip',
483 'public_ip_attr': 'public_ip',
485 self.test_context.key_uuid = 'foo-42'
486 result = self.test_context._get_server(attr_name)
487 self.assertEqual(result['user'], 'bot')
488 self.assertEqual(result['ip'], '127.0.0.1')
489 self.assertEqual(result['private_ip'], '10.0.0.1')
491 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
492 def test__get_server_found_dict_no_attrs(self, *args):
494 Use HeatContext._get_server to get a server that matches
495 based on a dictionary input.
497 foo2_server = mock.Mock()
498 foo2_server.private_ip = '10.0.0.2'
499 foo2_server.public_ip = '127.0.0.2'
500 foo2_server.context.user = 'oof'
502 baz3_server = mock.Mock()
503 baz3_server.private_ip = '10.0.0.3'
504 baz3_server.public_ip = '127.0.0.3'
505 baz3_server.context.user = 'zab'
507 self.test_context._name = 'bar'
508 self.test_context._task_id = '1234567890'
509 self.test_context._name_task_id = '{}-{}'.format(
510 self.test_context._name, self.test_context._task_id[:8])
511 self.test_context._user = 'bot'
512 self.test_context.stack = mock.Mock()
513 self.test_context.stack.outputs = {
514 'private_ip': '10.0.0.1',
515 'public_ip': '127.0.0.1',
517 self.test_context._server_map = {
523 'name': 'foo.bar-12345678',
526 self.test_context.key_uuid = 'foo-42'
527 result = self.test_context._get_server(attr_name)
528 self.assertEqual(result['user'], 'bot')
529 # no private ip attr mapping in the map results in None value in the result
530 self.assertIsNone(result['private_ip'])
531 # no public ip attr mapping in the map results in no value in the result
532 self.assertNotIn('ip', result)
534 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
535 def test__get_server_found_not_dict(self, *args):
537 Use HeatContext._get_server to get a server that matches
538 based on a non-dictionary input
540 foo2_server = mock.Mock()
541 foo2_server.private_ip = '10.0.0.2'
542 foo2_server.public_ip = '127.0.0.2'
543 foo2_server.context.user = 'oof'
545 baz3_server = mock.Mock()
546 baz3_server.private_ip = '10.0.0.3'
547 baz3_server.public_ip = None
548 baz3_server.context.user = 'zab'
550 self.test_context._name = 'bar1'
551 self.test_context._task_id = '1234567890'
552 self.test_context._name_task_id = 'bar1-12345678'
553 self.test_context.stack = mock.Mock()
554 self.test_context.stack.outputs = {
555 'private_ip': '10.0.0.1',
556 'public_ip': '127.0.0.1',
558 self.test_context.generate_routing_table = mock.MagicMock(return_value=[])
560 self.test_context._server_map = {
566 result = self.test_context._get_server(attr_name)
567 self.assertEqual(result['user'], 'zab')
568 self.assertEqual(result['private_ip'], '10.0.0.3')
569 # no public_ip on the server results in no value in the result
570 self.assertNotIn('public_ip', result)
572 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
573 def test__get_server_none_found_not_dict(self, *args):
575 Use HeatContext._get_server to not get a server due to
576 None value associated with the match to a non-dictionary
579 foo2_server = mock.Mock()
580 foo2_server.private_ip = '10.0.0.2'
581 foo2_server.public_ip = '127.0.0.2'
582 foo2_server.context.user = 'oof'
584 baz3_server = mock.Mock()
585 baz3_server.private_ip = '10.0.0.3'
586 baz3_server.public_ip = None
587 baz3_server.context.user = 'zab'
589 self.test_context._name = 'bar1'
590 self.test_context.stack = mock.Mock()
591 self.test_context.stack.outputs = {
592 'private_ip': '10.0.0.1',
593 'public_ip': '127.0.0.1',
595 self.test_context._server_map = {
601 self.test_context.key_uuid = 'foo-42'
603 result = self.test_context._get_server(attr_name)
604 self.assertIsNone(result)
606 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
607 def test__get_server_not_found_dict(self, *args):
609 Use HeatContext._get_server to not get a server for lack
610 of a match to a dictionary input
612 foo2_server = mock.Mock()
613 foo2_server.private_ip = '10.0.0.2'
614 foo2_server.public_ip = '127.0.0.2'
615 foo2_server.context.user = 'oof'
617 baz3_server = mock.Mock()
618 baz3_server.private_ip = '10.0.0.3'
619 baz3_server.public_ip = None
620 baz3_server.context.user = 'zab'
622 self.test_context._name = 'bar1'
623 self.test_context._task_id = '1235467890'
624 self.test_context._name_task_id = '{}-{}'.format(
625 self.test_context._name, self.test_context._task_id[:8])
626 self.test_context.stack = mock.Mock()
627 self.test_context.stack.outputs = {
628 'private_ip': '10.0.0.1',
629 'public_ip': '127.0.0.1',
631 self.test_context._server_map = {
636 self.test_context.key_uuid = 'foo-42'
639 'private_ip_attr': 'private_ip',
640 'public_ip_attr': 'public_ip',
642 result = self.test_context._get_server(attr_name)
643 self.assertIsNone(result)
645 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
646 def test__get_server_not_found_not_dict(self, *args):
648 Use HeatContext._get_server to not get a server for lack
649 of a match to a non-dictionary input
651 foo2_server = mock.Mock()
652 foo2_server.private_ip = '10.0.0.2'
653 foo2_server.public_ip = '127.0.0.2'
654 foo2_server.context.user = 'oof'
656 baz3_server = mock.Mock()
657 baz3_server.private_ip = '10.0.0.3'
658 baz3_server.public_ip = None
659 baz3_server.context.user = 'zab'
661 self.mock_context._name = 'bar1'
662 self.test_context.stack = mock.Mock()
663 self.mock_context.stack.outputs = {
664 'private_ip': '10.0.0.1',
665 'public_ip': '127.0.0.1',
667 self.mock_context._server_map = {
672 self.test_context.key_uuid = 'foo-42'
673 attr_name = 'foo.wow4'
674 result = self.test_context._get_server(attr_name)
675 self.assertIsNone(result)
677 # TODO: Split this into more granular tests
678 def test__get_network(self):
679 network1 = mock.MagicMock()
680 network1.name = 'net_1'
681 network1.vld_id = 'vld111'
682 network1.segmentation_id = 'seg54'
683 network1.network_type = 'type_a'
684 network1.physical_network = 'phys'
686 network2 = mock.MagicMock()
687 network2.name = 'net_2'
688 network2.segmentation_id = 'seg45'
689 network2.network_type = 'type_b'
690 network2.physical_network = 'virt'
692 self.test_context.networks = {
698 self.assertIsNone(self.test_context._get_network(attr_name))
701 self.assertIsNone(self.test_context._get_network(attr_name))
703 attr_name = {'network_type': 'nosuch'}
704 self.assertIsNone(self.test_context._get_network(attr_name))
707 self.assertIsNone(self.test_context._get_network(attr_name))
709 attr_name = {'segmentation_id': 'seg45'}
712 "segmentation_id": 'seg45',
713 "network_type": 'type_b',
714 "physical_network": 'virt',
716 result = self.test_context._get_network(attr_name)
717 self.assertDictEqual(result, expected)
722 "segmentation_id": 'seg54',
723 "network_type": 'type_a',
724 "physical_network": 'phys',
726 result = self.test_context._get_network(attr_name)
727 self.assertDictEqual(result, expected)