cisco_node_utils 1.1.0 → 1.2.0

data/tests/test_vrf.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2015 Cisco and/or its affiliates.
+# Copyright (c) 2015-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.
@@ -14,29 +14,34 @@
 
 require_relative 'ciscotest'
 require_relative '../lib/cisco_node_utils/vrf'
+require_relative '../lib/cisco_node_utils/vrf_af'
+require_relative '../lib/cisco_node_utils/vni'
 
 include Cisco
 
 # TestVrf - Minitest for Vrf node utility class
 class TestVrf < CiscoTestCase
   VRF_NAME_SIZE = 33
+  @@pre_clean_needed = true # rubocop:disable Style/ClassVars
 
   def setup
     super
-    vrfs = Vrf.vrfs
-    vrfs.each_value do |vrf|
-      next unless vrf.name =~ /^test_vrf/
-      config("no vrf context #{vrf.name}")
-    end
+    remove_all_vrfs if @@pre_clean_needed
+    @@pre_clean_needed = false # rubocop:disable Style/ClassVars
+  end
+
+  def teardown
+    super
+    remove_all_vrfs
   end
 
-  def test_vrf_collection_not_empty
+  def test_collection_not_empty
     vrfs = Vrf.vrfs
     refute_empty(vrfs, 'VRF collection is empty')
     assert(vrfs.key?('management'), 'VRF management does not exist')
   end
 
-  def test_vrf_create_and_destroy
+  def test_create_and_destroy
     v = Vrf.new('test_vrf')
     vrfs = Vrf.vrfs
     assert(vrfs.key?('test_vrf'), 'Error: failed to create vrf test_vrf')
@@ -46,19 +51,19 @@ class TestVrf < CiscoTestCase
     refute(vrfs.key?('test_vrf'), 'Error: failed to destroy vrf test_vrf')
   end
 
-  def test_vrf_name_type_invalid
+  def test_name_type_invalid
     assert_raises(TypeError, 'Wrong vrf name type did not raise type error') do
       Vrf.new(1000)
     end
   end
 
-  def test_vrf_name_zero_length
+  def test_name_zero_length
     assert_raises(Cisco::CliError, "Zero length name didn't raise CliError") do
       Vrf.new('')
     end
   end
 
-  def test_vrf_name_too_long
+  def test_name_too_long
     name = 'a' * VRF_NAME_SIZE
     assert_raises(Cisco::CliError,
                   'vrf name misconfig did not raise CliError') do
@@ -66,27 +71,165 @@ class TestVrf < CiscoTestCase
     end
   end
 
-  def test_vrf_shutdown_valid
-    shutdown_states = [true, false]
-    v = Vrf.new('test_vrf_shutdown')
-    shutdown_states.each do |start|
-      shutdown_states.each do |finish|
-        v.shutdown = start
-        assert_equal(start, v.shutdown, 'start')
-        v.shutdown = finish
-        assert_equal(finish, v.shutdown, 'finish')
-      end
-    end
+  def test_shutdown
+    v = Vrf.new('test_shutdown')
+    v.shutdown = true
+    assert(v.shutdown)
+    v.shutdown = false
+    refute(v.shutdown)
+
+    v.shutdown = true
+    assert(v.shutdown)
+    v.shutdown = v.default_shutdown
+    refute(v.shutdown)
+    v.destroy
+  end
+
+  def test_description
+    v = Vrf.new('test_description')
+    desc = 'tested by minitest'
+    v.description = desc
+    assert_equal(desc, v.description)
+
+    desc = v.default_description
+    v.description = desc
+    assert_equal(desc, v.description)
     v.destroy
   end
 
-  def test_vrf_description
-    vrf = Vrf.new('test_vrf_description')
-    vrf.description = 'tested by minitest'
-    assert_equal('tested by minitest', vrf.description,
-                 'failed to set description')
-    vrf.description = ' '
-    assert_empty(vrf.description, 'failed to remove description')
+  def test_vni
+    skip('Platform does not support MT-lite') unless Vni.mt_lite_support
+    vrf = Vrf.new('test_vni')
+    vrf.vni = 4096
+    assert_equal(4096, vrf.vni,
+                 "vrf vni should be set to '4096'")
+    vrf.vni = vrf.default_vni
+    assert_equal(vrf.default_vni, vrf.vni,
+                 'vrf vni should be set to default value')
     vrf.destroy
   end
