cisco_node_utils 1.3.0 → 1.4.0

data/tests/test_dns_domain.rb

@@ -51,7 +51,7 @@ class TestDnsDomain < CiscoTestCase
 
   # TESTS
 
-  def test_dnsdomain_create_destroy_single
+  def test_create_destroy_single
     id = 'aoeu.com'
     refute_includes(Cisco::DnsDomain.dnsdomains, id)
 
@@ -63,7 +63,7 @@ class TestDnsDomain < CiscoTestCase
     refute_includes(Cisco::DnsDomain.dnsdomains, id)
   end
 
-  def test_dnsdomain_create_destroy_multiple
+  def test_create_destroy_multiple
     id1 = 'aoeu.com'
     id2 = 'asdf.com'
     refute_includes(Cisco::DnsDomain.dnsdomains, id1)
@@ -83,7 +83,7 @@ class TestDnsDomain < CiscoTestCase
     refute_includes(Cisco::DnsDomain.dnsdomains, id2)
   end
 
-  def test_dnsdomain_create_destroy_single_vrf
+  def test_create_destroy_single_vrf
     id = 'aoeu.com'
     vrf = 'test'
     non_vrf = Cisco::DnsDomain.new(id)
@@ -100,7 +100,7 @@ class TestDnsDomain < CiscoTestCase
     non_vrf.destroy
   end
 
-  def test_dnsdomain_create_destroy_multiple_vrf
+  def test_create_destroy_multiple_vrf
     id1 = 'aoeu.com'
     id2 = 'asdf.com'
     vrf = 'test'

data/tests/test_domain_name.rb

@@ -51,7 +51,7 @@ class TestDomainName < CiscoTestCase
 
   # TESTS
 
-  def test_domainname_create_replace_destroy
+  def test_create_replace_destroy
     name1 = 'test.abc'
     name2 = 'test.xyz'
     refute_includes(Cisco::DomainName.domainnames, name1)
@@ -72,7 +72,7 @@ class TestDomainName < CiscoTestCase
     refute_includes(Cisco::DomainName.domainnames, name2)
   end
 
-  def test_domainname_create_replace_destroy_vrf
+  def test_create_replace_destroy_vrf
     name1 = 'test.abc'
     name2 = 'test.xyz'
     vrf = 'test'

data/tests/test_encapsulation.rb

@@ -23,16 +23,14 @@ class TestEncapsulation < CiscoTestCase
 
   def setup
     super
+    vdc_limit_f3_no_intf_needed(:set)
     return unless @@pre_clean_needed
-
-    # This provider requires MT-Full and a compatible linecard
-    mt_full_interface?
-    Vdc.new('default').limit_resource_module_type = 'f3'
     cleanup
     @@pre_clean_needed = false # rubocop:disable Style/ClassVars
   end
 
   def teardown
+    vdc_limit_f3_no_intf_needed(:clear) if first_or_last_teardown
     cleanup
     super
   end

data/tests/test_evpn_vni.rb

@@ -73,13 +73,20 @@ class TestEvpnVni < CiscoTestCase
   # test route_target
   def test_route_target
     vni = EvpnVni.new(4096)
-
-    # test route target both auto and route target both auto evpn
-    if Utils.nexus_i2_image
-      opts = [:import, :export]
-    else
-      opts = [:both, :import, :export]
-    end
+    opts = [:both, :import, :export]
+
+    # 'route_target_both' has limited support with I3 and later images.
+    # The Puppet README states:
+    # Caveat: The route_target_both property is discouraged due to the
+    # inconsistent behavior of the property across Nexus platforms and image
+    # versions. The 'both' keyword has a transformative behavior on some
+    # platforms/versions in which it creates two cli configurations: one for
+    # import targets, a second for export targets, while the 'both' command
+    # itself may not appear at all. When the 'both' keyword does not appear
+    # in the configuration it causes an idempotency problem for puppet. For
+    # this reason it is recommended to use explicit 'route_target_export' and
+    # 'route_target_import' properties instead of route_target_both.
+    opts.delete(:both) unless Utils.nexus_i2_image
 
     # Master list of communities to test against
     master = ['1.2.3.4:55', '2:2', '55:33', 'auto']

data/tests/test_fabricpath_global.rb

@@ -23,32 +23,31 @@ include Cisco
 # TestFabricpathGlobal - Minitest for Fabricpath Global node utils
 class TestFabricpathGlobal < CiscoTestCase
   @skip_unless_supported = 'fabricpath'
+  @@pre_clean_needed = true # rubocop:disable Style/ClassVars
 
   def setup
-    # setup runs at the beginning of each test
     super
-    fabricpath_testenv_setup
-    no_feature_fabricpath
+    vdc_limit_f3_no_intf_needed(:set)
+    return unless @@pre_clean_needed
+    config_no_warn('no nv overlay evpn ; no feature nv overlay')
+    remove_fabricpath_globals
+    @@pre_clean_needed = false # rubocop:disable Style/ClassVars
   end
 
   def teardown
