← Back to branch summary

~ubuntu-branches/ubuntu/saucy/quantum/saucy

« back to all changes in this revision

Viewing changes to quantum/tests/unit/test_common_utils.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2013-05-31 09:37:25 UTC
  • mfrom: (2.1.22)
  • Revision ID: package-import@ubuntu.com-20130531093725-bf9jom93l7jm57iv
Tags: 1:2013.2~b1-0ubuntu1
* New upstream release.
* debian/patches/fix-quantum-configuration.patch: Refreshed
* debian/control: Add testrepository.
* debian/control: Add subunit.
* debian/control: Add python-d21o1 and python-pbr as build-depends.
* debian/control: Add python-stevedore.

Show diffs side-by-side

added added

removed removed

Lines of Context:
quantum/tests/unit/test_common_utils.py
14
14
 
15
15
import testtools
16
16
 
 
17
from quantum.common import exceptions as q_exc
17
18
from quantum.common import utils
 
19
from quantum.plugins.common import utils as plugin_utils
18
20
from quantum.tests import base
19
21
 
20
22
 
59
61
 
60
62
    def test_parse_mappings_succeeds_for_no_mappings(self):
61
63
        self.assertEqual(self.parse(['']), {})
 
64
 
 
65
 
 
66
class UtilTestParseVlanRanges(base.BaseTestCase):
 
67
    _err_prefix = "Invalid network VLAN range: '"
 
68
    _err_too_few = "' - 'need more than 2 values to unpack'"
 
69
    _err_too_many = "' - 'too many values to unpack'"
 
70
    _err_not_int = "' - 'invalid literal for int() with base 10: '%s''"
 
71
    _err_bad_vlan = "' - '%s is not a valid VLAN tag'"
 
72
    _err_range = "' - 'End of VLAN range is less than start of VLAN range'"
 
73
 
 
74
    def _range_too_few_err(self, nv_range):
 
75
        return self._err_prefix + nv_range + self._err_too_few
 
76
 
 
77
    def _range_too_many_err(self, nv_range):
 
78
        return self._err_prefix + nv_range + self._err_too_many
 
79
 
 
80
    def _vlan_not_int_err(self, nv_range, vlan):
 
81
        return self._err_prefix + nv_range + (self._err_not_int % vlan)
 
82
 
 
83
    def _nrange_invalid_vlan(self, nv_range, n):
 
84
        vlan = nv_range.split(':')[n]
 
85
        v_range = ':'.join(nv_range.split(':')[1:])
 
86
        return self._err_prefix + v_range + (self._err_bad_vlan % vlan)
 
87
 
 
88
    def _vrange_invalid_vlan(self, v_range_tuple, n):
 
89
        vlan = v_range_tuple[n - 1]
 
90
        v_range_str = '%d:%d' % v_range_tuple
 
91
        return self._err_prefix + v_range_str + (self._err_bad_vlan % vlan)
 
92
 
 
93
    def _vrange_invalid(self, v_range_tuple):
 
94
        v_range_str = '%d:%d' % v_range_tuple
 
95
        return self._err_prefix + v_range_str + self._err_range
 
96
 
 
97
 
 
98
class TestVlanRangeVerifyValid(UtilTestParseVlanRanges):
 
99
    def verify_range(self, vlan_range):
 
100
        return plugin_utils.verify_vlan_range(vlan_range)
 
101
 
 
102
    def test_range_valid_ranges(self):
 
103
        self.assertEqual(self.verify_range((1, 2)), None)
 
104
        self.assertEqual(self.verify_range((1, 1999)), None)
 
105
        self.assertEqual(self.verify_range((100, 100)), None)
 
106
        self.assertEqual(self.verify_range((100, 200)), None)
 
107
        self.assertEqual(self.verify_range((4001, 4094)), None)
 
108
        self.assertEqual(self.verify_range((1, 4094)), None)
 
109
 
 
110
    def check_one_vlan_invalid(self, bad_range, which):
 
111
        expected_msg = self._vrange_invalid_vlan(bad_range, which)
 
112
        err = self.assertRaises(q_exc.NetworkVlanRangeError,
 
113
                                self.verify_range, bad_range)
 
114
        self.assertEqual(str(err), expected_msg)
 
115
 
 
116
    def test_range_first_vlan_invalid_negative(self):
 
117
        self.check_one_vlan_invalid((-1, 199), 1)
 
118
 
 
119
    def test_range_first_vlan_invalid_zero(self):
 
