cisco_node_utils 1.0.1 → 1.1.0

data/tests/test_syslog_server.rb

@@ -0,0 +1,88 @@
+#
+# Minitest for SyslogServer class
+#
+# 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_relative 'ciscotest'
+require_relative '../lib/cisco_node_utils/syslog_server'
+
+# TestSyslogServer - Minitest for SyslogServer node utility.
+class TestSyslogServer < CiscoTestCase
+  def setup
+    # setup runs at the beginning of each test
+    super
+    no_syslogserver
+  end
+
+  def teardown
+    # teardown runs at the end of each test
+    no_syslogserver
+    super
+  end
+
+  def no_syslogserver
+    # Turn the feature off for a clean test.
+    config('no logging server 1.2.3.4',
+           'no logging server 2.3.4.5',
+           'no vrf context red')
+  end
+
+  # TESTS
+
+  def test_syslogserver_create_destroy_single
+    id = '1.2.3.4'
+    refute_includes(Cisco::SyslogServer.syslogservers, id)
+
+    server = Cisco::SyslogServer.new(id, 2, 'default', true)
+    assert_includes(Cisco::SyslogServer.syslogservers, id)
+    assert_equal(Cisco::SyslogServer.syslogservers[id], server)
+
+    server.destroy
+    refute_includes(Cisco::SyslogServer.syslogservers, id)
+  end
+
+  def test_syslogserver_create_destroy_multiple
+    id = '1.2.3.4'
+    id2 = '2.3.4.5'
+    refute_includes(Cisco::SyslogServer.syslogservers, id)
+    refute_includes(Cisco::SyslogServer.syslogservers, id2)
+
+    server = Cisco::SyslogServer.new(id, 2, 'default', true)
+    server2 = Cisco::SyslogServer.new(id2, 2, 'default', true)
+    assert_includes(Cisco::SyslogServer.syslogservers, id)
+    assert_equal(Cisco::SyslogServer.syslogservers[id], server)
+    assert_includes(Cisco::SyslogServer.syslogservers, id2)
+    assert_equal(Cisco::SyslogServer.syslogservers[id2], server2)
+
+    server.destroy
+    server2.destroy
+    refute_includes(Cisco::SyslogServer.syslogservers, id)
+    refute_includes(Cisco::SyslogServer.syslogservers, id2)
+  end
+
+  def test_syslogserver_create_destroy_single_vrf
+    config('vrf context red')
+    id = '1.2.3.4'
+
+    refute_includes(Cisco::SyslogServer.syslogservers, id)
+
+    server = Cisco::SyslogServer.new(id, 2, 'red', true)
+    assert_includes(Cisco::SyslogServer.syslogservers, id)
+    assert_equal(Cisco::SyslogServer.syslogservers[id], server)
+
+    server.destroy
+    refute_includes(Cisco::SyslogServer.syslogservers, id)
+  end
+end

data/tests/test_syslog_settings.rb

@@ -0,0 +1,54 @@
+#
+# Minitest for SyslogSetting class
+#
+# 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_relative 'ciscotest'
+require_relative '../lib/cisco_node_utils/syslog_settings'
+
+# TestSyslogSetting - Minitest for SyslogSetting node utility.
+class TestSyslogSettings < CiscoTestCase
+  def setup
+    # setup runs at the beginning of each test
+    super
+    no_syslogsettings
+  end
+
+  def teardown
+    # teardown runs at the end of each test
+    no_syslogsettings
+    super
+  end
+
+  def no_syslogsettings
+    # Turn the feature off for a clean test.
+    config('no logging timestamp seconds')
+  end
+
+  # TESTS
+
+  def test_syslogsettings_create
+    syslog_setting = Cisco::SyslogSettings.new('default')
+    assert_includes(Cisco::SyslogSettings.syslogsettings, 'default')
+    assert_equal(Cisco::SyslogSettings.syslogsettings['default'],
+                 syslog_setting)
+
+    syslog_setting.timestamp = 'milliseconds'
+    assert_equal(Cisco::SyslogSettings.syslogsettings['default'].timestamp,
+                 'milliseconds')
+    assert_equal(syslog_setting.timestamp,
+                 'milliseconds')
+  end
+end

data/tests/test_tacacs_server.rb

@@ -12,47 +12,43 @@
 # 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/tacacs_server", __FILE__)
