cisco_node_utils 0.9.0

data/tests/test_interface_svi.rb

@@ -0,0 +1,267 @@
+# Copyright (c) 2014-2015 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 File.expand_path("../ciscotest", __FILE__)
+require File.expand_path("../../lib/cisco_node_utils/interface", __FILE__)
+
+include Cisco
+
+class TestSvi < CiscoTestCase
+  def get_cmd_ref_autostate
+    ref = cmd_ref.lookup("interface", "svi_autostate")
+    assert(ref, "Error, reference not found for autostate")
+    ref
+  end
+
+  # Decides whether to check for a raised Exception or an equal value.
+  def assert_result(expected_result, err_msg, &block)
+    if expected_result.is_a? Class
+      assert_raises(expected_result, &block)
+    else
+      value = block.call
+      assert_equal(expected_result, value, err_msg)
+    end
+  end
+
+  def set_cmd_ref_system_default_svi_autostate(state="")
+    s = @device.cmd("configure terminal")
+    s = @device.cmd("#{state}system default interface-vlan autostate")
+    s = @device.cmd("end")
+    node.cache_flush
+  end
+
+  def test_svi_prop_nil_when_ethernet
+    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_svi_create_valid
+    svi = Interface.new('Vlan23')
+    s = @device.cmd("show run interface all | inc Vlan")
+    cmd="interface Vlan1"
+    assert(s.include?(cmd), "Error: Failed to create svi Vlan1")
+
+    cmd="interface Vlan23"
+    assert(s.include?(cmd), "Error: Failed to create svi Vlan23")
+    svi.destroy
+
+    # Verify that svi23 got removed now that we invoked svi.destroy
+    s = @device.cmd("show run interface all | inc Vlan")
+    cmd="interface Vlan23"
+    refute(s.include?(cmd), "Error: svi Vlan23 still configured")
+  end
+
+  def test_svi_create_vlan_invalid
+    assert_raises(CliError) do
+      svi = Interface.new('10.1.1.1')
+    end
+  end
+
+  def test_svi_create_vlan_invalid_value
+    assert_raises(CliError) do
+      svi = Interface.new('Vlan0')
+    end
+  end
+
+  def test_svi_create_vlan_nil
+    assert_raises(TypeError) do
+      svi = Interface.new(nil)
+    end
+  end
+
+  def test_svi_name
+    svi = Interface.new('Vlan23')
+    assert_equal("vlan23", svi.name, "Error: svi vlan name is wrong")
+    svi.destroy
+  end
+
+  def test_svi_assignment
+    svi = Interface.new('Vlan23')
+    svi.svi_management = true
+    assert(svi.svi_management, "Error: svi svi_management, false")
+    svi_extra = svi
+    assert(svi_extra.svi_management, "Error: new svi svi_management, false")
+    svi.destroy
+  end
+
+  def test_svi_get_autostate_false
+    svi = Interface.new('Vlan23')
+
+    s = @device.cmd("configure terminal")
+    s = @device.cmd("interface vlan 23")
+    s = @device.cmd("no autostate")
+    s = @device.cmd("end")
+    # Flush the cache since we've modified the device
+    node.cache_flush()
+    ref = get_cmd_ref_autostate
+    result = ref.default_value
+    result = false if ref.config_set
+    assert_equal(result, svi.svi_autostate,
+                 "Error: svi autostate not correct.")
+    svi.destroy
+  end
+
+  def test_svi_get_autostate_true
+    svi = Interface.new('Vlan23')
+
+    s = @device.cmd("configure terminal")
+    s = @device.cmd("interface vlan 23")
+    s = @device.cmd("autostate")
+    s = @device.cmd("end")
+    # Flush the cache since we've modified the device
+    node.cache_flush()
+
+    ref = get_cmd_ref_autostate
+    result = ref.default_value
+    result = true if ref.config_set
+    assert_equal(result, svi.svi_autostate,
+                 "Error: svi autostate not correct.")
+    svi.destroy
+  end
+
+  def test_svi_set_autostate_false
+    ref = get_cmd_ref_autostate
+    svi = Interface.new('Vlan23')
+    assert_result(ref.test_config_result(false),
+                  "Error: svi autostate not set to false") {
+      svi.svi_autostate = false
+    }
+    svi.destroy
+  end
+
+  def test_svi_set_autostate_true
+    svi = Interface.new('Vlan23')
+    ref = get_cmd_ref_autostate
+    assert_result(ref.test_config_result(true),
+                  "Error: svi autostate not set to true") {
+      svi.svi_autostate = true
+    }
+    svi.destroy
+  end
+
+  def test_svi_set_autostate_default
+    svi = Interface.new('Vlan23')
+    ref = get_cmd_ref_autostate
+    default_value = ref.default_value
+    assert_result(ref.test_config_result(default_value),
+                  "Error: svi autostate not set to default") {
+      svi.svi_autostate = default_value
+    }
+    svi.destroy
+  end
+
+  def test_svi_get_management_true
+    svi = Interface.new('Vlan23')
+
+    s = @device.cmd("configure terminal")
+    s = @device.cmd("interface vlan 23")
+    s = @device.cmd("management")
+    s = @device.cmd("end")
+    # Flush the cache since we've modified the device
+    node.cache_flush()
+
+    assert(svi.svi_management)
+    svi.destroy
+  end
+
+  def test_svi_set_management_false
+    svi = Interface.new('Vlan23')
+    svi.svi_management = false
+    refute(svi.svi_management)
+    svi.destroy
+  end
+
+  def test_svi_set_management_true
+    svi = Interface.new('Vlan23')
+    svi.svi_management = true
+    assert(svi.svi_management)
+    svi.destroy
+  end
+
+  def test_svi_set_management_default
+    svi = Interface.new('Vlan23')
+    svi.svi_management = true
+    assert(svi.svi_management)
+
+    svi.svi_management = svi.default_svi_management
+    assert_equal(svi.default_svi_management, svi.svi_management)
+    svi.destroy
+  end
+
+  def test_svi_get_svis
+    count = 5
+
+    ref = get_cmd_ref_autostate
+    # Have to account for interface Vlan1 why we add 1 to count
+    (2..count + 1).each do |i|
+      str = "Vlan" + i.to_s
+      svi = Interface.new(str)
+      assert_result(ref.test_config_result(false),
+                    "Error: svi autostate not set to false") {
+        svi.svi_autostate = false
+      }
+      svi.svi_management = true
+    end
+
+    svis = Interface.interfaces
+    ref = get_cmd_ref_autostate
+    result = ref.default_value
+    svis.each do |id, svi|
+      case id
+      when /^vlan1$/
+        result = true if ref.config_set
+        assert_equal(result, svi.svi_autostate,
+                     "Error: svis collection, Vlan1, incorrect autostate")
+        refute(svi.svi_management,
+               "Error: svis collection, Vlan1, incorrect management")
+      when /^vlan/
+        result = false if ref.config_set
+        assert_equal(result, svi.svi_autostate,
+                     "Error: svis collection, Vlan#{id}, incorrect autostate")
+        assert(svi.svi_management,
+               "Error: svis collection, Vlan#{id}, incorrect management")
+      end
+    end
+
+    svis.each do |id, svi|
+      s = @device.cmd("conf t ; no interface #{id} ; end") if id[/^vlan/]
+    end
+  end
+
+  def test_svi_create_interface_description
+    svi = Interface.new('Vlan23')
+
+    description = "Test description"
+    svi.description = description
+    assert_equal(description, svi.description,
+                 "Error: Description not configured")
+    svi.destroy
+  end
+
+  def test_system_default_svi_autostate_on_off
+    interface = Interface.new("Eth1/1")
+
+    set_cmd_ref_system_default_svi_autostate("no ")
+    refute(interface.system_default_svi_autostate,
+           "Test for disabled - failed")
+
+    # common default is enabled
+    set_cmd_ref_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,722 @@
+# Copyright (c) 2014-2015 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 File.expand_path("../ciscotest", __FILE__)
+require File.expand_path("../../lib/cisco_node_utils/interface", __FILE__)
+require File.expand_path("../../lib/cisco_node_utils/vtp", __FILE__)
+
+include Cisco
+
+class TestInterfaceSwitchport < CiscoTestCase
+  def interface_ethernet_default(ethernet_id)
+    s = @device.cmd("configure terminal")
+    s = @device.cmd("no feature vtp")
+    s = @device.cmd("no feature interface-vlan")
+
+    s = @device.cmd("default interface ethernet #{ethernet_id}")
+    s = @device.cmd("end")
+    node.cache_flush
+  end
+
+  def get_cmd_ref_switchport_autostate_exclude
+    ref = cmd_ref.lookup("interface",
+                         "switchport_autostate_exclude")
+    assert(ref, "Error, reference not found for switchport_autostate_exclude")
+    ref
+  end
+
+  # Decides whether to check for a raised Exception or an equal value.
+  def assert_result(expected_result, err_msg, &block)
+    if expected_result.is_a? Class
+      assert_raises(expected_result, &block)
+    else
+      value = block.call
+      assert_equal(expected_result, value, err_msg)
+    end
+  end
+
+  def set_cmd_ref_system_default_switchport(state="")
+    s = @device.cmd("configure terminal")
+    s = @device.cmd("#{state} system default switchport")
+    s = @device.cmd("end")
+    node.cache_flush
+  end
+
+  def set_cmd_ref_system_default_switchport_shutdown(state="")
+    s = @device.cmd("configure terminal")
+    s = @device.cmd("#{state} system default switchport shutdown")
+    s = @device.cmd("end")
+    node.cache_flush
+  end
+
+  def test_switchport_vtp_disabled_feature_enabled
+    vtp = Vtp.new(true)
+    interface = Interface.new(interfaces[0])
+    refute(interface.switchport_vtp,
+           "Error: interface, access, vtp not disabled")
+    vtp.destroy
+  end
+
+  def test_switchport_vtp_disabled_feature_disabled_eth1_1
+    interface = Interface.new(interfaces[0])
+    refute(interface.switchport_vtp,
+           "Error: interface, access, vtp not disabled")
+  end
+
+  def test_switchport_vtp_disabled_feature_disabled_mgmt0
+    interface = Interface.new("mgmt0")
+    refute(interface.switchport_vtp,
+           "Error: interface, access, vtp not disabled")
+  end
+
+  def test_switchport_vtp_disabled_unsupported_mode_disabled
+    interface = Interface.new(interfaces[0])
+    interface.switchport_mode = :disabled
+    refute(interface.switchport_vtp,
+           "Error: interface, access, vtp not disabled")
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_switchport_vtp_disabled_unsupported_mode_fex
+    begin
+      interface = Interface.new(interfaces[0])
+      interface.switchport_mode = :fex_fabric
+      refute(interface.switchport_vtp,
+             "Error: interface, access, vtp not disabled")
+    rescue RuntimeError => e
+      msg = "[#{interfaces[0]}] switchport_mode is not supported on this interface"
+      assert_equal(msg.downcase, e.message)
+    end
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_switchport_vtp_enabled_access
+    vtp = Vtp.new(true)
+    interface = Interface.new(interfaces[0])
+    interface.switchport_mode = :access
+    s = @device.cmd("configure terminal")
+    s = @device.cmd("interface ethernet #{interfaces_id[0]}")
+    s = @device.cmd("vtp")
+    s = @device.cmd("end")
+    # Flush the cache since we've modified the device
+    node.cache_flush()
+
+    assert(interface.switchport_vtp,
+           "Error: interface, access, vtp not enabled")
+    vtp.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_switchport_vtp_disabled_access
+    vtp = Vtp.new(true)
+    interface = Interface.new(interfaces[0])
+    interface.switchport_mode = :access
+    s = @device.cmd("configure terminal")
+    s = @device.cmd("interface ethernet #{interfaces_id[0]}")
+    s = @device.cmd("no vtp")
+    s = @device.cmd("end")
+    # Flush the cache since we've modified the device
+    node.cache_flush()
+
+    refute(interface.switchport_vtp,
+           "Error: interface, access, vtp not disabled")
+    vtp.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_switchport_vtp_enabled_trunk
+    vtp = Vtp.new(true)
+    interface = Interface.new(interfaces[0])
+    interface.switchport_mode = :trunk
+    s = @device.cmd("configure terminal")
+    s = @device.cmd("interface ethernet #{interfaces_id[0]}")
+    s = @device.cmd("vtp")
+    s = @device.cmd("end")
+    # Flush the cache since we've modified the device
+    node.cache_flush()
+
+    assert(interface.switchport_vtp,
+           "Error: interface, trunk, vtp not enabled")
+    vtp.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_switchport_vtp_disabled_trunk
+    vtp = Vtp.new(true)
+    interface = Interface.new(interfaces[0])
+
+    interface.switchport_mode = :trunk
+    refute(interface.switchport_vtp,
+           "Error: interface, trunk, vtp not disabled")
+    vtp.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_vtp_default_access
+    vtp = Vtp.new(true)
+    interface = Interface.new(interfaces[0])
+    interface.switchport_mode = :access
+
+    interface.switchport_vtp = interface.default_switchport_vtp
+    refute(interface.switchport_vtp,
+           "Error:(1) mode :access, vtp should be default (false)")
+
+    interface.switchport_vtp = true
+    assert(interface.switchport_vtp,
+           "Error:(2) mode :access, vtp should be true")
+
+    interface.switchport_vtp = interface.default_switchport_vtp
+    refute(interface.switchport_vtp,
+           "Error:(3) mode :access, vtp should be default (false)")
+
+    vtp.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_vtp_default_trunk
+    vtp = Vtp.new(true)
+    interface = Interface.new(interfaces[0])
+
+    interface.switchport_mode = :trunk
+    interface.switchport_vtp = interface.default_switchport_vtp
+    refute(interface.switchport_vtp,
+           "Error:(1) mode :trunk, vtp should be default (false)")
+
+    interface.switchport_vtp = true
+    assert(interface.switchport_vtp,
+           "Error:(2) mode :trunk, vtp should be true")
+
+    interface.switchport_vtp = interface.default_switchport_vtp
+    refute(interface.switchport_vtp,
+           "Error:(3) mode :trunk, vtp should be default (false)")
+    vtp.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_vtp_true_access
+    vtp = Vtp.new(true)
+    interface = Interface.new(interfaces[0])
+
+    interface.switchport_mode = :access
+    interface.switchport_vtp = true
+    assert(interface.switchport_vtp,
+           "Error: interface, access, vtp not enabled")
+    vtp.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_vtp_true_trunk
+    vtp = Vtp.new(true)
+    interface = Interface.new(interfaces[0])
+
+    interface.switchport_mode = :trunk
+    interface.switchport_vtp = true
+    assert(interface.switchport_vtp,
+           "Error: interface, access, vtp not enabled")
+    vtp.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_vtp_true_unsupported_mode_disabled
+    vtp = Vtp.new(true)
+    interface = Interface.new(interfaces[0])
+
+    interface.switchport_mode = :disabled
+    refute(interface.switchport_vtp,
+           "Error: interface, access, vtp is enabled")
+    vtp.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_vtp_true_unsupported_mgmt0
+    vtp = Vtp.new(true)
+    interface = Interface.new("mgmt0")
+
+    interface.switchport_vtp = true
+    refute(interface.switchport_vtp,
+           "Error: interface, access, vtp is enabled")
+    vtp.destroy
+  end
+
+  def test_set_switchport_vtp_false_access
+    vtp = Vtp.new(true)
+    interface = Interface.new(interfaces[0])
+
+    interface.switchport_mode = :access
+    interface.switchport_vtp = false
+    refute(interface.switchport_vtp,
+           "Error: interface, access, vtp not disabled")
+    vtp.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_vtp_false_trunk
+    vtp = Vtp.new(true)
+    interface = Interface.new(interfaces[0])
+
+    interface.switchport_mode = :trunk
+    interface.switchport_vtp = false
+    refute(interface.switchport_vtp,
+           "Error: interface, access, vtp not disabled")
+    vtp.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_vtp_false_unsupported_mode_disabled
+    vtp = Vtp.new(true)
+    interface = Interface.new(interfaces[0])
+
+    interface.switchport_mode = :disabled
+    interface.switchport_vtp = false
+    refute(interface.switchport_vtp,
+           "Error: mode :disabled, vtp should be false")
+    vtp.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_switchport_autostate_disabled_feature_enabled
+    svi = Interface.new('Vlan23')
+    interface = Interface.new(interfaces[0])
+    refute(interface.switchport_autostate_exclude,
+           "Error: interface, access, autostate exclude not disabled")
+    svi.destroy
+  end
+
+  def test_switchport_autostate_disabled_feature_disabled_eth1_1
+    interface = Interface.new(interfaces[0])
+    refute(interface.switchport_autostate_exclude,
+           "Error: interface, access, autostate exclude not disabled")
+  end
+
+  def test_switchport_autostate_disabled_feature_disabled_mgmt0
+    interface = Interface.new("mgmt0")
+    refute(interface.switchport_autostate_exclude,
+           "Error: interface, access, autostate exclude not disabled")
+  end
+
+  def test_switchport_autostate_disabled_unsupported_mode
+    interface = Interface.new(interfaces[0])
+    interface.switchport_mode = :disabled
+    refute(interface.switchport_autostate_exclude,
+           "Error: interface, access, autostate exclude not disabled")
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_switchport_autostate_enabled_access
+    svi = Interface.new('Vlan23')
+    interface = Interface.new(interfaces[0])
+    s = @device.cmd("configure terminal")
+    s = @device.cmd("interface ethernet #{interfaces_id[0]}")
+    s = @device.cmd("switchport")
+    s = @device.cmd("switchport autostate exclude")
+    s = @device.cmd("end")
+    # Flush the cache since we've modified the device
+    node.cache_flush()
+
+    cmd_ref = get_cmd_ref_switchport_autostate_exclude
+    if cmd_ref.config_set
+      assert(interface.switchport_autostate_exclude,
+             "Error: interface, access, autostate exclude not enabled")
+    elsif
+      assert_equal(interface.default_switchport_autostate_exclude,
+                   interface.switchport_autostate_exclude,
+                   "Error: interface, access, autostate exclude not disabled")
+    end
+
+    svi.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_switchport_autostate_disabled_access
+    svi = Interface.new('Vlan23')
+    interface = Interface.new(interfaces[0])
+    refute(interface.switchport_autostate_exclude,
+           "Error: interface, access, autostate exclude not disabled")
+    svi.destroy
+  end
+
+  def test_switchport_autostate_enabled_trunk
+    svi = Interface.new('Vlan23')
+    interface = Interface.new(interfaces[0])
+    interface.switchport_mode = :trunk
+    s = @device.cmd("configure terminal")
+    s = @device.cmd("interface ethernet #{interfaces_id[0]}")
+    s = @device.cmd("switchport autostate exclude")
+    s = @device.cmd("end")
+    # Flush the cache since we've modified the device
+    node.cache_flush()
+
+    cmd_ref = get_cmd_ref_switchport_autostate_exclude
+    if cmd_ref.config_set
+      assert(interface.switchport_autostate_exclude,
+             "Error: interface, access, autostate exclude not enabled")
+    elsif
+      assert_equal(interface.default_switchport_autostate_exclude,
+                   interface.switchport_autostate_exclude,
+                   "Error: interface, access, autostate exclude not disabled")
+    end
+
+    svi.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_switchport_autostate_disabled_trunk
+    svi = Interface.new('Vlan23')
+    interface = Interface.new(interfaces[0])
+    interface.switchport_mode = :trunk
+    s = @device.cmd("configure terminal")
+    s = @device.cmd("interface ethernet #{interfaces_id[0]}")
+    s = @device.cmd("no switchport autostate exclude")
+    s = @device.cmd("end")
+    # Flush the cache since we've modified the device
+    node.cache_flush()
+
+    refute(interface.switchport_autostate_exclude,
+           "Error: interface, access, autostate exclude not disabled")
+    svi.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_raise_error_switchport_not_enabled
+    interface = Interface.new(interfaces[0])
+
+    @device.cmd("configure terminal")
+    @device.cmd("interface #{interfaces[0]}")
+    @device.cmd("no switchport")
+    @device.cmd("end")
+    node.cache_flush
+
+    assert_raises(RuntimeError) {
+      interface.switchport_autostate_exclude = true
+    }
+  end
+
+  def test_set_switchport_autostate_default_access
+    svi = Interface.new('Vlan23')
+    interface = Interface.new(interfaces[0])
+
+    # switchport must be enabled to configure autostate
+    @device.cmd("configure terminal")
+    @device.cmd("interface #{interfaces[0]}")
+    @device.cmd("switchport")
+    @device.cmd("end")
+    node.cache_flush
+
+    result = interface.default_switchport_autostate_exclude
+    assert_result(result,
+                  "Error: interface, access, autostate exclude not disabled") {
+      interface.switchport_autostate_exclude = result
+    }
+    svi.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_autostate_default_trunk
+    svi = Interface.new('Vlan23')
+    interface = Interface.new(interfaces[0])
+    interface.switchport_mode = :trunk
+
+    # switchport must be enabled to configure autostate
+    @device.cmd("configure terminal")
+    @device.cmd("interface #{interfaces[0]}")
+    @device.cmd("switchport")
+    @device.cmd("end")
+    node.cache_flush
+
+    result = false
+    assert_result(result,
+                  "Error: interface, access, autostate exclude not disabled") {
+      interface.switchport_autostate_exclude = result
+    }
+    svi.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_autostate_true_access
+    svi = Interface.new('Vlan23')
+    interface = Interface.new(interfaces[0])
+
+    # switchport must be enabled to configure autostate
+    @device.cmd("configure terminal")
+    @device.cmd("interface #{interfaces[0]}")
+    @device.cmd("switchport")
+    @device.cmd("end")
+    node.cache_flush
+
+    result = true
+    assert_result(result,
+                  "Error: interface, access, autostate exclude not disabled") {
+      interface.switchport_autostate_exclude = result
+    }
+    svi.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_autostate_true_trunk
+    svi = Interface.new('Vlan23')
+    interface = Interface.new(interfaces[0])
+    interface.switchport_mode = :trunk
+
+    # switchport must be enabled to configure autostate
+    @device.cmd("configure terminal")
+    @device.cmd("interface #{interfaces[0]}")
+    @device.cmd("switchport")
+    @device.cmd("end")
+    node.cache_flush
+
+    result = true
+    assert_result(result,
+                  "Error: interface, access, autostate exclude not disabled") {
+      interface.switchport_autostate_exclude = result
+    }
+    svi.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_autostate_true_unsupported_mode_disabled
+    svi = Interface.new('Vlan23')
+    interface = Interface.new(interfaces[0])
+    interface.switchport_mode = :disabled
+
+    assert_raises (RuntimeError) do
+      interface.switchport_autostate_exclude = true
+    end
+    svi.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_autostate_true_unsupported_mgmt0
+    svi = Interface.new('Vlan23')
+    interface = Interface.new("mgmt0")
+    assert_raises (RuntimeError) do
+      interface.switchport_autostate_exclude = true
+    end
+    svi.destroy
+  end
+
+  def test_set_switchport_autostate_false_access
+    svi = Interface.new('Vlan23')
+    interface = Interface.new(interfaces[0])
+
+    # switchport must be enabled to configure autostate
+    @device.cmd("configure terminal")
+    @device.cmd("interface #{interfaces[0]}")
+    @device.cmd("switchport")
+    @device.cmd("end")
+    node.cache_flush
+
+    result = false
+    assert_result(result,
+                  "Error: interface, access, autostate exclude not disabled") {
+      interface.switchport_autostate_exclude = result
+    }
+    svi.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_autostate_false_trunk
+    svi = Interface.new('Vlan23')
+    interface = Interface.new(interfaces[0])
+    interface.switchport_mode = :trunk
+
+    # switchport must be enabled to configure autostate
+    @device.cmd("configure terminal")
+    @device.cmd("interface #{interfaces[0]}")
+    @device.cmd("switchport")
+    @device.cmd("end")
+    node.cache_flush
+
+    result = false
+    assert_result(result,
+                  "Error: interface, access, autostate exclude not disabled") {
+      interface.switchport_autostate_exclude = result
+    }
+    svi.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_set_switchport_autostate_false_unsupported_mode_disabled
+    svi = Interface.new('Vlan23')
+    interface = Interface.new(interfaces[0])
+    interface.switchport_mode = :disabled
+
+    assert_raises (RuntimeError) do
+      interface.switchport_autostate_exclude = false
+    end
+    svi.destroy
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_interface_switchport_mode_invalid
+    interface = Interface.new(interfaces[0])
+    assert_raises(ArgumentError) {
+      interface.switchport_mode = :unknown
+    }
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_interface_switchport_mode_not_supported
+    interface = Interface.new("mgmt0")
+    assert_raises(RuntimeError) {
+      interface.switchport_mode = :access
+    }
+    begin
+      interface.switchport_mode = :access
+    rescue RuntimeError => e
+      msg = "[mgmt0] switchport_mode is not supported on this interface"
+      assert_equal(msg, e.message)
+    end
+  end
+
+  def test_interface_switchport_mode_valid
+    switchport_modes = [
+      :unknown,
+      :disabled,
+      :access,
+      :trunk,
+      #:fex_fabric, (fex is tested by test_interface_switchport_mode_valid_fex)
+      :tunnel,
+    ]
+
+    interface = Interface.new(interfaces[0])
+
+    switchport_modes.each { | start |
+      switchport_modes.each { | finish |
+        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 RuntimeError => e
+            msg = "[#{interfaces[0]}] switchport_mode is not supported on this interface"
+            assert_equal(msg.downcase, e.message)
+          end
+        end
+      }
+    }
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+  def test_interface_switchport_mode_valid_fex
+    switchport_modes = [
+      :unknown,
+      :fex_fabric,
+    ]
+
+    interface = Interface.new(interfaces[0])
+    switchport_modes.each { | start |
+      switchport_modes.each { | finish |
+        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")
+            interface.switchport_mode = finish
+            assert_equal(finish, interface.switchport_mode,
+                         "Error: Switchport mode, #{finish}, not as expected")
+          rescue RuntimeError => e
+            msg = "[#{interfaces[0]}] switchport_mode is not supported on this interface"
+            assert_equal(msg.downcase, e.message)
+          end
+        end
+      }
+    }
+    interface_ethernet_default(interfaces_id[0])
+  end
+
+=begin
+  # Run this test at your peril as it can cause timeouts for this test and
+  # others - 'no feature-set fex' states:
+  # "Feature-set Operation may take up to 30 minutes depending on the size of configuration."
+
+  def test_interface_switchport_fex_feature
+    test_matrix = {
+      #    [ <set_state>,  <expected> ]
+      1 => [:uninstalled, :uninstalled], # noop
+      2 => [:installed,   :installed],
+      3 => [:uninstalled, :uninstalled],
+      4 => [:enabled,     :enabled],
+      5 => [:enabled,     :enabled],     # noop
+      6 => [:installed,   :enabled],     # noop
+      7 => [:uninstalled, :uninstalled],
+      8 => [:disabled,    :uninstalled], # noop
+      9 => [:installed,   :installed],
+      10 => [:installed,   :installed],  # noop
+      11 => [:enabled,     :enabled],
+      12 => [:disabled,    :disabled],
+      13 => [:uninstalled, :uninstalled],
+      14 => [:installed,   :installed],
+      15 => [:disabled,    :installed],  # noop
+      16 => [:uninstalled, :uninstalled],
+    }
+    interface = Interface.new(interfaces[0])
+    # start test from :uninstalled state
+    interface.fex_feature_set(:uninstalled)
+    from = interface.fex_feature
+    test_matrix.each { |id,test|
+      #puts "Test #{id}: #{test}, (from: #{from}"
+      set_state, expected = test
+      interface.fex_feature_set(set_state)
+      curr = interface.fex_feature
+      assert_equal(expected, curr,
+                   "Error: fex test #{id}: from #{from} to #{set_state}")
+      from = curr
+    }
+  end
+=end
+
+  def test_system_default_switchport_on_off
+    interface = Interface.new("Eth1/1")
+
+    set_cmd_ref_system_default_switchport("")
+    assert(interface.system_default_switchport,
+           "Test for enabled - failed")
+
+    # common default is "no switch"
+    set_cmd_ref_system_default_switchport("no ")
+    refute(interface.system_default_switchport,
+           "Test for disabled - failed")
+  end
+
+  def test_system_default_switchport_shutdown_on_off
+    interface = Interface.new("Eth1/1")
+
+    set_cmd_ref_system_default_switchport_shutdown("no ")
+    refute(interface.system_default_switchport_shutdown,
+           "Test for disabled - failed")
+
+    # common default is "shutdown"
+    set_cmd_ref_system_default_switchport_shutdown("")
+    assert(interface.system_default_switchport_shutdown,
+           "Test for enabled - failed")
+  end
+
+  def test_interface_svi_command_on_non_vlan
+    interface = Interface.new(interfaces[0])
+    assert_raises(RuntimeError) {
+      interface.svi_autostate = true
+    }
+    assert_raises(RuntimeError) {
+      interface.svi_management = true
+    }
+    interface_ethernet_default(interfaces_id[0])
+  end
+end