-    # teardown runs at the end of each test
-    no_feature_fabricpath
+    remove_fabricpath_globals
+    if first_or_last_teardown
+      vdc_limit_f3_no_intf_needed(:clear)
+      config_no_warn('no feature-set fabricpath')
+    end
     super
   end
 
-  def no_feature_fabricpath
+  def remove_fabricpath_globals
     fg = FabricpathGlobal.globals
     fg.each { |_key, elem| elem.destroy } unless fg.empty?
   end
 
-  #  def no_feature_fabricpath
-  #    # Turn the feature off for a clean test.
-  #    config('no feature-set fabricpath')
-  #  end
-
-  # TESTS
-
   def test_create_destroy
     assert_empty(FabricpathGlobal.globals)
 

data/tests/test_feature.rb

@@ -22,6 +22,27 @@ include Cisco
 class TestFeature < CiscoTestCase
   @skip_unless_supported = 'feature'
 
+  def teardown
+    # f3 cleanup for non-f3 N7k's
+    vdc_limit_f3_no_intf_needed(:clear) if first_or_last_teardown
+
+    ['no nv overlay evpn',
+     'no feature bfd',
+     'no feature bgp',
+     'no feature dhcp',
+     'no feature fabric forwarding',
+     'no feature-set fex',
+     'no feature itd',
+     'no feature nv overlay',
+     'no feature ospf',
+     'no feature pim',
+     'no feature private-vlan',
+     'no feature tacacs',
+     'no feature vn-segment-vlan-based',
+     'no feature vni',
+     'no feature vtp'].each { |f| config_no_warn(f) }
+  end
+
   ###########
   # Helpers #
   ###########
@@ -33,6 +54,7 @@ class TestFeature < CiscoTestCase
 
     if ref
       feat_str = Regexp.last_match[1]
+      refute_nil(feat_str)
     else
       skip("'feature','#{feat}' is unsupported on this node")
     end
@@ -62,10 +84,19 @@ class TestFeature < CiscoTestCase
   ###################
   # Feature tests   #
   ###################
+
+  def test_bfd
+    feature('bfd')
+  end
+
   def test_bgp
     feature('bgp')
   end
 
+  def test_dhcp
+    feature('dhcp')
+  end
+
   def test_fabric_forwarding
     if node.product_id[/N(3)/]
       assert_nil(Feature.fabric_forwarding_enabled?)
@@ -85,12 +116,7 @@ class TestFeature < CiscoTestCase
       assert_raises(Cisco::UnsupportedError) { Feature.nv_overlay_enable }
       return
     end
-
-    # Dependency setup
-    vxlan_linecard?
-    vdc_lc_state('f3')
-    config_no_warn('no feature-set fabricpath')
-
+    vdc_limit_f3_no_intf_needed(:set)
     feature('nv_overlay')
   end
 
@@ -100,9 +126,8 @@ class TestFeature < CiscoTestCase
       assert_raises(Cisco::UnsupportedError) { Feature.nv_overlay_evpn_enable }
       return
     end
-    vxlan_linecard?
-    vdc_lc_state('f3')
 
+    vdc_limit_f3_no_intf_needed(:set)
     # nv_overlay_evpn can't use the 'feature' helper so test it explicitly here
     # Get current state of feature, then disable it
     pre_clean_enabled = Feature.nv_overlay_evpn_enabled?
@@ -144,15 +169,12 @@ class TestFeature < CiscoTestCase
   end
 
   def test_vni
-    # Dependency setup
-    vxlan_linecard?
-    vdc_lc_state('f3')
-
     if node.product_id[/N(5|6)/]
       Feature.nv_overlay_enable
     else
       # vni can't be removed if nv overlay is present
       config_no_warn('no feature nv overlay')
+      vdc_limit_f3_no_intf_needed(:set)
     end
     feature('vni')
   rescue RuntimeError => e
@@ -173,10 +195,10 @@ class TestFeature < CiscoTestCase
       assert_raises(Cisco::UnsupportedError) { Feature.fabric_enable }
       return
     end
+    vdc_limit_f3_no_intf_needed(:set)
     fs = 'feature-set fabric'
     # Get current state of the feature-set
     feature_set_installed = Feature.fabric_installed?
