1# (c) 2021 Red Hat Inc. 2# 3# This file is part of Ansible 4# 5# Ansible is free software: you can redistribute it and/or modify 6# it under the terms of the GNU General Public License as published by 7# the Free Software Foundation, either version 3 of the License, or 8# (at your option) any later version. 9# 10# Ansible is distributed in the hope that it will be useful, 11# but WITHOUT ANY WARRANTY; without even the implied warranty of 12# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13# GNU General Public License for more details. 14# 15# You should have received a copy of the GNU General Public License 16# along with Ansible. If not, see <http://www.gnu.org/licenses/>. 17 18# Make coding more python3-ish 19 20from __future__ import absolute_import, division, print_function 21 22__metaclass__ = type 23 24from textwrap import dedent 25from ansible_collections.cisco.nxos.tests.unit.compat.mock import patch 26from ansible_collections.cisco.nxos.tests.unit.modules.utils import ( 27 AnsibleFailJson, 28) 29from ansible_collections.cisco.nxos.plugins.modules import ( 30 nxos_bgp_neighbor_address_family, 31) 32 33from .nxos_module import TestNxosModule, load_fixture, set_module_args 34 35ignore_provider_arg = True 36 37 38class TestNxosBGPNeighborAddressFamilyModule(TestNxosModule): 39 40 # Testing strategy 41 # ------------------ 42 # (a) The unit tests cover `merged` and `replaced` for every attribute. 43 # Since `overridden` is essentially `replaced` but at a larger 44 # scale, these indirectly cover `overridden` as well. 45 # (b) For linear attributes replaced is not valid and hence, those tests 46 # delete the attributes from the config subsection. 47 # (c) The argspec for VRFs is same as the top-level spec and the config logic 48 # is re-used. Hence, those attributes are not explictly covered. However, a 49 # combination of VRF + top-level spec + AF is tested. 50 51 module = nxos_bgp_neighbor_address_family 52 53 def setUp(self): 54 super(TestNxosBGPNeighborAddressFamilyModule, self).setUp() 55 56 self.mock_get_resource_connection = patch( 57 "ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.resource_module_base.get_resource_connection" 58 ) 59 self.get_resource_connection = ( 60 self.mock_get_resource_connection.start() 61 ) 62 63 self.mock_get_config = patch( 64 "ansible_collections.cisco.nxos.plugins.module_utils.network.nxos.facts.bgp_neighbor_address_family." 65 "bgp_neighbor_address_family.Bgp_neighbor_address_familyFacts.get_config" 66 ) 67 self.get_config = self.mock_get_config.start() 68 69 def tearDown(self): 70 super(TestNxosBGPNeighborAddressFamilyModule, self).tearDown() 71 self.get_resource_connection.stop() 72 self.get_config.stop() 73 74 def test_nxos_bgp_nbr_af_advertise_map_merged(self): 75 # test merged for advertise_map 76 self.get_config.return_value = dedent( 77 """\ 78 router bgp 65536 79 vrf site-1 80 neighbor 192.168.1.1 81 address-family ipv4 unicast 82 advertise-map rmap2 exist-map rmap3 83 address-family ipv4 multicast 84 advertise-map rmap1 non-exist-map rmap5 85 """ 86 ) 87 set_module_args( 88 dict( 89 config=dict( 90 as_number="65536", 91 neighbors=[ 92 dict( 93 neighbor_address="10.0.0.2", 94 address_family=[ 95 dict( 96 afi="ipv4", 97 safi="multicast", 98 advertise_map=dict( 99 route_map="rmap1", exist_map="rmap2" 100 ), 101 ) 102 ], 103 ) 104 ], 105 vrfs=[ 106 dict( 107 vrf="site-1", 108 neighbors=[ 109 dict( 110 neighbor_address="192.168.1.1", 111 address_family=[ 112 dict( 113 afi="ipv4", 114 safi="unicast", 115 advertise_map=dict( 116 route_map="rmap2", 117 exist_map="rmap3", 118 ), 119 ), 120 dict( 121 afi="ipv4", 122 safi="multicast", 123 advertise_map=dict( 124 route_map="rmap1", 125 non_exist_map="rmap7", 126 ), 127 ), 128 ], 129 ) 130 ], 131 ) 132 ], 133 ), 134 state="merged", 135 ), 136 ignore_provider_arg, 137 ) 138 commands = [ 139 "router bgp 65536", 140 "neighbor 10.0.0.2", 141 "address-family ipv4 multicast", 142 "advertise-map rmap1 exist-map rmap2", 143 "vrf site-1", 144 "neighbor 192.168.1.1", 145 "address-family ipv4 multicast", 146 "advertise-map rmap1 non-exist-map rmap7", 147 ] 148 result = self.execute_module(changed=True) 149 self.assertEqual(set(result["commands"]), set(commands)) 150 151 def test_nxos_bgp_nbr_af_advertise_map_replaced(self): 152 # test replaced for advertise_map 153 self.get_config.return_value = dedent( 154 """\ 155 router bgp 65536 156 neighbor 10.0.0.2 157 address-family ipv4 multicast 158 advertise-map rmap1 exist-map rmap2 159 vrf site-1 160 neighbor 192.168.1.1 161 address-family ipv4 unicast 162 advertise-map rmap2 exist-map rmap3 163 address-family ipv4 multicast 164 advertise-map rmap1 non-exist-map rmap5 165 """ 166 ) 167 set_module_args( 168 dict( 169 config=dict( 170 as_number="65536", 171 neighbors=[ 172 dict( 173 neighbor_address="10.0.0.2", 174 address_family=[ 175 dict( 176 afi="ipv4", 177 safi="multicast", 178 advertise_map=dict( 179 route_map="rmap1", exist_map="rmap3" 180 ), 181 ) 182 ], 183 ) 184 ], 185 vrfs=[ 186 dict( 187 vrf="site-1", 188 neighbors=[ 189 dict( 190 neighbor_address="192.168.1.1", 191 address_family=[ 192 dict( 193 afi="ipv4", 194 safi="unicast", 195 advertise_map=dict( 196 route_map="rmap2", 197 exist_map="rmap3", 198 ), 199 ), 200 dict(afi="ipv4", safi="multicast"), 201 ], 202 ) 203 ], 204 ) 205 ], 206 ), 207 state="replaced", 208 ), 209 ignore_provider_arg, 210 ) 211 commands = [ 212 "router bgp 65536", 213 "neighbor 10.0.0.2", 214 "address-family ipv4 multicast", 215 "advertise-map rmap1 exist-map rmap3", 216 "vrf site-1", 217 "neighbor 192.168.1.1", 218 "address-family ipv4 multicast", 219 "no advertise-map rmap1 non-exist-map rmap5", 220 ] 221 result = self.execute_module(changed=True) 222 self.assertEqual(set(result["commands"]), set(commands)) 223 224 def test_nxos_bgp_nbr_af_advertisement_interval_merged(self): 225 # test merged for advertisement_interval 226 self.get_config.return_value = dedent( 227 """\ 228 router bgp 65536 229 vrf site-1 230 neighbor 192.168.1.1 231 address-family ipv4 unicast 232 advertisement-interval 300 233 """ 234 ) 235 set_module_args( 236 dict( 237 config=dict( 238 as_number="65536", 239 neighbors=[ 240 dict( 241 neighbor_address="10.0.0.2", 242 address_family=[ 243 dict( 244 afi="ipv4", 245 safi="multicast", 246 advertisement_interval=350, 247 ) 248 ], 249 ) 250 ], 251 vrfs=[ 252 dict( 253 vrf="site-1", 254 neighbors=[ 255 dict( 256 neighbor_address="192.168.1.1", 257 address_family=[ 258 dict( 259 afi="ipv4", 260 safi="unicast", 261 advertisement_interval=300, 262 ), 263 dict( 264 afi="ipv4", 265 safi="multicast", 266 advertisement_interval=400, 267 ), 268 ], 269 ) 270 ], 271 ) 272 ], 273 ), 274 state="merged", 275 ), 276 ignore_provider_arg, 277 ) 278 commands = [ 279 "router bgp 65536", 280 "neighbor 10.0.0.2", 281 "address-family ipv4 multicast", 282 "advertisement-interval 350", 283 "vrf site-1", 284 "neighbor 192.168.1.1", 285 "address-family ipv4 multicast", 286 "advertisement-interval 400", 287 ] 288 result = self.execute_module(changed=True) 289 self.assertEqual(set(result["commands"]), set(commands)) 290 291 def test_nxos_bgp_nbr_af_advertisement_interval_replaced(self): 292 # test replaced for advertisement_interval 293 self.get_config.return_value = dedent( 294 """\ 295 router bgp 65536 296 neighbor 10.0.0.2 297 address-family ipv4 unicast 298 advertisement-interval 410 299 address-family ipv4 multicast 300 advertisement-interval 350 301 vrf site-1 302 neighbor 192.168.1.1 303 address-family ipv4 unicast 304 advertisement-interval 300 305 address-family ipv4 multicast 306 advertisement-interval 400 307 """ 308 ) 309 set_module_args( 310 dict( 311 config=dict( 312 as_number="65536", 313 neighbors=[ 314 dict( 315 neighbor_address="10.0.0.2", 316 address_family=[ 317 dict(afi="ipv4", safi="unicast"), 318 dict( 319 afi="ipv4", 320 safi="multicast", 321 advertisement_interval=350, 322 ), 323 ], 324 ) 325 ], 326 vrfs=[ 327 dict( 328 vrf="site-1", 329 neighbors=[ 330 dict( 331 neighbor_address="192.168.1.1", 332 address_family=[ 333 dict( 334 afi="ipv4", 335 safi="unicast", 336 advertisement_interval=300, 337 ), 338 dict(afi="ipv4", safi="multicast"), 339 ], 340 ) 341 ], 342 ) 343 ], 344 ), 345 state="replaced", 346 ), 347 ignore_provider_arg, 348 ) 349 commands = [ 350 "router bgp 65536", 351 "neighbor 10.0.0.2", 352 "address-family ipv4 unicast", 353 "no advertisement-interval 410", 354 "vrf site-1", 355 "neighbor 192.168.1.1", 356 "address-family ipv4 multicast", 357 "no advertisement-interval 400", 358 ] 359 result = self.execute_module(changed=True) 360 self.assertEqual(set(result["commands"]), set(commands)) 361 362 def test_nxos_bgp_nbr_af_allowas_in_merged(self): 363 # test merged for allowas_in 364 self.get_config.return_value = dedent( 365 """\ 366 router bgp 65536 367 vrf site-1 368 neighbor 192.168.1.1 369 address-family ipv4 unicast 370 allowas-in 3 371 address-family ipv4 multicast 372 allowas-in 3 373 """ 374 ) 375 set_module_args( 376 dict( 377 config=dict( 378 as_number="65536", 379 neighbors=[ 380 dict( 381 neighbor_address="10.0.0.2", 382 address_family=[ 383 dict( 384 afi="ipv4", 385 safi="multicast", 386 allowas_in=dict(max_occurences=8), 387 ) 388 ], 389 ) 390 ], 391 vrfs=[ 392 dict( 393 vrf="site-1", 394 neighbors=[ 395 dict( 396 neighbor_address="192.168.1.1", 397 address_family=[ 398 dict( 399 afi="ipv4", 400 safi="unicast", 401 allowas_in=dict(max_occurences=5), 402 ), 403 dict( 404 afi="ipv4", 405 safi="multicast", 406 allowas_in=dict(max_occurences=3), 407 ), 408 ], 409 ) 410 ], 411 ) 412 ], 413 ), 414 state="merged", 415 ), 416 ignore_provider_arg, 417 ) 418 commands = [ 419 "router bgp 65536", 420 "neighbor 10.0.0.2", 421 "address-family ipv4 multicast", 422 "allowas-in 8", 423 "vrf site-1", 424 "neighbor 192.168.1.1", 425 "address-family ipv4 unicast", 426 "allowas-in 5", 427 ] 428 result = self.execute_module(changed=True) 429 self.assertEqual(set(result["commands"]), set(commands)) 430 431 def test_nxos_bgp_nbr_af_allowas_in_replaced(self): 432 # test replaced for allowas_in 433 self.get_config.return_value = dedent( 434 """\ 435 router bgp 65536 436 neighbor 10.0.0.2 437 address-family ipv4 multicast 438 allowas-in 8 439 vrf site-1 440 neighbor 192.168.1.1 441 address-family ipv4 unicast 442 allowas-in 5 443 address-family ipv4 multicast 444 allowas-in 3 445 """ 446 ) 447 set_module_args( 448 dict( 449 config=dict( 450 as_number="65536", 451 neighbors=[ 452 dict( 453 neighbor_address="10.0.0.2", 454 address_family=[ 455 dict( 456 afi="ipv4", 457 safi="multicast", 458 allowas_in=dict(max_occurences=9), 459 ) 460 ], 461 ) 462 ], 463 vrfs=[ 464 dict( 465 vrf="site-1", 466 neighbors=[ 467 dict( 468 neighbor_address="192.168.1.1", 469 address_family=[ 470 dict( 471 afi="ipv4", 472 safi="unicast", 473 allowas_in=dict(max_occurences=5), 474 ), 475 dict(afi="ipv4", safi="multicast"), 476 ], 477 ) 478 ], 479 ) 480 ], 481 ), 482 state="replaced", 483 ), 484 ignore_provider_arg, 485 ) 486 commands = [ 487 "router bgp 65536", 488 "neighbor 10.0.0.2", 489 "address-family ipv4 multicast", 490 "allowas-in 9", 491 "vrf site-1", 492 "neighbor 192.168.1.1", 493 "address-family ipv4 multicast", 494 "no allowas-in 3", 495 ] 496 result = self.execute_module(changed=True) 497 self.assertEqual(set(result["commands"]), set(commands)) 498 499 def test_nxos_bgp_nbr_af_as_override_merged(self): 500 # test merged for as_override 501 self.get_config.return_value = dedent( 502 """\ 503 router bgp 65536 504 neighbor 10.0.0.2 505 remote-as 65545 506 vrf site-1 507 neighbor 192.168.1.1 508 remote-as 65545 509 address-family ipv4 unicast 510 as-override 511 address-family ipv4 multicast 512 as-override 513 """ 514 ) 515 set_module_args( 516 dict( 517 config=dict( 518 as_number="65536", 519 neighbors=[ 520 dict( 521 neighbor_address="10.0.0.2", 522 address_family=[ 523 dict( 524 afi="ipv4", 525 safi="multicast", 526 as_override=True, 527 ) 528 ], 529 ) 530 ], 531 vrfs=[ 532 dict( 533 vrf="site-1", 534 neighbors=[ 535 dict( 536 neighbor_address="192.168.1.1", 537 address_family=[ 538 dict( 539 afi="ipv4", 540 safi="unicast", 541 as_override=True, 542 ), 543 dict( 544 afi="ipv4", 545 safi="multicast", 546 as_override=False, 547 ), 548 ], 549 ) 550 ], 551 ) 552 ], 553 ), 554 state="merged", 555 ), 556 ignore_provider_arg, 557 ) 558 commands = [ 559 "router bgp 65536", 560 "neighbor 10.0.0.2", 561 "address-family ipv4 multicast", 562 "as-override", 563 "vrf site-1", 564 "neighbor 192.168.1.1", 565 "address-family ipv4 multicast", 566 "no as-override", 567 ] 568 result = self.execute_module(changed=True) 569 self.assertEqual(set(result["commands"]), set(commands)) 570 571 def test_nxos_bgp_nbr_af_as_override_replaced(self): 572 # test replaced for as_override 573 self.get_config.return_value = dedent( 574 """\ 575 router bgp 65536 576 neighbor 10.0.0.2 577 remote-as 65545 578 address-family ipv4 multicast 579 as-override 580 vrf site-1 581 neighbor 192.168.1.1 582 remote-as 65545 583 address-family ipv4 unicast 584 as-override 585 address-family ipv4 multicast 586 as-override 587 """ 588 ) 589 set_module_args( 590 dict( 591 config=dict( 592 as_number="65536", 593 neighbors=[ 594 dict( 595 neighbor_address="10.0.0.2", 596 address_family=[ 597 dict(afi="ipv4", safi="multicast") 598 ], 599 ) 600 ], 601 vrfs=[ 602 dict( 603 vrf="site-1", 604 neighbors=[ 605 dict( 606 neighbor_address="192.168.1.1", 607 address_family=[ 608 dict( 609 afi="ipv4", 610 safi="unicast", 611 as_override=True, 612 ), 613 dict(afi="ipv4", safi="multicast"), 614 ], 615 ) 616 ], 617 ) 618 ], 619 ), 620 state="replaced", 621 ), 622 ignore_provider_arg, 623 ) 624 commands = [ 625 "router bgp 65536", 626 "neighbor 10.0.0.2", 627 "address-family ipv4 multicast", 628 "no as-override", 629 "vrf site-1", 630 "neighbor 192.168.1.1", 631 "address-family ipv4 multicast", 632 "no as-override", 633 ] 634 result = self.execute_module(changed=True) 635 self.assertEqual(set(result["commands"]), set(commands)) 636 637 def test_nxos_bgp_nbr_af_capability_merged(self): 638 # test merged for capability 639 self.get_config.return_value = dedent( 640 """\ 641 router bgp 65536 642 vrf site-1 643 neighbor 192.168.1.1 644 address-family ipv4 unicast 645 capability additional-paths receive 646 capability additional-paths send disable 647 address-family ipv4 multicast 648 capability additional-paths receive disable 649 capability additional-paths send 650 """ 651 ) 652 set_module_args( 653 dict( 654 config=dict( 655 as_number="65536", 656 neighbors=[ 657 dict( 658 neighbor_address="10.0.0.2", 659 address_family=[ 660 dict( 661 afi="ipv4", 662 safi="multicast", 663 capability=dict( 664 additional_paths=dict( 665 receive="enable", send="enable" 666 ) 667 ), 668 ) 669 ], 670 ) 671 ], 672 vrfs=[ 673 dict( 674 vrf="site-1", 675 neighbors=[ 676 dict( 677 neighbor_address="192.168.1.1", 678 address_family=[ 679 dict( 680 afi="ipv4", 681 safi="unicast", 682 capability=dict( 683 additional_paths=dict( 684 receive="disable", 685 send="enable", 686 ) 687 ), 688 ), 689 dict( 690 afi="ipv4", 691 safi="multicast", 692 capability=dict( 693 additional_paths=dict( 694 receive="enable", 695 send="disable", 696 ) 697 ), 698 ), 699 ], 700 ) 701 ], 702 ) 703 ], 704 ), 705 state="merged", 706 ), 707 ignore_provider_arg, 708 ) 709 commands = [ 710 "router bgp 65536", 711 "neighbor 10.0.0.2", 712 "address-family ipv4 multicast", 713 "capability additional-paths receive", 714 "capability additional-paths send", 715 "vrf site-1", 716 "neighbor 192.168.1.1", 717 "address-family ipv4 unicast", 718 "capability additional-paths receive disable", 719 "capability additional-paths send", 720 "address-family ipv4 multicast", 721 "capability additional-paths receive", 722 "capability additional-paths send disable", 723 ] 724 result = self.execute_module(changed=True) 725 self.assertEqual(set(result["commands"]), set(commands)) 726 727 def test_nxos_bgp_nbr_af_capability_replaced(self): 728 # test replaced for capability 729 self.get_config.return_value = dedent( 730 """\ 731 router bgp 65536 732 neighbor 10.0.0.2 733 address-family ipv4 multicast 734 capability additional-paths receive 735 capability additional-paths send 736 vrf site-1 737 neighbor 192.168.1.1 738 address-family ipv4 unicast 739 capability additional-paths receive disable 740 capability additional-paths send 741 address-family ipv4 multicast 742 capability additional-paths receive 743 capability additional-paths send disable 744 """ 745 ) 746 set_module_args( 747 dict( 748 config=dict( 749 as_number="65536", 750 neighbors=[ 751 dict( 752 neighbor_address="10.0.0.2", 753 address_family=[ 754 dict( 755 afi="ipv4", 756 safi="multicast", 757 capability=dict( 758 additional_paths=dict(send="enable") 759 ), 760 ) 761 ], 762 ) 763 ], 764 vrfs=[ 765 dict( 766 vrf="site-1", 767 neighbors=[ 768 dict( 769 neighbor_address="192.168.1.1", 770 address_family=[ 771 dict( 772 afi="ipv4", 773 safi="unicast", 774 capability=dict( 775 additional_paths=dict( 776 receive="disable", 777 send="enable", 778 ) 779 ), 780 ), 781 dict(afi="ipv4", safi="multicast"), 782 ], 783 ) 784 ], 785 ) 786 ], 787 ), 788 state="replaced", 789 ), 790 ignore_provider_arg, 791 ) 792 commands = [ 793 "router bgp 65536", 794 "neighbor 10.0.0.2", 795 "address-family ipv4 multicast", 796 "no capability additional-paths receive", 797 "vrf site-1", 798 "neighbor 192.168.1.1", 799 "address-family ipv4 multicast", 800 "no capability additional-paths receive", 801 "no capability additional-paths send disable", 802 ] 803 result = self.execute_module(changed=True) 804 self.assertEqual(set(result["commands"]), set(commands)) 805 806 def test_nxos_bgp_nbr_af_originate_peer_as_merged(self): 807 # test merged for default_originate, disable_peer_as_check 808 self.get_config.return_value = dedent( 809 """\ 810 router bgp 65536 811 vrf site-1 812 neighbor 192.168.1.1 813 address-family ipv4 unicast 814 default-originate 815 disable-peer-as-check 816 address-family ipv4 multicast 817 default-originate route-map rmap1 818 """ 819 ) 820 set_module_args( 821 dict( 822 config=dict( 823 as_number="65536", 824 neighbors=[ 825 dict( 826 neighbor_address="10.0.0.2", 827 address_family=[ 828 dict( 829 afi="ipv4", 830 safi="multicast", 831 default_originate=dict(set=True), 832 ), 833 dict( 834 afi="ipv4", 835 safi="unicast", 836 disable_peer_as_check=True, 837 default_originate=dict(route_map="rmap1"), 838 ), 839 ], 840 ) 841 ], 842 vrfs=[ 843 dict( 844 vrf="site-1", 845 neighbors=[ 846 dict( 847 neighbor_address="192.168.1.1", 848 address_family=[ 849 dict( 850 afi="ipv4", 851 safi="unicast", 852 disable_peer_as_check=True, 853 default_originate=dict(set=True), 854 ), 855 dict( 856 afi="ipv4", 857 safi="multicast", 858 default_originate=dict( 859 route_map="rmap2" 860 ), 861 ), 862 ], 863 ) 864 ], 865 ) 866 ], 867 ), 868 state="merged", 869 ), 870 ignore_provider_arg, 871 ) 872 commands = [ 873 "router bgp 65536", 874 "neighbor 10.0.0.2", 875 "address-family ipv4 multicast", 876 "default-originate", 877 "address-family ipv4 unicast", 878 "default-originate route-map rmap1", 879 "disable-peer-as-check", 880 "vrf site-1", 881 "neighbor 192.168.1.1", 882 "address-family ipv4 multicast", 883 "default-originate route-map rmap2", 884 ] 885 result = self.execute_module(changed=True) 886 self.assertEqual(set(result["commands"]), set(commands)) 887 888 def test_nxos_bgp_nbr_af_originate_peer_as_merged(self): 889 # test merged for default_originate, disable_peer_as_check 890 self.get_config.return_value = dedent( 891 """\ 892 router bgp 65536 893 neighbor 10.0.0.2 894 address-family ipv4 multicast 895 default-originate 896 address-family ipv4 unicast 897 default-originate route-map rmap1 898 disable-peer-as-check 899 vrf site-1 900 neighbor 192.168.1.1 901 address-family ipv4 unicast 902 default-originate 903 disable-peer-as-check 904 address-family ipv4 multicast 905 default-originate route-map rmap1 906 """ 907 ) 908 set_module_args( 909 dict( 910 config=dict( 911 as_number="65536", 912 neighbors=[ 913 dict( 914 neighbor_address="10.0.0.2", 915 address_family=[ 916 dict(afi="ipv4", safi="multicast"), 917 dict( 918 afi="ipv4", 919 safi="unicast", 920 default_originate=dict(route_map="rmap1"), 921 ), 922 ], 923 ) 924 ], 925 vrfs=[ 926 dict( 927 vrf="site-1", 928 neighbors=[ 929 dict( 930 neighbor_address="192.168.1.1", 931 address_family=[ 932 dict( 933 afi="ipv4", 934 safi="unicast", 935 disable_peer_as_check=True, 936 default_originate=dict(set=True), 937 ), 938 dict(afi="ipv4", safi="multicast"), 939 ], 940 ) 941 ], 942 ) 943 ], 944 ), 945 state="replaced", 946 ), 947 ignore_provider_arg, 948 ) 949 commands = [ 950 "router bgp 65536", 951 "neighbor 10.0.0.2", 952 "address-family ipv4 multicast", 953 "no default-originate", 954 "address-family ipv4 unicast", 955 "no disable-peer-as-check", 956 "vrf site-1", 957 "neighbor 192.168.1.1", 958 "address-family ipv4 multicast", 959 "no default-originate route-map rmap1", 960 ] 961 result = self.execute_module(changed=True) 962 self.assertEqual(set(result["commands"]), set(commands)) 963 964 def test_nxos_bgp_nbr_af_filter_list_inherit_merged(self): 965 # test merged for filter_list, inherit 966 self.get_config.return_value = dedent( 967 """\ 968 router bgp 65536 969 vrf site-1 970 neighbor 192.168.1.1 971 address-family ipv4 unicast 972 filter-list rmap1 in 973 filter-list rmap2 out 974 inherit peer-policy template-1 100 975 address-family ipv4 multicast 976 filter-list rmap1 out 977 inherit peer-policy template-1 300 978 """ 979 ) 980 set_module_args( 981 dict( 982 config=dict( 983 as_number="65536", 984 neighbors=[ 985 dict( 986 neighbor_address="10.0.0.2", 987 address_family=[ 988 dict( 989 afi="ipv4", 990 safi="multicast", 991 filter_list=dict( 992 inbound="rmap3", outbound="rmap4" 993 ), 994 inherit=dict( 995 template="template-2", sequence=200 996 ), 997 ) 998 ], 999 ) 1000 ], 1001 vrfs=[ 1002 dict( 1003 vrf="site-1", 1004 neighbors=[ 1005 dict( 1006 neighbor_address="192.168.1.1", 1007 address_family=[ 1008 dict( 1009 afi="ipv4", 1010 safi="unicast", 1011 filter_list=dict( 1012 inbound="rmap1", 1013 outbound="rmap2", 1014 ), 1015 inherit=dict( 1016 template="template-1", 1017 sequence=100, 1018 ), 1019 ), 1020 dict( 1021 afi="ipv4", 1022 safi="multicast", 1023 filter_list=dict(inbound="rmap2"), 1024 inherit=dict( 1025 template="template-1", 1026 sequence=400, 1027 ), 1028 ), 1029 ], 1030 ) 1031 ], 1032 ) 1033 ], 1034 ), 1035 state="merged", 1036 ), 1037 ignore_provider_arg, 1038 ) 1039 commands = [ 1040 "router bgp 65536", 1041 "neighbor 10.0.0.2", 1042 "address-family ipv4 multicast", 1043 "filter-list rmap3 in", 1044 "filter-list rmap4 out", 1045 "inherit peer-policy template-2 200", 1046 "vrf site-1", 1047 "neighbor 192.168.1.1", 1048 "address-family ipv4 multicast", 1049 "filter-list rmap2 in", 1050 "inherit peer-policy template-1 400", 1051 ] 1052 result = self.execute_module(changed=True) 1053 self.assertEqual(set(result["commands"]), set(commands)) 1054 1055 def test_nxos_bgp_nbr_af_filter_list_inherit_replaced(self): 1056 # test replaced for filter_list, inherit 1057 self.get_config.return_value = dedent( 1058 """\ 1059 router bgp 65536 1060 neighbor 10.0.0.2 1061 address-family ipv4 multicast 1062 filter-list rmap3 in 1063 filter-list rmap4 out 1064 inherit peer-policy template-2 200 1065 vrf site-1 1066 neighbor 192.168.1.1 1067 address-family ipv4 unicast 1068 filter-list rmap1 in 1069 filter-list rmap2 out 1070 inherit peer-policy template-1 100 1071 address-family ipv4 multicast 1072 filter-list rmap1 out 1073 filter-list rmap2 in 1074 inherit peer-policy template-1 300 1075 """ 1076 ) 1077 set_module_args( 1078 dict( 1079 config=dict( 1080 as_number="65536", 1081 neighbors=[ 1082 dict( 1083 neighbor_address="10.0.0.2", 1084 address_family=[ 1085 dict( 1086 afi="ipv4", 1087 safi="multicast", 1088 filter_list=dict(inbound="rmap3"), 1089 inherit=dict( 1090 template="template-2", sequence=200 1091 ), 1092 ) 1093 ], 1094 ) 1095 ], 1096 vrfs=[ 1097 dict( 1098 vrf="site-1", 1099 neighbors=[ 1100 dict( 1101 neighbor_address="192.168.1.1", 1102 address_family=[ 1103 dict( 1104 afi="ipv4", 1105 safi="unicast", 1106 filter_list=dict( 1107 inbound="rmap1", 1108 outbound="rmap2", 1109 ), 1110 inherit=dict( 1111 template="template-1", 1112 sequence=100, 1113 ), 1114 ), 1115 dict(afi="ipv4", safi="multicast"), 1116 ], 1117 ) 1118 ], 1119 ) 1120 ], 1121 ), 1122 state="replaced", 1123 ), 1124 ignore_provider_arg, 1125 ) 1126 commands = [ 1127 "router bgp 65536", 1128 "neighbor 10.0.0.2", 1129 "address-family ipv4 multicast", 1130 "no filter-list rmap4 out", 1131 "vrf site-1", 1132 "neighbor 192.168.1.1", 1133 "address-family ipv4 multicast", 1134 "no filter-list rmap2 in", 1135 "no filter-list rmap1 out", 1136 "no inherit peer-policy template-1 300", 1137 ] 1138 result = self.execute_module(changed=True) 1139 self.assertEqual(set(result["commands"]), set(commands)) 1140 1141 def test_nxos_bgp_nbr_af_maximum_prefix_merged(self): 1142 # test merged for maximum_prefix 1143 self.get_config.return_value = dedent( 1144 """\ 1145 router bgp 65536 1146 vrf site-1 1147 neighbor 192.168.1.1 1148 address-family ipv4 multicast 1149 maximum-prefix 12 1150 address-family ipv4 unicast 1151 maximum-prefix 12 80 1152 address-family ipv6 multicast 1153 maximum-prefix 12 85 warning-only 1154 address-family ipv6 unicast 1155 maximum-prefix 12 85 restart 1200 1156 """ 1157 ) 1158 set_module_args( 1159 dict( 1160 config=dict( 1161 as_number="65536", 1162 neighbors=[ 1163 dict( 1164 neighbor_address="10.0.0.2", 1165 address_family=[ 1166 dict( 1167 afi="ipv4", 1168 safi="multicast", 1169 maximum_prefix=dict(max_prefix_limit=20), 1170 ), 1171 dict( 1172 afi="ipv4", 1173 safi="unicast", 1174 maximum_prefix=dict( 1175 max_prefix_limit=25, 1176 generate_warning_threshold=85, 1177 ), 1178 ), 1179 dict( 1180 afi="ipv6", 1181 safi="multicast", 1182 maximum_prefix=dict( 1183 max_prefix_limit=28, 1184 generate_warning_threshold=90, 1185 warning_only=True, 1186 ), 1187 ), 1188 dict( 1189 afi="ipv6", 1190 safi="unicast", 1191 maximum_prefix=dict( 1192 max_prefix_limit=30, 1193 generate_warning_threshold=95, 1194 restart_interval=1200, 1195 ), 1196 ), 1197 ], 1198 ) 1199 ], 1200 vrfs=[ 1201 dict( 1202 vrf="site-1", 1203 neighbors=[ 1204 dict( 1205 neighbor_address="192.168.1.1", 1206 address_family=[ 1207 dict( 1208 afi="ipv4", 1209 safi="multicast", 1210 maximum_prefix=dict( 1211 max_prefix_limit=28 1212 ), 1213 ), 1214 dict( 1215 afi="ipv4", 1216 safi="unicast", 1217 maximum_prefix=dict( 1218 max_prefix_limit=12, 1219 generate_warning_threshold=80, 1220 ), 1221 ), 1222 dict( 1223 afi="ipv6", 1224 safi="multicast", 1225 maximum_prefix=dict( 1226 max_prefix_limit=12, 1227 generate_warning_threshold=85, 1228 warning_only=True, 1229 ), 1230 ), 1231 dict( 1232 afi="ipv6", 1233 safi="unicast", 1234 maximum_prefix=dict( 1235 max_prefix_limit=12, 1236 generate_warning_threshold=85, 1237 restart_interval=1200, 1238 ), 1239 ), 1240 ], 1241 ) 1242 ], 1243 ) 1244 ], 1245 ), 1246 state="merged", 1247 ), 1248 ignore_provider_arg, 1249 ) 1250 commands = [ 1251 "router bgp 65536", 1252 "neighbor 10.0.0.2", 1253 "address-family ipv4 multicast", 1254 "maximum-prefix 20", 1255 "address-family ipv4 unicast", 1256 "maximum-prefix 25 85", 1257 "address-family ipv6 multicast", 1258 "maximum-prefix 28 90 warning-only", 1259 "address-family ipv6 unicast", 1260 "maximum-prefix 30 95 restart 1200", 1261 "vrf site-1", 1262 "neighbor 192.168.1.1", 1263 "address-family ipv4 multicast", 1264 "maximum-prefix 28", 1265 ] 1266 result = self.execute_module(changed=True) 1267 self.assertEqual(set(result["commands"]), set(commands)) 1268 1269 def test_nxos_bgp_nbr_af_maximum_prefix_replaced(self): 1270 # test replaced for maximum_prefix 1271 self.get_config.return_value = dedent( 1272 """\ 1273 router bgp 65536 1274 neighbor 10.0.0.2 1275 address-family ipv4 multicast 1276 maximum-prefix 20 1277 address-family ipv4 unicast 1278 maximum-prefix 25 85 1279 vrf site-1 1280 neighbor 192.168.1.1 1281 address-family ipv4 multicast 1282 maximum-prefix 12 1283 address-family ipv4 unicast 1284 maximum-prefix 12 80 1285 address-family ipv6 multicast 1286 maximum-prefix 12 85 warning-only 1287 address-family ipv6 unicast 1288 maximum-prefix 12 85 restart 1200 1289 """ 1290 ) 1291 set_module_args( 1292 dict( 1293 config=dict( 1294 as_number="65536", 1295 neighbors=[ 1296 dict( 1297 neighbor_address="10.0.0.2", 1298 address_family=[ 1299 dict(afi="ipv4", safi="unicast"), 1300 dict( 1301 afi="ipv4", 1302 safi="multicast", 1303 maximum_prefix=dict(max_prefix_limit=28), 1304 ), 1305 ], 1306 ) 1307 ], 1308 vrfs=[ 1309 dict( 1310 vrf="site-1", 1311 neighbors=[ 1312 dict( 1313 neighbor_address="192.168.1.1", 1314 address_family=[ 1315 dict( 1316 afi="ipv4", 1317 safi="multicast", 1318 maximum_prefix=dict( 1319 max_prefix_limit=28 1320 ), 1321 ), 1322 dict( 1323 afi="ipv4", 1324 safi="unicast", 1325 maximum_prefix=dict( 1326 max_prefix_limit=12, 1327 generate_warning_threshold=80, 1328 ), 1329 ), 1330 dict(afi="ipv6", safi="multicast"), 1331 dict(afi="ipv6", safi="unicast"), 1332 ], 1333 ) 1334 ], 1335 ) 1336 ], 1337 ), 1338 state="replaced", 1339 ), 1340 ignore_provider_arg, 1341 ) 1342 commands = [ 1343 "router bgp 65536", 1344 "neighbor 10.0.0.2", 1345 "address-family ipv4 unicast", 1346 "no maximum-prefix 25 85", 1347 "address-family ipv6 multicast", 1348 "maximum-prefix 28", 1349 "vrf site-1", 1350 "neighbor 192.168.1.1", 1351 "address-family ipv4 multicast", 1352 "maximum-prefix 28", 1353 "address-family ipv6 multicast", 1354 "no maximum-prefix 12 85 warning-only", 1355 "address-family ipv6 unicast", 1356 "no maximum-prefix 12 85 restart 1200", 1357 ] 1358 result = self.execute_module(changed=True) 1359 self.assertEqual(set(result["commands"]), set(commands)) 1360 1361 def test_nxos_bgp_nbr_af_next_hop_merged(self): 1362 # test merged for next_hop_self, next_hop_third_party 1363 self.get_config.return_value = dedent( 1364 """\ 1365 router bgp 65536 1366 vrf site-1 1367 neighbor 192.168.1.1 1368 address-family ipv4 unicast 1369 next-hop-self 1370 no next-hop-third-party 1371 address-family ipv4 multicast 1372 next-hop-self all 1373 """ 1374 ) 1375 set_module_args( 1376 dict( 1377 config=dict( 1378 as_number="65536", 1379 neighbors=[ 1380 dict( 1381 neighbor_address="10.0.0.2", 1382 address_family=[ 1383 dict( 1384 afi="ipv4", 1385 safi="multicast", 1386 next_hop_self=dict(set=True), 1387 ), 1388 dict( 1389 afi="ipv4", 1390 safi="unicast", 1391 next_hop_self=dict(all_routes=True), 1392 ), 1393 ], 1394 ) 1395 ], 1396 vrfs=[ 1397 dict( 1398 vrf="site-1", 1399 neighbors=[ 1400 dict( 1401 neighbor_address="192.168.1.1", 1402 address_family=[ 1403 dict( 1404 afi="ipv4", 1405 safi="unicast", 1406 next_hop_self=dict(set=True), 1407 next_hop_third_party=True, 1408 ), 1409 dict( 1410 afi="ipv4", 1411 safi="multicast", 1412 next_hop_self=dict( 1413 all_routes=True 1414 ), 1415 ), 1416 dict( 1417 afi="ipv6", 1418 safi="multicast", 1419 next_hop_self=dict( 1420 all_routes=True 1421 ), 1422 ), 1423 ], 1424 ) 1425 ], 1426 ) 1427 ], 1428 ), 1429 state="merged", 1430 ), 1431 ignore_provider_arg, 1432 ) 1433 commands = [ 1434 "router bgp 65536", 1435 "neighbor 10.0.0.2", 1436 "address-family ipv4 multicast", 1437 "next-hop-self", 1438 "address-family ipv4 unicast", 1439 "next-hop-self all", 1440 "vrf site-1", 1441 "neighbor 192.168.1.1", 1442 "address-family ipv4 unicast", 1443 "next-hop-third-party", 1444 "address-family ipv6 multicast", 1445 "next-hop-self all", 1446 ] 1447 result = self.execute_module(changed=True) 1448 self.assertEqual(set(result["commands"]), set(commands)) 1449 1450 def test_nxos_bgp_nbr_af_next_hop_replaced(self): 1451 # test replaced for next_hop_self, next_hop_third_party 1452 self.get_config.return_value = dedent( 1453 """\ 1454 router bgp 65536 1455 neighbor 10.0.0.2 1456 address-family ipv4 multicast 1457 next-hop-self 1458 address-family ipv4 unicast 1459 next-hop-self all 1460 vrf site-1 1461 neighbor 192.168.1.1 1462 address-family ipv4 unicast 1463 next-hop-self 1464 no next-hop-third-party 1465 address-family ipv4 multicast 1466 next-hop-self all 1467 """ 1468 ) 1469 set_module_args( 1470 dict( 1471 config=dict( 1472 as_number="65536", 1473 neighbors=[ 1474 dict( 1475 neighbor_address="10.0.0.2", 1476 address_family=[ 1477 dict(afi="ipv4", safi="multicast"), 1478 dict( 1479 afi="ipv4", 1480 safi="unicast", 1481 next_hop_self=dict(all_routes=True), 1482 ), 1483 ], 1484 ) 1485 ], 1486 vrfs=[ 1487 dict( 1488 vrf="site-1", 1489 neighbors=[ 1490 dict( 1491 neighbor_address="192.168.1.1", 1492 address_family=[ 1493 dict( 1494 afi="ipv4", 1495 safi="unicast", 1496 next_hop_third_party=True, 1497 ), 1498 dict( 1499 afi="ipv4", 1500 safi="multicast", 1501 next_hop_self=dict( 1502 all_routes=True 1503 ), 1504 ), 1505 ], 1506 ) 1507 ], 1508 ) 1509 ], 1510 ), 1511 state="replaced", 1512 ), 1513 ignore_provider_arg, 1514 ) 1515 commands = [ 1516 "router bgp 65536", 1517 "neighbor 10.0.0.2", 1518 "address-family ipv4 multicast", 1519 "no next-hop-self", 1520 "vrf site-1", 1521 "neighbor 192.168.1.1", 1522 "address-family ipv4 unicast", 1523 "no next-hop-self", 1524 "next-hop-third-party", 1525 ] 1526 result = self.execute_module(changed=True) 1527 self.assertEqual(set(result["commands"]), set(commands)) 1528 1529 def test_nxos_bgp_nbr_af_prefix_list_merged(self): 1530 # test merged for prefix_list 1531 self.get_config.return_value = dedent( 1532 """\ 1533 router bgp 65536 1534 vrf site-1 1535 neighbor 192.168.1.1 1536 address-family ipv4 unicast 1537 prefix-list rmap1 in 1538 prefix-list rmap2 out 1539 address-family ipv4 multicast 1540 prefix-list rmap1 out 1541 """ 1542 ) 1543 set_module_args( 1544 dict( 1545 config=dict( 1546 as_number="65536", 1547 neighbors=[ 1548 dict( 1549 neighbor_address="10.0.0.2", 1550 address_family=[ 1551 dict( 1552 afi="ipv4", 1553 safi="multicast", 1554 prefix_list=dict( 1555 inbound="rmap3", outbound="rmap4" 1556 ), 1557 ) 1558 ], 1559 ) 1560 ], 1561 vrfs=[ 1562 dict( 1563 vrf="site-1", 1564 neighbors=[ 1565 dict( 1566 neighbor_address="192.168.1.1", 1567 address_family=[ 1568 dict( 1569 afi="ipv4", 1570 safi="unicast", 1571 prefix_list=dict( 1572 inbound="rmap1", 1573 outbound="rmap2", 1574 ), 1575 ), 1576 dict( 1577 afi="ipv4", 1578 safi="multicast", 1579 prefix_list=dict(inbound="rmap2"), 1580 ), 1581 ], 1582 ) 1583 ], 1584 ) 1585 ], 1586 ), 1587 state="merged", 1588 ), 1589 ignore_provider_arg, 1590 ) 1591 commands = [ 1592 "router bgp 65536", 1593 "neighbor 10.0.0.2", 1594 "address-family ipv4 multicast", 1595 "prefix-list rmap3 in", 1596 "prefix-list rmap4 out", 1597 "vrf site-1", 1598 "neighbor 192.168.1.1", 1599 "address-family ipv4 multicast", 1600 "prefix-list rmap2 in", 1601 ] 1602 result = self.execute_module(changed=True) 1603 self.assertEqual(set(result["commands"]), set(commands)) 1604 1605 def test_nxos_bgp_nbr_af_prefix_list_replaced(self): 1606 # test replaced for prefix_list 1607 self.get_config.return_value = dedent( 1608 """\ 1609 router bgp 65536 1610 neighbor 10.0.0.2 1611 address-family ipv4 multicast 1612 prefix-list rmap3 in 1613 prefix-list rmap4 out 1614 vrf site-1 1615 neighbor 192.168.1.1 1616 address-family ipv4 unicast 1617 prefix-list rmap1 in 1618 prefix-list rmap2 out 1619 address-family ipv4 multicast 1620 prefix-list rmap1 out 1621 prefix-list rmap2 in 1622 """ 1623 ) 1624 set_module_args( 1625 dict( 1626 config=dict( 1627 as_number="65536", 1628 neighbors=[ 1629 dict( 1630 neighbor_address="10.0.0.2", 1631 address_family=[ 1632 dict( 1633 afi="ipv4", 1634 safi="multicast", 1635 prefix_list=dict(inbound="rmap3"), 1636 ) 1637 ], 1638 ) 1639 ], 1640 vrfs=[ 1641 dict( 1642 vrf="site-1", 1643 neighbors=[ 1644 dict( 1645 neighbor_address="192.168.1.1", 1646 address_family=[ 1647 dict( 1648 afi="ipv4", 1649 safi="unicast", 1650 prefix_list=dict( 1651 inbound="rmap1", 1652 outbound="rmap2", 1653 ), 1654 ), 1655 dict(afi="ipv4", safi="multicast"), 1656 ], 1657 ) 1658 ], 1659 ) 1660 ], 1661 ), 1662 state="replaced", 1663 ), 1664 ignore_provider_arg, 1665 ) 1666 commands = [ 1667 "router bgp 65536", 1668 "neighbor 10.0.0.2", 1669 "address-family ipv4 multicast", 1670 "no prefix-list rmap4 out", 1671 "vrf site-1", 1672 "neighbor 192.168.1.1", 1673 "address-family ipv4 multicast", 1674 "no prefix-list rmap2 in", 1675 "no prefix-list rmap1 out", 1676 ] 1677 result = self.execute_module(changed=True) 1678 self.assertEqual(set(result["commands"]), set(commands)) 1679 1680 def test_nxos_bgp_nbr_af_rewrite_evpn_route_map_merged(self): 1681 # test merged for rewrite_evpn_rt_asn, route_map 1682 self.get_config.return_value = dedent( 1683 """\ 1684 router bgp 65536 1685 vrf site-1 1686 neighbor 192.168.1.1 1687 address-family ipv4 unicast 1688 route-map rmap1 in 1689 route-map rmap2 out 1690 rewrite-evpn-rt-asn 1691 address-family ipv4 multicast 1692 route-map rmap1 out 1693 rewrite-evpn-rt-asn 1694 """ 1695 ) 1696 set_module_args( 1697 dict( 1698 config=dict( 1699 as_number="65536", 1700 neighbors=[ 1701 dict( 1702 neighbor_address="10.0.0.2", 1703 address_family=[ 1704 dict( 1705 afi="ipv4", 1706 safi="multicast", 1707 route_map=dict( 1708 inbound="rmap3", outbound="rmap4" 1709 ), 1710 rewrite_evpn_rt_asn=True, 1711 ) 1712 ], 1713 ) 1714 ], 1715 vrfs=[ 1716 dict( 1717 vrf="site-1", 1718 neighbors=[ 1719 dict( 1720 neighbor_address="192.168.1.1", 1721 address_family=[ 1722 dict( 1723 afi="ipv4", 1724 safi="unicast", 1725 route_map=dict( 1726 inbound="rmap1", 1727 outbound="rmap2", 1728 ), 1729 rewrite_evpn_rt_asn=True, 1730 ), 1731 dict( 1732 afi="ipv4", 1733 safi="multicast", 1734 route_map=dict(inbound="rmap2"), 1735 rewrite_evpn_rt_asn=True, 1736 ), 1737 ], 1738 ) 1739 ], 1740 ) 1741 ], 1742 ), 1743 state="merged", 1744 ), 1745 ignore_provider_arg, 1746 ) 1747 commands = [ 1748 "router bgp 65536", 1749 "neighbor 10.0.0.2", 1750 "address-family ipv4 multicast", 1751 "route-map rmap3 in", 1752 "route-map rmap4 out", 1753 "rewrite-evpn-rt-asn", 1754 "vrf site-1", 1755 "neighbor 192.168.1.1", 1756 "address-family ipv4 multicast", 1757 "route-map rmap2 in", 1758 "rewrite-evpn-rt-asn", 1759 ] 1760 result = self.execute_module(changed=True) 1761 self.assertEqual(set(result["commands"]), set(commands)) 1762 1763 def test_nxos_bgp_nbr_af_rewrite_evpn_route_map_replaced(self): 1764 # test replaced for rewrite_evpn_rt_asn, route_map 1765 self.get_config.return_value = dedent( 1766 """\ 1767 router bgp 65536 1768 neighbor 10.0.0.2 1769 address-family ipv4 multicast 1770 route-map rmap3 in 1771 route-map rmap4 out 1772 rewrite-evpn-rt-asn 1773 vrf site-1 1774 neighbor 192.168.1.1 1775 address-family ipv4 unicast 1776 route-map rmap1 in 1777 route-map rmap2 out 1778 rewrite-evpn-rt-asn 1779 address-family ipv4 multicast 1780 route-map rmap1 out 1781 route-map rmap2 in 1782 rewrite-evpn-rt-asn 1783 """ 1784 ) 1785 set_module_args( 1786 dict( 1787 config=dict( 1788 as_number="65536", 1789 neighbors=[ 1790 dict( 1791 neighbor_address="10.0.0.2", 1792 address_family=[ 1793 dict( 1794 afi="ipv4", 1795 safi="multicast", 1796 route_map=dict(inbound="rmap3"), 1797 rewrite_evpn_rt_asn=True, 1798 ) 1799 ], 1800 ) 1801 ], 1802 vrfs=[ 1803 dict( 1804 vrf="site-1", 1805 neighbors=[ 1806 dict( 1807 neighbor_address="192.168.1.1", 1808 address_family=[ 1809 dict( 1810 afi="ipv4", 1811 safi="unicast", 1812 route_map=dict( 1813 inbound="rmap1", 1814 outbound="rmap2", 1815 ), 1816 rewrite_evpn_rt_asn=True, 1817 ), 1818 dict(afi="ipv4", safi="multicast"), 1819 ], 1820 ) 1821 ], 1822 ) 1823 ], 1824 ), 1825 state="replaced", 1826 ), 1827 ignore_provider_arg, 1828 ) 1829 commands = [ 1830 "router bgp 65536", 1831 "neighbor 10.0.0.2", 1832 "address-family ipv4 multicast", 1833 "no route-map rmap4 out", 1834 "vrf site-1", 1835 "neighbor 192.168.1.1", 1836 "address-family ipv4 multicast", 1837 "no route-map rmap2 in", 1838 "no route-map rmap1 out", 1839 "no rewrite-evpn-rt-asn", 1840 ] 1841 result = self.execute_module(changed=True) 1842 self.assertEqual(set(result["commands"]), set(commands)) 1843 1844 def test_nxos_bgp_route_reflector_client_send_community_merged(self): 1845 # test merged for route_reflector_client 1846 self.get_config.return_value = dedent( 1847 """\ 1848 router bgp 65536 1849 vrf site-1 1850 neighbor 192.168.1.1 1851 address-family ipv4 unicast 1852 route-reflector-client 1853 send-community 1854 """ 1855 ) 1856 set_module_args( 1857 dict( 1858 config=dict( 1859 as_number="65536", 1860 neighbors=[ 1861 dict( 1862 neighbor_address="10.0.0.2", 1863 address_family=[ 1864 dict( 1865 afi="ipv4", 1866 safi="multicast", 1867 route_reflector_client=True, 1868 send_community=dict(extended=True), 1869 ) 1870 ], 1871 ) 1872 ], 1873 vrfs=[ 1874 dict( 1875 vrf="site-1", 1876 neighbors=[ 1877 dict( 1878 neighbor_address="192.168.1.1", 1879 address_family=[ 1880 dict( 1881 afi="ipv4", 1882 safi="unicast", 1883 route_reflector_client=True, 1884 send_community=dict(set=True), 1885 ), 1886 dict( 1887 afi="ipv4", 1888 safi="multicast", 1889 send_community=dict(set=True), 1890 ), 1891 ], 1892 ) 1893 ], 1894 ) 1895 ], 1896 ), 1897 state="merged", 1898 ), 1899 ignore_provider_arg, 1900 ) 1901 commands = [ 1902 "router bgp 65536", 1903 "neighbor 10.0.0.2", 1904 "address-family ipv4 multicast", 1905 "route-reflector-client", 1906 "send-community extended", 1907 "vrf site-1", 1908 "neighbor 192.168.1.1", 1909 "address-family ipv4 multicast", 1910 "send-community", 1911 ] 1912 result = self.execute_module(changed=True) 1913 self.assertEqual(set(result["commands"]), set(commands)) 1914 1915 def test_nxos_bgp_route_reflector_client_send_community_replaced(self): 1916 # test replaced for route_reflector_client 1917 self.get_config.return_value = dedent( 1918 """\ 1919 router bgp 65536 1920 neighbor 10.0.0.2 1921 address-family ipv4 multicast 1922 route-reflector-client 1923 send-community extended 1924 vrf site-1 1925 neighbor 192.168.1.1 1926 address-family ipv4 unicast 1927 route-reflector-client 1928 send-community 1929 address-family ipv4 multicast 1930 send-community 1931 """ 1932 ) 1933 set_module_args( 1934 dict( 1935 config=dict( 1936 as_number="65536", 1937 neighbors=[ 1938 dict( 1939 neighbor_address="10.0.0.2", 1940 address_family=[ 1941 dict( 1942 afi="ipv4", 1943 safi="multicast", 1944 send_community=dict(extended=True), 1945 ) 1946 ], 1947 ) 1948 ], 1949 vrfs=[ 1950 dict( 1951 vrf="site-1", 1952 neighbors=[ 1953 dict( 1954 neighbor_address="192.168.1.1", 1955 address_family=[ 1956 dict( 1957 afi="ipv4", 1958 safi="unicast", 1959 route_reflector_client=True, 1960 send_community=dict(set=True), 1961 ), 1962 dict(afi="ipv4", safi="multicast"), 1963 ], 1964 ) 1965 ], 1966 ) 1967 ], 1968 ), 1969 state="replaced", 1970 ), 1971 ignore_provider_arg, 1972 ) 1973 commands = [ 1974 "router bgp 65536", 1975 "neighbor 10.0.0.2", 1976 "address-family ipv4 multicast", 1977 "no route-reflector-client", 1978 "vrf site-1", 1979 "neighbor 192.168.1.1", 1980 "address-family ipv4 multicast", 1981 "no send-community", 1982 ] 1983 result = self.execute_module(changed=True) 1984 self.assertEqual(set(result["commands"]), set(commands)) 1985 1986 def test_nxos_bgp_nbr_af_soft_reconfiguration_soo_merged(self): 1987 # test merged for soft_reconfiguration_inbound, soo 1988 self.get_config.return_value = dedent( 1989 """\ 1990 router bgp 65536 1991 vrf site-1 1992 neighbor 192.168.1.1 1993 address-family ipv4 unicast 1994 soft-reconfiguration inbound always 1995 soo 65:28 1996 """ 1997 ) 1998 set_module_args( 1999 dict( 2000 config=dict( 2001 as_number="65536", 2002 neighbors=[ 2003 dict( 2004 neighbor_address="10.0.0.2", 2005 address_family=[ 2006 dict( 2007 afi="ipv4", 2008 safi="multicast", 2009 soft_reconfiguration_inbound=dict( 2010 set=True 2011 ), 2012 soo="73:43", 2013 ) 2014 ], 2015 ) 2016 ], 2017 vrfs=[ 2018 dict( 2019 vrf="site-1", 2020 neighbors=[ 2021 dict( 2022 neighbor_address="192.168.1.1", 2023 address_family=[ 2024 dict( 2025 afi="ipv4", 2026 safi="unicast", 2027 soft_reconfiguration_inbound=dict( 2028 always=True 2029 ), 2030 soo="65:28", 2031 ), 2032 dict( 2033 afi="ipv4", 2034 safi="multicast", 2035 soft_reconfiguration_inbound=dict( 2036 always=True 2037 ), 2038 ), 2039 ], 2040 ) 2041 ], 2042 ) 2043 ], 2044 ), 2045 state="merged", 2046 ), 2047 ignore_provider_arg, 2048 ) 2049 commands = [ 2050 "router bgp 65536", 2051 "neighbor 10.0.0.2", 2052 "address-family ipv4 multicast", 2053 "soft-reconfiguration inbound", 2054 "soo 73:43", 2055 "vrf site-1", 2056 "neighbor 192.168.1.1", 2057 "address-family ipv4 multicast", 2058 "soft-reconfiguration inbound always", 2059 ] 2060 result = self.execute_module(changed=True) 2061 self.assertEqual(set(result["commands"]), set(commands)) 2062 2063 def test_nxos_bgp_nbr_af_soft_reconfiguration_soo_replaced(self): 2064 # test replaced for soft_reconfiguration_inbound, soo 2065 self.get_config.return_value = dedent( 2066 """\ 2067 router bgp 65536 2068 neighbor 10.0.0.2 2069 address-family ipv4 multicast 2070 soft-reconfiguration inbound 2071 soo 73:43 2072 vrf site-1 2073 neighbor 192.168.1.1 2074 address-family ipv4 unicast 2075 soft-reconfiguration inbound always 2076 soo 65:28 2077 address-family ipv4 multicast 2078 soft-reconfiguration inbound always 2079 """ 2080 ) 2081 set_module_args( 2082 dict( 2083 config=dict( 2084 as_number="65536", 2085 neighbors=[ 2086 dict( 2087 neighbor_address="10.0.0.2", 2088 address_family=[ 2089 dict( 2090 afi="ipv4", 2091 safi="multicast", 2092 soft_reconfiguration_inbound=dict( 2093 set=True 2094 ), 2095 ) 2096 ], 2097 ) 2098 ], 2099 vrfs=[ 2100 dict( 2101 vrf="site-1", 2102 neighbors=[ 2103 dict( 2104 neighbor_address="192.168.1.1", 2105 address_family=[ 2106 dict( 2107 afi="ipv4", 2108 safi="unicast", 2109 soft_reconfiguration_inbound=dict( 2110 always=True 2111 ), 2112 soo="65:28", 2113 ), 2114 dict(afi="ipv4", safi="multicast"), 2115 ], 2116 ) 2117 ], 2118 ) 2119 ], 2120 ), 2121 state="replaced", 2122 ), 2123 ignore_provider_arg, 2124 ) 2125 commands = [ 2126 "router bgp 65536", 2127 "neighbor 10.0.0.2", 2128 "address-family ipv4 multicast", 2129 "no soo 73:43", 2130 "vrf site-1", 2131 "neighbor 192.168.1.1", 2132 "address-family ipv4 multicast", 2133 "no soft-reconfiguration inbound always", 2134 ] 2135 result = self.execute_module(changed=True) 2136 self.assertEqual(set(result["commands"]), set(commands)) 2137 2138 def test_nxos_bgp_nbr_af_suppress_inactive_unsuppress_merged(self): 2139 # test merged for suppress_inactive, unsuppress_map, weight 2140 self.get_config.return_value = dedent( 2141 """\ 2142 router bgp 65536 2143 vrf site-1 2144 neighbor 192.168.1.1 2145 address-family ipv4 unicast 2146 suppress-inactive 2147 unsuppress-map rmap1 2148 address-family ipv4 multicast 2149 weight 10 2150 """ 2151 ) 2152 set_module_args( 2153 dict( 2154 config=dict( 2155 as_number="65536", 2156 neighbors=[ 2157 dict( 2158 neighbor_address="10.0.0.2", 2159 address_family=[ 2160 dict( 2161 afi="ipv4", 2162 safi="multicast", 2163 suppress_inactive=True, 2164 unsuppress_map="rmap2", 2165 weight=20, 2166 ) 2167 ], 2168 ) 2169 ], 2170 vrfs=[ 2171 dict( 2172 vrf="site-1", 2173 neighbors=[ 2174 dict( 2175 neighbor_address="192.168.1.1", 2176 address_family=[ 2177 dict( 2178 afi="ipv4", 2179 safi="unicast", 2180 suppress_inactive=True, 2181 unsuppress_map="rmap1", 2182 weight=25, 2183 ), 2184 dict( 2185 afi="ipv4", 2186 safi="multicast", 2187 suppress_inactive=True, 2188 unsuppress_map="rmap4", 2189 ), 2190 ], 2191 ) 2192 ], 2193 ) 2194 ], 2195 ), 2196 state="merged", 2197 ), 2198 ignore_provider_arg, 2199 ) 2200 commands = [ 2201 "router bgp 65536", 2202 "neighbor 10.0.0.2", 2203 "address-family ipv4 multicast", 2204 "suppress-inactive", 2205 "unsuppress-map rmap2", 2206 "weight 20", 2207 "vrf site-1", 2208 "neighbor 192.168.1.1", 2209 "address-family ipv4 unicast", 2210 "weight 25", 2211 "address-family ipv4 multicast", 2212 "suppress-inactive", 2213 "unsuppress-map rmap4", 2214 ] 2215 result = self.execute_module(changed=True) 2216 self.assertEqual(set(result["commands"]), set(commands)) 2217 2218 def test_nxos_bgp_nbr_af_suppress_inactive_unsuppress_replaced(self): 2219 # test replaced for suppress_inactive, unsuppress_map, weight 2220 self.get_config.return_value = dedent( 2221 """\ 2222 router bgp 65536 2223 neighbor 10.0.0.2 2224 address-family ipv4 multicast 2225 suppress-inactive 2226 unsuppress-map rmap2 2227 weight 20 2228 vrf site-1 2229 neighbor 192.168.1.1 2230 address-family ipv4 unicast 2231 suppress-inactive 2232 unsuppress-map rmap1 2233 weight 25 2234 address-family ipv4 multicast 2235 suppress-inactive 2236 unsuppress-map rmap4 2237 weight 10 2238 """ 2239 ) 2240 set_module_args( 2241 dict( 2242 config=dict( 2243 as_number="65536", 2244 neighbors=[ 2245 dict( 2246 neighbor_address="10.0.0.2", 2247 address_family=[ 2248 dict(afi="ipv4", safi="multicast") 2249 ], 2250 ) 2251 ], 2252 vrfs=[ 2253 dict( 2254 vrf="site-1", 2255 neighbors=[ 2256 dict( 2257 neighbor_address="192.168.1.1", 2258 address_family=[ 2259 dict( 2260 afi="ipv4", 2261 safi="unicast", 2262 suppress_inactive=True, 2263 unsuppress_map="rmap1", 2264 weight=25, 2265 ), 2266 dict(afi="ipv4", safi="multicast"), 2267 ], 2268 ) 2269 ], 2270 ) 2271 ], 2272 ), 2273 state="replaced", 2274 ), 2275 ignore_provider_arg, 2276 ) 2277 commands = [ 2278 "router bgp 65536", 2279 "neighbor 10.0.0.2", 2280 "address-family ipv4 multicast", 2281 "no suppress-inactive", 2282 "no unsuppress-map rmap2", 2283 "no weight 20", 2284 "vrf site-1", 2285 "neighbor 192.168.1.1", 2286 "address-family ipv4 multicast", 2287 "no suppress-inactive", 2288 "no unsuppress-map rmap4", 2289 "no weight 10", 2290 ] 2291 result = self.execute_module(changed=True) 2292 self.assertEqual(set(result["commands"]), set(commands)) 2293 2294 def test_nxos_bgp_nbr_af_deleted(self): 2295 # test deleted 2296 self.get_config.return_value = dedent( 2297 """\ 2298 router bgp 65536 2299 neighbor 10.0.0.2 2300 address-family ipv4 multicast 2301 address-family ipv6 unicast 2302 address-family link-state 2303 neighbor 10.0.0.3 2304 address-family ipv4 unicast 2305 vrf site-1 2306 neighbor 192.168.1.1 2307 address-family ipv4 unicast 2308 address-family ipv4 multicast 2309 address-family ipv6 unicast 2310 """ 2311 ) 2312 set_module_args( 2313 dict( 2314 config=dict( 2315 as_number="65536", 2316 neighbors=[ 2317 dict( 2318 neighbor_address="10.0.0.2", 2319 address_family=[ 2320 dict(afi="ipv4", safi="multicast"), 2321 dict(afi="link-state"), 2322 ], 2323 ) 2324 ], 2325 vrfs=[ 2326 dict( 2327 vrf="site-1", 2328 neighbors=[ 2329 dict( 2330 neighbor_address="192.168.1.1", 2331 address_family=[ 2332 dict(afi="ipv4", safi="unicast"), 2333 dict(afi="ipv4", safi="multicast"), 2334 ], 2335 ) 2336 ], 2337 ) 2338 ], 2339 ), 2340 state="deleted", 2341 ), 2342 ignore_provider_arg, 2343 ) 2344 commands = [ 2345 "router bgp 65536", 2346 "neighbor 10.0.0.2", 2347 "no address-family ipv4 multicast", 2348 "no address-family link-state", 2349 "vrf site-1", 2350 "neighbor 192.168.1.1", 2351 "no address-family ipv4 unicast", 2352 "no address-family ipv4 multicast", 2353 ] 2354 result = self.execute_module(changed=True) 2355 self.assertEqual(set(result["commands"]), set(commands)) 2356 2357 def test_nxos_bgp_nbr_af_deleted_all(self): 2358 # test deleted all 2359 self.get_config.return_value = dedent( 2360 """\ 2361 router bgp 65536 2362 neighbor 10.0.0.2 2363 address-family ipv4 multicast 2364 address-family ipv6 unicast 2365 address-family link-state 2366 neighbor 10.0.0.3 2367 address-family ipv4 unicast 2368 vrf site-1 2369 neighbor 192.168.1.1 2370 address-family ipv4 unicast 2371 address-family ipv4 multicast 2372 address-family ipv6 unicast 2373 """ 2374 ) 2375 set_module_args(dict(state="deleted"), ignore_provider_arg) 2376 commands = [ 2377 "router bgp 65536", 2378 "neighbor 10.0.0.2", 2379 "no address-family ipv4 unicast", 2380 "no address-family ipv4 multicast", 2381 "no address-family link-state", 2382 "neighbor 10.0.0.3", 2383 "no address-family ipv4 unicast", 2384 "vrf site-1", 2385 "neighbor 192.168.1.1", 2386 "no address-family ipv4 unicast", 2387 "no address-family ipv4 multicast", 2388 "no address-family ipv6 unicast", 2389 ] 2390 result = self.execute_module(changed=True) 2391 self.assertEqual(set(result["commands"]), set(commands)) 2392 2393 def test_nxos_bgp_nbr_af_overridden(self): 2394 # test overridden 2395 self.get_config.return_value = dedent( 2396 """\ 2397 router bgp 65536 2398 neighbor 10.0.0.2 2399 address-family ipv4 multicast 2400 address-family ipv6 unicast 2401 address-family link-state 2402 neighbor 10.0.0.3 2403 address-family ipv4 unicast 2404 vrf site-1 2405 neighbor 192.168.1.1 2406 address-family ipv4 unicast 2407 address-family ipv4 multicast 2408 address-family ipv6 unicast 2409 """ 2410 ) 2411 set_module_args( 2412 dict( 2413 config=dict( 2414 as_number="65536", 2415 neighbors=[ 2416 dict( 2417 neighbor_address="10.0.0.3", 2418 address_family=[ 2419 dict(afi="ipv4", safi="unicast"), 2420 dict( 2421 afi="link-state", 2422 route_reflector_client=True, 2423 ), 2424 ], 2425 ) 2426 ], 2427 vrfs=[ 2428 dict( 2429 vrf="site-1", 2430 neighbors=[ 2431 dict( 2432 neighbor_address="192.168.1.1", 2433 address_family=[ 2434 dict(afi="ipv4", safi="multicast") 2435 ], 2436 ) 2437 ], 2438 ) 2439 ], 2440 ), 2441 state="overridden", 2442 ), 2443 ignore_provider_arg, 2444 ) 2445 commands = [ 2446 "router bgp 65536", 2447 "neighbor 10.0.0.2", 2448 "no address-family ipv4 unicast", 2449 "no address-family ipv4 multicast", 2450 "no address-family link-state", 2451 "neighbor 10.0.0.3", 2452 "address-family link-state", 2453 "route-reflector-client", 2454 "vrf site-1", 2455 "neighbor 192.168.1.1", 2456 "no address-family ipv4 multicast", 2457 "no address-family ipv6 unicast", 2458 ] 2459 result = self.execute_module(changed=True) 2460 self.assertEqual(set(result["commands"]), set(commands)) 2461 2462 def test_nxos_bgp_nbr_af_gathered(self): 2463 # test gathered 2464 self.get_config.return_value = dedent( 2465 """\ 2466 router bgp 65536 2467 neighbor 10.0.0.3 2468 address-family ipv4 unicast 2469 address-family link-state 2470 vrf site-1 2471 neighbor 192.168.1.1 2472 address-family ipv4 multicast 2473 """ 2474 ) 2475 set_module_args(dict(state="gathered"), ignore_provider_arg) 2476 gathered = dict( 2477 as_number="65536", 2478 neighbors=[ 2479 dict( 2480 neighbor_address="10.0.0.3", 2481 address_family=[ 2482 dict(afi="ipv4", safi="unicast"), 2483 dict(afi="link-state"), 2484 ], 2485 ) 2486 ], 2487 vrfs=[ 2488 dict( 2489 vrf="site-1", 2490 neighbors=[ 2491 dict( 2492 neighbor_address="192.168.1.1", 2493 address_family=[ 2494 dict(afi="ipv4", safi="multicast") 2495 ], 2496 ) 2497 ], 2498 ) 2499 ], 2500 ) 2501 result = self.execute_module(changed=False) 2502 self.assertEqual(result["gathered"], gathered) 2503 2504 def test_nxos_bgp_nbr_af_parsed(self): 2505 # test parsed 2506 set_module_args( 2507 dict( 2508 running_config=dedent( 2509 """\ 2510 router bgp 65536 2511 neighbor 10.0.0.3 2512 address-family ipv4 unicast 2513 address-family link-state 2514 vrf site-1 2515 neighbor 192.168.1.1 2516 address-family ipv4 multicast 2517 """ 2518 ), 2519 state="parsed", 2520 ), 2521 ignore_provider_arg, 2522 ) 2523 parsed = dict( 2524 as_number="65536", 2525 neighbors=[ 2526 dict( 2527 neighbor_address="10.0.0.3", 2528 address_family=[ 2529 dict(afi="ipv4", safi="unicast"), 2530 dict(afi="link-state"), 2531 ], 2532 ) 2533 ], 2534 vrfs=[ 2535 dict( 2536 vrf="site-1", 2537 neighbors=[ 2538 dict( 2539 neighbor_address="192.168.1.1", 2540 address_family=[ 2541 dict(afi="ipv4", safi="multicast") 2542 ], 2543 ) 2544 ], 2545 ) 2546 ], 2547 ) 2548 result = self.execute_module(changed=False) 2549 self.assertEqual(result["parsed"], parsed) 2550 2551 def test_nxos_bgp_nbr_af_rendered(self): 2552 # test rendered 2553 set_module_args( 2554 dict( 2555 config=dict( 2556 as_number="65536", 2557 neighbors=[ 2558 dict( 2559 neighbor_address="10.0.0.2", 2560 address_family=[ 2561 dict( 2562 afi="ipv4", 2563 safi="multicast", 2564 suppress_inactive=True, 2565 unsuppress_map="rmap2", 2566 weight=20, 2567 ) 2568 ], 2569 ) 2570 ], 2571 vrfs=[ 2572 dict( 2573 vrf="site-1", 2574 neighbors=[ 2575 dict( 2576 neighbor_address="192.168.1.1", 2577 address_family=[ 2578 dict( 2579 afi="ipv4", 2580 safi="unicast", 2581 suppress_inactive=True, 2582 unsuppress_map="rmap1", 2583 weight=25, 2584 ), 2585 dict( 2586 afi="ipv4", 2587 safi="multicast", 2588 suppress_inactive=True, 2589 unsuppress_map="rmap4", 2590 ), 2591 ], 2592 ) 2593 ], 2594 ) 2595 ], 2596 ), 2597 state="rendered", 2598 ), 2599 ignore_provider_arg, 2600 ) 2601 rendered = [ 2602 "router bgp 65536", 2603 "neighbor 10.0.0.2", 2604 "address-family ipv4 multicast", 2605 "suppress-inactive", 2606 "unsuppress-map rmap2", 2607 "weight 20", 2608 "vrf site-1", 2609 "neighbor 192.168.1.1", 2610 "address-family ipv4 unicast", 2611 "suppress-inactive", 2612 "unsuppress-map rmap1", 2613 "weight 25", 2614 "address-family ipv4 multicast", 2615 "suppress-inactive", 2616 "unsuppress-map rmap4", 2617 ] 2618 result = self.execute_module(changed=False) 2619 self.assertEqual(set(result["rendered"]), set(rendered)) 2620 2621 def test_nxos_bgp_nbr_af_gathered_empty(self): 2622 # test gathered 2623 self.get_config.return_value = dedent( 2624 """\ 2625 """ 2626 ) 2627 set_module_args(dict(state="gathered"), ignore_provider_arg) 2628 gathered = dict() 2629 result = self.execute_module(changed=False) 2630 self.assertEqual(result["gathered"], gathered) 2631 2632 def test_nxos_bgp_nbr_af_gathered_only_asn(self): 2633 # test gathered 2634 self.get_config.return_value = dedent( 2635 """\ 2636 router bgp 65563 2637 """ 2638 ) 2639 set_module_args(dict(state="gathered"), ignore_provider_arg) 2640 gathered = dict(as_number="65563") 2641 result = self.execute_module(changed=False) 2642 self.assertEqual(result["gathered"], gathered) 2643 2644 def test_nxos_bgp_nbr_af_no_cmd(self): 2645 # test merged for rewrite_evpn_rt_asn, route_map 2646 self.get_config.return_value = dedent( 2647 """\ 2648 router bgp 65536 2649 neighbor 10.0.0.2 2650 address-family ipv4 multicast 2651 """ 2652 ) 2653 set_module_args( 2654 dict( 2655 config=dict( 2656 as_number="65536", 2657 neighbors=[ 2658 dict( 2659 neighbor_address="10.0.0.2", 2660 address_family=[ 2661 dict(afi="ipv4", safi="multicast") 2662 ], 2663 ) 2664 ], 2665 ), 2666 state="merged", 2667 ), 2668 ignore_provider_arg, 2669 ) 2670 result = self.execute_module(changed=False) 2671 self.assertEqual(result["commands"], []) 2672 2673 def test_nxos_bgp_af_send_community(self): 2674 # test merged for send_community 2675 self.get_config.return_value = dedent( 2676 """\ 2677 router bgp 65536 2678 neighbor 10.0.0.2 2679 address-family l2vpn evpn 2680 neighbor 10.0.0.3 2681 address-family l2vpn evpn 2682 send-community 2683 send-community extended 2684 """ 2685 ) 2686 set_module_args( 2687 dict( 2688 config=dict( 2689 as_number="65536", 2690 neighbors=[ 2691 dict( 2692 neighbor_address="10.0.0.2", 2693 address_family=[ 2694 dict( 2695 afi="l2vpn", 2696 safi="evpn", 2697 send_community=dict(both=True), 2698 ) 2699 ], 2700 ), 2701 dict( 2702 neighbor_address="10.0.0.3", 2703 address_family=[ 2704 dict( 2705 afi="l2vpn", 2706 safi="evpn", 2707 send_community=dict(both=True), 2708 ) 2709 ], 2710 ), 2711 dict( 2712 neighbor_address="10.0.0.4", 2713 address_family=[ 2714 dict( 2715 afi="l2vpn", 2716 safi="evpn", 2717 send_community=dict(set=True), 2718 ) 2719 ], 2720 ), 2721 ], 2722 ), 2723 state="merged", 2724 ), 2725 ignore_provider_arg, 2726 ) 2727 commands = [ 2728 "router bgp 65536", 2729 "neighbor 10.0.0.2", 2730 "address-family l2vpn evpn", 2731 "send-community", 2732 "send-community extended", 2733 "neighbor 10.0.0.4", 2734 "address-family l2vpn evpn", 2735 "send-community", 2736 ] 2737 result = self.execute_module(changed=True) 2738 self.assertEqual(set(result["commands"]), set(commands)) 2739