cisco_node_utils 1.3.0 → 1.4.0

data/tests/test_snmpgroup.rb

@@ -20,12 +20,12 @@ class TestSnmpGroup < CiscoTestCase
   @skip_unless_supported = 'snmp_group'
 
   # NXOS snmp groups will not be empty
-  def test_snmpgroup_collection_not_empty
+  def test_collection_not_empty
     snmpgroups = SnmpGroup.groups
     refute_empty(snmpgroups)
   end
 
-  def test_snmpgroup_collection_valid
+  def test_collection_valid
     snmpgroups = SnmpGroup.groups
     s = @device.cmd('show snmp group | include Role | no-more')
     snmpgroups.each_value do |snmpgroup|
@@ -35,13 +35,13 @@ class TestSnmpGroup < CiscoTestCase
     end
   end
 
-  def test_snmpgroup_exists_with_name_empty
+  def test_exists_with_name_empty
     assert_raises(ArgumentError) do
       SnmpGroup.exists?('')
     end
   end
 
-  def test_snmpgroup_exists_with_name_invalid
+  def test_exists_with_name_invalid
     name = 'group-dummy'
     exist = SnmpGroup.exists?(name)
     s = @device.cmd('show snmp group | in Role | no-more')
@@ -49,13 +49,13 @@ class TestSnmpGroup < CiscoTestCase
     assert_equal(exist, !line.nil?)
   end
 
-  def test_snmpgroup_exists_with_name_bad_type
+  def test_exists_with_name_bad_type
     assert_raises(TypeError) do
       SnmpGroup.exists?(:not_a_string)
     end
   end
 
-  def test_snmpgroup_exists_with_name_valid
+  def test_exists_with_name_valid
     name = 'network-admin'
     exist = SnmpGroup.exists?(name)
     s = @device.cmd('show snmp group | in Role | no-more')
@@ -63,7 +63,7 @@ class TestSnmpGroup < CiscoTestCase
     assert_equal(exist, !line.nil?)
   end
 
-  def test_snmpgroup_get_name
+  def test_get_name
     name = 'network-operator'
     snmpgroup = SnmpGroup.new(name)
     assert_equal(snmpgroup.name, name)

data/tests/test_snmpserver.rb

@@ -32,309 +32,220 @@ class TestSnmpServer < CiscoTestCase
     @default_show_command = 'show run snmp all | no-more'
     # set all commands to defaults
     s = SnmpServer.new
-    s.aaa_user_cache_timeout = s.default_aaa_user_cache_timeout
-    s.contact = s.default_contact
-    s.global_enforce_priv = s.default_global_enforce_priv
-    s.location = s.default_location
-    s.packet_size = 0
-    s.protocol = s.default_protocol
-    s.tcp_session_auth = s.default_tcp_session_auth
-  end
-
-  def test_snmpserver_aaa_user_cache_timeout_set_invalid_upper_range
-    snmpserver = SnmpServer.new
-    assert_raises(Cisco::CliError) do
-      snmpserver.aaa_user_cache_timeout = 86_401
+    if platform == :nexus
+      s.aaa_user_cache_timeout = s.default_aaa_user_cache_timeout
+      s.contact = s.default_contact
+      s.global_enforce_priv = s.default_global_enforce_priv
+      s.location = s.default_location
+      s.packet_size = 0
+      s.protocol = s.default_protocol
+      s.tcp_session_auth = s.default_tcp_session_auth
+    else
+      s.contact = s.default_contact
+      s.location = s.default_location
     end
   end
 
-  def test_snmpserver_aaa_user_cache_timeout_set_invalid_lower_range
-    snmpserver = SnmpServer.new
-    assert_raises(Cisco::CliError) do
-      snmpserver.aaa_user_cache_timeout = 0
+  def test_aaa_user_cache_timeout
+    if validate_property_excluded?('snmp_server', 'aaa_user_cache_timeout')
+      assert_raises(Cisco::UnsupportedError) do
+        SnmpServer.new.aaa_user_cache_timeout = 1400
+      end
+      return
     end
-  end
 