-    feature_enabled = Feature.fabric_enabled?
 
     config("no #{fs} ; no install #{fs}") if feature_set_installed
     refute_show_match(
@@ -187,10 +209,6 @@ class TestFeature < CiscoTestCase
 
     Feature.fabric_enable
     assert(Feature.fabric_enabled?, "(#{fs}) is not enabled")
-
-    # Return testbed to pre-clean state
-    config("no #{fs}") unless feature_enabled
-    config("no install #{fs}") unless feature_set_installed
   end
 
   def test_feature_set_fex

data/tests/test_interface.rb

@@ -64,6 +64,14 @@ class TestInterface < CiscoTestCase
 
   def teardown
     interface_ethernet_default(interfaces[0])
+    if first_or_last_teardown
+      config_no_warn('no feature pim')
+      config_no_warn('no feature dhcp')
+      config_no_warn('no feature bfd')
+      config_no_warn('no feature interface-vlan')
+      config_no_warn('no feature-set fabric')
+      config_no_warn('no install feature-set fabric')
+    end
     super
   end
 
@@ -184,12 +192,10 @@ class TestInterface < CiscoTestCase
     flunk(message)
   end
 
-  # Helper to find first valid speed that isn't "auto"
-  def valid_speed_set(interface)
-    valid_speed = nil
-    speeds = capable_speed_values(interface)
-    speeds.each do |value|
-      next if value == 'auto'
+  # Helper to find all configurable speeds for an interface
+  def valid_speeds(interface)
+    speeds = []
+    capable_speed_values(interface).each do |value|
       begin
         interface.speed = value
         assert_equal(value, interface.speed)
@@ -197,11 +203,9 @@ class TestInterface < CiscoTestCase
         next if speed_change_disallowed?(e.message)
         raise
       end
-      # Exit loop once proper speed is found
-      valid_speed = value
-      break
+      speeds << value
     end
-    valid_speed
+    speeds
   end
 
   # Helper to check for misc speed change disallowed error messages.
@@ -211,7 +215,8 @@ class TestInterface < CiscoTestCase
                 'requested config change not allowed',
                 /does not match the (transceiver speed|port capability)/,
                 'but the transceiver doesn t support this speed',
-                '% Ambiguous parameter']
+                '% Ambiguous parameter',
+                '% Invalid parameter']
     message[Regexp.union(patterns)]
   end
 
@@ -254,8 +259,21 @@ class TestInterface < CiscoTestCase
                "Error: #{interface.name} shutdown is not false")
 
         interface.shutdown = true
-        assert(interface.shutdown,
-               "Error: #{interface.name} shutdown is not true")
+        # On some platforms, a small delay is needed after setting the
+        # shutdown property before the new state can be retrieved by
+        # the getter.
+        # TBD: Likely a bug in nxapi, but it's not reproducible using
+        # the nxapi sandbox.
+        begin
+          assert(interface.shutdown,
+                 "Error: #{interface.name} shutdown is not true")
+        rescue Minitest::Assertion
+          sleep 1
+          node.cache_flush
+          tries ||= 1
+          retry unless (tries += 1) > 5
+          raise
+        end
 
         # Test default shutdown state
         if k.downcase.include?('ethernet') # Ethernet interfaces
@@ -486,43 +504,43 @@ class TestInterface < CiscoTestCase
     end
   end
 
-  def test_interface_create_name_nil
+  def test_create_name_nil
     assert_raises(TypeError) do
       Interface.new(nil)
     end
   end
 
-  def test_interface_create_name_invalid
+  def test_create_name_invalid
     assert_raises(TypeError) do
       Interface.new(node)
     end
   end
 
-  def test_interface_create_does_not_exist
+  def test_create_does_not_exist
     assert_raises(CliError) do
       Interface.new('bogus')
     end
   end
 
-  def test_interface_create_valid
+  def test_create_valid
     interface = Interface.new(interfaces[0])
     assert_equal(interfaces[0].downcase, interface.name)
   end
 
-  def test_interface_description_nil
+  def test_description_nil
     interface = Interface.new(interfaces[0])
     assert_raises(TypeError) do
       interface.description = nil
     end
   end
 
-  def test_interface_description_zero_length
+  def test_description_zero_length
     interface = Interface.new(interfaces[0])
     interface.description = ''
     assert_equal('', interface.description)
   end
 
-  def test_interface_description_valid
+  def test_description_valid
     interface = Interface.new(interfaces[0])
     description = 'This is a test description ! '
     interface.description = description
@@ -541,7 +559,35 @@ class TestInterface < CiscoTestCase
     subif.destroy
   end
 
-  def test_interface_mtu_change
+  def test_bfd_echo
+    interface = Interface.new(interfaces[0])
+    if validate_property_excluded?('interface', 'bfd_echo')
+      assert_nil(interface.bfd_echo)
+      assert_raises(Cisco::UnsupportedError) { interface.bfd_echo = false }
+      return
+    end
+    assert_equal(interface.default_bfd_echo,
+                 interface.bfd_echo)
+    interface.bfd_echo = false
+    assert_equal(false, interface.bfd_echo)
+    interface.bfd_echo = interface.default_bfd_echo
+    assert_equal(interface.default_bfd_echo,
+                 interface.bfd_echo)
+    # Clean up any stale config first
+    inf_name = "#{@port_channel}10"
+    Interface.new(inf_name).destroy
+
+    interface = Interface.new(inf_name)
+    assert_equal(interface.default_bfd_echo,
+                 interface.bfd_echo)
+    interface.bfd_echo = false
+    assert_equal(false, interface.bfd_echo)
+    interface.bfd_echo = interface.default_bfd_echo
+    assert_equal(interface.default_bfd_echo,
+                 interface.bfd_echo)
+  end
+
+  def test_mtu_change
     interface = Interface.new(interfaces[0])
     interface.switchport_mode = :disabled
     interface.mtu = 1520
