cisco_node_utils_mgx 2.1.0.1

data/tests/test_dhcp_relay_global.rb

@@ -0,0 +1,286 @@
+# 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
+    skip_incompat_version?('dhcp_relay_global', 'ipv4_sub_option_circuit_id_string')
+    assert_equal(drg.default_ipv4_sub_option_circuit_id_string, drg.ipv4_sub_option_circuit_id_string)
+    str = '%p%p'
+    drg.ipv4_sub_option_circuit_id_string = str
+    assert_match(/#{str}/, 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

data/tests/test_dns_domain.rb

@@ -0,0 +1,123 @@
+#
+# Minitest for DnsDomain class
+#
+# Copyright (c) 2014-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/dns_domain'
+
+# TestDnsDomain - Minitest for DnsDomain node utility.
+class TestDnsDomain < CiscoTestCase
+  @skip_unless_supported = 'dnsclient'
+
+  def setup
+    # setup runs at the beginning of each test
+    super
+    @backup_resolve = backup_resolv_file
+    no_dnsdomain_tests
+  end
+
+  def teardown
+    # teardown runs at the end of each test
+    no_dnsdomain_tests
+    restore_resolv_file(@backup_resolve)
+    super
+  end
+
+  def no_dnsdomain_tests
+    # Turn the feature off for a clean test.
+    if platform == :ios_xr
+      config('no domain list aoeu.com',
+             'no domain list asdf.com',
+             'no vrf test')
+    else
+      config('no ip domain-list aoeu.com',
+             'no ip domain-list asdf.com',
+             'no vrf context test')
+    end
+  end
+
+  # TESTS
+
+  def test_create_destroy_single
+    id = 'aoeu.com'
+    refute_includes(Cisco::DnsDomain.dnsdomains, id)
+
+    ns = Cisco::DnsDomain.new(id)
+    assert_includes(Cisco::DnsDomain.dnsdomains, id)
+    assert_equal(Cisco::DnsDomain.dnsdomains[id], ns)
+
+    ns.destroy
+    refute_includes(Cisco::DnsDomain.dnsdomains, id)
+  end
+
+  def test_create_destroy_multiple
+    id1 = 'aoeu.com'
+    id2 = 'asdf.com'
+    refute_includes(Cisco::DnsDomain.dnsdomains, id1)
+    refute_includes(Cisco::DnsDomain.dnsdomains, id2)
+
+    ns1 = Cisco::DnsDomain.new(id1)
+    ns2 = Cisco::DnsDomain.new(id2)
+    assert_includes(Cisco::DnsDomain.dnsdomains, id1)
+    assert_includes(Cisco::DnsDomain.dnsdomains, id2)
+    assert_equal(Cisco::DnsDomain.dnsdomains[id1], ns1)
+    assert_equal(Cisco::DnsDomain.dnsdomains[id2], ns2)
+
+    ns1.destroy
+    refute_includes(Cisco::DnsDomain.dnsdomains, id1)
+    assert_includes(Cisco::DnsDomain.dnsdomains, id2)
+    ns2.destroy
+    refute_includes(Cisco::DnsDomain.dnsdomains, id2)
+  end
+
+  def test_create_destroy_single_vrf
+    id = 'aoeu.com'
+    vrf = 'test'
+    non_vrf = Cisco::DnsDomain.new(id)
+    assert_includes(Cisco::DnsDomain.dnsdomains, id)
+    refute_includes(Cisco::DnsDomain.dnsdomains(vrf), id)
+
+    ns = Cisco::DnsDomain.new(id, vrf)
+    assert_includes(Cisco::DnsDomain.dnsdomains(vrf), id)
+    assert_equal(Cisco::DnsDomain.dnsdomains(vrf)[id], ns)
+
+    ns.destroy
+    refute_includes(Cisco::DnsDomain.dnsdomains(vrf), id)
+    assert_includes(Cisco::DnsDomain.dnsdomains, id)
+    non_vrf.destroy
+  end
+
+  def test_create_destroy_multiple_vrf
+    id1 = 'aoeu.com'
+    id2 = 'asdf.com'
+    vrf = 'test'
+    refute_includes(Cisco::DnsDomain.dnsdomains(vrf), id1)
+    refute_includes(Cisco::DnsDomain.dnsdomains(vrf), id2)
+
+    ns1 = Cisco::DnsDomain.new(id1, vrf)
+    ns2 = Cisco::DnsDomain.new(id2, vrf)
+    assert_includes(Cisco::DnsDomain.dnsdomains(vrf), id1)
+    assert_includes(Cisco::DnsDomain.dnsdomains(vrf), id2)
+    assert_equal(Cisco::DnsDomain.dnsdomains(vrf)[id1], ns1)
+    assert_equal(Cisco::DnsDomain.dnsdomains(vrf)[id2], ns2)
+
+    ns1.destroy
+    refute_includes(Cisco::DnsDomain.dnsdomains(vrf), id1)
+    assert_includes(Cisco::DnsDomain.dnsdomains(vrf), id2)
+    ns2.destroy
+    refute_includes(Cisco::DnsDomain.dnsdomains(vrf), id2)
+  end
+end

data/tests/test_domain_name.rb

@@ -0,0 +1,96 @@
+#
+# Minitest for DomainName class
+#
+# Copyright (c) 2014-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/domain_name'
+
+# TestDomainName - Minitest for DomainName node utility.
+class TestDomainName < CiscoTestCase
+  @skip_unless_supported = 'dnsclient'
+
+  def setup
+    # setup runs at the beginning of each test
+    super
+    @backup_resolve = backup_resolv_file
+    no_domainname_test_xyz
+  end
+
+  def teardown
+    # teardown runs at the end of each test
+    no_domainname_test_xyz
+    restore_resolv_file(@backup_resolve)
+    super
+  end
+
+  def no_domainname_test_xyz
+    # Turn the feature off for a clean test.
+    if platform == :ios_xr
+      config('no domain name test.abc',
+             'no domain name test.xyz',
+             'no vrf test')
+    else
+      config('no ip domain-name test.abc',
+             'no ip domain-name test.xyz',
+             'no vrf context test')
+    end
+  end
+
+  # TESTS
+
+  def test_create_replace_destroy
+    name1 = 'test.abc'
+    name2 = 'test.xyz'
+    refute_includes(Cisco::DomainName.domainnames, name1)
+    refute_includes(Cisco::DomainName.domainnames, name2)
+
+    domain = Cisco::DomainName.new(name1)
+    assert_includes(Cisco::DomainName.domainnames, name1)
+    refute_includes(Cisco::DomainName.domainnames, name2)
+    assert_equal(Cisco::DomainName.domainnames[name1], domain)
+
+    domain = Cisco::DomainName.new(name2)
+    refute_includes(Cisco::DomainName.domainnames, name1)
+    assert_includes(Cisco::DomainName.domainnames, name2)
+    assert_equal(Cisco::DomainName.domainnames[name2], domain)
+
+    domain.destroy
+    refute_includes(Cisco::DomainName.domainnames, name1)
+    refute_includes(Cisco::DomainName.domainnames, name2)
+  end
+
+  def test_create_replace_destroy_vrf
+    name1 = 'test.abc'
+    name2 = 'test.xyz'
+    vrf = 'test'
+    refute_includes(Cisco::DomainName.domainnames(vrf), name1)
+    refute_includes(Cisco::DomainName.domainnames(vrf), name2)
+
+    domain = Cisco::DomainName.new(name1, vrf)
+    assert_includes(Cisco::DomainName.domainnames(vrf), name1)
+    refute_includes(Cisco::DomainName.domainnames(vrf), name2)
+    assert_equal(Cisco::DomainName.domainnames(vrf)[name1], domain)
+
+    domain = Cisco::DomainName.new(name2, vrf)
+    refute_includes(Cisco::DomainName.domainnames(vrf), name1)
+    assert_includes(Cisco::DomainName.domainnames(vrf), name2)
+    assert_equal(Cisco::DomainName.domainnames(vrf)[name2], domain)
+
+    domain.destroy
+    refute_includes(Cisco::DomainName.domainnames(vrf), name1)
+    refute_includes(Cisco::DomainName.domainnames(vrf), name2)
+  end
+end

data/tests/test_encapsulation.rb

@@ -0,0 +1,75 @@
+# Copyright (c) 2014-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/encapsulation'
+require_relative '../lib/cisco_node_utils/vdc'
+
+# TestEncapsulation - Minitest for Encapsulation node utility class
+class TestEncapsulation < CiscoTestCase
+  @skip_unless_supported = 'encapsulation'
+  @@pre_clean_needed = true # rubocop:disable Style/ClassVars
+
+  def setup
+    super
+    vdc_limit_f3_no_intf_needed(:set)
+    return unless @@pre_clean_needed
+    cleanup
+    @@pre_clean_needed = false # rubocop:disable Style/ClassVars
+  end
+
+  def teardown
+    vdc_limit_f3_no_intf_needed(:clear) if first_or_last_teardown
+    cleanup
+    super
+  end
+
+  def cleanup
+    config_no_warn('no feature vni')
+    Encapsulation.encaps.each do |_encap, obj|
+      obj.destroy
+    end
+  end
+
+  # TESTS
+
+  def test_create_destroy
+    profile = 'cisco'
+    e = Encapsulation.new(profile)
+    assert(Encapsulation.encaps[profile], "profile '#{profile}' not found")
+    e.destroy
+  end
+
+  def test_dot1q_map
+    e = Encapsulation.new('cisco')
+    assert_equal(e.default_dot1q_map, e.dot1q_map)
+
+    map = ['100-110,150', '5000-5010,5050']
+    e.dot1q_map = map
+    assert_equal(map, e.dot1q_map)
+
+    e.dot1q_map = e.default_dot1q_map
+    assert_equal(e.default_dot1q_map, e.dot1q_map)
+
+    e.destroy
+  end
+
+  def test_dot1q_map_negative
+    e = Encapsulation.new('cisco')
+    assert_raises(CliError) do
+      # Test for range imbalance (3 vlans to only 2 vnis)
+      e.dot1q_map = ['101-103', '5101-5102']
+    end
+  end
+end

data/tests/test_evpn_multicast.rb

@@ -0,0 +1,65 @@
+# Evpn Multicast Unit Tests
+#
+# Rahul Shenoy, January, 2018
+#
+# Copyright (c) 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/evpn_multicast'
+require_relative '../lib/cisco_node_utils/feature'
+
+# TestEvpnMulticast - Minitest for EvpnMulticast class
+class TestEvpnMulticast < CiscoTestCase
+  @skip_unless_supported = 'evpn_multicast'
+
+  def setup
+    # Disable feature ngmvpn before each test to
+    # ensure we are starting with a clean slate for each test.
+    super
+    skip_incompat_version?('feature', 'ngmvpn')
+    config_no_warn('no feature ngmvpn')
+    config_no_warn('no advertise evpn multicast')
+  end
+
+  def teardown
+    # disable feature ngmvpn and advertise evpn multicast
+    # after each test
+    config_no_warn('no feature ngmvpn')
+    config_no_warn('no advertise evpn multicast')
+    super
+  end
+
+  def test_create_and_destroy
+    mc = EvpnMulticast.new
+    assert_equal('advertise evpn multicast', mc.multicast,
+                 'Error: failed to enable evpn multicast')
+    assert(Feature.ngmvpn_enabled?,
+           'Error: failed to enable feature ngmvpn')
+    mc.destroy
+    assert_equal('', mc.multicast,
+                 'Error: failed to disable evpn multicast')
+  end
+
+  def test_multicast
+    mc = EvpnMulticast.new
+    mc.multicast = false
+    assert_equal('', mc.multicast,
+                 'Error: failed to disable evpn multicast')
+    mc.multicast = true
+    assert_equal('advertise evpn multicast', mc.multicast,
+                 'Error: failed to enable evpn multicast')
+    mc.destroy
+  end
+end