cisco_node_utils 1.0.1 → 1.1.0

data/tests/test_vlan.rb

@@ -12,77 +12,71 @@
 # 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/vlan", __FILE__)
-require File.expand_path("../../lib/cisco_node_utils/interface", __FILE__)
+require_relative 'ciscotest'
+require_relative '../lib/cisco_node_utils/vlan'
+require_relative '../lib/cisco_node_utils/interface'
 
 include Cisco
 
+# TestVlan - Minitest for Vlan node utility
 class TestVlan < CiscoTestCase
   def interface_ethernet_default(ethernet_id)
-    s = @device.cmd("configure terminal")
-    s = @device.cmd("default interface ethernet #{ethernet_id}")
-    s = @device.cmd("end")
-    node.cache_flush
+    config("default interface ethernet #{ethernet_id}")
   end
 
   def test_vlan_collection_not_empty
     vlans = Vlan.vlans
-    assert_equal(false, vlans.empty?(), "VLAN collection is empty")
-    assert(vlans.key?("1"), "VLAN 1 does not exist")
+    assert_equal(false, vlans.empty?, 'VLAN collection is empty')
+    assert(vlans.key?('1'), 'VLAN 1 does not exist')
   end
 
   def test_vlan_create_invalid
-    e = assert_raises(CliError) do
-      v = Vlan.new(5000)
-    end
+    e = assert_raises(CliError) { Vlan.new(5000) }
     assert_match(/Invalid value.range/, e.message)
   end
 
   def test_vlan_create_invalid_non_numeric_vlan
-    e = assert_raises(ArgumentError) do
-      v = Vlan.new("fred")
-    end
+    e = assert_raises(ArgumentError) { Vlan.new('fred') }
     assert_match(/Invalid value.non-numeric/, e.message)
   end
 
   def test_vlan_create_and_destroy
     v = Vlan.new(1000)
     vlans = Vlan.vlans
-    assert(vlans.key?("1000"), "Error: failed to create vlan 1000")
+    assert(vlans.key?('1000'), 'Error: failed to create vlan 1000')
 
     v.destroy
     vlans = Vlan.vlans
-    refute(vlans.key?("1000"), "Error: failed to destroy vlan 1000")
+    refute(vlans.key?('1000'), 'Error: failed to destroy vlan 1000')
   end
 
   def test_vlan_name_default_1000
     v = Vlan.new(1000)
     assert_equal(v.default_vlan_name, v.vlan_name,
-                 "Error: Vlan name not initialized to default")
+                 'Error: Vlan name not initialized to default')
 
-    name = "Uplink-Chicago"
+    name = 'Uplink-Chicago'
     v.vlan_name = name
     assert_equal(name, v.vlan_name, "Error: Vlan name not updated to #{name}")
 
     v.vlan_name = v.default_vlan_name
     assert_equal(v.default_vlan_name, v.vlan_name,
-                 "Error: Vlan name not restored to default")
+                 'Error: Vlan name not restored to default')
     v.destroy
   end
 
   def test_vlan_name_default_40
     v = Vlan.new(40)
     assert_equal(v.default_vlan_name, v.vlan_name,
-                 "Error: Vlan name not initialized to default")
+                 'Error: Vlan name not initialized to default')
 
-    name = "Uplink-Chicago"
+    name = 'Uplink-Chicago'
     v.vlan_name = name
     assert_equal(name, v.vlan_name, "Error: Vlan name not updated to #{name}")
 
     v.vlan_name = v.default_vlan_name
     assert_equal(v.default_vlan_name, v.vlan_name,
-                 "Error: Vlan name not restored to default")
+                 'Error: Vlan name not restored to default')
     v.destroy
   end
 
@@ -104,16 +98,16 @@ class TestVlan < CiscoTestCase
 
   def test_vlan_name_zero_length
     v = Vlan.new(1000)
-    v.vlan_name = ""
-    assert("", v.vlan_name)
+    v.vlan_name = ''
+    assert('', v.vlan_name)
     v.destroy
   end
 
   def test_vlan_name_length_valid
     v = Vlan.new(1000)
