cisco_node_utils 1.3.0 → 1.4.0

data/tests/test_bfd_global.rb

@@ -0,0 +1,278 @@
+# Copyright (c) 2016 Cisco and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative 'ciscotest'
+require_relative '../lib/cisco_node_utils/bfd_global'
+
+include Cisco
+# TestBfdGlobal - Minitest for general functionality
+# of the BfdGlobal class.
+class TestBfdGlobal < CiscoTestCase
+  @skip_unless_supported = 'bfd_global'
+  # Tests
+
+  def setup
+    super
+    config 'no feature bfd'
+  end
+
+  def teardown
+    config 'no feature bfd'
+    super
+  end
+
+  def test_create_destroy
+    # create
+    bg = BfdGlobal.new
+    assert_equal(true, Feature.bfd_enabled?)
+
+    # destroy
+    bg.destroy
+    [:interval,
+     :ipv4_interval,
+     :ipv6_interval,
+     :fabricpath_interval,
+     :echo_interface,
+     :echo_rx_interval,
+     :ipv4_echo_rx_interval,
+     :ipv6_echo_rx_interval,
+     :fabricpath_vlan,
+     :slow_timer,
+     :ipv4_slow_timer,
+     :ipv6_slow_timer,
+     :fabricpath_slow_timer,
+     :startup_timer,
+    ].each do |prop|
+      assert_equal(bg.send("default_#{prop}"), bg.send("#{prop}")) if
+        bg.send("#{prop}")
+    end
+  end
+
+  def test_echo_interface
+    bg = BfdGlobal.new
+    config 'interface loopback 10'
+    default = bg.default_echo_interface
+    assert_equal(default, bg.echo_interface)
+    bg.echo_interface = 'loopback10'
+    assert_equal('loopback10', bg.echo_interface)
+    bg.echo_interface = default
+    assert_equal(default, bg.echo_interface)
+    config 'no interface loopback 10'
+  end
+
+  def test_fabricpath_vlan
+    bg = BfdGlobal.new
+    if validate_property_excluded?('bfd_global', 'fabricpath_vlan')
+      assert_nil(bg.fabricpath_vlan)
+      assert_raises(Cisco::UnsupportedError) do
+        bg.fabricpath_vlan = 100
+      end
+      return
+    end
+    assert_equal(bg.default_fabricpath_vlan, bg.fabricpath_vlan)
+    bg.fabricpath_vlan = 100
+    assert_equal(100, bg.fabricpath_vlan)
+    bg.fabricpath_vlan = bg.default_fabricpath_vlan
+    assert_equal(bg.default_fabricpath_vlan, bg.fabricpath_vlan)
+  end
+
+  def test_startup_timer
+    bg = BfdGlobal.new
+    if validate_property_excluded?('bfd_global', 'startup_timer')
+      assert_nil(bg.startup_timer)
+      assert_raises(Cisco::UnsupportedError) do
+        bg.startup_timer = 25
+      end
+      return
+    end
+    assert_equal(bg.default_startup_timer, bg.startup_timer)
+    bg.startup_timer = 25
+    assert_equal(25, bg.startup_timer)
+    bg.startup_timer = bg.default_startup_timer
+    assert_equal(bg.default_startup_timer, bg.startup_timer)
+  end
+
+  def test_echo_rx_interval
+    bg = BfdGlobal.new
+    if validate_property_excluded?('bfd_global', 'echo_rx_interval')
+      assert_nil(bg.echo_rx_interval)
+      assert_raises(Cisco::UnsupportedError) do
+        bg.echo_rx_interval = 300
+      end
+      return
+    end
+    assert_equal(bg.default_echo_rx_interval, bg.echo_rx_interval)
+    bg.echo_rx_interval = 300
+    assert_equal(300, bg.echo_rx_interval)
+    bg.echo_rx_interval = bg.default_echo_rx_interval
+    assert_equal(bg.default_echo_rx_interval, bg.echo_rx_interval)
+  end
+
+  def test_ipv4_echo_rx_interval
+    bg = BfdGlobal.new
+    if validate_property_excluded?('bfd_global', 'ipv4_echo_rx_interval')
+      assert_nil(bg.ipv4_echo_rx_interval)
+      assert_raises(Cisco::UnsupportedError) do
+        bg.ipv4_echo_rx_interval = 100
+      end
+      return
+    end
+    assert_equal(bg.default_ipv4_echo_rx_interval, bg.ipv4_echo_rx_interval)
+    bg.ipv4_echo_rx_interval = 100
+    assert_equal(100, bg.ipv4_echo_rx_interval)
+    bg.ipv4_echo_rx_interval = bg.default_ipv4_echo_rx_interval
+    assert_equal(bg.default_ipv4_echo_rx_interval, bg.ipv4_echo_rx_interval)
+  end
+
+  def test_ipv6_echo_rx_interval
+    bg = BfdGlobal.new
+    if validate_property_excluded?('bfd_global', 'ipv6_echo_rx_interval')
+      assert_nil(bg.ipv6_echo_rx_interval)
+      assert_raises(Cisco::UnsupportedError) do
+        bg.ipv6_echo_rx_interval = 100
+      end
+      return
+    end
+    assert_equal(bg.default_ipv6_echo_rx_interval, bg.ipv6_echo_rx_interval)
+    bg.ipv6_echo_rx_interval = 100
+    assert_equal(100, bg.ipv6_echo_rx_interval)
+    bg.ipv6_echo_rx_interval = bg.default_ipv6_echo_rx_interval
+    assert_equal(bg.default_ipv6_echo_rx_interval, bg.ipv6_echo_rx_interval)
+  end
+
+  def test_slow_timer
+    bg = BfdGlobal.new
+    assert_equal(bg.default_slow_timer, bg.slow_timer)
+    bg.slow_timer = 5000
+    assert_equal(5000, bg.slow_timer)
+    bg.slow_timer = bg.default_slow_timer
+    assert_equal(bg.default_slow_timer, bg.slow_timer)
+  end
+
+  def test_ipv4_slow_timer
+    bg = BfdGlobal.new
+    if validate_property_excluded?('bfd_global', 'ipv4_slow_timer')
+      assert_nil(bg.ipv4_slow_timer)
+      assert_raises(Cisco::UnsupportedError) do
+        bg.ipv4_slow_timer = 10_000
+      end
+      return
+    end
+    assert_equal(bg.default_ipv4_slow_timer, bg.ipv4_slow_timer)
+    bg.ipv4_slow_timer = 10_000
+    assert_equal(10_000, bg.ipv4_slow_timer)
+    bg.ipv4_slow_timer = bg.default_ipv4_slow_timer
+    assert_equal(bg.default_ipv4_slow_timer, bg.ipv4_slow_timer)
+  end
+
+  def test_ipv6_slow_timer
+    bg = BfdGlobal.new
+    if validate_property_excluded?('bfd_global', 'ipv6_slow_timer')
+      assert_nil(bg.ipv6_slow_timer)
+      assert_raises(Cisco::UnsupportedError) do
+        bg.ipv6_slow_timer = 25_000
+      end
+      return
+    end
+    assert_equal(bg.default_ipv6_slow_timer, bg.ipv6_slow_timer)
+    bg.ipv6_slow_timer = 25_000
+    assert_equal(25_000, bg.ipv6_slow_timer)
+    bg.ipv6_slow_timer = bg.default_ipv6_slow_timer
+    assert_equal(bg.default_ipv6_slow_timer, bg.ipv6_slow_timer)
+  end
+
+  def test_fabricpath_slow_timer
+    bg = BfdGlobal.new
+    if validate_property_excluded?('bfd_global', 'fabricpath_slow_timer')
+      assert_nil(bg.fabricpath_slow_timer)
+      assert_raises(Cisco::UnsupportedError) do
+        bg.fabricpath_slow_timer = 15_000
+      end
+      return
+    end
+    assert_equal(bg.default_fabricpath_slow_timer, bg.fabricpath_slow_timer)
+    bg.fabricpath_slow_timer = 15_000
+    assert_equal(15_000, bg.fabricpath_slow_timer)
+    bg.fabricpath_slow_timer = bg.default_fabricpath_slow_timer
+    assert_equal(bg.default_fabricpath_slow_timer, bg.fabricpath_slow_timer)
+  end
+
+  def test_interval
+    bg = BfdGlobal.new
+    arr = %w(100 100 25)
+    if validate_property_excluded?('bfd_global', 'interval')
+      assert_nil(bg.interval)
+      assert_raises(Cisco::UnsupportedError) do
+        bg.interval = arr
+      end
+      return
+    end
+    assert_equal(bg.default_interval, bg.interval)
+    bg.interval = arr
+    assert_equal(arr, bg.interval)
+    bg.interval = bg.default_interval
+    assert_equal(bg.default_interval, bg.interval)
+  end
+
+  def test_ipv4_interval
+    bg = BfdGlobal.new
+    arr = %w(200 200 50)
+    if validate_property_excluded?('bfd_global', 'ipv4_interval')
+      assert_nil(bg.ipv4_interval)
+      assert_raises(Cisco::UnsupportedError) do
+        bg.ipv4_interval = arr
+      end
+      return
+    end
+    assert_equal(bg.default_ipv4_interval, bg.ipv4_interval)
+    bg.ipv4_interval = arr
+    assert_equal(arr, bg.ipv4_interval)
+    bg.ipv4_interval = bg.default_ipv4_interval
+    assert_equal(bg.default_ipv4_interval, bg.ipv4_interval)
+  end
+
+  def test_ipv6_interval
+    bg = BfdGlobal.new
+    arr = %w(500 500 30)
+    if validate_property_excluded?('bfd_global', 'ipv6_interval')
+      assert_nil(bg.ipv6_interval)
+      assert_raises(Cisco::UnsupportedError) do
+        bg.ipv6_interval = arr
+      end
+      return
+    end
+    assert_equal(bg.default_ipv6_interval, bg.ipv6_interval)
+    bg.ipv6_interval = arr
+    assert_equal(arr, bg.ipv6_interval)
+    bg.ipv6_interval = bg.default_ipv6_interval
+    assert_equal(bg.default_ipv6_interval, bg.ipv6_interval)
+  end
+
+  def test_fabricpath_interval
+    bg = BfdGlobal.new
+    arr = %w(750 350 45)
+    if validate_property_excluded?('bfd_global', 'fabricpath_interval')
+      assert_nil(bg.fabricpath_interval)
+      assert_raises(Cisco::UnsupportedError) do
+        bg.fabricpath_interval = arr
+      end
+      return
+    end
+    assert_equal(bg.default_fabricpath_interval, bg.fabricpath_interval)
+    bg.fabricpath_interval = arr
+    assert_equal(arr, bg.fabricpath_interval)
+    bg.fabricpath_interval = bg.default_fabricpath_interval
+    assert_equal(bg.default_fabricpath_interval, bg.fabricpath_interval)
+  end
+end