+require_relative 'ciscotest'
+require_relative '../lib/cisco_node_utils/tacacs_server'
 
+# TestTacacsServer - Minitest for TacacsServer node utility
 class TestTacacsServer < CiscoTestCase
-  def get_tacacsserver_feature
-    s = @device.cmd("show run all | no-more")
-    cmd = "feature tacacs+"
-    line = /#{cmd}/.match(s)
+  def assert_tacacsserver_feature
+    assert_show_match(command: 'show run all | no-more',
+                      pattern: /feature tacacs\+/)
   end
 
-  # Helper routine to get the tacacs config. Ideally we should be able
-  # to use 'sh run tacacs all' but that does not work for 'directed-request'
-  # why 'sh run aaa all' is used.
-  def get_tacacsserver_match_line(name)
-    s = @device.cmd("show run tacacs all | no-more ; show run aaa all | no-more")
-    cmd = "tacacs-server"
-    pattern = (/#{cmd} #{name}/)
-    line = pattern.match(s)
+  def refute_tacacsserver_feature
+    refute_show_match(command: 'show run all | no-more',
+                      pattern: /feature tacacs\+/)
   end
 
-  def get_match_line(name)
-    s = @device.cmd("show run all | no-more")
-    line = /#{name}/.match(s)
+  def setup
+    super
+    # Most commands appear under 'show run tacacs all' but the
+    # 'directed-request' command is under 'show run aaa all'
+    @default_show_command = 'show run tacacs all | no-more ; ' \
+                            'show run aaa all | no-more'
   end
 
   def test_tacacsserver_create_valid
     tacacs = TacacsServer.new
-    line = get_tacacsserver_feature
-    refute_nil(line, "Error: Tacacs feature not set")
+    assert_tacacsserver_feature
     tacacs.destroy
   end
 
   def test_tacacsserver_get_encryption_type
-    s = @device.cmd("conf t ; no feature tacacs+ ; feature tacacs+ ; end")
-    node.cache_flush
+    config('no feature tacacs+', 'feature tacacs+')
     encryption_type = TACACS_SERVER_ENC_UNKNOWN
     # Get encryption password when not configured
     tacacs = TacacsServer.new
     assert_equal(encryption_type,
                  tacacs.encryption_type,
-                 "Error: Tacacs Server, encryption type incorrect")
+                 'Error: Tacacs Server, encryption type incorrect')
     tacacs.destroy
 
     # Get encryption password when configured
@@ -60,26 +56,19 @@ class TestTacacsServer < CiscoTestCase
     # This one is needed since the 'sh run' will always display the type
     # differently than the used encryption config type.
     sh_run_encryption_type = TACACS_SERVER_ENC_CISCO_TYPE_7
-    s = @device.cmd("configure terminal")
-    s = @device.cmd("feature tacacs+")
-    s = @device.cmd("tacacs-server key #{encryption_type} TEST")
-    s = @device.cmd("end")
-    node.cache_flush
+    config('feature tacacs+', "tacacs-server key #{encryption_type} TEST")
 
     tacacs = TacacsServer.new
     assert_equal(sh_run_encryption_type,
                  tacacs.encryption_type,
-                 "Error: Tacacs Server, encryption type incorrect")
+                 'Error: Tacacs Server, encryption type incorrect')
 
     encryption_type = TACACS_SERVER_ENC_CISCO_TYPE_7
-    s = @device.cmd("configure terminal")
-    s = @device.cmd("tacacs-server key #{encryption_type} TEST")
-    s = @device.cmd("end")
-    node.cache_flush
+    config("tacacs-server key #{encryption_type} TEST")
 
     assert_equal(sh_run_encryption_type,
                  tacacs.encryption_type,
-                 "Error: Tacacs Server, encryption type incorrect")
+                 'Error: Tacacs Server, encryption type incorrect')
     tacacs.destroy
   end
 
@@ -87,41 +76,37 @@ class TestTacacsServer < CiscoTestCase
     # Ruby can use defines, but only they're not initialized from an enum
     assert_equal(TACACS_SERVER_ENC_NONE,
                  TacacsServer.default_encryption_type,
-                 "Error: Tacacs Server, default encryption incorrect")
+                 'Error: Tacacs Server, default encryption incorrect')
   end
 
   def test_tacacsserver_get_encryption_password
     # Get encryption password when not configured