-    alphabet = "abcdefghijklmnopqrstuvwxyz0123456789"
-    name = ""
-    1.upto(VLAN_NAME_SIZE - 1) { | i |
+    alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789'
+    name = ''
+    1.upto(VLAN_NAME_SIZE - 1) do |i|
       begin
         name += alphabet[i % alphabet.size, 1]
         # puts "n is #{name}"
@@ -122,19 +116,18 @@ class TestVlan < CiscoTestCase
           assert_equal(name, v.vlan_name)
         end
       end
-    }
+    end
     v.destroy
   end
 
   def test_vlan_name_too_long
     v = Vlan.new(1000)
-    name = "a" * VLAN_NAME_SIZE
-    assert_raises(RuntimeError, "vlan misconfig did not raise RuntimeError") do
+    name = 'a' * VLAN_NAME_SIZE
+    assert_raises(RuntimeError, 'vlan misconfig did not raise RuntimeError') do
       v.vlan_name = name
     end
-    ref = cmd_ref.lookup("vlan", "name")
-    assert(ref, "Error, reference not found for vlan name")
-    ref = nil
+    ref = cmd_ref.lookup('vlan', 'name')
+    assert(ref, 'Error, reference not found for vlan name')
     v.destroy
   end
 
@@ -146,10 +139,10 @@ class TestVlan < CiscoTestCase
     v.destroy
     # start test
     v1 = Vlan.new(1000)
-    v1.vlan_name = "test"
+    v1.vlan_name = 'test'
     v2 = Vlan.new(1001)
-    assert_raises(RuntimeError, "vlan misconfig did not raise RuntimeError") do
-      v2.vlan_name = "test"
+    assert_raises(RuntimeError, 'vlan misconfig did not raise RuntimeError') do
+      v2.vlan_name = 'test'
     end
     v1.destroy
     v2.destroy
@@ -157,14 +150,14 @@ class TestVlan < CiscoTestCase
 
   def test_vlan_state_extended
     v = Vlan.new(2000)
-    v.state = "suspend"
+    v.state = 'suspend'
     v.destroy
   end
 
   def test_vlan_state_invalid
     v = Vlan.new(1000)
     assert_raises(RuntimeError) do
-      v.state = "unknown"
+      v.state = 'unknown'
     end
     v.destroy
   end
@@ -172,42 +165,37 @@ class TestVlan < CiscoTestCase
   def test_vlan_state_valid
     states = %w(unknown active suspend)
     v = Vlan.new(1000)
-    states.each { | start |
-      states.each { | finish |
-        if start != "unknown" &&
-           finish != "unknown"
-          v.state = start
-          assert_equal(start, v.state, "start")
-          v.state = finish
-          assert_equal(finish, v.state, "finish")
-        end
-      }
-    }
+    states.each do |start|
+      states.each do |finish|
+        next if start == 'unknown' || finish == 'unknown'
+        v.state = start
+        assert_equal(start, v.state, 'start')
+        v.state = finish
+        assert_equal(finish, v.state, 'finish')
+      end
+    end
     v.destroy
   end
 
   def test_vlan_shutdown_extended
     v = Vlan.new(2000)
-    assert_raises(RuntimeError, "vlan misconfig did not raise RuntimeError") do
-      v.shutdown = "shutdown"
+    assert_raises(RuntimeError, 'vlan misconfig did not raise RuntimeError') do
+      v.shutdown = 'shutdown'
     end
     v.destroy
   end
 
   def test_vlan_shutdown_valid
-    shutdown_states = [
-      true,
-      false
-    ]
+    shutdown_states = [true, false]
     v = Vlan.new(1000)
-    shutdown_states.each { | start |
-      shutdown_states.each { | finish |
+    shutdown_states.each do |start|
+      shutdown_states.each do |finish|
         v.shutdown = start
-        assert_equal(start, v.shutdown, "start")
+        assert_equal(start, v.shutdown, 'start')
         v.shutdown = finish
-        assert_equal(finish, v.shutdown, "finish")
-      }
-    }
+        assert_equal(finish, v.shutdown, 'finish')
+      end
+    end
     v.destroy
   end
 
