ryu/build/lib.linux-armv7l-2.7/ryu/tests/unit/services/protocols/bgp/test_bgpspeaker.py

   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
  16 import unittest
  17 import logging
  18 try:
  19     import mock  # Python 2
  20 except ImportError:
  21     from unittest import mock  # Python 3
  22
  23 from nose.tools import raises
  24
  25 from ryu.services.protocols.bgp import bgpspeaker
  26 from ryu.services.protocols.bgp.bgpspeaker import EVPN_MAX_ET
  27 from ryu.services.protocols.bgp.bgpspeaker import ESI_TYPE_LACP
  28 from ryu.services.protocols.bgp.api.prefix import ESI_TYPE_L2_BRIDGE
  29 from ryu.services.protocols.bgp.bgpspeaker import ESI_TYPE_MAC_BASED
  30 from ryu.services.protocols.bgp.api.prefix import REDUNDANCY_MODE_ALL_ACTIVE
  31 from ryu.services.protocols.bgp.api.prefix import REDUNDANCY_MODE_SINGLE_ACTIVE
  32
  33
  34 LOG = logging.getLogger(__name__)
  35
  36
  37 class 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)