-    s = @device.cmd("conf t ; no feature tacacs+ ; end")
-    node.cache_flush
+    config('no feature tacacs+')
     tacacs = TacacsServer.new
-    assert_equal(node.config_get_default("tacacs_server", "encryption_password"),
+    assert_equal(node.config_get_default('tacacs_server',
+                                         'encryption_password'),
                  tacacs.encryption_password,
-                 "Error: Tacacs Server, encryption password incorrect")
+                 'Error: Tacacs Server, encryption password incorrect')
     tacacs.destroy
 
     # Get encryption password when configured
-    sh_run_encryption_password = "WAWY"
+    sh_run_encryption_password = 'WAWY'
     encryption_type = TACACS_SERVER_ENC_NONE
     # This one is needed since the 'sh run' will always display the password
     # differently than the used encryption config type.
-    s = @device.cmd("configure terminal")
-    s = @device.cmd("feature tacacs+")
-    s = @device.cmd("tacacs-server key #{encryption_type} TEST")
-    s = @device.cmd("end")
-    # Flush the cache since we've modified the device
-    node.cache_flush
+    config('feature tacacs+', "tacacs-server key #{encryption_type} TEST")
     tacacs = TacacsServer.new
     assert_equal(sh_run_encryption_password,
                  tacacs.encryption_password,
-                 "Error: Tacacs Server, encryption password incorrect")
+                 'Error: Tacacs Server, encryption password incorrect')
     tacacs.destroy
   end
 
   def test_tacacsserver_get_default_encryption_password
-    assert_equal(node.config_get_default("tacacs_server", "encryption_password"),
+    assert_equal(node.config_get_default('tacacs_server',
+                                         'encryption_password'),
                  TacacsServer.default_encryption_password,
-                 "Error: Tacacs Server, default encryption password incorrect")
+                 'Error: Tacacs Server, default encryption password incorrect')
   end
 
   def test_tacacsserver_key_set
@@ -129,69 +114,67 @@ class TestTacacsServer < CiscoTestCase
     # This one is needed since the 'sh run' will always display the type
     # differently than the used encryption config type.
     sh_run_encryption_type = TACACS_SERVER_ENC_CISCO_TYPE_7
-    password = "TEST_NEW"
+    password = 'TEST_NEW'
 
     tacacs = TacacsServer.new
     tacacs.encryption_key_set(enc_type, password)
     # Get the password from the running config since its encoded
-    line = get_tacacsserver_match_line("key\s#{sh_run_encryption_type}\s\".*\"")
-    refute_nil(line, "Error: Tacacs Server, key not configured")
+    line = assert_show_match(
+      pattern: /tacacs-server key\s#{sh_run_encryption_type}\s".*"/,
+      msg:     'Error: Tacacs Server, key not configured')
     # Extract encrypted password, and git rid of the "" around the pasword
     md = line.to_s
-    encrypted_password = md.to_s.split(" ").last.tr('\"', '')
+    encrypted_password = md.to_s.split(' ').last.tr('\"', '')
     # Extract encryption type
     md = /tacacs-server\skey\s\d/.match(line.to_s)
-    encrypted_type = md.to_s.split(" ").last.to_i
+    encrypted_type = md.to_s.split(' ').last.to_i
     assert_equal(encrypted_type, tacacs.encryption_type,
-                 "Error: Tacacs Server, encryption type incorrect")
+                 'Error: Tacacs Server, encryption type incorrect')
     assert_equal(encrypted_password, tacacs.encryption_password,
-                 "Error: Tacacs Server, encryption password incorrect")
+                 'Error: Tacacs Server, encryption password incorrect')
     tacacs.destroy
   end
 
   def test_tacacsserver_key_unconfigure
-    s = @device.cmd("conf t ; no feature tacacs+ ; end")
-    node.cache_flush
+    config('no feature tacacs+')
     enc_type = TACACS_SERVER_ENC_NONE
     # This one is needed since the 'sh run' will always display the type
     # differently than the used encryption config type.
     sh_run_encryption_type = TACACS_SERVER_ENC_CISCO_TYPE_7
-    password = "TEST_NEW"
+    password = 'TEST_NEW'
 
     tacacs = TacacsServer.new
     tacacs.encryption_key_set(enc_type, password)
