← Back to branch summary

~ubuntu-branches/ubuntu/raring/quantum/raring-proposed

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Chuck Short, Yolanda Robla, James Page, Maru Newby
  • Date: 2013-01-11 09:14:35 UTC
  • mfrom: (2.1.17)
  • Revision ID: package-import@ubuntu.com-20130111091435-vaup7dwmtmajy5oe
Tags: 2013.1~g2-0ubuntu1
https://launchpad.net/bugs/1085038
https://launchpad.net/bugs/1076747
[ Chuck Short ]
* New upstream version. 
* debian/patches/fix-quantum-configuration.patch: Refreshed.

[ Yolanda Robla ]
* debian/quantum-l3-agent.quantum-metadata-agent.upstart: Add
  upstart configuration for Metadata Agent.
* debian/quantum-l3-agent.install: Added quantum-ns-metadata-proxy,
  quantum-metadata-agent and metadata_agent.ini.
* debian/patches/fix-quantum-configuration.patch: Update rootwrap
  configuration in metadata_agent.ini file.
* debian/changelog: Updated package version
* d/p/fix-quantum-configuration.patch: refresh patches

[ James Page ]
* d/*.install: Install entry points from bin directory instead
  of easy-install ones generated during the package build process
  (LP: #1085038).
* d/control: Drop BD on python-dev-all; its not required.
* d/rules: Install multiple upstart configurations for quantum-l3-agent.
* d/control: Tidy package descriptions.
* d/*.postrm: Drop as debhelper will generate update-rc.d calls in
  maintainer scripts if required.
* d/quantum-common.postinst: Tweak permissions setting so that /etc/quantum
  is not owned/writable by the quantum user, ensure that /etc/quantum/rootwrap*
  is owned by root:root.
* d/*agent*.postinst: Dropped as permissions now correctly set in
  quantum-common.
* d/patches/fix-quantum-configuration.patch: Re-add dropped fixes rootwrap and
  sqlite defaults for all plugins.
* d/control: Added new BD on alembic (>= 0.4.1~), version python-mock >= 1.0b1.

[ Maru Newby ]
* debian/control: Remove unnecessary openvswitch-vswitch dependency
  from quantum-plugin-openvswitch (LP: #1076747).

Show diffs side-by-side

added added

removed removed

Lines of Context:
quantum/tests/unit/test_attributes.py
33
33
        data = "I'm set"
34
34
        self.assertIs(attributes.is_attr_set(data), True)
35
35
 
36
 
    def test_validate_boolean(self):
37
 
        msg = attributes._validate_boolean(True)
38
 
        self.assertIsNone(msg)
39
 
 
40
 
        msg = attributes._validate_boolean(False)
41
 
        self.assertIsNone(msg)
42
 
 
43
 
        msg = attributes._validate_boolean('True')
44
 
        self.assertEquals(msg, "'True' is not boolean")
45
 
 
46
 
        msg = attributes._validate_boolean('False')
47
 
        self.assertEquals(msg, "'False' is not boolean")
48
 
 
49
 
        msg = attributes._validate_boolean(0)
50
 
        self.assertEquals(msg, "'0' is not boolean")
51
 
 
52
 
        msg = attributes._validate_boolean(1)
53
 
        self.assertEquals(msg, "'1' is not boolean")
54
 
 
55
 
        msg = attributes._validate_boolean(None)
56
 
        self.assertEquals(msg, "'None' is not boolean")
57
 
 
58
36
    def test_validate_values(self):
59
37
        msg = attributes._validate_values(4, [4, 6])
60
38
        self.assertIsNone(msg)
63
41
        self.assertIsNone(msg)
64
42
 
65
43
        msg = attributes._validate_values(7, [4, 6])
66
 
        self.assertEquals(msg, "'7' is not in [4, 6]")
 
44
        self.assertEqual(msg, "'7' is not in [4, 6]")
67
45
 
68
46
        msg = attributes._validate_values(7, (4, 6))
69
 
        self.assertEquals(msg, "'7' is not in (4, 6)")
 
47
        self.assertEqual(msg, "'7' is not in (4, 6)")
70
48
 
71
49
    def test_validate_string(self):
72
50
        msg = attributes._validate_string(None, None)
73
 
        self.assertEquals(msg, "'None' is not a valid string")
 
51
        self.assertEqual(msg, "'None' is not a valid string")
74
52
 
75
53
        # 0 == len(data) == max_len
76
54
        msg = attributes._validate_string("", 0)
90
68
 
91
69
        # 0 < max_len < len(data)
92
70
        msg = attributes._validate_string("1234567890", 9)
93
 
        self.assertEquals(msg, "'1234567890' exceeds maximum length of 9")
 
71
        self.assertEqual(msg, "'1234567890' exceeds maximum length of 9")
94
72
 
95
73
        msg = attributes._validate_string("123456789", None)
96
74
        self.assertIsNone(msg)
115
93
        self.assertIsNone(msg)
116
94
 
117
95
        msg = attributes._validate_range(0, [1, 9])
118
 
        self.assertEquals(msg, "'0' is not in range 1 through 9")
 
96
        self.assertEqual(msg, "'0' is not in range 1 through 9")
119
97
 
120
98
        msg = attributes._validate_range(10, (1, 9))
121
 
        self.assertEquals(msg, "'10' is not in range 1 through 9")
 
99
        self.assertEqual(msg, "'10' is not in range 1 through 9")
122
100
 
123
101
    def test_validate_mac_address(self):
124
102
        mac_addr = "ff:16:3e:4f:00:00"
127
105
 
128
106
        mac_addr = "ffa:16:3e:4f:00:00"
129
107
        msg = attributes._validate_mac_address(mac_addr)
130
 
        self.assertEquals(msg, "'%s' is not a valid MAC address" % mac_addr)
 
108
        self.assertEqual(msg, "'%s' is not a valid MAC address" % mac_addr)
131
109
 
132
110
    def test_validate_ip_address(self):
133
111
        ip_addr = '1.1.1.1'
136
114
 
137
115
        ip_addr = '1111.1.1.1'
138
116
        msg = attributes._validate_ip_address(ip_addr)
139
 
        self.assertEquals(msg, "'%s' is not a valid IP address" % ip_addr)
 
117
        self.assertEqual(msg, "'%s' is not a valid IP address" % ip_addr)
140
118
 
141
119
    def test_validate_ip_pools(self):
142
120
        pools = [[{'end': '10.0.0.254'}],
207
185
    def test_validate_hostroutes(self):
208
186
        hostroute_pools = [[{'destination': '100.0.0.0/24'}],
209
187
                           [{'nexthop': '10.0.2.20'}],
 
188
                           [{'nexthop': '10.0.2.20',
 
189
                             'forza': 'juve',
 
190
                             'destination': '100.0.0.0/8'}],
210
191
                           [{'nexthop': '1110.0.2.20',
211
192
                             'destination': '100.0.0.0/8'}],
212
193
                           [{'nexthop': '10.0.2.20',
215
196
                             'destination': '100.0.0.0/8'},
216
197
                            {'nexthop': '10.0.2.20',
217
198
                             'destination': '100.0.0.0/8'}],
 
199
                           [None],
218
200
                           None]
219
201
        for host_routes in hostroute_pools:
220
202
            msg = attributes._validate_hostroutes(host_routes, None)
241
223
 
242
224
        ip_addr = '1111.1.1.1'
243
225
        msg = attributes._validate_ip_address_or_none(ip_addr)
244
 
        self.assertEquals(msg, "'%s' is not a valid IP address" % ip_addr)
 
226
        self.assertEqual(msg, "'%s' is not a valid IP address" % ip_addr)
245
227
 
246
228
    def test_hostname_pattern(self):
247
229
        data = '@openstack'
340
322
        msg = attributes._validate_subnet(cidr,
341
323
                                          None)
342
324
        error = "'%s' is not a valid IP subnet" % cidr
343
 
        self.assertEquals(msg, error)
 
325
        self.assertEqual(msg, error)
344
326
 
345
327
        # Invalid - IPv6 without final octets, missing mask
346
328
        cidr = "fe80::"
347
329
        msg = attributes._validate_subnet(cidr,
348
330
                                          None)
349
331
        error = "'%s' is not a valid IP subnet" % cidr
350
 
        self.assertEquals(msg, error)
 
332
        self.assertEqual(msg, error)
351
333
 
352
334
        # Invalid - IPv6 with final octets, missing mask
353
335
        cidr = "fe80::0"
354
336
        msg = attributes._validate_subnet(cidr,
355
337
                                          None)
356
338
        error = "'%s' is not a valid IP subnet" % cidr
357
 
        self.assertEquals(msg, error)
 
339
        self.assertEqual(msg, error)
358
340
 
359
341
        # Invalid - Address format error
360
342
        cidr = 'invalid'
361
343
        msg = attributes._validate_subnet(cidr,
362
344
                                          None)
363
345
        error = "'%s' is not a valid IP subnet" % cidr
364
 
        self.assertEquals(msg, error)
 
346
        self.assertEqual(msg, error)
365
347
 
366
348
    def test_validate_regex(self):
367
349
        pattern = '[hc]at'
368
350
 
369
351
        data = None
370
352
        msg = attributes._validate_regex(data, pattern)
371
 
        self.assertEquals(msg, "'%s' is not valid input" % data)
 
353
        self.assertEqual(msg, "'%s' is not a valid input" % data)
372
354
 
373
355
        data = 'bat'
374
356
        msg = attributes._validate_regex(data, pattern)
375
 
        self.assertEquals(msg, "'%s' is not valid input" % data)
 
357
        self.assertEqual(msg, "'%s' is not a valid input" % data)
376
358
 
377
359
        data = 'hat'
378
360
        msg = attributes._validate_regex(data, pattern)
384
366
 
385
367
    def test_validate_uuid(self):
386
368
        msg = attributes._validate_uuid('garbage')
387
 
        self.assertEquals(msg, "'garbage' is not a valid UUID")
 
369
        self.assertEqual(msg, "'garbage' is not a valid UUID")
388
370
 
389
371
        msg = attributes._validate_uuid('00000000-ffff-ffff-ffff-000000000000')
390
372
        self.assertIsNone(msg)
391
373
 
 
374
    def test_validate_uuid_list(self):
 
375
        # check not a list
 
376
        uuids = [None,
 
377
                 123,
 
378
                 'e5069610-744b-42a7-8bd8-ceac1a229cd4',
 
379
                 '12345678123456781234567812345678',
 
380
                 {'uuid': 'e5069610-744b-42a7-8bd8-ceac1a229cd4'}]
 
381
        for uuid in uuids:
 
382
            msg = attributes._validate_uuid_list(uuid)
 
383
            error = "'%s' is not a list" % uuid
 
384
            self.assertEquals(msg, error)
 
385
 
 
386
        # check invalid uuid in a list
 
387
        invalid_uuid_lists = [[None],
 
388
                              [123],
 
389
                              [123, 'e5069610-744b-42a7-8bd8-ceac1a229cd4'],
 
390
                              ['123', '12345678123456781234567812345678'],
 
391
                              ['t5069610-744b-42a7-8bd8-ceac1a229cd4'],
 
392
                              ['e5069610-744b-42a7-8bd8-ceac1a229cd44'],
 
393
                              ['e50696100-744b-42a7-8bd8-ceac1a229cd4'],
 
394
                              ['e5069610-744bb-42a7-8bd8-ceac1a229cd4']]
 
395
        for uuid_list in invalid_uuid_lists:
 
396
            msg = attributes._validate_uuid_list(uuid_list)
 
397
            error = "'%s' is not a valid UUID" % uuid_list[0]
 
398
            self.assertEquals(msg, error)
 
399
 
 
400
        # check duplicate items in a list
 
401
        duplicate_uuids = ['e5069610-744b-42a7-8bd8-ceac1a229cd4',
 
402
                           'f3eeab00-8367-4524-b662-55e64d4cacb5',
 
403
                           'e5069610-744b-42a7-8bd8-ceac1a229cd4']
 
404
        msg = attributes._validate_uuid_list(duplicate_uuids)
 
405
        error = "Duplicate items in the list: %s" % ', '.join(duplicate_uuids)
 
406
        self.assertEquals(msg, error)
 
407
 
 
408
        # check valid uuid lists
 
409
        valid_uuid_lists = [['e5069610-744b-42a7-8bd8-ceac1a229cd4'],
 
410
                            ['f3eeab00-8367-4524-b662-55e64d4cacb5'],
 
411
                            ['e5069610-744b-42a7-8bd8-ceac1a229cd4',
 
412
                             'f3eeab00-8367-4524-b662-55e64d4cacb5']]
 
413
        for uuid_list in valid_uuid_lists:
 
414
            msg = attributes._validate_uuid_list(uuid_list)
 
415
            self.assertEquals(msg, None)
 
416
 
 
417
    def test_validate_dict(self):
 
418
        for value in (None, True, '1', []):
 
419
            self.assertEquals(attributes._validate_dict(value),
 
420
                              "'%s' is not a dictionary" % value)
 
421
 
 
422
        msg = attributes._validate_dict({})
 
423
        self.assertIsNone(msg)
 
424
 
 
425
        msg = attributes._validate_dict({'key': 'value'})
 
426
        self.assertIsNone(msg)
 
427
 
 
428
    def test_validate_non_negative(self):
 
429
        for value in (-1, '-2'):
 
430
            self.assertEquals(attributes._validate_non_negative(value),
 
431
                              "'%s' should be non-negative" % value)
 
432
 
 
433
        for value in (0, 1, '2', True, False):
 
434
            msg = attributes._validate_non_negative(value)
 
435
            self.assertIsNone(msg)
 
436
 
392
437
 
393
438
class TestConvertToBoolean(unittest2.TestCase):
394
439
 
418
463
class TestConvertToInt(unittest2.TestCase):
419
464
 
420
465
    def test_convert_to_int_int(self):
421
 
        self.assertEquals(attributes.convert_to_int(-1), -1)
422
 
        self.assertEquals(attributes.convert_to_int(0), 0)
423
 
        self.assertEquals(attributes.convert_to_int(1), 1)
 
466
        self.assertEqual(attributes.convert_to_int(-1), -1)
 
467
        self.assertEqual(attributes.convert_to_int(0), 0)
 
468
        self.assertEqual(attributes.convert_to_int(1), 1)
424
469
 
425
470
    def test_convert_to_int_str(self):
426
 
        self.assertEquals(attributes.convert_to_int('4'), 4)
427
 
        self.assertEquals(attributes.convert_to_int('6'), 6)
 
471
        self.assertEqual(attributes.convert_to_int('4'), 4)
 
472
        self.assertEqual(attributes.convert_to_int('6'), 6)
428
473
        self.assertRaises(q_exc.InvalidInput,
429
474
                          attributes.convert_to_int,
430
475
                          'garbage')
434
479
                          attributes.convert_to_int,
435
480
                          None)
436
481
 
 
482
    def test_convert_none_to_empty_list_none(self):
 
483
        self.assertEqual(
 
484
            [], attributes.convert_none_to_empty_list(None))
 
485
 
 
486
    def test_convert_none_to_empty_list_value(self):
 
487
        values = ['1', 3, [], [1], {}, {'a': 3}]
 
488
        for value in values:
 
489
            self.assertEqual(
 
490
                value, attributes.convert_none_to_empty_list(value))
 
491
 
437
492
 
438
493
class TestConvertKvp(unittest2.TestCase):
439
494
 
465
520
    def test_convert_kvp_str_to_list_succeeds_for_two_equals(self):
466
521
        result = attributes.convert_kvp_str_to_list('a=a=a')
467
522
        self.assertEqual(['a', 'a=a'], result)
 
523
 
 
524
 
 
525
class TestConvertToList(unittest2.TestCase):
 
526
 
 
527
    def test_convert_to_empty_list(self):
 
528
        for item in (None, [], (), {}):
 
529
            self.assertEquals(attributes.convert_to_list(item), [])
 
530
 
 
531
    def test_convert_to_list_string(self):
 
532
        for item in ('', 'foo'):
 
533
            self.assertEquals(attributes.convert_to_list(item), [item])
 
534
 
 
535
    def test_convert_to_list_iterable(self):
 
536
        for item in ([None], [1, 2, 3], (1, 2, 3), set([1, 2, 3]), ['foo']):
 
537
            self.assertEquals(attributes.convert_to_list(item), list(item))
 
538
 
 
539
    def test_convert_to_list_non_iterable(self):
 
540
        for item in (True, False, 1, 1.2, object()):
 
541
            self.assertEquals(attributes.convert_to_list(item), [item])