← Back to branch summary

~ubuntu-branches/ubuntu/vivid/neutron/vivid

« back to all changes in this revision

Viewing changes to neutron/tests/unit/test_provider_configuration.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2015-04-15 13:59:07 UTC
  • mfrom: (1.1.22)
  • Revision ID: package-import@ubuntu.com-20150415135907-z10fr18evag1ozq3
Tags: 1:2015.1~rc1-0ubuntu1
* New upstream milestone release:
  - debian/control: Update dependencies. 
  - debian/patches/disable-udev-tests.patch: Dropped no longer needed.
  - debian/patches/fixup-driver-test-execution.patch: Dropped no longer needed.
  - debian/patches/skip-iptest.patch: Skip failing test
  - debian/neutron-plugin-openvswitch-agent.install: Added neutron-ovsvapp-agent binary.
  - debian/neutron-plugin-cisco.install: Added neutron-cisco-apic-service-agent and 
    neutron-cisco-apic-host-agent

Show diffs side-by-side

added added

removed removed

Lines of Context:
neutron/tests/unit/test_provider_configuration.py
1
 
# Copyright 2013 VMware, Inc. All Rights Reserved.
2
 
#
3
 
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
4
 
#    not use this file except in compliance with the License. You may obtain
5
 
#    a copy of the License at
6
 
#
7
 
#         http://www.apache.org/licenses/LICENSE-2.0
8
 
#
9
 
#    Unless required by applicable law or agreed to in writing, software
10
 
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11
 
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12
 
#    License for the specific language governing permissions and limitations
13
 
#    under the License.
14
 
 
15
 
from oslo_config import cfg
16
 
 
17
 
from neutron.common import exceptions as n_exc
18
 
from neutron import manager
19
 
from neutron.plugins.common import constants
20
 
from neutron.services import provider_configuration as provconf
21
 
from neutron.tests import base
22
 
 
23
 
 
24
 
class ParseServiceProviderConfigurationTestCase(base.BaseTestCase):
25
 
    def test_default_service_provider_configuration(self):
26
 
        providers = cfg.CONF.service_providers.service_provider
27
 
        self.assertEqual(providers, [])
28
 
 
29
 
    def test_parse_single_service_provider_opt(self):
30
 
        cfg.CONF.set_override('service_provider',
31
 
                              [constants.LOADBALANCER +
32
 
                               ':lbaas:driver_path'],
33
 
                              'service_providers')
34
 
        expected = {'service_type': constants.LOADBALANCER,
35
 
                    'name': 'lbaas',
36
 
                    'driver': 'driver_path',
37
 
                    'default': False}
38
 
        res = provconf.parse_service_provider_opt()
39
 
        self.assertEqual(len(res), 1)
40
 
        self.assertEqual(res, [expected])
41
 
 
42
 
    def test_parse_single_default_service_provider_opt(self):
43
 
        cfg.CONF.set_override('service_provider',
44
 
                              [constants.LOADBALANCER +
45
 
                               ':lbaas:driver_path:default'],
46
 
                              'service_providers')
47
 
        expected = {'service_type': constants.LOADBALANCER,
48
 
                    'name': 'lbaas',
49
 
                    'driver': 'driver_path',
50
 
                    'default': True}
51
 
        res = provconf.parse_service_provider_opt()
52
 
        self.assertEqual(len(res), 1)
53
 
        self.assertEqual(res, [expected])
54
 
 
55
 
    def test_parse_multi_service_provider_opt(self):
56
 
        cfg.CONF.set_override('service_provider',
57
 
                              [constants.LOADBALANCER +
58
 
                               ':lbaas:driver_path',
59
 
                               constants.LOADBALANCER + ':name1:path1',
60
 
                               constants.LOADBALANCER +
61
 
                               ':name2:path2:default'],
62
 
                              'service_providers')
63
 
        res = provconf.parse_service_provider_opt()
64
 
        # This parsing crosses repos if additional projects are installed,
65
 
        # so check that at least what we expect is there; there may be more.
66
 
        self.assertTrue(len(res) >= 3)
67
 
 
68
 
    def test_parse_service_provider_opt_not_allowed_raises(self):
69
 
        cfg.CONF.set_override('service_provider',
70
 
                              [constants.LOADBALANCER +
71
 
                               ':lbaas:driver_path',
72
 
                               'svc_type:name1:path1'],
73
 
                              'service_providers')
74
 
        self.assertRaises(n_exc.Invalid, provconf.parse_service_provider_opt)
75
 
 
76
 
    def test_parse_service_provider_invalid_format(self):
77
 
        cfg.CONF.set_override('service_provider',
78
 
                              [constants.LOADBALANCER +
79
 
                               ':lbaas:driver_path',
80
 
                               'svc_type:name1:path1:def'],
81
 
                              'service_providers')
82
 
        self.assertRaises(n_exc.Invalid, provconf.parse_service_provider_opt)
83
 
        cfg.CONF.set_override('service_provider',
84
 
                              [constants.LOADBALANCER +
85
 
                               ':',
86
 
                               'svc_type:name1:path1:def'],
87
 
                              'service_providers')
88
 
        self.assertRaises(n_exc.Invalid, provconf.parse_service_provider_opt)
89
 
 
90
 
    def test_parse_service_provider_name_too_long(self):
91
 
        name = 'a' * 256
