cisco_node_utils_mgx 2.1.0.1

data/tests/test_interface_svi.rb

@@ -0,0 +1,210 @@
+# 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/interface'
+
+include Cisco
+
+# TestSvi - Minitest for Interface configuration of SVI interfaces.
+class TestSvi < CiscoTestCase
+  @@pre_clean_needed = true # rubocop:disable Style/ClassVars
+  attr_reader :svi
+
+  def self.runnable_methods
+    # We don't have a separate YAML file to key off, so we check platform
+    return super unless platform == :ios_xr
+    remove_method :setup
+    remove_method :teardown
+    [:xr_unsupported]
+  end
+
+  def xr_unsupported
+    skip("Skipping #{self.class}; Vlan interfaces are not supported on IOS XR")
+  end
+
+  def setup
+    super
+    remove_all_svis if @@pre_clean_needed
+    @@pre_clean_needed = false # rubocop:disable Style/ClassVars
+    @svi = Interface.new('Vlan23')
+  end
+
+  def remove_all_svis
+    Interface.interfaces.each do |int, obj|
+      next unless int[/vlan/]
+      next if int[/vlan1/]
+      obj.destroy
+    end
+  end
+
+  def teardown
+    remove_all_svis
+    config_no_warn('no feature private-vlan')
+    super
+  end
+
+  def skip_autostate_test?
+    skip('svi autostate properties are not supported on this platform') if
+      node.product_id =~ /N(5|6)K/
+  end
+
+  def system_default_svi_autostate(state='')
+    s = config("#{state}system default interface-vlan autostate")
+    if s[/Invalid input/] # rubocop:disable Style/GuardClause
+      skip("'system default interface-vlan autostate' is not supported")
+    end
+  end
+
+  def test_prop_nil_when_eth
+    skip_autostate_test?
+    intf = Interface.new(interfaces[0])
+    assert_nil(intf.svi_autostate,
+               'Error: svi_autostate should be nil when interface is ethernet')
+    assert_nil(intf.svi_management,
+               'Error: svi_management should be nil when interface is ethernet')
+  end
+
+  def test_create_valid
+    @default_show_command = 'show run interface all | inc Vlan'
+    assert_show_match(pattern: /interface Vlan1/,
+                      msg:     'Error: Failed to create svi Vlan1')
+
+    assert_show_match(pattern: /interface Vlan23/,
+                      msg:     'Error: Failed to create svi Vlan23')
+
+    svi.destroy
+
+    # Verify that svi23 got removed now that we invoked svi.destroy
+    refute_show_match(pattern: /interface Vlan23/,
+                      msg:     'Error: svi Vlan23 still configured')
+  end
+
+  def test_create_invalid
+    assert_raises(CliError) { Interface.new('10.1.1.1') }
+    assert_raises(CliError, Cisco::UnsupportedError) { Interface.new('Vlan0') }
+  end
+
+  def test_create_vlan_nil
+    assert_raises(TypeError) { Interface.new(nil) }
+  end
+
+  def test_name
+    assert_equal('vlan23', svi.name, 'Error: svi vlan name is wrong')
+  end
+
+  def test_assignment
+    svi.svi_management = true
+    assert(svi.svi_management, 'Error: svi svi_management, false')
+    svi_extra = Interface.new('Vlan23')
+    assert(svi_extra.svi_management, 'Error: new svi svi_management, false')
+  end
+
+  def test_get_autostate
+    # TBD: autostate is also tested in test_interface_switchport.rb so remove
+    # tests from one or the other
+    skip_autostate_test?
+
+    config('interface vlan 23', 'no autostate')
+    refute(svi.svi_autostate, 'Error: svi autostate not correct.')
+
+    config('interface vlan 23', 'autostate')
+    assert(svi.svi_autostate, 'Error: svi autostate not correct.')
+  end
+
+  def test_set_autostate
+    skip_autostate_test?
+    svi.svi_autostate = false
+    refute(svi.svi_autostate, 'Error: svi autostate not set to false')
+
+    svi.svi_autostate = true
+    assert(svi.svi_autostate, 'Error: svi autostate not set to true')
+
+    svi.svi_autostate = svi.default_svi_autostate
+    assert_equal(svi.default_svi_autostate, svi.svi_autostate,
+                 'Error: svi autostate not set to default')
+  end
+
+  def test_get_management
+    config('interface vlan 23', 'management')
+
+    assert(svi.svi_management)
+  end
+
+  def test_set_management
+    svi.svi_management = false
+    refute(svi.svi_management)
+
+    svi.svi_management = true
+    assert(svi.svi_management)
+
+    svi.svi_management = svi.default_svi_management
+    assert_equal(svi.default_svi_management, svi.svi_management)
+  end
+
+  def config_svi_properties(state)
+    # We don't want the default vlan23 for this test:
+    svi.destroy
+    # Skip default vlan1
+    (2..6).each do |i|
+      svi = Interface.new('Vlan' + i.to_s)
+      svi.svi_autostate = state unless /N(5|6)K/.match(node.product_id)
+      svi.svi_management = state
+    end
+  end
+
+  def test_get_svis
+    config_svi_properties(true)
+    Interface.interfaces.each do |id, obj|
+      next if id[/vlan1/]
+      next unless id[/vlan/]
+      unless /N(5|6)K/.match(node.product_id)
+        assert(obj.svi_autostate, "svi autostate should be enabled #{id}")
+      end
+      assert(obj.svi_management, "svi management should be enabled #{id}")
+    end
+
+    config_svi_properties(false)
+    Interface.interfaces.each do |id, obj|
+      next if id[/vlan1/]
+      next unless id[/vlan/]
+      unless /N(5|6)K/.match(node.product_id)
+        refute(obj.svi_autostate, "svi autostate should be disabled #{id}")
+      end
+      refute(obj.svi_management, "svi management should be disabled #{id}")
+    end
+  end
+
+  def test_description
+    description = 'Test description'
+    svi.description = description
+    assert_equal(description, svi.description,
+                 'Error: Description not configured')
+  end
+
+  def test_sys_def_svi_autostate
+    skip_autostate_test?
+    skip_legacy_defect?('8.0.1|8.1.1|8\.3', 'CSC: Behavior change after helsinki')
+    interface = Interface.new(interfaces[0])
+
+    system_default_svi_autostate('no ')
+    refute(interface.system_default_svi_autostate,
+           'Test for disabled - failed')
+
+    # common default is enabled
+    system_default_svi_autostate('')
+    assert(interface.system_default_svi_autostate,
+           'Test for enabled - failed')
+  end
+end

