cisco_node_utils 1.2.0 → 1.3.0

data/tests/test_dns_domain.rb

@@ -20,23 +20,33 @@ require_relative '../lib/cisco_node_utils/dns_domain'
 
 # TestDnsDomain - Minitest for DnsDomain node utility.
 class TestDnsDomain < CiscoTestCase
+  @skip_unless_supported = 'dnsclient'
+
   def setup
     # setup runs at the beginning of each test
     super
+    @backup_resolve = backup_resolv_file
     no_dnsdomain_tests
   end
 
   def teardown
     # teardown runs at the end of each test
     no_dnsdomain_tests
+    restore_resolv_file(@backup_resolve)
     super
   end
 
   def no_dnsdomain_tests
     # Turn the feature off for a clean test.
-    config('no ip domain-list aoeu.com',
-           'no ip domain-list asdf.com',
-           'no vrf context test')
+    if platform == :ios_xr
+      config('no domain list aoeu.com',
+             'no domain list asdf.com',
+             'no vrf test')
+    else
+      config('no ip domain-list aoeu.com',
+             'no ip domain-list asdf.com',
+             'no vrf context test')
+    end
   end
 
   # TESTS

data/tests/test_domain_name.rb

@@ -20,23 +20,33 @@ require_relative '../lib/cisco_node_utils/domain_name'
 
 # TestDomainName - Minitest for DomainName node utility.
 class TestDomainName < CiscoTestCase
+  @skip_unless_supported = 'dnsclient'
+
   def setup
     # setup runs at the beginning of each test
     super
+    @backup_resolve = backup_resolv_file
     no_domainname_test_xyz
   end
 
   def teardown
     # teardown runs at the end of each test
     no_domainname_test_xyz
+    restore_resolv_file(@backup_resolve)
     super
   end
 
   def no_domainname_test_xyz
     # Turn the feature off for a clean test.
-    config('no ip domain-name test.abc',
-           'no ip domain-name test.xyz',
-           'no vrf context test')
+    if platform == :ios_xr
+      config('no domain name test.abc',
+             'no domain name test.xyz',
+             'no vrf test')
+    else
+      config('no ip domain-name test.abc',
+             'no ip domain-name test.xyz',
+             'no vrf context test')
+    end
   end
 
   # TESTS

data/tests/test_encapsulation.rb

@@ -0,0 +1,77 @@
+# Copyright (c) 2014-2016 Cisco and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative 'ciscotest'
+require_relative '../lib/cisco_node_utils/encapsulation'
+require_relative '../lib/cisco_node_utils/vdc'
+
+# TestEncapsulation - Minitest for Encapsulation node utility class
+class TestEncapsulation < CiscoTestCase
+  @skip_unless_supported = 'encapsulation'
+  @@pre_clean_needed = true # rubocop:disable Style/ClassVars
+
+  def setup
+    super
+    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
+    cleanup
+    super
+  end
+
+  def cleanup
+    config_no_warn('no feature vni')
+    Encapsulation.encaps.each do |_encap, obj|
+      obj.destroy
+    end
+  end
+
+  # TESTS
+
+  def test_create_destroy
+    profile = 'cisco'
+    e = Encapsulation.new(profile)
+    assert(Encapsulation.encaps[profile], "profile '#{profile}' not found")
+    e.destroy
+  end
+
+  def test_dot1q_map
+    e = Encapsulation.new('cisco')
+    assert_equal(e.default_dot1q_map, e.dot1q_map)
+
+    map = ['100-110,150', '5000-5010,5050']
+    e.dot1q_map = map
+    assert_equal(map, e.dot1q_map)
+
+    e.dot1q_map = e.default_dot1q_map
+    assert_equal(e.default_dot1q_map, e.dot1q_map)
+
+    e.destroy
+  end
+
+  def test_dot1q_map_negative
+    e = Encapsulation.new('cisco')
+    assert_raises(CliError) do
+      # Test for range imbalance (3 vlans to only 2 vnis)
+      e.dot1q_map = ['101-103', '5101-5102']
+    end
+  end
+end

data/tests/test_evpn_vni.rb

@@ -21,13 +21,23 @@ require_relative '../lib/cisco_node_utils/evpn_vni'
 
 # TestEvpnVni - Minitest for EvpnVni class
 class TestEvpnVni < CiscoTestCase
+  @skip_unless_supported = 'evpn_vni'
+
   def setup
     # Disable feature bgp and no overlay evpn before each test to
     # ensure we are starting with a clean slate for each test.
     super
     config('no feature bgp')