-  def test_snmpserver_aaa_user_cache_timeout_set_valid
-    snmpserver = SnmpServer.new
-    newtimeout = 1400
-    snmpserver.aaa_user_cache_timeout = newtimeout
-    line = assert_show_match(
-      pattern: /snmp-server aaa-user cache-timeout (\d+)/)
-    timeout = line.to_s.split(' ').last.to_i
-    assert_equal(timeout, newtimeout)
-    # set to default
-    snmpserver.aaa_user_cache_timeout =
-      snmpserver.default_aaa_user_cache_timeout
-  end
+    s = SnmpServer.new
+    # initial
+    default = s.default_aaa_user_cache_timeout
+    assert_equal(default, s.aaa_user_cache_timeout)
 
-  def test_snmpserver_aaa_user_cache_timeout_set_default_valid
-    snmpserver = SnmpServer.new
-    snmpserver.aaa_user_cache_timeout =
-      snmpserver.default_aaa_user_cache_timeout
-    line = assert_show_match(
-      pattern: /snmp-server aaa-user cache-timeout (\d+)/)
-    timeout = line.to_s.split(' ').last.to_i
-    assert_equal(timeout, snmpserver.aaa_user_cache_timeout)
-  end
+    # non-default
+    s.aaa_user_cache_timeout = 1400
+    assert_equal(1400, s.aaa_user_cache_timeout)
 
-  def test_snmpserver_aaa_user_cache_timeout_get
-    snmpserver = SnmpServer.new
-    line = assert_show_match(
-      pattern: /snmp-server aaa-user cache-timeout (\d+)/)
-    timeout = line.to_s.split(' ').last.to_i
-    assert_equal(timeout, snmpserver.aaa_user_cache_timeout)
-  end
+    # default
+    s.aaa_user_cache_timeout = default
+    assert_equal(default, s.aaa_user_cache_timeout)
 
-  def test_snmpserver_sys_contact_get
-    snmpserver = SnmpServer.new
-    snmpserver.contact = 'test-contact'
-    line = assert_show_match(command: 'show snmp | no-more',
-                             pattern: /sys contact: [^\n\r]+/)
-    contact = ''
-    contact = line.to_s.gsub('sys contact:', '').strip unless line.nil?
-    # puts "contact : #{line}, #{snmpserver.contact}"
-    assert_equal(contact, snmpserver.contact)
-    # set to default
-    snmpserver.contact = snmpserver.default_contact
+    # negative tests
+    assert_raises(Cisco::CliError) { s.aaa_user_cache_timeout = 86_401 }
+    assert_raises(Cisco::CliError) { s.aaa_user_cache_timeout = 0 }
   end
 
-  def test_snmpserver_sys_contact_set_invalid
-    snmpserver = SnmpServer.new
-    assert_raises(TypeError) do
-      snmpserver.contact = 123
-    end
-  end
+  def test_contact
+    s = SnmpServer.new
+    # initial
+    default = s.default_contact
+    assert_equal(default, s.contact)
 
-  def test_snmpserver_sys_contact_set_zero_length
-    snmpserver = SnmpServer.new
-    newcontact = ''
-    snmpserver.contact = newcontact
-    assert_equal(newcontact, snmpserver.contact)
-    # set to default
-    snmpserver.contact = snmpserver.default_contact
-  end
+    # non-default
+    s.contact = 'minitest'
+    assert_equal('minitest', s.contact)
 
-  def test_snmpserver_sys_contact_set_valid
-    snmpserver = SnmpServer.new
-    newcontact = 'mvenkata_test# contact'
-    snmpserver.contact = newcontact
-    line = assert_show_match(command: 'show snmp | no-more',
-                             pattern: /sys contact: [^\n\r]+/)
-    # puts "line: #{line}"
-    contact = line.to_s.gsub('sys contact:', '').strip
-    assert_equal(contact, newcontact)
-    # set to default
-    snmpserver.contact = snmpserver.default_contact
+    # default
+    s.contact = default
+    assert_equal(default, s.contact)
+
+    # empty
+    s.contact = ''
+    assert_equal('', s.contact)
+
+    # negative test
+    assert_raises(TypeError) { s.contact = 123 }
   end
 
-  def test_snmpserver_sys_contact_set_special_chars
+  def test_contact_special_chars
     snmpserver = SnmpServer.new