-    line = get_tacacsserver_match_line("key\s#{sh_run_encryption_type}\s\".*\"")
-    refute_nil(line, "Error: Tacacs Server, key not configured")
+    assert_show_match(
+      pattern: /tacacs-server key\s#{sh_run_encryption_type}\s".*"/,
+      msg:     'Error: Tacacs Server, key not configured')
 
     enc_type = TACACS_SERVER_ENC_UNKNOWN
-    password = ""
+    password = ''
     tacacs.encryption_key_set(enc_type, password)
-    line = get_tacacsserver_match_line("key\s#{sh_run_encryption_type}\s\".*\"")
-    assert_nil(line, "Error: Tacacs Server, key configured")
+    refute_show_match(
+      pattern: /tacacs-server key\s#{sh_run_encryption_type}\s".*"/,
+      msg:     'Error: Tacacs Server, key configured')
     tacacs.destroy
   end
 
   def test_tacacsserver_get_timeout
     tacacs = TacacsServer.new
-    timeout = node.config_get_default("tacacs_server", "timeout")
+    timeout = node.config_get_default('tacacs_server', 'timeout')
     assert_equal(timeout, tacacs.timeout,
-                 "Error: Tacacs Server, timeout not default")
+                 'Error: Tacacs Server, timeout not default')
 
     timeout = 35
-    s = @device.cmd("configure terminal")
-    s = @device.cmd("tacacs-server timeout #{timeout}")
-    s = @device.cmd("end")
-    # Flush the cache since we've modified the device
-    node.cache_flush
+    config("tacacs-server timeout #{timeout}")
     assert_equal(timeout, tacacs.timeout,
-                 "Error: Tacacs Server, timeout not configured")
+                 'Error: Tacacs Server, timeout not configured')
     tacacs.destroy
   end
 
   def test_tacacsserver_get_default_timeout
-    assert_equal(node.config_get_default("tacacs_server", "timeout"),
+    assert_equal(node.config_get_default('tacacs_server', 'timeout'),
                  TacacsServer.default_timeout,
-                 "Error: Tacacs Server, default timeout incorrect")
+                 'Error: Tacacs Server, default timeout incorrect')
   end
 
   def test_tacacsserver_set_timeout
@@ -199,14 +182,14 @@ class TestTacacsServer < CiscoTestCase
 
     tacacs = TacacsServer.new
     tacacs.timeout = timeout
-    line = get_tacacsserver_match_line("timeout\s.*")
+    line = assert_show_match(pattern: /tacacs-server timeout\s.*/,
+                             msg:     'Error: timeout not configured')
     # Extract timeout
     md = /tacacs-server\stimeout\s\d*/.match(line.to_s)
-    sh_run_timeout = md.to_s.split(" ").last.to_i
+    sh_run_timeout = md.to_s.split(' ').last.to_i
     # Need a better way to extract the timeout
-    refute_nil(line, "Error: Tacacs Server, timeout not configured")
     assert_equal(sh_run_timeout, tacacs.timeout,
-                 "Error: Tacacs Server, timeout value incorrect")
+                 'Error: Tacacs Server, timeout value incorrect')
 
     # Invalid case
     timeout = 80
@@ -218,25 +201,21 @@ class TestTacacsServer < CiscoTestCase
 
   def test_tacacsserver_get_deadtime
     tacacs = TacacsServer.new
-    deadtime = node.config_get_default("tacacs_server", "deadtime")
+    deadtime = node.config_get_default('tacacs_server', 'deadtime')
     assert_equal(deadtime, tacacs.deadtime,
-                 "Error: Tacacs Server, deadtime not default")
+                 'Error: Tacacs Server, deadtime not default')
 
     deadtime = 850
-    s = @device.cmd("configure terminal")
-    s = @device.cmd("tacacs-server deadtime #{deadtime}")
-    s = @device.cmd("end")
-    # Flush the cache since we've modified the device
-    node.cache_flush
+    config("tacacs-server deadtime #{deadtime}")
     assert_equal(deadtime, tacacs.deadtime,
-                 "Error: Tacacs Server, deadtime not configured")
+                 'Error: Tacacs Server, deadtime not configured')
     tacacs.destroy
   end
 
   def test_tacacsserver_get_default_deadtime
-    assert_equal(node.config_get_default("tacacs_server", "deadtime"),
+    assert_equal(node.config_get_default('tacacs_server', 'deadtime'),
                  TacacsServer.default_deadtime,
-                 "Error: Tacacs Server, default deadtime incorrect")
+                 'Error: Tacacs Server, default deadtime incorrect')
   end
 
   def test_tacacsserver_set_deadtime