@@ -552,13 +598,13 @@ class TestInterface < CiscoTestCase
     assert_equal(interface.default_mtu, interface.mtu)
   end
 
-  def test_interface_mtu_invalid
+  def test_mtu_invalid
     interface = Interface.new(interfaces[0])
     interface.switchport_mode = :disabled
     assert_raises(Cisco::CliError) { interface.mtu = 'hello' }
   end
 
-  def test_interface_mtu_valid
+  def test_mtu_valid
     interface = Interface.new(interfaces[0])
     interface.switchport_mode = :disabled
     interface.mtu = 1550
@@ -625,8 +671,9 @@ class TestInterface < CiscoTestCase
 
     # Ensure speed is non-auto value
     if interface.default_speed == 'auto'
-      valid_speed = valid_speed_set(interface)
+      valid_speed = valid_speeds(interface).select { |v| v != 'auto' }.shift
       skip('Cannot configure non-auto speed') if valid_speed.nil?
+      interface.speed = valid_speed
     end
 
     # Test non-default values
@@ -642,7 +689,7 @@ class TestInterface < CiscoTestCase
     assert_equal(interface.duplex, interface.default_duplex)
   end
 
-  def test_interface_shutdown_valid
+  def test_shutdown_valid
     interface = Interface.new(interfaces[0])
     interface.shutdown = true
     assert(interface.shutdown, 'Error: shutdown state is not true')
@@ -659,14 +706,14 @@ class TestInterface < CiscoTestCase
                'Error: svi_management should be nil when interface is ethernet')
   end
 
-  #   def test_interface_get_prefix_list_when_switchport
+  #   def test_prefix_list_when_switchport
   #     interface = Interface.new(interfaces[0])
   #     interface.switchport_mode = :access
   #     addresses = interface.prefixes
   #     assert_empty(addresses)
   #   end
   #
-  #   def test_interface_get_prefix_list_with_ipv4_address_assignment
+  #   def test_prefix_list_with_ipv4
   #     interface = Interface.new(interfaces[0])
   #     interface.switchport_mode = :access
   #     interface.switchport_mode = :disabled if platform == :nexus
@@ -679,7 +726,7 @@ class TestInterface < CiscoTestCase
   #     prefixes = nil
   #   end
   #
-  #   def test_interface_get_prefix_list_with_ipv6_address_assignment
+  #   def test_prefix_list_with_ipv6
   #     interface = Interface.new(interfaces[0] )
   #     interface.switchport_mode = :access
   #     interface.switchport_mode = :disabled if platform == :nexus
@@ -692,7 +739,7 @@ class TestInterface < CiscoTestCase
   #     prefixes = nil
   #   end
   #
-  #   def test_interface_prefix_list_with_both_ip4_and_ipv6_address_assignments
+  #   def test_prefix_list_with_ipv4_ipv6
   #     interface = Interface.new(interfaces[0])
   #     interface.switchport_mode = :access
   #     interface.switchport_mode = :disabled if platform == :nexus
@@ -707,68 +754,35 @@ class TestInterface < CiscoTestCase
   #     prefixes = nil
   #   end
 
-  def negotiate_auto_helper(interface, default, speed)
+  def negotiate_auto_helper(interface, speed)
     if validate_property_excluded?('interface',
                                    interface.negotiate_auto_lookup_string)
       assert_raises(Cisco::UnsupportedError) { interface.negotiate_auto = true }
       return
     end
-    # Check current default state before any other changes
-    inf_name = interface.name
-    assert_equal(default, interface.default_negotiate_auto,
-                 "Error: #{inf_name} negotiate auto default value mismatch")
-
-    # Test non-defaults: Note that 'speed' and 'negotiate' are tightly coupled
-    # on some platforms. Some platforms need the speed command to be toggled
-    # before negotiate will work without raising an error; while others just
-    # need a non-'auto' speed value or may not support 'auto' at all; therefore
-    # just set a static speed value before setting any negotiate settings.
-    if default == true
-      negotiate_false(interface, speed)
-      negotiate_true(interface, speed)
-    else
-      negotiate_true(interface, speed)
-      negotiate_false(interface, speed)
-    end
-  end
 
-  def negotiate_true(interface, speed)
-    # puts " true: 'speed #{speed}', 'negotiate auto'"
-    intf = interface.name
+    # Note that 'speed' and 'negotiate auto' are tightly coupled
+    # When speed is 'auto', set negotiate auto to 'true'
+    # When speed is static value, turn off negotiate auto
     interface.speed = speed