-    config('no nv overlay evpn')
-    config('no evpn')
+
+    # Some platforms complain when nv overlay is not configured
+    config_no_warn('no nv overlay evpn')
+
+    # Some platforms remove the 'evpn' command when 'no nv overlay evpn'
+    # is processed, while others must remove it explicitly.
+    config_no_warn('no evpn')
+
+  rescue RuntimeError => e
+    hardware_supports_feature?(e.message)
   end
 
   def test_create_and_destroy
@@ -38,11 +48,9 @@ class TestEvpnVni < CiscoTestCase
     vni.destroy
     vni_list = EvpnVni.vnis
     refute(vni_list.key?('4096'), 'Error: failed to destroy evpn vni 4096')
-  end
 
-  def test_vni_collection
-    vni_list = EvpnVni.vnis
-    assert_equal(true, vni_list.empty?, 'VLAN collection is empty')
+  rescue RuntimeError => e
+    hardware_supports_feature?(e.message)
   end
 
   def test_route_distinguisher
@@ -57,6 +65,9 @@ class TestEvpnVni < CiscoTestCase
     assert_empty(vni.route_distinguisher,
                  'vni route_distinguisher should *NOT* be configured')
     vni.destroy
+
+  rescue RuntimeError => e
+    hardware_supports_feature?(e.message)
   end
 
   # test route_target
@@ -64,7 +75,11 @@ class TestEvpnVni < CiscoTestCase
     vni = EvpnVni.new(4096)
 
     # test route target both auto and route target both auto evpn
-    opts = [:both, :import, :export]
+    if Utils.nexus_i2_image
+      opts = [:import, :export]
+    else
+      opts = [:both, :import, :export]
+    end
 
     # Master list of communities to test against
     master = ['1.2.3.4:55', '2:2', '55:33', 'auto']
@@ -86,6 +101,9 @@ class TestEvpnVni < CiscoTestCase
     route_target_tester(vni, opts, should, 'Test 4')
 
     vni .destroy
+
+  rescue RuntimeError => e
+    hardware_supports_feature?(e.message)
   end
 
   def route_target_tester(vni, opts, should, test_id)

data/tests/test_fabricpath_global.rb

@@ -15,16 +15,19 @@
 require_relative 'ciscotest'
 require_relative '../lib/cisco_node_utils/cisco_cmn_utils'
 require_relative '../lib/cisco_node_utils/fabricpath_global'
+require_relative '../lib/cisco_node_utils/interface'
+require_relative '../lib/cisco_node_utils/platform'
 
 include Cisco
 
 # TestFabricpathGlobal - Minitest for Fabricpath Global node utils
 class TestFabricpathGlobal < CiscoTestCase
+  @skip_unless_supported = 'fabricpath'
+
   def setup
     # setup runs at the beginning of each test
     super
-    skip("Test not supported on #{node.product_id}") if
-      cmd_ref.lookup('fabricpath', 'feature').default_value.nil?
+    fabricpath_testenv_setup
     no_feature_fabricpath
   end
 
@@ -35,209 +38,210 @@ class TestFabricpathGlobal < CiscoTestCase
   end
 
   def no_feature_fabricpath
-    # Turn the feature off for a clean test.
-    config('no feature-set fabricpath')
+    fg = FabricpathGlobal.globals
+    fg.each { |_key, elem| elem.destroy } unless fg.empty?
   end
 
-  def n5k6k_platforms?
-    /N[56]K/ =~ node.product_id
-  end
+  #  def no_feature_fabricpath
+  #    # Turn the feature off for a clean test.
+  #    config('no feature-set fabricpath')
+  #  end
 
   # TESTS
 
-  def test_global_collection_empty
-    globals = FabricpathGlobal.globals
-    assert_equal(true, globals.empty?,
-                 'Globals should be empty for this test')
-  end
+  def test_create_destroy
+    assert_empty(FabricpathGlobal.globals)
 
-  def test_global_create
-    @global = FabricpathGlobal.new('default')
-    assert_equal(true, @global.name == 'default',
-                 "Global name not set correctly #{@global.name}")
-    assert_equal(:enabled, FabricpathGlobal.fabricpath_feature,
-                 'Fabricpath feature should have been enabled')
-    refute(FabricpathGlobal.globals.empty?,
-           'Globals should not be empty after create')
-  end
+    # create
+    fg = FabricpathGlobal.new('default')
+    assert_equal('default', fg.name)
+    assert_equal(:enabled, FabricpathGlobal.fabricpath_feature)
+    refute_empty(FabricpathGlobal.globals)
 