+
+  def test_route_distinguisher
+    v = Vrf.new('blue')
+    v.route_distinguisher = 'auto'
+    assert_equal('auto', v.route_distinguisher)
+
+    v.route_distinguisher = '1:1'
+    assert_equal('1:1', v.route_distinguisher)
+
+    v.route_distinguisher = '2:3'
+    assert_equal('2:3', v.route_distinguisher)
+
+    v.route_distinguisher = v.default_route_distinguisher
+    assert_empty(v.route_distinguisher,
+                 'v route_distinguisher should *NOT* be configured')
+    v.destroy
+  end
+
+  def test_vrf_af_create_destroy
+    v1 = VrfAF.new('cyan', %w(ipv4 unicast))
+    v2 = VrfAF.new('cyan', %w(ipv6 unicast))
+    v3 = VrfAF.new('red', %w(ipv4 unicast))
+    v4 = VrfAF.new('blue', %w(ipv4 unicast))
+    v5 = VrfAF.new('red', %w(ipv6 unicast))
+    assert_equal(2, VrfAF.afs['cyan'].keys.count)
+    assert_equal(2, VrfAF.afs['red'].keys.count)
+    assert_equal(1, VrfAF.afs['blue'].keys.count)
+
+    v1.destroy
+    v5.destroy
+    assert_equal(1, VrfAF.afs['cyan'].keys.count)
+    assert_equal(1, VrfAF.afs['red'].keys.count)
+    assert_equal(1, VrfAF.afs['blue'].keys.count)
+
+    v2.destroy
+    v3.destroy
+    v4.destroy
+    assert_equal(0, VrfAF.afs['cyan'].keys.count)
+    assert_equal(0, VrfAF.afs['red'].keys.count)
+    assert_equal(0, VrfAF.afs['blue'].keys.count)
+  end
+
+  def test_route_target
+    [%w(ipv4 unicast), %w(ipv6 unicast)].each { |af| route_target(af) }
+  end
+
+  def route_target(af)
+    # Common tester for route-target properties. Tests evpn and non-evpn.
+    #   route_target_both_auto
+    #   route_target_both_auto_evpn
+    #   route_target_export
+    #   route_target_export_evpn
+    #   route_target_import
+    #   route_target_import_evpn
+    vrf = 'red'
+    v = VrfAF.new(vrf, af)
+
+    # test route target both auto and route target both auto evpn
+    refute(v.default_route_target_both_auto,
+           'default value for route target both auto should be false')
+
+    refute(v.default_route_target_both_auto_evpn,
+           'default value for route target both auto evpn should be false')
+
+    v.route_target_both_auto = true
+    assert(v.route_target_both_auto, "vrf context #{vrf} af #{af}: "\
+           'v route-target both auto should be enabled')
+
+    v.route_target_both_auto = false
+    refute(v.route_target_both_auto, "vrf context #{vrf} af #{af}: "\
+           'v route-target both auto should be disabled')
+
+    v.route_target_both_auto_evpn = true
+    assert(v.route_target_both_auto_evpn, "vrf context #{vrf} af #{af}: "\
+           'v route-target both auto evpn should be enabled')
+
+    v.route_target_both_auto_evpn = false
+    refute(v.route_target_both_auto_evpn, "vrf context #{vrf} af #{af}: "\
+           'v route-target both auto evpn should be disabled')
+
+    opts = [:import, :export]
+
+    # Master list of communities to test against
+    master = ['1:1', '2:2', '3:3', '4:5']
+
+    # Test 1: both/import/export when no commands are present. Each target
+    # option will be tested with and without evpn (6 separate types)
+    should = master.clone
+    route_target_tester(v, af, opts, should, 'Test 1')
+
+    # Test 2: remove half of the entries
+    should = ['1:1', '4:4']
+    route_target_tester(v, af, opts, should, 'Test 2')
+
+    # Test 3: restore the removed entries
+    should = master.clone
+    route_target_tester(v, af, opts, should, 'Test 3')
+
+    # Test 4: 'default'
+    should = v.default_route_target_import
+    route_target_tester(v, af, opts, should, 'Test 4')
+  end
+
+  def route_target_tester(v, af, opts, should, test_id)
+    # First configure all four property types
+    opts.each do |opt|
+      # non-evpn
+      v.send("route_target_#{opt}=", should)
+      # evpn
+      v.send("route_target_#{opt}_evpn=", should)
+    end
+
+    # Now check the results
+    opts.each do |opt|
+      # non-evpn
+      result = v.send("route_target_#{opt}")
+      assert_equal(should, result,
+                   "#{test_id} : #{af} : route_target_#{opt}")
+      # evpn
+      result = v.send("route_target_#{opt}_evpn")
+      assert_equal(should, result,
+                   "#{test_id} : #{af} : route_target_#{opt}_evpn")
+    end
+  end
 end