-    interface.negotiate_auto = true
-    assert(interface.negotiate_auto,
-           "#{intf} negotiate auto value should be true")
-    assert_show_match(pattern: /^\s+negotiate auto/)
-  rescue Cisco::CliError => e
-    # 10G+ interfaces do not support negotiation
-    interface_supports_property?(intf, e.message)
-  end
-
-  # Yes, this method is nearly identical to negotiate_true.
-  # The negotiate property is evil to troubleshoot. Keep them separate.
-  def negotiate_false(interface, speed)
-    # puts "false: 'speed #{speed}', 'no negotiate auto'"
-    intf = interface.name
-    interface.speed = speed
-    interface.negotiate_auto = false
-    refute(interface.negotiate_auto,
-           "#{intf} negotiate auto value should be false")
-    assert_show_match(pattern: /^\s+no negotiate auto/)
-  rescue Cisco::CliError => e
-    # 10G+ interfaces do not support negotiation
-    interface_supports_property?(intf, e.message)
+    if speed == 'auto'
+      interface.negotiate_auto = true
+      assert(interface.negotiate_auto,
+             "#{interface.name} negotiate auto value should be true")
+    else
+      interface.negotiate_auto = false
+      refute(interface.negotiate_auto,
+             "#{interface.name} negotiate auto value should be false")
+    end
   end
 
   def test_negotiate_auto_portchannel
-    # Create interface member of this group (required for XR)
-    member = InterfaceChannelGroup.new(interfaces[0])
-    begin
-      member.channel_group = 10
-    rescue Cisco::UnsupportedError
-      # Some XR platform/version combinations don't support port-channel intfs
-      skip('bundle id config not supported on this node') if platform == :ios_xr
-      raise
+    if validate_property_excluded?('interface_channel_group', 'channel_group')
+      member = InterfaceChannelGroup.new(interfaces[0])
+      assert_raises(Cisco::UnsupportedError) do
+        member.channel_group = 10
+      end
+      return
     end
 
     # Clean up any stale config first
@@ -783,20 +797,14 @@ class TestInterface < CiscoTestCase
         interface.negotiate_auto = false
       end
     else
-      default = interface.default_negotiate_auto
       @default_show_command = show_cmd(inf_name)
 
-      # Port-channels will raise an error on some platforms unless they
-      # have a static speed value set first.
-      speed = '100'
-
-      # Test with switchport
-      interface.switchport_mode = :access
-      negotiate_auto_helper(interface, default, speed)
+      # Platforms raise error unless speed is properly configured first
+      speeds = valid_speeds(interface)
+      negotiate_auto_helper(interface, 'auto') if speeds.delete('auto')
 
-      # Test with no switchport
-      interface.switchport_mode = :disabled
-      negotiate_auto_helper(interface, default, speed)
+      non_auto = speeds.shift
+      negotiate_auto_helper(interface, non_auto) unless non_auto.nil?
     end
 
     # Cleanup
@@ -816,20 +824,14 @@ class TestInterface < CiscoTestCase
       return
     end
 
-    # Find a static speed. Some platforms will raise an error unless
-    # speed is configured before setting negotiate auto.
-    speed = valid_speed_set(interface)
-
-    default = interface.default_negotiate_auto
     @default_show_command = show_cmd(inf_name)
 
-    # Test with switchport
-    interface.switchport_mode = :access
-    negotiate_auto_helper(interface, default, speed)
+    # Platforms raise error unless speed is properly configured first
+    speeds = valid_speeds(interface)
+    negotiate_auto_helper(interface, 'auto') if speeds.delete('auto')
 
-    # Test with no switchport
-    interface.switchport_mode = :disabled
-    negotiate_auto_helper(interface, default, speed)
+    non_auto = speeds.shift
+    negotiate_auto_helper(interface, non_auto) unless non_auto.nil?
   end
 
   def test_negotiate_auto_loopback
@@ -859,7 +861,7 @@ class TestInterface < CiscoTestCase
     refute_empty(Interface.interfaces, 'Error: interfaces collection empty')
   end
 
-  def test_interface_ipv4_addr_mask_set_address_invalid
+  def test_ipv4_addr_mask_set_inv
     interface = create_interface
     interface.switchport_mode = :disabled if platform == :nexus
     assert_raises(Cisco::CliError) do
@@ -867,7 +869,7 @@ class TestInterface < CiscoTestCase
     end
   end
 
-  def test_interface_ipv4_addr_mask_set_netmask_invalid
+  def test_ipv4_addr_mask_set_inv_mask
     interface = create_interface
     interface.switchport_mode = :disabled if platform == :nexus
     assert_raises(Cisco::CliError) do
@@ -955,7 +957,7 @@ class TestInterface < CiscoTestCase
     end
   end
 
-  def test_interface_ipv4_address
+  def test_ipv4_address
     interface = create_interface
     interface.switchport_mode = :disabled if platform == :nexus
     address = '8.7.1.1'
@@ -1010,7 +1012,7 @@ class TestInterface < CiscoTestCase
                  'Error: ipv4 netmask length default get value mismatch')
   end
 
-  def test_interface_ipv4_address_getter_with_preconfig
+  def test_ipv4_addr_preconfig
     address = '8.7.1.1'
     length = 15
     ifname = interfaces[0]
@@ -1027,7 +1029,7 @@ class TestInterface < CiscoTestCase
     interface_ipv4_config(ifname, address, length, false)
   end
 
-  def test_interface_ipv4_address_getter_with_preconfig_secondary
+  def test_ipv4_addr_preconfig_sec
     address = '8.7.1.1'
     length = 15
     sec_address = '1.1.2.5'
