tests/topotests/ospf_basic_functionality/test_ospf_authentication.py

   1 #!/usr/bin/python
   2 # SPDX-License-Identifier: ISC
   3
   4 #
   5 # Copyright (c) 2020 by VMware, Inc. ("VMware")
   6 # Used Copyright (c) 2018 by Network Device Education Foundation, Inc.
   7 # ("NetDEF") in this file.
   8 #
   9
  10
  11 """OSPF Basic Functionality Automation."""
  12 import os
  13 import sys
  14 import time
  15 import pytest
  16 from time import sleep
  17 from copy import deepcopy
  18 from lib.topotest import frr_unicode
  19
  20 # Save the Current Working Directory to find configuration files.
  21 CWD = os.path.dirname(os.path.realpath(__file__))
  22 sys.path.append(os.path.join(CWD, "../"))
  23 sys.path.append(os.path.join(CWD, "../lib/"))
  24
  25 # pylint: disable=C0413
  26 # Import topogen and topotest helpers
  27 from lib.topogen import Topogen, get_topogen
  28
  29 # Import topoJson from lib, to create topology and initial configuration
  30 from lib.common_config import (
  31     start_topology,
  32     write_test_header,
  33     write_test_footer,
  34     reset_config_on_routers,
  35     step,
  36     shutdown_bringup_interface,
  37 )
  38 from lib.topolog import logger
  39 from lib.topojson import build_config_from_json
  40 from lib.ospf import verify_ospf_neighbor, config_ospf_interface, clear_ospf
  41 from ipaddress import IPv4Address
  42
  43 pytestmark = [pytest.mark.ospfd]
  44
  45
  46 # Global variables
  47 topo = None
  48 """
  49 TOPOOLOGY =
  50       Please view in a fixed-width font such as Courier.
  51       +---+  A1       +---+
  52       +R1 +------------+R2 |
  53       +-+-+-           +--++
  54         |  --        --  |
  55         |    -- A0 --    |
  56       A0|      ----      |
  57         |      ----      | A2
  58         |    --    --    |
  59         |  --        --  |
  60       +-+-+-            +-+-+
  61       +R0 +-------------+R3 |
  62       +---+     A3     +---+
  63
  64 TESTCASES =
  65 1. Verify ospf authentication with Simple password authentication.
  66 2. Verify ospf authentication with MD5 authentication.
  67 3. Verify ospf authentication with different authentication methods.
  68
  69  """
  70
  71
  72 def setup_module(mod):
  73     """
  74     Sets up the pytest environment
  75
  76     * `mod`: module name
  77     """
  78     testsuite_run_time = time.asctime(time.localtime(time.time()))
  79     logger.info("Testsuite start time: {}".format(testsuite_run_time))
  80     logger.info("=" * 40)
  81
  82     logger.info("Running setup_module to create topology")
  83
  84     # This function initiates the topology build with Topogen...
  85     json_file = "{}/ospf_authentication.json".format(CWD)
  86     tgen = Topogen(json_file, mod.__name__)
  87     global topo
  88     topo = tgen.json_topo
  89     # ... and here it calls Mininet initialization functions.
  90
  91     # Starting topology, create tmp files which are loaded to routers
  92     #  to start daemons and then start routers
  93     start_topology(tgen)
  94
  95     # Creating configuration from JSON
  96     build_config_from_json(tgen, topo)
  97
  98     # Don't run this test if we have any failure.
  99     if tgen.routers_have_failure():
 100         pytest.skip(tgen.errors)
 101
 102     ospf_covergence = verify_ospf_neighbor(tgen, topo)
 103     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 104         ospf_covergence
 105     )
 106
 107     logger.info("Running setup_module() done")
 108
 109
 110 def teardown_module(mod):
 111     """
 112     Teardown the pytest environment.
 113
 114     * `mod`: module name
 115     """
 116
 117     logger.info("Running teardown_module to delete topology")
 118
 119     tgen = get_topogen()
 120
 121     # Stop toplogy and Remove tmp files
 122     tgen.stop_topology()
 123
 124     logger.info(
 125         "Testsuite end time: {}".format(time.asctime(time.localtime(time.time())))
 126     )
 127     logger.info("=" * 40)
 128
 129
 130 # ##################################
 131 # Test cases start here.
 132 # ##################################
 133
 134
 135 def test_ospf_authentication_simple_pass_tc28_p1(request):
 136     """
 137     OSPF Authentication - Verify ospf authentication with Simple
 138     password authentication.
 139
 140     """
 141     tc_name = request.node.name
 142     write_test_header(tc_name)
 143     tgen = get_topogen()
 144     global topo
 145     step("Bring up the base config.")
 146     reset_config_on_routers(tgen)
 147     step(
 148         "Configure ospf with on R1 and R2, enable ospf on R1 interface"
 149         "connected to R2 with simple password authentication  using  ip ospf "
 150         "authentication  Simple password cmd."
 151     )
 152
 153     r1_ospf_auth = {
 154         "r1": {
 155             "links": {
 156                 "r2": {"ospf": {"authentication": True, "authentication-key": "ospf"}}
 157             }
 158         }
 159     }
 160     result = config_ospf_interface(tgen, topo, r1_ospf_auth)
 161     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 162
 163     step("clear ip ospf after configuring the authentication.")
 164     clear_ospf(tgen, "r1")
 165
 166     step("Verify that the neighbour is not FULL between R1 and R2.")
 167     dut = "r1"
 168     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut, expected=False)
 169     assert ospf_covergence is not True, "setup_module :Failed \n Error:" " {}".format(
 170         ospf_covergence
 171     )
 172
 173     step(
 174         "On R2 enable ospf on interface with simple password authentication "
 175         "using ip ospf authentication  Simple password cmd."
 176     )
 177
 178     r2_ospf_auth = {
 179         "r2": {
 180             "links": {
 181                 "r1": {"ospf": {"authentication": True, "authentication-key": "ospf"}}
 182             }
 183         }
 184     }
 185     result = config_ospf_interface(tgen, topo, r2_ospf_auth)
 186     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 187
 188     step(
 189         "Verify that the neighbour is FULL between R1 and R2  "
 190         "using show ip ospf neighbor cmd."
 191     )
 192
 193     dut = "r2"
 194     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 195     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 196         ospf_covergence
 197     )
 198
 199     step(
 200         "Disable simple password authentication on R2  using no ip ospf "
 201         "authentication Simple password cmd."
 202     )
 203     r2_ospf_auth = {
 204         "r2": {
 205             "links": {
 206                 "r1": {
 207                     "ospf": {
 208                         "authentication": True,
 209                         "authentication-key": "ospf",
 210                         "del_action": True,
 211                     }
 212                 }
 213             }
 214         }
 215     }
 216     result = config_ospf_interface(tgen, topo, r2_ospf_auth)
 217     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 218
 219     step("Verify on R1 neighbour is deleted for R2 after dead interval expiry")
 220     # wait till the dead time expiry
 221     sleep(6)
 222     dut = "r2"
 223     ospf_covergence = verify_ospf_neighbor(
 224         tgen, topo, dut=dut, expected=False, retry_timeout=10
 225     )
 226     assert ospf_covergence is not True, "setup_module :Failed \n Error:" " {}".format(
 227         ospf_covergence
 228     )
 229
 230     step("Again On R2 enable ospf on interface with  Simple password auth")
 231     r2_ospf_auth = {
 232         "r2": {
 233             "links": {
 234                 "r1": {"ospf": {"authentication": True, "authentication-key": "ospf"}}
 235             }
 236         }
 237     }
 238     result = config_ospf_interface(tgen, topo, r2_ospf_auth)
 239     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 240
 241     step(
 242         "Verify that the neighbour is FULL between R1 and R2 using"
 243         " show ip ospf neighbor cmd."
 244     )
 245
 246     dut = "r2"
 247     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 248     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 249         ospf_covergence
 250     )
 251
 252     step("Shut no shut interface on R1")
 253     dut = "r1"
 254     intf = topo["routers"]["r1"]["links"]["r2"]["interface"]
 255     shutdown_bringup_interface(tgen, dut, intf, False)
 256
 257     dut = "r2"
 258     step(
 259         "Verify that the neighbour is not FULL between R1 and R2 using "
 260         "show ip ospf neighbor cmd."
 261     )
 262     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut, expected=False)
 263     assert ospf_covergence is not True, "setup_module :Failed \n Error:" " {}".format(
 264         ospf_covergence
 265     )
 266
 267     dut = "r1"
 268     shutdown_bringup_interface(tgen, dut, intf, True)
 269
 270     step(
 271         "Verify that the neighbour is FULL between R1 and R2 using "
 272         "show ip ospf neighbor cmd."
 273     )
 274
 275     dut = "r2"
 276     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 277     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 278         ospf_covergence
 279     )
 280
 281     step("Change Ip address on R1 and R2")
 282
 283     topo_modify_change_ip = deepcopy(topo)
 284     intf_ip = topo_modify_change_ip["routers"]["r1"]["links"]["r2"]["ipv4"]
 285     topo_modify_change_ip["routers"]["r1"]["links"]["r2"]["ipv4"] = str(
 286         IPv4Address(frr_unicode(intf_ip.split("/")[0])) + 3
 287     ) + "/{}".format(intf_ip.split("/")[1])
 288
 289     build_config_from_json(tgen, topo_modify_change_ip, save_bkup=False)
 290
 291     reset_config_on_routers(tgen, routerName="r1")
 292     dut = "r1"
 293     intf = topo["routers"]["r1"]["links"]["r2"]["interface"]
 294     shutdown_bringup_interface(tgen, dut, intf, False)
 295     shutdown_bringup_interface(tgen, dut, intf, True)
 296
 297     # clear ip ospf after configuring the authentication.
 298     clear_ospf(tgen, "r1")
 299
 300     r1_ospf_auth = {
 301         "r1": {
 302             "links": {
 303                 "r2": {"ospf": {"authentication": True, "authentication-key": "ospf"}}
 304             }
 305         }
 306     }
 307     result = config_ospf_interface(tgen, topo, r1_ospf_auth)
 308     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 309
 310     step(
 311         "Verify that the neighbour is FULL between R1 and R2 with new "
 312         "ip address using show ip ospf "
 313     )
 314
 315     dut = "r1"
 316     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 317     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 318         ospf_covergence
 319     )
 320
 321     write_test_footer(tc_name)
 322
 323
 324 def test_ospf_authentication_md5_tc29_p1(request):
 325     """
 326     OSPF Authentication - Verify ospf authentication with MD5 authentication.
 327
 328     """
 329     tc_name = request.node.name
 330     write_test_header(tc_name)
 331     tgen = get_topogen()
 332     global topo
 333     step("Bring up the base config.")
 334     reset_config_on_routers(tgen)
 335     step(
 336         "Configure ospf with on R1 and R2, enable ospf on R1 interface "
 337         "connected to R2 with message-digest authentication using  ip "
 338         "ospf authentication  message-digest cmd."
 339     )
 340
 341     r1_ospf_auth = {
 342         "r1": {
 343             "links": {
 344                 "r2": {
 345                     "ospf": {
 346                         "authentication": "message-digest",
 347                         "authentication-key": "ospf",
 348                         "message-digest-key": "10",
 349                     }
 350                 }
 351             }
 352         }
 353     }
 354     result = config_ospf_interface(tgen, topo, r1_ospf_auth)
 355     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 356
 357     step("Verify that the neighbour is not FULL between R1 and R2.")
 358     # wait for dead time expiry.
 359     sleep(6)
 360     dut = "r1"
 361     ospf_covergence = verify_ospf_neighbor(
 362         tgen, topo, dut=dut, expected=False, retry_timeout=6
 363     )
 364     assert ospf_covergence is not True, "setup_module :Failed \n Error:" " {}".format(
 365         ospf_covergence
 366     )
 367
 368     step(
 369         "On R2 enable ospf on interface with message-digest authentication"
 370         "  using  ip ospf authentication  message-digest password cmd."
 371     )
 372
 373     r2_ospf_auth = {
 374         "r2": {
 375             "links": {
 376                 "r1": {
 377                     "ospf": {
 378                         "authentication": "message-digest",
 379                         "authentication-key": "ospf",
 380                         "message-digest-key": "10",
 381                     }
 382                 }
 383             }
 384         }
 385     }
 386     result = config_ospf_interface(tgen, topo, r2_ospf_auth)
 387     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 388
 389     step(
 390         "Verify that the neighbour is FULL between R1 and R2  "
 391         "using show ip ospf neighbor cmd."
 392     )
 393
 394     dut = "r2"
 395     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 396     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 397         ospf_covergence
 398     )
 399
 400     step(
 401         "Disable message-digest authentication on R2  using no ip ospf "
 402         "authentication  message-digest password cmd."
 403     )
 404
 405     r2_ospf_auth = {
 406         "r2": {
 407             "links": {
 408                 "r1": {
 409                     "ospf": {
 410                         "authentication": "message-digest",
 411                         "authentication-key": "ospf",
 412                         "message-digest-key": "10",
 413                         "del_action": True,
 414                     }
 415                 }
 416             }
 417         }
 418     }
 419     result = config_ospf_interface(tgen, topo, r2_ospf_auth)
 420     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 421
 422     step("Verify on R1 ,nbr is deleted for R2 after dead interval expiry")
 423     #  wait till the dead timer expiry
 424     sleep(6)
 425     dut = "r2"
 426     ospf_covergence = verify_ospf_neighbor(
 427         tgen, topo, dut=dut, expected=False, retry_timeout=10
 428     )
 429     assert ospf_covergence is not True, "setup_module :Failed \n Error:" " {}".format(
 430         ospf_covergence
 431     )
 432
 433     step("Again On R2 enable ospf on interface with  message-digest auth")
 434     r2_ospf_auth = {
 435         "r2": {
 436             "links": {
 437                 "r1": {
 438                     "ospf": {
 439                         "authentication": "message-digest",
 440                         "authentication-key": "ospf",
 441                         "message-digest-key": "10",
 442                     }
 443                 }
 444             }
 445         }
 446     }
 447     result = config_ospf_interface(tgen, topo, r2_ospf_auth)
 448     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 449
 450     step(
 451         "Verify that the neighbour is FULL between R1 and R2 using"
 452         " show ip ospf neighbor cmd."
 453     )
 454
 455     dut = "r2"
 456     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 457     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 458         ospf_covergence
 459     )
 460
 461     step("Shut no shut interface on R1")
 462     dut = "r1"
 463     intf = topo["routers"]["r1"]["links"]["r2"]["interface"]
 464     shutdown_bringup_interface(tgen, dut, intf, False)
 465
 466     dut = "r2"
 467     step(
 468         "Verify that the neighbour is not FULL between R1 and R2 using "
 469         "show ip ospf neighbor cmd."
 470     )
 471     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut, expected=False)
 472     assert ospf_covergence is not True, "setup_module :Failed \n Error:" " {}".format(
 473         ospf_covergence
 474     )
 475
 476     dut = "r1"
 477     shutdown_bringup_interface(tgen, dut, intf, True)
 478
 479     step(
 480         "Verify that the neighbour is FULL between R1 and R2 using "
 481         "show ip ospf neighbor cmd."
 482     )
 483
 484     dut = "r2"
 485     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 486     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 487         ospf_covergence
 488     )
 489
 490     step("Change Ip address on R1 and R2")
 491
 492     topo_modify_change_ip = deepcopy(topo)
 493
 494     intf_ip = topo_modify_change_ip["routers"]["r1"]["links"]["r2"]["ipv4"]
 495
 496     topo_modify_change_ip["routers"]["r1"]["links"]["r2"]["ipv4"] = str(
 497         IPv4Address(frr_unicode(intf_ip.split("/")[0])) + 3
 498     ) + "/{}".format(intf_ip.split("/")[1])
 499
 500     build_config_from_json(tgen, topo_modify_change_ip, save_bkup=False)
 501
 502     reset_config_on_routers(tgen, routerName="r1")
 503     dut = "r1"
 504     intf = topo["routers"]["r1"]["links"]["r2"]["interface"]
 505     shutdown_bringup_interface(tgen, dut, intf, False)
 506     shutdown_bringup_interface(tgen, dut, intf, True)
 507     clear_ospf(tgen, "r1")
 508     r1_ospf_auth = {
 509         "r1": {
 510             "links": {
 511                 "r2": {
 512                     "ospf": {
 513                         "authentication": "message-digest",
 514                         "authentication-key": "ospf",
 515                         "message-digest-key": "10",
 516                     }
 517                 }
 518             }
 519         }
 520     }
 521     result = config_ospf_interface(tgen, topo, r1_ospf_auth)
 522     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 523
 524     step(
 525         "Verify that the neighbour is FULL between R1 and R2 with new "
 526         "ip address using show ip ospf "
 527     )
 528
 529     dut = "r1"
 530     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 531     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 532         ospf_covergence
 533     )
 534
 535     write_test_footer(tc_name)
 536
 537
 538 def test_ospf_authentication_different_auths_tc30_p1(request):
 539     """
 540     OSPF Authentication - Verify ospf authentication with different
 541     authentication methods.
 542
 543     """
 544     tc_name = request.node.name
 545     write_test_header(tc_name)
 546     tgen = get_topogen()
 547     global topo
 548     step("Bring up the base config.")
 549     reset_config_on_routers(tgen)
 550     step(
 551         "Configure ospf with on R1 and R2, enable ospf on R1 interface "
 552         "connected to R2 with message-digest authentication using  ip "
 553         "ospf authentication  message-digest cmd."
 554     )
 555
 556     r1_ospf_auth = {
 557         "r1": {
 558             "links": {
 559                 "r2": {
 560                     "ospf": {
 561                         "authentication": "message-digest",
 562                         "authentication-key": "ospf",
 563                         "message-digest-key": "10",
 564                     }
 565                 }
 566             }
 567         }
 568     }
 569     result = config_ospf_interface(tgen, topo, r1_ospf_auth)
 570     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 571
 572     # wait for dead timer expiry
 573     sleep(6)
 574     step("Verify that the neighbour is not FULL between R1 and R2.")
 575     dut = "r1"
 576     ospf_covergence = verify_ospf_neighbor(
 577         tgen, topo, dut=dut, expected=False, retry_timeout=10
 578     )
 579     assert ospf_covergence is not True, "setup_module :Failed \n Error:" " {}".format(
 580         ospf_covergence
 581     )
 582
 583     step(
 584         "On R2 enable ospf on interface with message-digest authentication"
 585         "  using  ip ospf authentication  message-digest password cmd."
 586     )
 587
 588     r2_ospf_auth = {
 589         "r2": {
 590             "links": {
 591                 "r1": {
 592                     "ospf": {
 593                         "authentication": "message-digest",
 594                         "authentication-key": "ospf",
 595                         "message-digest-key": "10",
 596                     }
 597                 }
 598             }
 599         }
 600     }
 601     result = config_ospf_interface(tgen, topo, r2_ospf_auth)
 602     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 603
 604     step(
 605         "Verify that the neighbour is FULL between R1 and R2  "
 606         "using show ip ospf neighbor cmd."
 607     )
 608
 609     dut = "r2"
 610     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 611     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 612         ospf_covergence
 613     )
 614
 615     step(" Delete the configured password on both the routers.")
 616
 617     r2_ospf_auth = {
 618         "r2": {
 619             "links": {
 620                 "r1": {
 621                     "ospf": {
 622                         "authentication": "message-digest",
 623                         "authentication-key": "ospf",
 624                         "message-digest-key": "10",
 625                         "del_action": True,
 626                     }
 627                 }
 628             }
 629         }
 630     }
 631     result = config_ospf_interface(tgen, topo, r2_ospf_auth)
 632     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 633
 634     r1_ospf_auth = {
 635         "r1": {
 636             "links": {
 637                 "r2": {
 638                     "ospf": {
 639                         "authentication": "message-digest",
 640                         "authentication-key": "ospf",
 641                         "message-digest-key": "10",
 642                         "del_action": True,
 643                     }
 644                 }
 645             }
 646         }
 647     }
 648     result = config_ospf_interface(tgen, topo, r1_ospf_auth)
 649     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 650
 651     step(
 652         "Verify that the deletion is successful and  neighbour is FULL"
 653         " between R1 and R2 using show ip ospf neighbor cmd."
 654     )
 655
 656     dut = "r2"
 657     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 658     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 659         ospf_covergence
 660     )
 661
 662     step("Change the authentication type to simple password.")
 663     r1_ospf_auth = {
 664         "r1": {
 665             "links": {
 666                 "r2": {"ospf": {"authentication": True, "authentication-key": "ospf"}}
 667             }
 668         }
 669     }
 670     result = config_ospf_interface(tgen, topo, r1_ospf_auth)
 671     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 672
 673     r2_ospf_auth = {
 674         "r2": {
 675             "links": {
 676                 "r1": {"ospf": {"authentication": True, "authentication-key": "ospf"}}
 677             }
 678         }
 679     }
 680     result = config_ospf_interface(tgen, topo, r2_ospf_auth)
 681     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 682
 683     step(
 684         "Verify that the deletion is successful and  neighbour is"
 685         " FULL between R1 and R2 using show ip "
 686     )
 687
 688     dut = "r2"
 689     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 690     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 691         ospf_covergence
 692     )
 693
 694     step("Change the password in simple password.")
 695
 696     r1_ospf_auth = {
 697         "r1": {
 698             "links": {
 699                 "r2": {"ospf": {"authentication": True, "authentication-key": "OSPFv4"}}
 700             }
 701         }
 702     }
 703     result = config_ospf_interface(tgen, topo, r1_ospf_auth)
 704     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 705
 706     r2_ospf_auth = {
 707         "r2": {
 708             "links": {
 709                 "r1": {"ospf": {"authentication": True, "authentication-key": "OSPFv4"}}
 710             }
 711         }
 712     }
 713     result = config_ospf_interface(tgen, topo, r2_ospf_auth)
 714     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 715
 716     step(
 717         "Verify that the deletion is successful and  neighbour is"
 718         " FULL between R1 and R2 using show ip "
 719     )
 720
 721     dut = "r2"
 722     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 723     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 724         ospf_covergence
 725     )
 726
 727     step("Delete the password authentication on the interface ")
 728
 729     r1_ospf_auth = {
 730         "r1": {
 731             "links": {
 732                 "r2": {
 733                     "ospf": {
 734                         "authentication": True,
 735                         "authentication-key": "OSPFv4",
 736                         "del_action": True,
 737                     }
 738                 }
 739             }
 740         }
 741     }
 742     result = config_ospf_interface(tgen, topo, r1_ospf_auth)
 743     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 744
 745     r2_ospf_auth = {
 746         "r2": {
 747             "links": {
 748                 "r1": {
 749                     "ospf": {
 750                         "authentication": True,
 751                         "authentication-key": "OSPFv4",
 752                         "del_action": True,
 753                     }
 754                 }
 755             }
 756         }
 757     }
 758     result = config_ospf_interface(tgen, topo, r2_ospf_auth)
 759     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 760
 761     step(
 762         "Verify that the deletion is successful and  neighbour is"
 763         " FULL between R1 and R2 using show ip "
 764     )
 765
 766     dut = "r2"
 767     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 768     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 769         ospf_covergence
 770     )
 771
 772     step("Enable Md5 authentication on the interface")
 773
 774     r1_ospf_auth = {
 775         "r1": {
 776             "links": {
 777                 "r2": {
 778                     "ospf": {
 779                         "authentication": "message-digest",
 780                         "authentication-key": "ospf",
 781                         "message-digest-key": "10",
 782                     }
 783                 }
 784             }
 785         }
 786     }
 787     result = config_ospf_interface(tgen, topo, r1_ospf_auth)
 788     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 789
 790     r2_ospf_auth = {
 791         "r2": {
 792             "links": {
 793                 "r1": {
 794                     "ospf": {
 795                         "authentication": "message-digest",
 796                         "authentication-key": "ospf",
 797                         "message-digest-key": "10",
 798                     }
 799                 }
 800             }
 801         }
 802     }
 803     result = config_ospf_interface(tgen, topo, r2_ospf_auth)
 804     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 805
 806     step(
 807         "Verify that the neighbour is FULL between R1 and R2 using"
 808         " show ip ospf neighbor cmd."
 809     )
 810
 811     dut = "r2"
 812     ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut)
 813     assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format(
 814         ospf_covergence
 815     )
 816
 817     step("Change the MD5 authentication password")
 818
 819     r1_ospf_auth = {
 820         "r1": {
 821             "links": {
 822                 "r2": {
 823                     "ospf": {
 824                         "authentication": "message-digest",
 825                         "authentication-key": "OSPFv4",
 826                         "message-digest-key": "10",
 827                     }
 828                 }
 829             }
 830         }
 831     }
 832     result = config_ospf_interface(tgen, topo, r1_ospf_auth)
 833     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 834
 835     r2_ospf_auth = {
 836         "r2": {
 837             "links": {
 838                 "r1": {
 839                     "ospf": {
 840                         "authentication": "message-digest",
 841                         "authentication-key": "OSPFv4",
 842                         "message-digest-key": "10",
 843                     }
 844                 }
 845             }
 846         }
 847     }
 848     result = config_ospf_interface(tgen, topo, r2_ospf_auth)
 849     assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
 850
 851     write_test_footer(tc_name)
 852
 853
 854 if __name__ == "__main__":
 855     args = ["-s"] + sys.argv[1:]
 856     sys.exit(pytest.main(args))