92
 
        cfg.CONF.set_override('service_provider',
93
 
                              [constants.LOADBALANCER +
94
 
                               ':' + name + ':driver_path',
95
 
                               'svc_type:name1:path1:def'],
96
 
                              'service_providers')
97
 
        self.assertRaises(n_exc.Invalid, provconf.parse_service_provider_opt)
98
 
 
99
 
 
100
 
class ProviderConfigurationTestCase(base.BaseTestCase):
101
 
    def setUp(self):
102
 
        super(ProviderConfigurationTestCase, self).setUp()
103
 
 
104
 
    def test_ensure_driver_unique(self):
105
 
        pconf = provconf.ProviderConfiguration([])
106
 
        pconf.providers[('svctype', 'name')] = {'driver': 'driver',
107
 
                                                'default': True}
108
 
        self.assertRaises(n_exc.Invalid,
109
 
                          pconf._ensure_driver_unique, 'driver')
110
 
        self.assertIsNone(pconf._ensure_driver_unique('another_driver1'))
111
 
 
112
 
    def test_ensure_default_unique(self):
113
 
        pconf = provconf.ProviderConfiguration([])
114
 
        pconf.providers[('svctype', 'name')] = {'driver': 'driver',
115
 
                                                'default': True}
116
 
        self.assertRaises(n_exc.Invalid,
117
 
                          pconf._ensure_default_unique,
118
 
                          'svctype', True)
119
 
        self.assertIsNone(pconf._ensure_default_unique('svctype', False))
120
 
        self.assertIsNone(pconf._ensure_default_unique('svctype1', True))
121
 
        self.assertIsNone(pconf._ensure_default_unique('svctype1', False))
122
 
 
123
 
    def test_add_provider(self):
124
 
        pconf = provconf.ProviderConfiguration([])
125
 
        prov = {'service_type': constants.LOADBALANCER,
126
 
                'name': 'name',
127
 
                'driver': 'path',
128
 
                'default': False}
129
 
        pconf.add_provider(prov)
130
 
        self.assertEqual(len(pconf.providers), 1)
131
 
        self.assertEqual(pconf.providers.keys(),
132
 
                         [(constants.LOADBALANCER, 'name')])
133
 
        self.assertEqual(pconf.providers.values(),
134
 
                         [{'driver': 'path', 'default': False}])
135
 
 
136
 
    def test_add_duplicate_provider(self):
137
 
        pconf = provconf.ProviderConfiguration([])
138
 
        prov = {'service_type': constants.LOADBALANCER,
139
 
                'name': 'name',
140
 
                'driver': 'path',
141
 
                'default': False}
142
 
        pconf.add_provider(prov)
143
 
        self.assertRaises(n_exc.Invalid, pconf.add_provider, prov)
144
 
        self.assertEqual(len(pconf.providers), 1)
145
 
 
146
 
    def test_get_service_providers(self):
147
 
        provs = [{'service_type': constants.LOADBALANCER,
148
 
                  'name': 'name',
149
 
                  'driver': 'path',
150
 
                  'default': False},
151
 
                 {'service_type': constants.LOADBALANCER,
152
 
                  'name': 'name2',
153
 
                  'driver': 'path2',
154
 
                  'default': False},
155
 
                 {'service_type': 'st2',
156
 
                  'name': 'name',
157
 
                  'driver': 'driver',
158
 
                  'default': True
159
 
                  },
160
 
                 {'service_type': 'st3',
161
 
                  'name': 'name2',
162
 
                  'driver': 'driver2',
163
 
                  'default': True}]
164
 
        pconf = provconf.ProviderConfiguration(provs)
165
 
        for prov in provs:
166
 
            p = pconf.get_service_providers(
167
 
                filters={'name': [prov['name']],
168
 
                         'service_type': prov['service_type']}
169
 
            )
170
 
            self.assertEqual(p, [prov])
171
 
 
172
 
    def test_get_service_providers_with_fields(self):
173
 
        provs = [{'service_type': constants.LOADBALANCER,
174
 
                  'name': 'name',
175
 
                  'driver': 'path',
176
 
                  'default': False},
177
 
                 {'service_type': constants.LOADBALANCER,
178
 
                  'name': 'name2',
179
 
                  'driver': 'path2',
180
 
                  'default': False}]
181
 
        pconf = provconf.ProviderConfiguration(provs)
182
 
        for prov in provs:
183
 
            p = pconf.get_service_providers(
184
 
                filters={'name': [prov['name']],
185
 
                         'service_type': prov['service_type']},
186
 
                fields=['name']
187
 
            )
188
 
            self.assertEqual(p, [{'name': prov['name']}])
189
 
 
190
 
 
191
 
class GetProviderDriverClassTestCase(base.BaseTestCase):
192
 
    def test_get_provider_driver_class_hit(self):
193
 
        driver = 'ml2'
194
 
        expected = 'neutron.plugins.ml2.plugin.Ml2Plugin'
195
 
        actual = provconf.get_provider_driver_class(
196
 
            driver,
197
 
            namespace=manager.CORE_PLUGINS_NAMESPACE)
198
 
        self.assertEqual(expected, actual)
199
 
 
200
 
    def test_get_provider_driver_class_miss(self):
201
 
        retval = provconf.get_provider_driver_class('foo')
202
 
        self.assertEqual('foo', retval)