cisco_node_utils 1.2.0 → 1.3.0

data/tests/test_radius_server_group.rb

@@ -21,6 +21,8 @@ require File.expand_path('../../lib/cisco_node_utils/radius_server_group', \
 
 # TestRadiusServerGroup - Minitest for RadiusServerGroup node utility.
 class TestRadiusServerGroup < CiscoTestCase
+  @skip_unless_supported = 'radius_server_group'
+
   def setup
     # setup runs at the beginning of each test
     super

data/tests/test_router_bgp.rb

@@ -20,6 +20,46 @@
 require_relative 'ciscotest'
 require_relative '../lib/cisco_node_utils/bgp'
 
+# Temporary debug helper. Not for production and not to replace Cisco debugging.
+def debug_bgp
+  s = @device.cmd('show running-config router bgp')
+  caller_locations(1, 1).first.tap do |loc|
+    puts "\nDEBUG BGP: #{__FILE__}:#{loc.path}:#{loc.lineno}:\n#{s}"
+  end
+end
+
+def create_bgp_vrf(asnum, vrf)
+  if platform == :nexus
+    bgp = RouterBgp.new(asnum, vrf)
+  else
+    # IOS XR requires 'rd <id>' for any created VRF.
+    # But 'rd' requires a global router id. From a puppet p.o.v
+    # this is fine; the user is required to add a router-id to
+    # their manifest. For the minitest fudge this by calling
+    # RouterBgp.new twice. Once to create the BGP process,
+    # add a router-id, then call it again to create the VRF,
+    # and add a VRF level router-id (which is needed to make SYSDB
+    # behave).
+    bgp = RouterBgp.new(asnum)
+    bgp.router_id = '1.2.3.4'
+    bgp = RouterBgp.new(asnum, vrf)
+    bgp.router_id = '4.5.6.7'
+  end
+  bgp
+end
+
+def setup_default
+  @asnum = 55
+  @vrf = 'default'
+  RouterBgp.new(@asnum)
+end
+
+def setup_vrf
+  @asnum = 99
+  @vrf = 'yamllll'
+  create_bgp_vrf(@asnum, @vrf)
+end
+
 # TestRouterBgp - Minitest for RouterBgp class
 class TestRouterBgp < CiscoTestCase
   @@pre_clean_needed = true # rubocop:disable Style/ClassVars
@@ -31,12 +71,16 @@ class TestRouterBgp < CiscoTestCase
   end
 
   def teardown
-    super
     remove_all_bgps
+    super
   end
 
   def get_routerbgp_match_line(as_number, vrf='default')
-    s = @device.cmd("show run | section '^router bgp .*'")
+    if platform == :ios_xr
+      s = @device.cmd('show running-config router bgp')
+    else
+      s = @device.cmd("show run | section '^router bgp .*'")
+    end
     if vrf == 'default'
       line = /router bgp\s#{as_number}/.match(s)
     else
@@ -46,18 +90,36 @@ class TestRouterBgp < CiscoTestCase
   end
 
   def test_collection_empty
-    config('no feature bgp')
+    if platform == :ios_xr
+      config('no router bgp')
+    else
+      config('no feature bgp')
+    end
     node.cache_flush
     routers = RouterBgp.routers
     assert_empty(routers, 'RouterBgp collection is not empty')
   end
 
   def test_collection_not_empty
-    config('feature bgp',
-           'router bgp 55',
-           'vrf blue',
-           'vrf red',
-           'vrf white')
+    if platform == :nexus
+      config('feature bgp',
+             'router bgp 55',
+             'vrf blue',
+             'vrf red',
+             'vrf white')
+    else
+      config('router bgp 55',
+             'bgp router-id 1.2.3.4',
+             'vrf blue',
+             'bgp router-id 4.5.6.7',
+             'rd auto',
+             'vrf red',
+             'bgp router-id 4.5.6.7',
+             'rd auto',
+             'vrf white',
+             'bgp router-id 4.5.6.7',
+             'rd auto')
+    end
     routers = RouterBgp.routers
     refute_empty(routers, 'RouterBgp collection is empty')
     # validate the collection
@@ -97,44 +159,75 @@ class TestRouterBgp < CiscoTestCase
   end
 
   def test_create_valid
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    line = get_routerbgp_match_line(asnum)
-    refute_nil(line, "Error: 'router bgp #{asnum}' not configured")
+    bgp = setup_default
+    line = get_routerbgp_match_line(@asnum)
+    refute_nil(line, "Error: 'router bgp #{@asnum}' not configured")
     bgp.destroy
 
     vrf = 'wolfpack'
-    bgp = RouterBgp.new(asnum, vrf)
-    line = get_routerbgp_match_line(asnum, vrf)
-    refute_nil(line, "Error: 'router bgp #{asnum}' vrf '#{vrf}' not configured")
+    bgp = create_bgp_vrf(55, vrf)
+    line = get_routerbgp_match_line(@asnum, vrf)
+    refute_nil(line,
+               "Error: 'router bgp #{@asnum}' vrf '#{vrf}' not configured")
     bgp.destroy
   end
 
-  def test_valid_asn
-    [1, 4_294_967_295, '55', '1.0', '1.65535',
-     '65535.0', '65535.65535'].each do |test|
-      rtr_bgp = RouterBgp.new(test)
-      assert_equal(test.to_s, RouterBgp.routers.keys[0].to_s)
-      rtr_bgp.destroy
+  def test_process_initialized
+    return if validate_property_excluded?('bgp', 'process_initialized')
 
-      vrf = 'Duke'
-      bgp_vrf = RouterBgp.new(test, vrf)
-      assert_equal(test.to_s, RouterBgp.routers.keys[0].to_s)
-      bgp_vrf.destroy
-      rtr_bgp.destroy
+    # Cleanup may be slow on some platforms; make sure it's really dead
+    bgp = RouterBgp.new('55', 'default', false)
+    if bgp.process_initialized?
+      sleep 4
+      node.cache_flush
+    end
+    refute(bgp.process_initialized?, 'bgp should not be initialized')
+
+    bgp = RouterBgp.new('55', 'default')
+    bgp.wait_for_process_initialized unless bgp.process_initialized?
+    assert(bgp.process_initialized?, 'bgp should be initialized')
+  end
+
+  def wait_for_process_kill(bgp)
+    return unless node.product_id[/N(5|6)/]
+    # Hack for slow-start platforms which can also be slow-to-die.
+    # Tests that involve many quick process-start / process-stop cycles
+    # are prone to failure without this delay.
+    4.times do
+      return unless bgp.process_initialized?
+      sleep 1
+      node.cache_flush
     end
+    fail "#{bgp} :: process is still running"
   end
 
-  def test_create_valid_no_feature
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    line = get_routerbgp_match_line(asnum)
-    refute_nil(line, "Error: 'router bgp #{asnum}' not configured")
+  def test_valid_asn
+    [1, 4_294_967_295, '55', '1.0', '1.65535', '65535.0', '65535.65535'
+    ].each do |asn|
+      b = RouterBgp.new(asn)
+      assert_equal(asn.to_s, RouterBgp.routers.keys[0].to_s)
+      b.destroy
+      wait_for_process_kill(b)
+    end
+  end
+
+  def test_destroy
+    bgp = setup_default
+    line = get_routerbgp_match_line(@asnum)
+    refute_nil(line, "Error: 'router bgp #{@asnum}' not configured")
     bgp.destroy
 
-    s = @device.cmd('show run all | no-more')
-    line = /"feature bgp"/.match(s)
-    assert_nil(line, "Error: 'feature bgp' still configured")
+    if platform == :ios_xr
+      command = 'show run router bgp'
+      pattern = /"router bgp"/
+    else
+      command = 'show run all | no-more'
+      pattern = /"feature bgp"/
+    end
+
+    refute_show_match(
+      command: command, pattern: pattern,
+      msg: "Error: 'router bgp' still configured")
   end
 
   def test_create_invalid_multiple
@@ -148,7 +241,6 @@ class TestRouterBgp < CiscoTestCase
       bgp2 = RouterBgp.new(88)
       bgp2.destroy unless bgp2.nil?
     end
-
     bgp1.destroy
   end
 
@@ -163,104 +255,147 @@ class TestRouterBgp < CiscoTestCase
     end
   end
 
-  def test_destroy
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    bgp.destroy
-    line = get_routerbgp_match_line(asnum)
-    assert_nil(line, "Error: 'router bgp #{asnum}' not destroyed")
+  def test_nsr
+    nsr(setup_default)
+    nsr(setup_vrf)
   end
 
-  def test_bestpath
-    %w(test_default test_vrf).each do |t|
-      if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
+  def nsr(bgp)
+    if (platform == :nexus) || (platform == :ios_xr && !@vrf[/default/])
+      if platform == :nexus
+        assert_nil(bgp.default_nsr,
+                   'default bgp nsr should be nil on Nexus')
+        assert_nil(bgp.nsr,
+                   'bgp nsr should be nil on Nexus')
       else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
-      end
-      bgp.bestpath_always_compare_med = true
-      assert(bgp.bestpath_always_compare_med, "vrf #{vrf}: "\
-             'bgp bestpath_always_compare_med should be enabled')
-      bgp.bestpath_aspath_multipath_relax = true
-      assert(bgp.bestpath_aspath_multipath_relax, "vrf #{vrf}: "\
-             'bgp bestpath_aspath_multipath_relax should be enabled')
-      bgp.bestpath_compare_routerid = true
-      assert(bgp.bestpath_compare_routerid, "vrf #{vrf}: "\
-             'bgp bestpath_compare_routerid should be enabled')
-      bgp.bestpath_cost_community_ignore = true
-      assert(bgp.bestpath_cost_community_ignore, "vrf #{vrf}: "\
-             'bgp bestpath_cost_community_ignore should be enabled')
+        assert_nil(bgp.default_nsr,
+                   'default bgp nsr should return nil on XR with non-default' \
+                   ' vrf')
+        assert_nil(bgp.nsr,
+                   'bgp nsr should return nil on XR with non-default vrf')
+      end
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.nsr = true
+      end
+    else
+      assert_equal(bgp.nsr, bgp.default_nsr)
+      bgp.nsr = true
+      assert(bgp.nsr,
+             'bgp nsr should be enabled')
+      bgp.nsr = false
+      refute(bgp.nsr,
+             'bgp nsr should be disabled')
+    end
+    bgp.destroy
+  end
+
+  def test_bestpath_default
+    bestpath(setup_default)
+  end
+
+  def test_bestpath_vrf
+    bestpath(setup_vrf)
+  end
+
+  def bestpath(bgp)
+    bgp.bestpath_always_compare_med = true
+    assert(bgp.bestpath_always_compare_med,
+           'bgp bestpath_always_compare_med should be enabled')
+    bgp.bestpath_aspath_multipath_relax = true
+    assert(bgp.bestpath_aspath_multipath_relax,
+           'bgp bestpath_aspath_multipath_relax should be enabled')
+    bgp.bestpath_compare_routerid = true
+    assert(bgp.bestpath_compare_routerid,
+           'bgp bestpath_compare_routerid should be enabled')
+    bgp.bestpath_cost_community_ignore = true
+    assert(bgp.bestpath_cost_community_ignore,
+           'bgp bestpath_cost_community_ignore should be enabled')
+    if platform == :ios_xr && !@vrf[/default/]
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.bestpath_med_confed = true
+      end
+    else
       bgp.bestpath_med_confed = true
-      assert(bgp.bestpath_med_confed, "vrf #{vrf}: "\
+      assert(bgp.bestpath_med_confed,
              'bgp bestpath_med_confed should be enabled')
-      bgp.bestpath_med_missing_as_worst = true
-      assert(bgp.bestpath_med_missing_as_worst, "vrf #{vrf}: "\
-             'bgp bestpath_med_missing_as_worst should be enabled')
+    end
+    bgp.bestpath_med_missing_as_worst = true
+    assert(bgp.bestpath_med_missing_as_worst,
+           'bgp bestpath_med_missing_as_worst should be enabled')
+    if platform == :nexus
       bgp.bestpath_med_non_deterministic = true
-      assert(bgp.bestpath_med_non_deterministic, "vrf #{vrf}: "\
+      assert(bgp.bestpath_med_non_deterministic,
              'bgp bestpath_med_non_deterministic should be enabled')
-
-      bgp.bestpath_always_compare_med = false
-      refute(bgp.bestpath_always_compare_med, "vrf #{vrf}: "\
-             'bgp bestpath_always_compare_med should be disabled')
-      bgp.bestpath_aspath_multipath_relax = false
-      refute(bgp.bestpath_aspath_multipath_relax, "vrf #{vrf}: "\
-             'bgp bestpath_aspath_multipath_relax should be disabled')
-      bgp.bestpath_compare_routerid = false
-      refute(bgp.bestpath_compare_routerid, "vrf #{vrf}: "\
-             'bgp bestpath_compare_routerid should be disabled')
-      bgp.bestpath_cost_community_ignore = false
-      refute(bgp.bestpath_cost_community_ignore, "vrf #{vrf}: "\
-             'bgp bestpath_cost_community_ignore should be disabled')
+    else
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.bestpath_med_non_deterministic = true
+      end
+    end
+    bgp.bestpath_always_compare_med = false
+    refute(bgp.bestpath_always_compare_med,
+           'bgp bestpath_always_compare_med should be disabled')
+    bgp.bestpath_aspath_multipath_relax = false
+    refute(bgp.bestpath_aspath_multipath_relax,
+           'bgp bestpath_aspath_multipath_relax should be disabled')
+    bgp.bestpath_compare_routerid = false
+    refute(bgp.bestpath_compare_routerid,
+           'bgp bestpath_compare_routerid should be disabled')
+    bgp.bestpath_cost_community_ignore = false
+    refute(bgp.bestpath_cost_community_ignore,
+           'bgp bestpath_cost_community_ignore should be disabled')
+    unless platform == :ios_xr && !@vrf[/default/]
       bgp.bestpath_med_confed = false
-      refute(bgp.bestpath_med_confed, "vrf #{vrf}: "\
+      refute(bgp.bestpath_med_confed,
              'bgp bestpath_med_confed should be disabled')
-      bgp.bestpath_med_missing_as_worst = false
-      refute(bgp.bestpath_med_missing_as_worst, "vrf #{vrf}: "\
-             'bgp bestpath_med_missing_as_worst should be disabled')
+    end
+    bgp.bestpath_med_missing_as_worst = false
+    refute(bgp.bestpath_med_missing_as_worst,
+           'bgp bestpath_med_missing_as_worst should be disabled')
+    if platform == :nexus
       bgp.bestpath_med_non_deterministic = false
-      refute(bgp.bestpath_med_non_deterministic, "vrf #{vrf}: "\
+      refute(bgp.bestpath_med_non_deterministic,
              'bgp bestpath_med_non_deterministic should be disabled')
-      bgp.destroy
+    else
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.bestpath_med_non_deterministic = false
+      end
     end
+    bgp.destroy
   end
 
-  def test_bestpath_not_configured
-    %w(test_default test_vrf).each do |t|
-      if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
-      else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
-      end
-      refute(bgp.bestpath_always_compare_med, "vrf #{vrf}: "\
-             'bgp bestpath_always_compare_med should *NOT* be enabled')
-      refute(bgp.bestpath_aspath_multipath_relax, "vrf #{vrf}: "\
-             'bgp bestpath_aspath_multipath_relax should *NOT* be enabled')
-      refute(bgp.bestpath_compare_routerid, "vrf #{vrf}: "\
-             'bgp bestpath_compare_routerid should be *NOT* enabled')
-      refute(bgp.bestpath_cost_community_ignore, "vrf #{vrf}: "\
-             'bgp bestpath_cost_community_ignore should *NOT* be enabled')
-      refute(bgp.bestpath_med_confed, "vrf #{vrf}: "\
-             'bgp bestpath_med_confed should *NOT* be enabled')
-      refute(bgp.bestpath_med_missing_as_worst, "vrf #{vrf}: "\
-             'bgp bestpath_med_missing_as_worst should *NOT* be enabled')
-      refute(bgp.bestpath_med_non_deterministic, "vrf #{vrf}: "\
+  def test_bestpath_not_configured_default
+    bestpath_not_configured(setup_default)
+  end
+
+  def test_bestpath_not_configured_vrf
+    bestpath_not_configured(setup_vrf)
+  end
+
+  def bestpath_not_configured(bgp)
+    refute(bgp.bestpath_always_compare_med,
+           'bgp bestpath_always_compare_med should *NOT* be enabled')
+    refute(bgp.bestpath_aspath_multipath_relax,
+           'bgp bestpath_aspath_multipath_relax should *NOT* be enabled')
+    refute(bgp.bestpath_compare_routerid,
+           'bgp bestpath_compare_routerid should be *NOT* enabled')
+    refute(bgp.bestpath_cost_community_ignore,
+           'bgp bestpath_cost_community_ignore should *NOT* be enabled')
+    refute(bgp.bestpath_med_confed,
+           'bgp bestpath_med_confed should *NOT* be enabled')
+    refute(bgp.bestpath_med_missing_as_worst,
+           'bgp bestpath_med_missing_as_worst should *NOT* be enabled')
+    if platform == :nexus
+      refute(bgp.bestpath_med_non_deterministic,
              'bgp bestpath_med_non_deterministic should *NOT* be enabled')
-      bgp.destroy
+    else
+      assert_nil(bgp.bestpath_med_non_deterministic,
+                 'bgp bestpath_med_non_deterministic should *NOT* be supported')
     end
+    bgp.destroy
   end
 
   def test_default_bestpath
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     refute(bgp.default_bestpath_always_compare_med,
            'default value for bestpath_always_compare_med should be false')
     refute(bgp.default_bestpath_aspath_multipath_relax,
@@ -273,136 +408,191 @@ class TestRouterBgp < CiscoTestCase
            'default value for bestpath_med_confed should be false')
     refute(bgp.default_bestpath_med_missing_as_worst,
            'default value for bestpath_med_missing_as_worst should be false')
-    refute(bgp.default_bestpath_med_non_deterministic,
-           'default value for bestpath_med_non_deterministic should be false')
+    if platform == :nexus
+      refute(bgp.default_bestpath_med_non_deterministic,
+             'default value for bestpath_med_non_deterministic should be false')
+    else
+      assert_nil(bgp.default_bestpath_med_non_deterministic,
+                 'bgp default_bestpath_med_non_deterministic should ' \
+                 '*NOT* be supported')
+    end
     bgp.destroy
   end
 
-  def test_cluster_id
-    %w(test_default test_vrf).each do |t|
-      if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
-      else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
-      end
-      bgp.cluster_id = 34
-      assert_equal('34', bgp.cluster_id,
-                   "vrf #{vrf}: bgp cluster_id should be set to '34'")
-      bgp.cluster_id = '1.2.3.4'
-      assert_equal('1.2.3.4', bgp.cluster_id,
-                   "vrf #{vrf}: bgp cluster_id should be set to '1.2.3.4'")
-      bgp.cluster_id = ''
-      assert_empty(bgp.cluster_id,
-                   "vrf #{vrf}: bgp cluster_id should *NOT* be configured")
+  def test_cluster_id_default
+    cluster_id(setup_default)
+  end
+
+  def test_cluster_id_vrf
+    cluster_id(setup_vrf)
+  end
+
+  def cluster_id(bgp)
+    if platform == :ios_xr && @vrf != 'default'
+      # XR does not support this under a VRF, so test the getter and setter
+      assert_nil(bgp.cluster_id,
+                 'cluster_id should return nil on XR with non-default vrf')
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.cluster_id = 34
+      end
       bgp.destroy
+      return
     end
+    bgp.cluster_id = 34
+    assert_equal('34', bgp.cluster_id,
+                 "bgp cluster_id should be set to '34'")
+    bgp.cluster_id = '1.2.3.4'
+    assert_equal('1.2.3.4', bgp.cluster_id,
+                 "bgp cluster_id should be set to '1.2.3.4'")
+    bgp.cluster_id = ''
+    assert_empty(bgp.cluster_id,
+                 'bgp cluster_id should *NOT* be configured')
+    bgp.destroy
   end
 
   def test_cluster_id_not_configured
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     assert_empty(bgp.cluster_id,
                  'bgp cluster_id should *NOT* be configured')
     bgp.destroy
   end
 
   def test_default_cluster_id
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     assert_empty(bgp.default_cluster_id,
                  'bgp cluster_id default value should be empty')
     bgp.destroy
   end
 
   def test_disable_policy_batching
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    bgp.disable_policy_batching = true
-    assert(bgp.disable_policy_batching,
-           'bgp disable-policy-batching should be enabled')
-    bgp.disable_policy_batching = false
-    refute(bgp.disable_policy_batching,
-           'bgp disable-policy-batching should be disabled')
+    bgp = setup_default
+    if platform == :ios_xr
+      assert_nil(bgp.disable_policy_batching)
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.disable_policy_batching = true
+      end
+    else
+      bgp.disable_policy_batching = true
+      assert(bgp.disable_policy_batching,
+             'bgp disable-policy-batching should be enabled')
+      bgp.disable_policy_batching = false
+      refute(bgp.disable_policy_batching,
+             'bgp disable-policy-batching should be disabled')
+    end
     bgp.destroy
   end
 
   def test_default_disable_policy_batching
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    refute(bgp.disable_policy_batching,
-           'bgp disable-policy-batching value should be false')
+    bgp = setup_default
+    if platform == :ios_xr
+      assert_nil(bgp.disable_policy_batching)
+      assert_nil(bgp.default_disable_policy_batching)
+    else
+      refute(bgp.disable_policy_batching,
+             'bgp disable-policy-batching value should be false')
+    end
     bgp.destroy
   end
 
   def test_disable_policy_batching_ipv4
-    bgp = RouterBgp.new(55)
+    if platform == :ios_xr || node.product_id[/N(5|6|7)/]
+      b = RouterBgp.new(1)
+      assert_nil(b.disable_policy_batching_ipv4)
+      assert_nil(b.default_disable_policy_batching_ipv4)
+      assert_raises(Cisco::UnsupportedError) do
+        b.disable_policy_batching_ipv4 = 'xx'
+      end
+      return
+    end
+    bgp = setup_default
+    default = bgp.default_disable_policy_batching_ipv4
+    assert_equal(default, bgp.disable_policy_batching_ipv4,
+                 'bgp disable_policy_batching_ipv4 not set to default')
+
     bgp.disable_policy_batching_ipv4 = 'xx'
     assert_equal('xx', bgp.disable_policy_batching_ipv4,
                  "bgp disable_policy_batching_ipv4 should be set to 'xx'")
-    bgp.disable_policy_batching_ipv4 = bgp.default_disable_policy_batching_ipv4
+    bgp.disable_policy_batching_ipv4 = \
+      bgp.default_disable_policy_batching_ipv4
     assert_empty(bgp.disable_policy_batching_ipv4,
                  'bgp disable_policy_batching_ipv4 should be empty')
-    bgp.destroy
-  end
 
-  def test_default_disable_policy_batching_ipv4
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    assert_equal(bgp.default_disable_policy_batching_ipv4,
-                 bgp.disable_policy_batching_ipv4,
-                 'disable_policy_batching_ipv4 default value should be empty')
+    bgp.disable_policy_batching_ipv4 = default
+    assert_equal(default, bgp.disable_policy_batching_ipv4,
+                 'bgp disable_policy_batching_ipv4 not set to default')
     bgp.destroy
   end
 
   def test_disable_policy_batching_ipv6
-    bgp = RouterBgp.new(55)
+    if platform == :ios_xr || node.product_id[/N(5|6|7)/]
+      b = RouterBgp.new(1)
+      assert_nil(b.disable_policy_batching_ipv6)
+      assert_nil(b.default_disable_policy_batching_ipv6)
+      assert_raises(Cisco::UnsupportedError) do
+        b.disable_policy_batching_ipv6 = 'xx'
+      end
+      return
+    end
+    bgp = setup_default
+    default = bgp.default_disable_policy_batching_ipv6
+    assert_equal(default, bgp.disable_policy_batching_ipv6,
+                 'bgp disable_policy_batching_ipv6 not set to default')
+
     bgp.disable_policy_batching_ipv6 = 'xx'
     assert_equal('xx', bgp.disable_policy_batching_ipv6,
                  "bgp disable_policy_batching_ipv6 should be set to 'xx'")
-    bgp.disable_policy_batching_ipv6 = bgp.default_disable_policy_batching_ipv6
+    bgp.disable_policy_batching_ipv6 = \
+      bgp.default_disable_policy_batching_ipv6
     assert_empty(bgp.disable_policy_batching_ipv6,
                  'bgp disable_policy_batching_ipv6 should be empty')
-    bgp.destroy
-  end
 
-  def test_default_disable_policy_batching_ipv6
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    assert_equal(bgp.default_disable_policy_batching_ipv6,
-                 bgp.disable_policy_batching_ipv6,
-                 'disable_policy_batching_ipv6 default value should be empty')
+    bgp.disable_policy_batching_ipv6 = default
+    assert_equal(default, bgp.disable_policy_batching_ipv6,
+                 'bgp disable_policy_batching_ipv6 not set to default')
     bgp.destroy
   end
 
   def test_enforce_first_as
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    bgp.enforce_first_as = true
-    assert(bgp.enforce_first_as,
-           'bgp enforce-first-as should be enabled')
+    bgp = setup_default
+    if platform == :ios_xr
+      @default_show_command = 'show running-config router bgp 55'
+      @default_output_pattern = /bgp enforce-first-as disable/
+    else
+      @default_show_command = 'show run bgp all'
+      @default_output_pattern = /no enforce-first-as/
+    end
     bgp.enforce_first_as = false
-    refute(bgp.enforce_first_as,
-           'bgp enforce-first-as should be disabled')
+    refute(bgp.enforce_first_as)
+    assert_show_match(msg: 'enforce-first-as should be disabled')
+
+    bgp.enforce_first_as = true
+    assert(bgp.enforce_first_as)
+    refute_show_match(msg: 'enforce-first-as should be enabled')
+
     bgp.destroy
   end
 
   def test_default_enforce_first_as
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    assert(bgp.enforce_first_as,
-           'bgp enforce-first-as value should be enabled = true')
+    bgp = setup_default
+    assert_equal(bgp.default_enforce_first_as,
+                 bgp.enforce_first_as,
+                 'bgp enforce-first-as default value is incorrect')
     bgp.destroy
   end
 
   def test_event_history
-    bgp = RouterBgp.new(55)
+    bgp = setup_default
 
     opts = [:cli, :detail, :events, :periodic]
     opts.each do |opt|
+      if platform == :ios_xr # unsupported on XR
+        assert_equal(nil, bgp.send("event_history_#{opt}"))
+        assert_equal(nil, bgp.send("default_event_history_#{opt}"))
+        assert_raises(Cisco::UnsupportedError) do
+          bgp.send("event_history_#{opt}=", 'true')
+        end
+        next
+      end
       # Test basic true
       bgp.send("event_history_#{opt}=", 'true')
       set = bgp.send("default_event_history_#{opt}")
@@ -440,8 +630,7 @@ class TestRouterBgp < CiscoTestCase
   end
 
   def test_fast_external_fallover
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     bgp.fast_external_fallover = true
     assert(bgp.fast_external_fallover,
            'bgp fast-external-fallover should be enabled')
@@ -452,334 +641,444 @@ class TestRouterBgp < CiscoTestCase
   end
 
   def test_default_fast_external_fallover
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     assert(bgp.fast_external_fallover,
            'bgp fast-external-fallover default value should be true')
     bgp.destroy
   end
 
   def test_flush_routes
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    bgp.flush_routes = true
-    assert(bgp.flush_routes,
-           'bgp flush-routes should be enabled')
-    bgp.flush_routes = false
-    refute(bgp.flush_routes,
-           'bgp flush-routes should be disabled')
+    bgp = setup_default
+    if platform == :ios_xr
+      assert_nil(bgp.flush_routes)
+      assert_raises(UnsupportedError) { bgp.flush_routes = true }
+    else
+      bgp.flush_routes = true
+      assert(bgp.flush_routes,
+             'bgp flush-routes should be enabled')
+      bgp.flush_routes = false
+      refute(bgp.flush_routes,
+             'bgp flush-routes should be disabled')
+    end
     bgp.destroy
   end
 
   def test_default_flush_routes
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     refute(bgp.flush_routes,
            'bgp flush-routes value default value should be false')
     bgp.destroy
   end
 
-  def test_graceful_restart
-    %w(test_default test_vrf).each do |t|
-      if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
-      else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
-      end
-      bgp.graceful_restart = true
-      assert(bgp.graceful_restart,
-             "vrf #{vrf}: bgp graceful restart should be enabled")
-      bgp.graceful_restart_timers_restart = 55
-      assert_equal(55, bgp.graceful_restart_timers_restart,
-                   "vrf #{vrf}: bgp graceful restart timers restart" \
-                   "should be set to '55'")
-      bgp.graceful_restart_timers_stalepath_time = 77
-      assert_equal(77, bgp.graceful_restart_timers_stalepath_time,
-                   "vrf #{vrf}: bgp graceful restart timers stalepath time" \
-                   "should be set to '77'")
+  def test_graceful_restart_default
+    graceful_restart(setup_default)
+  end
+
+  def test_graceful_restart_vrf
+    graceful_restart(setup_vrf)
+  end
+
+  def graceful_restart(bgp)
+    if platform == :ios_xr && @vrf != 'default'
+      # XR does not support this under a VRF, so test the getter and setter
+      assert_nil(bgp.graceful_restart,
+                 'graceful_restart should return nil on XR with ' \
+                 'non-default vrf')
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.graceful_restart = true
+      end
+
+      assert_nil(bgp.graceful_restart_timers_restart,
+                 'graceful_restart_timers_restart should return nil on XR ' \
+                 'with non-default vrf')
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.graceful_restart_timers_restart = 55
+      end
+
+      assert_nil(bgp.graceful_restart_timers_stalepath_time,
+                 'graceful_restart_timers_stalepath_time should return nil ' \
+                 'on XR with non-default vrf')
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.graceful_restart_timers_stalepath_time = 77
+      end
+      bgp.destroy
+      return
+    end
+    bgp.graceful_restart = true
+    assert(bgp.graceful_restart,
+           'bgp graceful restart should be enabled')
+    bgp.graceful_restart_timers_restart = 55
+    assert_equal(55, bgp.graceful_restart_timers_restart,
+                 'bgp graceful restart timers restart' \
+                 "should be set to '55'")
+    bgp.graceful_restart_timers_stalepath_time = 77
+    assert_equal(77, bgp.graceful_restart_timers_stalepath_time,
+                 'bgp graceful restart timers stalepath time' \
+                 "should be set to '77'")
+    if platform == :nexus
       bgp.graceful_restart_helper = true
       assert(bgp.graceful_restart_helper,
-             "vrf #{vrf}: bgp graceful restart helper should be enabled")
-
-      bgp.graceful_restart = false
-      refute(bgp.graceful_restart,
-             "vrf #{vrf}: bgp graceful_restart should be disabled")
-      bgp.graceful_restart_timers_restart = 120
-      assert_equal(120, bgp.graceful_restart_timers_restart,
-                   "vrf #{vrf}: bgp graceful restart timers restart" \
-                   "should be set to default value of '120'")
-      bgp.graceful_restart_timers_stalepath_time = 300
-      assert_equal(300, bgp.graceful_restart_timers_stalepath_time,
-                   "vrf #{vrf}: bgp graceful restart timers stalepath time" \
-                   "should be set to default value of '300'")
+             'bgp graceful restart helper should be enabled')
+    else
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.graceful_restart_helper = true
+      end
+    end
+    bgp.graceful_restart = false
+    refute(bgp.graceful_restart,
+           'bgp graceful_restart should be disabled')
+    bgp.graceful_restart_timers_restart = 120
+    assert_equal(120, bgp.graceful_restart_timers_restart,
+                 'bgp graceful restart timers restart' \
+                 "should be set to default value of '120'")
+    bgp.graceful_restart_timers_stalepath_time = 300
+    assert_equal(300, bgp.graceful_restart_timers_stalepath_time,
+                 'bgp graceful restart timers stalepath time' \
+                 "should be set to default value of '300'")
+    if platform == :nexus
       bgp.graceful_restart_helper = false
       refute(bgp.graceful_restart_helper,
-             "vrf #{vrf}: bgp graceful restart helper should be disabled")
-      bgp.destroy
+             'bgp graceful restart helper should be disabled')
+    else
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.graceful_restart_helper = false
+      end
     end
+    bgp.destroy
   end
 
   def test_default_graceful_restart
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     assert(bgp.default_graceful_restart,
            'bgp graceful restart default value should be enabled = true')
     assert_equal(120, bgp.default_graceful_restart_timers_restart,
                  "bgp graceful restart default timer value should be '120'")
     assert_equal(300, bgp.default_graceful_restart_timers_stalepath_time,
                  "bgp graceful restart default timer value should be '300'")
-    refute(bgp.default_graceful_restart_helper,
-           'graceful restart helper default value should be enabled = false')
+    if platform == :nexus
+      refute(bgp.default_graceful_restart_helper,
+             'graceful restart helper default value ' \
+             'should be enabled = false')
+    else
+      assert_nil(bgp.default_graceful_restart_helper,
+                 'bgp default_graceful_restart_helper should ' \
+                 '*NOT* be supported')
+    end
+    bgp.destroy
   end
 
-  def test_confederation_id
-    %w(test_default test_vrf).each do |t|
-      if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
-      else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
-      end
-      bgp.confederation_id = 77
-      assert_equal('77', bgp.confederation_id,
-                   "vrf #{vrf}: bgp confederation_id should be set to '77'")
-      bgp.confederation_id = ''
-      assert_empty(bgp.confederation_id, "vrf #{vrf}: " \
-                   'bgp confederation_id should *NOT* be configured')
+  def test_confederation_id_default
+    confederation_id(setup_default)
+  end
+
+  def test_confederation_id_vrf
+    confederation_id(setup_vrf)
+  end
+
+  def confederation_id(bgp)
+    if platform == :ios_xr && @vrf != 'default'
+      # XR does not support this under a VRF, so test the getter and setter
+      assert_nil(bgp.confederation_id,
+                 'confederation_id should return nil on XR with ' \
+                 'non-default vrf')
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.confederation_id = 77
+      end
       bgp.destroy
+      return
     end
+    bgp.confederation_id = 77
+    assert_equal('77', bgp.confederation_id,
+                 "bgp confederation_id should be set to '77'")
+    bgp.confederation_id = ''
+    assert_empty(bgp.confederation_id, '' \
+                 'bgp confederation_id should *NOT* be configured')
+    bgp.destroy
   end
 
   def test_confed_id_uu76828
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     bgp.confederation_id = 55.77
     assert_equal('55.77', bgp.confederation_id,
                  "bgp confederation_id should be set to '55.77'")
+    bgp.destroy
   end
 
   def test_confederation_id_not_configured
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     assert_empty(bgp.confederation_id,
                  'bgp confederation_id should *NOT* be configured')
     bgp.destroy
   end
 
   def test_default_confederation_id
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     assert_empty(bgp.default_confederation_id,
                  'bgp confederation_id default value should be empty')
     bgp.destroy
   end
 
-  def test_confederation_peers
-    %w(test_default test_vrf).each do |t|
-      if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
-      else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
-      end
-      # Confederation peer configuration requires that a
-      # confederation id be configured first so the expectation
-      # in the next test is an empty peer list
-      bgp.confederation_id = 55
-      assert_empty(bgp.confederation_peers,
-                   "vrf #{vrf}: bgp confederation_peers list should be empty")
-      bgp.confederation_peers_set(15)
-      assert_equal('15', bgp.confederation_peers,
-                   "vrf #{vrf}: bgp confederation_peers list should be '15'")
-      bgp.confederation_peers_set(16)
-      assert_equal('16', bgp.confederation_peers,
-                   "vrf #{vrf}: bgp confederation_peers list should be '16'")
-      bgp.confederation_peers_set(55.77)
-      assert_equal('55.77', bgp.confederation_peers,
-                   "vrf #{vrf}: bgp confederation_peers list should be" \
-                   "'55.77'")
-      bgp.confederation_peers_set('15 16 55.77 18 555 299')
-      assert_equal('15 16 55.77 18 555 299',
-                   bgp.confederation_peers,
-                   "vrf #{vrf}: bgp confederation_peers list should be" \
-                   "'15 16 55.77 18 555 299'")
-      bgp.confederation_peers_set('')
-      assert_empty(bgp.confederation_peers,
-                   "vrf #{vrf}: bgp confederation_peers list should be empty")
+  def test_confederation_peers_default
+    confed_peers_test(setup_default)
+  end
+
+  def test_confederation_peers_vrf
+    confed_peers_test(setup_vrf)
+  end
+
+  def confed_peers_test(bgp)
+    # Confederation peer configuration requires that a
+    # confederation id be configured first so the expectation
+    # in the next test is an empty peer list
+    if platform == :ios_xr && @vrf != 'default'
+      # XR does not support this under a VRF, so test the getter and setter
+      assert_nil(bgp.confederation_peers,
+                 'confederation_peers should return nil on XR ' \
+                 'with non-default vrf')
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.confederation_peers = ['15', '55.77', '16', '18', '555', '299']
+      end
       bgp.destroy
+      return
     end
+    bgp.confederation_id = 55
+
+    assert_empty(bgp.confederation_peers,
+                 'bgp confederation_peers list should be empty')
+    bgp.confederation_peers = [15]
+    assert_equal(['15'], bgp.confederation_peers,
+                 "bgp confederation_peers list should be ['15']")
+    bgp.confederation_peers = [16]
+    assert_equal(['16'], bgp.confederation_peers,
+                 "bgp confederation_peers list should be ['16']")
+    bgp.confederation_peers = [55.77]
+    assert_equal(['55.77'], bgp.confederation_peers,
+                 'bgp confederation_peers list should be ' \
+                 "['55.77']")
+    bgp.confederation_peers = ['15', '55.77', '16', '18', '555', '299']
+    assert_equal(['15', '16', '18', '299', '55.77', '555'],
+                 bgp.confederation_peers,
+                 'bgp confederation_peers list should be ' \
+                 "'['15', '16', '18', '299', '55.77', '555']'")
+    bgp.confederation_peers = []
+    assert_empty(bgp.confederation_peers,
+                 'bgp confederation_peers list should be empty')
+    bgp.destroy
   end
 
   def test_confederation_peers_not_configured
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     assert_empty(bgp.confederation_peers,
                  'bgp confederation_peers list should *NOT* be configured')
     bgp.destroy
   end
 
   def test_default_confederation_peers
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     assert_empty(bgp.default_confederation_peers,
                  'bgp confederation_peers default value should be empty')
     bgp.destroy
   end
 
   def test_isolate
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    bgp.isolate = true
-    assert(bgp.isolate,
-           'bgp isolate should be enabled')
-    bgp.isolate = false
-    refute(bgp.isolate,
-           'bgp isolate should be disabled')
+    bgp = setup_default
+    if platform == :ios_xr
+      assert_nil(bgp.isolate)
+      assert_nil(bgp.default_isolate)
+      assert_raises(UnsupportedError) { bgp.isolate = true }
+    else
+      bgp.isolate = true
+      assert(bgp.isolate,
+             'bgp isolate should be enabled')
+      bgp.isolate = false
+      refute(bgp.isolate,
+             'bgp isolate should be disabled')
+    end
     bgp.destroy
   end
 
   def test_default_isolate
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     refute(bgp.isolate,
            'bgp isolate default value should be false')
     bgp.destroy
   end
 
-  def test_log_neighbor_changes
-    %w(test_default test_vrf).each do |t|
-      if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
-      else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
-      end
-      bgp.log_neighbor_changes = true
-      assert(bgp.log_neighbor_changes,
-             "vrf #{vrf}: bgp log_neighbor_changes should be enabled")
-      bgp.log_neighbor_changes = false
-      refute(bgp.log_neighbor_changes,
-             "vrf #{vrf}: bgp log_neighbor_changes should be disabled")
-      bgp.destroy
-    end
+  def test_log_neighbor_changes_default
+    log_neighbor_changes(setup_default)
   end
 
-  def test_log_neighbor_changes_not_configured
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    refute(bgp.log_neighbor_changes,
-           'bgp log_neighbor_changes should be disabled')
+  def test_log_neighbor_changes_vrf
+    log_neighbor_changes(setup_vrf)
+  end
+
+  def log_neighbor_changes(bgp)
+    if platform == :ios_xr
+      vrf_str = @vrf == 'default' ? '' : "vrf #{@vrf}"
+      @default_show_command =
+        "show running-config router bgp #{@asnum} #{vrf_str}"
+      @default_output_pattern = /bgp log neighbor changes disable/
+    else
+      @default_show_command = 'show run bgp all'
+      @default_output_pattern = /log-neighbor-changes/
+    end
+    bgp.log_neighbor_changes = false
+    refute(bgp.log_neighbor_changes)
+
+    msg_disable = 'log neighbor changes should be disabled'
+    msg_enable  = 'log neighbor changes should be enabled'
+
+    if platform == :ios_xr
+      # XR the disable keyword added
+      assert_show_match(msg: msg_disable)
+    else
+      # Nexus the command is removed
+      refute_show_match(msg: msg_disable)
+    end
+    bgp.log_neighbor_changes = true
+    assert(bgp.log_neighbor_changes)
+    if platform == :ios_xr
+      # XR removes the whole command including disable keyword
+      refute_show_match(msg: msg_enable)
+    else
+      # Nexus adds the log-neighbor-changes command
+      assert_show_match(msg: msg_enable)
+    end
     bgp.destroy
   end
 
   def test_default_log_neighbor_changes
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    refute(bgp.default_log_neighbor_changes,
-           'bgp log_neighbor_changes default value should be false')
+    bgp = setup_default
+    if bgp.default_log_neighbor_changes
+      # XR logging is on by default
+      assert(bgp.log_neighbor_changes,
+             'bgp log_neighbor_changes should be enabled')
+    else
+      refute(bgp.log_neighbor_changes,
+             'bgp log_neighbor_changes should be disabled')
+    end
     bgp.destroy
   end
 
-  def maxas_limit(vrf)
-    bgp = RouterBgp.new(55, vrf)
-    limit = 20
-    bgp.maxas_limit = limit
-    assert_equal(limit, bgp.maxas_limit, "vrf #{vrf}: maxas-limit invalid")
+  def test_maxas_limit_default
+    maxas_limit(setup_default)
+  end
 
-    limit = bgp.default_maxas_limit
-    bgp.maxas_limit = limit
-    assert_equal(limit, bgp.maxas_limit, "vrf #{vrf}: maxas-limit not default")
+  def test_maxas_limit_vrf
+    maxas_limit(setup_vrf)
   end
 
-  def test_maxas_limit
-    %w(default cyan).each do |vrf|
-      maxas_limit(vrf)
+  def maxas_limit(bgp)
+    if platform == :ios_xr
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.maxas_limit = 50
+      end
+    else
+      bgp.maxas_limit = 50
+      assert_equal(50, bgp.maxas_limit,
+                   "bgp maxas-limit should be set to '50'")
+      bgp.maxas_limit = bgp.default_maxas_limit
+      assert_equal(bgp.default_maxas_limit, bgp.maxas_limit,
+                   'bgp maxas-limit should be set to default value')
     end
+    bgp.destroy
+  end
+
+  def test_default_maxas_limit
+    bgp = setup_default
+    assert_equal(bgp.default_maxas_limit, bgp.maxas_limit,
+                 'bgp maxas-limit should be default value')
+    bgp.destroy
   end
 
   def test_neighbor_down_fib_accelerate
+    if platform == :ios_xr || node.product_id[/N(5|6|7)/]
+      b = RouterBgp.new(1)
+      assert_nil(b.neighbor_down_fib_accelerate)
+      assert_nil(b.default_neighbor_down_fib_accelerate)
+      assert_raises(Cisco::UnsupportedError) do
+        b.neighbor_down_fib_accelerate = true
+      end
+      return
+    end
     %w(test_default test_vrf).each do |t|
       if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
+        bgp = setup_default
       else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
+        bgp = setup_vrf
       end
+      default = bgp.default_neighbor_down_fib_accelerate
+      assert_equal(default, bgp.neighbor_down_fib_accelerate,
+                   'bgp neighbor_fib_down_accelerate not set to default value')
+
       bgp.neighbor_down_fib_accelerate = true
       assert(bgp.neighbor_down_fib_accelerate,
-             "vrf #{vrf}: bgp neighbor_down_fib_accelerate should be enabled")
+             "vrf #{@vrf}: bgp neighbor_down_fib_accelerate "\
+             'should be enabled')
       bgp.neighbor_down_fib_accelerate = false
       refute(bgp.neighbor_down_fib_accelerate,
-             "vrf #{vrf}: bgp neighbor_down_fib_accelerate should be disabled")
+             "vrf #{@vrf}: bgp neighbor_down_fib_accelerate "\
+             'should be disabled')
+
+      bgp.neighbor_down_fib_accelerate = default
+      assert_equal(default, bgp.neighbor_down_fib_accelerate,
+                   'bgp neighbor_fib_down_accelerate not set to default value')
       bgp.destroy
     end
   end
 
-  def test_neighbor_down_fib_accelerate_not_configured
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    refute(bgp.neighbor_down_fib_accelerate,
-           'bgp neighbor_down_fib_accelerate should be disabled')
-    bgp.destroy
-  end
-
-  def test_default_neighbor_down_fib_accelerate
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    refute(bgp.default_neighbor_down_fib_accelerate,
-           'bgp neighbor_down_fib_accelerate default value should be false')
-    bgp.destroy
-  end
-
   def test_reconnect_interval
+    if platform == :ios_xr || node.product_id[/N(5|6|7)/]
+      b = RouterBgp.new(1)
+      assert_nil(b.reconnect_interval)
+      assert_nil(b.default_reconnect_interval)
+      assert_raises(Cisco::UnsupportedError) do
+        b.reconnect_interval = 34
+      end
+      return
+    end
     %w(test_default test_vrf).each do |t|
       if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
+        bgp = setup_default
       else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
-      end
-      bgp.reconnect_interval = 34
-      assert_equal(34, bgp.reconnect_interval,
-                   "vrf #{vrf}: bgp reconnect_interval should be set to '34'")
-      bgp.reconnect_interval = 60
-      assert_equal(60, bgp.reconnect_interval,
-                   "vrf #{vrf}: bgp reconnect_interval should be set to '60'")
+        bgp = setup_vrf
+      end
+      if platform == :ios_xr
+        assert_raises(Cisco::UnsupportedError) do
+          bgp.reconnect_interval = 34
+        end
+      else
+        bgp.reconnect_interval = 34
+        assert_equal(34, bgp.reconnect_interval,
+                     "vrf #{@vrf}: bgp reconnect_interval should be set to 34")
+        bgp.reconnect_interval = 60
+        assert_equal(60, bgp.reconnect_interval,
+                     "vrf #{@vrf}: bgp reconnect_interval should be set to 60")
+      end
       bgp.destroy
     end
   end
 
   def test_reconnect_interval_default
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    assert_equal(bgp.default_reconnect_interval, bgp.reconnect_interval,
-                 'reconnect_interval should be set to default value')
-    bgp.destroy
+    bgp = setup_default
+    if platform == :ios_xr
+      assert_nil(bgp.reconnect_interval,
+                 'reconnect_interval should return nil on XR')
+    else
+      assert_equal(bgp.default_reconnect_interval, bgp.reconnect_interval,
+                   "reconnect_interval should be set to default value of '60'")
+      bgp.destroy
+    end
   end
 
   def test_route_distinguisher
+    skip_nexus_i2_image?
     remove_all_vrfs
 
-    bgp = RouterBgp.new(55, 'blue')
+    bgp = setup_vrf
+    assert_empty(bgp.route_distinguisher,
+                 'bgp route_distinguisher should *NOT* be configured')
+
     bgp.route_distinguisher = 'auto'
     assert_equal('auto', bgp.route_distinguisher)
 
@@ -798,63 +1097,58 @@ class TestRouterBgp < CiscoTestCase
   def test_router_id
     %w(test_default test_vrf).each do |t|
       if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
+        bgp = setup_default
       else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
+        bgp = setup_vrf
       end
-      bgp.router_id = '1.2.3.4'
-      assert_equal('1.2.3.4', bgp.router_id,
-                   "vrf #{vrf}: bgp router_id should be set to '1.2.3.4'")
+      bgp.router_id = '7.8.9.11'
+      assert_equal('7.8.9.11', bgp.router_id,
+                   "vrf #{@vrf}: bgp router_id invalid")
       bgp.router_id = ''
       assert_empty(bgp.router_id,
-                   "vrf #{vrf}: bgp router_id should *NOT* be configured")
+                   "vrf #{@vrf}: bgp router_id should *NOT* be configured")
       bgp.destroy
     end
   end
 
   def test_router_id_not_configured
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     assert_empty(bgp.router_id,
                  'bgp router_id should *NOT* be configured')
     bgp.destroy
   end
 
   def test_default_router_id
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     assert_empty(bgp.default_router_id,
                  'bgp router_id default value should be empty')
     bgp.destroy
   end
 
   def test_shutdown
-    # NOTE: Shutdown command only applies under
-    # default vrf
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    bgp.shutdown = true
-    assert(bgp.shutdown, 'bgp should be shutdown')
-    bgp.shutdown = false
-    refute(bgp.shutdown, "bgp should in 'no shutdown' state")
+    bgp = setup_default
+    if platform == :ios_xr
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.shutdown = true
+      end
+    else
+      bgp.shutdown = true
+      assert(bgp.shutdown, 'bgp should be shutdown')
+      bgp.shutdown = false
+      refute(bgp.shutdown, "bgp should in 'no shutdown' state")
+    end
     bgp.destroy
   end
 
   def test_shutdown_not_configured
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     refute(bgp.shutdown,
            "bgp should be in 'no shutdown' state")
     bgp.destroy
   end
 
   def test_default_shutdown
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     refute(bgp.default_shutdown,
            'bgp shutdown default value should be false')
     bgp.destroy
@@ -863,35 +1157,35 @@ class TestRouterBgp < CiscoTestCase
   def test_suppress_fib_pending
     %w(test_default test_vrf).each do |t|
       if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
+        bgp = setup_default
+      else
+        bgp = setup_vrf
+      end
+      if platform == :ios_xr
+        assert_raises(Cisco::UnsupportedError) do
+          bgp.suppress_fib_pending = true
+        end
       else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
-      end
-      bgp.suppress_fib_pending = true
-      assert(bgp.suppress_fib_pending,
-             "vrf #{vrf}: bgp suppress_fib_pending should be enabled")
-      bgp.suppress_fib_pending = false
-      refute(bgp.suppress_fib_pending,
-             "vrf #{vrf}: bgp suppress_fib_pending should be disabled")
+        bgp.suppress_fib_pending = true
+        assert(bgp.suppress_fib_pending,
+               "vrf #{@vrf}: bgp suppress_fib_pending should be enabled")
+        bgp.suppress_fib_pending = false
+        refute(bgp.suppress_fib_pending,
+               "vrf #{@vrf}: bgp suppress_fib_pending should be disabled")
+      end
       bgp.destroy
     end
   end
 
   def test_suppress_fib_pending_not_configured
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     refute(bgp.suppress_fib_pending,
            'bgp suppress_fib_pending should be disabled')
     bgp.destroy
   end
 
   def test_default_suppress_fib_pending
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     refute(bgp.default_suppress_fib_pending,
            'bgp suppress_fib_pending default value should be false')
     bgp.destroy
@@ -900,64 +1194,71 @@ class TestRouterBgp < CiscoTestCase
   def test_timer_bestpath_limit
     %w(test_default test_vrf).each do |t|
       if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
+        bgp = setup_default
       else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
-      end
-      bgp.timer_bestpath_limit_set(34)
-      assert_equal(34, bgp.timer_bestpath_limit, "vrf #{vrf}: " \
-                   "bgp timer_bestpath_limit should be set to '34'")
-      bgp.timer_bestpath_limit_set(300)
-      assert_equal(300, bgp.timer_bestpath_limit, "vrf #{vrf}: " \
-                   "bgp timer_bestpath_limit should be set to '300'")
+        bgp = setup_vrf
+      end
+      if platform == :ios_xr
+        assert_raises(Cisco::UnsupportedError) do
+          bgp.timer_bestpath_limit_set(34)
+        end
+      else
+        bgp.timer_bestpath_limit_set(34)
+        assert_equal(34, bgp.timer_bestpath_limit, "vrf #{@vrf}: " \
+                     "bgp timer_bestpath_limit should be set to '34'")
+        bgp.timer_bestpath_limit_set(300)
+        assert_equal(300, bgp.timer_bestpath_limit, "vrf #{@vrf}: " \
+                     "bgp timer_bestpath_limit should be set to '300'")
+      end
       bgp.destroy
     end
   end
 
   def test_timer_bestpath_limit_default
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
-    assert_equal(300, bgp.timer_bestpath_limit,
-                 "timer_bestpath_limit should be default value of '300'")
+    bgp = setup_default
+    if platform == :ios_xr
+      assert_nil(bgp.timer_bestpath_limit,
+                 'timer_bestpath_limit should be nil for XR')
+    else
+      assert_equal(300, bgp.timer_bestpath_limit,
+                   "timer_bestpath_limit should be default value of '300'")
+    end
     bgp.destroy
   end
 
-  def test_timer_bestpath_limit_always
-    %w(test_default test_vrf).each do |t|
-      if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
-      else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
+  def test_timer_bestpath_limit_always_default
+    timer_bestpath_limit_always(setup_default)
+  end
+
+  def test_timer_bestpath_limit_always_vrf
+    timer_bestpath_limit_always(setup_vrf)
+  end
+
+  def timer_bestpath_limit_always(bgp)
+    if platform == :ios_xr
+      assert_raises(Cisco::UnsupportedError) do
+        bgp.timer_bestpath_limit_set(34, true)
       end
+    else
       bgp.timer_bestpath_limit_set(34, true)
       assert(bgp.timer_bestpath_limit_always,
-             "vrf #{vrf}: bgp timer_bestpath_limit_always should be enabled")
+             "vrf #{@vrf}: bgp timer_bestpath_limit_always should be enabled")
       bgp.timer_bestpath_limit_set(34, false)
       refute(bgp.timer_bestpath_limit_always,
-             "vrf #{vrf}: bgp timer_bestpath_limit_always should be disabled")
-      bgp.destroy
+             "vrf #{@vrf}: bgp timer_bestpath_limit_always should be disabled")
     end