@@ -216,21 +204,21 @@ class TestVlan < CiscoTestCase
     interfaces = Interface.interfaces
     interfaces_added_to_vlan = []
     count = 3
-    interfaces.each { | name, interface |
-      if interface.name.match(/ethernet/) && count > 0
-        interfaces_added_to_vlan << name
-        interface.switchport_mode = :access
-        v.add_interface(interface)
-        count -= 1
-      end
-    }
+    interfaces.each do |name, interface|
+      next unless interface.name.match(%r{ethernet[0-9/]}) && count > 0
+      interfaces_added_to_vlan << name
+      interface.switchport_mode = :access
+      v.add_interface(interface)
+      count -= 1
+    end
+    assert_equal(0, count)
 
     interfaces = v.interfaces
-    interfaces.each { | name, interface |
+    interfaces.each do |name, interface|
       assert_includes(interfaces_added_to_vlan, name)
-      assert_equal(v.vlan_id, interface.access_vlan, "Interface.access_vlan")
+      assert_equal(v.vlan_id, interface.access_vlan, 'Interface.access_vlan')
       v.remove_interface(interface)
-    }
+    end
 
     interfaces = v.interfaces
     assert(interfaces.empty?)
@@ -241,9 +229,7 @@ class TestVlan < CiscoTestCase
     v = Vlan.new(1000)
     interface = Interface.new(interfaces[0])
     interface.switchport_mode = :disabled
-    assert_raises(RuntimeError) {
-      v.add_interface(interface)
-    }
+    assert_raises(RuntimeError) { v.add_interface(interface) }
     v.destroy
     interface_ethernet_default(interfaces_id[0])
   end
@@ -254,9 +240,7 @@ class TestVlan < CiscoTestCase
     interface.switchport_mode = :access
     v.add_interface(interface)
     interface.switchport_mode = :disabled
-    assert_raises(RuntimeError) {
-      v.remove_interface(interface)
-    }
+    assert_raises(RuntimeError) { v.remove_interface(interface) }
 
     v.destroy
     interface_ethernet_default(interfaces_id[0])

data/tests/test_vrf.rb

@@ -0,0 +1,92 @@
+# Copyright (c) 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/vrf'
+
+include Cisco
+
+# TestVrf - Minitest for Vrf node utility class
+class TestVrf < CiscoTestCase
+  VRF_NAME_SIZE = 33
+
+  def setup
+    super
+    vrfs = Vrf.vrfs
+    vrfs.each_value do |vrf|
+      next unless vrf.name =~ /^test_vrf/
+      config("no vrf context #{vrf.name}")
+    end
+  end
+
+  def test_vrf_collection_not_empty
+    vrfs = Vrf.vrfs
+    refute_empty(vrfs, 'VRF collection is empty')
+    assert(vrfs.key?('management'), 'VRF management does not exist')
+  end
+
+  def test_vrf_create_and_destroy
+    v = Vrf.new('test_vrf')
+    vrfs = Vrf.vrfs
+    assert(vrfs.key?('test_vrf'), 'Error: failed to create vrf test_vrf')
+
+    v.destroy
+    vrfs = Vrf.vrfs
+    refute(vrfs.key?('test_vrf'), 'Error: failed to destroy vrf test_vrf')
+  end
+
+  def test_vrf_name_type_invalid
+    assert_raises(TypeError, 'Wrong vrf name type did not raise type error') do
+      Vrf.new(1000)
+    end
+  end
+
+  def test_vrf_name_zero_length
+    assert_raises(Cisco::CliError, "Zero length name didn't raise CliError") do
+      Vrf.new('')
+    end
+  end
+
+  def test_vrf_name_too_long
+    name = 'a' * VRF_NAME_SIZE
+    assert_raises(Cisco::CliError,
+                  'vrf name misconfig did not raise CliError') do
+      Vrf.new(name)
+    end
+  end
+
+  def test_vrf_shutdown_valid
+    shutdown_states = [true, false]
+    v = Vrf.new('test_vrf_shutdown')
+    shutdown_states.each do |start|
+      shutdown_states.each do |finish|
+        v.shutdown = start
+        assert_equal(start, v.shutdown, 'start')
+        v.shutdown = finish
+        assert_equal(finish, v.shutdown, 'finish')
+      end
+    end
+    v.destroy
+  end
+
+  def test_vrf_description
+    vrf = Vrf.new('test_vrf_description')
+    vrf.description = 'tested by minitest'
+    assert_equal('tested by minitest', vrf.description,
+                 'failed to set description')
+    vrf.description = ' '
+    assert_empty(vrf.description, 'failed to remove description')
+    vrf.destroy
+  end
+end