data/tests/test_vtp.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2015 Cisco and/or its affiliates.
+# 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.

data/tests/test_vxlan_vtep.rb

@@ -0,0 +1,214 @@
+# Copyright (c) 2013-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/feature'
+require_relative '../lib/cisco_node_utils/vxlan_vtep'
+require_relative '../lib/cisco_node_utils/vdc'
+
+include Cisco
+
+# TestVxlanGlobal - Minitest for VxlanGlobal node utility
+class TestVxlanVtep < CiscoTestCase
+  def setup
+    super
+    skip('Platform does not support MT-full or MT-lite') unless
+      VxlanVtep.mt_full_support || VxlanVtep.mt_lite_support
+  end
+
+  def teardown
+    return unless Vdc.vdc_support
+    # Reset the vdc module type back to default
+    v = Vdc.new('default')
+    v.limit_resource_module_type = '' if v.limit_resource_module_type == 'f3'
+  end
+
+  def compatible_interface?
+    # MT-full tests require a specific linecard; either because they need a
+    # compatible interface or simply to enable the features. Either way
+    # we will provide an appropriate interface name if the linecard is present.
+    # Example 'show mod' output to match against:
+    #   '9  12  10/40 Gbps Ethernet Module  N7K-F312FQ-25 ok'
+    sh_mod = @device.cmd("sh mod | i '^[0-9]+.*N7K-F3'")[/^(\d+)\s.*N7K-F3/]
+    slot = sh_mod.nil? ? nil : Regexp.last_match[1]
+    skip('Unable to find a compatible interface in chassis') if slot.nil?
+
+    "ethernet#{slot}/1"
+  end
+
+  def mt_full_env_setup
+    skip('Platform does not support MT-full') unless VxlanVtep.mt_full_support
+    compatible_interface?
+    v = Vdc.new('default')
+    v.limit_resource_module_type = 'f3' unless
+      v.limit_resource_module_type == 'f3'
+    config('no feature nv overlay')
+  end
+
+  def mt_lite_env_setup
+    skip('Platform does not support MT-lite') unless VxlanVtep.mt_lite_support
+    config('no feature nv overlay')
+    config('no feature vn-segment-vlan-based')
+  end
+
+  def test_create_destroy_one
+    # VxlanVtep.new() will enable 'feature nv overlay'
+    mt_full_env_setup if VxlanVtep.mt_full_support
+    mt_lite_env_setup if VxlanVtep.mt_lite_support
+
+    id = 'nve1'
+    vtep = VxlanVtep.new(id)
+    @default_show_command = "show running | i 'interface #{id}'"
+
+    assert_show_match(pattern: /^interface #{id}$/,
+                      msg:     "failed to create interface #{id}")
+
+    assert_includes(Cisco::VxlanVtep.vteps, id)
+    assert_equal(Cisco::VxlanVtep.vteps[id], vtep)
+
+    vtep.destroy
+    refute_show_match(pattern: /^interface #{id}$/,
+                      msg:     "failed to destroy interface #{id}")
+  end
+
+  def test_mt_full_create_destroy_multiple
+    if VxlanVtep.mt_full_support
+      mt_full_env_setup
+    else
+      skip('Platform does not support MT-full')
+    end
+
+    id1 = 'nve1'
+    id2 = 'nve2'
+    id3 = 'nve3'
+    id4 = 'nve4'
+    vtep1 = VxlanVtep.new(id1)
+    vtep2 = VxlanVtep.new(id2)
+    vtep3 = VxlanVtep.new(id3)
+    vtep4 = VxlanVtep.new(id4)
+
+    [id1, id2, id3, id4].each do |id|
+      assert_show_match(command: "show running | i 'interface #{id}'",
+                        pattern: /^interface #{id}$/,
+                        msg:     "failed to create interface #{id}")
+      assert_includes(Cisco::VxlanVtep.vteps, id)
+    end
+
+    vtep1.destroy
+    vtep2.destroy
+    vtep3.destroy
+    vtep4.destroy
+
+    [id1, id2, id3, id4].each do |id|
+      refute_show_match(command: "show running | i 'interface #{id}'",
+                        pattern: /^interface #{id}$/,
+                        msg:     "failed to create interface #{id}")
+    end
+  end
+
+  def test_create_negative
+    # MT-lite supports a single nve int, MT-full supports 4.
+    mt_full_env_setup if VxlanVtep.mt_full_support
+    mt_lite_env_setup if VxlanVtep.mt_lite_support
+    if VxlanVtep.mt_lite_support
+      VxlanVtep.new('nve1')
+      negative_id = 'nve2'
+
+    elsif VxlanVtep.mt_full_support
+      mt_full_env_setup
+      (1..4).each { |n| VxlanVtep.new("nve#{n}") }
+      negative_id = 'nve5'
+    end
+
+    assert_raises(CliError) do
+      VxlanVtep.new(negative_id)
+    end
+  end
+
+  def test_description
+    mt_full_env_setup if VxlanVtep.mt_full_support
+    mt_lite_env_setup if VxlanVtep.mt_lite_support
+
+    vtep = VxlanVtep.new('nve1')
+
+    # Set description to non-default value and verify
+    desc = 'vxlan interface'
+    vtep.description = desc
+    assert_equal(desc, vtep.description)
+
+    # Set description to default value and verify
+    desc = vtep.default_description
+    vtep.description = desc
+    assert_equal(desc, vtep.description)
+  end
+
+  def test_host_reachability
+    skip("Test not supported on #{node.product_id}") if
+      cmd_ref.lookup('vxlan_vtep', 'host_reachability').default_value.nil?
+    mt_full_env_setup if VxlanVtep.mt_full_support
+    mt_lite_env_setup if VxlanVtep.mt_lite_support
+
+    vtep = VxlanVtep.new('nve1')
+
+    vtep.host_reachability = 'flood'
+    assert_equal('flood', vtep.host_reachability)
+    vtep.host_reachability = 'evpn'
+    assert_equal('evpn', vtep.host_reachability)
+
+    # Set value back to flood, currently evpn.
+    vtep.host_reachability = 'flood'
+    assert_equal('flood', vtep.host_reachability)
+  end
+
+  def test_shutdown
+    mt_full_env_setup if VxlanVtep.mt_full_support
+    mt_lite_env_setup if VxlanVtep.mt_lite_support
+
+    vtep = VxlanVtep.new('nve1')
+
+    vtep.shutdown = true
+    assert(vtep.shutdown, 'source_interface is not shutdown')
+
+    vtep.shutdown = false
+    refute(vtep.shutdown, 'source_interface is shutdown')
+
+    vtep.shutdown = vtep.default_shutdown
+    assert(vtep.shutdown, 'source_interface is not shutdown')
+  end
+
+  def test_source_interface
+    mt_full_env_setup if VxlanVtep.mt_full_support
+    mt_lite_env_setup if VxlanVtep.mt_lite_support
+
+    vtep = VxlanVtep.new('nve1')
+
+    # Set source_interface to non-default value
+    val = 'loopback55'
+    vtep.source_interface = val
+    assert_equal(val, vtep.source_interface)
+
+    # Change source_interface when nve interface is in a 'no shutdown' state
+    vtep.shutdown = false
+    val = 'loopback77'
+    vtep.source_interface = val
+    assert_equal(val, vtep.source_interface)
+    # source_interface should 'no shutdown' after the change.
+    refute(vtep.shutdown, 'source_interface is shutdown')
+
+    # Set source_interface to default value
+    val = vtep.default_source_interface
+    vtep.source_interface = val
+    assert_equal(val, vtep.source_interface)
+  end
+end