class TestSessionClass(unittest.TestCase):
@patch("sanji.session.sleep")
@patch("sanji.session.Thread")
def setUp(self, Thread, sleep):
self.thread_mock = Thread.return_value = MagicMock()
self.thread_mock.is_alive.return_value = True
self.session = Session()
def tearDown(self):
self.session.stop()
self.session = None
def test_init(self):
self.assertIsInstance(self.session.session_list, dict)
self.assertIsInstance(self.session.timeout_queue, deque)
def test_resolve(self):
message1 = Message({}, generate_id=True)
self.session.create(message1)
self.assertEqual(self.session.resolve(message1.id)["message"],
message1)
# resolve unknow message
self.session.resolve(1234)
def test_resolve_send(self):
# normal
message1 = Message({}, generate_id=True)
self.session.create(message1, mid=1)
session = self.session.resolve_send(1)
self.assertEqual(session["message"], message1)
self.assertEqual(session["status"], Status.SENT)
# not found
self.assertEqual(self.session.resolve_send(1234), None)
def test_create(self):
message1 = Message({}, generate_id=True)
message2 = Message({}, generate_id=True)
message3 = Message({}, generate_id=True)
# create session as normal
self.session.create(message1)
self.assertEqual(self.session.session_list[message1.id]["message"],
message1)
# id duplicate
message2.id = message1.id
session = self.session.create(message2)
self.assertNotEqual(session, None)
message3.id = message1.id
with self.assertRaises(SessionError):
self.session.create(message3, force=False)
def test_stop_is_alive_false(self):
self.thread_mock.is_alive.return_value = False
self.session.stop()
self.assertFalse(self.session.thread_aging.is_alive())
self.assertFalse(self.thread_mock.join.called)
def test_stop_is_alive_true(self):
self.thread_mock.is_alive.return_value = True
self.session.stop()
self.thread_mock.join.assert_called_once_with()
@patch("sanji.session.sleep")
def test_aging(self, sleep):
self.session.stop()
message1 = Message({}, generate_id=True)
# timeout (response)
self.session.create(message1, age=0)
m = self.session.stop_event = Mock()
conf = {"is_set.side_effect": [False, True, False, True]}
m.configure_mock(**conf)
self.session.aging()
try:
self.session.timeout_queue.pop()
except Exception:
self.fail("timeout_queue is empty")
# timeout (send)
self.session.create(message1, age=0)
self.session.aging()
for session in self.session.session_list.itervalues():
session["is_published"].set()
try:
self.session.timeout_queue.pop()
except Exception:
self.fail("timeout_queue is empty")
class TestPublishClass(unittest.TestCase):
@patch("sanji.session.Thread")
def setUp(self, Thread):
self.conn = Mockup()
self.session = Session()
self.publish = Publish(self.conn, self.session)
def tearDown(self):
self.session.stop()
self.conn = None
self.session = None
self.publish = None
def test_crud(self): # noqa
self.conn.publish = Mock(return_value=1)
self.session.create = Mock(return_value={})
# CRUD: block
with patch("sanji.publish.Publish._wait_published") as _wait_published:
_wait_published.return_value = None
for method in ["get", "put", "post", "delete"]:
self.publish.__getattribute__(method)("/test/resource", {
"test": method
}, False)
self.conn.publish.assert_called_once_with(topic="/controller",
qos=2,
payload=ANY)
self.conn.publish.reset_mock()
self.session.create.assert_called_once_with(ANY, mid=1, age=60)
self.session.create.reset_mock()
# CRUD: non-block
with patch("sanji.publish.Publish._wait_resolved") as _wait_resolved:
# Normal case
_wait_resolved.return_value = None
for method in ["get", "put", "post", "delete"]:
self.publish.__getattribute__(method)("/test/resource", {
"test": method
}, True)
# Timeout
_wait_resolved.side_effect = TimeoutError
for method in ["get", "put", "post", "delete"]:
with self.assertRaises(TimeoutError):
self.publish.__getattribute__(method)("/test/resource", {
"test": method
}, True, 0)
# StatusError
_wait_resolved.side_effect = StatusError
for method in ["get", "put", "post", "delete"]:
with self.assertRaises(StatusError):
self.publish.__getattribute__(method)("/test/resource", {
"test": method
}, True)
def test_event(self):
with patch("sanji.publish.Publish._wait_published") as _wait_published:
_wait_published.return_value = None
self.publish._conn.publish = Mock()
self.publish.event.get("/test/event2", {
"type": "notify2",
"message": "hi"
})
self.publish._conn.publish.assert_called_once_with(
topic="/controller", qos=2, payload=ANY)
def test_direct(self):
with patch("sanji.publish.Publish._wait_published") as _wait_published:
_wait_published.return_value = None
self.publish.direct.get("/test/direct1", {
"type": "direct1",
"message": "hi"
},
block=False)
_wait_published.assert_called_once_with(ANY)
def test_create_response(self):
messages = [
Message({"test": "block"}, generate_id=True),
Message({
"query": {},
"param": {},
"sign": ["controller"]
},
generate_id=True)
]
def check_message(topic, qos, payload):
self.assertNotIn("query", payload)
self.assertNotIn("param", payload)
self.assertIn("sign", payload)
self.assertIn("code", payload)
self.assertIn("this is sign", payload["sign"])
self.publish._wait_published = Mock(return_value=None)
self.conn.publish = check_message
for message in messages:
resp = self.publish.create_response(message, "this is sign")
resp(500, {"ccc": "moxa best"})
self.publish._wait_published.assert_called_once_with(
ANY, no_response=True)
self.publish._wait_published.reset_mock()
def test__create_message(self):
# input dict
msg = self.publish._create_message({}, None)
self.assertIsInstance(msg, Message)
msg = self.publish._create_message(
{
'method': 'get',
'sign': ['aaa', 'bbb']
}, {'test': 1234})
self.assertEqual(msg.method, 'get')
self.assertEqual(msg.data['test'], 1234)
self.assertEqual(msg.sign, ['aaa', 'bbb'])
# input Messgae
in_msg = Message({'method': 'post', 'resource': '/test'})
out_msg = self.publish._create_message(data=in_msg)
self.assertDictEqual(in_msg.__dict__, out_msg.__dict__)
def test__wait_resolved(self):
# RESPONSE_TIMEOUT
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = Status.RESPONSE_TIMEOUT
with self.assertRaises(TimeoutError):
self.publish._wait_resolved(session)
# RESOLVED
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = Status.RESOLVED
session["resolve_message"] = True
self.assertTrue(self.publish._wait_resolved(session))
# UNKNOWN
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = 999
with self.assertRaises(StatusError):
self.publish._wait_resolved(session)
def test__wait_published(self):
# SEND_TIMEOUT
session = self.session.create(Message({}, generate_id=True))
session["status"] = Status.SEND_TIMEOUT
session["is_published"].set()
with self.assertRaises(TimeoutError):
self.publish._wait_published(session)
# SENT
session = self.session.create(Message({}, generate_id=True))
session["status"] = Status.SENT
session["is_published"].set()
self.assertDictEqual(self.publish._wait_published(session), session)
# UNKNOWN
session = self.session.create(Message({}, generate_id=True))
session["status"] = 999
session["is_published"].set()
with self.assertRaises(StatusError):
self.publish._wait_published(session)
class TestPublishClass(unittest.TestCase):
def setUp(self):
self.conn = ConnectionMockup()
self.session = Session()
self.publish = Publish(self.conn, self.session)
def tearDown(self):
self.session.stop()
self.conn = None
self.session = None
self.publish = None
def test_crud(self): # noqa
this = self
mids = []
this.index = 0
def send(method, resouce, data, block):
mids.append(
this.publish.__getattribute__(method)(resouce,
data,
block=block))
threads = []
for method in ["get", "put", "post", "delete"]:
thread = Thread(target=send,
args=(method, "/test/resource", {
"test": method
}, False))
thread.daemon = True
thread.start()
threads.append(thread)
sleep(0.5)
for session in self.session.session_list.itervalues():
session["status"] = Status.SENT
session["is_resolved"].set()
session["is_published"].set()
for thread in threads:
thread.join(1)
self.assertFalse(thread.is_alive())
# CRUD - block
def send_block(message, data):
self.assertEqual(self.publish.get("/test/resource", message), data)
def send_timeout(message, data):
with self.assertRaises(TimeoutError):
print self.publish.put("/test/resource", message, timeout=0)
with self.assertRaises(TimeoutError):
self.publish.delete("/test/resource", message, timeout=-1)
def resolve_statuserror(message):
with self.assertRaises(StatusError):
self.publish.put("/", message, timeout=10)
message = Message({"test": "block"}, generate_id=True)
thread = Thread(target=send_block, args=(
message,
"block",
))
thread.daemon = True
thread.start()
sleep(0.1)
self.session.resolve(message.id, "block")
thread.join(1)
self.assertFalse(thread.is_alive())
# CRUD - block timeout
message = Message({"test": "timeout"}, generate_id=True)
thread = Thread(target=send_timeout, args=(
message,
"timeout",
))
thread.daemon = True
thread.start()
sleep(0.1)
# self.session.resolve(message.id, 1)
thread.join(1)
self.assertFalse(thread.is_alive())
# Resolve StatusError
message = Message({"test": "StatusError"}, generate_id=True)
thread = Thread(target=resolve_statuserror, args=(message, ))
thread.daemon = True
thread.start()
sleep(0.1)
self.session.resolve(message.id, 1, 123)
thread.join(1)
self.assertFalse(thread.is_alive())
def test_event(self):
# Resolve StatusError
def send_block():
self.publish.event("/test/event2", {
"type": "notify2",
"message": "hi"
})
thread = Thread(target=send_block, args=())
thread.daemon = True
thread.start()
sleep(0.5)
self.assertEqual(len(self.session.session_list), 1)
for session in self.session.session_list.itervalues():
self.session.resolve_send(session["mid"])
thread.join(0.5)
self.assertFalse(thread.is_alive())
self.assertEqual(len(self.session.session_list), 0)
def test_direct(self):
def send_nonblock():
session = self.publish.direct.get("/test/direct1", {
"type": "direct1",
"message": "hi"
},
block=False)
self.session.resolve(session["message"].id, None)
thread = Thread(target=send_nonblock, args=())
thread.daemon = True
thread.start()
sleep(0.5)
self.assertEqual(len(self.session.session_list), 1)
for session in self.session.session_list.itervalues():
session["status"] = Status.SENT
session["is_published"].set()
thread.join(0.5)
self.assertFalse(thread.is_alive())
def send_block():
self.publish.direct.get("/test/direct2", {
"type": "direct2",
"message": "hi"
},
block=True)
thread = Thread(target=send_block, args=())
thread.daemon = True
thread.start()
sleep(0.5)
self.assertEqual(len(self.session.session_list), 1)
session = self.session.session_list.values()[0]
self.session.resolve(session["message"].id, session["mid"])
thread.join(0.5)
self.assertFalse(thread.is_alive())
def test_create_response(self):
messages = [
Message({"test": "block"}, generate_id=True),
Message({
"query": {},
"param": {},
"sign": ["controller"]
},
generate_id=True)
]
def send_block(msg):
response = self.publish.create_response(msg, "this is sign")
response(500, {"ccc": "moxa best"})
threads = []
for message in messages:
thread = Thread(target=send_block, args=(message, ))
thread.daemon = True
thread.start()
threads.append(thread)
map(lambda t: t.join(0.1), threads)
self.assertEqual(len(self.session.session_list), len(messages))
for session in self.session.session_list.itervalues():
session["status"] = Status.SENT
session["is_published"].set()
for thread in threads:
thread.join(0.5)
self.assertFalse(thread.is_alive())
def test__create_message(self):
# input dict
msg = self.publish._create_message({}, None)
self.assertIsInstance(msg, Message)
msg = self.publish._create_message(
{
'method': 'get',
'sign': ['aaa', 'bbb']
}, {'test': 1234})
self.assertEqual(msg.method, 'get')
self.assertEqual(msg.data['test'], 1234)
self.assertEqual(msg.sign, ['aaa', 'bbb'])
# input Messgae
in_msg = Message({'method': 'post', 'resource': '/test'})
out_msg = self.publish._create_message(data=in_msg)
self.assertDictEqual(in_msg.__dict__, out_msg.__dict__)
def test__wait_resolved(self):
# RESPONSE_TIMEOUT
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = Status.RESPONSE_TIMEOUT
with self.assertRaises(TimeoutError):
self.publish._wait_resolved(session)
# RESOLVED
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = Status.RESOLVED
session["resolve_message"] = True
self.assertTrue(self.publish._wait_resolved(session))
# UNKNOWN
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = 999
with self.assertRaises(StatusError):
self.publish._wait_resolved(session)
def test__wait_published(self):
# SEND_TIMEOUT
session = self.session.create(Message({}, generate_id=True))
session["status"] = Status.SEND_TIMEOUT
session["is_published"].set()
with self.assertRaises(TimeoutError):
self.publish._wait_published(session)
# SENT
session = self.session.create(Message({}, generate_id=True))
session["status"] = Status.SENT
session["is_published"].set()
self.assertDictEqual(self.publish._wait_published(session), session)
# UNKNOWN
session = self.session.create(Message({}, generate_id=True))
session["status"] = 999
session["is_published"].set()
with self.assertRaises(StatusError):
self.publish._wait_published(session)
class TestPublishClass(unittest.TestCase):
@patch("sanji.session.Thread")
def setUp(self, Thread):
self.conn = Mockup()
self.session = Session()
self.publish = Publish(self.conn, self.session)
def tearDown(self):
self.session.stop()
self.conn = None
self.session = None
self.publish = None
def test_crud(self): # noqa
self.conn.publish = Mock(return_value=1)
self.session.create = Mock(return_value={})
# CRUD: block
with patch("sanji.publish.Publish._wait_published") as _wait_published:
_wait_published.return_value = None
for method in ["get", "put", "post", "delete"]:
self.publish.__getattribute__(method)("/test/resource",
{"test": method}, False)
self.conn.publish.assert_called_once_with(topic="/controller",
qos=2,
payload=ANY)
self.conn.publish.reset_mock()
self.session.create.assert_called_once_with(ANY, mid=1, age=60)
self.session.create.reset_mock()
# CRUD: non-block
with patch("sanji.publish.Publish._wait_resolved") as _wait_resolved:
# Normal case
_wait_resolved.return_value = None
for method in ["get", "put", "post", "delete"]:
self.publish.__getattribute__(method)("/test/resource",
{"test": method}, True)
# Timeout
_wait_resolved.side_effect = TimeoutError
for method in ["get", "put", "post", "delete"]:
with self.assertRaises(TimeoutError):
self.publish.__getattribute__(method)("/test/resource",
{"test": method},
True, 0)
# StatusError
_wait_resolved.side_effect = StatusError
for method in ["get", "put", "post", "delete"]:
with self.assertRaises(StatusError):
self.publish.__getattribute__(method)("/test/resource",
{"test": method},
True)
def test_event(self):
with patch("sanji.publish.Publish._wait_published") as _wait_published:
_wait_published.return_value = None
self.publish._conn.publish = Mock()
self.publish.event.get("/test/event2",
{"type": "notify2", "message": "hi"})
self.publish._conn.publish.assert_called_once_with(
topic="/controller", qos=2, payload=ANY)
def test_direct(self):
with patch("sanji.publish.Publish._wait_published") as _wait_published:
_wait_published.return_value = None
self.publish.direct.get("/test/direct1", {
"type": "direct1",
"message": "hi"},
block=False)
_wait_published.assert_called_once_with(ANY)
def test_create_response(self):
messages = [
Message({"test": "block"}, generate_id=True),
Message({"query": {}, "param": {}, "sign": ["controller"]},
generate_id=True)
]
def check_message(topic, qos, payload):
self.assertNotIn("query", payload)
self.assertNotIn("param", payload)
self.assertIn("sign", payload)
self.assertIn("code", payload)
self.assertIn("this is sign", payload["sign"])
self.publish._wait_published = Mock(return_value=None)
self.conn.publish = check_message
for message in messages:
resp = self.publish.create_response(message, "this is sign")
resp(500, {"ccc": "moxa best"})
self.publish._wait_published.assert_called_once_with(
ANY, no_response=True)
self.publish._wait_published.reset_mock()
def test__create_message(self):
# input dict
msg = self.publish._create_message({}, None)
self.assertIsInstance(msg, Message)
msg = self.publish._create_message(
{'method': 'get', 'sign': ['aaa', 'bbb']}, {'test': 1234}
)
self.assertEqual(msg.method, 'get')
self.assertEqual(msg.data['test'], 1234)
self.assertEqual(msg.sign, ['aaa', 'bbb'])
# input Messgae
in_msg = Message({'method': 'post', 'resource': '/test'})
out_msg = self.publish._create_message(data=in_msg)
self.assertDictEqual(in_msg.__dict__, out_msg.__dict__)
def test__wait_resolved(self):
# RESPONSE_TIMEOUT
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = Status.RESPONSE_TIMEOUT
with self.assertRaises(TimeoutError):
self.publish._wait_resolved(session)
# RESOLVED
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = Status.RESOLVED
session["resolve_message"] = True
self.assertTrue(self.publish._wait_resolved(session))
# UNKNOWN
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = 999
with self.assertRaises(StatusError):
self.publish._wait_resolved(session)
def test__wait_published(self):
# SEND_TIMEOUT
session = self.session.create(Message({}, generate_id=True))
session["status"] = Status.SEND_TIMEOUT
session["is_published"].set()
with self.assertRaises(TimeoutError):
self.publish._wait_published(session)
# SENT
session = self.session.create(Message({}, generate_id=True))
session["status"] = Status.SENT
session["is_published"].set()
self.assertDictEqual(self.publish._wait_published(session),
session)
# UNKNOWN
session = self.session.create(Message({}, generate_id=True))
session["status"] = 999
session["is_published"].set()
with self.assertRaises(StatusError):
self.publish._wait_published(session)
class TestPublishClass(unittest.TestCase):
def setUp(self):
self.conn = ConnectionMockup()
self.session = Session()
self.publish = Publish(self.conn, self.session)
def tearDown(self):
self.session.stop()
self.conn = None
self.session = None
self.publish = None
def test_crud(self): # noqa
this = self
mids = []
this.index = 0
def send(method, resouce, data, block):
mids.append(this.publish.__getattribute__(method)
(resouce, data, block=block))
threads = []
for method in ["get", "put", "post", "delete"]:
thread = Thread(target=send, args=(
method, "/test/resource", {"test": method}, False))
thread.daemon = True
thread.start()
threads.append(thread)
sleep(0.5)
for session in self.session.session_list.itervalues():
session["status"] = Status.SENT
session["is_resolved"].set()
session["is_published"].set()
for thread in threads:
thread.join(1)
self.assertFalse(thread.is_alive())
# CRUD - block
def send_block(message, data):
self.assertEqual(self.publish.get("/test/resource", message),
data)
def send_timeout(message, data):
with self.assertRaises(TimeoutError):
print self.publish.put("/test/resource", message, timeout=0)
with self.assertRaises(TimeoutError):
self.publish.delete("/test/resource", message, timeout=-1)
def resolve_statuserror(message):
with self.assertRaises(StatusError):
self.publish.put("/", message, timeout=10)
message = Message({"test": "block"}, generate_id=True)
thread = Thread(target=send_block, args=(message, "block",))
thread.daemon = True
thread.start()
sleep(0.1)
self.session.resolve(message.id, "block")
thread.join(1)
self.assertFalse(thread.is_alive())
# CRUD - block timeout
message = Message({"test": "timeout"}, generate_id=True)
thread = Thread(target=send_timeout, args=(message, "timeout",))
thread.daemon = True
thread.start()
sleep(0.1)
# self.session.resolve(message.id, 1)
thread.join(1)
self.assertFalse(thread.is_alive())
# Resolve StatusError
message = Message({"test": "StatusError"}, generate_id=True)
thread = Thread(target=resolve_statuserror, args=(message,))
thread.daemon = True
thread.start()
sleep(0.1)
self.session.resolve(message.id, 1, 123)
thread.join(1)
self.assertFalse(thread.is_alive())
def test_event(self):
# Resolve StatusError
def send_block():
self.publish.event("/test/event2",
{"type": "notify2", "message": "hi"})
thread = Thread(target=send_block, args=())
thread.daemon = True
thread.start()
sleep(0.5)
self.assertEqual(len(self.session.session_list), 1)
for session in self.session.session_list.itervalues():
self.session.resolve_send(session["mid"])
thread.join(0.5)
self.assertFalse(thread.is_alive())
self.assertEqual(len(self.session.session_list), 0)
def test_direct(self):
def send_nonblock():
session = self.publish.direct.get("/test/direct1", {
"type": "direct1",
"message": "hi"},
block=False)
self.session.resolve(session["message"].id, None)
thread = Thread(target=send_nonblock, args=())
thread.daemon = True
thread.start()
sleep(0.5)
self.assertEqual(len(self.session.session_list), 1)
for session in self.session.session_list.itervalues():
session["status"] = Status.SENT
session["is_published"].set()
thread.join(0.5)
self.assertFalse(thread.is_alive())
def send_block():
self.publish.direct.get("/test/direct2",
{"type": "direct2", "message": "hi"},
block=True)
thread = Thread(target=send_block, args=())
thread.daemon = True
thread.start()
sleep(0.5)
self.assertEqual(len(self.session.session_list), 1)
session = self.session.session_list.values()[0]
self.session.resolve(session["message"].id, session["mid"])
thread.join(0.5)
self.assertFalse(thread.is_alive())
def test_create_response(self):
messages = [
Message({"test": "block"}, generate_id=True),
Message({"query": {}, "param": {}, "sign": ["controller"]},
generate_id=True)
]
def send_block(msg):
response = self.publish.create_response(msg, "this is sign")
response(500, {"ccc": "moxa best"})
threads = []
for message in messages:
thread = Thread(target=send_block, args=(message,))
thread.daemon = True
thread.start()
threads.append(thread)
map(lambda t: t.join(0.1), threads)
self.assertEqual(len(self.session.session_list), len(messages))
for session in self.session.session_list.itervalues():
session["status"] = Status.SENT
session["is_published"].set()
for thread in threads:
thread.join(0.5)
self.assertFalse(thread.is_alive())
def test__create_message(self):
# input dict
msg = self.publish._create_message({}, None)
self.assertIsInstance(msg, Message)
msg = self.publish._create_message(
{'method': 'get', 'sign': ['aaa', 'bbb']}, {'test': 1234}
)
self.assertEqual(msg.method, 'get')
self.assertEqual(msg.data['test'], 1234)
self.assertEqual(msg.sign, ['aaa', 'bbb'])
# input Messgae
in_msg = Message({'method': 'post', 'resource': '/test'})
out_msg = self.publish._create_message(data=in_msg)
self.assertDictEqual(in_msg.__dict__, out_msg.__dict__)
def test__wait_resolved(self):
# RESPONSE_TIMEOUT
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = Status.RESPONSE_TIMEOUT
with self.assertRaises(TimeoutError):
self.publish._wait_resolved(session)
# RESOLVED
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = Status.RESOLVED
session["resolve_message"] = True
self.assertTrue(self.publish._wait_resolved(session))
# UNKNOWN
session = self.session.create(Message({}, generate_id=True))
session["is_resolved"].set()
session["status"] = 999
with self.assertRaises(StatusError):
self.publish._wait_resolved(session)
def test__wait_published(self):
# SEND_TIMEOUT
session = self.session.create(Message({}, generate_id=True))
session["status"] = Status.SEND_TIMEOUT
session["is_published"].set()
with self.assertRaises(TimeoutError):
self.publish._wait_published(session)
# SENT
session = self.session.create(Message({}, generate_id=True))
session["status"] = Status.SENT
session["is_published"].set()
self.assertDictEqual(self.publish._wait_published(session),
session)
# UNKNOWN
session = self.session.create(Message({}, generate_id=True))
session["status"] = 999
session["is_published"].set()
with self.assertRaises(StatusError):
self.publish._wait_published(session)
class TestSessionClass(unittest.TestCase):
def setUp(self):
self.session = Session()
def tearDown(self):
self.session.stop()
self.session = None
def test_init(self):
self.assertIsInstance(self.session.session_list, dict)
# self.assertIsInstance(self.session.session_lock, Lock)
self.assertIsInstance(self.session.timeout_queue, deque)
self.assertIsInstance(self.session.thread_aging, Thread)
def test_resolve(self):
message1 = Message({}, generate_id=True)
self.session.create(message1)
self.assertEqual(self.session.resolve(message1.id)["message"],
message1)
# resolve unknow message
self.session.resolve(1234)
def test_resolve_send(self):
# normal
message1 = Message({}, generate_id=True)
self.session.create(message1, mid=1)
session = self.session.resolve_send(1)
self.assertEqual(session["message"], message1)
self.assertEqual(session["status"], Status.SENT)
# not found
self.assertEqual(self.session.resolve_send(1234), None)
def test_create(self):
message1 = Message({}, generate_id=True)
message2 = Message({}, generate_id=True)
message3 = Message({}, generate_id=True)
# create session as normal
self.session.create(message1)
self.assertEqual(self.session.session_list[message1.id]["message"],
message1)
# id duplicate
message2.id = message1.id
session = self.session.create(message2)
self.assertNotEqual(session, None)
message3.id = message1.id
with self.assertRaises(SessionError):
self.session.create(message3, force=False)
# aging should be test too
sleep(1)
self.assertLess(self.session.session_list[message1.id]["age"], 60)
def test_stop(self):
self.session.stop()
self.assertFalse(self.session.thread_aging.is_alive())
def test_aging(self):
message1 = Message({}, generate_id=True)
# timeout (response)
self.session.create(message1, age=0)
sleep(1)
try:
self.session.timeout_queue.pop()
except Exception:
self.fail("timeout_queue is not empty")
# timeout (send)
self.session.create(message1, age=1)
for session in self.session.session_list.itervalues():
session["is_published"].set()
sleep(1)
try:
self.session.timeout_queue.pop()
except Exception:
self.fail("timeout_queue is empty")