data/tests/test_vtp.rb

@@ -12,9 +12,10 @@
 # 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/vtp", __FILE__)
+require_relative 'ciscotest'
+require_relative '../lib/cisco_node_utils/vtp'
 
+# TestVtp - Minitest for Vtp node utility class
 class TestVtp < CiscoTestCase
   def setup
     super
@@ -29,8 +30,7 @@ class TestVtp < CiscoTestCase
   def no_feature_vtp
     # VTP will raise an error if the domain is configured twice so we need to
     # turn the feature off for a clean test.
-    @device.cmd("conf t ; no feature vtp ; end")
-    node.cache_flush()
+    config('no feature vtp')
   end
 
   def vtp_domain(domain)
@@ -45,73 +45,66 @@ class TestVtp < CiscoTestCase
     assert_equal(vtp.default_password, vtp.password)
     assert_equal(vtp.default_filename, vtp.filename)
     assert_equal(vtp.default_version, vtp.version)
-    refute(Vtp.enabled, "VTP feature was unexpectedly enabled?")
+    refute(Vtp.enabled, 'VTP feature was unexpectedly enabled?')
   end
 
   def test_vtp_enabled_but_no_domain
     vtp = Vtp.new(false)
-    @device.cmd("conf t ; feature vtp ; end")
-    node.cache_flush()
+    config('feature vtp')
     assert(Vtp.enabled)
     assert_empty(vtp.domain)
     assert_equal(vtp.default_password, vtp.password)
     assert_equal(vtp.default_filename, vtp.filename)
     assert_equal(vtp.default_version, vtp.version)
     # Can set these without setting domain
-    vtp.filename = "bootflash:/foo.bar"
-    assert_equal("bootflash:/foo.bar", vtp.filename)
+    vtp.filename = 'bootflash:/foo.bar'
+    assert_equal('bootflash:/foo.bar', vtp.filename)
     vtp.version = 1
     assert_equal(1, vtp.version)
     # Can't set any of the below without setting a domain first
     assert_raises(RuntimeError) do
-      vtp.password = "hello"
+      vtp.password = 'hello'
     end
   end
 
   def test_vtp_domain_enable_disable
     assert_empty(Vtp.domain)
-    vtp = vtp_domain("enable")
-    assert_equal("enable", Vtp.domain)
+    vtp = vtp_domain('enable')
+    assert_equal('enable', Vtp.domain)
     vtp.destroy
     assert_empty(Vtp.domain)
   end
 
   def test_vtp_create_valid
-    vtp = vtp_domain("accounting")
+    vtp_domain('accounting')
     s = @device.cmd("show run vtp | incl '^vtp domain'")
     assert_match(/^vtp domain accounting/, s,
-                 "Error: failed to create vtp domain")
+                 'Error: failed to create vtp domain')
   end
 
   def test_vtp_domain_name_change
-    vtp = vtp_domain("accounting")
-    vtp_new = vtp_domain("uplink")
-    assert_equal("uplink", vtp.domain,
-                 "Error: vtp domain name incorrect")
+    vtp = vtp_domain('accounting')
+    vtp_domain('uplink')
+    assert_equal('uplink', vtp.domain,
+                 'Error: vtp domain name incorrect')
   end
 
   def test_vtp_create_preconfig_no_change
