def test_chatMessageHandler(self): # Get chat data chat_data = self.test_chat_datasets[1] # Create ChatTagHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) # Process messages for deserialized_msg in chat_data.message_list: message_handler.process(deserialized_msg) # Retrieve all chat tag models tag_models = message_handler.chat_tag_handler.finalize() # Compare number of tags created to expected number expected_tag_models = chat_data.expected_tag_models self.assertEqual(len(expected_tag_models), len(tag_models)) # Compare output to expected values for (index, actual_tag) in enumerate(tag_models): # index values start at 0 self.assertEqual(expected_tag_models[index].user_id, actual_tag.user_id) self.assertEqual(expected_tag_models[index].tag_id, actual_tag.tag_id) self.assertEqual(expected_tag_models[index].name, actual_tag.name) self.assertEqual(expected_tag_models[index].deleted, actual_tag.deleted) self.assertEqual(expected_tag_models[index].chat_minute.chat_session_id, actual_tag.chat_minute.chat_session_id) self.assertEqual(expected_tag_models[index].chat_minute.topic_id, actual_tag.chat_minute.topic_id) self.assertEqual(expected_tag_models[index].chat_minute.start, actual_tag.chat_minute.start) self.assertEqual(expected_tag_models[index].chat_minute.end, actual_tag.chat_minute.end)
def _persist_data(self, db_session): """Persist chat data to the db This method will create the necessary chat minutes, tags, and other entities for the chat based on the chat messages that were created by the chat service. """ try: # Retrieve the chat session id job = db_session.query(ChatPersistJob).filter(ChatPersistJob.id==self.job_id).one() self.chat_session_id = job.chat_session.id # Specify the format of the msg data thrift_b64_format_id = db_session.query(ChatMessageFormatType).\ filter(ChatMessageFormatType.name=='THRIFT_BINARY_B64').\ one().\ id # Read all chat messages that were stored by the chat svc. # It's important that the messages be consumed in chronological # order so that ordering dependencies between messages can be # properly handled. # (e.g. ChatTags needing a reference to a ChatMinute) chat_messages = db_session.query(ChatMessage).\ filter(ChatMessage.chat_session_id == self.chat_session_id).\ filter(ChatMessage.format_type_id == thrift_b64_format_id).\ order_by(ChatMessage.timestamp).\ all() self.log.info("Persist job_id=%d found %d messages to process for chat_session_id=%d" % (self.job_id, len(chat_messages), self.chat_session_id)) # Deserialize all chat message data deserialized_chat_msgs = [] for chat_message in chat_messages: deserialized_msg = Message() deserialize(deserialized_msg, chat_message.data) deserialized_chat_msgs.append(deserialized_msg) # Generate topics collection for this chat topics_manager = TopicDataManager() topic_id = topics_manager.get_root_topic_id(db_session, self.chat_session_id) topics_collection = topics_manager.get_collection(db_session, topic_id) # Process the deserialized chat messages handler = ChatMessageHandler(self.chat_session_id, topics_collection) for message in deserialized_chat_msgs: handler.process(message) # Persist the generated models models_to_persist = handler.finalize() for model in models_to_persist: db_session.add(model) db_session.flush() except Exception as e: raise e
def test_createModels_sameUserSameTagNameDifferentMinute(self): # Get chat data chat_data = self.test_chat_datasets[1] chat_minute = chat_data.expected_minute_models[1] # Create ChatTagHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) tag_handler = message_handler.chat_tag_handler # Expected ChatTag message = chat_data.message_list[9] expected_tag1 = ChatTag(user_id=message.header.userId, chat_minute=chat_minute, tag_id=message.tagCreateMessage.tagReferenceId, name=message.tagCreateMessage.name, deleted=False) # Create the real ChatTag message_handler.chat_minute_handler._set_active_minute(chat_minute) tag_handler.create_models(message) # Expected ChatTag message = chat_data.message_list[10] expected_tag2 = ChatTag( user_id=message.header.userId, chat_minute=self. dummy_chat_minute, #Different ChatMinute than 1st Tag tag_id=message.tagCreateMessage.tagReferenceId, name=message.tagCreateMessage.name, deleted=False) # Create the real ChatTag message_handler.chat_minute_handler._set_active_minute( self.dummy_chat_minute) tag_handler.create_models(message) # Retrieve created models created_tags = tag_handler.finalize() self.assertEqual(2, len(created_tags)) self.assertIsNotNone(created_tags[0]) self.assertIsNotNone(created_tags[1]) actual_tag1 = created_tags[0] actual_tag2 = created_tags[1] # Compare output to expected values self.assertEqual(expected_tag1.user_id, actual_tag1.user_id) self.assertEqual(expected_tag1.chat_minute, actual_tag1.chat_minute) self.assertEqual(expected_tag1.tag_id, actual_tag1.tag_id) self.assertEqual(expected_tag1.name, actual_tag1.name) self.assertEqual(expected_tag1.deleted, actual_tag1.deleted) # Compare output to expected values self.assertEqual(expected_tag2.user_id, actual_tag2.user_id) self.assertEqual(expected_tag2.chat_minute, actual_tag2.chat_minute) self.assertEqual(expected_tag2.tag_id, actual_tag2.tag_id) self.assertEqual(expected_tag2.name, actual_tag2.name) self.assertEqual(expected_tag2.deleted, actual_tag2.deleted)
def test_deleteModels_doubleDelete(self): # Get chat data chat_data = self.test_chat_datasets[1] chat_minute = chat_data.expected_minute_models[1] # Create ChatTagHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) message_handler.chat_minute_handler._set_active_minute(chat_minute) tag_handler = message_handler.chat_tag_handler # Create the real ChatTag tag_create_message = chat_data.message_list[7] tag_handler.create_models(tag_create_message) # Delete the ChatTag tag_delete_message = chat_data.message_list[8] tag_handler.delete_models(tag_delete_message) # Delete the tag again # Should silently fail tag_handler.delete_models(tag_delete_message) created_tags = tag_handler.finalize() self.assertEqual(0, len(created_tags))
def test_createModels_singleTag(self): # Get chat data chat_data = self.test_chat_datasets[1] chat_minute = chat_data.expected_minute_models[1] # Create ChatTagHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) message_handler.chat_minute_handler._set_active_minute(chat_minute) tag_handler = message_handler.chat_tag_handler # Expected ChatTag message = chat_data.message_list[6] expected_tag = ChatTag(user_id=message.header.userId, chat_minute=chat_minute, tag_id=message.tagCreateMessage.tagReferenceId, name=message.tagCreateMessage.name, deleted=False) # Create the real ChatTag tag_handler.create_models(message) created_tags = tag_handler.finalize() self.assertEqual(1, len(created_tags)) actual_tag = created_tags[0] # Compare output to expected values self.assertEqual(expected_tag.user_id, actual_tag.user_id) self.assertEqual(expected_tag.chat_minute, actual_tag.chat_minute) self.assertEqual(expected_tag.tag_id, actual_tag.tag_id) self.assertEqual(expected_tag.name, actual_tag.name) self.assertEqual(expected_tag.deleted, actual_tag.deleted)
def test_createModels(self): # Get chat data chat_data = self.test_chat_datasets[0] # Create ChatMarkerHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) marker_handler = message_handler.chat_marker_handler # Process messages for deserialized_msg in chat_data.message_list: message_handler.process(deserialized_msg) # Retrieve all speaking marker models speaking_models = marker_handler.finalize() # Ensure number of created models self.assertEqual(len(chat_data.expected_marker_models), len(speaking_models)) # Ensure models are returned in chronological order prev_model_start = 0 for model in speaking_models: model_start = tz.utc_to_timestamp(model.start) self.assertGreater(model_start, prev_model_start) prev_model_start = model_start # Check model data expected_models = chat_data.expected_marker_models for index, model in enumerate(speaking_models): self.assertIsNotNone(model.start) self.assertIsNotNone(model.end) self.assertEqual(expected_models[index].user_id, model.user_id) self.assertEqual( expected_models[index].chat_minute.chat_session_id, model.chat_minute.chat_session_id) self.assertEqual(expected_models[index].chat_minute.topic_id, model.chat_minute.topic_id) self.assertEqual(expected_models[index].chat_minute.start, model.chat_minute.start) self.assertEqual(expected_models[index].chat_minute.end, model.chat_minute.end)
def test_ChatMessageHandlerInit(self): # Specify a chat chat_data = self.test_chat_datasets[0] # Instantiate MessageHandler handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) self.assertIsNotNone(handler.chat_marker_handler) self.assertIsNotNone(handler.chat_minute_handler) self.assertIsNotNone(handler.chat_tag_handler)
def test_deleteModels(self): # Get chat data chat_data = self.test_chat_datasets[0] # Create ChatTagHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) marker_handler = message_handler.chat_marker_handler with self.assertRaises(NotImplementedError): marker_handler.delete_models(None)
def test_chatMinuteHandler(self): """ Sends input deserialized Thrift messages into the ChatMessageHandler and verifies the output ChatMinute objects. """ # Get chat data chat_data = self.test_chat_datasets[0] # Create ChatMinuteHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) minute_handler = message_handler.chat_minute_handler # Process messages for deserialized_msg in chat_data.message_list: message_handler.process(deserialized_msg) # Retrieve all chat minute models ordered by topic rank minute_models = minute_handler.finalize() # Ensure number of created models self.assertEqual(len(chat_data.expected_minute_models), len(minute_models)) # Ensure models are returned in chronological order prev_model_start = 0 for model in minute_models: model_start = tz.utc_to_timestamp(model.start) self.assertGreaterEqual(model_start, prev_model_start) prev_model_start = model_start # Check model data expected_models = chat_data.expected_minute_models for index, model in enumerate(minute_models): self.assertEqual(expected_models[index].chat_session_id, model.chat_session_id) self.assertEqual(expected_models[index].topic_id, model.topic_id) self.assertEqual(expected_models[index].start, model.start) self.assertEqual(expected_models[index].end, model.end)
def test_getHighestLeafs(self): for dataset in self.test_topic_datasets: message_handler = ChatMessageHandler(self.chat_session_id, dataset.topic_collection) handler = message_handler.chat_minute_handler highest_leafs = handler._get_highest_ranked_leafs( dataset.topic_collection) expected_highest_leafs = dataset.expected_highest_leaf_list_by_rank # Verify topics self.assertEqual(expected_highest_leafs, highest_leafs)
def test_updateModels(self): # Get chat data chat_data = self.test_chat_datasets[0] # Create ChatMinuteHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) minute_handler = message_handler.chat_minute_handler # Set the start time on the chat minutes (Root, Topic1) message = chat_data.message_list[27] message_handler.process(message) # Since the end-time's have not been written, an exception should be raised with self.assertRaises(InvalidChatMinuteException): minute_handler.finalize() # Set the end time on the chat minutes (Root, Topic1) message = chat_data.message_list[64] message_handler.process(message) minute_models = minute_handler.finalize() # Ensure number of created models self.assertEqual(len(chat_data.expected_minute_models), len(minute_models)) # Ensure models are returned in chronological order prev_model_start = 0 for model in minute_models: model_start = tz.utc_to_timestamp(model.start) self.assertGreaterEqual(model_start, prev_model_start) prev_model_start = model_start # Check model data expected_models = chat_data.expected_minute_models for index, model in enumerate(minute_models): self.assertEqual(expected_models[index].chat_session_id, model.chat_session_id) self.assertEqual(expected_models[index].topic_id, model.topic_id) self.assertEqual(expected_models[index].start, model.start) self.assertEqual(expected_models[index].end, model.end)
def test_updateModels(self): # Get chat data chat_data = self.test_chat_datasets[1] # Create ChatTagHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) tag_handler = message_handler.chat_tag_handler message = chat_data.message_list[6] with self.assertRaises(NotImplementedError): tag_handler.update_models(message)
def test_chatMessageHandler(self): # Get chat data chat_data = self.test_chat_datasets[1] # Create ChatTagHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) # Process messages for deserialized_msg in chat_data.message_list: message_handler.process(deserialized_msg) # Retrieve all chat tag models tag_models = message_handler.chat_tag_handler.finalize() # Compare number of tags created to expected number expected_tag_models = chat_data.expected_tag_models self.assertEqual(len(expected_tag_models), len(tag_models)) # Compare output to expected values for (index, actual_tag) in enumerate(tag_models): # index values start at 0 self.assertEqual(expected_tag_models[index].user_id, actual_tag.user_id) self.assertEqual(expected_tag_models[index].tag_id, actual_tag.tag_id) self.assertEqual(expected_tag_models[index].name, actual_tag.name) self.assertEqual(expected_tag_models[index].deleted, actual_tag.deleted) self.assertEqual( expected_tag_models[index].chat_minute.chat_session_id, actual_tag.chat_minute.chat_session_id) self.assertEqual(expected_tag_models[index].chat_minute.topic_id, actual_tag.chat_minute.topic_id) self.assertEqual(expected_tag_models[index].chat_minute.start, actual_tag.chat_minute.start) self.assertEqual(expected_tag_models[index].chat_minute.end, actual_tag.chat_minute.end)
def test_createModels_invalidMinute(self): # Get chat data chat_data = self.test_chat_datasets[0] # Create ChatMinuteHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) minute_handler = message_handler.chat_minute_handler # Create the real ChatTag message = chat_data.message_list[27] minute_handler.create_models(message) with self.assertRaises(InvalidChatMinuteException): minute_handler.finalize()
def test_deleteModels_invalidTagID(self): # Get chat data chat_data = self.test_chat_datasets[1] chat_minute = chat_data.expected_minute_models[1] # Create ChatTagHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) message_handler.chat_minute_handler._set_active_minute(chat_minute) tag_handler = message_handler.chat_tag_handler message = chat_data.message_list[8] with self.assertRaises(TagIdDoesNotExistException): tag_handler.delete_models(message)
def test_createModels(self): # Get chat data chat_data = self.test_chat_datasets[0] # Create ChatMarkerHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) marker_handler = message_handler.chat_marker_handler # Process messages for deserialized_msg in chat_data.message_list: message_handler.process(deserialized_msg) # Retrieve all speaking marker models speaking_models = marker_handler.finalize() # Ensure number of created models self.assertEqual(len(chat_data.expected_marker_models), len(speaking_models)) # Ensure models are returned in chronological order prev_model_start = 0 for model in speaking_models: model_start = tz.utc_to_timestamp(model.start) self.assertGreater(model_start, prev_model_start) prev_model_start = model_start # Check model data expected_models = chat_data.expected_marker_models for index, model in enumerate(speaking_models): self.assertIsNotNone(model.start) self.assertIsNotNone(model.end) self.assertEqual(expected_models[index].user_id, model.user_id) self.assertEqual(expected_models[index].chat_minute.chat_session_id, model.chat_minute.chat_session_id) self.assertEqual(expected_models[index].chat_minute.topic_id, model.chat_minute.topic_id) self.assertEqual(expected_models[index].chat_minute.start, model.chat_minute.start) self.assertEqual(expected_models[index].chat_minute.end, model.chat_minute.end)
def test_getChatMinuteEndTopicChain(self): for dataset in self.test_topic_datasets: message_handler = ChatMessageHandler(self.chat_session_id, dataset.topic_collection) handler = message_handler.chat_minute_handler chat_minute_end_topic_chain = handler._get_chat_minute_end_topic_chain( dataset.topic_collection) expected_topic_chain = dataset.expected_chat_minute_end_topic_chain for key, value in chat_minute_end_topic_chain.items(): for topic in value: #print 'key %s: %s' % (key, topic.id) pass # Verify topics self.assertEqual(expected_topic_chain, chat_minute_end_topic_chain)
def test_createModels_noActiveChatMinute(self): # Get chat data chat_data = self.test_chat_datasets[1] chat_minute = None # Create ChatTagHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) message_handler.chat_minute_handler._set_active_minute(chat_minute) tag_handler = message_handler.chat_tag_handler # Test create_models message = chat_data.message_list[6] with self.assertRaises(NoActiveChatMinuteException): tag_handler.create_models(message) # Test delete_models message = chat_data.message_list[8] with self.assertRaises(NoActiveChatMinuteException): tag_handler.delete_models(message)
def test_createModels_noActiveChatMinute(self): # Get chat data chat_data = self.test_chat_datasets[0] # Create ChatMarkerHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) message_handler.chat_minute_handler._set_active_minute(None) marker_handler = message_handler.chat_marker_handler # Process chat-started message to indicate that the active minute # should now never be None self.assertEqual(False, marker_handler.is_chat_started) message = chat_data.message_list[28] marker_handler.create_models(message) self.assertEqual(True, marker_handler.is_chat_started) # Test create_models message = chat_data.message_list[31] # Get a speaking marker message with self.assertRaises(NoActiveChatMinuteException): marker_handler.create_models(message)
def _persist_data(self, db_session): """Persist chat data to the db This method will create the necessary chat minutes, tags, and other entities for the chat based on the chat messages that were created by the chat service. """ try: # Retrieve the chat session id job = db_session.query(ChatPersistJob).filter( ChatPersistJob.id == self.job_id).one() self.chat_session_id = job.chat_session.id # Specify the format of the msg data thrift_b64_format_id = db_session.query(ChatMessageFormatType).\ filter(ChatMessageFormatType.name=='THRIFT_BINARY_B64').\ one().\ id # Read all chat messages that were stored by the chat svc. # It's important that the messages be consumed in chronological # order so that ordering dependencies between messages can be # properly handled. # (e.g. ChatTags needing a reference to a ChatMinute) chat_messages = db_session.query(ChatMessage).\ filter(ChatMessage.chat_session_id == self.chat_session_id).\ filter(ChatMessage.format_type_id == thrift_b64_format_id).\ order_by(ChatMessage.timestamp).\ all() self.log.info( "Persist job_id=%d found %d messages to process for chat_session_id=%d" % (self.job_id, len(chat_messages), self.chat_session_id)) # Deserialize all chat message data deserialized_chat_msgs = [] for chat_message in chat_messages: deserialized_msg = Message() deserialize(deserialized_msg, chat_message.data) deserialized_chat_msgs.append(deserialized_msg) # Generate topics collection for this chat topics_manager = TopicDataManager() topic_id = topics_manager.get_root_topic_id( db_session, self.chat_session_id) topics_collection = topics_manager.get_collection( db_session, topic_id) # Process the deserialized chat messages handler = ChatMessageHandler(self.chat_session_id, topics_collection) for message in deserialized_chat_msgs: handler.process(message) # Persist the generated models models_to_persist = handler.finalize() for model in models_to_persist: db_session.add(model) db_session.flush() except Exception as e: raise e
def test_createModels_differentUserSameTagNameSameMinute(self): # Get chat data chat_data = self.test_chat_datasets[1] chat_minute = chat_data.expected_minute_models[1] # Create ChatTagHandler message_handler = ChatMessageHandler(chat_data.chat_session_id, chat_data.topic_collection) message_handler.chat_minute_handler._set_active_minute(chat_minute) tag_handler = message_handler.chat_tag_handler # Expected ChatTag message = chat_data.message_list[6] expected_tag1 = ChatTag(user_id=message.header.userId, chat_minute=chat_minute, tag_id=message.tagCreateMessage.tagReferenceId, name=message.tagCreateMessage.name, deleted=False) # Create the real ChatTag tag_handler.create_models(message) # Expected ChatTag # Message is a copy of m7, with changes to tagId, userId message = Message( tagCreateMessage=TagCreateMessage( tagId='4141decbb6f44471939149d6bc801777', name='Tag', tagReferenceId=None, minuteId='6350813013bd4472b9ef5366fca0b434'), minuteUpdateMessage=None, whiteboardDeletePathMessage=None, minuteCreateMessage=None, header=MessageHeader( chatSessionToken= '1_MX4xNTg4OTk5MX4xMjcuMC4wLjF-V2VkIEF1ZyAyMiAwNjo1ODoyNSBQRFQgMjAxMn4wLjg5Mjc3OTJ-', timestamp=1345643936.348819, route=MessageRoute(type=1, recipients=[]), userId=14, type=100, id='7f577979990945efa0b41ab887155a1d'), tagDeleteMessage=None, whiteboardCreateMessage=None, whiteboardDeleteMessage=None, markerCreateMessage=None, whiteboardCreatePathMessage=None) expected_tag2 = ChatTag(user_id=message.header.userId, chat_minute=chat_minute, tag_id=message.tagCreateMessage.tagReferenceId, name=message.tagCreateMessage.name, deleted=False) # Create the real ChatTag tag_handler.create_models(message) # Retrieve created models created_tags = tag_handler.finalize() self.assertEqual(2, len(created_tags)) self.assertIsNotNone(created_tags[0]) self.assertIsNotNone(created_tags[1]) actual_tag1 = created_tags[0] actual_tag2 = created_tags[1] # Compare output to expected values self.assertEqual(expected_tag1.user_id, actual_tag1.user_id) self.assertEqual(expected_tag1.chat_minute, actual_tag1.chat_minute) self.assertEqual(expected_tag1.tag_id, actual_tag1.tag_id) self.assertEqual(expected_tag1.name, actual_tag1.name) self.assertEqual(expected_tag1.deleted, actual_tag1.deleted) # Compare output to expected values self.assertEqual(expected_tag2.user_id, actual_tag2.user_id) self.assertEqual(expected_tag2.chat_minute, actual_tag2.chat_minute) self.assertEqual(expected_tag2.tag_id, actual_tag2.tag_id) self.assertEqual(expected_tag2.name, actual_tag2.name) self.assertEqual(expected_tag2.deleted, actual_tag2.deleted)