@@ -1048,27 +1050,27 @@ class TestInterface < CiscoTestCase
     interface_ipv4_config(ifname, address, length, false, false)
   end
 
-  def test_interface_ipv4_arp_timeout
+  def test_ipv4_arp_timeout
     unless platform == :ios_xr
       # Setup
       config_no_warn('no interface vlan11')
-      int = Interface.new('vlan11')
+      svi = Interface.new('vlan11')
 
       # Test default
-      assert_equal(int.default_ipv4_arp_timeout, int.ipv4_arp_timeout)
+      assert_equal(svi.default_ipv4_arp_timeout, svi.ipv4_arp_timeout)
       # Test non-default
-      int.ipv4_arp_timeout = 300
-      assert_equal(300, int.ipv4_arp_timeout)
+      svi.ipv4_arp_timeout = 300
+      assert_equal(300, svi.ipv4_arp_timeout)
       # Set back to default
-      int.ipv4_arp_timeout = int.default_ipv4_arp_timeout
-      assert_equal(int.default_ipv4_arp_timeout, int.ipv4_arp_timeout)
+      svi.ipv4_arp_timeout = svi.default_ipv4_arp_timeout
+      assert_equal(svi.default_ipv4_arp_timeout, svi.ipv4_arp_timeout)
     end
     # Attempt to configure on a non-vlan interface
-    nonvlanint = create_interface
-    assert_raises(RuntimeError) { nonvlanint.ipv4_arp_timeout = 300 }
+    nonsvi = create_interface
+    assert_raises(RuntimeError) { nonsvi.ipv4_arp_timeout = 300 }
   end
 
-  def test_interface_ipv4_forwarding
+  def test_ipv4_forwarding
     intf = interfaces[0]
     i = Interface.new(intf)
 
@@ -1099,7 +1101,7 @@ class TestInterface < CiscoTestCase
     assert_equal(i.default_ipv4_forwarding, i.ipv4_forwarding)
   end
 
-  def test_interface_fabric_forwarding_anycast_gateway
+  def test_ff_anycast_gateway_mac
     # Ensure N7k has compatible interface
     mt_full_interface? if node.product_id[/N7/]
 
@@ -1154,7 +1156,7 @@ class TestInterface < CiscoTestCase
     end
   end
 
-  def test_interface_ipv4_proxy_arp
+  def test_ipv4_proxy_arp
     interface = create_interface
     interface.switchport_mode = :disabled if platform == :nexus
 
@@ -1191,7 +1193,7 @@ class TestInterface < CiscoTestCase
                  'Error: ip proxy-arp default get value mismatch')
   end
 
-  def test_interface_ipv4_redirects
+  def test_ipv4_redirects
     interface = create_interface
     interface.switchport_mode = :disabled if platform == :nexus
 
@@ -1338,7 +1340,7 @@ class TestInterface < CiscoTestCase
 
   # NOTE - Changes to this method may require new validation methods
   #        to be created or existing ones to be modified.
-  def test_interface_ipv4_all_interfaces
+  def test_ipv4_all_interfaces
     inttype_h = interface_test_data
 
     # Set system defaults to "factory" values prior to initial test.
@@ -1391,7 +1393,7 @@ class TestInterface < CiscoTestCase
     end
   end
 
-  def test_interface_vrf_default
+  def test_vrf_default
     interface = Interface.new('loopback1')
     assert_empty(interface.vrf)
     interface.vrf = 'foo'
@@ -1400,18 +1402,18 @@ class TestInterface < CiscoTestCase
     assert_equal(interface.vrf, interface.default_vrf)
   end
 
-  def test_interface_vrf_invalid_type
+  def test_vrf_invalid_type
     interface = Interface.new('loopback1')
     assert_raises(TypeError) { interface.vrf = 1 }
   end
 
-  def test_interface_vrf_exceeds_max_length
+  def test_vrf_exceeds_max_length
     interface = Interface.new('loopback1')
     long_string = 'a' * (IF_VRF_MAX_LENGTH + 1)
     assert_raises(Cisco::CliError) { interface.vrf = long_string }
   end
 
-  def test_interface_vrf_override
+  def test_vrf_override
     interface = Interface.new('loopback1')
     vrf1 = 'test1'
     vrf2 = 'test2'
@@ -1421,7 +1423,7 @@ class TestInterface < CiscoTestCase
     interface.destroy
   end
 
-  def test_interface_vrf_valid
+  def test_vrf_valid
     interface = Interface.new('loopback1')
     vrf = 'test'
     interface.vrf = vrf
@@ -1491,4 +1493,227 @@ class TestInterface < CiscoTestCase
     i.ipv4_pim_sparse_mode = i.default_ipv4_pim_sparse_mode
     assert_equal(i.default_ipv4_pim_sparse_mode, i.ipv4_pim_sparse_mode)
   end