data/tests/test_bgp_neighbor.rb

@@ -265,6 +265,26 @@ class TestBgpNeighbor < CiscoTestCase
     end
   end
 
+  def test_bfd
+    %w(default test_vrf).each do |vrf|
+      neighbor = create_neighbor(vrf)
+      if validate_property_excluded?('bgp_neighbor', 'bfd')
+        assert_nil(neighbor.bfd)
+        assert_nil(neighbor.default_bfd)
+        assert_raises(Cisco::UnsupportedError) do
+          neighbor.bfd = true
+        end
+      else
+        check = [false, true, neighbor.default_bfd]
+        check.each do |value|
+          neighbor.bfd = value
+          assert_equal(value, neighbor.bfd)
+        end
+      end
+      neighbor.destroy
+    end
+  end
+
   def test_ebgp_multihop
     %w(default test_vrf).each do |vrf|
       neighbor = create_neighbor(vrf)

data/tests/test_bridge_domain_vni.rb

@@ -24,7 +24,6 @@ class TestBridgeDomainVNI < CiscoTestCase
 
   def cleanup
     remove_all_vlans
-    remove_all_bridge_domains
     config_no_warn('no feature vni')
     BridgeDomainVNI.range_bds.each do |_bd, obj|
       obj.destroy
@@ -33,21 +32,18 @@ class TestBridgeDomainVNI < CiscoTestCase
 
   def setup
     super