-    s = @device.cmd("configure terminal")
-    s = @device.cmd("feature vtp")
-    s = @device.cmd("vtp domain accounting")
-    s = @device.cmd("end")
+    config('feature vtp', 'vtp domain accounting')
 
-    # Flush the cache since we've modified the device
-    node.cache_flush()
-
-    vtp = vtp_domain("accounting")
-    assert_equal("accounting", vtp.domain,
-                 "Error: vtp domain wrong")
+    vtp = vtp_domain('accounting')
+    assert_equal('accounting', vtp.domain,
+                 'Error: vtp domain wrong')
   end
 
   def test_vtp_create_double
-    vtp = vtp_domain("accounting")
-    vtp_new = vtp_domain("accounting")
+    vtp = vtp_domain('accounting')
+    vtp_new = vtp_domain('accounting')
 
-    assert_equal("accounting", vtp.domain,
-                 "Error: vtp domain wrong")
-    assert_equal("accounting", vtp_new.domain,
-                 "Error: vtp_new domain wrong")
+    assert_equal('accounting', vtp.domain,
+                 'Error: vtp domain wrong')
+    assert_equal('accounting', vtp_new.domain,
+                 'Error: vtp_new domain wrong')
   end
 
   def test_vtp_create_domain_invalid
@@ -128,171 +121,160 @@ class TestVtp < CiscoTestCase
 
   def test_vtp_create_domain_empty
     assert_raises(ArgumentError) do
-      vtp_domain("")
+      vtp_domain('')
     end
   end
 
   def test_vtp_assignment
-    vtp = vtp_domain("accounting")
-    vtp.password = "copy_test"
-    assert_equal("copy_test", vtp.password,
-                 "Error: vtp password not set")
+    vtp = vtp_domain('accounting')
+    vtp.password = 'copy_test'
+    assert_equal('copy_test', vtp.password,
+                 'Error: vtp password not set')
     vtp_extra = vtp
-    assert_equal("copy_test", vtp_extra.password,
-                 "Error: vtp password not set")
+    assert_equal('copy_test', vtp_extra.password,
+                 'Error: vtp password not set')
   end
 
   def test_vtp_domain_get
-    vtp = vtp_domain("accounting")
-    assert_equal("accounting", vtp.domain,
-                 "Error: vtp domain incorrect")
+    vtp = vtp_domain('accounting')
+    assert_equal('accounting', vtp.domain,
+                 'Error: vtp domain incorrect')
   end
 
   def test_vtp_password_nil
-    vtp = vtp_domain("accounting")
+    vtp = vtp_domain('accounting')
     assert_raises(TypeError) do
       vtp.password = nil
     end
   end
 
   def test_vtp_password_default
-    vtp = vtp_domain("accounting")
-    vtp.password = "test_me"
-    assert_equal("test_me", vtp.password,
-                 "Error: vtp password not correct")
+    vtp = vtp_domain('accounting')
+    vtp.password = 'test_me'
+    assert_equal('test_me', vtp.password,
+                 'Error: vtp password not correct')
 
     vtp.password = vtp.default_password
-    assert_equal(node.config_get_default("vtp", "password"), vtp.password,
-                 "Error: vtp password not correct")
+    assert_equal(node.config_get_default('vtp', 'password'), vtp.password,
+                 'Error: vtp password not correct')
   end
 
   def test_vtp_password_zero_length
-    vtp = vtp_domain("accounting")
-    vtp.password = ""
-    assert_equal("", vtp.password,
-                 "Error: vtp password not empty")
+    vtp = vtp_domain('accounting')
+    vtp.password = ''
+    assert_equal('', vtp.password,
+                 'Error: vtp password not empty')
   end
 
   def test_vtp_password_get
-    vtp = vtp_domain("accounting")
+    vtp = vtp_domain('accounting')
 