+
+  def test_storm_control_broadcast
+    interface = Interface.new(interfaces[0])
+    interface.switchport_enable(true)
+    if validate_property_excluded?('interface', 'storm_control_broadcast')
+      assert_nil(interface.storm_control_broadcast)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.storm_control_broadcast = '20.12'
+      end
+      return
+    end
+    assert_equal(interface.default_storm_control_broadcast,
+                 interface.storm_control_broadcast)
+    interface.storm_control_broadcast = '20.12'
+    assert_equal('20.12', interface.storm_control_broadcast)
+    interface.storm_control_broadcast =
+      interface.default_storm_control_broadcast
+    assert_equal(interface.default_storm_control_broadcast,
+                 interface.storm_control_broadcast)
+  end
+
+  def test_storm_control_multicast
+    interface = Interface.new(interfaces[0])
+    interface.switchport_enable(true)
+    if validate_property_excluded?('interface', 'storm_control_multicast')
+      assert_nil(interface.storm_control_multicast)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.storm_control_multicast = '33.33'
+      end
+      return
+    end
+    assert_equal(interface.default_storm_control_multicast,
+                 interface.storm_control_multicast)
+    interface.storm_control_multicast = '33.33'
+    assert_equal('33.33', interface.storm_control_multicast)
+    interface.storm_control_multicast =
+      interface.default_storm_control_multicast
+    assert_equal(interface.default_storm_control_multicast,
+                 interface.storm_control_multicast)
+  end
+
+  def test_storm_control_unicast
+    interface = Interface.new(interfaces[0])
+    interface.switchport_enable(true)
+    if validate_property_excluded?('interface', 'storm_control_unicast')
+      assert_nil(interface.storm_control_unicast)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.storm_control_unicast = '44.44'
+      end
+      return
+    end
+    assert_equal(interface.default_storm_control_unicast,
+                 interface.storm_control_unicast)
+    interface.storm_control_unicast = '44.44'
+    assert_equal('44.44', interface.storm_control_unicast)
+    interface.storm_control_unicast =
+      interface.default_storm_control_unicast
+    assert_equal(interface.default_storm_control_unicast,
+                 interface.storm_control_unicast)
+  end
+
+  def test_ipv4_dhcp_relay_addr
+    interface = Interface.new(interfaces[0])
+    interface.switchport_enable(false)
+    list = ['1.1.1.1', '2.2.2.2']
+    if validate_property_excluded?('interface', 'ipv4_dhcp_relay_addr')
+      assert_nil(interface.ipv4_dhcp_relay_addr)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.ipv4_dhcp_relay_addr = list
+      end
+      return
+    end
+    assert_equal(interface.default_ipv4_dhcp_relay_addr,
+                 interface.ipv4_dhcp_relay_addr)
+    interface.ipv4_dhcp_relay_addr = list
+    assert_equal(list, interface.ipv4_dhcp_relay_addr)
+    interface.ipv4_dhcp_relay_addr =
+      interface.default_ipv4_dhcp_relay_addr
+    assert_equal(interface.default_ipv4_dhcp_relay_addr,
+                 interface.ipv4_dhcp_relay_addr)
+  end
+
+  def test_ipv4_dhcp_relay_info_trust
+    interface = Interface.new(interfaces[0])
+    interface.switchport_enable(false)
+    if validate_property_excluded?('interface', 'ipv4_dhcp_relay_info_trust')
+      assert_nil(interface.ipv4_dhcp_relay_info_trust)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.ipv4_dhcp_relay_info_trust = true
+      end
+      return
+    end
+    assert_equal(interface.default_ipv4_dhcp_relay_info_trust,
+                 interface.ipv4_dhcp_relay_info_trust)
+    interface.ipv4_dhcp_relay_info_trust = true
+    assert_equal(true, interface.ipv4_dhcp_relay_info_trust)
+    interface.ipv4_dhcp_relay_info_trust =
+      interface.default_ipv4_dhcp_relay_info_trust
+    assert_equal(interface.default_ipv4_dhcp_relay_info_trust,
+                 interface.ipv4_dhcp_relay_info_trust)
+  end
+
+  def test_ipv4_dhcp_relay_src_addr_hsrp
+    interface = Interface.new(interfaces[0])
+    interface.switchport_enable(false)
+    if validate_property_excluded?('interface', 'ipv4_dhcp_relay_src_addr_hsrp')
+      assert_nil(interface.ipv4_dhcp_relay_src_addr_hsrp)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.ipv4_dhcp_relay_src_addr_hsrp = true
+      end
+      return
+    end
+    assert_equal(interface.default_ipv4_dhcp_relay_src_addr_hsrp,
+                 interface.ipv4_dhcp_relay_src_addr_hsrp)
+    interface.ipv4_dhcp_relay_src_addr_hsrp = true
+    assert_equal(true, interface.ipv4_dhcp_relay_src_addr_hsrp)
+    interface.ipv4_dhcp_relay_src_addr_hsrp =
+      interface.default_ipv4_dhcp_relay_src_addr_hsrp
+    assert_equal(interface.default_ipv4_dhcp_relay_src_addr_hsrp,
+                 interface.ipv4_dhcp_relay_src_addr_hsrp)
+  end
+
+  def test_ipv4_dhcp_relay_src_intf
+    interface = Interface.new(interfaces[0])
+    interface.switchport_enable(false)
+    if validate_property_excluded?('interface', 'ipv4_dhcp_relay_src_intf')
+      assert_nil(interface.ipv4_dhcp_relay_src_intf)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.ipv4_dhcp_relay_src_intf = 'port-channel200'
+      end
+      return
+    end
+    assert_equal(interface.default_ipv4_dhcp_relay_src_intf,
+                 interface.ipv4_dhcp_relay_src_intf)
+    interface.ipv4_dhcp_relay_src_intf = 'port-channel200'
+    assert_equal('port-channel200', interface.ipv4_dhcp_relay_src_intf)
+    interface.ipv4_dhcp_relay_src_intf =
+      interface.default_ipv4_dhcp_relay_src_intf
+    assert_equal(interface.default_ipv4_dhcp_relay_src_intf,
+                 interface.ipv4_dhcp_relay_src_intf)
+  end
+
+  def test_ipv4_dhcp_relay_subnet_broadcast
+    interface = Interface.new(interfaces[0])
+    interface.switchport_enable(false)
+    if validate_property_excluded?('interface', 'ipv4_dhcp_relay_subnet_broadcast')
+      assert_nil(interface.ipv4_dhcp_relay_subnet_broadcast)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.ipv4_dhcp_relay_subnet_broadcast = true
+      end
+      return
+    end
+    assert_equal(interface.default_ipv4_dhcp_relay_subnet_broadcast,
+                 interface.ipv4_dhcp_relay_subnet_broadcast)
+    interface.ipv4_dhcp_relay_subnet_broadcast = true
+    assert_equal(true, interface.ipv4_dhcp_relay_subnet_broadcast)
+    interface.ipv4_dhcp_relay_subnet_broadcast =
+      interface.default_ipv4_dhcp_relay_subnet_broadcast
+    assert_equal(interface.default_ipv4_dhcp_relay_subnet_broadcast,
+                 interface.ipv4_dhcp_relay_subnet_broadcast)
+  end
+
+  def test_ipv4_dhcp_smart_relay
+    interface = Interface.new(interfaces[0])
+    interface.switchport_enable(false)
+    if validate_property_excluded?('interface', 'ipv4_dhcp_smart_relay')
+      assert_nil(interface.ipv4_dhcp_smart_relay)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.ipv4_dhcp_smart_relay = true
+      end
+      return
+    end
+    assert_equal(interface.default_ipv4_dhcp_smart_relay,
+                 interface.ipv4_dhcp_smart_relay)
+    interface.ipv4_dhcp_smart_relay = true
+    assert_equal(true, interface.ipv4_dhcp_smart_relay)
+    interface.ipv4_dhcp_smart_relay =
+      interface.default_ipv4_dhcp_smart_relay
+    assert_equal(interface.default_ipv4_dhcp_smart_relay,
+                 interface.ipv4_dhcp_smart_relay)
+  end
+
+  def test_ipv6_dhcp_relay_addr
+    interface = Interface.new(interfaces[0])
+    interface.switchport_enable(false)
+    list = ['2000::11', '2000::12']
+    if validate_property_excluded?('interface', 'ipv6_dhcp_relay_addr')
+      assert_nil(interface.ipv6_dhcp_relay_addr)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.ipv6_dhcp_relay_addr = list
+      end
+      return
+    end
+    assert_equal(interface.default_ipv6_dhcp_relay_addr,
+                 interface.ipv6_dhcp_relay_addr)
+    interface.ipv6_dhcp_relay_addr = list
+    assert_equal(list, interface.ipv6_dhcp_relay_addr)
+    interface.ipv6_dhcp_relay_addr =
+      interface.default_ipv6_dhcp_relay_addr
+    assert_equal(interface.default_ipv6_dhcp_relay_addr,
+                 interface.ipv6_dhcp_relay_addr)
+  end
+
+  def test_ipv6_dhcp_relay_src_intf
+    inf_name = interfaces[0]
+    interface = Interface.new(inf_name)
+    interface.switchport_enable(false)
+    if validate_property_excluded?('interface', 'ipv6_dhcp_relay_src_intf')
+      assert_nil(interface.ipv6_dhcp_relay_src_intf)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.ipv6_dhcp_relay_src_intf = inf_name
+      end
+      return
+    end
+    assert_equal(interface.default_ipv6_dhcp_relay_src_intf,
+                 interface.ipv6_dhcp_relay_src_intf)
+    interface.ipv6_dhcp_relay_src_intf = inf_name
+    assert_equal(inf_name, interface.ipv6_dhcp_relay_src_intf)
+    interface.ipv6_dhcp_relay_src_intf =
+      interface.default_ipv6_dhcp_relay_src_intf
+    assert_equal(interface.default_ipv6_dhcp_relay_src_intf,
+                 interface.ipv6_dhcp_relay_src_intf)
+  end
 end