← Back to branch summary

~1chb1n/charms/trusty/quantum-gateway/next-amulet-tk2

« back to all changes in this revision

Viewing changes to unit_tests/test_quantum_contexts.py

  • Committer: james.page at ubuntu
  • Date: 2015-03-19 17:02:44 UTC
  • mfrom: (85.4.45 quantum-gateway)
  • Revision ID: james.page@ubuntu.com-20150319170244-ap5qc8uidf4pss7k
[dosaboy,r=james-page] Add support for neutron device mtu and physical bridge mapping.

Show diffs side-by-side

added added

removed removed

Lines of Context:
unit_tests/test_quantum_contexts.py
16
16
    'config',
17
17
    'context_complete',
18
18
    'eligible_leader',
19
 
    'get_ipv4_addr',
20
 
    'get_ipv6_addr',
21
 
    'get_nic_hwaddr',
22
19
    'get_os_codename_install_source',
23
 
    'list_nics',
24
20
    'relation_get',
25
21
    'relation_ids',
26
22
    'related_units',
46
42
        yield mock_open, mock_file
47
43
 
48
44
 
49
 
class _TestQuantumContext(CharmTestCase):
 
45
class TestNetworkServiceContext(CharmTestCase):
50
46
 
51
47
    def setUp(self):
52
 
        super(_TestQuantumContext, self).setUp(quantum_contexts, TO_PATCH)
 
48
        super(TestNetworkServiceContext, self).setUp(quantum_contexts,
 
49
                                                     TO_PATCH)
53
50
        self.config.side_effect = self.test_config.get
54
 
 
55
 
    def test_not_related(self):
56
 
        self.relation_ids.return_value = []
57
 
        self.assertEquals(self.context(), {})
58
 
 
59
 
    def test_no_units(self):
60
 
        self.relation_ids.return_value = []
61
 
        self.relation_ids.return_value = ['foo']
62
 
        self.related_units.return_value = []
63
 
        self.assertEquals(self.context(), {})
64
 
 
65
 
    def test_no_data(self):
66
 
        self.relation_ids.return_value = ['foo']
67
 
        self.related_units.return_value = ['bar']
68
 
        self.relation_get.side_effect = self.test_relation.get
69
 
        self.context_complete.return_value = False
70
 
        self.assertEquals(self.context(), {})
71
 
 
72
 
    def test_data_multi_unit(self):
73
 
        self.relation_ids.return_value = ['foo']
74
 
        self.related_units.return_value = ['bar', 'baz']
75
 
        self.context_complete.return_value = True
76
 
        self.relation_get.side_effect = self.test_relation.get
77
 
        self.assertEquals(self.context(), self.data_result)
78
 
 
79
 
    def test_data_single_unit(self):
80
 
        self.relation_ids.return_value = ['foo']
81
 
        self.related_units.return_value = ['bar']
82
 
        self.context_complete.return_value = True
83
 
        self.relation_get.side_effect = self.test_relation.get
84
 
        self.assertEquals(self.context(), self.data_result)
85
 
 
86
 
 
87
 
class TestNetworkServiceContext(_TestQuantumContext):
88
 
 
89
 
    def setUp(self):
90
 
        super(TestNetworkServiceContext, self).setUp()
91
51
        self.context = quantum_contexts.NetworkServiceContext()
92
52
        self.test_relation.set(
93
53
            {'keystone_host': '10.5.0.1',
116
76
            'auth_protocol': 'http',
117
77
        }
118
78
 
 
79
    def test_not_related(self):
 
80
        self.relation_ids.return_value = []
 
81
        self.assertEquals(self.context(), {})
 
82
 
 
83
    def test_no_units(self):
 
84
        self.relation_ids.return_value = []
 
85
        self.relation_ids.return_value = ['foo']
 
86
        self.related_units.return_value = []
 
87
        self.assertEquals(self.context(), {})
 
88
 
 
89
    def test_no_data(self):
 
90
        self.relation_ids.return_value = ['foo']
 
91
        self.related_units.return_value = ['bar']
 
92
        self.relation_get.side_effect = self.test_relation.get
 
93
        self.context_complete.return_value = False
 
94
        self.assertEquals(self.context(), {})
 
95
 
 
96
    def test_data_multi_unit(self):
 
97
        self.relation_ids.return_value = ['foo']
 
98
        self.related_units.return_value = ['bar', 'baz']
 
99
        self.context_complete.return_value = True
 
100
        self.relation_get.side_effect = self.test_relation.get
 
101
        self.assertEquals(self.context(), self.data_result)
 
102
 
 
103
    def test_data_single_unit(self):
 
104
        self.relation_ids.return_value = ['foo']
 
105
        self.related_units.return_value = ['bar']
 
106
        self.context_complete.return_value = True
 
107
        self.relation_get.side_effect = self.test_relation.get
 
108
        self.assertEquals(self.context(), self.data_result)
 
109
 
119
110
 
120
111
class TestNeutronPortContext(CharmTestCase):
121
112
 
136
127
        }
