← Back to branch summary

~niedbalski/ubuntu/vivid/neutron/fixes-1447803

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2014-10-03 18:45:23 UTC
  • mfrom: (1.1.15)
  • Revision ID: package-import@ubuntu.com-20141003184523-4mt6dy1q3j8n30c9
Tags: 1:2014.2~rc1-0ubuntu1
https://launchpad.net/bugs/1323729
* New upstream release candidate:
  - d/p/*: Refreshed.
  - d/control: Add python-requests-mock to BD's.
  - d/control: Align versioned requirements with upstream.
* Transition linuxbridge and openvswitch plugin users to modular
  layer 2 plugin (LP: #1323729):
  - d/control: Mark removed plugin packages as transitional, depend
    on neutron-plugin-ml2, mark oldlibs/extra.
  - d/neutron-plugin-{linuxbridge,openvswitch}.install: Drop.
  - d/control: Depend on neutron-plugin-ml2 for linuxbridge
    agent package.
  - d/neutron-plugin-linuxbridge-agent.upstart: Use ml2 plugin
    configuration files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
neutron/tests/unit/test_common_utils.py
16
16
import mock
17
17
import testtools
18
18
 
 
19
from neutron.common import constants
19
20
from neutron.common import exceptions as n_exc
20
21
from neutron.common import utils
 
22
from neutron.plugins.common import constants as p_const
21
23
from neutron.plugins.common import utils as plugin_utils
22
24
from neutron.tests import base
23
25
 
65
67
        self.assertEqual(self.parse(['']), {})
66
68
 
67
69
 
 
70
class TestParseTunnelRangesMixin(object):
 
71
    TUN_MIN = None
 
72
    TUN_MAX = None
 
73
    TYPE = None
 
74
    _err_prefix = "Invalid network Tunnel range: '%d:%d' - "
 
75
    _err_suffix = "%s is not a valid %s identifier"
 
76
    _err_range = "End of tunnel range is less than start of tunnel range"
 
77
 
 
78
    def _build_invalid_tunnel_range_msg(self, t_range_tuple, n):
 
79
        bad_id = t_range_tuple[n - 1]
 
80
        return (self._err_prefix % t_range_tuple) + (self._err_suffix
 
81
                                                 % (bad_id, self.TYPE))
 
82
 
 
83
    def _build_range_reversed_msg(self, t_range_tuple):
 
84
        return (self._err_prefix % t_range_tuple) + self._err_range
 
85
 
 
86
    def _verify_range(self, tunnel_range):
 
87
        return plugin_utils.verify_tunnel_range(tunnel_range, self.TYPE)
 
88
 
 
89
    def _check_range_valid_ranges(self, tunnel_range):
 
90
        self.assertIsNone(self._verify_range(tunnel_range))
 
91
 
 
92
    def _check_range_invalid_ranges(self, bad_range, which):
 
93
        expected_msg = self._build_invalid_tunnel_range_msg(bad_range, which)
 
94
        err = self.assertRaises(n_exc.NetworkTunnelRangeError,
 
95
                                self._verify_range, bad_range)
 
96
        self.assertEqual(expected_msg, str(err))
 
97
 
 
98
    def _check_range_reversed(self, bad_range):
 
99
        err = self.assertRaises(n_exc.NetworkTunnelRangeError,
 
100
                                self._verify_range, bad_range)
 
101
        expected_msg = self._build_range_reversed_msg(bad_range)
 
102
        self.assertEqual(expected_msg, str(err))
 
103
 
 
104
    def test_range_tunnel_id_valid(self):
 
105
            self._check_range_valid_ranges((self.TUN_MIN, self.TUN_MAX))
 
106
 
 
107
    def test_range_tunnel_id_invalid(self):
 
108
            self._check_range_invalid_ranges((-1, self.TUN_MAX), 1)
 
109
            self._check_range_invalid_ranges((self.TUN_MIN,
 
110
                                              self.TUN_MAX + 1), 2)
 
111
            self._check_range_invalid_ranges((self.TUN_MIN - 1,
 
112
                                              self.TUN_MAX + 1), 1)
 
113
 
 
114
    def test_range_tunnel_id_reversed(self):
 
115
            self._check_range_reversed((self.TUN_MAX, self.TUN_MIN))
 
116
 
 
117
 
 
118
class TestGreTunnelRangeVerifyValid(TestParseTunnelRangesMixin,
 
119
                                    base.BaseTestCase):
 
120
    TUN_MIN = constants.MIN_GRE_ID
 
121
    TUN_MAX = constants.MAX_GRE_ID
 
122
    TYPE = p_const.TYPE_GRE
 
123
 
 
124
 
 
125
class TestVxlanTunnelRangeVerifyValid(TestParseTunnelRangesMixin,
 
126
                                      base.BaseTestCase):
 
127
    TUN_MIN = constants.MIN_VXLAN_VNI
 
128
    TUN_MAX = constants.MAX_VXLAN_VNI
 
129
    TYPE = p_const.TYPE_VXLAN
 
130
 
 
131
 
68
132
class UtilTestParseVlanRanges(base.BaseTestCase):
69
133
    _err_prefix = "Invalid network VLAN range: '"
70
134
    _err_too_few = "' - 'need more than 2 values to unpack'"
464
528
        calls.assert_has_calls([mock.call(0), mock.call(1), mock.call(3)],
465
529
                               any_order=True)
466
530
        self.assertTrue(logger.called)
 
531
 
 
532
 
 
533
class TestDvrServices(base.BaseTestCase):
 
534
 
 
535
    def _test_is_dvr_serviced(self, device_owner, expected):
 
536
        self.assertEqual(expected, utils.is_dvr_serviced(device_owner))
 
537
 
 
538
    def test_is_dvr_serviced_with_lb_port(self):
 
539
        self._test_is_dvr_serviced(constants.DEVICE_OWNER_LOADBALANCER, True)
 
540
 
 
541
    def test_is_dvr_serviced_with_dhcp_port(self):
 
542
        self._test_is_dvr_serviced(constants.DEVICE_OWNER_DHCP, True)
 
543
 
 
544
    def test_is_dvr_serviced_with_vm_port(self):
 
545
        self._test_is_dvr_serviced('compute:', True)