elif os.path.isdir(fdn):
m = load_module(fdn)
modules.append(m)
except ImportError:
pass
return modules
if __name__ == '__main__':
Logger.file_config()
options = Parser().parse()
logging.info("python ComponentManager options: %s", options)
dispatcher = MessageDispatcher()
dispatcher.start()
component_manager = ComponentManager(options.rid, dispatcher)
classes = []
cwd = os.getcwd()
directory = os.path.join(cwd, options.dir)
modules = load_modules(directory)
for m in modules:
for name, clazz in inspect.getmembers(m, inspect.isclass):
if options.dir not in inspect.getsourcefile(clazz):
continue
if issubclass(clazz, RemoteObject):
classes.append(clazz)
from org.o3project.odenos.core.util.logger import Logger
from org.o3project.odenos.core.util.network_interface import NetworkInterface
from org.o3project.odenos.remoteobject.manager.system.component_connection import (
ComponentConnection
)
from org.o3project.odenos.remoteobject.manager.system.component_connection_logic_and_network import (
ComponentConnectionLogicAndNetwork
)
if __name__ == '__main__':
Logger.file_config()
# Create MessageDispatcher
dispatcher = MessageDispatcher()
dispatcher.set_remote_system_manager()
dispatcher.start()
time.sleep(1)
exit_code = 0
try:
# Create SystemManager Interface
sysif = SystemManagerInterface(dispatcher)
print "//////////////////////////////////////////////////"
print "//// (1) Create Original Network."
print "//////////////////////////////////////////////////"
send_property = ObjectProperty("Network", "original_nw")
resp = sysif.put_components(send_property)
print resp.status_code
print json.dumps(resp.body, sort_keys=True, indent=4)
class MessageDispatcherTest(unittest.TestCase):
DISPATCHER_PATH = "org.o3project.odenos.remoteobject.transport.message_dispatcher." +\
"MessageDispatcher"
REQUEST_PATH = "org.o3project.odenos.remoteobject.message.request.Request"
RESPONSE_PATH = "org.o3project.odenos.remoteobject.message.response.Response"
EVENT_PATH = "org.o3project.odenos.remoteobject.message.event.Event"
value = ""
value02 = ""
result = ""
def setUp(self):
self.target = MessageDispatcher()
def tearDown(self):
self.target = None
def test_EventSubscriptionMap_constructor(self):
self.target = self.target.EventSubscriptionMap()
self.assertEqual(
self.target._EventSubscriptionMap__subscriptions, {})
self.assertEqual(
self.target._EventSubscriptionMap__subscription_map, {})
def test_EventSubscriptionMap_get_subscriptions_keys(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscription_map = {
"key01": "value01", "key02": "value02",
"key03": "value03", "key04": "value04"}
self.result = self.target.get_subscriptions_keys()
self.assertEqual(
self.result, ["key01", "key02", "key03", "key04"])
def test_EventSubscriptionMap_set_subscription(self):
self.target = self.target.EventSubscriptionMap()
self.value = EventSubscription("EventSubscription",
{"key01": ["value01",
"value02"]})
self.target.set_subscription(self.value)
self.assertEqual(
self.target._EventSubscriptionMap__subscriptions,
{"EventSubscription": set(["key01:value01",
"key01:value02"])})
self.assertEqual(
self.target._EventSubscriptionMap__subscription_map,
{"key01:value01": set(["EventSubscription"]),
"key01:value02": set(["EventSubscription"])})
def test_EventSubscriptionMap_remove_subscription_exist(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscriptions =\
{"EventSubscription01": set(["key01:value01",
"key01:value02"]),
"EventSubscription02": set(["key01:value01",
"key01:value02"])}
self.target._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["EventSubscription01",
"EventSubscription02"]),
"key01:value02": set(["EventSubscription01",
"EventSubscription02"])}
self.result = self.target.remove_subscription("EventSubscription02")
self.assertEqual(
self.target._EventSubscriptionMap__subscriptions,
{"EventSubscription01": set(["key01:value01",
"key01:value02"])})
self.assertEqual(
self.target._EventSubscriptionMap__subscription_map,
{"key01:value01": set(["EventSubscription01"]),
"key01:value02": set(["EventSubscription01"])})
self.assertEqual(
self.result, set(["key01:value01", "key01:value02"]))
def test_EventSubscriptionMap_remove_subscription_subscriber_not_in(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscriptions =\
{"EventSubscription01": set(["key01:value01",
"key01:value02"]),
"EventSubscription": set(["key01:value01",
"key01:value02"])}
self.target._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["EventSubscription01",
"EventSubscription02"]),
"key01:value02": set(["EventSubscription01",
"EventSubscription02"])}
self.result = self.target.remove_subscription("EventSubscription02")
self.assertEqual(
self.target._EventSubscriptionMap__subscriptions,
{"EventSubscription01": set(["key01:value01",
"key01:value02"]),
"EventSubscription": set(["key01:value01",
"key01:value02"])})
self.assertEqual(
self.target._EventSubscriptionMap__subscription_map,
{"key01:value01": set(["EventSubscription01"]),
"key01:value02": set(["EventSubscription01"])})
self.assertEqual(
self.result, set())
def test_EventSubscriptionMap_remove_subscription_subscribers_zero(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscriptions =\
{"EventSubscription01": set(["key01:value01",
"key01:value02"]),
"EventSubscription02": set(["key01:value01",
"key01:value02"])}
self.target._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["EventSubscription02"]),
"key01:value02": set(["EventSubscription01",
"EventSubscription02"])}
self.result = self.target.remove_subscription("EventSubscription02")
self.assertEqual(
self.target._EventSubscriptionMap__subscriptions,
{"EventSubscription01": set(["key01:value01",
"key01:value02"])})
self.assertEqual(
self.target._EventSubscriptionMap__subscription_map,
{"key01:value02": set(["EventSubscription01"])})
self.assertEqual(
self.result, set(["key01:value01", "key01:value02"]))
def test_EventSubscriptionMap_get_subscribers_return_subscribers(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["EventSubscription01",
"EventSubscription02"]),
"key01:value02": set(["EventSubscription01",
"EventSubscription02"])}
self.result = self.target.get_subscribers("key01", "value01")
self.assertEqual(
self.result, set(["EventSubscription01",
"EventSubscription02"]))
def test_EventSubscriptionMap_get_subscribers_return_keys(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscriptions =\
{"EventSubscription01": set(["key01:value01",
"key01:value02"]),
"EventSubscription": set(["key01:value01",
"key01:value02"])}
self.result = self.target.get_subscribers()
self.assertEqual(
self.result, set(["EventSubscription01", "EventSubscription"]))
def test_EventSubscriptionMap_clear(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscriptions =\
{"EventSubscription01": set(["key01:value01",
"key01:value02"]),
"EventSubscription": set(["key01:value01",
"key01:value02"])}
self.target._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["EventSubscription01",
"EventSubscription02"]),
"key01:value02": set(["EventSubscription01",
"EventSubscription02"])}
self.target.clear()
self.assertEqual(
self.target._EventSubscriptionMap__subscriptions,
{})
self.assertEqual(
self.target._EventSubscriptionMap__subscription_map,
{})
def test_PublishData_constructor(self):
self.target = self.target.PublishData("trans", "PublishData",
1, "channel", "data")
self.assertEqual(
self.target.trans, "trans")
self.assertEqual(
self.target.type, "PublishData")
self.assertEqual(
self.target.sno, 1)
self.assertEqual(
self.target.channel, "channel")
self.assertEqual(
self.target.data, "data")
def test_constructor(self):
with nested(
patch("uuid.uuid4"),
patch("Queue.Queue"),
patch("org.o3project.odenos.remoteobject." +
"transport.message_dispatcher." +
"MessageDispatcher.EventSubscriptionMap")) as (
mock_uuid4,
mock_Queue,
mock_EventSubscriptionMap):
mock_uuid4.return_value = "mock_uuid4"
mock_Queue.return_value = "mock_Queue"
mock_EventSubscriptionMap.return_value =\
"mock_EventSubscriptionMap"
self.target = MessageDispatcher()
self.assertEqual(self.target._MessageDispatcher__clients, {})
self.assertEqual(
self.target._MessageDispatcher__local_objects, {})
self.assertEqual(
self.target._MessageDispatcher__event_manager_id, None)
self.assertEqual(
self.target.system_manager_id, "systemmanager")
self.assertEqual(
self.target._MessageDispatcher__redisServer, "localhost")
self.assertEqual(
self.target._MessageDispatcher__redisPort, 6379)
self.assertEqual(
self.target._MessageDispatcher__sourceDispatcherId,
"mock_uuid4")
self.assertEqual(
self.target._MessageDispatcher__pubsqueue,
"mock_Queue")
self.assertEqual(
self.target._MessageDispatcher__redisSubscriber, None)
self.assertEqual(
self.target._MessageDispatcher__subscription_map,
"mock_EventSubscriptionMap")
def test_redisPublisherRunnable_success(self):
remote_msg_trans = RemoteMessageTransport("remote_object_id",
self.target)
self.value = self.target.PublishData(remote_msg_trans, 0,
1, "123456789", "data")
self.target._MessageDispatcher__redisPubliser = redis.StrictRedis(
host=self.target._MessageDispatcher__redisServer,
port=self.target._MessageDispatcher__redisPort)
self.target._MessageDispatcher__pubsqueue.put(self.value)
self.target._MessageDispatcher__pubsqueue.put(None)
with nested(patch("redis.client.StrictRedis.publish"),
patch("org.o3project.odenos.remoteobject.transport."
"remote_message_transport.RemoteMessageTransport."
"signalResponse")) as (mock_publish,
mock_signalResponse):
self.target._MessageDispatcher__redisPublisherRunnable()
mock_publish.assert_called_once_with("123456789", "data")
self.assertEqual(mock_signalResponse.call_count, 0)
def test_redisPublisherRunnable_Exept(self):
remote_msg_trans = RemoteMessageTransport("remote_object_id",
self.target)
self.value = self.target.PublishData(remote_msg_trans, 0,
1, "channel", "data")
self.target._MessageDispatcher__pubsqueue.put(self.value)
self.target._MessageDispatcher__pubsqueue.put(None)
with nested(patch("redis.client.StrictRedis.publish"),
patch("org.o3project.odenos.remoteobject.transport."
"remote_message_transport.RemoteMessageTransport."
"signalResponse")) as (mock_publish,
mock_signalResponse):
self.target._MessageDispatcher__redisPublisherRunnable()
self.assertEqual(mock_publish.call_count, 0)
self.assertEqual(mock_signalResponse.call_count, 1)
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_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_EVENT(self):
event = Event("publisher_id", "event_type", "event_body")
pk = msgpack.Packer()
resb = bytearray()
resb.extend(pk.pack(2))
resb.extend(pk.pack(0))
resb.extend(pk.pack("publisher_id:event_type"))
resb.extend(pk.pack(event.packed_object()))
self.value = {"type": "message",
"data": resb}
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()
with nested(
patch("redis.client.PubSub.subscribe"),
patch("redis.client.PubSub.unsubscribe"),
patch("redis.client.PubSub.listen"),
patch(self.EVENT_PATH + ".create_from_packed")) as (
mock_subscribe,
mock_unsubscribe,
mock_listen,
mock_event):
mock_subscribe.return_value = None
mock_unsubscribe.return_value = None
mock_listen.return_value = [self.value]
self.target._MessageDispatcher__redisSubscriberRunnable()
mock_event.assert_called_once_with(
["publisher_id", "event_type", "event_body"])
def test_redisSubscriberRunnable_except(self):
event = Event("publisher_id", "event_type", "event_body")
pk = msgpack.Packer()
resb = bytearray()
resb.extend(pk.pack(2))
resb.extend(pk.pack(0))
resb.extend(pk.pack("publisher_id:event_type"))
resb.extend(pk.pack(event.packed_object()))
self.value = {"type": "message",
"data": resb}
with nested(
patch("redis.client.PubSub.subscribe"),
patch("logging.error"),
patch("redis.client.PubSub.unsubscribe"),
patch("redis.client.PubSub.listen"),
patch(self.EVENT_PATH + ".create_from_packed")) as (
mock_subscribe,
logging_error,
mock_unsubscribe,
mock_listen,
mock_event):
mock_subscribe.return_value = None
mock_unsubscribe.return_value = None
mock_listen.return_value = [self.value]
mock_event.side_effect = KeyError()
self.target.start()
self.target._MessageDispatcher__redisSubscriberRunnable()
self.target.close()
mock_event.assert_called_any_with(
["publisher_id", "event_type", "event_body"])
def test_start(self):
with nested(
patch("redis.client.PubSub.subscribe"),
patch("redis.client.PubSub.unsubscribe")) as (
mock_subscribe,
mock_unsubscribe):
mock_subscribe.return_value = None
mock_unsubscribe.return_value = None
self.target.start()
self.target.close()
def test_stop_redisSubscriberThread_Not_None(self):
with nested(
patch("redis.client.PubSub.subscribe"),
patch("threading.Thread.join"),
patch("redis.client.PubSub.unsubscribe")) as (
mock_subscribe,
mock_join,
mock_unsubscribe):
mock_subscribe.return_value = None
self.target.start()
self.target.stop()
self.assertEqual(mock_join.call_count, 2)
self.assertEqual(mock_unsubscribe.call_count, 1)
def test_stop_redisSubscriberThread_None(self):
self.target.stop()
def test_join_redisSubscriberThread_Not_None(self):
self.target._MessageDispatcher__redisSubscriberThread =\
threading.Thread(
target=self.target._MessageDispatcher__redisSubscriberRunnable)
self.target._MessageDispatcher__redisPublisherThread =\
threading.Thread(
target=self.target._MessageDispatcher__redisPublisherRunnable)
with nested(
patch("redis.client.PubSub.subscribe"),
patch("threading.Thread.join")) as (
mock_subscribe,
mock_join):
mock_subscribe.return_value = None
self.target.join()
self.assertEqual(mock_join.call_count, 2)
self.target._MessageDispatcher__redisPublisherThread = None
self.target._MessageDispatcher__redisSubscriberThread = None
def test_join_redisSubscriberThread_None(self):
self.target.join()
def test_close(self):
remote_msg_trans = RemoteMessageTransport("remote_object_id",
self.target)
self.target._MessageDispatcher__local_objects["object_id"] =\
remote_msg_trans
self.target._MessageDispatcher__clients["object_id"] =\
remote_msg_trans
self.target.close()
self.assertEqual(self.target._MessageDispatcher__local_objects, {})
self.assertEqual(self.target._MessageDispatcher__clients, {})
def test_get_message_client_create_client_exist(self):
remote_msg_trans = RemoteMessageTransport("remote_object_id",
self.target)
self.target._MessageDispatcher__clients["object_id"] =\
remote_msg_trans
self.result =\
self.target._MessageDispatcher__get_message_client("object_id")
self.assertNotEqual(self.target._MessageDispatcher__clients, {})
self.assertEqual(
self.target._MessageDispatcher__clients["object_id"].responseMap,
{})
def test_get_message_client_create_RemoteMessageT_client(self):
self.result =\
self.target._MessageDispatcher__get_message_client("object_id")
self.assertNotEqual(self.target._MessageDispatcher__clients, {})
self.assertEqual(
self.target._MessageDispatcher__clients["object_id"].responseMap,
{})
def test_get_message_client_create_LocalMessage_client(self):
self.target._MessageDispatcher__local_objects = {"object_id": None}
self.result =\
self.target._MessageDispatcher__get_message_client("object_id")
self.assertNotEqual(self.target._MessageDispatcher__clients, {})
self.assertEqual(
self.target._MessageDispatcher__clients["object_id"].object_id,
"object_id")
def test_get_source_dispatcher_id(self):
with patch("uuid.uuid4") as mock_uuid4:
mock_uuid4.return_value = "mock_uuid4"
self.target = MessageDispatcher()
self.result = self.target.get_source_dispatcher_id()
self.assertEqual(self.result, "mock_uuid4")
def test_getRedisPublisher(self):
self.assertEqual(
self.target.getRedisPublisher(),
self.target._MessageDispatcher__redisPubliser)
def test_update_subscriber_redisSubscriber_Not_None(self):
self.target._MessageDispatcher__sourceDispatcherId = "DispatcherId"
subscription_map =\
self.target._MessageDispatcher__subscription_map
subscription_map._EventSubscriptionMap__subscriptions =\
{"remote_object": set(["key01:value01",
"key01:value02"]),
"local_object": set(["key01:value01",
"key01:value02"])}
subscription_map._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["remote_object",
"local_object"]),
"key01:value02": set(["remote_object",
"local_object"])}
remote_object = RemoteObject("remote_object", self.target)
self.target._MessageDispatcher__local_objects =\
{"remote_object": remote_object}
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 patch("redis.client.PubSub.subscribe") as mock_subscribe:
self.target._MessageDispatcher__update_subscriber()
mock_subscribe.assert_called_once_with(
["DispatcherId", "remote_object",
"key01:value01", "key01:value02"])
def test_update_subscriber_redisSubscriber_None(self):
self.target._MessageDispatcher__update_subscriber()
def test_event_manager_id_exist(self):
self.target._MessageDispatcher__event_manager_id = "maneager_id"
self.assertEqual(self.target.event_manager_id, "maneager_id")
def test_event_manager_id_None(self):
self.target._MessageDispatcher__event_manager_id = None
self.assertEqual(self.target.event_manager_id, "eventmanager")
def test_add_local_object(self):
remote_msg_trans = RemoteMessageTransport("remote_object_id",
self.target)
self.target.add_local_object(remote_msg_trans)
self.assertEqual(
self.target._MessageDispatcher__local_objects["remote_object_id"],
remote_msg_trans)
def test_remove_local_object(self):
remote_msg_trans = RemoteMessageTransport("remote_object",
self.target)
local_msg_trans = LocalMessageTransport("local_object",
self.target)
self.target._MessageDispatcher__local_objects =\
{"remote_object": remote_msg_trans,
"local_object": local_msg_trans}
subscription_map =\
self.target._MessageDispatcher__subscription_map
subscription_map._EventSubscriptionMap__subscriptions =\
{"remote_object": set(["key01:value01",
"key01:value02"]),
"local_object": set(["key01:value01",
"key01:value02"])}
subscription_map._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["remote_object",
"local_object"]),
"key01:value02": set(["remote_object",
"local_object"])}
self.target.remove_local_object(local_msg_trans)
self.assertEqual(
self.target._MessageDispatcher__local_objects,
{"remote_object": remote_msg_trans})
self.assertEqual(
subscription_map._EventSubscriptionMap__subscriptions,
{"remote_object": set(["key01:value01",
"key01:value02"])})
self.assertEqual(
subscription_map._EventSubscriptionMap__subscription_map,
{"key01:value01": set(["remote_object"]),
"key01:value02": set(["remote_object"])})
def test_add_remote_client(self):
clients = self.target._MessageDispatcher__clients
self.target.add_remote_client("remote_object")
self.assertNotEqual(self.target._MessageDispatcher__clients, {})
self.assertEqual(
clients["remote_object"].responseMap,
{})
def test_remove_remote_client(self):
clients = self.target._MessageDispatcher__clients
clients["remote_object"] = "mock"
self.target.remove_remote_client("remote_object")
self.assertEqual(self.target._MessageDispatcher__clients, {})
def test_get_local_object_ids(self):
self.target._MessageDispatcher__local_objects =\
{"remote_object": None,
"local_object": None}
self.result = self.target.get_local_object_ids()
self.assertEqual(
self.result, ["remote_object", "local_object"])
def test_set_remote_system_manager(self):
clients = self.target._MessageDispatcher__clients
self.result = self.target.set_remote_system_manager()
self.assertNotEqual(self.target._MessageDispatcher__clients, {})
self.assertEqual(
clients["systemmanager"].responseMap,
{})
def test_request_sync(self):
with patch("org.o3project.odenos.remoteobject.transport." +
"remote_message_transport.RemoteMessageTransport." +
"send_request_message") as mock_send_request_message:
request = Request("object_id", "method", "path")
mock_send_request_message.return_value = "send_request_message"
self.result = self.target.request_sync(request)
self.assertEqual(self.result, "send_request_message")
def test_publish_event_async(self):
event = Event("publisher_id", "event_type", "event_body")
self.target.publish_event_async(event)
self.result = self.target._MessageDispatcher__pubsqueue.get()
self.assertEqual(
self.result.trans, None)
self.assertEqual(
self.result.type, 2)
self.assertEqual(
self.result.sno, 0)
self.assertEqual(
self.result.channel, "publisher_id:event_type")
def test_subscribe_event(self):
# TODO: this requires some work...
with patch("org.o3project.odenos.remoteobject.transport." +
"remote_message_transport.RemoteMessageTransport." +
"send_request_message") as mock_send_request_message:
mock_send_request_message.return_value = "send_request_message"
subscription_map =\
self.target._MessageDispatcher__subscription_map
self.value = EventSubscription("EventSubscription01",
{"key01": ["value01"]})
subscription_map._EventSubscriptionMap__subscriptions =\
{"EventSubscription01": set(["key01:value01",
"key01:value02"]),
"EventSubscription": set(["key01:value01",
"key01:value02"])}
self.target._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["EventSubscription01",
"EventSubscription02"]),
"key01:value02": set(["EventSubscription01",
"EventSubscription02"])}
self.result = self.target.subscribe_event(self.value)
self.assertEqual(self.result, "send_request_message")
def test_pushPublishQueue(self):
self.target.pushPublishQueue(None, 2,
1, "channel", "data")
self.result = self.target._MessageDispatcher__pubsqueue.get()
self.assertEqual(
self.result.trans, None)
self.assertEqual(
self.result.type, 2)
self.assertEqual(
self.result.sno, 1)
self.assertEqual(
self.result.channel, "channel")
self.assertEqual(
self.result.data, "data")
def test_dispatch_request_object_id_in_local_objects(self):
request = Request("remote_object", "method", "path")
remote_object = RemoteObject("remote_object", self.target)
self.target._MessageDispatcher__local_objects =\
{"remote_object": remote_object}
with patch("org.o3project.odenos.remoteobject." +
"remote_object.RemoteObject." +
"dispatch_request") as mock_dispatch_request:
mock_dispatch_request.return_value = "mock_dispatch_request"
self.result = self.target.dispatch_request(request)
self.assertEqual(
self.result, "mock_dispatch_request")
def test_dispatch_request_object_id_not_in_local_objects(self):
request = Request("NoneID", "method", "path")
remote_object = RemoteObject("remote_object", self.target)
self.target._MessageDispatcher__local_objects =\
{"remote_object": remote_object}
self.result = self.target.dispatch_request(request)
self.assertEqual(
self.result.status_code, 404)
self.assertEqual(
self.result.body, None)
def test_dispatch_event(self):
event = Event("key01", "value01", "event_body")
subscription_map =\
self.target._MessageDispatcher__subscription_map
subscription_map._EventSubscriptionMap__subscriptions =\
{"remote_object": set(["key01:value01",
"key01:value02"]),
"local_object": set(["key01:value01",
"key01:value02"])}
subscription_map._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["remote_object",
"local_object"]),
"key01:value02": set(["remote_object",
"local_object"])}
remote_object = RemoteObject("remote_object", self.target)
self.target._MessageDispatcher__local_objects =\
{"remote_object": remote_object}
with patch("org.o3project.odenos.remoteobject." +
"remote_object.RemoteObject." +
"dispatch_event") as mock_dispatch_event:
self.target.dispatch_event(event)
mock_dispatch_event.assert_called_once_with(event)
def test_dispatch_event_id_equal_del_obj_ids(self):
event = Event("key01", "value01", "event_body")
subscription_map =\
self.target._MessageDispatcher__subscription_map
subscription_map._EventSubscriptionMap__subscriptions =\
{"remote_object": set(["key01:value01",
"key01:value02"]),
"local_object": set(["key01:value01",
"key01:value02"])}
subscription_map._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["remote_object",
"local_object"]),
"key01:value02": set(["remote_object",
"local_object"])}
self.target._MessageDispatcher__local_objects =\
{"remote_object": None}
with patch(self.DISPATCHER_PATH +
".EventSubscriptionMap" +
".remove_subscription") as mock_remove_subscription:
self.target.dispatch_event(event)
mock_remove_subscription.assert_called_once_with("remote_object")
class MessageDispatcherTest(unittest.TestCase):
DISPATCHER_PATH = "org.o3project.odenos.remoteobject.transport.message_dispatcher." +\
"MessageDispatcher"
REQUEST_PATH = "org.o3project.odenos.remoteobject.message.request.Request"
RESPONSE_PATH = "org.o3project.odenos.remoteobject.message.response.Response"
EVENT_PATH = "org.o3project.odenos.remoteobject.message.event.Event"
value = ""
value02 = ""
result = ""
def setUp(self):
self.target = MessageDispatcher()
def tearDown(self):
self.target = None
def test_EventSubscriptionMap_constructor(self):
self.target = self.target.EventSubscriptionMap()
self.assertEqual(self.target._EventSubscriptionMap__subscriptions, {})
self.assertEqual(self.target._EventSubscriptionMap__subscription_map,
{})
def test_EventSubscriptionMap_get_subscriptions_keys(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscription_map = {
"key01": "value01",
"key02": "value02",
"key03": "value03",
"key04": "value04"
}
self.result = self.target.get_subscriptions_keys()
self.assertEqual(self.result, ["key01", "key02", "key03", "key04"])
def test_EventSubscriptionMap_set_subscription(self):
self.target = self.target.EventSubscriptionMap()
self.value = EventSubscription("EventSubscription",
{"key01": ["value01", "value02"]})
self.target.set_subscription(self.value)
self.assertEqual(
self.target._EventSubscriptionMap__subscriptions,
{"EventSubscription": set(["key01:value01", "key01:value02"])})
self.assertEqual(
self.target._EventSubscriptionMap__subscription_map, {
"key01:value01": set(["EventSubscription"]),
"key01:value02": set(["EventSubscription"])
})
def test_EventSubscriptionMap_remove_subscription_exist(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscriptions =\
{"EventSubscription01": set(["key01:value01",
"key01:value02"]),
"EventSubscription02": set(["key01:value01",
"key01:value02"])}
self.target._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["EventSubscription01",
"EventSubscription02"]),
"key01:value02": set(["EventSubscription01",
"EventSubscription02"])}
self.result = self.target.remove_subscription("EventSubscription02")
self.assertEqual(
self.target._EventSubscriptionMap__subscriptions,
{"EventSubscription01": set(["key01:value01", "key01:value02"])})
self.assertEqual(
self.target._EventSubscriptionMap__subscription_map, {
"key01:value01": set(["EventSubscription01"]),
"key01:value02": set(["EventSubscription01"])
})
self.assertEqual(self.result, set(["key01:value01", "key01:value02"]))
def test_EventSubscriptionMap_remove_subscription_subscriber_not_in(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscriptions =\
{"EventSubscription01": set(["key01:value01",
"key01:value02"]),
"EventSubscription": set(["key01:value01",
"key01:value02"])}
self.target._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["EventSubscription01",
"EventSubscription02"]),
"key01:value02": set(["EventSubscription01",
"EventSubscription02"])}
self.result = self.target.remove_subscription("EventSubscription02")
self.assertEqual(
self.target._EventSubscriptionMap__subscriptions, {
"EventSubscription01": set(["key01:value01", "key01:value02"]),
"EventSubscription": set(["key01:value01", "key01:value02"])
})
self.assertEqual(
self.target._EventSubscriptionMap__subscription_map, {
"key01:value01": set(["EventSubscription01"]),
"key01:value02": set(["EventSubscription01"])
})
self.assertEqual(self.result, set())
def test_EventSubscriptionMap_remove_subscription_subscribers_zero(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscriptions =\
{"EventSubscription01": set(["key01:value01",
"key01:value02"]),
"EventSubscription02": set(["key01:value01",
"key01:value02"])}
self.target._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["EventSubscription02"]),
"key01:value02": set(["EventSubscription01",
"EventSubscription02"])}
self.result = self.target.remove_subscription("EventSubscription02")
self.assertEqual(
self.target._EventSubscriptionMap__subscriptions,
{"EventSubscription01": set(["key01:value01", "key01:value02"])})
self.assertEqual(self.target._EventSubscriptionMap__subscription_map,
{"key01:value02": set(["EventSubscription01"])})
self.assertEqual(self.result, set(["key01:value01", "key01:value02"]))
def test_EventSubscriptionMap_get_subscribers_return_subscribers(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["EventSubscription01",
"EventSubscription02"]),
"key01:value02": set(["EventSubscription01",
"EventSubscription02"])}
self.result = self.target.get_subscribers("key01", "value01")
self.assertEqual(self.result,
set(["EventSubscription01", "EventSubscription02"]))
def test_EventSubscriptionMap_get_subscribers_return_keys(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscriptions =\
{"EventSubscription01": set(["key01:value01",
"key01:value02"]),
"EventSubscription": set(["key01:value01",
"key01:value02"])}
self.result = self.target.get_subscribers()
self.assertEqual(self.result,
set(["EventSubscription01", "EventSubscription"]))
def test_EventSubscriptionMap_clear(self):
self.target = self.target.EventSubscriptionMap()
self.target._EventSubscriptionMap__subscriptions =\
{"EventSubscription01": set(["key01:value01",
"key01:value02"]),
"EventSubscription": set(["key01:value01",
"key01:value02"])}
self.target._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["EventSubscription01",
"EventSubscription02"]),
"key01:value02": set(["EventSubscription01",
"EventSubscription02"])}
self.target.clear()
self.assertEqual(self.target._EventSubscriptionMap__subscriptions, {})
self.assertEqual(self.target._EventSubscriptionMap__subscription_map,
{})
def test_PublishData_constructor(self):
self.target = self.target.PublishData("trans", "PublishData", 1,
"channel", "data")
self.assertEqual(self.target.trans, "trans")
self.assertEqual(self.target.type, "PublishData")
self.assertEqual(self.target.sno, 1)
self.assertEqual(self.target.channel, "channel")
self.assertEqual(self.target.data, "data")
def test_constructor(self):
with nested(
patch("uuid.uuid4"), patch("Queue.Queue"),
patch("org.o3project.odenos.remoteobject." +
"transport.message_dispatcher." +
"MessageDispatcher.EventSubscriptionMap")) as (
mock_uuid4, mock_Queue, mock_EventSubscriptionMap):
mock_uuid4.return_value = "mock_uuid4"
mock_Queue.return_value = "mock_Queue"
mock_EventSubscriptionMap.return_value =\
"mock_EventSubscriptionMap"
self.target = MessageDispatcher()
self.assertEqual(self.target._MessageDispatcher__clients, {})
self.assertEqual(self.target._MessageDispatcher__local_objects, {})
self.assertEqual(self.target._MessageDispatcher__event_manager_id,
None)
self.assertEqual(self.target.system_manager_id, "systemmanager")
self.assertEqual(self.target._MessageDispatcher__redisServer,
"localhost")
self.assertEqual(self.target._MessageDispatcher__redisPort, 6379)
self.assertEqual(
self.target._MessageDispatcher__sourceDispatcherId,
"mock_uuid4")
self.assertEqual(self.target._MessageDispatcher__pubsqueue,
"mock_Queue")
self.assertEqual(self.target._MessageDispatcher__redisSubscriber,
None)
self.assertEqual(self.target._MessageDispatcher__subscription_map,
"mock_EventSubscriptionMap")
def test_redisPublisherRunnable_success(self):
remote_msg_trans = RemoteMessageTransport("remote_object_id",
self.target)
self.value = self.target.PublishData(remote_msg_trans, 0, 1,
"123456789", "data")
self.target._MessageDispatcher__redisPubliser = redis.StrictRedis(
host=self.target._MessageDispatcher__redisServer,
port=self.target._MessageDispatcher__redisPort)
self.target._MessageDispatcher__pubsqueue.put(self.value)
self.target._MessageDispatcher__pubsqueue.put(None)
with nested(
patch("redis.client.StrictRedis.publish"),
patch("org.o3project.odenos.remoteobject.transport."
"remote_message_transport.RemoteMessageTransport."
"signalResponse")) as (mock_publish,
mock_signalResponse):
self.target._MessageDispatcher__redisPublisherRunnable()
mock_publish.assert_called_once_with("123456789", "data")
self.assertEqual(mock_signalResponse.call_count, 0)
def test_redisPublisherRunnable_Exept(self):
remote_msg_trans = RemoteMessageTransport("remote_object_id",
self.target)
self.value = self.target.PublishData(remote_msg_trans, 0, 1, "channel",
"data")
self.target._MessageDispatcher__pubsqueue.put(self.value)
self.target._MessageDispatcher__pubsqueue.put(None)
with nested(
patch("redis.client.StrictRedis.publish"),
patch("org.o3project.odenos.remoteobject.transport."
"remote_message_transport.RemoteMessageTransport."
"signalResponse")) as (mock_publish,
mock_signalResponse):
self.target._MessageDispatcher__redisPublisherRunnable()
self.assertEqual(mock_publish.call_count, 0)
self.assertEqual(mock_signalResponse.call_count, 1)
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_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_EVENT(self):
event = Event("publisher_id", "event_type", "event_body")
pk = msgpack.Packer()
resb = bytearray()
resb.extend(pk.pack(2))
resb.extend(pk.pack(0))
resb.extend(pk.pack("publisher_id:event_type"))
resb.extend(pk.pack(event.packed_object()))
self.value = {"type": "message", "data": resb}
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()
with nested(patch("redis.client.PubSub.subscribe"),
patch("redis.client.PubSub.unsubscribe"),
patch("redis.client.PubSub.listen"),
patch(self.EVENT_PATH +
".create_from_packed")) as (mock_subscribe,
mock_unsubscribe,
mock_listen, mock_event):
mock_subscribe.return_value = None
mock_unsubscribe.return_value = None
mock_listen.return_value = [self.value]
self.target._MessageDispatcher__redisSubscriberRunnable()
mock_event.assert_called_once_with(
["publisher_id", "event_type", "event_body"])
def test_redisSubscriberRunnable_except(self):
event = Event("publisher_id", "event_type", "event_body")
pk = msgpack.Packer()
resb = bytearray()
resb.extend(pk.pack(2))
resb.extend(pk.pack(0))
resb.extend(pk.pack("publisher_id:event_type"))
resb.extend(pk.pack(event.packed_object()))
self.value = {"type": "message", "data": resb}
with nested(patch("redis.client.PubSub.subscribe"),
patch("logging.error"),
patch("redis.client.PubSub.unsubscribe"),
patch("redis.client.PubSub.listen"),
patch(self.EVENT_PATH +
".create_from_packed")) as (mock_subscribe,
logging_error,
mock_unsubscribe,
mock_listen, mock_event):
mock_subscribe.return_value = None
mock_unsubscribe.return_value = None
mock_listen.return_value = [self.value]
mock_event.side_effect = KeyError()
self.target.start()
self.target._MessageDispatcher__redisSubscriberRunnable()
self.target.close()
mock_event.assert_called_any_with(
["publisher_id", "event_type", "event_body"])
def test_start(self):
with nested(patch("redis.client.PubSub.subscribe"),
patch("redis.client.PubSub.unsubscribe")) as (
mock_subscribe, mock_unsubscribe):
mock_subscribe.return_value = None
mock_unsubscribe.return_value = None
self.target.start()
self.target.close()
def test_stop_redisSubscriberThread_Not_None(self):
with nested(patch("redis.client.PubSub.subscribe"),
patch("threading.Thread.join"),
patch("redis.client.PubSub.unsubscribe")) as (
mock_subscribe, mock_join, mock_unsubscribe):
mock_subscribe.return_value = None
self.target.start()
self.target.stop()
self.assertEqual(mock_join.call_count, 2)
self.assertEqual(mock_unsubscribe.call_count, 1)
def test_stop_redisSubscriberThread_None(self):
self.target.stop()
def test_join_redisSubscriberThread_Not_None(self):
self.target._MessageDispatcher__redisSubscriberThread =\
threading.Thread(
target=self.target._MessageDispatcher__redisSubscriberRunnable)
self.target._MessageDispatcher__redisPublisherThread =\
threading.Thread(
target=self.target._MessageDispatcher__redisPublisherRunnable)
with nested(patch("redis.client.PubSub.subscribe"),
patch("threading.Thread.join")) as (mock_subscribe,
mock_join):
mock_subscribe.return_value = None
self.target.join()
self.assertEqual(mock_join.call_count, 2)
self.target._MessageDispatcher__redisPublisherThread = None
self.target._MessageDispatcher__redisSubscriberThread = None
def test_join_redisSubscriberThread_None(self):
self.target.join()
def test_close(self):
remote_msg_trans = RemoteMessageTransport("remote_object_id",
self.target)
self.target._MessageDispatcher__local_objects["object_id"] =\
remote_msg_trans
self.target._MessageDispatcher__clients["object_id"] =\
remote_msg_trans
self.target.close()
self.assertEqual(self.target._MessageDispatcher__local_objects, {})
self.assertEqual(self.target._MessageDispatcher__clients, {})
def test_get_message_client_create_client_exist(self):
remote_msg_trans = RemoteMessageTransport("remote_object_id",
self.target)
self.target._MessageDispatcher__clients["object_id"] =\
remote_msg_trans
self.result =\
self.target._MessageDispatcher__get_message_client("object_id")
self.assertNotEqual(self.target._MessageDispatcher__clients, {})
self.assertEqual(
self.target._MessageDispatcher__clients["object_id"].responseMap,
{})
def test_get_message_client_create_RemoteMessageT_client(self):
self.result =\
self.target._MessageDispatcher__get_message_client("object_id")
self.assertNotEqual(self.target._MessageDispatcher__clients, {})
self.assertEqual(
self.target._MessageDispatcher__clients["object_id"].responseMap,
{})
def test_get_message_client_create_LocalMessage_client(self):
self.target._MessageDispatcher__local_objects = {"object_id": None}
self.result =\
self.target._MessageDispatcher__get_message_client("object_id")
self.assertNotEqual(self.target._MessageDispatcher__clients, {})
self.assertEqual(
self.target._MessageDispatcher__clients["object_id"].object_id,
"object_id")
def test_get_source_dispatcher_id(self):
with patch("uuid.uuid4") as mock_uuid4:
mock_uuid4.return_value = "mock_uuid4"
self.target = MessageDispatcher()
self.result = self.target.get_source_dispatcher_id()
self.assertEqual(self.result, "mock_uuid4")
def test_getRedisPublisher(self):
self.assertEqual(self.target.getRedisPublisher(),
self.target._MessageDispatcher__redisPubliser)
def test_update_subscriber_redisSubscriber_Not_None(self):
self.target._MessageDispatcher__sourceDispatcherId = "DispatcherId"
subscription_map =\
self.target._MessageDispatcher__subscription_map
subscription_map._EventSubscriptionMap__subscriptions =\
{"remote_object": set(["key01:value01",
"key01:value02"]),
"local_object": set(["key01:value01",
"key01:value02"])}
subscription_map._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["remote_object",
"local_object"]),
"key01:value02": set(["remote_object",
"local_object"])}
remote_object = RemoteObject("remote_object", self.target)
self.target._MessageDispatcher__local_objects =\
{"remote_object": remote_object}
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 patch("redis.client.PubSub.subscribe") as mock_subscribe:
self.target._MessageDispatcher__update_subscriber()
mock_subscribe.assert_called_once_with([
"DispatcherId", "remote_object", "key01:value01",
"key01:value02"
])
def test_update_subscriber_redisSubscriber_None(self):
self.target._MessageDispatcher__update_subscriber()
def test_event_manager_id_exist(self):
self.target._MessageDispatcher__event_manager_id = "maneager_id"
self.assertEqual(self.target.event_manager_id, "maneager_id")
def test_event_manager_id_None(self):
self.target._MessageDispatcher__event_manager_id = None
self.assertEqual(self.target.event_manager_id, "eventmanager")
def test_add_local_object(self):
remote_msg_trans = RemoteMessageTransport("remote_object_id",
self.target)
self.target.add_local_object(remote_msg_trans)
self.assertEqual(
self.target._MessageDispatcher__local_objects["remote_object_id"],
remote_msg_trans)
def test_remove_local_object(self):
remote_msg_trans = RemoteMessageTransport("remote_object", self.target)
local_msg_trans = LocalMessageTransport("local_object", self.target)
self.target._MessageDispatcher__local_objects =\
{"remote_object": remote_msg_trans,
"local_object": local_msg_trans}
subscription_map =\
self.target._MessageDispatcher__subscription_map
subscription_map._EventSubscriptionMap__subscriptions =\
{"remote_object": set(["key01:value01",
"key01:value02"]),
"local_object": set(["key01:value01",
"key01:value02"])}
subscription_map._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["remote_object",
"local_object"]),
"key01:value02": set(["remote_object",
"local_object"])}
self.target.remove_local_object(local_msg_trans)
self.assertEqual(self.target._MessageDispatcher__local_objects,
{"remote_object": remote_msg_trans})
self.assertEqual(
subscription_map._EventSubscriptionMap__subscriptions,
{"remote_object": set(["key01:value01", "key01:value02"])})
self.assertEqual(
subscription_map._EventSubscriptionMap__subscription_map, {
"key01:value01": set(["remote_object"]),
"key01:value02": set(["remote_object"])
})
def test_add_remote_client(self):
clients = self.target._MessageDispatcher__clients
self.target.add_remote_client("remote_object")
self.assertNotEqual(self.target._MessageDispatcher__clients, {})
self.assertEqual(clients["remote_object"].responseMap, {})
def test_remove_remote_client(self):
clients = self.target._MessageDispatcher__clients
clients["remote_object"] = "mock"
self.target.remove_remote_client("remote_object")
self.assertEqual(self.target._MessageDispatcher__clients, {})
def test_get_local_object_ids(self):
self.target._MessageDispatcher__local_objects =\
{"remote_object": None,
"local_object": None}
self.result = self.target.get_local_object_ids()
self.assertEqual(self.result, ["remote_object", "local_object"])
def test_set_remote_system_manager(self):
clients = self.target._MessageDispatcher__clients
self.result = self.target.set_remote_system_manager()
self.assertNotEqual(self.target._MessageDispatcher__clients, {})
self.assertEqual(clients["systemmanager"].responseMap, {})
def test_request_sync(self):
with patch("org.o3project.odenos.remoteobject.transport." +
"remote_message_transport.RemoteMessageTransport." +
"send_request_message") as mock_send_request_message:
request = Request("object_id", "method", "path")
mock_send_request_message.return_value = "send_request_message"
self.result = self.target.request_sync(request)
self.assertEqual(self.result, "send_request_message")
def test_publish_event_async(self):
event = Event("publisher_id", "event_type", "event_body")
self.target.publish_event_async(event)
self.result = self.target._MessageDispatcher__pubsqueue.get()
self.assertEqual(self.result.trans, None)
self.assertEqual(self.result.type, 2)
self.assertEqual(self.result.sno, 0)
self.assertEqual(self.result.channel, "publisher_id:event_type")
def test_subscribe_event(self):
# TODO: this requires some work...
with patch("org.o3project.odenos.remoteobject.transport." +
"remote_message_transport.RemoteMessageTransport." +
"send_request_message") as mock_send_request_message:
mock_send_request_message.return_value = "send_request_message"
subscription_map =\
self.target._MessageDispatcher__subscription_map
self.value = EventSubscription("EventSubscription01",
{"key01": ["value01"]})
subscription_map._EventSubscriptionMap__subscriptions =\
{"EventSubscription01": set(["key01:value01",
"key01:value02"]),
"EventSubscription": set(["key01:value01",
"key01:value02"])}
self.target._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["EventSubscription01",
"EventSubscription02"]),
"key01:value02": set(["EventSubscription01",
"EventSubscription02"])}
self.result = self.target.subscribe_event(self.value)
self.assertEqual(self.result, "send_request_message")
def test_pushPublishQueue(self):
self.target.pushPublishQueue(None, 2, 1, "channel", "data")
self.result = self.target._MessageDispatcher__pubsqueue.get()
self.assertEqual(self.result.trans, None)
self.assertEqual(self.result.type, 2)
self.assertEqual(self.result.sno, 1)
self.assertEqual(self.result.channel, "channel")
self.assertEqual(self.result.data, "data")
def test_dispatch_request_object_id_in_local_objects(self):
request = Request("remote_object", "method", "path")
remote_object = RemoteObject("remote_object", self.target)
self.target._MessageDispatcher__local_objects =\
{"remote_object": remote_object}
with patch("org.o3project.odenos.remoteobject." +
"remote_object.RemoteObject." +
"dispatch_request") as mock_dispatch_request:
mock_dispatch_request.return_value = "mock_dispatch_request"
self.result = self.target.dispatch_request(request)
self.assertEqual(self.result, "mock_dispatch_request")
def test_dispatch_request_object_id_not_in_local_objects(self):
request = Request("NoneID", "method", "path")
remote_object = RemoteObject("remote_object", self.target)
self.target._MessageDispatcher__local_objects =\
{"remote_object": remote_object}
self.result = self.target.dispatch_request(request)
self.assertEqual(self.result.status_code, 404)
self.assertEqual(self.result.body, None)
def test_dispatch_event(self):
event = Event("key01", "value01", "event_body")
subscription_map =\
self.target._MessageDispatcher__subscription_map
subscription_map._EventSubscriptionMap__subscriptions =\
{"remote_object": set(["key01:value01",
"key01:value02"]),
"local_object": set(["key01:value01",
"key01:value02"])}
subscription_map._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["remote_object",
"local_object"]),
"key01:value02": set(["remote_object",
"local_object"])}
remote_object = RemoteObject("remote_object", self.target)
self.target._MessageDispatcher__local_objects =\
{"remote_object": remote_object}
with patch("org.o3project.odenos.remoteobject." +
"remote_object.RemoteObject." +
"dispatch_event") as mock_dispatch_event:
self.target.dispatch_event(event)
mock_dispatch_event.assert_called_once_with(event)
def test_dispatch_event_id_equal_del_obj_ids(self):
event = Event("key01", "value01", "event_body")
subscription_map =\
self.target._MessageDispatcher__subscription_map
subscription_map._EventSubscriptionMap__subscriptions =\
{"remote_object": set(["key01:value01",
"key01:value02"]),
"local_object": set(["key01:value01",
"key01:value02"])}
subscription_map._EventSubscriptionMap__subscription_map =\
{"key01:value01": set(["remote_object",
"local_object"]),
"key01:value02": set(["remote_object",
"local_object"])}
self.target._MessageDispatcher__local_objects =\
{"remote_object": None}
with patch(self.DISPATCHER_PATH + ".EventSubscriptionMap" +
".remove_subscription") as mock_remove_subscription:
self.target.dispatch_event(event)
mock_remove_subscription.assert_called_once_with("remote_object")