+    vdc_limit_f3_no_intf_needed(:set)
     cleanup unless @@cleaned
     @@cleaned = true # rubocop:disable Style/ClassVars
-    mt_full_interface?
-    v = Vdc.new('default')
-    v.limit_resource_module_type = 'f3' unless
-      v.limit_resource_module_type == 'f3'
   end
 
   def teardown
     cleanup
+    vdc_limit_f3_no_intf_needed(:clear) if first_or_last_teardown
     super
   end
 
   def test_single_bd_member_vni
-    mt_full_interface?
     bd = BridgeDomainVNI.new('100')
     assert_equal(bd.default_member_vni, bd.member_vni,
                  'Error: Bridge-Domain is mapped to different vnis')
@@ -65,7 +61,6 @@ class TestBridgeDomainVNI < CiscoTestCase
   end
 
   def test_multiple_bd_member_vni
-    mt_full_interface?
     bd = BridgeDomainVNI.new('100-110, 150, 170-171 ')
     assert_equal(bd.default_member_vni, bd.member_vni,
                  'Error: Bridge-Domain is mapped to different vnis')
@@ -83,7 +78,6 @@ class TestBridgeDomainVNI < CiscoTestCase
   end
 
   def test_member_vni_empty_assign
-    mt_full_interface?
     bd = BridgeDomainVNI.new(100)
     bd.member_vni = ''
     assert_equal(bd.default_member_vni, bd.member_vni,
@@ -92,7 +86,6 @@ class TestBridgeDomainVNI < CiscoTestCase
   end
 
   def test_overwrite_bd_member_vni
-    mt_full_interface?
     bd = BridgeDomainVNI.new('100-110')
     assert_equal(bd.default_member_vni, bd.member_vni,
                  'Error: Bridge-Domain is mapped to different vnis')

data/tests/test_cmn_utils.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+# cisco_cmn_utils Unit Tests
+#
+# Chris Van Heuveln, May, 2016
+#
+# Copyright (c) 2016 Cisco and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative 'ciscotest'
+require_relative '../lib/cisco_node_utils/cisco_cmn_utils'
+
+# Test utility methods in cisco_cmn_utils
+class TestCmnUtils < CiscoTestCase
+  #
+  # TBD: Add tests for *all* methods in cisco_cmn_utils
+  #
+  def test_dash_range_to_ruby_range
+    expected = [2..5, 9..9, 4..6]
+
+    str_input = '2-5, 9, 4-6'
+    assert_equal(expected, Utils.dash_range_to_ruby_range(str_input))
+
+    arr_input = ['2-5', '9', '4-6']
+    assert_equal(expected, Utils.dash_range_to_ruby_range(arr_input))
+  end
+
+  def test_ruby_range_to_dash_range
+    str_expected = '2-5, 9, 4-6'
+    arr_expected = ['2-5', '9', '4-6']
+
+    input1 = [2..5, 9..9, 4..6]
+    input2 = input1.clone
+    assert_equal(str_expected, Utils.ruby_range_to_dash_range(input1, :string))
+    assert_equal(arr_expected, Utils.ruby_range_to_dash_range(input2, :array))
+  end
+
+  def test_dash_range_to_elements
+    expected = %w(2 3 4 5 6 9)
+
+    str_input = '2-5, 9, 4-6'
+    str_arr_input = ['2-5, 9, 4-6']
+    arr_input = str_input.split(', ')
+
+    assert_equal(expected, Utils.dash_range_to_elements(str_input))
+    assert_equal(expected, Utils.dash_range_to_elements(str_arr_input))
+    assert_equal(expected, Utils.dash_range_to_elements(arr_input))
+  end
+
+  def test_merge_range
+    expected = [2..6, 9..9]
+    input = [2..5, 9..9, 4..6]
+    assert_equal(expected, Utils.merge_range(input))
+  end
+
+  def test_normalize_range_array
+    expected = ['2-6', '9']
+
+    str_input = '2-5, 9, 4-6'
+    str_arr_input = ['2-5, 9, 4-6']
+    arr_input = str_input.split(', ')
+    assert_equal(expected, Utils.normalize_range_array(str_input))
+    assert_equal(expected, Utils.normalize_range_array(str_arr_input))
+    assert_equal(expected, Utils.normalize_range_array(arr_input))
+  end
+end

data/tests/test_dhcp_relay_global.rb

@@ -0,0 +1,284 @@
+# Copyright (c) 2013-2016 Cisco and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative 'ciscotest'
+require_relative '../lib/cisco_node_utils/dhcp_relay_global'
+
+include Cisco
+# TestDhcpRelayGlobal - Minitest for general functionality
+# of the DhcpRelayGlobal class.
+class TestDhcpRelayGlobal < CiscoTestCase
+  @skip_unless_supported = 'dhcp_relay_global'
+  DEFAULT_NAME = 'default'
+
+  # Tests
+
+  def setup
+    super
+    config_no_warn('no feature dhcp')
+  end
+
+  def teardown
+    config_no_warn('no feature dhcp') if first_or_last_teardown
+    super
+  end
+
+  def create_dhcp_relay_global
+    DhcpRelayGlobal.new
+  end
+
+  def test_collection_empty
+    drg = DhcpRelayGlobal.globals
+    assert_empty(drg)
+  end
+
+  def test_destroy
+    drg = create_dhcp_relay_global
+    assert_equal(true, Feature.dhcp_enabled?)
+
+    drg.destroy
+    [:ipv4_information_option,
+     :ipv4_information_option_trust,
+     :ipv4_information_option_vpn,
+     :ipv4_information_trust_all,
+     :ipv4_relay,
+     :ipv4_smart_relay,
+     :ipv4_src_addr_hsrp,
+     :ipv4_src_intf,
+     :ipv4_sub_option_circuit_id_custom,
+     :ipv4_sub_option_circuit_id_string,
+     :ipv4_sub_option_cisco,
+     :ipv6_option_cisco,
+     :ipv6_option_vpn,
+     :ipv6_relay,
+     :ipv6_src_intf,
+    ].each do |prop|
+      assert_equal(drg.send("default_#{prop}"), drg.send("#{prop}")) if
+        drg.send("#{prop}")
+    end
+  end
+
+  def test_ipv4_information_option
+    drg = create_dhcp_relay_global
+    assert_equal(drg.default_ipv4_information_option, drg.ipv4_information_option)
+    drg.ipv4_information_option = true
+    assert_equal(true, drg.ipv4_information_option)
+    drg.ipv4_information_option = drg.default_ipv4_information_option
+    assert_equal(drg.default_ipv4_information_option, drg.ipv4_information_option)
+  end
+
+  def test_ipv4_information_option_trust
+    drg = create_dhcp_relay_global
+    if validate_property_excluded?('dhcp_relay_global',
+                                   'ipv4_information_option_trust')
+      assert_nil(drg.ipv4_information_option_trust)
+      assert_raises(Cisco::UnsupportedError) do
+        drg.ipv4_information_option_trust = true
+      end
+      return
+    end
+    assert_equal(drg.default_ipv4_information_option_trust,
+                 drg.ipv4_information_option_trust)
+    drg.ipv4_information_option_trust = true
+    assert_equal(true, drg.ipv4_information_option_trust)
+    drg.ipv4_information_option_trust = drg.default_ipv4_information_option_trust
+    assert_equal(drg.default_ipv4_information_option_trust,
+                 drg.ipv4_information_option_trust)
+  end
+
+  def test_ipv4_information_option_vpn
+    drg = create_dhcp_relay_global
+    assert_equal(drg.default_ipv4_information_option_vpn,
+                 drg.ipv4_information_option_vpn)
+    drg.ipv4_information_option_vpn = true
+    assert_equal(true, drg.ipv4_information_option_vpn)
+    drg.ipv4_information_option_vpn = drg.default_ipv4_information_option_vpn
+    assert_equal(drg.default_ipv4_information_option_vpn,
+                 drg.ipv4_information_option_vpn)
+  end
+
+  def test_ipv4_information_trust_all
+    drg = create_dhcp_relay_global
+    if validate_property_excluded?('dhcp_relay_global',
+                                   'ipv4_information_trust_all')
+      assert_nil(drg.ipv4_information_trust_all)
+      assert_raises(Cisco::UnsupportedError) do
+        drg.ipv4_information_trust_all = true
+      end
+      return
+    end
+    assert_equal(drg.default_ipv4_information_trust_all,
+                 drg.ipv4_information_trust_all)
+    drg.ipv4_information_trust_all = true
+    assert_equal(true, drg.ipv4_information_trust_all)
+    drg.ipv4_information_trust_all = drg.default_ipv4_information_trust_all
+    assert_equal(drg.default_ipv4_information_trust_all,
+                 drg.ipv4_information_trust_all)
+  end
+
+  def test_ipv4_relay
+    drg = create_dhcp_relay_global
+    assert_equal(drg.default_ipv4_relay, drg.ipv4_relay)
+    drg.ipv4_relay = true
+    assert_equal(true, drg.ipv4_relay)
+    drg.ipv4_relay = false
+    assert_equal(false, drg.ipv4_relay)
+    drg.ipv4_relay = drg.default_ipv4_relay
+    assert_equal(drg.default_ipv4_relay, drg.ipv4_relay)
+  end
+
+  def test_ipv4_smart_relay
+    drg = create_dhcp_relay_global
+    assert_equal(drg.default_ipv4_smart_relay, drg.ipv4_smart_relay)
+    drg.ipv4_smart_relay = true
+    assert_equal(true, drg.ipv4_smart_relay)
+    drg.ipv4_smart_relay = drg.default_ipv4_smart_relay
+    assert_equal(drg.default_ipv4_smart_relay, drg.ipv4_smart_relay)
+  end
+
+  def test_ipv4_src_addr_hsrp
+    drg = create_dhcp_relay_global
+    if validate_property_excluded?('dhcp_relay_global',
+                                   'ipv4_src_addr_hsrp')
+      assert_nil(drg.ipv4_src_addr_hsrp)
+      assert_raises(Cisco::UnsupportedError) do
+        drg.ipv4_src_addr_hsrp = true
+      end
+      return
+    end
+    assert_equal(drg.default_ipv4_src_addr_hsrp,
+                 drg.ipv4_src_addr_hsrp)
+    drg.ipv4_src_addr_hsrp = true
+    assert_equal(true, drg.ipv4_src_addr_hsrp)
+    drg.ipv4_src_addr_hsrp = drg.default_ipv4_src_addr_hsrp
+    assert_equal(drg.default_ipv4_src_addr_hsrp,
+                 drg.ipv4_src_addr_hsrp)
+  end
+
+  def test_ipv4_src_intf
+    drg = create_dhcp_relay_global
+    if validate_property_excluded?('dhcp_relay_global', 'ipv4_src_intf')
+      assert_nil(drg.ipv4_src_intf)
+      assert_raises(Cisco::UnsupportedError) do
+        drg.ipv4_src_intf = 'port-channel200'
+      end
+      return
+    end
+    assert_equal(drg.default_ipv4_src_intf, drg.ipv4_src_intf)
+    drg.ipv4_src_intf = 'port-channel200'
+    assert_equal('port-channel200', drg.ipv4_src_intf)
+    drg.ipv4_src_intf = drg.default_ipv4_src_intf
+    assert_equal(drg.default_ipv4_src_intf, drg.ipv4_src_intf)
+  end
+
+  def test_ipv4_sub_option_circuit_id_custom
+    skip_nexus_i2_image?
+    drg = create_dhcp_relay_global
+    if validate_property_excluded?('dhcp_relay_global',
+                                   'ipv4_sub_option_circuit_id_custom')
+      assert_nil(drg.ipv4_sub_option_circuit_id_custom)
+      assert_raises(Cisco::UnsupportedError) do
+        drg.ipv4_sub_option_circuit_id_custom = true
+      end
+      return
+    end
+    assert_equal(drg.default_ipv4_sub_option_circuit_id_custom,
+                 drg.ipv4_sub_option_circuit_id_custom)
+    drg.ipv4_sub_option_circuit_id_custom = true
+    assert_equal(true, drg.ipv4_sub_option_circuit_id_custom)
+    drg.ipv4_sub_option_circuit_id_custom = drg.default_ipv4_sub_option_circuit_id_custom
+    assert_equal(drg.default_ipv4_sub_option_circuit_id_custom,
+                 drg.ipv4_sub_option_circuit_id_custom)
+  end
+
+  def test_ipv4_sub_option_circuit_id_string
+    drg = create_dhcp_relay_global
+    if validate_property_excluded?('dhcp_relay_global', 'ipv4_sub_option_circuit_id_string')
+      assert_nil(drg.ipv4_sub_option_circuit_id_string)
+      assert_raises(Cisco::UnsupportedError) do
+        drg.ipv4_sub_option_circuit_id_string = '%p%p'
+      end
+      return
+    end
+    assert_equal(drg.default_ipv4_sub_option_circuit_id_string, drg.ipv4_sub_option_circuit_id_string)
+    drg.ipv4_sub_option_circuit_id_string = '%p%p'
+    assert_equal('%p%p', drg.ipv4_sub_option_circuit_id_string)
+    drg.ipv4_sub_option_circuit_id_string = drg.default_ipv4_sub_option_circuit_id_string
+    assert_equal(drg.default_ipv4_sub_option_circuit_id_string, drg.ipv4_sub_option_circuit_id_string)
+  end
+
+  def test_ipv4_sub_option_cisco
+    drg = create_dhcp_relay_global
+    assert_equal(drg.default_ipv4_sub_option_cisco, drg.ipv4_sub_option_cisco)
+    drg.ipv4_sub_option_cisco = true
+    assert_equal(true, drg.ipv4_sub_option_cisco)
+    drg.ipv4_sub_option_cisco = drg.default_ipv4_sub_option_cisco
+    assert_equal(drg.default_ipv4_sub_option_cisco, drg.ipv4_sub_option_cisco)
+  end
+
+  def test_ipv6_option_cisco
+    drg = create_dhcp_relay_global
+    if validate_property_excluded?('dhcp_relay_global',
+                                   'ipv6_option_cisco')
+      assert_nil(drg.ipv6_option_cisco)
+      assert_raises(Cisco::UnsupportedError) do
+        drg.ipv6_option_cisco = true
+      end
+      return
+    end
+    assert_equal(drg.default_ipv6_option_cisco,
+                 drg.ipv6_option_cisco)
+    drg.ipv6_option_cisco = true
+    assert_equal(true, drg.ipv6_option_cisco)
+    drg.ipv6_option_cisco = drg.default_ipv6_option_cisco
+    assert_equal(drg.default_ipv6_option_cisco,
+                 drg.ipv6_option_cisco)
+  end
+
+  def test_ipv6_option_vpn
+    drg = create_dhcp_relay_global
+    assert_equal(drg.default_ipv6_option_vpn, drg.ipv6_option_vpn)
+    drg.ipv6_option_vpn = true
+    assert_equal(true, drg.ipv6_option_vpn)
+    drg.ipv6_option_vpn = drg.default_ipv6_option_vpn
+    assert_equal(drg.default_ipv6_option_vpn, drg.ipv6_option_vpn)
+  end
+
+  def test_ipv6_relay
+    drg = create_dhcp_relay_global
+    assert_equal(drg.default_ipv6_relay, drg.ipv6_relay)
+    drg.ipv6_relay = true
+    assert_equal(true, drg.ipv6_relay)
+    drg.ipv6_relay = false
+    assert_equal(false, drg.ipv6_relay)
+    drg.ipv6_relay = drg.default_ipv6_relay
+    assert_equal(drg.default_ipv6_relay, drg.ipv6_relay)
+  end
+
+  def test_ipv6_src_intf
+    drg = create_dhcp_relay_global
+    if validate_property_excluded?('dhcp_relay_global', 'ipv6_src_intf')
+      assert_nil(drg.ipv6_src_intf)
+      assert_raises(Cisco::UnsupportedError) do
+        drg.ipv6_src_intf = 'loopback2'
+      end
+      return
+    end
+    assert_equal(drg.default_ipv6_src_intf, drg.ipv6_src_intf)
+    drg.ipv6_src_intf = 'loopback2 '
+    assert_equal('loopback2', drg.ipv6_src_intf)
+    drg.ipv6_src_intf = drg.default_ipv6_src_intf
+    assert_equal(drg.default_ipv6_src_intf, drg.ipv6_src_intf)
+  end
+end