@@ -244,13 +223,13 @@ class TestTacacsServer < CiscoTestCase
 
     tacacs = TacacsServer.new
     tacacs.deadtime = deadtime
-    line = get_tacacsserver_match_line("deadtime\s.*")
+    line = assert_show_match(pattern: /tacacs-server deadtime\s.*/,
+                             msg:     'Error: deadtime not configured')
     # Extract deadtime
     md = /tacacs-server\sdeadtime\s\d*/.match(line.to_s)
-    sh_run_deadtime = md.to_s.split(" ").last.to_i
-    refute_nil(line, "Error: Tacacs Server, deadtime not configured")
+    sh_run_deadtime = md.to_s.split(' ').last.to_i
     assert_equal(sh_run_deadtime, tacacs.deadtime,
-                 "Error: Tacacs Server, deadtime incorrect")
+                 'Error: Tacacs Server, deadtime incorrect')
     # Invalid case
     deadtime = 2450
     assert_raises(Cisco::CliError) do
@@ -260,60 +239,55 @@ class TestTacacsServer < CiscoTestCase
   end
 
   def test_tacacsserver_get_directed_request
-    s = @device.cmd("conf t ; feature tacacs ; tacacs-server directed-request ; end")
-    # Flush the cache since we've modified the device
-    node.cache_flush
+    config('feature tacacs', 'tacacs-server directed-request')
     tacacs = TacacsServer.new
     assert(tacacs.directed_request?,
-           "Error: Tacacs Server, directed-request not set")
+           'Error: Tacacs Server, directed-request not set')
 
-    s = @device.cmd("conf t ; no tacacs-server directed-request ; end")
-    node.cache_flush
+    config('no tacacs-server directed-request')
     refute(tacacs.directed_request?,
-           "Error: Tacacs Server, directed-request set")
+           'Error: Tacacs Server, directed-request set')
     tacacs.destroy
   end
 
   def test_tacacsserver_get_default_directed_request
-    assert_equal(node.config_get_default("tacacs_server", "directed_request"),
+    assert_equal(node.config_get_default('tacacs_server', 'directed_request'),
                  TacacsServer.default_directed_request,
-                 "Error: Tacacs Server, default directed-request incorrect")
+                 'Error: Tacacs Server, default directed-request incorrect')
   end
 
   def test_tacacsserver_set_directed_request
-    s = @device.cmd("conf t ; feature tacacs ; tacacs-server directed-request ; end")
+    config('feature tacacs', 'tacacs-server directed-request')
     state = true
     tacacs = TacacsServer.new
     tacacs.directed_request = state
-    line = get_tacacsserver_match_line("directed-request")
-    refute_nil(line, "Error: Tacacs Server, directed-request not configured")
+    assert_show_match(pattern: /tacacs-server directed-request/,
+                      msg:     'directed-request not configured')
     assert(tacacs.directed_request?,
-           "Error: Tacacs Server, directed-request not set")
+           'Error: Tacacs Server, directed-request not set')
 
     # Turn it off
-    s = @device.cmd("conf t ; no tacacs-server directed-request ; end")
-    node.cache_flush
+    config('no tacacs-server directed-request')
     refute(tacacs.directed_request?,
-           "Error: Tacacs Server, directed-request set")
+           'Error: Tacacs Server, directed-request set')
 
     # Turn it back on then go to default
-    s = @device.cmd("conf t ; no tacacs-server directed-request ; end")
-    state = node.config_get_default("tacacs_server", "directed_request")
+    config('no tacacs-server directed-request')
+    state = node.config_get_default('tacacs_server', 'directed_request')
     tacacs.directed_request = state
-    line = get_match_line("no tacacs-server directed-request")
-    refute_nil(line,
-               "Error: Tacacs Server, default directed-request not configured")
+    line = assert_show_match(pattern: /no tacacs-server directed-request/,
+                             msg:     'default directed-request not configed')
 
     # Extract the state of directed-request
