def test_basic_config(self):
"""Tests the minimal config"""
port_number = 1
port_key = 1
input_config = {}
output_config = {'description': str(port_key), 'number': port_number}
expected_config = self.default_config
expected_config.update(input_config)
expected_config.update(output_config)
port = Port(port_key, 1, input_config)
output_config = port.to_conf()
self.assertEqual(output_config, expected_config)
key_exceptions = ['name', '_id', 'dp_id', 'dyn_phys_up']
dict_keys = set(port.__dict__.keys())
conf_keys = set(port.to_conf().keys())
for exception in key_exceptions:
dict_keys.remove(exception)
self.assertEqual(dict_keys, conf_keys)
def test_config_with_vlans(self):
"""Tests the config with tagged and native vlans"""
vlan100 = MockVLAN('v100')
vlan200 = MockVLAN('v200')
vlan300 = MockVLAN('v300')
tagged_vlans = [vlan200, vlan300]
native_vlan = vlan100
port_number = 1
port_key = 'port_1'
input_config = {'number': port_number}
output_config = {
'description': str(port_key),
'number': port_number,
'native_vlan': vlan100.name,
'tagged_vlans': [vlan200.name, vlan300.name]
}
expected_config = self.default_config
expected_config.update(input_config)
expected_config.update(output_config)
port = Port(port_key, 1, input_config)
port.native_vlan = native_vlan
port.tagged_vlans = tagged_vlans
output_config = port.to_conf()
self.assertEqual(output_config, expected_config)
def _dp_parse_port(dp_id, p_identifier, port_conf, vlans):
port = Port(p_identifier, dp_id, port_conf)
if port.native_vlan is not None:
v_identifier = port.native_vlan
vlan = _get_vlan_by_identifier(dp_id, v_identifier, vlans)
port.native_vlan = vlan
vlan.add_untagged(port)
port_tagged_vlans = [
_get_vlan_by_identifier(dp_id, v_identifier, vlans) for v_identifier in port.tagged_vlans]
port.tagged_vlans = port_tagged_vlans
for vlan in port.tagged_vlans:
vlan.add_tagged(port)
return port
def test_config_with_port_number(self):
"""Tests the minimal config"""
port_number = 1
port_key = 'port_1'
input_config = {'number': port_number}
output_config = {'description': str(port_key), 'number': port_number}
expected_config = self.default_config
expected_config.update(input_config)
expected_config.update(output_config)
port = Port(port_key, 1, input_config)
output_config = port.to_conf()
self.assertEqual(output_config, expected_config)
def test_lacp_update(self):
"""Test updating port LACP information causes correct actor state changes"""
port = Port(1, 1, {})
# Initial state: Not configured
self.assertEqual(port.dyn_lacp_port_selected, LACP_STATE_NONE)
self.assertEqual(port.dyn_lacp_actor_state, LACP_STATE_NONE)
# Initializing
port.lacp_update(True, None, None)
self.assertEqual(port.dyn_lacp_actor_state, LACP_ACTOR_INIT)
# Receiving first packets but no sync
port.lacp_update(False, 1, 1)
self.assertEqual(port.dyn_lacp_actor_state, LACP_ACTOR_NOACT)
# Receiving sync packets
port.lacp_update(True, 1, 1)
self.assertEqual(port.dyn_lacp_actor_state, LACP_ACTOR_UP)
def test_vlans(self):
"""Test that the vlans() method behaves correctly"""
vlan100 = MockVLAN('v100')
vlan200 = MockVLAN('v200')
vlan300 = MockVLAN('v300')
tagged_vlans = [vlan200, vlan300]
native_vlan = vlan100
port = Port(1, 1, {})
port.native_vlan = native_vlan
self.assertEqual(port.vlans(), [native_vlan])
port.tagged_vlans = tagged_vlans
self.assertEqual(set(port.vlans()), set([native_vlan] + tagged_vlans))
port.native_vlan = None
self.assertEqual(set(port.vlans()), set(tagged_vlans))
def port_parser(dp_id, p_identifier, port_conf, vlans):
port = Port(p_identifier, port_conf)
if port.mirror is not None:
# ignore other config
return port
if port.native_vlan is not None:
v_identifier = port.native_vlan
vlan = _get_vlan_by_identifier(dp_id, v_identifier, vlans)
vlan.untagged.append(port)
for v_identifier in port.tagged_vlans:
vlan = _get_vlan_by_identifier(dp_id, v_identifier, vlans)
vlan.tagged.append(port)
return port
def test_vlans(self):
"""Test that the vlans() method behaves correctly"""
vlan100 = MockVLAN('v100')
vlan200 = MockVLAN('v200')
vlan300 = MockVLAN('v300')
tagged_vlans = [vlan200, vlan300]
native_vlan = vlan100
port = Port(1, 1, {})
port.native_vlan = native_vlan
self.assertIn(native_vlan, port.vlans())
port.tagged_vlans = tagged_vlans
self.assertEqual(set(port.vlans()), set([native_vlan] + tagged_vlans))
port.native_vlan = None
self.assertEqual(set(port.vlans()), set(tagged_vlans))
def _dp_parse_port(dp_id, port_key, port_conf, vlans):
def _dp_parse_native_port_vlan():
if port.native_vlan is not None:
vlan = _get_vlan_by_key(dp_id, port.native_vlan, vlans)
port.native_vlan = vlan
def _dp_parse_tagged_port_vlans():
if port.tagged_vlans:
port_tagged_vlans = [
_get_vlan_by_key(dp_id, vlan_key, vlans) for vlan_key in port.tagged_vlans]
port.tagged_vlans = port_tagged_vlans
port = Port(port_key, dp_id, port_conf)
test_config_condition(str(port_key) not in (str(port.number), port.name), (
'Port key %s match port name or port number' % port_key))
_dp_parse_native_port_vlan()
_dp_parse_tagged_port_vlans()
return port
def test_lacp_port_update(self):
"""Test LACP port options"""
port = Port(1, 1, {})
port.enabled = True
port.dyn_phys_up = True
# Port defaults to NOTCONFIGURED
self.assertEqual(port.dyn_lacp_port_selected, LACP_PORT_NOTCONFIGURED)
# Now call update to configure port and get initial state
# depending on the chosen DP
port.lacp_port_update(False)
self.assertEqual(port.dyn_lacp_port_selected, LACP_PORT_UNSELECTED)
# Now select our the port's current DP
port.lacp_port_update(True)
self.assertEqual(port.dyn_lacp_port_selected, LACP_PORT_SELECTED)
# Test option to force standby mode
# Option forces the statemachine to revert to STANDBY mode when not selected
port.lacp_standby = True
port.lacp_port_update(True)
self.assertEqual(port.dyn_lacp_port_selected, LACP_PORT_SELECTED)
port.lacp_port_update(False)
self.assertEqual(port.dyn_lacp_port_selected, LACP_PORT_STANDBY)
# Test forcing selected port
port.lacp_standby = False
port.lacp_selected = True
port.lacp_port_update(False)
self.assertEqual(port.dyn_lacp_port_selected, LACP_PORT_SELECTED)
# Test forcing unselected port
port.lacp_selected = False
port.lacp_unselected = True
port.lacp_port_update(True)
self.assertEqual(port.dyn_lacp_port_selected, LACP_PORT_UNSELECTED)
# Test reverting to unconfigured on port cold start
port.lacp_unselected = False
port.lacp_port_update(False, True)
self.assertEqual(port.dyn_lacp_port_selected, LACP_PORT_NOTCONFIGURED)
def test_lacp_flags(self):
"""Test port LACP flags returns correct flags for current port states"""
port = Port(1, 1, {})
# LACP config option to force flags on
port.lacp_collect_and_distribute = True
self.assertEqual(port.get_lacp_flags(), (1, 1, 1))
port.lacp_collect_and_distribute = False
# Port is selected, so flags should be on
port.dyn_lacp_port_selected = LACP_PORT_SELECTED
self.assertEqual(port.get_lacp_flags(), (1, 1, 1))
# Port in standby, only allow sync
port.dyn_lacp_port_selected = LACP_PORT_STANDBY
self.assertEqual(port.get_lacp_flags(), (1, 0, 0))
# Port not in standby, or selected
port.dyn_lacp_port_selected = LACP_PORT_UNSELECTED
self.assertEqual(port.get_lacp_flags(), (0, 0, 0))
port.dyn_lacp_port_selected = LACP_PORT_NOTCONFIGURED
self.assertEqual(port.get_lacp_flags(), (0, 0, 0))
def test_lacp_actor_update(self):
"""Test updating port LACP information causes correct actor state changes"""
port = Port(1, 1, {})
port.enabled = True
port.dyn_phys_up = True
# Before configuring the LACP state machine, default is notconfigured
self.assertEqual(port.dyn_lacp_port_selected, LACP_PORT_NOTCONFIGURED)
self.assertEqual(port.dyn_lacp_actor_state, LACP_ACTOR_NOTCONFIGURED)
# Move to initial configuration state when no packets have been received yet
port.lacp_actor_update(False, None, None)
self.assertEqual(port.dyn_lacp_actor_state, LACP_ACTOR_INIT)
# Receiving first packets but no SYNC bit set
port.lacp_actor_update(False, 1, 1)
self.assertEqual(port.dyn_lacp_actor_state, LACP_ACTOR_NOSYNC)
# Receiving sync packets
port.lacp_actor_update(True, 1, 1)
self.assertEqual(port.dyn_lacp_actor_state, LACP_ACTOR_UP)
# Port phys down, move to ACTOR_NONE state
port.dyn_phys_up = False
port.lacp_actor_update(True, 1, 1)
self.assertEqual(port.dyn_lacp_actor_state, LACP_ACTOR_NONE)
port.lacp_actor_update(False, None, None)
self.assertEqual(port.dyn_lacp_actor_state, LACP_ACTOR_NONE)
# Go back to init once port restarted
port.dyn_phys_up = True
port.lacp_actor_update(False, None, None)
self.assertEqual(port.dyn_lacp_actor_state, LACP_ACTOR_INIT)
# Cold starting will force the port to revert to notconfigured state
port.lacp_actor_update(False, None, None, True)
self.assertEqual(port.dyn_lacp_actor_state, LACP_ACTOR_NOTCONFIGURED)