-  def test_global_destroy
-    # create and test again
-    test_global_create
-    @global.destroy
-    # now it should be wiped out
-    test_global_collection_empty
+    # destroy
+    fg.destroy
+    assert_empty(FabricpathGlobal.globals)
   end
 
   def test_aggregate_multicast_routes
-    return if n5k6k_platforms?
-    @global = FabricpathGlobal.new('default')
-    @global.aggregate_multicast_routes = true
-    assert(@global.aggregate_multicast_routes,
-           'Aggregate multicast routes not set')
-    @global.aggregate_multicast_routes = false
-    refute(@global.aggregate_multicast_routes,
-           'Aggregate multicast routes not reset')
+    fg = FabricpathGlobal.new('default')
+    if validate_property_excluded?('fabricpath', 'aggregate_multicast_routes')
+      assert_raises(Cisco::UnsupportedError) do
+        fg.aggregate_multicast_routes = true
+      end
+      return
+    end
+
+    fg = FabricpathGlobal.new('default')
+    fg.aggregate_multicast_routes = true
+    assert(fg.aggregate_multicast_routes,
+           'aggregate_multicast_routes: Expected: true')
+
+    fg.aggregate_multicast_routes = false
+    refute(fg.aggregate_multicast_routes,
+           'aggregate_multicast_routes: Expected: false')
   end
 
   def test_allocate_delay
-    @global = FabricpathGlobal.new('default')
-    # test default value
-    assert_equal(@global.default_allocate_delay,
-                 @global.allocate_delay,
-                 'Default allocate_delay not set correctly')
-    @global.allocate_delay = 20
-    assert_equal(20, @global.allocate_delay,
-                 'allocate_delay not set to 20')
+    fg = FabricpathGlobal.new('default')
+    assert_equal(fg.default_allocate_delay, fg.allocate_delay)
+
+    fg.allocate_delay = 20
+    assert_equal(20, fg.allocate_delay)
   end
 
   def test_graceful_merge
-    @global = FabricpathGlobal.new('default')
-    # test default value
-    assert_equal(:enable, @global.graceful_merge,
-                 'Default graceful_merge not set correctly')
-    @global.graceful_merge = :disable
-    assert_equal(:disable, @global.graceful_merge,
-                 'graceful merge not set to disable')
+    fg = FabricpathGlobal.new('default')
+    assert_equal(fg.default_graceful_merge, fg.graceful_merge)
+
+    fg.graceful_merge = :disable
+    assert_equal(:disable, fg.graceful_merge)
   end
 
   def test_linkup_delay_all
-    @global = FabricpathGlobal.new('default')
-    # test default value
-    assert_equal(@global.default_linkup_delay,
-                 @global.linkup_delay,
-                 'Default linkup_delay not set correctly')
-    @global.linkup_delay = 25
-    assert_equal(25, @global.linkup_delay,
-                 'linkup_delay not set to 25')
-
-    return if n5k6k_platforms?
-
-    refute(@global.linkup_delay_always,
-           'linkup_delay_always should not be set by default')
-    @global.linkup_delay_always = true
-    assert(@global.linkup_delay_always,
-           'linkup_delay_always is not getting set')
-
-    @global.linkup_delay_enable = true
-    @global.linkup_delay_enable = false
-    refute(@global.linkup_delay_enable,
-           'linkup_delay is not getting disabled')
+    fg = FabricpathGlobal.new('default')
+    assert_equal(fg.default_linkup_delay, fg.linkup_delay)
+
+    fg.linkup_delay = 25
+    assert_equal(25, fg.linkup_delay)
+
+    if validate_property_excluded?('fabricpath', 'linkup_delay_always')
+      assert_raises(Cisco::UnsupportedError) { fg.linkup_delay_always = true }
+    else
+      assert_equal(fg.default_linkup_delay_always, fg.linkup_delay_always)
+      fg.linkup_delay_always = true
+      assert(fg.linkup_delay_always, 'linkup_delay_always: Expected: true')
+      fg.linkup_delay_always = false
+      refute(fg.linkup_delay_always, 'linkup_delay_always: Expected: false')
+    end
+
+    if validate_property_excluded?('fabricpath', 'linkup_delay_enable')
+      assert_raises(Cisco::UnsupportedError) { fg.linkup_delay_enable = true }
+      return
+    end
+
+    assert_equal(fg.default_linkup_delay_enable, fg.linkup_delay_enable)
+    fg.linkup_delay_enable = true
+    assert(fg.linkup_delay_enable, 'linkup_delay_enable: Expected: true')
+    fg.linkup_delay_enable = false
+    refute(fg.linkup_delay_enable, 'linkup_delay_enable: Expected: false')
   end
 
   def test_loadbalance_algorithm
