1# Copyright (C) 2016 Nippon Telegraph and Telephone Corporation.
2#
3# Licensed under the Apache License, Version 2.0 (the "License");
4# you may not use this file except in compliance with the License.
5# You may obtain 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,
11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
12# implied.
13# See the License for the specific language governing permissions and
14# limitations under the License.
15
16import unittest
17import logging
18try:
19    import mock  # Python 2
20except ImportError:
21    from unittest import mock  # Python 3
22
23from nose.tools import raises
24
25from ryu.services.protocols.bgp import bgpspeaker
26from ryu.services.protocols.bgp.bgpspeaker import EVPN_MAX_ET
27from ryu.services.protocols.bgp.bgpspeaker import ESI_TYPE_LACP
28from ryu.services.protocols.bgp.api.prefix import ESI_TYPE_L2_BRIDGE
29from ryu.services.protocols.bgp.bgpspeaker import ESI_TYPE_MAC_BASED
30from ryu.services.protocols.bgp.api.prefix import REDUNDANCY_MODE_ALL_ACTIVE
31from ryu.services.protocols.bgp.api.prefix import REDUNDANCY_MODE_SINGLE_ACTIVE
32
33
34LOG = logging.getLogger(__name__)
35
36
37class Test_BGPSpeaker(unittest.TestCase):
38    """
39    Test case for bgp.bgpspeaker.BGPSpeaker
40    """
41
42    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
43                mock.MagicMock(return_value=None))
44    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
45    def test_evpn_prefix_add_eth_auto_discovery(self, mock_call):
46        # Prepare test data
47        route_type = bgpspeaker.EVPN_ETH_AUTO_DISCOVERY
48        route_dist = '65000:100'
49        esi = {
50            'type': ESI_TYPE_LACP,
51            'mac_addr': 'aa:bb:cc:dd:ee:ff',
52            'port_key': 100,
53        }
54        ethernet_tag_id = EVPN_MAX_ET
55        redundancy_mode = REDUNDANCY_MODE_ALL_ACTIVE
56        next_hop = '0.0.0.0'
57        expected_kwargs = {
58            'route_type': route_type,
59            'route_dist': route_dist,
60            'esi': esi,
61            'ethernet_tag_id': ethernet_tag_id,
62            'redundancy_mode': redundancy_mode,
63            'next_hop': next_hop,
64        }
65
66        # Test
67        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
68        speaker.evpn_prefix_add(
69            route_type=route_type,
70            route_dist=route_dist,
71            esi=esi,
72            ethernet_tag_id=ethernet_tag_id,
73            redundancy_mode=redundancy_mode,
74        )
75
76        # Check
77        mock_call.assert_called_with(
78            'evpn_prefix.add_local', **expected_kwargs)
79
80    @mock.patch(
81        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
82        mock.MagicMock(return_value=None))
83    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
84    def test_evpn_prefix_add_eth_auto_discovery_vni(self, mock_call):
85        # Prepare test data
86        route_type = bgpspeaker.EVPN_ETH_AUTO_DISCOVERY
87        route_dist = '65000:100'
88        esi = {
89            'type': ESI_TYPE_L2_BRIDGE,
90            'mac_addr': 'aa:bb:cc:dd:ee:ff',
91            'priority': 100,
92        }
93        ethernet_tag_id = EVPN_MAX_ET
94        redundancy_mode = REDUNDANCY_MODE_SINGLE_ACTIVE
95        vni = 500
96        next_hop = '0.0.0.0'
97        expected_kwargs = {
98            'route_type': route_type,
99            'route_dist': route_dist,
100            'esi': esi,
101            'ethernet_tag_id': ethernet_tag_id,
102            'redundancy_mode': redundancy_mode,
103            'vni': vni,
104            'next_hop': next_hop,
105        }
106
107        # Test
108        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
109        speaker.evpn_prefix_add(
110            route_type=route_type,
111            route_dist=route_dist,
112            esi=esi,
113            ethernet_tag_id=ethernet_tag_id,
114            redundancy_mode=redundancy_mode,
115            vni=vni
116        )
117
118        # Check
119        mock_call.assert_called_with(
120            'evpn_prefix.add_local', **expected_kwargs)
121
122    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
123                mock.MagicMock(return_value=None))
124    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
125    def test_evpn_prefix_add_mac_ip_adv(self, mock_call):
126        # Prepare test data
127        route_type = bgpspeaker.EVPN_MAC_IP_ADV_ROUTE
128        route_dist = '65000:100'
129        esi = 0  # denotes single-homed
130        ethernet_tag_id = 200
131        mac_addr = 'aa:bb:cc:dd:ee:ff'
132        ip_addr = '192.168.0.1'
133        next_hop = '10.0.0.1'
134        expected_kwargs = {
135            'route_type': route_type,
136            'route_dist': route_dist,
137            'esi': esi,
138            'ethernet_tag_id': ethernet_tag_id,
139            'mac_addr': mac_addr,
140            'ip_addr': ip_addr,
141            'next_hop': next_hop,
142        }
143
144        # Test
145        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
146        speaker.evpn_prefix_add(
147            route_type=route_type,
148            route_dist=route_dist,
149            esi=esi,
150            ethernet_tag_id=ethernet_tag_id,
151            mac_addr=mac_addr,
152            ip_addr=ip_addr,
153            next_hop=next_hop,
154        )
155
156        # Check
157        mock_call.assert_called_with(
158            'evpn_prefix.add_local', **expected_kwargs)
159
160    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
161                mock.MagicMock(return_value=None))
162    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
163    def test_evpn_prefix_add_mac_ip_adv_vni(self, mock_call):
164        # Prepare test data
165        route_type = bgpspeaker.EVPN_MAC_IP_ADV_ROUTE
166        route_dist = '65000:100'
167        esi = 0  # denotes single-homed
168        ethernet_tag_id = 200
169        mac_addr = 'aa:bb:cc:dd:ee:ff'
170        ip_addr = '192.168.0.1'
171        vni = 500
172        next_hop = '10.0.0.1'
173        tunnel_type = bgpspeaker.TUNNEL_TYPE_VXLAN
174        expected_kwargs = {
175            'route_type': route_type,
176            'route_dist': route_dist,
177            'esi': esi,
178            'ethernet_tag_id': ethernet_tag_id,
179            'mac_addr': mac_addr,
180            'ip_addr': ip_addr,
181            'vni': vni,
182            'next_hop': next_hop,
183            'tunnel_type': tunnel_type,
184        }
185
186        # Test
187        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
188        speaker.evpn_prefix_add(
189            route_type=route_type,
190            route_dist=route_dist,
191            esi=esi,
192            ethernet_tag_id=ethernet_tag_id,
193            mac_addr=mac_addr,
194            ip_addr=ip_addr,
195            vni=vni,
196            next_hop=next_hop,
197            tunnel_type=tunnel_type,
198        )
199
200        # Check
201        mock_call.assert_called_with(
202            'evpn_prefix.add_local', **expected_kwargs)
203
204    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
205                mock.MagicMock(return_value=None))
206    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
207    def test_evpn_prefix_add_multicast_etag(self, mock_call):
208        # Prepare test data
209        route_type = bgpspeaker.EVPN_MULTICAST_ETAG_ROUTE
210        route_dist = '65000:100'
211        esi = 0  # denotes single-homed
212        ethernet_tag_id = 200
213        mac_addr = 'aa:bb:cc:dd:ee:ff'
214        ip_addr = '192.168.0.1'
215        next_hop = '10.0.0.1'
216        expected_kwargs = {
217            'route_type': route_type,
218            'route_dist': route_dist,
219            # 'esi': esi,  # should be ignored
220            'ethernet_tag_id': ethernet_tag_id,
221            # 'mac_addr': mac_addr,  # should be ignored
222            'ip_addr': ip_addr,
223            'next_hop': next_hop,
224        }
225
226        # Test
227        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
228        speaker.evpn_prefix_add(
229            route_type=route_type,
230            route_dist=route_dist,
231            esi=esi,
232            ethernet_tag_id=ethernet_tag_id,
233            mac_addr=mac_addr,
234            ip_addr=ip_addr,
235            next_hop=next_hop,
236        )
237
238        # Check
239        mock_call.assert_called_with(
240            'evpn_prefix.add_local', **expected_kwargs)
241
242    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
243                mock.MagicMock(return_value=None))
244    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
245    def test_evpn_prefix_add_multicast_etag_no_next_hop(self, mock_call):
246        # Prepare test data
247        route_type = bgpspeaker.EVPN_MULTICAST_ETAG_ROUTE
248        route_dist = '65000:100'
249        esi = 0  # denotes single-homed
250        ethernet_tag_id = 200
251        mac_addr = 'aa:bb:cc:dd:ee:ff'
252        ip_addr = '192.168.0.1'
253        next_hop = '0.0.0.0'  # the default value
254        expected_kwargs = {
255            'route_type': route_type,
256            'route_dist': route_dist,
257            # 'esi': esi,  # should be ignored
258            'ethernet_tag_id': ethernet_tag_id,
259            # 'mac_addr': mac_addr,  # should be ignored
260            'ip_addr': ip_addr,
261            'next_hop': next_hop,
262        }
263
264        # Test
265        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
266        speaker.evpn_prefix_add(
267            route_type=route_type,
268            route_dist=route_dist,
269            esi=esi,
270            ethernet_tag_id=ethernet_tag_id,
271            mac_addr=mac_addr,
272            ip_addr=ip_addr,
273            # next_hop=next_hop,  # omitted
274        )
275
276        # Check
277        mock_call.assert_called_with(
278            'evpn_prefix.add_local', **expected_kwargs)
279
280    @mock.patch(
281        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
282        mock.MagicMock(return_value=None))
283    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
284    def test_evpn_prefix_add_eth_segment(self, mock_call):
285        # Prepare test data
286        route_type = bgpspeaker.EVPN_ETH_SEGMENT
287        route_dist = '65000:100'
288        esi = {
289            'type': ESI_TYPE_MAC_BASED,
290            'mac_addr': 'aa:bb:cc:dd:ee:ff',
291            'local_disc': 100,
292        }
293        ip_addr = '192.168.0.1'
294        next_hop = '0.0.0.0'
295        expected_kwargs = {
296            'route_type': route_type,
297            'route_dist': route_dist,
298            'esi': esi,
299            'ip_addr': ip_addr,
300            'next_hop': next_hop,
301        }
302
303        # Test
304        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
305        speaker.evpn_prefix_add(
306            route_type=route_type,
307            route_dist=route_dist,
308            esi=esi,
309            ip_addr=ip_addr,
310        )
311
312        # Check
313        mock_call.assert_called_with(
314            'evpn_prefix.add_local', **expected_kwargs)
315
316    @mock.patch(
317        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
318        mock.MagicMock(return_value=None))
319    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
320    def test_evpn_prefix_add_ip_prefix_route(self, mock_call):
321        # Prepare test data
322        route_type = bgpspeaker.EVPN_IP_PREFIX_ROUTE
323        route_dist = '65000:100'
324        esi = 0  # denotes single-homed
325        ethernet_tag_id = 200
326        ip_prefix = '192.168.0.0/24'
327        gw_ip_addr = '172.16.0.1'
328        next_hop = '0.0.0.0'
329        expected_kwargs = {
330            'route_type': route_type,
331            'route_dist': route_dist,
332            'esi': esi,
333            'ethernet_tag_id': ethernet_tag_id,
334            'ip_prefix': ip_prefix,
335            'gw_ip_addr': gw_ip_addr,
336            'next_hop': next_hop,
337        }
338
339        # Test
340        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
341        speaker.evpn_prefix_add(
342            route_type=route_type,
343            route_dist=route_dist,
344            esi=esi,
345            ethernet_tag_id=ethernet_tag_id,
346            ip_prefix=ip_prefix,
347            gw_ip_addr=gw_ip_addr,
348        )
349
350        # Check
351        mock_call.assert_called_with(
352            'evpn_prefix.add_local', **expected_kwargs)
353
354    @mock.patch(
355        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
356        mock.MagicMock(return_value=None))
357    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
358    def test_evpn_prefix_add_ip_prefix_route_vni(self, mock_call):
359        # Prepare test data
360        route_type = bgpspeaker.EVPN_IP_PREFIX_ROUTE
361        route_dist = '65000:100'
362        esi = 0  # denotes single-homed
363        ethernet_tag_id = 200
364        ip_prefix = '192.168.0.0/24'
365        gw_ip_addr = '172.16.0.1'
366        vni = 500
367        tunnel_type = bgpspeaker.TUNNEL_TYPE_VXLAN
368        next_hop = '0.0.0.0'
369        expected_kwargs = {
370            'route_type': route_type,
371            'route_dist': route_dist,
372            'esi': esi,
373            'ethernet_tag_id': ethernet_tag_id,
374            'ip_prefix': ip_prefix,
375            'gw_ip_addr': gw_ip_addr,
376            'tunnel_type': tunnel_type,
377            'vni': vni,
378            'next_hop': next_hop,
379        }
380
381        # Test
382        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
383        speaker.evpn_prefix_add(
384            route_type=route_type,
385            route_dist=route_dist,
386            esi=esi,
387            ethernet_tag_id=ethernet_tag_id,
388            ip_prefix=ip_prefix,
389            gw_ip_addr=gw_ip_addr,
390            tunnel_type=tunnel_type,
391            vni=vni,
392        )
393
394        # Check
395        mock_call.assert_called_with(
396            'evpn_prefix.add_local', **expected_kwargs)
397
398    @raises(ValueError)
399    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
400                mock.MagicMock(return_value=None))
401    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
402    def test_evpn_prefix_add_invalid_route_type(self, mock_call):
403        # Prepare test data
404        route_type = 'foobar'  # Invalid EVPN route type
405        route_dist = '65000:100'
406        esi = 0  # denotes single-homed
407        ethernet_tag_id = 200
408        mac_addr = 'aa:bb:cc:dd:ee:ff'
409        ip_addr = '192.168.0.1'
410        next_hop = '10.0.0.1'
411
412        # Test
413        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
414        speaker.evpn_prefix_add(
415            route_type=route_type,
416            route_dist=route_dist,
417            esi=esi,
418            ethernet_tag_id=ethernet_tag_id,
419            mac_addr=mac_addr,
420            ip_addr=ip_addr,
421            next_hop=next_hop,
422        )
423
424        # Check
425        mock_call.assert_called_with(
426            'evpn_prefix.add_local', 'Invalid arguments detected')
427
428    @mock.patch(
429        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
430        mock.MagicMock(return_value=None))
431    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
432    def test_evpn_prefix_del_auto_discovery(self, mock_call):
433        # Prepare test data
434        route_type = bgpspeaker.EVPN_ETH_AUTO_DISCOVERY
435        route_dist = '65000:100'
436        esi = {
437            'type': ESI_TYPE_LACP,
438            'mac_addr': 'aa:bb:cc:dd:ee:ff',
439            'port_key': 100,
440        }
441        ethernet_tag_id = EVPN_MAX_ET
442        expected_kwargs = {
443            'route_type': route_type,
444            'route_dist': route_dist,
445            'esi': esi,
446            'ethernet_tag_id': ethernet_tag_id,
447        }
448
449        # Test
450        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
451        speaker.evpn_prefix_del(
452            route_type=route_type,
453            route_dist=route_dist,
454            esi=esi,
455            ethernet_tag_id=ethernet_tag_id,
456        )
457
458        # Check
459        mock_call.assert_called_with(
460            'evpn_prefix.delete_local', **expected_kwargs)
461
462    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
463                mock.MagicMock(return_value=None))
464    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
465    def test_evpn_prefix_del_mac_ip_adv(self, mock_call):
466        # Prepare test data
467        route_type = bgpspeaker.EVPN_MAC_IP_ADV_ROUTE
468        route_dist = '65000:100'
469        ethernet_tag_id = 200
470        mac_addr = 'aa:bb:cc:dd:ee:ff'
471        ip_addr = '192.168.0.1'
472        expected_kwargs = {
473            'route_type': route_type,
474            'route_dist': route_dist,
475            'ethernet_tag_id': ethernet_tag_id,
476            'mac_addr': mac_addr,
477            'ip_addr': ip_addr,
478        }
479
480        # Test
481        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
482        speaker.evpn_prefix_del(
483            route_type=route_type,
484            route_dist=route_dist,
485            ethernet_tag_id=ethernet_tag_id,
486            mac_addr=mac_addr,
487            ip_addr=ip_addr,
488        )
489
490        # Check
491        mock_call.assert_called_with(
492            'evpn_prefix.delete_local', **expected_kwargs)
493
494    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
495                mock.MagicMock(return_value=None))
496    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
497    def test_evpn_prefix_del_multicast_etag(self, mock_call):
498        # Prepare test data
499        route_type = bgpspeaker.EVPN_MULTICAST_ETAG_ROUTE
500        route_dist = '65000:100'
501        esi = 0  # denotes single-homed
502        ethernet_tag_id = 200
503        mac_addr = 'aa:bb:cc:dd:ee:ff'
504        ip_addr = '192.168.0.1'
505        expected_kwargs = {
506            'route_type': route_type,
507            'route_dist': route_dist,
508            # 'esi': esi,  # should be ignored
509            'ethernet_tag_id': ethernet_tag_id,
510            # 'mac_addr': mac_addr,  # should be ignored
511            'ip_addr': ip_addr,
512        }
513
514        # Test
515        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
516        speaker.evpn_prefix_del(
517            route_type=route_type,
518            route_dist=route_dist,
519            esi=esi,
520            ethernet_tag_id=ethernet_tag_id,
521            mac_addr=mac_addr,
522            ip_addr=ip_addr,
523        )
524
525        # Check
526        mock_call.assert_called_with(
527            'evpn_prefix.delete_local', **expected_kwargs)
528
529    @raises(ValueError)
530    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
531                mock.MagicMock(return_value=None))
532    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
533    def test_evpn_prefix_del_invalid_route_type(self, mock_call):
534        # Prepare test data
535        route_type = 'foobar'  # Invalid EVPN route type
536        route_dist = '65000:100'
537        esi = 0  # denotes single-homed
538        ethernet_tag_id = 200
539        mac_addr = 'aa:bb:cc:dd:ee:ff'
540        ip_addr = '192.168.0.1'
541
542        # Test
543        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
544        speaker.evpn_prefix_del(
545            route_type=route_type,
546            route_dist=route_dist,
547            esi=esi,
548            ethernet_tag_id=ethernet_tag_id,
549            mac_addr=mac_addr,
550            ip_addr=ip_addr,
551        )
552
553        # Check
554        mock_call.assert_called_with(
555            'evpn_prefix.delete_local', 'Invalid arguments detected')
556
557    @mock.patch(
558        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
559        mock.MagicMock(return_value=None))
560    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
561    def test_evpn_prefix_del_eth_segment(self, mock_call):
562        # Prepare test data
563        route_type = bgpspeaker.EVPN_ETH_SEGMENT
564        route_dist = '65000:100'
565        esi = {
566            'esi_type': ESI_TYPE_MAC_BASED,
567            'mac_addr': 'aa:bb:cc:dd:ee:ff',
568            'local_disc': 100,
569        }
570        ip_addr = '192.168.0.1'
571        expected_kwargs = {
572            'route_type': route_type,
573            'route_dist': route_dist,
574            'esi': esi,
575            'ip_addr': ip_addr,
576        }
577
578        # Test
579        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
580        speaker.evpn_prefix_del(
581            route_type=route_type,
582            route_dist=route_dist,
583            esi=esi,
584            ip_addr=ip_addr,
585        )
586
587        # Check
588        mock_call.assert_called_with(
589            'evpn_prefix.delete_local', **expected_kwargs)
590
591    @mock.patch(
592        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
593        mock.MagicMock(return_value=None))
594    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
595    def test_evpn_prefix_del_ip_prefix_route(self, mock_call):
596        # Prepare test data
597        route_type = bgpspeaker.EVPN_IP_PREFIX_ROUTE
598        route_dist = '65000:100'
599        ethernet_tag_id = 200
600        ip_prefix = '192.168.0.0/24'
601        expected_kwargs = {
602            'route_type': route_type,
603            'route_dist': route_dist,
604            'ethernet_tag_id': ethernet_tag_id,
605            'ip_prefix': ip_prefix,
606        }
607
608        # Test
609        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
610        speaker.evpn_prefix_del(
611            route_type=route_type,
612            route_dist=route_dist,
613            ethernet_tag_id=ethernet_tag_id,
614            ip_prefix=ip_prefix,
615        )
616
617        # Check
618        mock_call.assert_called_with(
619            'evpn_prefix.delete_local', **expected_kwargs)
620
621    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
622                mock.MagicMock(return_value=None))
623    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
624    def test_evpn_prefix_add_pmsi_no_tunnel_info(self, mock_call):
625        # Prepare test data
626        route_type = bgpspeaker.EVPN_MULTICAST_ETAG_ROUTE
627        route_dist = '65000:100'
628        ethernet_tag_id = 200
629        next_hop = '0.0.0.0'
630        ip_addr = '192.168.0.1'
631        pmsi_tunnel_type = bgpspeaker.PMSI_TYPE_NO_TUNNEL_INFO
632        expected_kwargs = {
633            'route_type': route_type,
634            'route_dist': route_dist,
635            'ethernet_tag_id': ethernet_tag_id,
636            'next_hop': next_hop,
637            'ip_addr': ip_addr,
638            'pmsi_tunnel_type': pmsi_tunnel_type,
639        }
640
641        # Test
642        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
643        speaker.evpn_prefix_add(
644            route_type=route_type,
645            route_dist=route_dist,
646            ethernet_tag_id=ethernet_tag_id,
647            ip_addr=ip_addr,
648            pmsi_tunnel_type=pmsi_tunnel_type,
649        )
650
651        # Check
652        mock_call.assert_called_with(
653            'evpn_prefix.add_local', **expected_kwargs)
654
655    @mock.patch(
656        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
657        mock.MagicMock(return_value=None))
658    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
659    def test_evpn_prefix_add_pmsi_ingress_rep(self, mock_call):
660        # Prepare test data
661        route_type = bgpspeaker.EVPN_MULTICAST_ETAG_ROUTE
662        route_dist = '65000:100'
663        ethernet_tag_id = 200
664        next_hop = '0.0.0.0'
665        ip_addr = '192.168.0.1'
666        pmsi_tunnel_type = bgpspeaker.PMSI_TYPE_INGRESS_REP
667        expected_kwargs = {
668            'route_type': route_type,
669            'route_dist': route_dist,
670            'ethernet_tag_id': ethernet_tag_id,
671            'next_hop': next_hop,
672            'ip_addr': ip_addr,
673            'pmsi_tunnel_type': pmsi_tunnel_type,
674        }
675
676        # Test
677        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
678        speaker.evpn_prefix_add(
679            route_type=route_type,
680            route_dist=route_dist,
681            ethernet_tag_id=ethernet_tag_id,
682            ip_addr=ip_addr,
683            pmsi_tunnel_type=pmsi_tunnel_type,
684        )
685
686        # Check
687        mock_call.assert_called_with(
688            'evpn_prefix.add_local', **expected_kwargs)
689
690    @raises(ValueError)
691    @mock.patch(
692        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
693        mock.MagicMock(return_value=None))
694    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
695    def test_evpn_prefix_add_invalid_pmsi_tunnel_type(self, mock_call):
696        # Prepare test data
697        route_type = bgpspeaker.EVPN_MULTICAST_ETAG_ROUTE
698        route_dist = '65000:100'
699        ethernet_tag_id = 200
700        next_hop = '0.0.0.0'
701        ip_addr = '192.168.0.1'
702        pmsi_tunnel_type = 1
703
704        # Test
705        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
706        speaker.evpn_prefix_add(
707            route_type=route_type,
708            route_dist=route_dist,
709            ethernet_tag_id=ethernet_tag_id,
710            ip_addr=ip_addr,
711            pmsi_tunnel_type=pmsi_tunnel_type,
712        )
713
714        # Check
715        mock_call.assert_called_with(
716            'evpn_prefix.add_local', 'Invalid arguments detected')
717
718    @mock.patch(
719        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
720        mock.MagicMock(return_value=None))
721    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
722    def test_flowspec_prefix_add_ipv4(self, mock_call):
723        # Prepare test data
724        flowspec_family = bgpspeaker.FLOWSPEC_FAMILY_IPV4
725        rules = {
726            'dst_prefix': '10.60.1.0/24',
727        }
728
729        actions = {
730            'traffic_marking': {
731                'dscp': 24,
732            }
733        }
734
735        expected_kwargs = {
736            'flowspec_family': flowspec_family,
737            'rules': rules,
738            'actions': actions,
739        }
740
741        # Test
742        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
743        speaker.flowspec_prefix_add(
744            flowspec_family=flowspec_family,
745            rules=rules,
746            actions=actions)
747
748        # Check
749        mock_call.assert_called_with(
750            'flowspec.add', **expected_kwargs)
751
752    @mock.patch(
753        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
754        mock.MagicMock(return_value=None))
755    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
756    def test_flowspec_prefix_add_ipv4_without_actions(self, mock_call):
757        # Prepare test data
758        flowspec_family = bgpspeaker.FLOWSPEC_FAMILY_IPV4
759        rules = {
760            'dst_prefix': '10.60.1.0/24',
761        }
762
763        expected_kwargs = {
764            'flowspec_family': flowspec_family,
765            'rules': rules,
766            'actions': {},
767        }
768
769        # Test
770        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
771        speaker.flowspec_prefix_add(
772            flowspec_family=flowspec_family,
773            rules=rules)
774
775        # Check
776        mock_call.assert_called_with(
777            'flowspec.add', **expected_kwargs)
778
779    @mock.patch(
780        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
781        mock.MagicMock(return_value=None))
782    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
783    def test_flowspec_prefix_del_ipv4(self, mock_call):
784        # Prepare test data
785        flowspec_family = bgpspeaker.FLOWSPEC_FAMILY_IPV4
786        rules = {
787            'dst_prefix': '10.60.1.0/24',
788        }
789
790        expected_kwargs = {
791            'flowspec_family': flowspec_family,
792            'rules': rules,
793        }
794
795        # Test
796        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
797        speaker.flowspec_prefix_del(
798            flowspec_family=flowspec_family,
799            rules=rules)
800
801        # Check
802        mock_call.assert_called_with(
803            'flowspec.del', **expected_kwargs)
804
805    @mock.patch(
806        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
807        mock.MagicMock(return_value=None))
808    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
809    def test_flowspec_prefix_add_vpnv4(self, mock_call):
810        # Prepare test data
811        flowspec_family = bgpspeaker.FLOWSPEC_FAMILY_VPNV4
812        route_dist = '65001:100'
813        rules = {
814            'dst_prefix': '10.70.1.0/24',
815        }
816
817        actions = {
818            'traffic_marking': {
819                'dscp': 24,
820            }
821        }
822
823        expected_kwargs = {
824            'flowspec_family': flowspec_family,
825            'route_dist': route_dist,
826            'rules': rules,
827            'actions': actions,
828        }
829
830        # Test
831        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
832        speaker.flowspec_prefix_add(
833            flowspec_family=flowspec_family,
834            route_dist=route_dist,
835            rules=rules,
836            actions=actions)
837
838        # Check
839        mock_call.assert_called_with(
840            'flowspec.add_local', **expected_kwargs)
841
842    @mock.patch(
843        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
844        mock.MagicMock(return_value=None))
845    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
846    def test_flowspec_prefix_del_vpnv4(self, mock_call):
847        # Prepare test data
848        flowspec_family = bgpspeaker.FLOWSPEC_FAMILY_VPNV4
849        route_dist = '65001:100'
850        rules = {
851            'dst_prefix': '10.70.1.0/24',
852        }
853
854        expected_kwargs = {
855            'flowspec_family': flowspec_family,
856            'route_dist': route_dist,
857            'rules': rules,
858        }
859
860        # Test
861        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
862        speaker.flowspec_prefix_del(
863            flowspec_family=flowspec_family,
864            route_dist=route_dist,
865            rules=rules)
866
867        # Check
868        mock_call.assert_called_with(
869            'flowspec.del_local', **expected_kwargs)
870
871    @mock.patch(
872        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
873        mock.MagicMock(return_value=None))
874    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
875    def test_flowspec_prefix_add_ipv6(self, mock_call):
876        # Prepare test data
877        flowspec_family = bgpspeaker.FLOWSPEC_FAMILY_IPV6
878        rules = {
879            'dst_prefix': '2001::3/128/32',
880        }
881
882        actions = {
883            'traffic_marking': {
884                'dscp': 24,
885            }
886        }
887
888        expected_kwargs = {
889            'flowspec_family': flowspec_family,
890            'rules': rules,
891            'actions': actions,
892        }
893
894        # Test
895        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
896        speaker.flowspec_prefix_add(
897            flowspec_family=flowspec_family,
898            rules=rules,
899            actions=actions)
900
901        # Check
902        mock_call.assert_called_with(
903            'flowspec.add', **expected_kwargs)
904
905    @mock.patch(
906        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
907        mock.MagicMock(return_value=None))
908    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
909    def test_flowspec_prefix_add_ipv6_without_actions(self, mock_call):
910        # Prepare test data
911        flowspec_family = bgpspeaker.FLOWSPEC_FAMILY_IPV6
912        rules = {
913            'dst_prefix': '2001::3/128/32',
914        }
915
916        expected_kwargs = {
917            'flowspec_family': flowspec_family,
918            'rules': rules,
919            'actions': {},
920        }
921
922        # Test
923        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
924        speaker.flowspec_prefix_add(
925            flowspec_family=flowspec_family,
926            rules=rules)
927
928        # Check
929        mock_call.assert_called_with(
930            'flowspec.add', **expected_kwargs)
931
932    @mock.patch(
933        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
934        mock.MagicMock(return_value=None))
935    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
936    def test_flowspec_prefix_del_ipv6(self, mock_call):
937        # Prepare test data
938        flowspec_family = bgpspeaker.FLOWSPEC_FAMILY_IPV6
939        rules = {
940            'dst_prefix': '2001::3/128/32',
941        }
942
943        expected_kwargs = {
944            'flowspec_family': flowspec_family,
945            'rules': rules,
946        }
947
948        # Test
949        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
950        speaker.flowspec_prefix_del(
951            flowspec_family=flowspec_family,
952            rules=rules)
953
954        # Check
955        mock_call.assert_called_with(
956            'flowspec.del', **expected_kwargs)
957
958    @mock.patch(
959        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
960        mock.MagicMock(return_value=None))
961    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
962    def test_flowspec_prefix_add_vpnv6(self, mock_call):
963        # Prepare test data
964        flowspec_family = bgpspeaker.FLOWSPEC_FAMILY_VPNV6
965        route_dist = '65001:100'
966        rules = {
967            'dst_prefix': '2001::3/128/32',
968        }
969
970        actions = {
971            'traffic_marking': {
972                'dscp': 24,
973            }
974        }
975
976        expected_kwargs = {
977            'flowspec_family': flowspec_family,
978            'route_dist': route_dist,
979            'rules': rules,
980            'actions': actions,
981        }
982
983        # Test
984        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
985        speaker.flowspec_prefix_add(
986            flowspec_family=flowspec_family,
987            route_dist=route_dist,
988            rules=rules,
989            actions=actions)
990
991        # Check
992        mock_call.assert_called_with(
993            'flowspec.add_local', **expected_kwargs)
994
995    @mock.patch(
996        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
997        mock.MagicMock(return_value=None))
998    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
999    def test_flowspec_prefix_del_vpnv6(self, mock_call):
1000        # Prepare test data
1001        flowspec_family = bgpspeaker.FLOWSPEC_FAMILY_VPNV6
1002        route_dist = '65001:100'
1003        rules = {
1004            'dst_prefix': '2001::3/128/32',
1005        }
1006
1007        expected_kwargs = {
1008            'flowspec_family': flowspec_family,
1009            'route_dist': route_dist,
1010            'rules': rules,
1011        }
1012
1013        # Test
1014        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
1015        speaker.flowspec_prefix_del(
1016            flowspec_family=flowspec_family,
1017            route_dist=route_dist,
1018            rules=rules)
1019
1020        # Check
1021        mock_call.assert_called_with(
1022            'flowspec.del_local', **expected_kwargs)
1023
1024    @mock.patch(
1025        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
1026        mock.MagicMock(return_value=None))
1027    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
1028    def test_flowspec_prefix_add_l2vpn(self, mock_call):
1029        # Prepare test data
1030        flowspec_family = bgpspeaker.FLOWSPEC_FAMILY_L2VPN
1031        route_dist = '65001:100'
1032        rules = {
1033            'dst_mac': '12:34:56:78:9a:bc',
1034        }
1035
1036        actions = {
1037            'traffic_marking': {
1038                'dscp': 24,
1039            }
1040        }
1041
1042        expected_kwargs = {
1043            'flowspec_family': flowspec_family,
1044            'route_dist': route_dist,
1045            'rules': rules,
1046            'actions': actions,
1047        }
1048
1049        # Test
1050        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
1051        speaker.flowspec_prefix_add(
1052            flowspec_family=flowspec_family,
1053            route_dist=route_dist,
1054            rules=rules,
1055            actions=actions)
1056
1057        # Check
1058        mock_call.assert_called_with(
1059            'flowspec.add_local', **expected_kwargs)
1060
1061    @mock.patch(
1062        'ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker.__init__',
1063        mock.MagicMock(return_value=None))
1064    @mock.patch('ryu.services.protocols.bgp.bgpspeaker.call')
1065    def test_flowspec_prefix_del_l2vpn(self, mock_call):
1066        # Prepare test data
1067        flowspec_family = bgpspeaker.FLOWSPEC_FAMILY_L2VPN
1068        route_dist = '65001:100'
1069        rules = {
1070            'dst_mac': '12:34:56:78:9a:bc',
1071        }
1072
1073        expected_kwargs = {
1074            'flowspec_family': flowspec_family,
1075            'route_dist': route_dist,
1076            'rules': rules,
1077        }
1078
1079        # Test
1080        speaker = bgpspeaker.BGPSpeaker(65000, '10.0.0.1')
1081        speaker.flowspec_prefix_del(
1082            flowspec_family=flowspec_family,
1083            route_dist=route_dist,
1084            rules=rules)
1085
1086        # Check
1087        mock_call.assert_called_with(
1088            'flowspec.del_local', **expected_kwargs)
1089