137
128
        self.absent_macs = "aa:a5:ae:ae:ab:a4 "
138
129
 
139
 
    def test_no_ext_port(self):
140
 
        self.config.return_value = None
141
 
        self.assertIsNone(quantum_contexts.ExternalPortContext()())
142
 
 
143
 
    def test_ext_port_eth(self):
144
 
        self.config.return_value = 'eth1010'
145
 
        self.assertEquals(quantum_contexts.ExternalPortContext()(),
146
 
                          {'ext_port': 'eth1010'})
 
130
    def fake_config(self, cfgdict):
 
131
 
 
132
        def _fake_config(key):
 
133
            return cfgdict.get(key)
 
134
 
 
135
        return _fake_config
147
136
 
148
137
    def _fake_get_hwaddr(self, arg):
149
138
        return self.machine_macs[arg]
151
140
    def _fake_get_ipv4(self, arg, fatal=False):
152
141
        return self.machine_nics[arg]
153
142
 
154
 
    def test_ext_port_mac(self):
 
143
    @patch('charmhelpers.contrib.openstack.context.config')
 
144
    def test_no_ext_port(self, mock_config):
 
145
        self.config.side_effect = config = self.fake_config({})
 
146
        mock_config.side_effect = config
 
147
        self.assertEquals(quantum_contexts.ExternalPortContext()(), {})
 
148
 
 
149
    @patch('charmhelpers.contrib.openstack.context.config')
 
150
    def test_ext_port_eth(self, mock_config):
 
151
        config = self.fake_config({'ext-port': 'eth1010'})
 
152
        self.config.side_effect = config
 
153
        mock_config.side_effect = config
 
154
        self.assertEquals(quantum_contexts.ExternalPortContext()(),
 
155
                          {'ext_port': 'eth1010'})
 
156
 
 
157
    @patch('charmhelpers.contrib.openstack.context.get_nic_hwaddr')
 
158
    @patch('charmhelpers.contrib.openstack.context.list_nics')
 
159
    @patch('charmhelpers.contrib.openstack.context.get_ipv6_addr')
 
160
    @patch('charmhelpers.contrib.openstack.context.get_ipv4_addr')
 
161
    @patch('charmhelpers.contrib.openstack.context.config')
 
162
    def test_ext_port_mac(self, mock_config, mock_get_ipv4_addr,
 
163
                          mock_get_ipv6_addr, mock_list_nics,
 
164
                          mock_get_nic_hwaddr):
155
165
        config_macs = self.absent_macs + " " + self.machine_macs['eth2']
156
 
        self.get_ipv4_addr.side_effect = self._fake_get_ipv4
157
 
        self.get_ipv6_addr.return_value = []
158
 
        self.config.return_value = config_macs
159
 
        self.list_nics.return_value = self.machine_macs.keys()
160
 
        self.get_nic_hwaddr.side_effect = self._fake_get_hwaddr
161
 
        self.assertEquals(quantum_contexts.ExternalPortContext()(),
162
 
                          {'ext_port': 'eth2'})
163
 
        self.config.return_value = self.absent_macs
164
 
        self.assertIsNone(quantum_contexts.ExternalPortContext()())
165
 
 
166
 
    def test_ext_port_mac_one_used_nic(self):
167
 
        config_macs = self.machine_macs['eth1'] + " " + \
168
 
            self.machine_macs['eth2']
169
 
        self.get_ipv4_addr.side_effect = self._fake_get_ipv4
170
 
        self.get_ipv6_addr.return_value = []
171
 
        self.config.return_value = config_macs
172
 
        self.list_nics.return_value = self.machine_macs.keys()
173
 
        self.get_nic_hwaddr.side_effect = self._fake_get_hwaddr
174
 
        self.assertEquals(quantum_contexts.ExternalPortContext()(),
175
 
                          {'ext_port': 'eth2'})
176
 
 
177
 
    def test_data_port_eth(self):
178
 
        self.config.return_value = 'eth1010'
 
166
        config = self.fake_config({'ext-port': config_macs})
 
167
        self.config.side_effect = config
 
168
        mock_config.side_effect = config
 
169
 
 
170
        mock_get_ipv4_addr.side_effect = self._fake_get_ipv4
 
171
        mock_get_ipv6_addr.return_value = []
 
172
        mock_list_nics.return_value = self.machine_macs.keys()
 
173
        mock_get_nic_hwaddr.side_effect = self._fake_get_hwaddr
 
174
 
 
175
        self.assertEquals(quantum_contexts.ExternalPortContext()(),
 
176
                          {'ext_port': 'eth2'})
 