-    @global = FabricpathGlobal.new('default')
-    # test default value
-    check_val = n5k6k_platforms? ? 'source-destination' : 'symmetric'
-    assert_equal(check_val, @global.loadbalance_algorithm,
-                 "default algo should be #{check_val} but is
-                  #{@global.loadbalance_algorithm}")
-    @global.loadbalance_algorithm = 'source'
-    assert_equal('source', @global.loadbalance_algorithm,
-                 'algo not getting set to source-destination')
+    fg = FabricpathGlobal.new('default')
+    assert_equal(fg.default_loadbalance_algorithm, fg.loadbalance_algorithm)
+
+    fg.loadbalance_algorithm = 'source'
+    assert_equal('source', fg.loadbalance_algorithm)
+    if validate_property_excluded?('fabricpath',
+                                   'loadbalance_algorithm_symmetric_support')
+      assert_nil(fg.loadbalance_algorithm_symmetric_support)
+      return
+    end
+    fg.loadbalance_algorithm = 'symmetric'
+    assert_equal('symmetric', fg.loadbalance_algorithm)
   end
 
   def test_loadbalance_multicast
-    return if n5k6k_platforms?
-    @global = FabricpathGlobal.new('default')
-    # test default values first
-    assert_equal(@global.default_loadbalance_multicast_rotate,
-                 @global.loadbalance_multicast_rotate,
-                 "default mcast rotate should be 6
-                  but is #{@global.loadbalance_multicast_rotate}")
-    assert(@global.loadbalance_multicast_has_vlan,
-           "default mcast include-vlan should be true
-           but is #{@global.loadbalance_multicast_has_vlan}")
-    @global.send(:loadbalance_multicast=, 3, false)
-    assert_equal(3, @global.loadbalance_multicast_rotate,
-                 "mcast rotate should now be 3
-                  but is #{@global.loadbalance_multicast_rotate}")
-    refute(@global.loadbalance_multicast_has_vlan,
-           "mcast include-vlan should now be false
-           but is #{@global.loadbalance_multicast_has_vlan}")
+    # loadbalance_multicast= is a custom setter that takes 2 args:
+    #   rotate, has_vlan
+    fg = FabricpathGlobal.new('default')
+    if validate_property_excluded?('fabricpath',
+                                   'loadbalance_multicast_set')
+      assert_raises(Cisco::UnsupportedError) do
+        (fg.send(:loadbalance_multicast=, 0, 0))
+      end
+      return
+    end
+
+    # default_loadbalance_multicast_rotate: n/a
+    assert(fg.loadbalance_multicast_has_vlan,
+           'loadbalance_multicast_has_vlan: Expected: true')
+
+    fg.send(:loadbalance_multicast=, 3, false)
+    assert_equal(3, fg.loadbalance_multicast_rotate)
+    refute(fg.loadbalance_multicast_has_vlan,
+           'loadbalance_multicast_has_vlan: Expected: false')
   end
 
   def test_loadbalance_unicast
-    @global = FabricpathGlobal.new('default')
-    # test default values first
-    assert_equal(@global.default_loadbalance_unicast_layer,
-                 @global.loadbalance_unicast_layer,
-                 "default unicast layer should be mixed
-                  but is #{@global.loadbalance_unicast_layer}")
-    assert_equal(@global.default_loadbalance_unicast_rotate,
-                 @global.loadbalance_unicast_rotate,
-                 "default unicast rotate not set correctly
-                  but is set to #{@global.loadbalance_unicast_rotate}") unless
-                 n5k6k_platforms?
-    assert(@global.loadbalance_unicast_has_vlan,
-           "default unicast include-vlan should be true
-           but is #{@global.loadbalance_unicast_has_vlan}")
-    @global.send(:loadbalance_unicast=, 'layer4', 3, false)
-    assert_equal('layer4', @global.loadbalance_unicast_layer,
-                 "unicast layer should be layer4
-                  but is #{@global.loadbalance_unicast_layer}")
-    assert_equal(3, @global.loadbalance_unicast_rotate,
-                 "unicast rotate should now be 3
-                  but is #{@global.loadbalance_unicast_rotate}") unless
-                 n5k6k_platforms?
-    refute(@global.loadbalance_unicast_has_vlan,
-           "unicast include-vlan should now be false
-           but is #{@global.loadbalance_unicast_has_vlan}")
+    # loadbalance_unicast= is a custom setter that takes up to 3 args:
+    #   layer, rotate, has_vlan (rotate is not supported on some plats)
+
+    fg = FabricpathGlobal.new('default')
+    assert_equal(fg.default_loadbalance_unicast_layer,
+                 fg.loadbalance_unicast_layer)
+
+    # default_loadbalance_unicast_rotate: n/a
+    assert_equal(fg.default_loadbalance_unicast_has_vlan,
+                 fg.loadbalance_unicast_has_vlan)
+
+    fg.send(:loadbalance_unicast=, 'layer4', 3, false)
+    assert_equal('layer4', fg.loadbalance_unicast_layer)
+    unless validate_property_excluded?('fabricpath',
+                                       'loadbalance_unicast_rotate')
+      assert_equal(3, fg.loadbalance_unicast_rotate)
+    end
+    refute(fg.loadbalance_unicast_has_vlan,
+           'loadbalance_unicast_has_vlan: Expected: false')
   end
 
   def test_mode
-    @global = FabricpathGlobal.new('default')
-    # test default value
-    assert_equal(@global.default_mode, @global.mode,
-                 "default mode should be normal but is #{@global.mode}")
-    @global.mode = 'transit'
-    assert_equal('transit', @global.mode,
-                 'mode not getting set to transit')
-    @global.mode = 'normal'
-    assert_equal('normal', @global.mode,
-                 'mode not getting set to transit')
+    fg = FabricpathGlobal.new('default')
+    assert_equal(fg.default_mode, fg.mode)
+
+    fg.mode = 'transit'
+    assert_equal('transit', fg.mode)
+    fg.mode = 'normal'
+    assert_equal('normal', fg.mode)
   end
 
   def test_switch_id
-    @global = FabricpathGlobal.new('default')
-    # auto_id = @global.switch_id
-    @global.switch_id = 100
-    assert_equal(100, @global.switch_id,
-                 'switchid not getting set to 100')
+    fg = FabricpathGlobal.new('default')
+    # auto_id = fg.switch_id
+    # switch_id does not have a default
+    fg.switch_id = 100
+    assert_equal(100, fg.switch_id)
   end
 
   def test_transition_delay
-    @global = FabricpathGlobal.new('default')
-    # test default value
-    assert_equal(@global.default_transition_delay,
-                 @global.transition_delay,
-                 'Default allocate_delay not set correctly')
-    @global.transition_delay = 20
-    assert_equal(20, @global.transition_delay,
-                 'transition_delay not set to 20')
+    fg = FabricpathGlobal.new('default')
+    assert_equal(fg.default_transition_delay, fg.transition_delay)
+
+    fg.transition_delay = 20
+    assert_equal(20, fg.transition_delay)
   end
 
   def test_ttl_multicast
-    return if n5k6k_platforms?
-    @global = FabricpathGlobal.new('default')
-    # test default value
-    assert_equal(@global.default_ttl_multicast,
-                 @global.ttl_multicast,
-                 'Default multicast ttl not set correctly')
-    @global.ttl_multicast = 16
-    assert_equal(16, @global.ttl_multicast,
-                 'multicast ttl not getting set to 16')
+    fg = FabricpathGlobal.new('default')
+    if validate_property_excluded?('fabricpath', 'ttl_multicast')
+      assert_raises(Cisco::UnsupportedError) { fg.ttl_multicast = 40 }
+      return
+    end
+
+    assert_equal(fg.default_ttl_multicast, fg.ttl_multicast)
+    fg.ttl_multicast = 16
+    assert_equal(16, fg.ttl_multicast)
   end
 
   def test_ttl_unicast
-    return if n5k6k_platforms?
-    @global = FabricpathGlobal.new('default')
-    # test default value
-    assert_equal(@global.default_ttl_unicast,
-                 @global.ttl_unicast,
-                 'Default unicast ttl not set correctly')
-    @global.ttl_unicast = 40
-    assert_equal(40, @global.ttl_unicast,
-                 'unicast ttl not getting set to 40')
+    fg = FabricpathGlobal.new('default')
+    if validate_property_excluded?('fabricpath', 'ttl_unicast')
+      assert_raises(Cisco::UnsupportedError) { fg.ttl_unicast = 40 }
+      return
+    end
+    assert_equal(fg.default_ttl_unicast, fg.ttl_unicast)
+    fg.ttl_unicast = 40
+    assert_equal(40, fg.ttl_unicast)
+  end
+
+  def test_interface_switchport_mode
+    i = Interface.new(interfaces[0])
+    i.switchport_mode = :fabricpath
+    assert_equal(:fabricpath, i.switchport_mode)
+
+    i.switchport_mode = :trunk
+    assert_equal(:trunk, i.switchport_mode)
+    config("default interface #{interfaces[0]}")
   end
 end