-    s = @device.cmd("configure terminal")
-    s = @device.cmd("vtp password cisco123")
-    s = @device.cmd("end")
-    # Flush the cache since we've modified the device
-    node.cache_flush()
-    assert_equal("cisco123", vtp.password,
-                 "Error: vtp password not correct")
+    config('vtp password cisco123')
+    assert_equal('cisco123', vtp.password,
+                 'Error: vtp password not correct')
   end
 
   def test_vtp_password_get_not_set
-    vtp = vtp_domain("accounting")
-    assert_equal("", vtp.password,
-                 "Error: vtp password not empty")
+    vtp = vtp_domain('accounting')
+    assert_equal('', vtp.password,
+                 'Error: vtp password not empty')
   end
 
   def test_vtp_password_clear
-    vtp = vtp_domain("accounting")
-    vtp.password = "cisco123"
-    assert_equal("cisco123", vtp.password,
-                 "Error: vtp password not set")
+    vtp = vtp_domain('accounting')
+    vtp.password = 'cisco123'
+    assert_equal('cisco123', vtp.password,
+                 'Error: vtp password not set')
 
-    vtp.password = ""
-    assert_equal("", vtp.password,
-                 "Error: vtp default password not set")
+    vtp.password = ''
+    assert_equal('', vtp.password,
+                 'Error: vtp default password not set')
   end
 
   def test_vtp_password_valid
-    vtp = vtp_domain("accounting")
-    alphabet = "abcdefghijklmnopqrstuvwxyz0123456789"
-    password = ""
-    1.upto(Vtp::MAX_VTP_PASSWORD_SIZE - 1) { | i |
-      begin
-        password += alphabet[i % alphabet.size, 1]
-        vtp.password = password
-        assert_equal(password.rstrip, vtp.password,
-                     "Error: vtp password not set")
-      end
-    }
+    vtp = vtp_domain('accounting')
+    alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789'
+    password = ''
+    1.upto(Vtp::MAX_VTP_PASSWORD_SIZE - 1) do |i|
+      password += alphabet[i % alphabet.size, 1]
+      vtp.password = password
+      assert_equal(password.rstrip, vtp.password,
+                   'Error: vtp password not set')
+    end
   end
 
   def test_vtp_password_too_long
-    vtp = vtp_domain("accounting")
-    password = "a"
-    Vtp::MAX_VTP_PASSWORD_SIZE.times {
-      password += "a"
-    }
-    assert_raises(ArgumentError) {
-      vtp.password = password
-    }
+    vtp = vtp_domain('accounting')
+    password = 'a' * (Vtp::MAX_VTP_PASSWORD_SIZE + 1)
+    assert_raises(ArgumentError) { vtp.password = password }
   end
 
   def test_vtp_password_special_characters
-    vtp = vtp_domain("password")
+    vtp = vtp_domain('password')
     vtp.password = 'hello!//\\#%$x'
     assert_equal('hello!//\\#%$x', vtp.password)
   end
 
   def test_vtp_filename_nil
-    vtp = vtp_domain("accounting")
+    vtp = vtp_domain('accounting')
     assert_raises(TypeError) do
       vtp.filename = nil
     end
   end
 
   def test_vtp_filename_valid
-    vtp = vtp_domain("accounting")
-    vtp.filename = "bootflash:/test.dat"
-    assert_equal("bootflash:/test.dat", vtp.filename,
-                 "Error: vtp file content wrong")
+    vtp = vtp_domain('accounting')
+    vtp.filename = 'bootflash:/test.dat'
+    assert_equal('bootflash:/test.dat', vtp.filename,
+                 'Error: vtp file content wrong')
   end
 
   def test_vtp_filename_zero_length
-    vtp = vtp_domain("accounting")
+    vtp = vtp_domain('accounting')
     vtp.filename = vtp.default_filename
-    assert_equal(node.config_get_default("vtp", "filename"), vtp.filename,
-                 "Error: vtp file content wrong")
+    assert_equal(node.config_get_default('vtp', 'filename'), vtp.filename,
+                 'Error: vtp file content wrong')
 
     # send in 'no' to remove the config. That will cause the default
     # to get reapplied.
