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
16 from yardstick import ssh
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.tests.unit import base as ut_base
25 LOG = logging.getLogger(__name__)
28 class HeatContextTestCase(ut_base.BaseUnitTestCase):
31 self.test_context = heat.HeatContext()
32 self.addCleanup(self._remove_contexts)
35 def _remove_contexts():
36 for context in base.Context.list:
37 context._delete_context()
38 base.Context.list = []
40 def test___init__(self):
41 self.assertIsNone(self.test_context._name)
42 self.assertIsNone(self.test_context._task_id)
43 self.assertFalse(self.test_context._flags.no_setup)
44 self.assertFalse(self.test_context._flags.no_teardown)
45 self.assertIsNone(self.test_context.stack)
46 self.assertEqual(self.test_context.networks, OrderedDict())
47 self.assertEqual(self.test_context.servers, [])
48 self.assertEqual(self.test_context.placement_groups, [])
49 self.assertEqual(self.test_context.server_groups, [])
50 self.assertIsNone(self.test_context.keypair_name)
51 self.assertIsNone(self.test_context.secgroup_name)
52 self.assertEqual(self.test_context._server_map, {})
53 self.assertIsNone(self.test_context._image)
54 self.assertIsNone(self.test_context._flavor)
55 self.assertIsNone(self.test_context._user)
56 self.assertIsNone(self.test_context.template_file)
57 self.assertIsNone(self.test_context.heat_parameters)
58 self.assertIsNone(self.test_context.key_filename)
60 @mock.patch('yardstick.benchmark.contexts.heat.PlacementGroup')
61 @mock.patch('yardstick.benchmark.contexts.heat.ServerGroup')
62 @mock.patch('yardstick.benchmark.contexts.heat.Network')
63 @mock.patch('yardstick.benchmark.contexts.heat.Server')
64 def test_init(self, mock_server, mock_network, mock_sg, mock_pg):
66 pgs = {'pgrp1': {'policy': 'availability'}}
67 sgs = {'servergroup1': {'policy': 'affinity'}}
68 networks = {'bar': {'cidr': '10.0.1.0/24'}}
69 servers = {'baz': {'floating_ip': True, 'placement': 'pgrp1'}}
70 attrs = {'name': 'foo',
71 'task_id': '1234567890',
72 'placement_groups': pgs,
77 self.test_context.init(attrs)
79 self.assertFalse(self.test_context._flags.no_setup)
80 self.assertFalse(self.test_context._flags.no_teardown)
81 self.assertEqual(self.test_context._name, "foo")
82 self.assertEqual(self.test_context._task_id, '1234567890')
83 self.assertEqual(self.test_context.name, "foo-12345678")
84 self.assertEqual(self.test_context.keypair_name, "foo-12345678-key")
85 self.assertEqual(self.test_context.secgroup_name, "foo-12345678-secgroup")
87 mock_pg.assert_called_with('pgrp1', self.test_context,
88 pgs['pgrp1']['policy'])
89 mock_sg.assert_called_with('servergroup1', self.test_context,
90 sgs['servergroup1']['policy'])
91 self.assertEqual(len(self.test_context.placement_groups), 1)
92 self.assertEqual(len(self.test_context.server_groups), 1)
94 mock_network.assert_called_with(
95 'bar', self.test_context, networks['bar'])
96 self.assertEqual(len(self.test_context.networks), 1)
98 mock_server.assert_called_with('baz', self.test_context,
100 self.assertEqual(len(self.test_context.servers), 1)
102 def test_init_no_name_or_task_id(self):
104 self.assertRaises(KeyError, self.test_context.init, attrs)
107 self.test_context._name = 'foo'
108 self.test_context._task_id = '1234567890'
109 self.test_context._name_task_id = '{}-{}'.format(
110 self.test_context._name, self.test_context._task_id[:8])
111 self.assertEqual(self.test_context.name, 'foo-12345678')
112 self.assertEqual(self.test_context.assigned_name, 'foo')
114 def test_name_flags(self):
115 self.test_context._flags = base.Flags(
116 **{"no_setup": True, "no_teardown": True})
117 self.test_context._name = 'foo'
118 self.test_context._task_id = '1234567890'
120 self.assertEqual(self.test_context.name, 'foo')
121 self.assertEqual(self.test_context.assigned_name, 'foo')
123 def test_init_no_setup_no_teardown(self):
125 attrs = {'name': 'foo',
126 'task_id': '1234567890',
127 'placement_groups': {},
137 self.test_context.init(attrs)
138 self.assertTrue(self.test_context._flags.no_setup)
139 self.assertTrue(self.test_context._flags.no_teardown)
141 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
142 def test__add_resources_to_template_no_servers(self, mock_template):
143 self.test_context._name = 'ctx'
144 self.test_context._task_id = '1234567890'
145 self.test_context._name_task_id = '{}-{}'.format(
146 self.test_context._name, self.test_context._task_id[:8])
147 self.test_context.keypair_name = "ctx-key"
148 self.test_context.secgroup_name = "ctx-secgroup"
149 self.test_context.key_uuid = "2f2e4997-0a8e-4eb7-9fa4-f3f8fbbc393b"
150 netattrs = {'cidr': '10.0.0.0/24', 'provider': None,
151 'external_network': 'ext_net'}
153 self.test_context.networks = OrderedDict(
154 {"mynet": model.Network("mynet", self.test_context,
157 self.test_context._add_resources_to_template(mock_template)
158 mock_template.add_keypair.assert_called_with(
161 mock_template.add_security_group.assert_called_with("ctx-secgroup")
162 mock_template.add_network.assert_called_with(
163 "ctx-12345678-mynet", 'physnet1', None, None, None, None)
164 mock_template.add_router.assert_called_with(
165 "ctx-12345678-mynet-router",
166 netattrs["external_network"],
167 "ctx-12345678-mynet-subnet")
168 mock_template.add_router_interface.assert_called_with(
169 "ctx-12345678-mynet-router-if0",
170 "ctx-12345678-mynet-router",
171 "ctx-12345678-mynet-subnet")
173 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
174 def test_attrs_get(self, *args):
175 image, flavor, user = expected_tuple = 'foo1', 'foo2', 'foo3'
176 self.assertNotEqual(self.test_context.image, image)
177 self.assertNotEqual(self.test_context.flavor, flavor)
178 self.assertNotEqual(self.test_context.user, user)
179 self.test_context._image = image
180 self.test_context._flavor = flavor
181 self.test_context._user = user
182 attr_tuple = self.test_context.image, self.test_context.flavor, self.test_context.user
183 self.assertEqual(attr_tuple, expected_tuple)
185 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
186 def test_attrs_set_negative(self, *args):
187 with self.assertRaises(AttributeError):
188 self.test_context.image = 'foo'
190 with self.assertRaises(AttributeError):
191 self.test_context.flavor = 'foo'
193 with self.assertRaises(AttributeError):
194 self.test_context.user = 'foo'
196 def test__create_new_stack(self):
197 template = mock.Mock()
198 self.test_context._create_new_stack(template)
199 template.create.assert_called_once()
201 def test__create_new_stack_stack_create_failed(self):
202 template = mock.Mock()
203 template.create.side_effect = y_exc.HeatTemplateError
205 self.assertRaises(y_exc.HeatTemplateError,
206 self.test_context._create_new_stack,
209 def test__create_new_stack_keyboard_interrupt(self):
210 template = mock.Mock()
211 template.create.side_effect = KeyboardInterrupt
212 self.assertRaises(y_exc.StackCreationInterrupt,
213 self.test_context._create_new_stack,
216 @mock.patch.object(os.path, 'exists', return_value=True)
217 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
218 @mock.patch.object(heat.HeatContext, '_create_new_stack')
219 def test_deploy_stack_creation_failed(self, mock_create,
220 mock_resources_template, mock_path_exists):
221 self.test_context._name = 'foo'
222 self.test_context._task_id = '1234567890'
223 self.test_context._name_task_id = 'foo-12345678'
224 mock_create.side_effect = y_exc.HeatTemplateError
225 self.assertRaises(y_exc.HeatTemplateError,
226 self.test_context.deploy)
228 mock_path_exists.assert_called()
229 mock_resources_template.assert_called_once()
231 @mock.patch.object(os.path, 'exists', return_value=False)
232 @mock.patch.object(ssh.SSH, 'gen_keys')
233 @mock.patch.object(heat, 'HeatTemplate')
234 def test_deploy(self, mock_template, mock_genkeys, mock_path_exists):
235 self.test_context._name = 'foo'
236 self.test_context._task_id = '1234567890'
237 self.test_context._name_task_id = '{}-{}'.format(
238 self.test_context._name, self.test_context._task_id[:8])
239 self.test_context.template_file = '/bar/baz/some-heat-file'
240 self.test_context.heat_parameters = {'image': 'cirros'}
241 self.test_context.get_neutron_info = mock.MagicMock()
242 self.test_context.deploy()
244 mock_template.assert_called_with(
245 'foo-12345678', template_file='/bar/baz/some-heat-file',
246 heat_parameters={'image': 'cirros'},
247 os_cloud_config=self.test_context._flags.os_cloud_config)
248 self.assertIsNotNone(self.test_context.stack)
249 key_filename = ''.join(
250 [consts.YARDSTICK_ROOT_PATH,
251 'yardstick/resources/files/yardstick_key-',
252 self.test_context._name_task_id])
253 mock_genkeys.assert_called_once_with(key_filename)
254 mock_path_exists.assert_any_call(key_filename)
256 @mock.patch.object(heat, 'HeatTemplate')
257 @mock.patch.object(os.path, 'exists', return_value=False)
258 @mock.patch.object(ssh.SSH, 'gen_keys')
259 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack')
260 @mock.patch.object(heat.HeatContext, '_create_new_stack')
261 def test_deploy_no_setup(self, mock_create_new_stack,
262 mock_retrieve_existing_stack, mock_genkeys, mock_path_exists,
264 self.test_context._name = 'foo'
265 self.test_context._task_id = '1234567890'
266 self.test_context.template_file = '/bar/baz/some-heat-file'
267 self.test_context.heat_parameters = {'image': 'cirros'}
268 self.test_context.get_neutron_info = mock.MagicMock()
269 self.test_context._flags.no_setup = True
270 self.test_context.deploy()
272 mock_create_new_stack.assert_not_called()
273 mock_retrieve_existing_stack.assert_called_with(self.test_context.name)
274 self.assertIsNotNone(self.test_context.stack)
275 key_filename = ''.join(
276 [consts.YARDSTICK_ROOT_PATH,
277 'yardstick/resources/files/yardstick_key-',
278 self.test_context._name])
279 mock_genkeys.assert_called_once_with(key_filename)
280 mock_path_exists.assert_any_call(key_filename)
282 @mock.patch.object(heat, 'HeatTemplate')
283 @mock.patch.object(os.path, 'exists', return_value=False)
284 @mock.patch.object(ssh.SSH, 'gen_keys')
285 @mock.patch.object(heat.HeatContext, '_create_new_stack')
286 @mock.patch.object(heat.HeatContext, '_retrieve_existing_stack',
288 def test_deploy_try_retrieve_context_does_not_exist(self,
289 mock_retrieve_stack, mock_create_new_stack, mock_genkeys,
290 mock_path_exists, *args):
291 self.test_context._name = 'demo'
292 self.test_context._task_id = '1234567890'
293 self.test_context._flags.no_setup = True
294 self.test_context.template_file = '/bar/baz/some-heat-file'
295 self.test_context.get_neutron_info = mock.MagicMock()
296 self.test_context.deploy()
298 mock_retrieve_stack.assert_called_once_with(self.test_context._name)
299 mock_create_new_stack.assert_called()
300 key_filename = ''.join(
301 [consts.YARDSTICK_ROOT_PATH,
302 'yardstick/resources/files/yardstick_key-',
303 self.test_context._name])
304 mock_genkeys.assert_called_once_with(key_filename)
305 mock_path_exists.assert_any_call(key_filename)
307 @mock.patch.object(heat, 'HeatTemplate', return_value='heat_template')
308 @mock.patch.object(heat.HeatContext, '_add_resources_to_template')
309 @mock.patch.object(os.path, 'exists', return_value=False)
310 @mock.patch.object(ssh.SSH, 'gen_keys')
311 def test_deploy_ssh_key_before_adding_resources(self, mock_genkeys,
312 mock_path_exists, mock_add_resources, *args):
313 mock_manager = mock.Mock()
314 mock_manager.attach_mock(mock_add_resources,
315 '_add_resources_to_template')
316 mock_manager.attach_mock(mock_genkeys, 'gen_keys')
317 mock_manager.reset_mock()
318 self.test_context._name_task_id = 'demo-12345678'
319 self.test_context.get_neutron_info = mock.Mock()
320 with mock.patch.object(self.test_context, '_create_new_stack') as \
322 mock.patch.object(self.test_context, 'get_neutron_info') as \
324 self.test_context.deploy()
326 mock_neutron_info.assert_called_once()
327 mock_create_stack.assert_called_once()
328 key_filename = ''.join(
329 [consts.YARDSTICK_ROOT_PATH,
330 'yardstick/resources/files/yardstick_key-',
331 self.test_context._name_task_id])
332 mock_genkeys.assert_called_once_with(key_filename)
333 mock_path_exists.assert_any_call(key_filename)
335 mock_call_gen_keys = mock.call.gen_keys(key_filename)
336 mock_call_add_resources = (
337 mock.call._add_resources_to_template('heat_template'))
338 self.assertTrue(mock_manager.mock_calls.index(mock_call_gen_keys) <
339 mock_manager.mock_calls.index(mock_call_add_resources))
341 def test_check_for_context(self):
343 # check that the context exists
345 def test_add_server_port(self):
346 network1 = mock.MagicMock()
347 network2 = mock.MagicMock()
348 self.test_context._name = 'foo'
349 self.test_context._task_id = '1234567890'
350 self.test_context._name_task_id = '{}-{}'.format(
351 self.test_context._name, self.test_context._task_id[:8])
352 self.test_context.stack = mock.MagicMock()
353 self.test_context.networks = {
357 self.test_context.stack.outputs = {
358 u'b': u'10.20.30.45',
360 u'foo-12345678-a-subnet-cidr': u'10.20.0.0/15',
361 u'foo-12345678-a-subnet-gateway_ip': u'10.20.30.1',
362 u'b-mac_address': u'00:01',
363 u'b-device_id': u'dev21',
364 u'b-network_id': u'net789',
365 u'd': u'40.30.20.15',
367 u'foo-12345678-c-subnet-cidr': u'40.30.0.0/18',
368 u'foo-12345678-c-subnet-gateway_ip': u'40.30.20.254',
369 u'd-mac_address': u'00:10',
370 u'd-device_id': u'dev43',
371 u'd-network_id': u'net987',
372 u'e': u'40.30.20.15',
374 u'e-mac_address': u'00:10',
375 u'e-device_id': u'dev43',
376 u'e-network_id': u'net987',
378 server = mock.MagicMock()
379 server.private_ip = None
380 server.ports = OrderedDict([
381 ('a', [{'stack_name': 'b', 'port': 'port_a'}]),
382 ('c', [{'stack_name': 'd', 'port': 'port_c'},
383 {'stack_name': 'e', 'port': 'port_f'}]),
387 "private_ip": '10.20.30.45',
389 "subnet_cidr": '10.20.0.0/15',
390 "network": '10.20.0.0',
391 "netmask": '255.254.0.0',
393 "gateway_ip": '10.20.30.1',
394 "mac_address": '00:01',
395 "device_id": 'dev21',
396 "network_id": 'net789',
398 "local_mac": '00:01',
399 "local_ip": '10.20.30.45',
401 self.test_context.add_server_port(server)
402 self.assertEqual(server.private_ip, '10.20.30.45')
403 self.assertEqual(len(server.interfaces), 3)
404 self.assertDictEqual(server.interfaces['port_a'], expected)
406 @mock.patch('yardstick.benchmark.contexts.heat.os')
407 @mock.patch.object(heat.HeatContext, '_delete_key_file')
408 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
409 def test_undeploy(self, mock_template, mock_delete_key, *args):
410 self.test_context.stack = mock_template
411 self.test_context._name = 'foo'
412 self.test_context._task_id = '1234567890'
413 self.test_context._name_task_id = '{}-{}'.format(
414 self.test_context._name, self.test_context._task_id[:8])
415 # mock_os.path.exists.return_value = True
416 self.test_context.key_filename = 'foo/bar/foobar'
417 self.test_context.undeploy()
418 mock_delete_key.assert_called()
419 mock_template.delete.assert_called_once()
421 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
422 def test_undeploy_no_teardown(self, mock_template):
423 self.test_context.stack = mock_template
424 self.test_context._name = 'foo'
425 self.test_context._task_id = '1234567890'
426 self.test_context._flags.no_teardown = True
427 self.test_context.undeploy()
429 mock_template.delete.assert_not_called()
431 @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
432 @mock.patch('yardstick.benchmark.contexts.heat.os')
433 def test_undeploy_key_filename(self, mock_os, mock_template):
434 self.test_context.stack = mock_template
435 self.test_context._name = 'foo'
436 self.test_context._task_id = '1234567890'
437 self.test_context._name_task_id = '{}-{}'.format(
438 self.test_context._name, self.test_context._task_id)
439 mock_os.path.exists.return_value = True
440 self.test_context.key_filename = 'foo/bar/foobar'
441 self.assertIsNone(self.test_context.undeploy())
443 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
444 def test__get_server_found_dict(self, *args):
446 Use HeatContext._get_server to get a server that matches
447 based on a dictionary input.
449 foo2_server = mock.Mock()
450 foo2_server.key_filename = None
451 foo2_server.private_ip = '10.0.0.2'
452 foo2_server.public_ip = '127.0.0.2'
453 foo2_server.context.user = 'oof'
455 baz3_server = mock.Mock()
456 baz3_server.key_filename = None
457 baz3_server.private_ip = '10.0.0.3'
458 baz3_server.public_ip = '127.0.0.3'
459 baz3_server.context.user = 'zab'
461 self.test_context._name = 'bar'
462 self.test_context._task_id = '1234567890'
463 self.test_context._name_task_id = '{}-{}'.format(
464 self.test_context._name, self.test_context._task_id[:8])
465 self.test_context._user = 'bot'
466 self.test_context.stack = mock.Mock()
467 self.test_context.stack.outputs = {
468 'private_ip': '10.0.0.1',
469 'public_ip': '127.0.0.1',
471 self.test_context._server_map = {
477 'name': 'foo.bar-12345678',
478 'private_ip_attr': 'private_ip',
479 'public_ip_attr': 'public_ip',
481 self.test_context.key_uuid = 'foo-42'
482 result = self.test_context._get_server(attr_name)
483 self.assertEqual(result['user'], 'bot')
484 self.assertEqual(result['ip'], '127.0.0.1')
485 self.assertEqual(result['private_ip'], '10.0.0.1')
487 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
488 def test__get_server_found_dict_no_attrs(self, *args):
490 Use HeatContext._get_server to get a server that matches
491 based on a dictionary input.
493 foo2_server = mock.Mock()
494 foo2_server.private_ip = '10.0.0.2'
495 foo2_server.public_ip = '127.0.0.2'
496 foo2_server.context.user = 'oof'
498 baz3_server = mock.Mock()
499 baz3_server.private_ip = '10.0.0.3'
500 baz3_server.public_ip = '127.0.0.3'
501 baz3_server.context.user = 'zab'
503 self.test_context._name = 'bar'
504 self.test_context._task_id = '1234567890'
505 self.test_context._name_task_id = '{}-{}'.format(
506 self.test_context._name, self.test_context._task_id[:8])
507 self.test_context._user = 'bot'
508 self.test_context.stack = mock.Mock()
509 self.test_context.stack.outputs = {
510 'private_ip': '10.0.0.1',
511 'public_ip': '127.0.0.1',
513 self.test_context._server_map = {
519 'name': 'foo.bar-12345678',
522 self.test_context.key_uuid = 'foo-42'
523 result = self.test_context._get_server(attr_name)
524 self.assertEqual(result['user'], 'bot')
525 # no private ip attr mapping in the map results in None value in the result
526 self.assertIsNone(result['private_ip'])
527 # no public ip attr mapping in the map results in no value in the result
528 self.assertNotIn('ip', result)
530 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
531 def test__get_server_found_not_dict(self, *args):
533 Use HeatContext._get_server to get a server that matches
534 based on a non-dictionary input
536 foo2_server = mock.Mock()
537 foo2_server.private_ip = '10.0.0.2'
538 foo2_server.public_ip = '127.0.0.2'
539 foo2_server.context.user = 'oof'
541 baz3_server = mock.Mock()
542 baz3_server.private_ip = '10.0.0.3'
543 baz3_server.public_ip = None
544 baz3_server.context.user = 'zab'
546 self.test_context._name = 'bar1'
547 self.test_context._task_id = '1234567890'
548 self.test_context._name_task_id = 'bar1-12345678'
549 self.test_context.stack = mock.Mock()
550 self.test_context.stack.outputs = {
551 'private_ip': '10.0.0.1',
552 'public_ip': '127.0.0.1',
554 self.test_context.generate_routing_table = mock.MagicMock(return_value=[])
556 self.test_context._server_map = {
562 result = self.test_context._get_server(attr_name)
563 self.assertEqual(result['user'], 'zab')
564 self.assertEqual(result['private_ip'], '10.0.0.3')
565 # no public_ip on the server results in no value in the result
566 self.assertNotIn('public_ip', result)
568 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
569 def test__get_server_none_found_not_dict(self, *args):
571 Use HeatContext._get_server to not get a server due to
572 None value associated with the match to a non-dictionary
575 foo2_server = mock.Mock()
576 foo2_server.private_ip = '10.0.0.2'
577 foo2_server.public_ip = '127.0.0.2'
578 foo2_server.context.user = 'oof'
580 baz3_server = mock.Mock()
581 baz3_server.private_ip = '10.0.0.3'
582 baz3_server.public_ip = None
583 baz3_server.context.user = 'zab'
585 self.test_context._name = 'bar1'
586 self.test_context.stack = mock.Mock()
587 self.test_context.stack.outputs = {
588 'private_ip': '10.0.0.1',
589 'public_ip': '127.0.0.1',
591 self.test_context._server_map = {
597 self.test_context.key_uuid = 'foo-42'
599 result = self.test_context._get_server(attr_name)
600 self.assertIsNone(result)
602 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
603 def test__get_server_not_found_dict(self, *args):
605 Use HeatContext._get_server to not get a server for lack
606 of a match to a dictionary input
608 foo2_server = mock.Mock()
609 foo2_server.private_ip = '10.0.0.2'
610 foo2_server.public_ip = '127.0.0.2'
611 foo2_server.context.user = 'oof'
613 baz3_server = mock.Mock()
614 baz3_server.private_ip = '10.0.0.3'
615 baz3_server.public_ip = None
616 baz3_server.context.user = 'zab'
618 self.test_context._name = 'bar1'
619 self.test_context._task_id = '1235467890'
620 self.test_context._name_task_id = '{}-{}'.format(
621 self.test_context._name, self.test_context._task_id[:8])
622 self.test_context.stack = mock.Mock()
623 self.test_context.stack.outputs = {
624 'private_ip': '10.0.0.1',
625 'public_ip': '127.0.0.1',
627 self.test_context._server_map = {
632 self.test_context.key_uuid = 'foo-42'
635 'private_ip_attr': 'private_ip',
636 'public_ip_attr': 'public_ip',
638 result = self.test_context._get_server(attr_name)
639 self.assertIsNone(result)
641 @mock.patch("yardstick.benchmark.contexts.heat.pkg_resources")
642 def test__get_server_not_found_not_dict(self, *args):
644 Use HeatContext._get_server to not get a server for lack
645 of a match to a non-dictionary input
647 foo2_server = mock.Mock()
648 foo2_server.private_ip = '10.0.0.2'
649 foo2_server.public_ip = '127.0.0.2'
650 foo2_server.context.user = 'oof'
652 baz3_server = mock.Mock()
653 baz3_server.private_ip = '10.0.0.3'
654 baz3_server.public_ip = None
655 baz3_server.context.user = 'zab'
657 self.mock_context = mock.Mock(spec=heat.HeatContext())
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)