-    # newcontact = "Test{}(%tuvy@_cisco contact$#!@1234^&*()_+"
     newcontact = 'user@example.com @$%&}test ]|[#_@test contact'
     snmpserver.contact = newcontact
-    line = assert_show_match(command: 'show snmp | no-more',
-                             pattern: /sys contact: [^\n\r]+/)
-    # puts "line: #{line}"
-    contact = line.to_s.gsub('sys contact:', '').strip
+    if platform == :nexus
+      line = assert_show_match(command: 'show snmp | no-more',
+                               pattern: /sys contact: [^\n\r]+/)
+      # puts "line: #{line}"
+      contact = line.to_s.gsub('sys contact:', '').strip
+    else
+      line = assert_show_match(command: 'show running-config snmp-server',
+                               pattern: /snmp-server contact [^\n\r]+/)
+      contact = ''
+      contact = line.to_s.gsub('snmp-server contact', '').strip unless line.nil?
+    end
     assert_equal(contact, newcontact)
     # set to default
     snmpserver.contact = snmpserver.default_contact
   end
 
-  def test_snmpserver_sys_contact_set_default
-    snmpserver = SnmpServer.new
-    snmpserver.contact = snmpserver.default_contact
-    line = assert_show_match(command: 'show snmp | no-more',
-                             pattern: /sys contact: [^\n\r]*/)
-    contact = ''
-    contact = line.to_s.gsub('sys contact:', '').strip unless line.nil?
-    assert_equal(contact, snmpserver.default_contact)
-  end
+  def test_location
+    s = SnmpServer.new
+    # initial
+    default = s.default_location
+    assert_equal(default, s.location)
 
-  def test_snmpserver_sys_location_get
-    snmpserver = SnmpServer.new
-    # set location
-    snmpserver.location = 'test-location'
-    line = assert_show_match(command: 'show snmp | no-more',
-                             pattern: /sys location: [^\n\r]+/)
-    location = ''
-    location = line.to_s.gsub('sys location:', '').strip unless line.nil?
-    # puts "location : #{location}, #{snmpserver.location}"
-    assert_equal(location, snmpserver.location)
-    # set to default
-    snmpserver.location = snmpserver.default_location
-  end
+    # non-default
+    s.location = 'minitest'
+    assert_equal('minitest', s.location)
 
-  def test_snmpserver_sys_location_set_invalid
-    snmpserver = SnmpServer.new
-    assert_raises(TypeError) do
-      snmpserver.location = 123
-    end
-  end
+    # default
+    s.location = default
+    assert_equal(default, s.location)
 
-  def test_snmpserver_sys_location_set_zero_length
-    snmpserver = SnmpServer.new
-    newlocation = ''
-    snmpserver.location = newlocation
-    assert_equal(newlocation, snmpserver.location)
-  end
+    # empty
+    s.location = ''
+    assert_equal('', s.location)
 
-  def test_snmpserver_sys_location_set_valid
-    snmpserver = SnmpServer.new
-    newlocation = 'bxb-300-2-1 test location'
-    snmpserver.location = newlocation
-    line = assert_show_match(command: 'show snmp | no-more',
-                             pattern: /sys location: [^\n\r]+/)
-    location = line.to_s.gsub('sys location:', '').strip
-    assert_equal(location, newlocation)
-    # set to default
-    snmpserver.location = snmpserver.default_location
+    # negative test
+    assert_raises(TypeError) { s.location = 123 }
   end
 
-  def test_snmpserver_sys_location_set_special_chars
+  def test_location_special_chars
     snmpserver = SnmpServer.new
     newlocation = 'bxb-300 2nd floor test !$%^33&&*) location'
     snmpserver.location = newlocation
-    line = assert_show_match(command: 'show snmp | no-more',
-                             pattern: /sys location: [^\n\r]+/)
-    location = line.to_s.gsub('sys location:', '').strip
+    if platform == :nexus
+      line = assert_show_match(command: 'show snmp | no-more',
+                               pattern: /sys location: [^\n\r]+/)
+      location = line.to_s.gsub('sys location:', '').strip
+    else
+      line = assert_show_match(command: 'show running-config snmp-server',
+                               pattern: /snmp-server location [^\n\r]+/)
+      location = line.to_s.gsub('snmp-server location', '').strip
+    end
     assert_equal(location, newlocation)
     # set to default
     snmpserver.location = snmpserver.default_location
   end
 
