cisco_node_utils_mgx 2.1.0.1

data/tests/test_vxlan_vtep_vni.rb

@@ -0,0 +1,326 @@
+# Copyright (c) 2013-2018 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/vxlan_vtep'
+require_relative '../lib/cisco_node_utils/vxlan_vtep_vni'
+require_relative '../lib/cisco_node_utils/evpn_multisite'
+
+include Cisco
+
+# TestVxlanVtepVni - Minitest for VxlanVtepVni node utility
+class TestVxlanVtepVni < CiscoTestCase
+  @skip_unless_supported = 'vxlan_vtep_vni'
+  @@pre_clean_needed = true # rubocop:disable Style/ClassVars
+  @@feature_unsupported = false # rubocop:disable Style/ClassVars
+
+  def setup
+    super
+    skip('setup: Feature is unsupported on this device') if @@feature_unsupported
+    vdc_limit_f3_no_intf_needed(:set) if VxlanVtep.mt_full_support
+    Interface.interfaces(:nve).each { |_nve, obj| obj.destroy }
+    feature_cleanup if @@pre_clean_needed
+    Feature.nv_overlay_enable
+    config_no_warn('feature vn-segment-vlan-based') if VxlanVtep.mt_lite_support
+    @@pre_clean_needed = false # rubocop:disable Style/ClassVars
+  rescue RuntimeError => e
+    # Skip locally to shortcut the dependencies above for the next test
+    @@feature_unsupported = hardware_supports_feature?(e.message, status_only: true) # rubocop:disable Style/ClassVars
+    @@feature_unsupported ? skip(e.message) : raise(e.message)
+  end
+
+  def teardown
+    if first_or_last_teardown
+      vdc_limit_f3_no_intf_needed(:clear)
+      feature_cleanup
+    end
+    super
+  end
+
+  def feature_cleanup
+    config_no_warn('no feature-set fabricpath')
+    config_no_warn('no feature vni')
+    config_no_warn('no feature vn-segment-vlan-based')
+    config_no_warn('no nv overlay evpn ; no feature nv overlay')
+    # Rapid nv feature toggle can cause failures on some platforms;
+    # symptom e.g. 'show runn | i ^feature' will hang
+    sleep 5
+  end
+
+  def test_create_with_existing
+    VxlanVtep.new('nve1').host_reachability = 'evpn'
+    associate_vrf = true
+    member = '5000'
+
+    VxlanVtepVni.new('nve1', member)
+    assert_includes(VxlanVtepVni.vnis['nve1'], member)
+
+    VxlanVtepVni.new('nve1', member, associate_vrf)
+    assert_includes(VxlanVtepVni.vnis['nve1'], member)
+    assert(VxlanVtepVni.vnis['nve1'], associate_vrf)
+
+    VxlanVtepVni.new('nve1', member)
+    assert_includes(VxlanVtepVni.vnis['nve1'], member)
+  end
+
+  def test_vnis
+    VxlanVtep.new('nve1')
+    skip('Platform does not support vnis') if VxlanVtepVni.vnis['nve1'].nil?
+
+    # Test empty case
+    assert_empty(VxlanVtepVni.vnis['nve1'])
+
+    # Host reachablity must be set to evpn for associate_vrf
+    # testing.
+    VxlanVtep.new('nve1').host_reachability = 'evpn'
+    associate_vrf = true
+
+    # Create one
+    member1 = '5000'
+    vni1 = VxlanVtepVni.new('nve1', member1, associate_vrf)
+    assert_includes(VxlanVtepVni.vnis['nve1'], member1)
+    assert(VxlanVtepVni.vnis['nve1'], associate_vrf)
+    assert_equal(VxlanVtepVni.vnis['nve1'][member1], vni1)
+
+    # Create several
+    member2 = '5001-6001'
+    member3 = '8888'
+    refute_includes(VxlanVtepVni.vnis['nve1'], member2)
+    refute_includes(VxlanVtepVni.vnis['nve1'], member3)
+
+    vni2 = VxlanVtepVni.new('nve1', member2)
+    vni3 = VxlanVtepVni.new('nve1', member3)
+    assert_includes(VxlanVtepVni.vnis['nve1'], member2)
+    assert_equal(VxlanVtepVni.vnis['nve1'][member2], vni2)
+    assert_includes(VxlanVtepVni.vnis['nve1'], member3)
+    assert_equal(VxlanVtepVni.vnis['nve1'][member3], vni3)
+
+    # Destroy one
+    vni2.destroy
+    refute_includes(VxlanVtepVni.vnis['nve1'], member2)
+    refute_equal(VxlanVtepVni.vnis['nve1'][member2], vni2)
+
+    # Destroy all
+    vni1.destroy
+    vni3.destroy
+    assert_empty(VxlanVtepVni.vnis['nve1'])
+  end
+
+  def test_ingress_replication
+    skip_legacy_defect?('7.0.3.I3.1',
+                        'CSCuy27700: Validation failed for vni mcast group configured')
+
+    vni = VxlanVtepVni.new('nve1', '5000')
+    if validate_property_excluded?('vxlan_vtep_vni', 'ingress_replication')
+      assert_raises(Cisco::UnsupportedError) { vni.ingress_replication = 'bgp' }
+      return
+    end
+
+    # Test non-default values
+    vni.ingress_replication = 'static'
+    assert_equal('static', vni.ingress_replication)
+
+    vni.ingress_replication = 'bgp'
+    assert_equal('bgp', vni.ingress_replication)
+
+    # Test default case
+    ir = vni.default_ingress_replication
+    vni.ingress_replication = ir
+    assert_equal(ir, vni.ingress_replication)
+
+    # Test the case where an existing multicast_group is removed before
+    # configuring ingress_replication
+    vni.multicast_group = '224.1.1.1'
+    assert_equal('224.1.1.1', vni.multicast_group)
+
+    vni.ingress_replication = 'static'
+    assert_equal('static', vni.ingress_replication)
+  end
+
+  def test_multicast_group
+    skip_legacy_defect?('7.0.3.I3.1',
+                        'CSCuy27700: Validation failed for vni mcast group configured')
+
+    vni1 = VxlanVtepVni.new('nve1', '6000')
+    vni2 = VxlanVtepVni.new('nve1', '8001-8200')
+
+    # No multicast groups configured
+    assert_empty(vni1.multicast_group)
+
+    # Test single multicast group
+    vni1.multicast_group = '224.1.1.1'
+    assert_equal('224.1.1.1', vni1.multicast_group)
+
+    # Test the case where an existing ingress_replication is removed before
+    # configuring multicast_group
+    unless validate_property_excluded?('vxlan_vtep_vni', 'ingress_replication')
+      vni1.ingress_replication = 'static'
+      assert_equal('static', vni1.ingress_replication)
+
+      vni1.multicast_group = '224.1.1.1'
+      assert_equal('224.1.1.1', vni1.multicast_group)
+    end
+
+    # Test multicast group range
+    vni2.multicast_group = '224.1.1.1 224.1.1.200'
+    assert_equal('224.1.1.1 224.1.1.200', vni2.multicast_group)
+
+    # Test default
+    vni1.multicast_group = vni1.default_multicast_group
+    assert_empty(vni1.multicast_group)
+    vni2.multicast_group = vni2.default_multicast_group
+    assert_empty(vni2.multicast_group)
+  end
+
+  def test_peer_list
+    vni = VxlanVtepVni.new('nve1', '6000')
+    if validate_property_excluded?('vxlan_vtep_vni', 'peer_list')
+      assert_raises(Cisco::UnsupportedError) { vni.peer_list = ['1.1.1.1'] }
+      return
+    end
+
+    peer_list = ['1.1.1.1', '2.2.2.2', '3.3.3.3', '4.4.4.4']
+
+    # Test: all peers when current is empty
+    should = peer_list.clone
+    vni.peer_list = should
+    result = vni.peer_list
+    assert_equal(should.sort, result.sort,
+                 'Test 1. From empty, to all peers')
+
+    # Test: remove half of the peers
+    should.shift(2)
+    vni.peer_list = should
+    result = vni.peer_list
+    assert_equal(should.sort, result.sort,
+                 'Test 2. Remove half of the peers')
+
+    # Test: restore removed peers
+    should = peer_list.clone
+    vni.peer_list = should
+    result = vni.peer_list
+    assert_equal(should.sort, result.sort,
+                 'Test 3. Restore removed peers')
+
+    # Test: default
+    should = vni.default_peer_list
+    vni.peer_list = should
+    result = vni.peer_list
+    assert_equal(should.sort, result.sort,
+                 'Test 4. Default')
+  end
+
+  def test_suppress_arp
+    vni = VxlanVtepVni.new('nve1', '6000')
+    VxlanVtep.new('nve1').host_reachability = 'evpn'
+
+    # Test: Check suppress_arp is not configured.
+    refute(vni.suppress_arp, 'suppress_arp should be disabled')
+
+    begin
+      # Test: Enable suppress_arp
+      vni.suppress_arp = true
+      assert(vni.suppress_arp, 'suppress_arp should be enabled')
+    rescue CliError => e
+      msg = 'TCAM reconfiguration required followed by reload' \
+        " Skipping test case.\n#{e}"
+      skip(msg) if /ERROR: Please configure TCAM/.match(e.to_s)
+    end
+
+    # Test: Default
+    vni.suppress_arp = vni.default_suppress_arp
+    refute(vni.suppress_arp, 'suppress_arp should be disabled')
+  end
+
+  def test_suppress_arp_disable
+    skip_incompat_version?('vxlan_vtep_vni', 'suppress_arp_disable')
+    vni = VxlanVtepVni.new('nve1', '6000')
+    VxlanVtep.new('nve1').host_reachability = 'evpn'
+
+    if validate_property_excluded?('vxlan_vtep_vni', 'suppress_arp_disable')
+      assert_raises(Cisco::UnsupportedError) { vni.suppress_arp_disable = true }
+      return
+    end
+
+    # Test: Check suppress_arp_disable is not configured.
+    refute(vni.suppress_arp_disable, 'suppress_arp_disable should be disabled')
+
+    begin
+      # Test: Enable suppress_arp_disable
+      vni.suppress_arp_disable = true
+      assert(vni.suppress_arp_disable, 'suppress_arp_disable should be enabled')
+    rescue CliError => e
+      msg = 'TCAM reconfiguration required followed by reload' \
+        " Skipping test case.\n#{e}"
+      skip(msg) if /ERROR: Please configure TCAM/.match(e.to_s)
+    end
+
+    # Test: Default
+    vni.suppress_arp_disable = vni.default_suppress_arp_disable
+    refute(vni.suppress_arp_disable, 'suppress_arp_disable should be disabled')
+  end
+
+  def test_suppress_uuc
+    vni = VxlanVtepVni.new('nve1', '6000')
+    VxlanVtep.new('nve1').host_reachability = 'evpn'
+    if validate_property_excluded?('vxlan_vtep_vni', 'suppress_uuc')
+      assert_nil(vni.suppress_uuc)
+      assert_nil(vni.default_suppress_uuc)
+      assert_raises(Cisco::UnsupportedError) { vni.suppress_uuc = true }
+      return
+    end
+
+    skip_incompat_version?('vxlan_vtep_vni', 'suppress_uuc')
+    # Test: Check suppress_uuc is not configured.
+    refute(vni.suppress_uuc, 'suppress_uuc should be disabled')
+
+    # Test: Enable suppress_uuc
+    vni.suppress_uuc = true
+    assert(vni.suppress_uuc, 'suppress_uuc should be enabled')
+
+    # Test: Default
+    vni.suppress_uuc = vni.default_suppress_uuc
+    refute(vni.suppress_uuc, 'suppress_uuc should be disabled')
+  end
+
+  def test_multisite_ingress_replication
+    skip("#{node.product_id} doesn't support this feature") unless
+      node.product_id[/N9K.*EX/]
+
+    vni = VxlanVtepVni.new('nve1', '6000')
+    ms = EvpnMultisite.new(100)
+
+    # Test: Default
+    vni.multisite_ingress_replication =
+      vni.default_multisite_ingress_replication
+    refute(vni.multisite_ingress_replication,
+           'multisite ingress-replication should be disabled')
+
+    # Test: Enable multisite_ingress_replication
+    vni.multisite_ingress_replication = true
+    assert(vni.multisite_ingress_replication,
+           'multisite ingress-replication should be enabled')
+
+    # Test: Disable multisite_ingress_replication
+    vni.multisite_ingress_replication = false
+    refute(vni.multisite_ingress_replication,
+           'multisite ingress-replication should be disabled')
+
+    ms.destroy
+    # Test: enabling multisite ingress-replication without a multisite bg errors
+    assert_raises(Cisco::CliError) do
+      vni.multisite_ingress_replication = true
+    end
+  end
+end

