cisco_node_utils 1.2.0 → 1.3.0

data/tests/test_vlan_mt_full.rb

@@ -39,7 +39,9 @@ class TestVlanMtFull < CiscoTestCase
 
   def setup
     super
-    cleanup unless @@cleaned
+    return if @@cleaned
+    cleanup
+    remove_all_bridge_domains # BDs may conflict with our test vlans
     @@cleaned = true # rubocop:disable Style/ClassVars
   end
 
@@ -48,25 +50,12 @@ class TestVlanMtFull < CiscoTestCase
   end
 
   def interface_ethernet_default(ethernet_id)
-    config("default interface ethernet #{ethernet_id}")
-  end
-
-  def compatible_interface?
-    # MT-full tests require a specific linecard; either because they need a
-    # compatible interface or simply to enable the features. Either way
-    # we will provide an appropriate interface name if the linecard is present.
-    # Example 'show mod' output to match against:
-    #   '9  12  10/40 Gbps Ethernet Module  N7K-F312FQ-25 ok'
-    sh_mod = @device.cmd("sh mod | i '^[0-9]+.*N7K-F3'")[/^(\d+)\s.*N7K-F3/]
-    slot = sh_mod.nil? ? nil : Regexp.last_match[1]
-    skip('Unable to find a compatible interface in chassis') if slot.nil?
-
-    "ethernet#{slot}/1"
+    config("default interface #{ethernet_id}")
   end
 
   def mt_full_env_setup
     skip('Platform does not support MT-full') unless VxlanVtep.mt_full_support
-    compatible_interface?
+    mt_full_interface?
     v = Vdc.new('default')
     v.limit_resource_module_type = 'f3' unless
       v.limit_resource_module_type == 'f3'
@@ -77,8 +66,9 @@ class TestVlanMtFull < CiscoTestCase
 
     # Test for valid mode
     v = Vlan.new(2000)
-    assert_equal('ce', v.mode,
-                 'Mode should have been default to ce')
+    default = v.default_mode
+    assert_equal(default, v.mode,
+                 'Mode should have been default value: #{default}')
     v.mode = 'fabricpath'
     assert_equal(:enabled, v.fabricpath_feature,
                  'Fabricpath feature should have been enabled')
@@ -87,9 +77,9 @@ class TestVlanMtFull < CiscoTestCase
 
     # Test for invalid mode
     v = Vlan.new(100)
-    assert_equal('ce', v.mode,
-                 'Mode should have been default to ce')
+    assert_equal(default, v.mode,
+                 'Mode should have been default value: #{default}')
 
-    assert_raises(RuntimeError) { v.mode = 'junk' }
+    assert_raises(CliError) { v.mode = 'junk' }
   end
 end

data/tests/test_vlan_private.rb