data/tests/test_interface_switchport.rb

@@ -0,0 +1,468 @@
+# 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/interface'
+require_relative '../lib/cisco_node_utils/vtp'
+
+include Cisco
+
+# TestInterfaceSwitchport
+# Parent class for specific types of switchport tests (below)
+class TestInterfaceSwitchport < CiscoTestCase
+  attr_reader :interface
+
+  def platform_supports_vtp_switchport_access?
+    skip('Platform does not support VTP when switchport mode is access') if
+      node.product_id =~ /N(5|6|7)/
+  end
+
+  def setup
+    super
+    config_no_warn('no feature vtp', 'no feature interface-vlan')
+    @interface = Interface.new(interfaces[0])
+  end
+
+  def teardown
+    interface_ethernet_default(interfaces[0])
+    super
+  end
+
+  def interface_ethernet_default(ethernet_intf)
+    config("default interface #{ethernet_intf}")
+  end
+
+  def mgmt_intf
+    if platform == :nexus
+      'mgmt0'
+    elsif platform == :ios_xr
+      'MgmtEth0/RP0/CPU0/0'
+    end
+  end
+end
+
+# TestSwitchport - general interface switchport tests.
+class TestSwitchport < TestInterfaceSwitchport
+  DEFAULT_IF_ACCESS_VLAN = 1
+  DEFAULT_IF_SWITCHPORT_NATIVE_VLAN = 1
+
+  def system_default_switchport(state='')
+    config("#{state} system default switchport")
+  end
+
+  def system_default_switchport_shutdown(state='')
+    config("#{state} system default switchport shutdown")
+  end
+
+  def test_access_vlan
+    interface.switchport_mode = :disabled
+    if platform == :ios_xr
+      assert_raises(Cisco::UnsupportedError) do
+        interface.switchport_mode = :access
+      end
+      assert_nil(interface.access_vlan)
+    else
+      interface.switchport_mode = :access
+      assert_equal(DEFAULT_IF_ACCESS_VLAN, interface.access_vlan)
+    end
+  end
+
+  def test_access_vlan_sw_disabled
+    interface.switchport_mode = :disabled
+    assert_nil(interface.access_vlan)
+  end
+
+  def test_access_vlan_sw_trunk
+    interface.switchport_mode = :disabled
+    if platform == :ios_xr
+      assert_raises(Cisco::UnsupportedError) do
+        interface.switchport_mode = :trunk
+      end
+      assert_nil(interface.access_vlan)
+    else
+      interface.switchport_mode = :trunk
+      assert_equal(DEFAULT_IF_ACCESS_VLAN, interface.access_vlan)
+    end
+  end
+
+  def test_sw_vtp_disabled
+    refute(interface.switchport_vtp,
+           'Error: interface, access, vtp not disabled')
+
+    # mgmt
+    interface = Interface.new(mgmt_intf)
+    refute(interface.switchport_vtp,
+           'Error: interface, access, vtp not disabled')
+
+    # no switchport
+    interface.switchport_mode = :disabled
+    refute(interface.switchport_vtp,
+           'Error: interface, access, vtp not disabled')
+  end
+
+  def test_sw_vtp_disabled_fex
+    if validate_property_excluded?('feature', 'fex')
+      assert_raises(Cisco::UnsupportedError) do
+        Feature.fex_enable
+      end
+      return
+    end
+    if validate_property_excluded?('interface', 'switchport')
+      assert_raises(Cisco::UnsupportedError) do
+        interface.switchport_mode = :fex_fabric
+      end
+      return
+    end
+    interface.switchport_mode = :fex_fabric
+    refute(interface.switchport_vtp,
+           'Error: interface, access, vtp not disabled')
+  rescue Cisco::CliError => e
+    incompatible_interface?(e.message)
+  end
+
+  def test_sw_autostate_disabled
+    refute(interface.switchport_autostate_exclude,
+           'Error: interface, access, autostate exclude not disabled')
+
+    # mgmt
+    interface = Interface.new(mgmt_intf)
+    refute(interface.switchport_autostate_exclude,
+           'Error: interface, access, autostate exclude not disabled')
+
+    # no switchport
+    if platform == :ios_xr
+      assert_nil(interface.switchport_autostate_exclude)
+    else
+      interface.switchport_mode = :disabled
+      refute(interface.switchport_autostate_exclude,
+             'Error: interface, access, autostate exclude not disabled')
+    end
+  end
+
+  def test_sw_mode_disabled
+    if platform == :ios_xr
+      assert_raises(Cisco::UnsupportedError) do
+        interface.switchport_autostate_exclude = true
+      end
+    else
+      interface.switchport_enable(false)
+
+      assert_raises(RuntimeError) do
+        interface.switchport_autostate_exclude = true
+      end
+    end
+  end
+
+  def test_sw_mode_invalid
+    assert_raises(ArgumentError) { interface.switchport_mode = :unknown }
+
+    interface = Interface.new(mgmt_intf)
+    assert_raises(Cisco::CliError, Cisco::UnsupportedError) do
+      interface.switchport_mode = :access
+    end
+  end
+
+  def test_sw_mode_valid
+    if platform == :ios_xr
+      # We don't support any switchport modes on IOS XR
+      # but we allow the user to set :disabled since that's the default.
+      interface.switchport_mode = :disabled
+      assert_nil(interface.switchport_mode)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.switchport_mode = :access
+      end
+      assert_raises(Cisco::UnsupportedError) do
+        interface.switchport_mode = :trunk
+      end
+      assert_nil(interface.switchport_mode)
+      return
+    end
+
+    switchport_modes = [
+      :unknown,
+      :disabled,
+      :access,
+      :trunk,
+      :tunnel,
+    ]
+
+    switchport_modes.each do |start|
+      switchport_modes.each do |finish|
+        next if start == :unknown || finish == :unknown
+        begin
+          # puts "#{start},#{finish}"
+          interface.switchport_mode = start
+          assert_equal(start, interface.switchport_mode,
+                       "Error: Switchport mode, #{start}, not as expected")
+          # puts "now finish #{finish}"
+          interface.switchport_mode = finish
+          assert_equal(finish, interface.switchport_mode,
+                       "Error: Switchport mode, #{finish}, not as expected")
+        rescue Cisco::CliError
+          next
+        end
+      end
+    end
+  end
+
+  def test_sw_mode_valid_fex
+    if validate_property_excluded?('feature', 'fex')
+      assert_raises(Cisco::UnsupportedError) do
+        Feature.fex_enable
+      end
+      return
+    end
+    if validate_property_excluded?('interface', 'switchport')
+      assert_raises(Cisco::UnsupportedError) do
+        interface.switchport_mode = :fex_fabric
+      end
+      return
+    end
+
+    interface.switchport_mode = :fex_fabric
+  rescue Cisco::CliError => e
+    incompatible_interface?(e.message)
+  end
+
+  def test_sw_trunk_allowed_vlan
+    if platform == :ios_xr
+      assert_nil(interface.default_switchport_trunk_allowed_vlan)
+      assert_nil(interface.switchport_trunk_allowed_vlan)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.switchport_trunk_allowed_vlan = 'all'
+      end
+      assert_raises(Cisco::UnsupportedError) do
+        interface.switchport_trunk_allowed_vlan = '20'
+      end
+      assert_raises(Cisco::UnsupportedError) do
+        interface.switchport_trunk_allowed_vlan = 'none'
+      end
+    else
+      interface.switchport_enable
+      interface.switchport_trunk_allowed_vlan = 'all'
+      assert_equal(interface.default_switchport_trunk_allowed_vlan,
+                   interface.switchport_trunk_allowed_vlan)
+
+      interface.switchport_trunk_allowed_vlan = '20'
+      assert_equal('20', interface.switchport_trunk_allowed_vlan)
+
+      interface.switchport_trunk_allowed_vlan = '30'
+      assert_equal('30', interface.switchport_trunk_allowed_vlan)
+
+      interface.switchport_trunk_allowed_vlan =
+        interface.default_switchport_trunk_allowed_vlan
+      assert_equal(interface.default_switchport_trunk_allowed_vlan,
+                   interface.switchport_trunk_allowed_vlan)
+
+      interface.switchport_trunk_allowed_vlan = 'none'
+      assert_equal('none', interface.switchport_trunk_allowed_vlan)
+
+      interface.switchport_trunk_allowed_vlan = '20, 30'
+      assert_equal('20,30', interface.switchport_trunk_allowed_vlan)
+
+      # Some images have behavior where 'vlan add' is separate line
+      # This behavior is triggered for vlan ranges that exceed character limit
+      vlans = '500-528,530,532,534,587,590-593,597-598,600,602,604'
+      interface.switchport_trunk_allowed_vlan = vlans
+      assert_equal(vlans, interface.switchport_trunk_allowed_vlan)
+    end
+  end
+
+  def test_sw_trunk_native_vlan
+    if platform == :ios_xr
+      assert_nil(interface.switchport_trunk_native_vlan)
+      assert_nil(interface.default_switchport_trunk_native_vlan)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.switchport_trunk_native_vlan = 20
+      end
+    else
+      interface.switchport_enable
+
+      interface.switchport_trunk_native_vlan = 20
+      assert_equal(20, interface.switchport_trunk_native_vlan)
+
+      interface.switchport_trunk_native_vlan = 30
+      assert_equal(30, interface.switchport_trunk_native_vlan)
+
+      interface.switchport_trunk_native_vlan =
+        interface.default_switchport_trunk_native_vlan
+      assert_equal(DEFAULT_IF_SWITCHPORT_NATIVE_VLAN,
+                   interface.switchport_trunk_native_vlan)
+    end
+  end
+
+  def test_sys_def_sw_on_off
+    if platform == :nexus
+      system_default_switchport('')
+      assert(interface.system_default_switchport,
+             'Test for enabled - failed')
+
+      # common default is "no switch"
+      system_default_switchport('no ')
+    end
+    refute(interface.system_default_switchport,
+           'Test for disabled - failed')
+  rescue RuntimeError => e
+    skip('NX-OS defect: system default switchport nvgens twice') if
+      e.message[/Expected zero.one value/]
+    flunk(e.message)
+  end
+
+  def test_sys_def_sw_shut_on_off
+    if platform == :nexus
+      system_default_switchport_shutdown('no ')
+      refute(interface.system_default_switchport_shutdown,
+             'Test for disabled - failed')
+
+      # common default is "shutdown"
+      system_default_switchport_shutdown('')
+    end
+    assert(interface.system_default_switchport_shutdown,
+           'Test for enabled - failed')
+  end
+
+  def test_svi_cmd_on_non_vlan
+    assert_raises(RuntimeError) { interface.svi_autostate = true }
+    assert_raises(RuntimeError) { interface.svi_management = true }
+  end
+end
+
+# TestInterfaceSwitchportSvi
+# Minitest for Interface switchport configuration in combo with interface-vlan
+# Not applicable to IOS XR
+class TestInterfaceSwSvi < TestInterfaceSwitchport
+  attr_reader :svi
+
+  def setup
+    super
+    skip('VLAN interfaces are not supported on IOS XR') if platform == :ios_xr
+    @svi = Interface.new('Vlan23')
+  end
+
+  def teardown
+    svi.destroy unless platform == :ios_xr || svi.nil?
+    super
+  end
+
+  def test_sw_autostate
+    i = interface
+    if validate_property_excluded?('interface', 'switchport_autostate_exclude')
+      assert_raises(Cisco::UnsupportedError) do
+        i.switchport_autostate_exclude = false
+      end
+      return
+    end
+
+    default = i.default_switchport_autostate_exclude
+
+    # access
+    i.switchport_mode = :access
+    assert_equal(default, i.switchport_autostate_exclude)
+
+    i.switchport_autostate_exclude = true
+    assert(i.switchport_autostate_exclude)
+
+    i.switchport_autostate_exclude = false
+    refute(i.switchport_autostate_exclude)
+
+    i.switchport_autostate_exclude = default
+    assert_equal(default, i.switchport_autostate_exclude)
+
+    # trunk
+    i.switchport_mode = :trunk
+    i.switchport_autostate_exclude = true
+    assert(i.switchport_autostate_exclude)
+
+    i.switchport_autostate_exclude = false
+    refute(i.switchport_autostate_exclude)
+
+    i.switchport_autostate_exclude = default
+    assert_equal(default, i.switchport_autostate_exclude)
+
+    # disabled
+    interface.switchport_mode = :disabled
+    assert_raises RuntimeError do
+      interface.switchport_autostate_exclude = true
+    end
+
+    assert_raises RuntimeError do
+      interface.switchport_autostate_exclude = false
+    end
+  end
+end
+
+# TestInterfaceSwitchportVtp
+# Minitest for Interface switchport configuration in combo with Vtp class
+# Not applicable to IOS XR
+class TestInterfaceSwVtp < TestInterfaceSwitchport
+  attr_reader :vtp
+
+  def setup
+    super
+    skip('VTP is not supported on IOS XR or fretta') if
+      platform == :ios_xr || product_tag[/n(3|9)k-f/]
+    @vtp = Vtp.new(true)
+  end
+
+  def teardown
+    vtp.destroy unless platform == :ios_xr || product_tag[/n(3|9)k-f/]
+    super
+  end
+
+  def test_mode_access
+    # Basic test
+    refute(interface.switchport_vtp,
+           'Error: interface, access, vtp not disabled')
+
+    # Now :access
+    platform_supports_vtp_switchport_access?
+    interface.switchport_mode = :access
+
+    default = interface.default_switchport_vtp
+    assert_equal(default, interface.switchport_vtp)
+
+    interface.switchport_vtp = true
+    assert(interface.switchport_vtp)
+
+    interface.switchport_vtp = false
+    refute(interface.switchport_vtp)
+
+    interface.switchport_vtp = default
+    assert_equal(default, interface.switchport_vtp)
+  end
+
+  def test_mode_trunk
+    platform_supports_vtp_switchport_access?
+    interface.switchport_mode = :trunk
+
+    default = interface.default_switchport_vtp
+    assert_equal(default, interface.switchport_vtp)
+
+    interface.switchport_vtp = true
+    assert(interface.switchport_vtp)
+
+    interface.switchport_vtp = false
+    refute(interface.switchport_vtp)
+
+    interface.switchport_vtp = default
+    assert_equal(default, interface.switchport_vtp)
+  end
+
+  def test_mode_disabled
+    platform_supports_vtp_switchport_access?
+    interface.switchport_mode = :disabled
+    refute(interface.switchport_vtp,
+           'Error: interface, access, vtp is enabled')
+  end
+end