-  def test_snmpserver_sys_location_set_default
-    snmpserver = SnmpServer.new
-    #    snmpserver.location = snmpserver.default_location
-    snmpserver.location = 'FOO'
-    line = assert_show_match(command: 'show snmp | no-more',
-                             pattern: /sys location: [^\n\r]+/)
-    location = ''
-    location = line.to_s.gsub('sys location:', '').strip unless line.nil?
-    assert_equal(location, snmpserver.location)
-    # set to default
-    snmpserver.location = snmpserver.default_location
-  end
-
-  def test_snmpserver_packetsize_get
-    snmpserver = SnmpServer.new
-    snmpserver.packet_size = 2000
-    line = assert_show_match(pattern: /snmp-server packetsize (\d+)/)
-    packetsize = 0
-    packetsize = line.to_s.split(' ').last.to_i unless line.nil?
-    assert_equal(packetsize, snmpserver.packet_size)
-    # unset to default
-    snmpserver.packet_size = 0
-  end
+  def test_packet_size
+    skip_legacy_defect?('7.0.3.I2.2e|7.0.3.I3.1',
+                        'CSCuz14217: CLI shows default snmp packet-size incorrectly as 0')
 
-  def test_snmpserver_packetsize_set_invalid_upper_range
-    snmpserver = SnmpServer.new
-    newpacketsize = 17_383
-    assert_raises(Cisco::CliError) do
-      snmpserver.packet_size = newpacketsize
+    if validate_property_excluded?('snmp_server', 'packet_size')
+      assert_raises(Cisco::UnsupportedError) do
+        SnmpServer.new.packet_size = 2000
+      end
+      return
     end
+
+    s = SnmpServer.new
+    # initial
+    default = s.default_packet_size
+    assert_equal(default, s.packet_size)
+
+    # non-default
+    s.packet_size = 1400
+    assert_equal(1400, s.packet_size)
+
+    # default
+    s.packet_size = default
+    assert_equal(default, s.packet_size)
+
+    # negative tests
+    assert_raises(Cisco::CliError) { s.packet_size = 17_383 } # upper bound
+    assert_raises(Cisco::CliError) { s.packet_size = 480 }    # lower bound
   end
 
-  def test_snmpserver_packetsize_set_invalid_lower_range
-    snmpserver = SnmpServer.new
-    newpacketsize = 480
-    assert_raises(Cisco::CliError) do
-      snmpserver.packet_size = newpacketsize
+  def test_global_enforce_priv
+    if validate_property_excluded?('snmp_server', 'global_enforce_priv')
+      assert_raises(Cisco::UnsupportedError) do
+        SnmpServer.new.global_enforce_priv = true
+      end
+      return
     end
-  end
 
-  def test_snmpserver_packetsize_set_valid
-    snmpserver = SnmpServer.new
-    newpacketsize = 1600
-    snmpserver.packet_size = newpacketsize
-    line = assert_show_match(pattern: /snmp-server packetsize (\d+)/)
-    packetsize = line.to_s.split(' ').last.to_i
-    assert_equal(packetsize, newpacketsize)
-    # unset to default
-    snmpserver.packet_size = 0
-  end
+    s = SnmpServer.new
+    # initial
+    default = s.default_global_enforce_priv
+    assert_equal(default, s.global_enforce_priv?)
 
-  def test_snmpserver_packetsize_set_default
-    snmpserver = SnmpServer.new
-    refute_show_match(pattern: /snmp-server packetsize (\d+)/)
-    assert_equal(0, snmpserver.packet_size,
-                 'Error: Snmp Server, packet size not default')
-
-    snmpserver.packet_size = 850
-    line = assert_show_match(pattern: /snmp-server packetsize (\d+)/)
-    packetsize = line.to_s.split(' ').last.to_i
-    assert_equal(packetsize, snmpserver.packet_size,
-                 'Error: Snmp Server, packet size not default')
-
-    snmpserver.packet_size = snmpserver.default_packet_size
-    # TODO: this seems weird, why is default_packet_size not 0 as above?
-    line = assert_show_match(pattern: /snmp-server packetsize (\d+)/)
-    packetsize = line.to_s.split(' ').last.to_i
-    assert_equal(packetsize, snmpserver.packet_size,
-                 'Error: Snmp Server, packet size not default')
-    # set to default
-    snmpserver.packet_size = 0
+    # non-default
+    s.global_enforce_priv = !default
+    assert_equal(!default, s.global_enforce_priv?)
+
+    # default
+    s.global_enforce_priv = default
+    assert_equal(default, s.global_enforce_priv?)
   end
 