data/tests/test_yang.rb

@@ -0,0 +1,369 @@
+#!/usr/bin/env ruby
+# Yang Unit Tests
+#
+# Charles Burkett, May, 2016
+#
+# Copyright (c) 2015-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/yang'
+
+# TestYang - Minitest for Yang class
+class TestYang < CiscoTestCase
+  BLUE_VRF = '{"Cisco-IOS-XR-infra-rsi-cfg:vrfs":{
+      "vrf":[
+         {
+            "vrf-name":"BLUE",
+            "description":"Generic external traffic",
+            "create":[
+               null
+            ]
+         }
+      ]
+    }}'
+
+  RED_VRF = '{"Cisco-IOS-XR-infra-rsi-cfg:vrfs":{
+      "vrf":[
+         {
+            "vrf-name":"RED",
+            "create":[
+               null
+            ]
+         }
+      ]
+    }}'
+
+  GREEN_VRF = '{"Cisco-IOS-XR-infra-rsi-cfg:vrfs":{
+      "vrf":[
+         {
+            "vrf-name":"GREEN",
+            "create": [null]
+         }
+      ]
+    }}'
+
+  BLUE_GREEN_VRF = '{"Cisco-IOS-XR-infra-rsi-cfg:vrfs":{
+      "vrf":[
+         {
+            "vrf-name":"BLUE",
+            "create":[null],
+            "description":"Generic external traffic"
+         },
+         {
+            "vrf-name":"GREEN",
+            "create":[null]
+         }
+      ]
+  }}'
+
+  BLUE_VRF_NO_PROPERTIES = '{"Cisco-IOS-XR-infra-rsi-cfg:vrfs":{
+      "vrf":[
+         {
+            "vrf-name":"BLUE",
+            "create":[
+               null
+            ]
+         }
+      ]
+    }}'
+
+  BLUE_VRF_PROPERTIES1 = '{"Cisco-IOS-XR-infra-rsi-cfg:vrfs":{
+      "vrf":[
+         {
+            "vrf-name":"BLUE",
+            "create":[
+               null
+            ],
+            "vpn-id":{
+              "vpn-oui":0,
+              "vpn-index":0
+              }
+         }
+      ]
+    }}'
+
+  BLUE_VRF_PROPERTIES2 = '{"Cisco-IOS-XR-infra-rsi-cfg:vrfs":{
+      "vrf":[
+         {
+            "vrf-name":"BLUE",
+            "description":"Generic external traffic",
+            "create":[
+               null
+            ],
+            "vpn-id":{
+              "vpn-oui":0,
+              "vpn-index":0
+              }
+         }
+      ]
+    }}'
+
+  BLUE_VRF_PROPERTIES3 = '{"Cisco-IOS-XR-infra-rsi-cfg:vrfs":{
+      "vrf":[
+         {
+            "vrf-name":"BLUE",
+            "description":"Generic ext traffic",
+            "create":[
+               null
+            ],
+            "vpn-id":{
+              "vpn-oui":8,
+              "vpn-index":9
+              }
+         }
+      ]
+    }}'
+
+  NO_VRFS = '{"Cisco-IOS-XR-infra-rsi-cfg:vrfs": [null]}'
+  PATH_VRFS = '{"Cisco-IOS-XR-infra-rsi-cfg:vrfs": [null]}'
+
+  def self.runnable_methods
+    return [:all_skipped] unless platform == :ios_xr
+    super
+  end
+
+  def all_skipped
+    puts 'Node under test does not appear to use the gRPC client'
+    assert(validate_property_excluded?('yang', 'support'))
+  end
+
+  def setup
+    super
+    clear_vrfs
+  end
+
+  def teardown
+    super
+    clear_vrfs
+  end
+
+  def clear_vrfs
+    return unless platform == :ios_xr
+    current_vrfs = node.get_yang(PATH_VRFS)
+
+    # remove all vrfs
+    node.delete_yang(PATH_VRFS) unless Yang.empty?(current_vrfs)
+  end
+
+  def test_delete_vrfs
+    node.merge_yang(BLUE_VRF)  # ensure at least one VRF is there
+    assert(node.get_yang(PATH_VRFS).match('BLUE'), 'Did not find the BLUE vrf')
+
+    clear_vrfs
+    assert_equal('', node.get_yang(PATH_VRFS),
+                 'There are still vrfs configured')
+  end
+
+  def test_add_vrf
+    node.merge_yang(BLUE_VRF)  # create a single VRF
+    assert(node.get_yang(PATH_VRFS).match('BLUE'), 'Did not find the BLUE vrf')
+
+    node.replace_yang(GREEN_VRF) # create a single VRF
+    assert(node.get_yang(PATH_VRFS).match('GREEN'),
+           'Did not find the GREEN vrf')
+    refute(node.get_yang(PATH_VRFS).match('BLUE'),
+           'Found the BLUE vrf')
+  end
+
+  def test_errors
+    # Note: Originally, we were checking for YangErrors and ClientErrors,
+    # but the type of error raised seemed to change from one XR image to the
+    # next, so now we check for the more general CiscoError in these tests.
+
+    # === test get_yang ===========
+
+    # Request is not wellformed
+    assert_raises(Cisco::CiscoError) { node.get_yang('aabbcc') }
+
+    # parse error: object key and value must be separated by a colon
+    assert_raises(Cisco::CiscoError) { node.get_yang('{"aabbcc"}') }
+
+    # unknown-namespace
+    assert_raises(Cisco::CiscoError) { node.get_yang('{"aabbcc": "foo"}') }
+
+    # unknown-element
+    assert_raises(Cisco::CiscoError) do
+      node.get_yang('{"Cisco-IOS-XR-infra-rsi-cfg:aabbcc": "foo"}')
+    end
+
+    # parse error: premature EOF
+    assert_raises(Cisco::CiscoError) { node.get_yang('{') }
+
+    # parse error: invalid object key (must be a string)
+    assert_raises(Cisco::CiscoError) { node.get_yang('{: "foo"}') }
+
+    # === test merge_yang ===========
+
+    # Request is not wellformed
+    assert_raises(Cisco::CiscoError) { node.merge_yang('aabbcc') }
+
+    # unknown-element
+    assert_raises(Cisco::CiscoError) do
+      node.merge_yang('{"Cisco-IOS-XR-infra-rsi-cfg:aabbcc": "foo"}')
+    end
+
+    # bad-element
+    assert_raises(Cisco::CiscoError) do
+      node.merge_yang('{"Cisco-IOS-XR-infra-rsi-cfg:vrfs": "foo"}')
+    end
+
+    # missing-element
+    assert_raises(Cisco::CiscoError) do
+      node.merge_yang('{"Cisco-IOS-XR-infra-rsi-cfg:vrfs": {"vrf":[{}]}}')
+    end
+
+    # === test replace_yang ===========
+
+    # unknown-namespace
+    assert_raises(Cisco::CiscoError) do
+      node.replace_yang('{"Cisco-IOS-XR-infra-rsi-cfg:aabbcc": "foo"}')
+    end
+
+    # Request is not wellformed
+    assert_raises(Cisco::CiscoError) do
+      node.replace_yang('{"Cisco-IOS-XR-infra-rsi-cfg:vrfs": }')
+    end
+  end
+
+  def test_merge_diff
+    # ensure we think that a merge is needed (in-sinc = false)
+    refute(Yang.insync_for_merge?(BLUE_VRF, node.get_yang(PATH_VRFS)),
+           'Expected not in-sync')
+
+    node.merge_yang(BLUE_VRF) # create the blue VRF
+
+    # ensure we think that a merge is NOT needed (in-sinc = true)
+    assert(Yang.insync_for_merge?(BLUE_VRF, node.get_yang(PATH_VRFS)),
+           'Expected in-sync')
+
+    # ensure we think that the merge is needed (in-sinc = false)
+    refute(Yang.insync_for_merge?(RED_VRF, node.get_yang(PATH_VRFS)),
+           'Expected not in-sync')
+
+    node.merge_yang(RED_VRF) # create the red VRF
+
+    # ensure we think that a merge is NOT needed (in-sinc = true)
+    assert(Yang.insync_for_merge?(RED_VRF, node.get_yang(PATH_VRFS)),
+           'Expected in-sync')
+
+    node.merge_yang(GREEN_VRF) # create green VRF
+    # ensure we think that a merge is NOT needed (in-sinc = true)
+    assert(Yang.insync_for_merge?(GREEN_VRF, node.get_yang(PATH_VRFS)),
+           'Expected in-sync')
+  end
+
+  def test_replace_diff
+    # ensure we think that a merge is needed (in-sinc = false)
+    refute(Yang.insync_for_replace?(BLUE_VRF, node.get_yang(PATH_VRFS)),
+           'Expected not in-sync')
+
+    node.replace_yang(BLUE_VRF) # create the blue VRF
+    # ensure we think that a replace is NOT needed (in-sinc = true)
+    assert(Yang.insync_for_replace?(BLUE_VRF, node.get_yang(PATH_VRFS)),
+           'Expected in-sync')
+
+    node.replace_yang(RED_VRF) # create the red VRF
+    # ensure we think that a replace is NOT needed (in-sinc = true)
+    assert(Yang.insync_for_replace?(RED_VRF, node.get_yang(PATH_VRFS)),
+           'Expected in-sync')
+
+    node.replace_yang(GREEN_VRF) # create green VRF
+    # ensure we think that a replace is NOT needed (in-sinc = true)
+    assert(Yang.insync_for_replace?(GREEN_VRF, node.get_yang(PATH_VRFS)),
+           'Expected in-sync')
+
+    node.merge_yang(BLUE_VRF)
+
+    # ensure we think that a replace is NOT needed (in-sinc = true)
+    assert(Yang.insync_for_replace?(BLUE_GREEN_VRF, node.get_yang(PATH_VRFS)),
+           'Expected in sync')
+    # ensure we think that a replace is needed (in-sinc = true)
+    refute(Yang.insync_for_replace?(BLUE_VRF, node.get_yang(PATH_VRFS)),
+           'Expected not in sync')
+    refute(Yang.insync_for_replace?(GREEN_VRF, node.get_yang(PATH_VRFS)),
+           'Expected not in sync')
+
+    node.replace_yang(BLUE_VRF)
+    # ensure we think that a replace is NOT needed (in-sinc = true)
+    assert(Yang.insync_for_replace?(BLUE_VRF, node.get_yang(PATH_VRFS)),
+           'Expected in-sync')
+    # ensure we think that a replace is needed (in-sinc = true)
+    refute(Yang.insync_for_replace?(GREEN_VRF, node.get_yang(PATH_VRFS)),
+           'Expected not in-sync')
+    refute(Yang.insync_for_replace?(BLUE_GREEN_VRF, node.get_yang(PATH_VRFS)),
+           'Expected not in-sync')
+  end
+
+  def test_merge_leaves
+    node.merge_yang(BLUE_VRF) # create blue vrf with description
+
+    # merge blue vrf with vpn id to blue vrf with description
+    node.merge_yang(BLUE_VRF_PROPERTIES1)
+
+    # ensure that new leaves are merged with old.
+    assert(Yang.insync_for_merge?(BLUE_VRF_PROPERTIES2,
+                                  node.get_yang(PATH_VRFS)), 'Expected in-sync')
+
+    # update description and vpn-id
+    node.merge_yang(BLUE_VRF_PROPERTIES3)
+    assert(Yang.insync_for_merge?(BLUE_VRF_PROPERTIES3,
+                                  node.get_yang(PATH_VRFS)), 'Expected in-sync')
+  end
+
+  def test_replace_leaves
+    node.replace_yang(BLUE_VRF) # create blue vrf with description
+
+    # replace blue vrf (description) by blue vrf (vpn-id)
+    node.replace_yang(BLUE_VRF_PROPERTIES1)
+
+    # ensure that new properties are replaced by old.
+    assert(Yang.insync_for_replace?(BLUE_VRF_PROPERTIES1,
+                                    node.get_yang(PATH_VRFS)),
+           'Expected in-sync')
+
+    # replace description and vpn-id
+    node.replace_yang(BLUE_VRF_PROPERTIES3)
+    assert(Yang.insync_for_replace?(BLUE_VRF_PROPERTIES3,
+                                    node.get_yang(PATH_VRFS)),
+           'Expected in-sync')
+  end
+
+  def test_merge
+    node.merge_yang(BLUE_VRF)   # create blue vrf
+    node.merge_yang(GREEN_VRF)  # create green vrf
+
+    yang = node.get_yang(PATH_VRFS)
+
+    assert_yang_equal(BLUE_GREEN_VRF, yang)
+  end
+
+  def test_replace
+    node.merge_yang(BLUE_VRF)     # create blue vrf
+    node.replace_yang(GREEN_VRF)  # create green vrf
+
+    yang = node.get_yang(PATH_VRFS)
+
+    assert_yang_equal(GREEN_VRF, yang)
+  end
+
+  def assert_yang_equal(expected, actual)
+    equal = Yang.insync_for_replace?(expected, actual) &&
+            Yang.insync_for_replace?(actual, expected)
+    assert(equal,
+           "Expected: '#{expected}',\n"\
+           "Actual: '#{actual}',\n",
+          )
+  end
+end