def test__on_flow_delete_enabled_False(self):
Dispatcher = Mock()
Dispatcher.network_id = "NetworkId"
Network_id = "NetworkId"
flow_body1 = Flow("BasicFlow", "v01", "FlowId1", "Owner", False, 65535,
"none", {})
flow_body2 = Flow("BasicFlow", "v01", "FlowId1", "Owner", True, 65535,
"established", {})
self.target._network_interfaces["NetworkId"] =\
NetworkInterface(Dispatcher, Network_id)
with nested(
patch(
'org.o3project.odenos.core.util.network_interface.'
'NetworkInterface.get_flow',
return_value=flow_body1),
patch('org.o3project.odenos.core.util.network_interface.'
'NetworkInterface.put_flow')) as (m_get_flow,
m_put_flow):
self.target._on_flow_delete("NetworkId", flow_body2)
self.assertEqual(m_get_flow.call_count, 1)
m_get_flow.assert_any_call("FlowId1")
self.assertEqual(m_put_flow.call_count, 0)
self.assertEqual(flow_body1.status, "none")
def test_create_from_packed(self):
Type = "BasicFlow"
Version = "v02"
Flow_id = "Id02"
Owner = "Owner"
Enabled = True
Priority = "65535"
Status = "none"
Attributes = {
"bandwidth": "20Mbps",
"req_bandwidth": "11Mbps",
"latency": "30msec",
"req_latency": "11msec"
}
Publisher_id = 'Id1'
Event_type = 'flowchanged'
flow_target = Flow(Type, Version, Flow_id, Owner, Enabled, Priority,
Status, Attributes)
value = [Publisher_id, Event_type, flow_target]
self.result = self.target.create_from_packed(value)
self.assertEqual(self.result.publisher_id, self.Publisher_id)
self.assertEqual(self.result.event_type, self.Event_type)
self.assertEqual(self.result.body, flow_target)
def _delete_flow_conversion(self, network_id, flow):
logging.debug(">> %s", stack()[0][3])
resp_list = {}
if network_id is None or flow is None:
return resp_list
dst_flows = self._conversion_table.get_flow(network_id,
flow.flow_id)
for dst_flow in dst_flows:
flow_id = dst_flow.split("::")
if flow_id[0] not in self._network_interfaces:
continue
network_if = self._network_interfaces[flow_id[0]]
resp = network_if.del_flow(flow_id[1])
resp_flow = None
if resp.body is not None:
try:
resp_flow = Flow.create_from_packed(resp.body)
except KeyError, err:
logging.error("DELETE Flow Invalid Response Message"
+ " KeyError: " + str(err))
return None
resp_list[dst_flow] = resp_flow
class ResponseTest(unittest.TestCase):
Type = "BasicFlow"
Version = "v01"
Flow_id = "Id01"
Owner = "Owner"
Enabled = True
Priority = "65535"
Status = "none"
Attributes = {
"bandwidth": "10Mbps",
"req_bandwidth": "11Mbps",
"latency": "10msec",
"req_latency": "11msec"
}
Publisher_id = 'Id1'
Event_type = 'flow'
value = {
"type": Type,
"version": Version,
"flow_id": Flow_id,
"owner": Owner,
"enabled": Enabled,
"priority": Priority,
"status": Status,
"attributes": Attributes
}
Packed = [Response.StatusCode.OK, value]
flow_target = Flow(Type, Version, Flow_id, Owner, Enabled, Priority,
Status, Attributes)
flow_target_packed_object = flow_target.packed_object()
def setUp(self):
self.target = Response(Response.StatusCode.OK, self.flow_target)
def tearDown(self):
self.target = None
def test_constructor_hasattr_True(self):
self.assertEqual(self.target.status_code, Response.StatusCode.OK)
self.assertEqual(self.target.body, self.value)
def test_constructor_hasattr_Falseself(self):
self.target2 = Response(Response.StatusCode.CREATED, self.value)
self.assertEqual(self.target2.status_code, Response.StatusCode.CREATED)
self.assertEqual(self.target2.body, self.value)
def test_is_error_method_GET_status_code_OK(self):
self.result = Response(Response.StatusCode.OK, self.flow_target)
self.assertEqual(self.result.is_error("GET"), False)
def test_is_error_method_GET_status_code_NotOK(self):
self.result = Response(Response.StatusCode.CREATED, self.flow_target)
self.assertEqual(self.result.is_error("GET"), True)
def test_is_error_method_DELETE_status_code_OK(self):
self.result = Response(Response.StatusCode.OK, self.flow_target)
self.assertEqual(self.result.is_error("DELETE"), False)
def test_is_error_method_DELETE_status_code_NotOK(self):
self.result = Response(Response.StatusCode.CREATED, self.flow_target)
self.assertEqual(self.result.is_error("DELETE"), True)
def test_is_error_method_PUT_status_code_OK(self):
self.result = Response(Response.StatusCode.OK, self.flow_target)
self.assertEqual(self.result.is_error("PUT"), False)
def test_is_error_method_PUT_status_code_CREATED(self):
self.result = Response(Response.StatusCode.CREATED, self.flow_target)
self.assertEqual(self.result.is_error("PUT"), False)
def test_is_error_method_PUT_status_code_NotOKandCREATED(self):
self.result = Response(Response.StatusCode.ACCEPTED, self.flow_target)
self.assertEqual(self.result.is_error("PUT"), True)
def test_is_error_method_other_status_code_OK(self):
self.result = Response(Response.StatusCode.OK, self.flow_target)
self.assertEqual(self.result.is_error("POST"), False)
def test_is_error_method_other_status_code_CREATED(self):
self.result = Response(Response.StatusCode.CREATED, self.flow_target)
self.assertEqual(self.result.is_error("POST"), False)
def test_is_error_method_other_status_code_NotOKandCREATED(self):
self.result = Response(Response.StatusCode.ACCEPTED, self.flow_target)
self.assertEqual(self.result.is_error("POST"), True)
def test_create_from_packed(self):
self.result = self.target.create_from_packed(self.Packed)
self.assertEqual(self.result.status_code, Response.StatusCode.OK)
self.assertEqual(self.result.body, self.value)
def test_packed_object(self):
self.result = self.target.packed_object()
self.assertEqual(self.result, (Response.StatusCode.OK, self.value))
self.assertEqual(len(self.result), 2)
class EventTest(unittest.TestCase):
Type = "BasicFlow"
Version = "v01"
Flow_id = "Id01"
Owner = "Owner"
Enabled = True
Priority = "65535"
Status = "none"
Attributes = {
"bandwidth": "10Mbps",
"req_bandwidth": "11Mbps",
"latency": "10msec",
"req_latency": "11msec"
}
Publisher_id = 'Id1'
Event_type = 'flowchanged'
flow_target = Flow(Type, Version, Flow_id, Owner, Enabled, Priority,
Status, Attributes)
flow_target_packed_object = flow_target.packed_object()
def setUp(self):
self.target = Event(self.Publisher_id, self.Event_type,
self.flow_target)
def tearDown(self):
self.target = None
def test_constructor(self):
self.assertEqual(self.target.publisher_id, self.Publisher_id)
self.assertEqual(self.target.event_type, self.Event_type)
self.assertEqual(self.target.body, self.flow_target)
def test_create_from_packed(self):
Type = "BasicFlow"
Version = "v02"
Flow_id = "Id02"
Owner = "Owner"
Enabled = True
Priority = "65535"
Status = "none"
Attributes = {
"bandwidth": "20Mbps",
"req_bandwidth": "11Mbps",
"latency": "30msec",
"req_latency": "11msec"
}
Publisher_id = 'Id1'
Event_type = 'flowchanged'
flow_target = Flow(Type, Version, Flow_id, Owner, Enabled, Priority,
Status, Attributes)
value = [Publisher_id, Event_type, flow_target]
self.result = self.target.create_from_packed(value)
self.assertEqual(self.result.publisher_id, self.Publisher_id)
self.assertEqual(self.result.event_type, self.Event_type)
self.assertEqual(self.result.body, flow_target)
def test_packed_object_hasattr_True(self):
self.result = self.target.packed_object()
self.assertEqual(self.result[0], self.Publisher_id)
self.assertEqual(self.result[1], self.Event_type)
self.assertEqual(self.result[2], self.flow_target_packed_object)
def test_packed_object_hasattr_False(self):
self.newtarget = Event(self.Publisher_id, self.Event_type,
self.flow_target_packed_object)
self.result = self.newtarget.packed_object()
self.assertEqual(self.result[0], self.Publisher_id)
self.assertEqual(self.result[1], self.Event_type)
self.assertEqual(self.result[2], self.flow_target_packed_object)
def _update_flow_conversion(self, network_id,
flow_prev, flow_curr, attributes):
logging.debug(">> %s", stack()[0][3])
resp_list = {}
if network_id is None or flow_curr is None:
return resp_list
attributes_list = []
if attributes is None:
attributes_list = []
else:
attributes_list = attributes
# get ignore list
flow_ignore_keys = self.__get_ignore_keys(self.keys_flow, attributes)
flow_ignore_attributes = self.__get_ignore_keys(self.attributes_flow,
attributes_list)
for dst_flow in self._conversion_table.get_flow(network_id,
flow_curr.flow_id):
flow_id = dst_flow.split("::")
if flow_id[0] not in self._network_interfaces:
continue
network_if = self._network_interfaces[flow_id[0]]
# get flow
flow = network_if.get_flow(flow_id[1])
if flow is None:
continue
# key copy (curr -> body)
updated = False
if ("enabled" not in flow_ignore_keys
and flow.enabled != flow_curr.enabled):
updated = True
flow.enabled = flow_curr.enabled
if ("priority" not in flow_ignore_keys
and flow.priority != flow_curr.priority):
updated = True
flow.priority = flow_curr.priority
if ("status" not in flow_ignore_keys
and flow.status != flow_curr.status):
updated = True
flow.status = flow_curr.status
# attr copy (curr -> body)
curr_attr = flow_curr.attributes
for attr_key in curr_attr:
if (attr_key in flow_ignore_attributes or
(attr_key in flow.attributes and
flow.attributes[attr_key] == curr_attr[attr_key])):
continue
updated = True
flow.attributes[attr_key] = \
flow_curr.attributes[attr_key]
# put flow
if updated:
resp = network_if.put_flow(flow)
try:
resp_flow = Flow.create_from_packed(resp.body)
resp_list[dst_flow] = resp_flow
except KeyError, err:
logging.error("PUT Flow Invalid Response Message"
+ " KeyError: " + str(err))
class RequestTest(unittest.TestCase):
Type = "BasicFlow"
Version = "v01"
Flow_id = "Id01"
Owner = "Owner"
Enabled = True
Priority = "65535"
Status = "none"
Attributes = {
"bandwidth": "10Mbps",
"req_bandwidth": "11Mbps",
"latency": "10msec",
"req_latency": "11msec"
}
Publisher_id = 'Id1'
Event_type = 'flow'
value = {
"type": Type,
"version": Version,
"flow_id": Flow_id,
"owner": Owner,
"enabled": Enabled,
"priority": Priority,
"status": Status,
"attributes": Attributes
}
Packed = ["FlowId2", Request.Method.GET, "flows/FlowId2", value]
flow_target = Flow(Type, Version, Flow_id, Owner, Enabled, Priority,
Status, Attributes)
flow_target_packed_object = flow_target.packed_object()
def setUp(self):
self.target = Request("FlowId1", Request.Method.GET, "flows/FlowId1",
self.flow_target)
def tearDown(self):
self.target = None
def test_constructor_hasattr_True(self):
self.assertEqual(self.target.object_id, "FlowId1")
self.assertEqual(self.target.method, Request.Method.GET)
self.assertEqual(self.target.path, "flows/FlowId1")
self.assertEqual(self.target.body, self.value)
def test_constructor_hasattr_False(self):
self.target2 = Request("FlowId2", Request.Method.GET, "flows/FlowId2",
self.value)
self.assertEqual(self.target2.object_id, "FlowId2")
self.assertEqual(self.target2.method, Request.Method.GET)
self.assertEqual(self.target2.path, "flows/FlowId2")
self.assertEqual(self.target2.body, self.value)
def test_create_from_packed(self):
self.result = self.target.create_from_packed(self.Packed)
self.assertEqual(self.result.object_id, "FlowId2")
self.assertEqual(self.result.method, Request.Method.GET)
self.assertEqual(self.result.path, "flows/FlowId2")
self.assertEqual(self.result.body, self.value)
def test_packed_object(self):
self.result = self.target.packed_object()
self.assertEqual(
self.result,
("FlowId1", Request.Method.GET, "flows/FlowId1", self.value))
self.assertEqual(len(self.result), 4)
def setUp(self):
self.target = Flow(self.Type, self.Version, self.Flow_id, self.Owner,
self.Enabled, self.Priority, self.Status,
self.Attributes)
class FlowTest(unittest.TestCase):
Type = "BasicFlow"
Version = "v01"
Flow_id = "Id01"
Owner = "Owner"
Enabled = True
Priority = 65535
Status = "none"
Attributes = {"bandwidth": 10, "req_bandwidth": 11,
"latency": 10, "req_latency": 11}
def setUp(self):
self.target = Flow(self.Type, self.Version, self.Flow_id, self.Owner,
self.Enabled, self.Priority, self.Status,
self.Attributes)
def tearDown(self):
self.target = None
def test_constructor(self):
self.assertEqual(self.target._body[self.target.TYPE],
self.Type)
self.assertEqual(self.target._body[self.target.VERSION],
self.Version)
self.assertEqual(self.target._body[self.target.FLOW_ID],
self.Flow_id)
self.assertEqual(self.target._body[self.target.OWNER],
self.Owner)
self.assertEqual(self.target._body[self.target.ENABLED],
self.Enabled)
self.assertEqual(self.target._body[self.target.PRIORITY],
self.Priority)
self.assertEqual(self.target._body[self.target.STATUS],
self.Status)
self.assertEqual(self.target._body[self.target.ATTRIBUTES],
self.Attributes)
def test_type_property(self):
self.assertEqual(self.target.type, self.Type)
def test_version_property(self):
self.assertEqual(self.target.version, self.Version)
def test_flow_id_property(self):
self.assertEqual(self.target.flow_id, self.Flow_id)
def test_owner_property(self):
self.assertEqual(self.target.owner, self.Owner)
def test_enabled_property(self):
self.assertEqual(self.target.enabled, self.Enabled)
def test_enabled_setter(self):
self.assertEqual(self.target._body[self.target.ENABLED],
self.Enabled)
self.target.enabled = False
self.assertEqual(self.target._body[self.target.ENABLED],
False)
def test_priority_property(self):
self.assertEqual(self.target.priority, self.Priority)
def test_priority_setter(self):
self.assertEqual(self.target._body[self.target.PRIORITY],
self.Priority)
self.target.priority = 0
self.assertEqual(self.target._body[self.target.PRIORITY],
0)
def test_status_property(self):
self.assertEqual(self.target.status, self.Status)
def test_status_setter(self):
self.assertEqual(self.target._body[self.target.STATUS],
self.Status)
self.target.status = "establishing"
self.assertEqual(self.target._body[self.target.STATUS],
"establishing")
def test_attributes_property(self):
self.assertEqual(self.target.attributes, self.Attributes)
def test_create_from_packed_Version_NotNone(self):
Type2 = "OFPFlow"
Version2 = "v02"
Flow_id2 = "Id02"
Owner2 = "Owner2"
Enabled2 = False
Priority2 = 1
Status2 = "established"
Attributes2 = {"bandwidth": 12, "req_bandwidth": 13,
"latency": 12, "req_latency": 13}
self.value = {"type": Type2, "version": Version2,
"flow_id": Flow_id2, "owner": Owner2,
"enabled": Enabled2, "priority": Priority2,
"status": Status2, "attributes": Attributes2}
self.result = self.target.create_from_packed(self.value)
self.assertEqual(self.result._body[self.target.TYPE],
Type2)
self.assertEqual(self.result._body[self.target.VERSION],
Version2)
self.assertEqual(self.result._body[self.target.FLOW_ID],
Flow_id2)
self.assertEqual(self.result._body[self.target.OWNER],
Owner2)
self.assertEqual(self.result._body[self.target.ENABLED],
Enabled2)
self.assertEqual(self.result._body[self.target.PRIORITY],
Priority2)
self.assertEqual(self.result._body[self.target.STATUS],
Status2)
self.assertEqual(self.result._body[self.target.ATTRIBUTES],
Attributes2)
def test_create_from_packed_Version_None(self):
Type2 = "OFPFlow"
Flow_id2 = "Id02"
Owner2 = "Owner2"
Enabled2 = False
Priority2 = 1
Status2 = "established"
Attributes2 = {"bandwidth": 12, "req_bandwidth": 13,
"latency": 12, "req_latency": 13}
self.value = {"type": Type2,
"flow_id": Flow_id2, "owner": Owner2,
"enabled": Enabled2, "priority": Priority2,
"status": Status2, "attributes": Attributes2}
self.result = self.target.create_from_packed(self.value)
self.assertEqual(self.result._body[self.target.TYPE],
Type2)
self.assertEqual(self.result._body[self.target.VERSION],
None)
self.assertEqual(self.result._body[self.target.FLOW_ID],
Flow_id2)
self.assertEqual(self.result._body[self.target.OWNER],
Owner2)
self.assertEqual(self.result._body[self.target.ENABLED],
Enabled2)
self.assertEqual(self.result._body[self.target.PRIORITY],
Priority2)
self.assertEqual(self.result._body[self.target.STATUS],
Status2)
self.assertEqual(self.result._body[self.target.ATTRIBUTES],
Attributes2)
def test_packed_object(self):
self.result = self.target.packed_object()
self.assertEqual(self.result[self.target.TYPE],
self.Type)
self.assertEqual(self.result[self.target.VERSION],
self.Version)
self.assertEqual(self.result[self.target.FLOW_ID],
self.Flow_id)
self.assertEqual(self.result[self.target.OWNER],
self.Owner)
self.assertEqual(self.result[self.target.ENABLED],
self.Enabled)
self.assertEqual(self.result[self.target.PRIORITY],
self.Priority)
self.assertEqual(self.result[self.target.STATUS],
self.Status)
self.assertEqual(self.result[self.target.ATTRIBUTES],
self.Attributes)
