tests/unit/benchmark/contexts/test_heat.py

   1 #!/usr/bin/env python
   2
   3 ##############################################################################
   4 # Copyright (c) 2015 Ericsson AB and others.
   5 #
   6 # All rights reserved. This program and the accompanying materials
   7 # are made available under the terms of the Apache License, Version 2.0
   8 # which accompanies this distribution, and is available at
   9 # http://www.apache.org/licenses/LICENSE-2.0
  10 ##############################################################################
  11
  12 # Unittest for yardstick.benchmark.contexts.heat
  13
  14 from __future__ import absolute_import
  15
  16 import ipaddress
  17 import logging
  18 import os
  19 import unittest
  20 import uuid
  21 from collections import OrderedDict
  22
  23 import mock
  24
  25 from yardstick.benchmark.contexts import heat
  26 from yardstick.benchmark.contexts import model
  27
  28
  29 LOG = logging.getLogger(__name__)
  30
  31
  32 class HeatContextTestCase(unittest.TestCase):
  33
  34     def setUp(self):
  35         self.test_context = heat.HeatContext()
  36         self.mock_context = mock.Mock(spec=heat.HeatContext())
  37
  38     def test_construct(self):
  39
  40         self.assertIsNone(self.test_context.name)
  41         self.assertIsNone(self.test_context.stack)
  42         self.assertEqual(self.test_context.networks, OrderedDict())
  43         self.assertEqual(self.test_context.servers, [])
  44         self.assertEqual(self.test_context.placement_groups, [])
  45         self.assertEqual(self.test_context.server_groups, [])
  46         self.assertIsNone(self.test_context.keypair_name)
  47         self.assertIsNone(self.test_context.secgroup_name)
  48         self.assertEqual(self.test_context._server_map, {})
  49         self.assertIsNone(self.test_context._image)
  50         self.assertIsNone(self.test_context._flavor)
  51         self.assertIsNone(self.test_context._user)
  52         self.assertIsNone(self.test_context.template_file)
  53         self.assertIsNone(self.test_context.heat_parameters)
  54         self.assertIsNotNone(self.test_context.key_uuid)
  55         self.assertIsNotNone(self.test_context.key_filename)
  56
  57     @mock.patch('yardstick.benchmark.contexts.heat.PlacementGroup')
  58     @mock.patch('yardstick.benchmark.contexts.heat.ServerGroup')
  59     @mock.patch('yardstick.benchmark.contexts.heat.Network')
  60     @mock.patch('yardstick.benchmark.contexts.heat.Server')
  61     def test_init(self, mock_server, mock_network, mock_sg, mock_pg):
  62
  63         pgs = {'pgrp1': {'policy': 'availability'}}
  64         sgs = {'servergroup1': {'policy': 'affinity'}}
  65         networks = {'bar': {'cidr': '10.0.1.0/24'}}
  66         servers = {'baz': {'floating_ip': True, 'placement': 'pgrp1'}}
  67         attrs = {'name': 'foo',
  68                  'placement_groups': pgs,
  69                  'server_groups': sgs,
  70                  'networks': networks,
  71                  'servers': servers}
  72
  73         self.test_context.init(attrs)
  74
  75         self.assertEqual(self.test_context.name, "foo")
  76         self.assertEqual(self.test_context.keypair_name, "foo-key")
  77         self.assertEqual(self.test_context.secgroup_name, "foo-secgroup")
  78
  79         mock_pg.assert_called_with('pgrp1', self.test_context,
  80                                    pgs['pgrp1']['policy'])
  81         mock_sg.assert_called_with('servergroup1', self.test_context,
  82                                    sgs['servergroup1']['policy'])
  83         self.assertTrue(len(self.test_context.placement_groups) == 1)
  84         self.assertTrue(len(self.test_context.server_groups) == 1)
  85
  86         mock_network.assert_called_with(
  87             'bar', self.test_context, networks['bar'])
  88         self.assertTrue(len(self.test_context.networks) == 1)
  89
  90         mock_server.assert_called_with('baz', self.test_context,
  91                                        servers['baz'])
  92         self.assertTrue(len(self.test_context.servers) == 1)
  93
  94         if os.path.exists(self.test_context.key_filename):
  95             try:
  96                 os.remove(self.test_context.key_filename)
  97                 os.remove(self.test_context.key_filename + ".pub")
  98             except OSError:
  99                 LOG.exception("key_filename: %s",
 100                               self.test_context.key_filename)
 101
 102     @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
 103     def test__add_resources_to_template_no_servers(self, mock_template):
 104
 105         self.test_context.keypair_name = "foo-key"
 106         self.test_context.secgroup_name = "foo-secgroup"
 107         self.test_context.key_uuid = "2f2e4997-0a8e-4eb7-9fa4-f3f8fbbc393b"
 108         netattrs = {'cidr': '10.0.0.0/24', 'provider': None, 'external_network': 'ext_net'}
 109         self.mock_context.name = 'bar'
 110         self.test_context.networks = OrderedDict(
 111             {"fool-network": model.Network("fool-network", self.mock_context,
 112                                            netattrs)})
 113
 114         self.test_context._add_resources_to_template(mock_template)
 115         mock_template.add_keypair.assert_called_with(
 116             "foo-key",
 117             "2f2e4997-0a8e-4eb7-9fa4-f3f8fbbc393b")
 118         mock_template.add_security_group.assert_called_with("foo-secgroup")
 119 #        mock_template.add_network.assert_called_with("bar-fool-network", 'physnet1', None)
 120         mock_template.add_router.assert_called_with("bar-fool-network-router", netattrs["external_network"], "bar-fool-network-subnet")
 121         mock_template.add_router_interface.assert_called_with("bar-fool-network-router-if0", "bar-fool-network-router", "bar-fool-network-subnet")
 122
 123     @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
 124     @mock.patch('yardstick.benchmark.contexts.heat.get_neutron_client')
 125     def test_deploy(self, mock_neutron, mock_template):
 126
 127         self.test_context.name = 'foo'
 128         self.test_context.template_file = '/bar/baz/some-heat-file'
 129         self.test_context.heat_parameters = {'image': 'cirros'}
 130         self.test_context.heat_timeout = 5
 131         self.test_context.deploy()
 132
 133         mock_template.assert_called_with(self.test_context.name,
 134                                          self.test_context.template_file,
 135                                          self.test_context.heat_parameters)
 136         self.assertIsNotNone(self.test_context.stack)
 137
 138     def test_add_server_port(self):
 139         network1 = mock.MagicMock()
 140         network1.vld_id = 'vld111'
 141         network2 = mock.MagicMock()
 142         network2.vld_id = 'vld777'
 143         self.test_context.name = 'foo'
 144         self.test_context.stack = mock.MagicMock()
 145         self.test_context.networks = {
 146             'a': network1,
 147             'c': network2,
 148         }
 149         self.test_context.stack.outputs = {
 150             u'b': u'10.20.30.45',
 151             u'b-subnet_id': 1,
 152             u'foo-a-subnet-cidr': u'10.20.0.0/15',
 153             u'foo-a-subnet-gateway_ip': u'10.20.30.1',
 154             u'b-mac_address': u'00:01',
 155             u'b-device_id': u'dev21',
 156             u'b-network_id': u'net789',
 157             u'd': u'40.30.20.15',
 158             u'd-subnet_id': 2,
 159             u'foo-c-subnet-cidr': u'40.30.0.0/18',
 160             u'foo-c-subnet-gateway_ip': u'40.30.20.254',
 161             u'd-mac_address': u'00:10',
 162             u'd-device_id': u'dev43',
 163             u'd-network_id': u'net987',
 164         }
 165         server = mock.MagicMock()
 166         server.ports = OrderedDict([
 167             ('a', {'stack_name': 'b'}),
 168             ('c', {'stack_name': 'd'}),
 169         ])
 170
 171         expected = {
 172             "private_ip": '10.20.30.45',
 173             "subnet_id": 1,
 174             "subnet_cidr": '10.20.0.0/15',
 175             "network": '10.20.0.0',
 176             "netmask": '255.254.0.0',
 177             "gateway_ip": '10.20.30.1',
 178             "mac_address": '00:01',
 179             "device_id": 'dev21',
 180             "network_id": 'net789',
 181             "network_name": 'a',
 182             "local_mac": '00:01',
 183             "local_ip": '10.20.30.45',
 184             "vld_id": 'vld111',
 185         }
 186         self.test_context.add_server_port(server)
 187         self.assertEqual(server.private_ip, '10.20.30.45')
 188         self.assertEqual(len(server.interfaces), 2)
 189         self.assertDictEqual(server.interfaces['a'], expected)
 190
 191     @mock.patch('yardstick.benchmark.contexts.heat.HeatTemplate')
 192     def test_undeploy(self, mock_template):
 193
 194         self.test_context.stack = mock_template
 195         self.test_context.undeploy()
 196
 197         self.assertTrue(mock_template.delete.called)
 198
 199     def test__get_server(self):
 200
 201         self.mock_context.name = 'bar'
 202         self.mock_context.stack.outputs = {'public_ip': '127.0.0.1',
 203                                            'private_ip': '10.0.0.1'}
 204         self.mock_context.key_uuid = uuid.uuid4()
 205
 206         attr_name = {'name': 'foo.bar',
 207                      'public_ip_attr': 'public_ip',
 208                      'private_ip_attr': 'private_ip'}
 209         result = heat.HeatContext._get_server(self.mock_context, attr_name)
 210
 211         self.assertEqual(result['ip'], '127.0.0.1')
 212         self.assertEqual(result['private_ip'], '10.0.0.1')
 213
 214     def test__get_network(self):
 215         network1 = mock.MagicMock()
 216         network1.name = 'net_1'
 217         network1.vld_id = 'vld111'
 218         network1.segmentation_id = 'seg54'
 219         network1.network_type = 'type_a'
 220         network1.physical_network = 'phys'
 221
 222         network2 = mock.MagicMock()
 223         network2.name = 'net_2'
 224         network2.vld_id = 'vld999'
 225         network2.segmentation_id = 'seg45'
 226         network2.network_type = 'type_b'
 227         network2.physical_network = 'virt'
 228
 229         self.test_context.networks = {
 230             'a': network1,
 231             'b': network2,
 232         }
 233
 234         attr_name = None
 235         self.assertIsNone(self.test_context._get_network(attr_name))
 236
 237         attr_name = {}
 238         self.assertIsNone(self.test_context._get_network(attr_name))
 239
 240         attr_name = {'vld_id': 'vld777'}
 241         self.assertIsNone(self.test_context._get_network(attr_name))
 242
 243         attr_name = 'vld777'
 244         self.assertIsNone(self.test_context._get_network(attr_name))
 245
 246         attr_name = {'vld_id': 'vld999'}
 247         expected = {
 248             "name": 'net_2',
 249             "vld_id": 'vld999',
 250             "segmentation_id": 'seg45',
 251             "network_type": 'type_b',
 252             "physical_network": 'virt',
 253         }
 254         result = self.test_context._get_network(attr_name)
 255         self.assertDictEqual(result, expected)
 256
 257         attr_name = 'a'
 258         expected = {
 259             "name": 'net_1',
 260             "vld_id": 'vld111',
 261             "segmentation_id": 'seg54',
 262             "network_type": 'type_a',
 263             "physical_network": 'phys',
 264         }
 265         result = self.test_context._get_network(attr_name)
 266         self.assertDictEqual(result, expected)