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