-    sh_run_directed_request = line.to_s.split(" ").first
-    assert_equal("no", sh_run_directed_request,
-                 "Error: Tacacs Server, directed-request not unconfigured")
+    sh_run_directed_request = line.to_s.split(' ').first
+    assert_equal('no', sh_run_directed_request,
+                 'Error: Tacacs Server, directed-request not unconfigured')
 
     refute(tacacs.directed_request?,
-           "Error: Tacacs Server, directed-request set")
+           'Error: Tacacs Server, directed-request set')
 
     # Invalid case
-    state = "TEST"
+    state = 'TEST'
     assert_raises(TypeError) do
       tacacs.directed_request = state
     end
@@ -321,53 +295,46 @@ class TestTacacsServer < CiscoTestCase
   end
 
   def test_tacacsserver_get_source_interface
-    s = @device.cmd("configure terminal")
-    s = @device.cmd("no ip tacacs source-interface")
-    s = @device.cmd("end")
+    config('no ip tacacs source-interface')
     tacacs = TacacsServer.new
-    intf = node.config_get_default("tacacs_server", "source_interface")
+    intf = node.config_get_default('tacacs_server', 'source_interface')
     assert_equal(intf, tacacs.source_interface,
-                 "Error: Tacacs Server, source-interface set")
-
-    intf = "Ethernet1/1"
-    s = @device.cmd("configure terminal")
-    s = @device.cmd("ip tacacs source-interface #{intf}")
-    s = @device.cmd("end")
-    # Flush the cache since we've modified the device
-    node.cache_flush
+                 'Error: Tacacs Server, source-interface set')
+
+    intf = 'Ethernet1/1'
+    config("ip tacacs source-interface #{intf}")
     assert_equal(intf, tacacs.source_interface,
-                 "Error: Tacacs Server, source-interface not correct")
+                 'Error: Tacacs Server, source-interface not correct')
     tacacs.destroy
   end
 
   def test_tacacsserver_get_default_source_interface
-    assert_equal(node.config_get_default("tacacs_server", "source_interface"),
+    assert_equal(node.config_get_default('tacacs_server', 'source_interface'),
                  TacacsServer.default_source_interface,
-                 "Error: Tacacs Server, default source-interface incorrect")
+                 'Error: Tacacs Server, default source-interface incorrect')
   end
 
   def test_tacacsserver_set_source_interface
-    s = @device.cmd("conf t ; feature tacacs+ ; no ip tacacs source-int ; end")
-    node.cache_flush
-    intf = node.config_get_default("tacacs_server", "source_interface")
+    config('feature tacacs+', 'no ip tacacs source-int')
+    intf = node.config_get_default('tacacs_server', 'source_interface')
     tacacs = TacacsServer.new
     assert_equal(intf, tacacs.source_interface,
-                 "Error: Tacacs Server, source-interface set")
+                 'Error: Tacacs Server, source-interface set')
 
-    intf = "Ethernet1/1"
+    intf = 'Ethernet1/1'
     tacacs.source_interface = intf
-    line = get_match_line("ip tacacs source-interface #{intf}")
+    line = assert_show_match(pattern: /ip tacacs source-interface #{intf}/,
+                             msg:     'source-interface not configured')
     # Extract source-interface
-    sh_run_source_interface = line.to_s.split(" ").last
-    refute_nil(line, "Error: Tacacs Server, source-interface not configured")
+    sh_run_source_interface = line.to_s.split(' ').last
     assert_equal(sh_run_source_interface, tacacs.source_interface,
-                 "Error: Tacacs Server, source-interface not correct")
+                 'Error: Tacacs Server, source-interface not correct')
 
     # Now bring it back to default
-    intf = node.config_get_default("tacacs_server", "source_interface")
+    intf = node.config_get_default('tacacs_server', 'source_interface')
     tacacs.source_interface = intf
-    line = get_match_line("no ip tacacs source-interface")
-    refute_nil(line, "Error: Tacacs Server, source-interface not default")
+    assert_show_match(pattern: /no ip tacacs source-interface/,
+                      msg:     'source-interface not default')
 
     # Invalid case
     state = true
@@ -379,10 +346,8 @@ class TestTacacsServer < CiscoTestCase
 
   def test_tacacsserver_destroy
     tacacs = TacacsServer.new
-    line = get_tacacsserver_feature
-    refute_nil(line, "Error: Tacacs feature not set")
+    assert_tacacsserver_feature
     tacacs.destroy
-    line = get_tacacsserver_feature
-    assert_nil(line, "Error: Tacacs feature still present")
+    refute_tacacsserver_feature
   end
 end