120
        self.check_one_vlan_invalid((0, 199), 1)
 
121
 
 
122
    def test_range_first_vlan_invalid_limit_plus_one(self):
 
123
        self.check_one_vlan_invalid((4095, 199), 1)
 
124
 
 
125
    def test_range_first_vlan_invalid_too_big(self):
 
126
        self.check_one_vlan_invalid((9999, 199), 1)
 
127
 
 
128
    def test_range_second_vlan_invalid_negative(self):
 
129
        self.check_one_vlan_invalid((299, -1), 2)
 
130
 
 
131
    def test_range_second_vlan_invalid_zero(self):
 
132
        self.check_one_vlan_invalid((299, 0), 2)
 
133
 
 
134
    def test_range_second_vlan_invalid_limit_plus_one(self):
 
135
        self.check_one_vlan_invalid((299, 4095), 2)
 
136
 
 
137
    def test_range_second_vlan_invalid_too_big(self):
 
138
        self.check_one_vlan_invalid((299, 9999), 2)
 
139
 
 
140
    def test_range_both_vlans_invalid_01(self):
 
141
        self.check_one_vlan_invalid((-1, 0), 1)
 
142
 
 
143
    def test_range_both_vlans_invalid_02(self):
 
144
        self.check_one_vlan_invalid((0, 4095), 1)
 
145
 
 
146
    def test_range_both_vlans_invalid_03(self):
 
147
        self.check_one_vlan_invalid((4095, 9999), 1)
 
148
 
 
149
    def test_range_both_vlans_invalid_04(self):
 
150
        self.check_one_vlan_invalid((9999, -1), 1)
 
151
 
 
152
    def test_range_reversed(self):
 
153
        bad_range = (95, 10)
 
154
        expected_msg = self._vrange_invalid(bad_range)
 
155
        err = self.assertRaises(q_exc.NetworkVlanRangeError,
 
156
                                self.verify_range, bad_range)
 
157
        self.assertEqual(str(err), expected_msg)
 
158
 
 
159
 
 
160
class TestParseOneVlanRange(UtilTestParseVlanRanges):
 
161
    def parse_one(self, cfg_entry):
 
162
        return plugin_utils.parse_network_vlan_range(cfg_entry)
 
163
 
 
164
    def test_parse_one_net_no_vlan_range(self):
 
165
        config_str = "net1"
 
166
        expected_networks = ("net1", None)
 
167
        self.assertEqual(self.parse_one(config_str), expected_networks)
 
168
 
 
169
    def test_parse_one_net_and_vlan_range(self):
 
170
        config_str = "net1:100:199"
 
171
        expected_networks = ("net1", (100, 199))
 
172
        self.assertEqual(self.parse_one(config_str), expected_networks)
 
173
 
 
174
    def test_parse_one_net_incomplete_range(self):
 
175
        config_str = "net1:100"
 
176
        expected_msg = self._range_too_few_err(config_str)
 
177
        err = self.assertRaises(q_exc.NetworkVlanRangeError,
 
178
                                self.parse_one, config_str)
 
179
        self.assertEqual(str(err), expected_msg)
 
180
 
 
181
    def test_parse_one_net_range_too_many(self):
 
182
        config_str = "net1:100:150:200"
 
183
        expected_msg = self._range_too_many_err(config_str)
 
184
        err = self.assertRaises(q_exc.NetworkVlanRangeError,
 
185
                                self.parse_one, config_str)
 
186
        self.assertEqual(str(err), expected_msg)
 
187
 
 
188
    def test_parse_one_net_vlan1_not_int(self):
 
189
        config_str = "net1:foo:199"
 
190
        expected_msg = self._vlan_not_int_err(config_str, 'foo')
 
191
        err = self.assertRaises(q_exc.NetworkVlanRangeError,
 
192
                                self.parse_one, config_str)
 
193
        self.assertEqual(str(err), expected_msg)
 
194
 
 
195
    def test_parse_one_net_vlan2_not_int(self):
 
196
        config_str = "net1:100:bar"
 
197
        expected_msg = self._vlan_not_int_err(config_str, 'bar')
 
198
        err = self.assertRaises(q_exc.NetworkVlanRangeError,
 
199
                                self.parse_one, config_str)
 
200
        self.assertEqual(str(err), expected_msg)
 
201
 
 
202
    def test_parse_one_net_and_max_range(self):
 
203
        config_str = "net1:1:4094"
 