+    bgp.destroy
   end
 
   def test_timer_bestpath_limit_always_not_configured
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     refute(bgp.timer_bestpath_limit_always,
            'bgp timer_bestpath_limit_always should be disabled')
     bgp.destroy
   end
 
   def test_default_timer_bestpath_limit_always
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     refute(bgp.default_timer_bestpath_limit_always,
            'bgp timer_bestpath_limit_always default value should be false')
     bgp.destroy
@@ -966,38 +1267,33 @@ class TestRouterBgp < CiscoTestCase
   def test_timer_bgp_keepalive_hold
     %w(test_default test_vrf).each do |t|
       if t == 'test_default'
-        asnum = 55
-        vrf = 'default'
-        bgp = RouterBgp.new(asnum)
+        bgp = setup_default
       else
-        asnum = 99
-        vrf = 'yamllll'
-        bgp = RouterBgp.new(asnum, vrf)
+        bgp = setup_vrf
       end
       bgp.timer_bgp_keepalive_hold_set(25, 45)
-      assert_equal(%w(25 45), bgp.timer_bgp_keepalive_hold, "vrf #{vrf}: " \
+      assert_equal(%w(25 45), bgp.timer_bgp_keepalive_hold, "vrf #{@vrf}: " \
                    "keepalive and hold values should be '25 and 45'")
       bgp.timer_bgp_keepalive_hold_set(60, 180)
-      assert_equal(%w(60 180), bgp.timer_bgp_keepalive_hold, "vrf #{vrf}: " \
+      assert_equal(%w(60 180), bgp.timer_bgp_keepalive_hold, "vrf #{@vrf}: " \
                    "keepalive and hold values should be '60 and 180'")
-      assert_equal(60, bgp.timer_bgp_keepalive, "vrf #{vrf}: " \
+      assert_equal(60, bgp.timer_bgp_keepalive, "vrf #{@vrf}: " \
                    "keepalive value should be '60'")
-      assert_equal(180, bgp.timer_bgp_holdtime, "vrf #{vrf}: " \
+      assert_equal(180, bgp.timer_bgp_holdtime, "vrf #{@vrf}: " \
                    "keepalive value should be '180'")
       bgp.timer_bgp_keepalive_hold_set(500, 3600)
-      assert_equal(%w(500 3600), bgp.timer_bgp_keepalive_hold, "vrf #{vrf}: " \
+      assert_equal(%w(500 3600), bgp.timer_bgp_keepalive_hold, "vrf #{@vrf}: " \
                    "keepalive and hold values should be '500 and 3600'")
-      assert_equal(500, bgp.timer_bgp_keepalive, "vrf #{vrf}: " \
+      assert_equal(500, bgp.timer_bgp_keepalive, "vrf #{@vrf}: " \
                    "keepalive value should be '500'")
-      assert_equal(3600, bgp.timer_bgp_holdtime, "vrf #{vrf}: " \
+      assert_equal(3600, bgp.timer_bgp_holdtime, "vrf #{@vrf}: " \
                    "keepalive value should be '3600'")
       bgp.destroy
     end
   end
 
   def test_default_timer_keepalive_hold_default
-    asnum = 55
-    bgp = RouterBgp.new(asnum)
+    bgp = setup_default
     assert_equal(%w(60 180), bgp.default_timer_bgp_keepalive_hold,
                  'bgp timer_bestpath_timer_keepalive_hold_default values ' \
                  "should be '60' and '180'")