def test_handle_features_reply(self, *args):
"""Test handle features reply."""
(mock_freply_v0x01, mock_freply_v0x04, mock_send_desc_request_v0x01,
mock_send_desc_request_v0x04, mock_send_set_config_v0x01,
mock_send_set_config_v0x04, mock_buffers_put) = args
mock_freply_v0x01.return_value = self.switch_v0x01.connection.switch
mock_freply_v0x04.return_value = self.switch_v0x04.connection.switch
self.switch_v0x01.connection.state = ConnectionState.SETUP
self.switch_v0x01.connection.protocol.state = 'waiting_features_reply'
name = 'kytos/of_core.v0x0[14].messages.in.ofpt_features_reply'
content = {"source": self.switch_v0x01.connection}
event = get_kytos_event_mock(name=name, content=content)
self.napp.handle_features_reply(event)
mock_freply_v0x01.assert_called_with(self.napp.controller, event)
mock_send_desc_request_v0x01.assert_called_with(
self.napp.controller, self.switch_v0x01.connection.switch)
mock_send_set_config_v0x01.assert_called_with(
self.napp.controller, self.switch_v0x01.connection.switch)
self.switch_v0x04.connection.state = ConnectionState.SETUP
self.switch_v0x04.connection.protocol.state = 'waiting_features_reply'
content = {"source": self.switch_v0x04.connection}
event = get_kytos_event_mock(name=name, content=content)
self.napp.handle_features_reply(event)
mock_freply_v0x04.assert_called_with(self.napp.controller, event)
mock_send_desc_request_v0x04.assert_called_with(
self.napp.controller, self.switch_v0x04.connection.switch)
mock_send_set_config_v0x04.assert_called_with(
self.napp.controller, self.switch_v0x04.connection.switch)
mock_buffers_put.assert_called()
def test_on_handshake_completed_request_flow_list(self, *args):
"""Test request flow list."""
(mock_update_flow_list_v0x01, mock_update_flow_list_v0x04) = args
mock_update_flow_list_v0x04.return_value = "ABC"
name = 'kytos/of_core.handshake.completed'
content = {"switch": self.switch_v0x01}
event = get_kytos_event_mock(name=name, content=content)
self.napp.on_handshake_completed_request_flow_list(event)
mock_update_flow_list_v0x01.assert_called_with(self.napp.controller,
self.switch_v0x01)
content = {"switch": self.switch_v0x04}
event = get_kytos_event_mock(name=name, content=content)
self.napp.on_handshake_completed_request_flow_list(event)
mock_update_flow_list_v0x04.assert_called_with(self.napp.controller,
self.switch_v0x04)
def test_install_table_miss_flow(self, *args):
"""Test _create_flow_mod method for flow_mod 1.3 packet."""
(mock_flow_mod, mock_action, mock_instruction, mock_kytos_event,
mock_buffer_put) = args
flow_mod = MagicMock()
flow_mod.instructions = []
instruction = MagicMock()
instruction.actions = []
action = MagicMock()
mock_flow_mod.return_value = flow_mod
mock_action.return_value = action
mock_instruction.return_value = instruction
switch = get_switch_mock("00:00:00:00:00:00:00:01", 0x04)
event = get_kytos_event_mock(name='kytos/core.switch.new',
content={'switch': switch})
self.napp.install_table_miss_flow(event)
self.assertEqual(flow_mod.command, 0)
self.assertEqual(instruction.actions[0], action)
self.assertEqual(flow_mod.instructions[0], instruction)
event_call = call(name=('kytos/of_l2ls.messages.out.'
'ofpt_flow_mod'),
content={
'destination': switch.connection,
'message': flow_mod
})
mock_kytos_event.assert_has_calls([event_call])
mock_buffer_put.assert_called_once()
def test_install_table_miss_flow(self, *args):
"""Test _create_flow_mod method for flow 1.3 packet."""
(mock_get_switch_by_dpid, mock_settings, mock_requests,
mock_port13) = args
mock_port13.OFPP_CONTROLLER = 123
flow_manager_url = 'http://localhost:8181/api/kytos/flow_manager/v2'
mock_settings.FLOW_MANAGER_URL = flow_manager_url
mock_settings.TABLE_ID = 0
expected_flow = {}
expected_flow['priority'] = 0
expected_flow['table_id'] = 0
expected_flow['actions'] = [{'action_type': 'output', 'port': 123}]
dpid = "00:00:00:00:00:00:00:01"
switch = get_switch_mock(dpid, 0x04)
mock_get_switch_by_dpid.return_value = switch
destination = switch.id
endpoint = f'{flow_manager_url}/flows/{destination}'
event = get_kytos_event_mock(name='kytos/topology.switch.enabled',
content={'dpid': dpid})
self.napp.install_table_miss_flow(event)
data = {'flows': [expected_flow]}
mock_requests.post.assert_called_with(endpoint, json=data)
def test_handle_errors(self, mock_send_napp_event):
"""Test handle_errors method."""
flow = MagicMock()
self.napp._flow_mods_sent[0] = (flow, 'add')
switch = get_switch_mock("00:00:00:00:00:00:00:01")
switch.connection = get_connection_mock(
0x04, get_switch_mock("00:00:00:00:00:00:00:02"))
protocol = MagicMock()
protocol.unpack.return_value = 'error_packet'
switch.connection.protocol = protocol
message = MagicMock()
message.header.xid.value = 0
message.error_type = 2
message.code = 5
event = get_kytos_event_mock(name='.*.of_core.*.ofpt_error',
content={
'message': message,
'source': switch.connection
})
self.napp.handle_errors(event)
mock_send_napp_event.assert_called_with(flow.switch,
flow,
'error',
error_command='add',
error_code=5,
error_type=2)
def test_handle_raw_in(self, *args):
"""Test handle_raw_in."""
(mock_emit_message_in, mock_negotiate, mock_of_slicer) = args
mock_packets = MagicMock()
mock_data = MagicMock()
mock_connection = MagicMock()
mock_connection.is_new.side_effect = [True, False, True, False]
mock_connection.is_during_setup.return_value = False
mock_of_slicer.return_value = [[mock_packets, mock_packets], b'']
name = 'kytos/core.openflow.raw.in'
content = {'source': mock_connection, 'new_data': mock_data}
mock_event = get_kytos_event_mock(name=name, content=content)
self.napp.handle_raw_in(mock_event)
mock_negotiate.assert_called()
mock_emit_message_in.assert_called()
# Test Fail
mock_negotiate.side_effect = NegotiationException('Foo')
self.napp.handle_raw_in(mock_event)
self.assertEqual(mock_connection.close.call_count, 1)
mock_connection.close.call_count = 0
mock_connection.protocol.unpack.side_effect = AttributeError()
self.napp.handle_raw_in(mock_event)
self.assertEqual(mock_connection.close.call_count, 1)
def test_handle_lldp_flows(self, mock_post, mock_delete):
"""Test handle_lldp_flow method."""
dpid = "00:00:00:00:00:00:00:01"
switch = get_switch_mock("00:00:00:00:00:00:00:01", 0x04)
self.napp.controller.switches = {dpid: switch}
event_post = get_kytos_event_mock(name='kytos/topology.switch.enabled',
content={'dpid': dpid})
event_del = get_kytos_event_mock(name='kytos/topology.switch.disabled',
content={'dpid': dpid})
self.napp.handle_lldp_flows(event_post)
mock_post.assert_called()
self.napp.handle_lldp_flows(event_del)
mock_delete.assert_called()
def test_handle_openflow_in_hello_failed(self):
"""Test handle_openflow_in_hello_failed."""
mock_destination = MagicMock()
content = {'destination': mock_destination}
mock_event = get_kytos_event_mock(name='kytos/of_core',
content=content)
self.napp.handle_openflow_in_hello_failed(mock_event)
self.assertEqual(mock_event.destination.close.call_count, 1)
def test_handle_features_request_sent(self):
"""Test tests_handle_features_request_sent."""
mock_protocol = MagicMock()
mock_protocol.protocol.state = 'sending_features'
expected = 'waiting_features_reply'
name = 'kytos/of_core.v0x0[14].messages.out.ofpt_features_request'
content = {'destination': mock_protocol}
mock_event = get_kytos_event_mock(name=name, content=content)
self.napp.handle_features_request_sent(mock_event)
self.assertEqual(mock_event.destination.protocol.state, expected)
def test_event_delete_failure_case(self, *args):
"""Test event_delete method to failure case."""
(mock_delete_metadata, _) = args
event = get_kytos_event_mock(name='kytos.storehouse.delete',
content={})
self.napp.event_delete(event)
self.napp.backend.delete.assert_not_called()
mock_delete_metadata.assert_not_called()
def test_event_list_success_case(self, mock_execute_callback):
"""Test event_list method to success case."""
result = MagicMock()
self.napp.backend.list.return_value = result
event = get_kytos_event_mock(name='kytos.storehouse.list',
content={'namespace': 'namespace'})
self.napp.event_list(event)
mock_execute_callback.assert_called_with(event, result, None)
def test_event_list_failure_case(self, mock_execute_callback):
"""Test event_list method to failure case."""
error = KeyError()
self.napp.backend.list.side_effect = [error]
event = get_kytos_event_mock(name='kytos.storehouse.list',
content={'namespace': 'namespace'})
self.napp.event_list(event)
mock_execute_callback.assert_called_with(event, None, error)
def test_kytos_event_mock(self):
"""Test kytos_event mock."""
kytos_event_mock = get_kytos_event_mock(name='event',
content={
'message': 'msg',
'destination': 'dest',
'source': 'src'
})
self.assertEqual(kytos_event_mock.name, 'event')
self.assertEqual(kytos_event_mock.message, 'msg')
self.assertEqual(kytos_event_mock.destination, 'dest')
self.assertEqual(kytos_event_mock.source, 'src')
def test_event_update_failure_case(self, mock_execute_callback):
"""Test event_update method to failure case."""
self.napp.backend.retrieve.return_value = None
event = get_kytos_event_mock(name='kytos.storehouse.update',
content={
'namespace': 'namespace',
'box_id': '123'
})
self.napp.event_update(event)
self.napp.backend.update.assert_not_called()
def test_event_add_flow(self, mock_install_flows):
"""Test method for installing flows on the switches through events."""
dpid = "00:00:00:00:00:00:00:01"
switch = get_switch_mock(dpid)
self.napp.controller.switches = {dpid: switch}
mock_flow_dict = MagicMock()
event = get_kytos_event_mock(name='kytos.flow_manager.flows.install',
content={
'dpid': dpid,
'flow_dict': mock_flow_dict
})
self.napp.event_flows_install_delete(event)
mock_install_flows.assert_called_with('add', mock_flow_dict, [switch])
def test_event_update_success_case(self, mock_execute_callback):
"""Test event_update method to success case."""
box = MagicMock()
self.napp.backend.retrieve.return_value = box
event = get_kytos_event_mock(name='kytos.storehouse.update',
content={
'namespace': 'namespace',
'box_id': '123'
})
self.napp.event_update(event)
self.napp.backend.update.assert_called_with('namespace', box)
def test_handle_packet_in(self, *args):
"""Test handle_packet_in method."""
(mock_ethernet, mock_kytos_event, mock_create_flow_mod,
mock_create_packet_out, mock_buffer_put) = args
ethernet = MagicMock()
mock_ethernet.return_value = ethernet
flow_mod = MagicMock()
mock_create_flow_mod.return_value = flow_mod
packet_out = MagicMock()
mock_create_packet_out.return_value = packet_out
ports = [1, 2]
switch = get_switch_mock("00:00:00:00:00:00:00:01", 0x04)
switch.where_is_mac.return_value = ports
message = MagicMock()
message.reason = 0
message.in_port = 1
event = get_kytos_event_mock(name='kytos/of_core.v0x0[14].messages.in.'
'ofpt_packet_in',
content={
'source': switch.connection,
'message': message
})
self.napp.handle_packet_in(event)
switch.update_mac_table.assert_called_with(ethernet.source,
message.in_port)
mock_create_flow_mod.assert_called_with(switch.ofp_version, ethernet,
ports[0])
mock_create_packet_out.assert_called_with(switch.ofp_version, message,
ports)
calls = [
call(name=('kytos/of_l2ls.messages.out.'
'ofpt_flow_mod'),
content={
'destination': event.source,
'message': flow_mod
}),
call(name=('kytos/of_l2ls.messages.out.'
'ofpt_packet_out'),
content={
'destination': event.source,
'message': packet_out
})
]
mock_kytos_event.assert_has_calls(calls)
self.assertEqual(mock_buffer_put.call_count, 2)
def test_handle_multipart_reply(self, *args):
"""Test handle multipart reply."""
(mock_of_core_v0x04_utils, mock_from_of_flow_stats_v0x04) = args
flow_msg = MagicMock()
flow_msg.multipart_type = MultipartType.OFPMP_FLOW
name = 'kytos/of_core.v0x04.messages.in.ofpt_multipart_reply'
content = {"source": self.switch_v0x04.connection, "message": flow_msg}
event = get_kytos_event_mock(name=name, content=content)
self.napp.handle_multipart_reply(event)
mock_from_of_flow_stats_v0x04.assert_called_with(
flow_msg, self.switch_v0x04.connection.switch)
ofpmp_port_desc = MagicMock()
ofpmp_port_desc.body = "A"
ofpmp_port_desc.multipart_type = MultipartType.OFPMP_PORT_DESC
content = {
"source": self.switch_v0x04.connection,
"message": ofpmp_port_desc
}
event = get_kytos_event_mock(name=name, content=content)
self.napp.handle_multipart_reply(event)
mock_of_core_v0x04_utils.assert_called_with(
self.napp.controller, self.switch_v0x04.connection.switch,
ofpmp_port_desc.body)
ofpmp_desc = MagicMock()
ofpmp_desc.body = "A"
ofpmp_desc.multipart_type = MultipartType.OFPMP_DESC
content = {
"source": self.switch_v0x04.connection,
"message": ofpmp_desc
}
event = get_kytos_event_mock(name=name, content=content)
switch_update = self.switch_v0x04.connection.switch.update_description
self.napp.handle_multipart_reply(event)
self.assertEqual(switch_update.call_count, 1)
def test_handle_stats_reply(self, mock_from_of_flow_stats_v0x01):
"""Test handle stats reply."""
mock_from_of_flow_stats_v0x01.return_value = "ABC"
flow_msg = MagicMock()
flow_msg.body = "A"
flow_msg.body_type = StatsType.OFPST_FLOW
name = 'kytos/of_core.v0x01.messages.in.ofpt_stats_reply'
content = {"source": self.switch_v0x01.connection, "message": flow_msg}
event = get_kytos_event_mock(name=name, content=content)
self.napp.handle_stats_reply(event)
mock_from_of_flow_stats_v0x01.assert_called_with(
flow_msg.body, self.switch_v0x01.connection.switch)
desc_msg = MagicMock()
desc_msg.body = "A"
desc_msg.body_type = StatsType.OFPST_DESC
content = {"source": self.switch_v0x01.connection, "message": desc_msg}
event = get_kytos_event_mock(name=name, content=content)
switch_update = self.switch_v0x01.connection.switch.update_description
self.napp.handle_stats_reply(event)
self.assertEqual(switch_update.call_count, 1)
def test_event_delete_success_case(self, *args):
"""Test event_delete method to success case."""
(mock_delete_metadata, _) = args
self.napp.backend.delete.return_value = 'result'
event = get_kytos_event_mock(name='kytos.storehouse.delete',
content={
'namespace': 'namespace',
'box_id': '123'
})
self.napp.event_delete(event)
self.napp.backend.delete.assert_called_once_with('namespace', '123')
mock_delete_metadata.assert_called_once_with('namespace', '123')
def test_handle_errors(self, mock_send_napp_event):
"""Test handle_errors method."""
flow = MagicMock()
self.napp._flow_mods_sent[0] = flow
message = MagicMock()
message.header.xid.value = 0
message.error_type = 2
message.code = 5
event = get_kytos_event_mock(name='.*.of_core.*.ofpt_error',
content={'message': message})
self.napp.handle_errors(event)
mock_send_napp_event.assert_called_with(flow.switch, flow, 'error',
error_code=5, error_type=2)
def test_event_create_failure_case(self, *args):
"""Test event_create method to failure case."""
(mock_search_metadata_by, mock_add_metadata_to_cache, _) = args
mock_search_metadata_by.return_value = True
event = get_kytos_event_mock(name='kytos.storehouse.create',
content={
'namespace': 'namespace',
'box_id': '123',
'data': 'data'
})
self.napp.event_create(event)
self.napp.backend.create.assert_not_called()
mock_add_metadata_to_cache.assert_not_called()
def test_event_create_success_case(self, *args):
"""Test event_create method to success case."""
(mock_search_metadata_by, mock_add_metadata_to_cache, _,
mock_box) = args
mock_search_metadata_by.return_value = False
event = get_kytos_event_mock(name='kytos.storehouse.create',
content={
'namespace': 'namespace',
'box_id': 'box_id',
'data': 'data'
})
self.napp.event_create(event)
self.napp.backend.create.assert_called_with(mock_box.return_value)
mock_add_metadata_to_cache.assert_called_with(mock_box.return_value)
def test_install_lldp_flow(self, *args):
"""Test install_lldp_flow method."""
(mock_build_lldp_packet_out, mock_kytos_event, mock_buffer_put) = args
switch = get_switch_mock("00:00:00:00:00:00:00:01", 0x04)
event = get_kytos_event_mock(name='kytos/of_core.handshake.completed',
content={'switch': switch})
mock_build_lldp_packet_out.side_effect = ['flow_mod', None]
mock_kytos_event.return_value = 'ofpt_flow_mod'
self.napp.install_lldp_flow(event)
switch.connection = None
self.napp.install_lldp_flow(event)
mock_buffer_put.assert_called_once_with('ofpt_flow_mod')
def test_notify_uplink_detected(self, *args):
"""Test notify_uplink_detected method."""
(mock_ethernet, mock_lldp, mock_dpid, mock_ubint32,
mock_unpack_non_empty, mock_get_switch_by_dpid, mock_kytos_event,
mock_buffer_put) = args
switch = get_switch_mock("00:00:00:00:00:00:00:01", 0x04)
message = MagicMock()
message.in_port = 1
message.data = 'data'
event = get_kytos_event_mock(name='kytos/of_core.v0x0[14].messages.in.'
'ofpt_packet_in',
content={
'source': switch.connection,
'message': message
})
ethernet = MagicMock()
ethernet.ether_type = 0x88CC
ethernet.data = 'eth_data'
lldp = MagicMock()
lldp.chassis_id.sub_value = 'chassis_id'
lldp.port_id.sub_value = 'port_id'
dpid = MagicMock()
dpid.value = "00:00:00:00:00:00:00:02"
port_b = MagicMock()
mock_unpack_non_empty.side_effect = [ethernet, lldp, dpid, port_b]
mock_get_switch_by_dpid.return_value = get_switch_mock(
dpid.value, 0x04)
mock_kytos_event.return_value = 'nni'
self.napp.notify_uplink_detected(event)
calls = [
call(mock_ethernet, message.data),
call(mock_lldp, ethernet.data),
call(mock_dpid, lldp.chassis_id.sub_value),
call(mock_ubint32, lldp.port_id.sub_value)
]
mock_unpack_non_empty.assert_has_calls(calls)
mock_buffer_put.assert_called_with('nni')
