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