204
        expected_networks = ("net1", (1, 4094))
 
205
        self.assertEqual(self.parse_one(config_str), expected_networks)
 
206
 
 
207
    def test_parse_one_net_range_bad_vlan1(self):
 
208
        config_str = "net1:9000:150"
 
209
        expected_msg = self._nrange_invalid_vlan(config_str, 1)
 
210
        err = self.assertRaises(q_exc.NetworkVlanRangeError,
 
211
                                self.parse_one, config_str)
 
212
        self.assertEqual(str(err), expected_msg)
 
213
 
 
214
    def test_parse_one_net_range_bad_vlan2(self):
 
215
        config_str = "net1:4000:4999"
 
216
        expected_msg = self._nrange_invalid_vlan(config_str, 2)
 
217
        err = self.assertRaises(q_exc.NetworkVlanRangeError,
 
218
                                self.parse_one, config_str)
 
219
        self.assertEqual(str(err), expected_msg)
 
220
 
 
221
 
 
222
class TestParseVlanRangeList(UtilTestParseVlanRanges):
 
223
    def parse_list(self, cfg_entries):
 
224
        return plugin_utils.parse_network_vlan_ranges(cfg_entries)
 
225
 
 
226
    def test_parse_list_one_net_no_vlan_range(self):
 
227
        config_list = ["net1"]
 
228
        expected_networks = {"net1": []}
 
229
        self.assertEqual(self.parse_list(config_list), expected_networks)
 
230
 
 
231
    def test_parse_list_one_net_vlan_range(self):
 
232
        config_list = ["net1:100:199"]
 
233
        expected_networks = {"net1": [(100, 199)]}
 
234
        self.assertEqual(self.parse_list(config_list), expected_networks)
 
235
 
 
236
    def test_parse_two_nets_no_vlan_range(self):
 
237
        config_list = ["net1",
 
238
                       "net2"]
 
239
        expected_networks = {"net1": [],
 
240
                             "net2": []}
 
241
        self.assertEqual(self.parse_list(config_list), expected_networks)
 
242
 
 
243
    def test_parse_two_nets_range_and_no_range(self):
 
244
        config_list = ["net1:100:199",
 
245
                       "net2"]
 
246
        expected_networks = {"net1": [(100, 199)],
 
247
                             "net2": []}
 
248
        self.assertEqual(self.parse_list(config_list), expected_networks)
 
249
 
 
250
    def test_parse_two_nets_no_range_and_range(self):
 
251
        config_list = ["net1",
 
252
                       "net2:200:299"]
 
253
        expected_networks = {"net1": [],
 
254
                             "net2": [(200, 299)]}
 
255
        self.assertEqual(self.parse_list(config_list), expected_networks)
 
256
 
 
257
    def test_parse_two_nets_bad_vlan_range1(self):
 
258
        config_list = ["net1:100",
 
259
                       "net2:200:299"]
 
260
        expected_msg = self._range_too_few_err(config_list[0])
 
261
        err = self.assertRaises(q_exc.NetworkVlanRangeError,
 
262
                                self.parse_list, config_list)
 
263
        self.assertEqual(str(err), expected_msg)
 
264
 
 
265
    def test_parse_two_nets_vlan_not_int2(self):
 
266
        config_list = ["net1:100:199",
 
267
                       "net2:200:0x200"]
 
268
        expected_msg = self._vlan_not_int_err(config_list[1], '0x200')
 
269
        err = self.assertRaises(q_exc.NetworkVlanRangeError,
 
270
                                self.parse_list, config_list)
 
271
        self.assertEqual(str(err), expected_msg)
 
272
 
 
273
    def test_parse_two_nets_and_append_1_2(self):
 
274
        config_list = ["net1:100:199",
 
275
                       "net1:1000:1099",
 
276
                       "net2:200:299"]
 
277
        expected_networks = {"net1": [(100, 199),
 
278
                                      (1000, 1099)],
 
279
                             "net2": [(200, 299)]}
 
280
        self.assertEqual(self.parse_list(config_list), expected_networks)
 
281
 
 
282
    def test_parse_two_nets_and_append_1_3(self):
 
283
        config_list = ["net1:100:199",
 
284
                       "net2:200:299",
 
285
                       "net1:1000:1099"]
 
286
        expected_networks = {"net1": [(100, 199),
 
287
                                      (1000, 1099)],
 
288
                             "net2": [(200, 299)]}
 
289
        self.assertEqual(self.parse_list(config_list), expected_networks)