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
17 from yardstick import ssh
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.tests.unit import base as ut_base
26 LOG = logging.getLogger(__name__)
29 class HeatContextTestCase(ut_base.BaseUnitTestCase):
32 self.test_context = heat.HeatContext()
33 self.addCleanup(self._remove_contexts)
34 self.mock_context = mock.Mock(spec=heat.HeatContext())
35 self.name_iter = ('vnf{:03}'.format(x) for x in count(0, step=3))
37 def _remove_contexts(self):
38 if self.test_context in self.test_context.list:
39 self.test_context._delete_context()
41 def test___init__(self):
42 self.assertIsNone(self.test_context._name)
43 self.assertIsNone(self.test_context._task_id)
44 self.assertFalse(self.test_context._flags.no_setup)
45 self.assertFalse(self.test_context._flags.no_teardown)
46 self.assertIsNone(self.test_context.stack)
47 self.assertEqual(self.test_context.networks, OrderedDict())
48 self.assertEqual(self.test_context.servers, [])
49 self.assertEqual(self.test_context.placement_groups, [])
50 self.assertEqual(self.test_context.server_groups, [])
51 self.assertIsNone(self.test_context.keypair_name)
52 self.assertIsNone(self.test_context.secgroup_name)
53 self.assertEqual(self.test_context._server_map, {})
54 self.assertIsNone(self.test_context._image)
55 self.assertIsNone(self.test_context._flavor)
56 self.assertIsNone(self.test_context._user)
57 self.assertIsNone(self.test_context.template_file)
58 self.assertIsNone(self.test_context.heat_parameters)
59 self.assertIsNone(self.test_context.key_filename)
61 @mock.patch('yardstick.benchmark.contexts.heat.PlacementGroup')
62 @mock.patch('yardstick.benchmark.contexts.heat.ServerGroup')
63 @mock.patch('yardstick.benchmark.contexts.heat.Network')
64 @mock.patch('yardstick.benchmark.contexts.heat.Server')
65 def test_init(self, mock_server, mock_network, mock_sg, mock_pg):
67 pgs = {'pgrp1': {'policy': 'availability'}}
68 sgs = {'servergroup1': {'policy': 'affinity'}}
69 networks = {'bar': {'cidr': '10.0.1.0/24'}}
70 servers = {'baz': {'floating_ip': True, 'placement': 'pgrp1'}}
71 attrs = {'name': 'foo',
72 'task_id': '1234567890',
73 'placement_groups': pgs,
78 self.test_context.init(attrs)
80 self.assertFalse(self.test_context._flags.no_setup)
81 self.assertFalse(self.test_context._flags.no_teardown)
82 self.assertEqual(self.test_context._name, "foo")
83 self.assertEqual(self.test_context._task_id, '1234567890')
84 self.assertEqual(self.test_context.name, "foo-12345678")
85 self.assertEqual(self.test_context.keypair_name, "foo-12345678-key")
86 self.assertEqual(self.test_context.secgroup_name, "foo-12345678-secgroup")
88 mock_pg.assert_called_with('pgrp1', self.test_context,
89 pgs['pgrp1']['policy'])
90 mock_sg.assert_called_with('servergroup1', self.test_context,
91 sgs['servergroup1']['policy'])
92 self.assertEqual(len(self.test_context.placement_groups), 1)
93 self.assertEqual(len(self.test_context.server_groups), 1)
95 mock_network.assert_called_with(
96 'bar', self.test_context, networks['bar'])
97 self.assertEqual(len(self.test_context.networks), 1)
99 mock_server.assert_called_with('baz', self.test_context,
101 self.assertEqual(len(self.test_context.servers), 1)
103 def test_init_no_name_or_task_id(self):
105 self.assertRaises(KeyError, self.test_context.init, attrs)
108 self.test_context._name = 'foo'
109 self.test_context._task_id = '1234567890'
110 self.test_context._name_task_id = '{}-{}'.format(
111 self.test_context._name, self.test_context._task_id[:8])
112 self.assertEqual(self.test_context.name, 'foo-12345678')
113 self.assertEqual(self.test_context.assigned_name, 'foo')
115 def test_name_flags(self):
116 self.test_context._flags = base.Flags(
117 **{"no_setup": True, "no_teardown": True})
118 self.test_context._name = 'foo'
119 self.test_context._task_id = '1234567890'
121 self.assertEqual(self.test_context.name, 'foo')
122 self.assertEqual(self.test_context.assigned_name, 'foo')
124 def test_init_no_setup_no_teardown(self):
126 attrs = {'name': 'foo',
127 'task_id': '1234567890',
128 'placement_groups': {},
138 self.test_context.init(attrs)
139 self.assertTrue(self.test_context._flags.no_setup)
140 self.assertTrue(self.test_context._flags.no_teardown)
142 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
143 def test__add_resources_to_template_no_servers(self, mock_template):
144 self.test_context._name = 'ctx'
145 self.test_context._task_id = '1234567890'
146 self.test_context._name_task_id = '{}-{}'.format(
147 self.test_context._name, self.test_context._task_id[:8])
148 self.test_context.keypair_name = "ctx-key"
149 self.test_context.secgroup_name = "ctx-secgroup"
150 self.test_context.key_uuid = "2f2e4997-0a8e-4eb7-9fa4-f3f8fbbc393b"
151 netattrs = {'cidr': '10.0.0.0/24', 'provider': None,
152 'external_network': 'ext_net'}
154 self.test_context.networks = OrderedDict(
155 {"mynet": model.Network("mynet", self.test_context,
158 self.test_context._add_resources_to_template(mock_template)
159 mock_template.add_keypair.assert_called_with(
162 mock_template.add_security_group.assert_called_with("ctx-secgroup")
163 mock_template.add_network.assert_called_with(
164 "ctx-12345678-mynet", 'physnet1', None, None, None, None)
165 mock_template.add_router.assert_called_with(
166 "ctx-12345678-mynet-router",
167 netattrs["external_network"],
168 "ctx-12345678-mynet-subnet")
169 mock_template.add_router_interface.assert_called_with(
170 "ctx-12345678-mynet-router-if0",
171 "ctx-12345678-mynet-router",
172 "ctx-12345678-mynet-subnet")
174 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
175 def test_attrs_get(self, *args):
176 image, flavor, user = expected_tuple = 'foo1', 'foo2', 'foo3'
177 self.assertNotEqual(self.test_context.image, image)
178 self.assertNotEqual(self.test_context.flavor, flavor)
179 self.assertNotEqual(self.test_context.user, user)
180 self.test_context._image = image
181 self.test_context._flavor = flavor
182 self.test_context._user = user
183 attr_tuple = self.test_context.image, self.test_context.flavor, self.test_context.user
184 self.assertEqual(attr_tuple, expected_tuple)
186 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
187 def test_attrs_set_negative(self, *args):
188 with self.assertRaises(AttributeError):
189 self.test_context.image = 'foo'
191 with self.assertRaises(AttributeError):
192 self.test_context.flavor = 'foo'
194 with self.assertRaises(AttributeError):
195 self.test_context.user = 'foo'
197 def test__create_new_stack(self):
198 template = mock.Mock()
199 self.test_context._create_new_stack(template)
200 template.create.assert_called_once()
202 def test__create_new_stack_stack_create_failed(self):
203 template = mock.Mock()
204 template.create.side_effect = y_exc.HeatTemplateError
206 self.assertRaises(y_exc.HeatTemplateError,
207 self.test_context._create_new_stack,
210 def test__create_new_stack_keyboard_interrupt(self):
211 template = mock.Mock()
212 template.create.side_effect = KeyboardInterrupt
213 self.assertRaises(y_exc.StackCreationInterrupt,
214 self.test_context._create_new_stack,
217 @mock.patch.object(os.path, 'exists', return_value=True)
218 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
219 @mock.patch.object(heat.HeatContext, '_create_new_stack')
220 def test_deploy_stack_creation_failed(self, mock_create,
221 mock_resources_template, mock_path_exists):
222 self.test_context._name = 'foo'
223 self.test_context._task_id = '1234567890'
224 self.test_context._name_task_id = 'foo-12345678'
225 mock_create.side_effect = y_exc.HeatTemplateError
226 self.assertRaises(y_exc.HeatTemplateError,
227 self.test_context.deploy)
229 mock_path_exists.assert_called()
230 mock_resources_template.assert_called_once()
232 @mock.patch.object(os.path, 'exists', return_value=False)
233 @mock.patch.object(ssh.SSH, 'gen_keys')
234 @mock.patch.object(heat, 'HeatTemplate')
235 def test_deploy(self, mock_template, mock_genkeys, mock_path_exists):
236 self.test_context._name = 'foo'
237 self.test_context._task_id = '1234567890'
238 self.test_context._name_task_id = '{}-{}'.format(
239 self.test_context._name, self.test_context._task_id[:8])
240 self.test_context.template_file = '/bar/baz/some-heat-file'
241 self.test_context.heat_parameters = {'image': 'cirros'}
242 self.test_context.get_neutron_info = mock.MagicMock()
243 self.test_context.deploy()
245 mock_template.assert_called_with(
246 'foo-12345678', template_file='/bar/baz/some-heat-file',
247 heat_parameters={'image': 'cirros'},
248 os_cloud_config=self.test_context._flags.os_cloud_config)
249 self.assertIsNotNone(self.test_context.stack)
250 key_filename = ''.join(
251 [consts.YARDSTICK_ROOT_PATH,
252 'yardstick/resources/files/yardstick_key-',
253 self.test_context._name_task_id])
254 mock_genkeys.assert_called_once_with(key_filename)
255 mock_path_exists.assert_any_call(key_filename)
257 @mock.patch.object(heat, 'HeatTemplate')
258 @mock.patch.object(os.path, 'exists', return_value=False)
259 @mock.patch.object(ssh.SSH, 'gen_keys')
260 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack')
261 @mock.patch.object(heat.HeatContext, '_create_new_stack')
262 def test_deploy_no_setup(self, mock_create_new_stack,
263 mock_retrieve_existing_stack, mock_genkeys, mock_path_exists,
265 self.test_context._name = 'foo'
266 self.test_context._task_id = '1234567890'
267 self.test_context.template_file = '/bar/baz/some-heat-file'
268 self.test_context.heat_parameters = {'image': 'cirros'}
269 self.test_context.get_neutron_info = mock.MagicMock()
270 self.test_context._flags.no_setup = True
271 self.test_context.deploy()
273 mock_create_new_stack.assert_not_called()
274 mock_retrieve_existing_stack.assert_called_with(self.test_context.name)
275 self.assertIsNotNone(self.test_context.stack)
276 key_filename = ''.join(
277 [consts.YARDSTICK_ROOT_PATH,
278 'yardstick/resources/files/yardstick_key-',
279 self.test_context._name])
280 mock_genkeys.assert_called_once_with(key_filename)
281 mock_path_exists.assert_any_call(key_filename)
283 @mock.patch.object(heat, 'HeatTemplate')
284 @mock.patch.object(os.path, 'exists', return_value=False)
285 @mock.patch.object(ssh.SSH, 'gen_keys')
286 @mock.patch.object(heat.HeatContext, '_create_new_stack')
287 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack',
289 def test_deploy_try_retrieve_context_does_not_exist(self,
290 mock_retrieve_stack, mock_create_new_stack, mock_genkeys,
291 mock_path_exists, *args):
292 self.test_context._name = 'demo'
293 self.test_context._task_id = '1234567890'
294 self.test_context._flags.no_setup = True
295 self.test_context.template_file = '/bar/baz/some-heat-file'
296 self.test_context.get_neutron_info = mock.MagicMock()
297 self.test_context.deploy()
299 mock_retrieve_stack.assert_called_once_with(self.test_context._name)
300 mock_create_new_stack.assert_called()
301 key_filename = ''.join(
302 [consts.YARDSTICK_ROOT_PATH,
303 'yardstick/resources/files/yardstick_key-',
304 self.test_context._name])
305 mock_genkeys.assert_called_once_with(key_filename)
306 mock_path_exists.assert_any_call(key_filename)
308 @mock.patch.object(heat, 'HeatTemplate', return_value='heat_template')
309 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
310 @mock.patch.object(os.path, 'exists', return_value=False)
311 @mock.patch.object(ssh.SSH, 'gen_keys')
312 def test_deploy_ssh_key_before_adding_resources(self, mock_genkeys,
313 mock_path_exists, mock_add_resources, *args):
314 mock_manager = mock.Mock()
315 mock_manager.attach_mock(mock_add_resources,
316 '_add_resources_to_template')
317 mock_manager.attach_mock(mock_genkeys, 'gen_keys')
318 mock_manager.reset_mock()
319 self.test_context._name_task_id = 'demo-12345678'
320 self.test_context.get_neutron_info = mock.Mock()
321 with mock.patch.object(self.test_context, '_create_new_stack') as \
323 mock.patch.object(self.test_context, 'get_neutron_info') as \
325 self.test_context.deploy()
327 mock_neutron_info.assert_called_once()
328 mock_create_stack.assert_called_once()
329 key_filename = ''.join(
330 [consts.YARDSTICK_ROOT_PATH,
331 'yardstick/resources/files/yardstick_key-',
332 self.test_context._name_task_id])
333 mock_genkeys.assert_called_once_with(key_filename)
334 mock_path_exists.assert_any_call(key_filename)
336 mock_call_gen_keys = mock.call.gen_keys(key_filename)
337 mock_call_add_resources = (
338 mock.call._add_resources_to_template('heat_template'))
339 self.assertTrue(mock_manager.mock_calls.index(mock_call_gen_keys) <
340 mock_manager.mock_calls.index(mock_call_add_resources))
342 def test_check_for_context(self):
344 # check that the context exists
346 def test_add_server_port(self):
347 network1 = mock.MagicMock()
348 network2 = mock.MagicMock()
349 self.test_context._name = 'foo'
350 self.test_context._task_id = '1234567890'
351 self.test_context._name_task_id = '{}-{}'.format(
352 self.test_context._name, self.test_context._task_id[:8])
353 self.test_context.stack = mock.MagicMock()
354 self.test_context.networks = {
358 self.test_context.stack.outputs = {
359 u'b': u'10.20.30.45',
361 u'foo-12345678-a-subnet-cidr': u'10.20.0.0/15',
362 u'foo-12345678-a-subnet-gateway_ip': u'10.20.30.1',
363 u'b-mac_address': u'00:01',
364 u'b-device_id': u'dev21',
365 u'b-network_id': u'net789',
366 u'd': u'40.30.20.15',
368 u'foo-12345678-c-subnet-cidr': u'40.30.0.0/18',
369 u'foo-12345678-c-subnet-gateway_ip': u'40.30.20.254',
370 u'd-mac_address': u'00:10',
371 u'd-device_id': u'dev43',
372 u'd-network_id': u'net987',
373 u'e': u'40.30.20.15',
375 u'e-mac_address': u'00:10',
376 u'e-device_id': u'dev43',
377 u'e-network_id': u'net987',
379 server = mock.MagicMock()
380 server.private_ip = None
381 server.ports = OrderedDict([
382 ('a', [{'stack_name': 'b', 'port': 'port_a'}]),
383 ('c', [{'stack_name': 'd', 'port': 'port_c'},
384 {'stack_name': 'e', 'port': 'port_f'}]),
388 "private_ip": '10.20.30.45',
390 "subnet_cidr": '10.20.0.0/15',
391 "network": '10.20.0.0',
392 "netmask": '255.254.0.0',
394 "gateway_ip": '10.20.30.1',
395 "mac_address": '00:01',
396 "device_id": 'dev21',
397 "network_id": 'net789',
399 "local_mac": '00:01',
400 "local_ip": '10.20.30.45',
402 self.test_context.add_server_port(server)
403 self.assertEqual(server.private_ip, '10.20.30.45')
404 self.assertEqual(len(server.interfaces), 3)
405 self.assertDictEqual(server.interfaces['port_a'], expected)
407 @mock.patch('yardstick.benchmark.contexts.heat.os')
408 @mock.patch.object(heat.HeatContext, '_delete_key_file')
409 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
410 def test_undeploy(self, mock_template, mock_delete_key, *args):
411 self.test_context.stack = mock_template
412 self.test_context._name = 'foo'
413 self.test_context._task_id = '1234567890'
414 self.test_context._name_task_id = '{}-{}'.format(
415 self.test_context._name, self.test_context._task_id[:8])
416 # mock_os.path.exists.return_value = True
417 self.test_context.key_filename = 'foo/bar/foobar'
418 self.test_context.undeploy()
419 mock_delete_key.assert_called()
420 mock_template.delete.assert_called_once()
422 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
423 def test_undeploy_no_teardown(self, mock_template):
424 self.test_context.stack = mock_template
425 self.test_context._name = 'foo'
426 self.test_context._task_id = '1234567890'
427 self.test_context._flags.no_teardown = True
428 self.test_context.undeploy()
430 mock_template.delete.assert_not_called()
432 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
433 @mock.patch('yardstick.benchmark.contexts.heat.os')
434 def test_undeploy_key_filename(self, mock_os, mock_template):
435 self.test_context.stack = mock_template
436 self.test_context._name = 'foo'
437 self.test_context._task_id = '1234567890'
438 self.test_context._name_task_id = '{}-{}'.format(
439 self.test_context._name, self.test_context._task_id)
440 mock_os.path.exists.return_value = True
441 self.test_context.key_filename = 'foo/bar/foobar'
442 self.assertIsNone(self.test_context.undeploy())
444 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
445 def test__get_server_found_dict(self, *args):
447 Use HeatContext._get_server to get a server that matches
448 based on a dictionary input.
450 foo2_server = mock.Mock()
451 foo2_server.key_filename = None
452 foo2_server.private_ip = '10.0.0.2'
453 foo2_server.public_ip = '127.0.0.2'
454 foo2_server.context.user = 'oof'
456 baz3_server = mock.Mock()
457 baz3_server.key_filename = None
458 baz3_server.private_ip = '10.0.0.3'
459 baz3_server.public_ip = '127.0.0.3'
460 baz3_server.context.user = 'zab'
462 self.test_context._name = 'bar'
463 self.test_context._task_id = '1234567890'
464 self.test_context._name_task_id = '{}-{}'.format(
465 self.test_context._name, self.test_context._task_id[:8])
466 self.test_context._user = 'bot'
467 self.test_context.stack = mock.Mock()
468 self.test_context.stack.outputs = {
469 'private_ip': '10.0.0.1',
470 'public_ip': '127.0.0.1',
472 self.test_context._server_map = {
478 'name': 'foo.bar-12345678',
479 'private_ip_attr': 'private_ip',
480 'public_ip_attr': 'public_ip',
482 self.test_context.key_uuid = 'foo-42'
483 result = self.test_context._get_server(attr_name)
484 self.assertEqual(result['user'], 'bot')
485 self.assertEqual(result['ip'], '127.0.0.1')
486 self.assertEqual(result['private_ip'], '10.0.0.1')
488 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
489 def test__get_server_found_dict_no_attrs(self, *args):
491 Use HeatContext._get_server to get a server that matches
492 based on a dictionary input.
494 foo2_server = mock.Mock()
495 foo2_server.private_ip = '10.0.0.2'
496 foo2_server.public_ip = '127.0.0.2'
497 foo2_server.context.user = 'oof'
499 baz3_server = mock.Mock()
500 baz3_server.private_ip = '10.0.0.3'
501 baz3_server.public_ip = '127.0.0.3'
502 baz3_server.context.user = 'zab'
504 self.test_context._name = 'bar'
505 self.test_context._task_id = '1234567890'
506 self.test_context._name_task_id = '{}-{}'.format(
507 self.test_context._name, self.test_context._task_id[:8])
508 self.test_context._user = 'bot'
509 self.test_context.stack = mock.Mock()
510 self.test_context.stack.outputs = {
511 'private_ip': '10.0.0.1',
512 'public_ip': '127.0.0.1',
514 self.test_context._server_map = {
520 'name': 'foo.bar-12345678',
523 self.test_context.key_uuid = 'foo-42'
524 result = self.test_context._get_server(attr_name)
525 self.assertEqual(result['user'], 'bot')
526 # no private ip attr mapping in the map results in None value in the result
527 self.assertIsNone(result['private_ip'])
528 # no public ip attr mapping in the map results in no value in the result
529 self.assertNotIn('ip', result)
531 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
532 def test__get_server_found_not_dict(self, *args):
534 Use HeatContext._get_server to get a server that matches
535 based on a non-dictionary input
537 foo2_server = mock.Mock()
538 foo2_server.private_ip = '10.0.0.2'
539 foo2_server.public_ip = '127.0.0.2'
540 foo2_server.context.user = 'oof'
542 baz3_server = mock.Mock()
543 baz3_server.private_ip = '10.0.0.3'
544 baz3_server.public_ip = None
545 baz3_server.context.user = 'zab'
547 self.test_context._name = 'bar1'
548 self.test_context._task_id = '1234567890'
549 self.test_context._name_task_id = 'bar1-12345678'
550 self.test_context.stack = mock.Mock()
551 self.test_context.stack.outputs = {
552 'private_ip': '10.0.0.1',
553 'public_ip': '127.0.0.1',
555 self.test_context.generate_routing_table = mock.MagicMock(return_value=[])
557 self.test_context._server_map = {
563 result = self.test_context._get_server(attr_name)
564 self.assertEqual(result['user'], 'zab')
565 self.assertEqual(result['private_ip'], '10.0.0.3')
566 # no public_ip on the server results in no value in the result
567 self.assertNotIn('public_ip', result)
569 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
570 def test__get_server_none_found_not_dict(self, *args):
572 Use HeatContext._get_server to not get a server due to
573 None value associated with the match to a non-dictionary
576 foo2_server = mock.Mock()
577 foo2_server.private_ip = '10.0.0.2'
578 foo2_server.public_ip = '127.0.0.2'
579 foo2_server.context.user = 'oof'
581 baz3_server = mock.Mock()
582 baz3_server.private_ip = '10.0.0.3'
583 baz3_server.public_ip = None
584 baz3_server.context.user = 'zab'
586 self.test_context._name = 'bar1'
587 self.test_context.stack = mock.Mock()
588 self.test_context.stack.outputs = {
589 'private_ip': '10.0.0.1',
590 'public_ip': '127.0.0.1',
592 self.test_context._server_map = {
598 self.test_context.key_uuid = 'foo-42'
600 result = self.test_context._get_server(attr_name)
601 self.assertIsNone(result)
603 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
604 def test__get_server_not_found_dict(self, *args):
606 Use HeatContext._get_server to not get a server for lack
607 of a match to a dictionary input
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._task_id = '1235467890'
621 self.test_context._name_task_id = '{}-{}'.format(
622 self.test_context._name, self.test_context._task_id[:8])
623 self.test_context.stack = mock.Mock()
624 self.test_context.stack.outputs = {
625 'private_ip': '10.0.0.1',
626 'public_ip': '127.0.0.1',
628 self.test_context._server_map = {
633 self.test_context.key_uuid = 'foo-42'
636 'private_ip_attr': 'private_ip',
637 'public_ip_attr': 'public_ip',
639 result = self.test_context._get_server(attr_name)
640 self.assertIsNone(result)
642 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
643 def test__get_server_not_found_not_dict(self, *args):
645 Use HeatContext._get_server to not get a server for lack
646 of a match to a non-dictionary input
648 foo2_server = mock.Mock()
649 foo2_server.private_ip = '10.0.0.2'
650 foo2_server.public_ip = '127.0.0.2'
651 foo2_server.context.user = 'oof'
653 baz3_server = mock.Mock()
654 baz3_server.private_ip = '10.0.0.3'
655 baz3_server.public_ip = None
656 baz3_server.context.user = 'zab'
658 self.mock_context._name = 'bar1'
659 self.test_context.stack = mock.Mock()
660 self.mock_context.stack.outputs = {
661 'private_ip': '10.0.0.1',
662 'public_ip': '127.0.0.1',
664 self.mock_context._server_map = {
669 self.test_context.key_uuid = 'foo-42'
670 attr_name = 'foo.wow4'
671 result = self.test_context._get_server(attr_name)
672 self.assertIsNone(result)
674 # TODO: Split this into more granular tests
675 def test__get_network(self):
676 network1 = mock.MagicMock()
677 network1.name = 'net_1'
678 network1.vld_id = 'vld111'
679 network1.segmentation_id = 'seg54'
680 network1.network_type = 'type_a'
681 network1.physical_network = 'phys'
683 network2 = mock.MagicMock()
684 network2.name = 'net_2'
685 network2.segmentation_id = 'seg45'
686 network2.network_type = 'type_b'
687 network2.physical_network = 'virt'
689 self.test_context.networks = {
695 self.assertIsNone(self.test_context._get_network(attr_name))
698 self.assertIsNone(self.test_context._get_network(attr_name))
700 attr_name = {'network_type': 'nosuch'}
701 self.assertIsNone(self.test_context._get_network(attr_name))
704 self.assertIsNone(self.test_context._get_network(attr_name))
706 attr_name = {'segmentation_id': 'seg45'}
709 "segmentation_id": 'seg45',
710 "network_type": 'type_b',
711 "physical_network": 'virt',
713 result = self.test_context._get_network(attr_name)
714 self.assertDictEqual(result, expected)
719 "segmentation_id": 'seg54',
720 "network_type": 'type_a',
721 "physical_network": 'phys',
723 result = self.test_context._get_network(attr_name)
724 self.assertDictEqual(result, expected)