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)