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()
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_any_call(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_any_call(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()
299 self.test_context.deploy()
301 mock_retrieve_stack.assert_called_once_with(self.test_context._name)
302 mock_create_new_stack.assert_called()
303 key_filename = ''.join(
304 [consts.YARDSTICK_ROOT_PATH,
305 'yardstick/resources/files/yardstick_key-',
306 self.test_context._name])
307 mock_genkeys.assert_called_once_with(key_filename)
308 mock_path_exists.assert_any_call(key_filename)
310 @mock.patch.object(heat, 'HeatTemplate', return_value='heat_template')
311 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
312 @mock.patch.object(os.path, 'exists', return_value=False)
313 @mock.patch.object(ssh.SSH, 'gen_keys')
314 def test_deploy_ssh_key_before_adding_resources(self, mock_genkeys,
315 mock_path_exists, mock_add_resources, *args):
316 mock_manager = mock.Mock()
317 mock_manager.attach_mock(mock_add_resources,
318 '_add_resources_to_template')
319 mock_manager.attach_mock(mock_genkeys, 'gen_keys')
320 mock_manager.reset_mock()
321 self.test_context._name_task_id = 'demo-12345678'
322 self.test_context.get_neutron_info = mock.Mock()
323 with mock.patch.object(self.test_context, '_create_new_stack') as \
325 mock.patch.object(self.test_context, 'get_neutron_info') as \
327 self.test_context.deploy()
329 mock_neutron_info.assert_called_once()
330 mock_create_stack.assert_called_once()
331 key_filename = ''.join(
332 [consts.YARDSTICK_ROOT_PATH,
333 'yardstick/resources/files/yardstick_key-',
334 self.test_context._name_task_id])
335 mock_genkeys.assert_called_once_with(key_filename)
336 mock_path_exists.assert_any_call(key_filename)
338 mock_call_gen_keys = mock.call.gen_keys(key_filename)
339 mock_call_add_resources = (
340 mock.call._add_resources_to_template('heat_template'))
341 self.assertTrue(mock_manager.mock_calls.index(mock_call_gen_keys) <
342 mock_manager.mock_calls.index(mock_call_add_resources))
344 def test_check_for_context(self):
346 # check that the context exists
348 def test_add_server_port(self):
349 network1 = mock.MagicMock()
350 network2 = mock.MagicMock()
351 self.test_context._name = 'foo'
352 self.test_context._task_id = '1234567890'
353 self.test_context._name_task_id = '{}-{}'.format(
354 self.test_context._name, self.test_context._task_id[:8])
355 self.test_context.stack = mock.MagicMock()
356 self.test_context.networks = {
360 self.test_context.stack.outputs = {
361 u'b': u'10.20.30.45',
363 u'foo-12345678-a-subnet-cidr': u'10.20.0.0/15',
364 u'foo-12345678-a-subnet-gateway_ip': u'10.20.30.1',
365 u'b-mac_address': u'00:01',
366 u'b-device_id': u'dev21',
367 u'b-network_id': u'net789',
368 u'd': u'40.30.20.15',
370 u'foo-12345678-c-subnet-cidr': u'40.30.0.0/18',
371 u'foo-12345678-c-subnet-gateway_ip': u'40.30.20.254',
372 u'd-mac_address': u'00:10',
373 u'd-device_id': u'dev43',
374 u'd-network_id': u'net987',
375 u'e': u'40.30.20.15',
377 u'e-mac_address': u'00:10',
378 u'e-device_id': u'dev43',
379 u'e-network_id': u'net987',
381 server = mock.MagicMock()
382 server.private_ip = None
383 server.ports = OrderedDict([
384 ('a', [{'stack_name': 'b', 'port': 'port_a'}]),
385 ('c', [{'stack_name': 'd', 'port': 'port_c'},
386 {'stack_name': 'e', 'port': 'port_f'}]),
390 "private_ip": '10.20.30.45',
392 "subnet_cidr": '10.20.0.0/15',
393 "network": '10.20.0.0',
394 "netmask": '255.254.0.0',
396 "gateway_ip": '10.20.30.1',
397 "mac_address": '00:01',
398 "device_id": 'dev21',
399 "network_id": 'net789',
401 "local_mac": '00:01',
402 "local_ip": '10.20.30.45',
404 self.test_context.add_server_port(server)
405 self.assertEqual(server.private_ip, '10.20.30.45')
406 self.assertEqual(len(server.interfaces), 3)
407 self.assertDictEqual(server.interfaces['port_a'], expected)
409 @mock.patch('yardstick.benchmark.contexts.heat.os')
410 @mock.patch.object(heat.HeatContext, '_delete_key_file')
411 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
412 def test_undeploy(self, mock_template, mock_delete_key, *args):
413 self.test_context.stack = mock_template
414 self.test_context._name = 'foo'
415 self.test_context._task_id = '1234567890'
416 self.test_context._name_task_id = '{}-{}'.format(
417 self.test_context._name, self.test_context._task_id[:8])
418 # mock_os.path.exists.return_value = True
419 self.test_context.key_filename = 'foo/bar/foobar'
420 self.test_context.undeploy()
421 mock_delete_key.assert_called()
422 mock_template.delete.assert_called_once()
424 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
425 def test_undeploy_no_teardown(self, mock_template):
426 self.test_context.stack = mock_template
427 self.test_context._name = 'foo'
428 self.test_context._task_id = '1234567890'
429 self.test_context._flags.no_teardown = True
430 self.test_context.undeploy()
432 mock_template.delete.assert_not_called()
434 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
435 @mock.patch('yardstick.benchmark.contexts.heat.os')
436 def test_undeploy_key_filename(self, mock_os, mock_template):
437 self.test_context.stack = mock_template
438 self.test_context._name = 'foo'
439 self.test_context._task_id = '1234567890'
440 self.test_context._name_task_id = '{}-{}'.format(
441 self.test_context._name, self.test_context._task_id)
442 mock_os.path.exists.return_value = True
443 self.test_context.key_filename = 'foo/bar/foobar'
444 self.assertIsNone(self.test_context.undeploy())
446 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
447 def test__get_server_found_dict(self, *args):
449 Use HeatContext._get_server to get a server that matches
450 based on a dictionary input.
452 foo2_server = mock.Mock()
453 foo2_server.key_filename = None
454 foo2_server.private_ip = '10.0.0.2'
455 foo2_server.public_ip = '127.0.0.2'
456 foo2_server.context.user = 'oof'
458 baz3_server = mock.Mock()
459 baz3_server.key_filename = None
460 baz3_server.private_ip = '10.0.0.3'
461 baz3_server.public_ip = '127.0.0.3'
462 baz3_server.context.user = 'zab'
464 self.test_context._name = 'bar'
465 self.test_context._task_id = '1234567890'
466 self.test_context._name_task_id = '{}-{}'.format(
467 self.test_context._name, self.test_context._task_id[:8])
468 self.test_context._user = 'bot'
469 self.test_context.stack = mock.Mock()
470 self.test_context.stack.outputs = {
471 'private_ip': '10.0.0.1',
472 'public_ip': '127.0.0.1',
474 self.test_context._server_map = {
480 'name': 'foo.bar-12345678',
481 'private_ip_attr': 'private_ip',
482 'public_ip_attr': 'public_ip',
484 self.test_context.key_uuid = 'foo-42'
485 result = self.test_context._get_server(attr_name)
486 self.assertEqual(result['user'], 'bot')
487 self.assertEqual(result['ip'], '127.0.0.1')
488 self.assertEqual(result['private_ip'], '10.0.0.1')
490 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
491 def test__get_server_found_dict_no_attrs(self, *args):
493 Use HeatContext._get_server to get a server that matches
494 based on a dictionary input.
496 foo2_server = mock.Mock()
497 foo2_server.private_ip = '10.0.0.2'
498 foo2_server.public_ip = '127.0.0.2'
499 foo2_server.context.user = 'oof'
501 baz3_server = mock.Mock()
502 baz3_server.private_ip = '10.0.0.3'
503 baz3_server.public_ip = '127.0.0.3'
504 baz3_server.context.user = 'zab'
506 self.test_context._name = 'bar'
507 self.test_context._task_id = '1234567890'
508 self.test_context._name_task_id = '{}-{}'.format(
509 self.test_context._name, self.test_context._task_id[:8])
510 self.test_context._user = 'bot'
511 self.test_context.stack = mock.Mock()
512 self.test_context.stack.outputs = {
513 'private_ip': '10.0.0.1',
514 'public_ip': '127.0.0.1',
516 self.test_context._server_map = {
522 'name': 'foo.bar-12345678',
525 self.test_context.key_uuid = 'foo-42'
526 result = self.test_context._get_server(attr_name)
527 self.assertEqual(result['user'], 'bot')
528 # no private ip attr mapping in the map results in None value in the result
529 self.assertIsNone(result['private_ip'])
530 # no public ip attr mapping in the map results in no value in the result
531 self.assertNotIn('ip', result)
533 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
534 def test__get_server_found_not_dict(self, *args):
536 Use HeatContext._get_server to get a server that matches
537 based on a non-dictionary input
539 foo2_server = mock.Mock()
540 foo2_server.private_ip = '10.0.0.2'
541 foo2_server.public_ip = '127.0.0.2'
542 foo2_server.context.user = 'oof'
544 baz3_server = mock.Mock()
545 baz3_server.private_ip = '10.0.0.3'
546 baz3_server.public_ip = None
547 baz3_server.context.user = 'zab'
549 self.test_context._name = 'bar1'
550 self.test_context._task_id = '1234567890'
551 self.test_context._name_task_id = 'bar1-12345678'
552 self.test_context.stack = mock.Mock()
553 self.test_context.stack.outputs = {
554 'private_ip': '10.0.0.1',
555 'public_ip': '127.0.0.1',
557 self.test_context.generate_routing_table = mock.MagicMock(return_value=[])
559 self.test_context._server_map = {
565 result = self.test_context._get_server(attr_name)
566 self.assertEqual(result['user'], 'zab')
567 self.assertEqual(result['private_ip'], '10.0.0.3')
568 # no public_ip on the server results in no value in the result
569 self.assertNotIn('public_ip', result)
571 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
572 def test__get_server_none_found_not_dict(self, *args):
574 Use HeatContext._get_server to not get a server due to
575 None value associated with the match to a non-dictionary
578 foo2_server = mock.Mock()
579 foo2_server.private_ip = '10.0.0.2'
580 foo2_server.public_ip = '127.0.0.2'
581 foo2_server.context.user = 'oof'
583 baz3_server = mock.Mock()
584 baz3_server.private_ip = '10.0.0.3'
585 baz3_server.public_ip = None
586 baz3_server.context.user = 'zab'
588 self.test_context._name = 'bar1'
589 self.test_context.stack = mock.Mock()
590 self.test_context.stack.outputs = {
591 'private_ip': '10.0.0.1',
592 'public_ip': '127.0.0.1',
594 self.test_context._server_map = {
600 self.test_context.key_uuid = 'foo-42'
602 result = self.test_context._get_server(attr_name)
603 self.assertIsNone(result)
605 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
606 def test__get_server_not_found_dict(self, *args):
608 Use HeatContext._get_server to not get a server for lack
609 of a match to a dictionary input
611 foo2_server = mock.Mock()
612 foo2_server.private_ip = '10.0.0.2'
613 foo2_server.public_ip = '127.0.0.2'
614 foo2_server.context.user = 'oof'
616 baz3_server = mock.Mock()
617 baz3_server.private_ip = '10.0.0.3'
618 baz3_server.public_ip = None
619 baz3_server.context.user = 'zab'
621 self.test_context._name = 'bar1'
622 self.test_context._task_id = '1235467890'
623 self.test_context._name_task_id = '{}-{}'.format(
624 self.test_context._name, self.test_context._task_id[:8])
625 self.test_context.stack = mock.Mock()
626 self.test_context.stack.outputs = {
627 'private_ip': '10.0.0.1',
628 'public_ip': '127.0.0.1',
630 self.test_context._server_map = {
635 self.test_context.key_uuid = 'foo-42'
638 'private_ip_attr': 'private_ip',
639 'public_ip_attr': 'public_ip',
641 result = self.test_context._get_server(attr_name)
642 self.assertIsNone(result)
644 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
645 def test__get_server_not_found_not_dict(self, *args):
647 Use HeatContext._get_server to not get a server for lack
648 of a match to a non-dictionary input
650 foo2_server = mock.Mock()
651 foo2_server.private_ip = '10.0.0.2'
652 foo2_server.public_ip = '127.0.0.2'
653 foo2_server.context.user = 'oof'
655 baz3_server = mock.Mock()
656 baz3_server.private_ip = '10.0.0.3'
657 baz3_server.public_ip = None
658 baz3_server.context.user = 'zab'
660 self.mock_context._name = 'bar1'
661 self.test_context.stack = mock.Mock()
662 self.mock_context.stack.outputs = {
663 'private_ip': '10.0.0.1',
664 'public_ip': '127.0.0.1',
666 self.mock_context._server_map = {
671 self.test_context.key_uuid = 'foo-42'
672 attr_name = 'foo.wow4'
673 result = self.test_context._get_server(attr_name)
674 self.assertIsNone(result)
676 # TODO: Split this into more granular tests
677 def test__get_network(self):
678 network1 = mock.MagicMock()
679 network1.name = 'net_1'
680 network1.vld_id = 'vld111'
681 network1.segmentation_id = 'seg54'
682 network1.network_type = 'type_a'
683 network1.physical_network = 'phys'
685 network2 = mock.MagicMock()
686 network2.name = 'net_2'
687 network2.segmentation_id = 'seg45'
688 network2.network_type = 'type_b'
689 network2.physical_network = 'virt'
691 self.test_context.networks = {
697 self.assertIsNone(self.test_context._get_network(attr_name))
700 self.assertIsNone(self.test_context._get_network(attr_name))
702 attr_name = {'network_type': 'nosuch'}
703 self.assertIsNone(self.test_context._get_network(attr_name))
706 self.assertIsNone(self.test_context._get_network(attr_name))
708 attr_name = {'segmentation_id': 'seg45'}
711 "segmentation_id": 'seg45',
712 "network_type": 'type_b',
713 "physical_network": 'virt',
715 result = self.test_context._get_network(attr_name)
716 self.assertDictEqual(result, expected)
721 "segmentation_id": 'seg54',
722 "network_type": 'type_a',
723 "physical_network": 'phys',
725 result = self.test_context._get_network(attr_name)
726 self.assertDictEqual(result, expected)