-  def test_snmpserver_packetsize_unset
-    snmpserver = SnmpServer.new
+  def test_protocol
+    if validate_property_excluded?('snmp_server', 'protocol')
+      assert_raises(Cisco::UnsupportedError) do
+        SnmpServer.new.protocol = true
+      end
+      return
+    end
 
-    # Get orginal packet size
-    org_packet_size = snmpserver.packet_size
-    snmpserver.packet_size = 0
-    refute_show_match(pattern: /snmp-server packetsize (\d+)/)
-    assert_equal(0, snmpserver.packet_size,
-                 'Error: Snmp Server, packet size not unset')
-
-    # Restore packet size
-    snmpserver.packet_size = org_packet_size
-    assert_equal(org_packet_size, snmpserver.packet_size,
-                 'Error: Snmp Server, packet size not restored')
-    # set to default
-    snmpserver.packet_size = 0
-  end
+    s = SnmpServer.new
+    # initial
+    default = s.default_protocol
+    assert_equal(default, s.protocol?)
 
-  def test_snmpserver_global_enforce_priv
-    snmpserver = SnmpServer.new
-    default = snmpserver.default_global_enforce_priv
-    snmpserver.global_enforce_priv = default
-    if default == true
-      assert_show_match(pattern: /^snmp-server globalEnforcePriv/)
-      assert(snmpserver.global_enforce_priv?)
-
-      snmpserver.global_enforce_priv = false
-      assert_show_match(pattern: /^no snmp-server globalEnforcePriv/)
-      refute(snmpserver.global_enforce_priv?)
-    else
-      assert_show_match(pattern: /^no snmp-server globalEnforcePriv/)
-      refute(snmpserver.global_enforce_priv?)
+    # non-default
+    s.protocol = !default
+    assert_equal(!default, s.protocol?)
 
-      snmpserver.global_enforce_priv = true
-      assert_show_match(pattern: /^snmp-server globalEnforcePriv/)
-      assert(snmpserver.global_enforce_priv?)
-    end
-    # Cleanup
-    snmpserver.global_enforce_priv = snmpserver.default_global_enforce_priv
+    # default
+    s.protocol = default
+    assert_equal(default, s.protocol?)
   end
 
-  def test_snmpserver_protocol_get_set
-    snmpserver = SnmpServer.new
-    snmpserver.protocol = false
-    assert_equal(false, snmpserver.protocol?)
-    snmpserver.protocol =
-      snmpserver.default_protocol
-    assert_equal(snmpserver.default_protocol,
-                 snmpserver.protocol?)
-  end
+  def test_tcp_session_auth
+    if validate_property_excluded?('snmp_server', 'tcp_session_auth')
+      assert_raises(Cisco::UnsupportedError) do
+        SnmpServer.new.tcp_session_auth = true
+      end
+      return
+    end
 
-  def test_snmpserver_tcp_session_auth_get_set
-    snmpserver = SnmpServer.new
-    snmpserver.tcp_session_auth = false
-    assert_equal(false, snmpserver.tcp_session_auth?)
-    snmpserver.tcp_session_auth =
-      snmpserver.default_tcp_session_auth
-    assert_equal(snmpserver.default_tcp_session_auth,
-                 snmpserver.tcp_session_auth?)
+    s = SnmpServer.new
+    # initial
+    default = s.default_tcp_session_auth
+    assert_equal(default, s.tcp_session_auth?)
+
+    # non-default
+    s.tcp_session_auth = !default
+    assert_equal(!default, s.tcp_session_auth?)
+
+    # default
+    s.tcp_session_auth = default
+    assert_equal(default, s.tcp_session_auth?)
   end
 end