-    vtp.filename = ""
-    assert_equal(node.config_get_default("vtp", "filename"), vtp.filename,
-                 "Error: vtp file content wrong")
+    vtp.filename = ''
+    assert_equal(node.config_get_default('vtp', 'filename'), vtp.filename,
+                 'Error: vtp file content wrong')
   end
 
   def test_vtp_filename_auto_enable
     vtp = Vtp.new(false)
-    refute(Vtp.enabled, "VTP should not be enabled")
-    vtp.filename = "bootflash:/foo.bar"
+    refute(Vtp.enabled, 'VTP should not be enabled')
+    vtp.filename = 'bootflash:/foo.bar'
     assert(Vtp.enabled)
-    assert_equal("bootflash:/foo.bar", vtp.filename)
+    assert_equal('bootflash:/foo.bar', vtp.filename)
   end
 
   def test_vtp_version_valid
-    vtp = vtp_domain("accounting")
+    vtp = vtp_domain('accounting')
     vtp.version = vtp.default_version
-    assert_equal(node.config_get_default("vtp", "version"), vtp.version,
-                 "Error: vtp version not default")
+    assert_equal(node.config_get_default('vtp', 'version'), vtp.version,
+                 'Error: vtp version not default')
   end
 
   def test_vtp_version3_valid
-    vtp = vtp_domain("accounting")
+    vtp = vtp_domain('accounting')
 
-    ref = cmd_ref.lookup("vtp", "version")
-    assert(ref, "Error, reference not found for vtp version3")
+    ref = cmd_ref.lookup('vtp', 'version')
+    assert(ref, 'Error, reference not found for vtp version3')
 
-    assert_result(ref.test_config_result(3), "Error: vtp version3 error") {
+    assert_result(ref.test_config_result(3), 'Error: vtp version3 error') do
       vtp.version = 3
       vtp.version
-    }
-
-    ref = nil
+    end
   end
 
   # Decides whether to check for a raised Exception or an equal value.
   def assert_result(expected_result, err_msg, &block)
     if /Error/ =~ expected_result.to_s
-      expected_result = eval(expected_result) if expected_result.is_a?(String)
+      if expected_result.is_a?(String)
+        expected_result = Object.const_get(expected_result)
+      end
       assert_raises(expected_result, &block)
     else
       value = block.call
@@ -301,25 +283,25 @@ class TestVtp < CiscoTestCase
   end
 
   def test_vtp_version_invalid
-    vtp = vtp_domain("accounting")
+    vtp = vtp_domain('accounting')
     assert_raises(Cisco::CliError) do
       vtp.version = 34
     end
   end
 
   def test_vtp_version_default
-    vtp = vtp_domain("accounting")
+    vtp = vtp_domain('accounting')
     vtp.version = 2
     assert_equal(2, vtp.version,
-                 "Error: vtp version not correct")
+                 'Error: vtp version not correct')
     vtp.version = vtp.default_version
-    assert_equal(node.config_get_default("vtp", "version"), vtp.version,
-                 "Error: vtp version not default")
+    assert_equal(node.config_get_default('vtp', 'version'), vtp.version,
+                 'Error: vtp version not default')
   end
 
   def test_vtp_version_auto_enable
     vtp = Vtp.new(false)
-    refute(Vtp.enabled, "VTP should not be enabled")
+    refute(Vtp.enabled, 'VTP should not be enabled')
     vtp.version = 1
     assert(Vtp.enabled)
     assert_equal(1, vtp.version)
@@ -327,9 +309,9 @@ class TestVtp < CiscoTestCase
 
   def test_vtp_feature_enable_disable
     Vtp.new.enable
-    assert(Vtp.enabled, "Error: vtp is not enabled")
+    assert(Vtp.enabled, 'Error: vtp is not enabled')
 
     Vtp.new.destroy
-    refute(Vtp.enabled, "Error: vtp is not disabled")
+    refute(Vtp.enabled, 'Error: vtp is not disabled')
   end
 end