def action(self, request):
path_match = False
for rule in self.__rules:
matched = re.search(rule[self.PATTERN], request.path)
if not matched:
continue
path_match = True
if request.method != rule[self.METHOD]:
continue
if rule[self.PARAMS] == 0:
return rule[self.FUNC]()
elif rule[self.PARAMS] == 1:
if request.body is None:
return rule[self.FUNC](*matched.groups())
else:
return rule[self.FUNC](request.body)
else:
if request.body is None:
return rule[self.FUNC](*matched.groups())
else:
return rule[self.FUNC](request.body, *matched.groups())
if path_match:
return Response(Response.StatusCode.METHOD_NOT_ALLOWED, None)
return Response(Response.StatusCode.NOT_FOUND, None)
def test__del_object_to_remote_object_StatusCode_NotOK(self):
Path = RemoteObjectInterface.PROPETY_PATH
method = Request.Method.DELETE
_object_id = self.object_id
status_code = Response.StatusCode.NOT_FOUND
debug_log = "Error Response DELETE DestID:" + _object_id\
+ " Path:" + Path\
+ " StatusCode:" + str(status_code)
value = "propertyBody"
with nested(
patch(
'org.o3project.odenos.core.util.remote_object_interface.'
'RemoteObjectInterface.'
'_RemoteObjectInterface__send_request',
return_value=Response(status_code, value)),
patch('logging.debug')) as (m_send_request, m_log_debug):
self.result = self.target._del_object_to_remote_object(Path, value)
self.assertEqual(m_send_request.call_count, 1)
m_send_request.assert_any_call(_object_id,
method,
Path,
body=value)
self.assertEqual(m_log_debug.call_count, 1)
m_log_debug.assert_any_call(debug_log)
self.assertNotEqual(self.result, None)
def test_get_connection_arg_ComponentConnectio_success(self):
ComponentConnectioTmp = ComponentConnection("slicer1network",
"original",
"running")
body = ComponentConnectioTmp.packed_object()
with nested(
patch('org.o3project.odenos.core.util.remote_object_interface.'
'RemoteObjectInterface._get_object_to_remote_object',
return_value=Response(Response.StatusCode.OK,
body)),
patch('org.o3project.odenos.remoteobject.manager.system.'
'component_connection.ComponentConnection.'
'create_from_packed',
return_value=ComponentConnection.create_from_packed(
body)),
patch('org.o3project.odenos.remoteobject.manager.system.'
'component_connection_logic_and_network.'
'ComponentConnectionLogicAndNetwork.create_from_packed'),
patch('logging.error'
)) as (m_get_object,
m_Connection,
m_LogicAndNetwork,
m_log_error):
self.result = self.target.get_connection("slicer1network")
self.assertEqual(m_get_object.call_count, 1)
m_get_object.assert_any_call(SystemManagerInterface.
CONNECTION_PATH %
"slicer1network")
self.assertEqual(m_Connection.call_count, 1)
m_Connection.assert_any_call(body)
self.assertEqual(m_LogicAndNetwork.call_count, 0)
self.assertNotEqual(self.result, None)
self.assertEqual(self.result.packed_object(), body)
self.assertEqual(m_log_error.call_count, 0)
def _do_get_component_types(self):
comp_types = {}
tmp = None
try:
for type_name, clazz in self.remote_object_classes.items():
comp_id = "%s_%s" % (self.object_id, type_name)
component = clazz(comp_id, None)
obj_prop = component.object_property
component = None
type = obj_prop.get_property(ObjectProperty.OBJECT_TYPE)
super_type = obj_prop.get_property(
ObjectProperty.OBJECT_SUPER_TYPE)
connection_types = {}
connection_types_str = obj_prop.get_property(
ObjectProperty.CONNECTION_TYPES)
conn_type_list = connection_types_str.split(",")
for type_elem in conn_type_list:
type_elem_list = type_elem.split(":")
if len(type_elem_list) == 2:
connection_types[type_elem_list[0]] = type_elem_list[1]
description = obj_prop.get_property(ObjectProperty.DESCRIPTION)
target = ComponentType(type, super_type, connection_types,
description)
comp_types[type_name] = target.packed_object()
except Exception, e:
return Response(Response.StatusCode.INTERNAL_SERVER_ERROR, str(e))
def test_get_connection_arg_is_error_NG(self):
with nested(
patch('org.o3project.odenos.core.util.remote_object_interface.'
'RemoteObjectInterface._get_object_to_remote_object',
return_value=Response(Response.StatusCode.NOT_FOUND,
None)),
patch('org.o3project.odenos.remoteobject.manager.system.'
'component_connection.ComponentConnection.'
'create_from_packed'),
patch('org.o3project.odenos.remoteobject.manager.system.'
'component_connection_logic_and_network.'
'ComponentConnectionLogicAndNetwork.create_from_packed'),
patch('logging.error'
)) as (m_get_object,
m_Connection,
m_LogicAndNetwork,
m_log_error):
self.result = self.target.get_connection("slicer1network")
self.assertEqual(m_get_object.call_count, 1)
m_get_object.assert_any_call(SystemManagerInterface.
CONNECTION_PATH %
"slicer1network")
self.assertEqual(m_Connection.call_count, 0)
self.assertEqual(m_LogicAndNetwork.call_count, 0)
self.assertEqual(self.result, None)
self.assertEqual(m_log_error.call_count, 0)
def test_register_to_system_manager_success(self):
self.target._request = MagicMock()
self.target._ComponentManager__register_component_managers =\
MagicMock()
register_component_managers =\
self.target._ComponentManager__register_component_managers
self.target._ComponentManager__register_event_manager =\
MagicMock()
register_event_manager =\
self.target._ComponentManager__register_event_manager
self.target._ComponentManager__subscribe_event =\
MagicMock()
subscribe_event =\
self.target._ComponentManager__subscribe_event
self.value = {
"id": "123456",
"super_type": "Network",
"type": "Network",
"base_uri": "http://example.com:123456",
"state": "running",
"description": "NetworkComponent"
}
self.target._request.return_value = Response(Response.StatusCode.OK,
self.value)
with patch('logging.debug') as m_logging_debug:
self.target.register_to_system_manager()
self.assertEqual(m_logging_debug.call_count, 1)
self.assertEqual(register_component_managers.call_count, 1)
self.assertEqual(register_event_manager.call_count, 1)
self.assertEqual(subscribe_event.call_count, 1)
self.target._ComponentManager__register_component_managers.close()
self.target._ComponentManager__register_event_manager.close()
self.target._ComponentManager__subscribe_event.close()
def send_request_message(self, request):
# for deep copy of Request object
obj = msgpack.unpackb(msgpack.packb(request.packed_object()))
rcv_request = Request.create_from_packed(obj)
response = self.dispatcher.dispatch_request(rcv_request)
# for deep copy of Response object
obj = msgpack.unpackb(msgpack.packb(response.packed_object()))
return Response.create_from_packed(obj)
def test_Future_set(self):
self.target = self.target.Future()
response = Response(200, "body")
self.target.set(response)
self.assertEqual(self.target._Future__response, response)
self.assertEqual(self.target._Future__response_obtained, True)
def _request(self, object_id, method, path, body=None):
resp = Response(Response.StatusCode.INTERNAL_SERVER_ERROR, None)
try:
resp = self._request_sync(object_id, method, path, body)
except:
logging.error("Exception: Request to " + object_id + " Method:" +
method + " Path:" + path)
logging.error(traceback.format_exc())
return resp
def _do_delete_remote_object(self, object_id):
if object_id in self.remote_objects:
remote_object = self.remote_objects[object_id]
prev = copy.deepcopy(
remote_object._object_property).packed_object()
remote_object.on_finalize()
del self.remote_objects[object_id]
logging.debug("Deleted RemoteObject ID:%s", object_id)
return Response(Response.StatusCode.OK, None)
def test_do_event_componentmanagerchanged_keyerror(self):
self.value = {
"type": "ComponentManager",
"id": "456",
"base_uri": "789"
}
self.result = Response("add", self.value)
with patch('logging.error') as m_logging_error:
self.target._do_event_componentmanagerchanged(self.result)
self.assertEqual(m_logging_error.call_count, 1)
def _do_delete_component(self, object_id):
if object_id in self.components:
component = self.components[object_id]
prev = copy.deepcopy(component._object_property).packed_object()
component.on_finalize()
del self.components[object_id]
self._do_component_changed(ComponentChanged.Action.DELETE, prev,
None)
logging.info("Deleted Component ID:%s", object_id)
return Response(Response.StatusCode.OK, None)
def del_flow(self, flow_id):
logging.debug("DELETE Flow NetworkID:" + self.network_id + " FlowID:" +
flow_id)
flow = self.get_flow(flow_id)
if flow is None:
return Response(Response.StatusCode.OK, None)
flow.enabled = False
path = self.FLOW_PATH % flow_id
return self._del_object_to_remote_object(path, body=flow)
def test_send_request_message(self):
request = Request("object_id", "method", "path")
response = Response(200, "body")
self.target.dispatcher.dispatch_request =\
MagicMock(return_value=response)
result = self.target.send_request_message(request)
self.assertEqual(result.status_code, 200)
self.assertEqual(result.body, "body")
def test_get_component_managers_error(self):
with patch('org.o3project.odenos.core.util.remote_object_interface.'
'RemoteObjectInterface._get_object_to_remote_object',
return_value=Response(Response.StatusCode.NOT_FOUND,
None)
) as m_get_object:
self.result = self.target.get_component_managers()
self.assertEqual(m_get_object.call_count, 1)
m_get_object.assert_any_call(SystemManagerInterface.
COMP_MNGS_PATH)
self.assertEqual(self.result, None)
def dispatch_request(self, request):
try:
resp = self.__parser.action(request)
if resp.status_code == Response.StatusCode.NOT_FOUND:
resp = self._on_request(request)
except:
logging.error("Exception: Receive Request" + " Method:" +
request.method + " Path:" + request.path)
logging.error(traceback.format_exc())
resp = Response(Response.StatusCode.INTERNAL_SERVER_ERROR, None)
return resp
def test_get_connections_success(self):
ComponentConnectioTmp = ComponentConnection("slicer1_network1",
"original",
"running")
LogicAndNetworkTmp =\
ComponentConnectionLogicAndNetwork("slicer1_network2",
"original",
"running",
"LogicId",
"NetworkId")
ComponentConnectioTmp_packed_object =\
ComponentConnectioTmp.packed_object()
LogicAndNetworkTmp_packed_object =\
LogicAndNetworkTmp.packed_object()
body = {"slicer1network": ComponentConnectioTmp_packed_object,
"slicer2network": LogicAndNetworkTmp_packed_object}
with nested(
patch('org.o3project.odenos.core.util.remote_object_interface.'
'RemoteObjectInterface._get_object_to_remote_object',
return_value=Response(Response.StatusCode.OK, body)),
patch('org.o3project.odenos.remoteobject.manager.system.'
'component_connection.ComponentConnection.'
'create_from_packed',
return_value=ComponentConnection.create_from_packed(
ComponentConnectioTmp_packed_object)),
patch('org.o3project.odenos.remoteobject.manager.system.'
'component_connection_logic_and_network.'
'ComponentConnectionLogicAndNetwork.create_from_packed',
return_value=ComponentConnectionLogicAndNetwork.
create_from_packed(LogicAndNetworkTmp_packed_object)),
patch('logging.error'
)) as (m_get_object,
m_Connection,
m_LogicAndNetwork,
m_log_error):
self.result = self.target.get_connections()
self.assertEqual(m_get_object.call_count, 1)
m_get_object.assert_any_call(SystemManagerInterface.
CONNECTIONS_PATH)
self.assertEqual(m_Connection.call_count, 1)
m_Connection.assert_any_call(
ComponentConnectioTmp_packed_object)
self.assertEqual(m_LogicAndNetwork.call_count, 1)
m_LogicAndNetwork.assert_any_call(
LogicAndNetworkTmp_packed_object)
self.assertNotEqual(self.result, None)
self.assertEqual(len(self.result), 2)
self.assertEqual(self.result["slicer1network"].packed_object(),
ComponentConnectioTmp_packed_object)
self.assertEqual(self.result["slicer2network"].packed_object(),
LogicAndNetworkTmp_packed_object)
self.assertEqual(m_log_error.call_count, 0)
def test_get_component_type_arg_comp_type_error(self):
value = "ComponentTypeBody"
with patch('org.o3project.odenos.core.util.remote_object_interface.'
'RemoteObjectInterface._get_object_to_remote_object',
return_value=Response(Response.StatusCode.NOT_FOUND,
value)
) as m_get_object:
self.result = self.target.get_component_type("CompTypeId1")
self.assertEqual(m_get_object.call_count, 1)
m_get_object.assert_any_call(SystemManagerInterface.
COMP_TYPE_PATH % "CompTypeId1")
self.assertEqual(self.result, None)
def test_add_component_managers_success(self):
value = ComponentManager("cmp_id", self.Dispatcher)
with nested(patch('org.o3project.odenos.core.util.remote_object_interface.'
'RemoteObjectInterface._put_object_to_remote_object', \
return_value=Response(Response.StatusCode.OK, value.object_property)
), patch("logging.error")) as (m_put_object, logging_error):
self.result = self.target.add_component_manager(value)
self.assertEqual(m_put_object.call_count, 1)
m_put_object.assert_any_call(SystemManagerInterface.
COMP_MNG_PATH % value.object_id,
value.object_property)
def test_get_event_manager_success(self):
value = "EventManager_Body"
with patch('org.o3project.odenos.core.util.remote_object_interface.'
'RemoteObjectInterface._get_object_to_remote_object',
return_value=Response(Response.StatusCode.OK, value)
) as m_get_object:
self.result = self.target.get_event_manager()
self.assertEqual(m_get_object.call_count, 1)
m_get_object.assert_any_call(SystemManagerInterface.
EVENT_MNG_PATH)
self.assertNotEqual(self.result, None)
self.assertEqual(self.result, value)
def test_redisSubscriberRunnable_TYPE_RESPONSE(self):
clients = self.target._MessageDispatcher__clients
remote_msg_trans = RemoteMessageTransport("publisher_id:event_type",
self.target)
clients["publisher_id:event_type"] = remote_msg_trans
response = Response(200, "remote_msg_trans")
pk = msgpack.Packer()
resb = bytearray()
resb.extend(pk.pack(1))
resb.extend(pk.pack(0))
resb.extend(pk.pack("publisher_id:event_type"))
resb.extend(pk.pack(response.packed_object()))
self.value = {"type": "message",
"data": resb}
self.target._MessageDispatcher__redisSubscriber = redis.StrictRedis(
host=self.target._MessageDispatcher__redisServer,
port=self.target._MessageDispatcher__redisPort)
self.target._MessageDispatcher__redisSubscriber =\
self.target._MessageDispatcher__redisSubscriber.pubsub()
with nested(
patch("redis.client.PubSub.subscribe"),
patch("redis.client.PubSub.unsubscribe"),
patch("redis.client.PubSub.listen"),
patch(self.RESPONSE_PATH + ".create_from_packed")) as (
mock_subscribe,
mock_unsubscribe,
mock_listen,
mock_response):
mock_subscribe.return_value = None
mock_unsubscribe.return_value = None
mock_listen.return_value = [self.value]
self.target._MessageDispatcher__redisSubscriberRunnable()
mock_response.assert_called_once_with(
[200, "remote_msg_trans"])
def delete_all_flow(self):
logging.debug("DELETE AllFlow NetworkID:" + self.network_id)
resp_list = []
flow_set = self.get_flow_set()
if flow_set is None:
resp_list.append(Response(Response.StatusCode.OK, None))
return resp_list
for flow_id in flow_set.flows:
resp_list.append(self.del_flow(flow_id))
return resp_list
def test_get_component_arg_comp_id_success(self):
value = "ComponentBody"
with patch('org.o3project.odenos.core.util.remote_object_interface.'
'RemoteObjectInterface._get_object_to_remote_object',
return_value=Response(Response.StatusCode.OK,
value)
) as m_get_object:
self.result = self.target.get_component("CompId1")
self.assertEqual(m_get_object.call_count, 1)
m_get_object.assert_any_call(SystemManagerInterface.
COMP_PATH % "CompId1")
self.assertNotEqual(self.result, None)
self.assertEqual(self.result, value)
def _do_put_property(self, body):
logging.debug("Receive PUT Property ObjectID:" + self.object_id)
# check State Change to Finalizing
for k, v in body.items():
if k == ObjectProperty.OBJECT_STATE:
oldValue = self._object_property.get_property(k)
self.on_state_changed(oldValue, v)
# update Property
if not (self._object_property.equals(body)):
self._object_property.put_property(body)
return Response(Response.StatusCode.OK, self._object_property)
def test_get_property_success(self):
value = "propertyBody"
with patch(
'org.o3project.odenos.core.util.remote_object_interface.'
'RemoteObjectInterface._get_object_to_remote_object',
return_value=Response(Response.StatusCode.OK,
value)) as m_get_object:
self.result = self.target.get_property()
self.assertEqual(m_get_object.call_count, 1)
self.assertEqual(m_get_object.call_args[0][0],
RemoteObjectInterface.PROPETY_PATH)
self.assertNotEqual(self.result, None)
def __redisPublisherRunnable(self):
while (True):
pubs = self.__pubsqueue.get()
if pubs is None:
break
try:
self.__redisPubliser.publish(pubs.channel, pubs.data)
except:
if pubs.type == self.TYPE_REQUEST:
if pubs.trans is not None:
pubs.trans.signalResponse(
pubs.sno,
Response(Response.StatusCode.NOT_FOUND, None))
pass
def test_get_settings_StatusCode_NotOK(self):
value = "settingsBody"
with patch(
'org.o3project.odenos.core.util.remote_object_interface.'
'RemoteObjectInterface._get_object_to_remote_object',
return_value=Response(Response.StatusCode.NOT_FOUND,
value)) as m_get_object:
self.result = self.target.get_settings()
self.assertEqual(m_get_object.call_count, 1)
self.assertEqual(m_get_object.call_args[0][0],
RemoteObjectInterface.SETTINGS_PATH)
self.assertEqual(self.result, None)
def _do_put_remote_object(self, obj_prop, object_id):
remote_object_type = obj_prop[ObjectProperty.OBJECT_TYPE]
if remote_object_type not in self.remote_object_classes:
return Response(Response.StatusCode.BAD_REQUEST, None)
elif object_id in self.remote_objects:
return Response(Response.StatusCode.CONFLICT, None)
remote_object_class = self.remote_object_classes[remote_object_type]
self.remote_objects[object_id] = remote_object_class(
object_id, self.dispatcher)
if self.remote_objects[object_id].on_initialize(obj_prop):
self.remote_objects[object_id].set_state(
ObjectProperty.State.RUNNING)
else:
self.remote_objects[object_id].set_state(
ObjectProperty.State.ERROR)
logging.debug("Created RemoteObject Type:%s ID:%s", remote_object_type,
object_id)
return Response(Response.StatusCode.CREATED,
self.remote_objects[object_id].object_property)
def test_redisSubscriberRunnable_TYPE_RESPONSE(self):
clients = self.target._MessageDispatcher__clients
remote_msg_trans = RemoteMessageTransport("publisher_id:event_type",
self.target)
clients["publisher_id:event_type"] = remote_msg_trans
response = Response(200, "remote_msg_trans")
pk = msgpack.Packer()
resb = bytearray()
resb.extend(pk.pack(1))
resb.extend(pk.pack(0))
resb.extend(pk.pack("publisher_id:event_type"))
resb.extend(pk.pack(response.packed_object()))
self.value = {"type": "message", "data": resb}
self.target._MessageDispatcher__redisSubscriber = redis.StrictRedis(
host=self.target._MessageDispatcher__redisServer,
port=self.target._MessageDispatcher__redisPort)
self.target._MessageDispatcher__redisSubscriber =\
self.target._MessageDispatcher__redisSubscriber.pubsub()
with nested(patch("redis.client.PubSub.subscribe"),
patch("redis.client.PubSub.unsubscribe"),
patch("redis.client.PubSub.listen"),
patch(self.RESPONSE_PATH +
".create_from_packed")) as (mock_subscribe,
mock_unsubscribe,
mock_listen,
mock_response):
mock_subscribe.return_value = None
mock_unsubscribe.return_value = None
mock_listen.return_value = [self.value]
self.target._MessageDispatcher__redisSubscriberRunnable()
mock_response.assert_called_once_with([200, "remote_msg_trans"])
def _do_put_component(self, obj_prop, object_id):
component_type = obj_prop[ObjectProperty.OBJECT_TYPE]
if component_type not in self.component_classes:
return Response(Response.StatusCode.BAD_REQUEST, None)
elif object_id in self.components:
return Response(Response.StatusCode.CONFLICT, None)
component_class = self.component_classes[component_type]
self.components[object_id] = component_class(object_id,
self.dispatcher)
if self.components[object_id].on_initialize(obj_prop):
self.components[object_id].\
_object_property.set_state(ObjectProperty.State.RUNNING)
else:
self.components[object_id].\
_object_property.set_state(ObjectProperty.State.ERROR)
curr = self.components[object_id].object_property.packed_object()
self._do_component_changed(ComponentChanged.Action.ADD, None, curr)
logging.info("Created Component Type:%s ID:%s", component_type,
object_id)
return Response(Response.StatusCode.CREATED,
self.components[object_id].object_property)
def delete_topology(self):
logging.debug("DELETE Topology NetworkID:" + self.network_id)
resp_list = []
topology = self.get_topology()
if topology is None:
resp_list.append(Response(Response.StatusCode.OK, None))
return resp_list
for link_id in topology.links:
# delete Link
resp_list.append(self.del_link(link_id))
for node_id, node in topology.nodes.items():
for port_id in node.ports:
# delete port
resp_list.append(self.del_port(node_id, port_id))
# delete node
resp_list.append(self.del_node(node_id))
if len(resp_list) == 0:
resp_list.append(Response(Response.StatusCode.OK, None))
return resp_list
def __redisSubscriberRunnable(self):
for mesg in self.__redisSubscriber.listen():
if mesg['type'] != 'message':
continue
try:
bio = BytesIO()
bio.write(mesg['data'])
bio.seek(0)
upk = msgpack.Unpacker(bio)
tp = upk.unpack()
sno = upk.unpack()
srcid = upk.unpack()
if tp == self.TYPE_REQUEST:
request = Request.create_from_packed(upk.unpack())
def request_runnable(request, sno, srcid):
response = self.dispatch_request(request)
pk = msgpack.Packer()
resb = bytearray()
resb.extend(pk.pack(self.TYPE_RESPONSE))
resb.extend(pk.pack(sno))
resb.extend(pk.pack(request.object_id))
resb.extend(pk.pack(response.packed_object()))
self.__pubsqueue.put(
MessageDispatcher.PublishData(None,
self.TYPE_RESPONSE,
sno,
srcid,
resb))
self.thread_pool.submit(request_runnable,
request,
sno,
srcid)
elif tp == self.TYPE_RESPONSE:
trans = self.__clients[srcid]
response = Response.create_from_packed(upk.unpack())
trans.signalResponse(sno, response)
elif tp == self.TYPE_EVENT:
event = Event.create_from_packed(upk.unpack())
def event_runnable(event):
self.dispatch_event(event)
self.thread_pool.submit(event_runnable, event)
except:
logging.error(traceback.format_exc())
pass
def test_do_event_componentmanagerchanged_delete_action(self):
self.value = ComponentManager("456", self.MessageDispatcher)
self.target.register_component_type(self.value.__class__)
self.value = {
"type": "ComponentManager",
"id": "456",
"base_uri": "789"
}
self.result = self.target._do_put_component(self.value, "456")
prev = self.target.components["456"].object_property.packed_object()
self.target.dispatcher.remove_remote_client = Mock()
self.value = {"action": "delete", "prev": prev, "curr": None}
self.result = Response("add", self.value)
self.target._do_event_componentmanagerchanged(self.result)
self.assertEqual(
self.target.dispatcher.remove_remote_client.call_count, 1)
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)
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_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 setUp(self):
self.target = Response(Response.StatusCode.OK, self.flow_target)
def test_redisSubscriberRunnable_TYPE_REQUEST(self):
request = Request("object_id", "method", "path", None)
request_packed = request.packed_object()
response = Response(200, "body")
response_packed = response.packed_object()
pk = msgpack.Packer()
resb = bytearray()
resb.extend(pk.pack(0))
resb.extend(pk.pack(0))
resb.extend(pk.pack("object_id"))
resb.extend(pk.pack(request_packed))
self.value = {"type": "message",
"data": resb}
self.value02 = {"type": "ERROR",
"data": resb}
resb_check = bytearray()
resb_check.extend(pk.pack(1))
resb_check.extend(pk.pack(0))
resb_check.extend(pk.pack("object_id"))
resb_check.extend(pk.pack(response_packed))
self.target.thread_pool = futures.ThreadPoolExecutor(max_workers=8)
self.target._MessageDispatcher__redisSubscriber = redis.StrictRedis(
host=self.target._MessageDispatcher__redisServer,
port=self.target._MessageDispatcher__redisPort)
self.target._MessageDispatcher__redisSubscriber =\
self.target._MessageDispatcher__redisSubscriber.pubsub()
def dummy_request_runnable(arg, request, sno, srcid):
arg(request, sno, srcid)
with nested(
patch("redis.client.PubSub.subscribe"),
patch("redis.client.PubSub.unsubscribe"),
patch("redis.client.PubSub.listen"),
patch("concurrent.futures.ThreadPoolExecutor.submit"),
patch(self.REQUEST_PATH + ".create_from_packed"),
patch(self.DISPATCHER_PATH + ".dispatch_request")) as (
mock_subscribe,
mock_unsubscribe,
mock_listen,
mock_submit,
mock_request,
mock_dispatch_request):
mock_subscribe.return_value = None
mock_unsubscribe.return_value = None
mock_listen.return_value = [self.value, self.value02]
mock_request.return_value = request
mock_dispatch_request.return_value = response
mock_submit.side_effect = dummy_request_runnable
self.target._MessageDispatcher__redisSubscriberRunnable()
self.result = self.target._MessageDispatcher__pubsqueue.get()
mock_request.assert_called_once_with(
["object_id", "method", "path", None])
self.assertEqual(mock_submit.call_count, 1)
self.assertEqual(
self.result.trans, None)
self.assertEqual(
self.result.type, 1)
self.assertEqual(
self.result.sno, 0)
self.assertEqual(
self.result.channel, "object_id")
self.assertEqual(
self.result.data, resb_check)