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 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"])
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 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_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)
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)