@@ -0,0 +1,669 @@
+# NXAPI New test for feature private-vlan
+# Davide Celotto Febraury 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/vlan'
+
+include Cisco
+
+# TestVlan - Minitest for Vlan node utility
+class TestVlan < CiscoTestCase
+  @skip_unless_supported = 'vlan'
+
+  @@cleaned = false # rubocop:disable Style/ClassVars
+  def cleanup
+    Vlan.vlans.each do |vlan, obj|
+      # skip reserved vlans
+      next if vlan == '1'
+      next if node.product_id[/N5K|N6K|N7K/] && (1002..1005).include?(vlan.to_i)
+      obj.destroy
+    end
+    config_no_warn('no feature vtp')
+    config_no_warn('no feature private-vlan')
+  end
+
+  def setup
+    super
+    cleanup unless @@cleaned
+    @@cleaned = true # rubocop:disable Style/ClassVars
+  end
+
+  def teardown
+    cleanup
+  end
+
+  def test_private_type_default
+    config_no_warn('no feature vtp')
+    config_no_warn('feature private-vlan')
+    v1 = Vlan.new(100)
+    pv_type = ''
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+    else
+      assert_equal(pv_type, v1.private_vlan_type)
+    end
+  end
+
+  def test_private_association_default
+    config_no_warn('no feature vtp')
+    config_no_warn('feature private-vlan')
+    v1 = Vlan.new(100)
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      return
+    else
+      result = []
+      assert_equal(result, v1.private_vlan_association)
+    end
+  end
+
+  def test_private_vlan_type_primary
+    v1 = Vlan.new(100)
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+    end
+  end
+
+  def test_no_private_vlan_type_primary
+    v1 = Vlan.new(200)
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = ''
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+    end
+  end
+
+  def test_multi_private_vlan_type_primary
+    v1 = Vlan.new(100)
+    v2 = Vlan.new(101)
+    v3 = Vlan.new(200)
+    v4 = Vlan.new(201)
+    v5 = Vlan.new(203)
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      v2.private_vlan_type = pv_type
+      v3.private_vlan_type = pv_type
+      v4.private_vlan_type = pv_type
+      v5.private_vlan_type = pv_type
+
+      assert_equal(pv_type, v1.private_vlan_type)
+      assert_equal(pv_type, v2.private_vlan_type)
+      assert_equal(pv_type, v3.private_vlan_type)
+      assert_equal(pv_type, v4.private_vlan_type)
+      assert_equal(pv_type, v5.private_vlan_type)
+    end
+  end
+
+  def test_private_vlan_type_isolated
+    v1 = Vlan.new(100)
+    pv_type = 'isolated'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+    end
+  end
+
+  def test_private_vlan_type_community
+    v1 = Vlan.new(100)
+    pv_type = 'community'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+    end
+  end
+
+  def test_private_vlan_type_isolated_primary
+    v1 = Vlan.new(100)
+    pv_type = 'isolated'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      v2 = Vlan.new(200)
+      pv_type = 'primary'
+      v2.private_vlan_type = pv_type
+      assert_equal(pv_type, v2.private_vlan_type)
+    end
+  end
+
+  def test_private_vlan_type_isolated_community_primary
+    v1 = Vlan.new(100)
+    pv_type = 'isolated'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      v2 = Vlan.new(200)
+      pv_type = 'primary'
+      v2.private_vlan_type = pv_type
+      assert_equal(pv_type, v2.private_vlan_type)
+      v3 = Vlan.new(300)
+      pv_type = 'community'
+      v3.private_vlan_type = pv_type
+      assert_equal(pv_type, v3.private_vlan_type)
+    end
+  end
+
+  def test_private_vlan_type_change_isolated_to_primary
+    v1 = Vlan.new(100)
+    pv_type = 'isolated'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = 'primary'
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+    end
+  end
+
+  def test_private_vlan_type_change_isolated_to_community
+    v1 = Vlan.new(100)
+    pv_type = 'isolated'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = 'community'
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+    end
+  end
+
+  def test_private_vlan_type_change_community_to_isolated
+    v1 = Vlan.new(100)
+    pv_type = 'community'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = 'isolated'
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+    end
+  end
+
+  def test_private_vlan_type_change_community_to_primary
+    v1 = Vlan.new(100)
+    pv_type = 'community'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = 'primary'
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+    end
+  end
+
+  def test_private_vlan_type_change_primary_to_isolated
+    v1 = Vlan.new(100)
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = 'isolated'
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+    end
+  end
+
+  def test_private_vlan_type_change_primary_to_community
+    v1 = Vlan.new(100)
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = 'community'
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+    end
+  end
+
+  def test_private_vlan_isolate_association
+    vlan_list = %w(100 101)
+    result = ['101']
+    v1 = Vlan.new(vlan_list[0])
+    v2 = Vlan.new(vlan_list[1])
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = 'isolated'
+      v2.private_vlan_type = pv_type
+      assert_equal(pv_type, v2.private_vlan_type)
+
+      v1.private_vlan_association = ['101']
+
+      assert_equal(result, v1.private_vlan_association)
+    end
+  end
+
+  def test_private_vlan_community_association
+    vlan_list = %w(100 101)
+    result = ['101']
+    v1 = Vlan.new(vlan_list[0])
+    v2 = Vlan.new(vlan_list[1])
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = 'community'
+      v2.private_vlan_type = pv_type
+      assert_equal(pv_type, v2.private_vlan_type)
+
+      v1.private_vlan_association = ['101']
+
+      assert_equal(result, v1.private_vlan_association)
+    end
+  end
+
+  def test_private_vlan_association_failure
+    vlan_list = %w(100 101 200)
+    result = %w(101 200)
+    v1 = Vlan.new(vlan_list[0])
+    v2 = Vlan.new(vlan_list[1])
+    v3 = Vlan.new(vlan_list[2])
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = 'isolated'
+      v2.private_vlan_type = pv_type
+      assert_equal(pv_type, v2.private_vlan_type)
+      pv_type = 'community'
+      v3.private_vlan_type = pv_type
+      assert_equal(pv_type, v3.private_vlan_type)
+
+      v1.private_vlan_association = %w(101 200)
+
+      assert_equal(result, v1.private_vlan_association)
+
+      pv_type = 'isolated'
+      assert_raises(RuntimeError, 'vlan misconf did not raise RuntimeError') do
+        v3.private_vlan_type = pv_type
+      end
+
+      assert_equal(result, v1.private_vlan_association)
+
+    end
+  end
+
+  def test_private_vlan_association_operational_and_not_operational
+    vlan_list = %w(100 101 200)
+    result = %w(101 200)
+
+    v1 = Vlan.new(vlan_list[0])
+    v2 = Vlan.new(vlan_list[1])
+
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+
+      pv_type = 'isolated'
+      v2.private_vlan_type = pv_type
+      assert_equal(pv_type, v2.private_vlan_type)
+
+      v1.private_vlan_association = %w(101 200)
+
+      assert_equal(result, v1.private_vlan_association)
+    end
+  end
+
+  def test_private_vlan_association_vlan_not_configured
+    vlan_list = %w(100 101 200)
+    result = %w(101 200)
+    v1 = Vlan.new(vlan_list[0])
+    v2 = Vlan.new(vlan_list[1])
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = 'isolated'
+      v2.private_vlan_type = pv_type
+      assert_equal(pv_type, v2.private_vlan_type)
+
+      v1.private_vlan_association = %w(101 200)
+      assert_equal(result, v1.private_vlan_association)
+    end
+  end
+
+  def test_private_vlan_association_add_vlan
+    vlan_list = %w(100 101)
+    result = ['101']
+    v1 = Vlan.new(vlan_list[0])
+    v2 = Vlan.new(vlan_list[1])
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = 'isolated'
+      v2.private_vlan_type = pv_type
+      assert_equal(pv_type, v2.private_vlan_type)
+
+      v1.private_vlan_association = ['101']
+      assert_equal(result, v1.private_vlan_association)
+    end
+  end
+
+  def test_private_vlan_association_remove_vlan
+    vlan_list = %w(100 101 200)
+    result = %w(101 200)
+    v1 = Vlan.new(vlan_list[0])
+    v2 = Vlan.new(vlan_list[1])
+    v3 = Vlan.new(vlan_list[2])
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = 'isolated'
+      v2.private_vlan_type = pv_type
+      assert_equal(pv_type, v2.private_vlan_type)
+
+      pv_type = 'community'
+      v3.private_vlan_type = pv_type
+      assert_equal(pv_type, v3.private_vlan_type)
+
+      v1.private_vlan_association = %w(101 200)
+      assert_equal(result, v1.private_vlan_association)
+
+      # v1.private_vlan_association_remove_vlans = '101'
+      # result = '200'
+      # assert_equal(result, vlan_list(v1))
+
+    end
+  end
+
+  def test_no_private_vlan_association
+    vlan_list = %w(100 101 200)
+    result = %w(101 200)
+    v1 = Vlan.new(vlan_list[0])
+    v2 = Vlan.new(vlan_list[1])
+    v3 = Vlan.new(vlan_list[2])
+
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+
+      pv_type = 'isolated'
+      v2.private_vlan_type = pv_type
+      assert_equal(pv_type, v2.private_vlan_type)
+
+      pv_type = 'community'
+      v3.private_vlan_type = pv_type
+      assert_equal(pv_type, v3.private_vlan_type)
+
+      v1.private_vlan_association = %w(101 200)
+      assert_equal(result, v1.private_vlan_association)
+
+      v1.private_vlan_association = ['200']
+      result = ['200']
+      assert_equal(result, v1.private_vlan_association)
+
+    end
+  end
+
+  def test_no_private_vlan_association_all
+    vlan_list = %w(100 101 200)
+    result = %w(101 200)
+    v1 = Vlan.new(vlan_list[0])
+    v2 = Vlan.new(vlan_list[1])
+    v3 = Vlan.new(vlan_list[2])
+
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+
+      pv_type = 'isolated'
+      v2.private_vlan_type = pv_type
+      assert_equal(pv_type, v2.private_vlan_type)
+
+      pv_type = 'community'
+      v3.private_vlan_type = pv_type
+      assert_equal(pv_type, v3.private_vlan_type)
+
+      v1.private_vlan_association = %w(101 200)
+      assert_equal(result, v1.private_vlan_association)
+      v1.private_vlan_association = []
+      result = []
+      assert_equal(result, v1.private_vlan_association)
+
+    end
+  end
+
+  def test_private_vlan_isolate_community_association
+    vlan_list = %w(100 101 200)
+    result = %w(101 200)
+    v1 = Vlan.new(vlan_list[0])
+    v2 = Vlan.new(vlan_list[1])
+    v3 = Vlan.new(vlan_list[2])
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+      pv_type = 'isolated'
+      v2.private_vlan_type = pv_type
+      assert_equal(pv_type, v2.private_vlan_type)
+      pv_type = 'community'
+      v3.private_vlan_type = pv_type
+      assert_equal(pv_type, v3.private_vlan_type)
+
+      v1.private_vlan_association = %w(101 200)
+
+      assert_equal(result, v1.private_vlan_association)
+    end
+  end
+
+  def test_private_vlan_multi_isolate_community_association
+    vlan_list = %w(100 101 102 104 105 200 201 202)
+    result = %w(101 104 105 200 202)
+    v1 = Vlan.new(vlan_list[0])
+
+    pv_type = 'primary'
+    if validate_property_excluded?('vlan', 'private_vlan_type')
+      assert_nil(v1.private_vlan_type)
+      assert_raises(Cisco::UnsupportedError) do
+        v1.private_vlan_type = pv_type
+      end
+      return
+    else
+      v2 = Vlan.new(vlan_list[1])
+      v3 = Vlan.new(vlan_list[2])
+      v4 = Vlan.new(vlan_list[3])
+      v5 = Vlan.new(vlan_list[4])
+      v6 = Vlan.new(vlan_list[5])
+      v7 = Vlan.new(vlan_list[6])
+
+      v1.private_vlan_type = pv_type
+      assert_equal(pv_type, v1.private_vlan_type)
+
+      pv_type = 'isolated'
+      v2.private_vlan_type = pv_type
+      assert_equal(pv_type, v2.private_vlan_type)
+
+      pv_type = 'isolated'
+      v3.private_vlan_type = pv_type
+      assert_equal(pv_type, v3.private_vlan_type)
+
+      pv_type = 'community'
+      v4.private_vlan_type = pv_type
+      assert_equal(pv_type, v4.private_vlan_type)
+
+      pv_type = 'community'
+      v5.private_vlan_type = pv_type
+      assert_equal(pv_type, v5.private_vlan_type)
+
+      pv_type = 'community'
+      v6.private_vlan_type = pv_type
+      assert_equal(pv_type, v6.private_vlan_type)
+
+      pv_type = 'primary'
+      v7.private_vlan_type = pv_type
+      assert_equal(pv_type, v7.private_vlan_type)
+
+      v1.private_vlan_association = ['101', '104-105', '200', '202']
+
+      assert_equal(result, v1.private_vlan_association)
+
+      v1.private_vlan_association = ['101', '103-105', '108']
+
+      result = %w(101 103 104 105 108)
+      assert_equal(result, v1.private_vlan_association)
+
+      v1.private_vlan_association = ['101', '103-105', '108']
+      result = %w(101 103 104 105 108)
+      assert_equal(result, v1.private_vlan_association)
+    end
+  end
+end