177
 
 
178
        config = self.fake_config({'ext-port': self.absent_macs})
 
179
        self.config.side_effect = config
 
180
        mock_config.side_effect = config
 
181
 
 
182
        self.assertEquals(quantum_contexts.ExternalPortContext()(), {})
 
183
 
 
184
    @patch.object(quantum_contexts, '_neutron_api_settings')
 
185
    @patch('charmhelpers.contrib.openstack.context.get_nic_hwaddr')
 
186
    @patch('charmhelpers.contrib.openstack.context.list_nics')
 
187
    @patch('charmhelpers.contrib.openstack.context.get_ipv6_addr')
 
188
    @patch('charmhelpers.contrib.openstack.context.get_ipv4_addr')
 
189
    @patch('charmhelpers.contrib.openstack.context.config')
 
190
    def test_ext_port_mac_one_used_nic(self, mock_config,
 
191
                                       mock_get_ipv4_addr,
 
192
                                       mock_get_ipv6_addr, mock_list_nics,
 
193
                                       mock_get_nic_hwaddr,
 
194
                                       mock_neutron_api_settings):
 
195
 
 
196
        mock_neutron_api_settings.return_value = {'network_device_mtu': 1234}
 
197
        config_macs = "%s %s" % (self.machine_macs['eth1'],
 
198
                                 self.machine_macs['eth2'])
 
199
 
 
200
        mock_get_ipv4_addr.side_effect = self._fake_get_ipv4
 
201
        mock_get_ipv6_addr.return_value = []
 
202
        mock_list_nics.return_value = self.machine_macs.keys()
 
203
        mock_get_nic_hwaddr.side_effect = self._fake_get_hwaddr
 
204
 
 
205
        config = self.fake_config({'ext-port': config_macs})
 
206
        self.config.side_effect = config
 
207
        mock_config.side_effect = config
 
208
        self.assertEquals(quantum_contexts.ExternalPortContext()(),
 
209
                          {'ext_port': 'eth2', 'ext_port_mtu': 1234})
 
210
 
 
211
    @patch('charmhelpers.contrib.openstack.context.NeutronPortContext.'
 
212
           'resolve_ports')
 
213
    def test_data_port_eth(self, mock_resolve):
 
214
        self.config.side_effect = self.fake_config({'data-port':
 
215
                                                    'phybr1:eth1010'})
 
216
        mock_resolve.side_effect = lambda ports: ports
179
217
        self.assertEquals(quantum_contexts.DataPortContext()(),
180
 
                          {'data_port': 'eth1010'})
 
218
                          {'phybr1': 'eth1010'})
181
219
 
182
220
 
183
221
class TestL3AgentContext(CharmTestCase):
228
266
        self.test_config.set('debug', False)
229
267
        self.test_config.set('verbose', True)
230
268
        self.test_config.set('instance-mtu', 1420)
 
269
        self.test_config.set('vlan-ranges',
 
270
                             'physnet1:1000:2000 physnet2:2001:3000')
 
271
        # Provided by neutron-api relation
 
272
        self.relation_ids.return_value = ['neutron-plugin-api:0']
 
273
        self.related_units.return_value = ['neutron-api/0']
 
274
        rdata = {'network-device-mtu': 9000}
 
275
        self.relation_get.side_effect = lambda *args, **kwargs: rdata
231
276
        self.get_os_codename_install_source.return_value = 'folsom'
232
277
        _host_ip.return_value = '10.5.0.1'
233
278
        _secret.return_value = 'testsecret'
234
 
        self.assertEquals(quantum_contexts.QuantumGatewayContext()(), {
 
279
        ctxt = quantum_contexts.QuantumGatewayContext()()
 
280
        self.relation_ids.assert_called_with('neutron-plugin-api')
 
281
        self.assertEquals(ctxt, {
235
282
            'shared_secret': 'testsecret',
236
283
            'local_ip': '10.5.0.1',
237
284
            'instance_mtu': 1420,
242
289
            'verbose': True,
243
290
            'l2_population': False,
244
291
            'overlay_network_type': 'gre',
 
292
            'bridge_mappings': 'physnet1:br-data',
 
293
            'network_providers': 'physnet1 physnet2',
 
294
            'vlan_ranges': 'physnet1:1000:2000 physnet2:2001:3000',
 
295
            'network_device_mtu': 9000,
 
296
            'veth_mtu': 9000,
245
297
        })
246
298
 
247
299
 
384
436
                           'overlay_network_type': 'gre'})
385
437
 
386
438
    def test_neutron_api_settings_no_apiplugin(self):
 
439
        self.config.return_value = 1500
387
440
        self.relation_ids.return_value = []
388
441
        self.assertEquals(quantum_contexts._neutron_api_settings(),
389
442
                          {'l2_population': False,