def test_thread_returned_with_thread_id_returns_404(self):
"""retrieves thread using id that doesn't exist"""
with self.app.app_context():
with current_app.test_request_context():
with self.assertRaises(NotFound):
Retriever.retrieve_thread('anotherThreadId',
self.user_respondent)
def test_all_messages_in_conversation_marked_unread(self):
# create a thread with two messages
conversation_id = self.create_conversation_with_respondent_as_unread(
user=self.user_respondent, message_count=2)
with self.app.app_context():
conversation = Retriever.retrieve_thread(conversation_id,
self.user_respondent)
for msg in conversation.all():
# as there's two ways that a message is unread, first check the `read at` time isn't set
self.assertIsNone(msg.read_at)
# now collect all the message labels
labels = []
for status in msg.statuses:
labels.append(status.label)
# and check the unread is present
self.assertTrue("UNREAD" in labels)
# now mark the first message as read and check the whole conversation is now read
Modifier.mark_message_as_read(
conversation[0].serialize(self.user_respondent),
self.user_respondent)
con = Retriever.retrieve_thread(conversation_id,
self.user_respondent)
for msg in con.all():
# message `read at` should now be set
self.assertIsNotNone(msg.read_at)
# collect the labels again
labels = []
for status in msg.statuses:
labels.append(status.label)
# and there should be no unread
self.assertFalse("UNREAD" in labels)
def test_latest_message_from_each_thread_chosen_desc(self):
"""checks the message chosen for each thread is the latest message within that thread"""
for _ in range(5):
self.create_thread(no_of_messages=3)
with self.app.app_context():
with current_app.test_request_context():
args = get_args(limit=MESSAGE_QUERY_LIMIT)
response = Retriever.retrieve_thread_list(
self.user_internal, args)
date = []
thread_ids = []
msg_ids = []
for message in response.items:
serialized_msg = message.serialize(self.user_internal)
if 'sent_date' in serialized_msg:
date.append(serialized_msg['sent_date'])
elif 'modified_date' in serialized_msg:
date.append(serialized_msg['modified_date'])
thread_ids.append(serialized_msg['thread_id'])
msg_ids.append(serialized_msg['msg_id'])
self.assertEqual(len(msg_ids), 5)
args = get_args(page=1, limit=MESSAGE_QUERY_LIMIT)
for x in range(0, len(thread_ids)):
thread = Retriever.retrieve_thread(thread_ids[x],
self.user_internal)
self.assertEqual(date[x],
str(thread.all()[0].events[0].date_time))
self.assertEqual(msg_ids[x],
thread.all()[0].events[0].msg_id)
def test_all_msg_returned_for_thread_id(self):
"""retrieves messages for thread_id from database"""
thread_id = self.create_thread(no_of_messages=6)
with self.app.app_context():
with current_app.test_request_context():
response = Retriever.retrieve_thread(thread_id,
self.user_respondent)
self.assertEqual(len(response.all()), 6)
def test_thread_returned_in_desc_order(self):
"""check thread returned in correct order"""
thread_id = self.create_thread(no_of_messages=6)
with self.app.app_context():
with current_app.test_request_context():
response = Retriever.retrieve_thread(thread_id,
self.user_respondent)
self.assertEqual(len(response.all()), 6)
sent = [
str(message.events[0].date_time)
for message in response.all()
]
desc_date = sorted(sent, reverse=True)
self.assertEqual(len(sent), 6)
self.assertListEqual(desc_date, sent)
def test_read_date_is_set(self):
"""testing message read_date is set when unread label is removed"""
thread_id = self.populate_database(1, mark_as_read=False)
with self.app.app_context():
thread = Retriever.retrieve_thread(thread_id,
self.user_respondent).all()
serialised_message = Retriever.retrieve_message(
thread[0].msg_id, self.user_internal)
Modifier.mark_message_as_read(serialised_message,
self.user_internal)
serialised_message = Retriever.retrieve_message(
thread[0].msg_id, self.user_internal)
db_message = SecureMessage.query.filter(
SecureMessage.msg_id == serialised_message['msg_id']).one()
self.assertIsNotNone(serialised_message['read_date'])
self.assertTrue(isinstance(db_message.read_at, datetime.datetime))
# Test that timestamp on read message is less than 3 seconds old to prove it
# was only just created
delta = datetime.datetime.utcnow() - db_message.read_at
self.assertTrue(delta.total_seconds() < 3)
def test_respondent_can_only_see_their_messages(self):
"""tests that a respondent can only see their messages i.e. they should not
see any messages sent to another respondent"""
first_respondent_thread_id = self.create_thread(
no_of_messages=1,
external_actor=self.default_external_actor,
internal_actor=self.default_internal_actor)
second_respondent_thread_id = self.create_thread(
no_of_messages=1,
external_actor=self.second_external_actor,
internal_actor=self.default_internal_actor)
with self.app.app_context():
with current_app.test_request_context():
args = get_args()
first_respondent_thread_list = Retriever.retrieve_thread_list(
self.user_respondent, args)
self.assertEqual(first_respondent_thread_list.total, 1)
second_respondent_thread_list = Retriever.retrieve_thread_list(
self.second_user_respondent, args)
self.assertEqual(second_respondent_thread_list.total, 1)
internal_thread_list = Retriever.retrieve_thread_list(
self.user_internal, args)
self.assertEqual(internal_thread_list.total, 2)
# first respondent can retrieve the message they sent
first_respondent_thread = Retriever.retrieve_thread(
first_respondent_thread_id, self.user_respondent)
self.assertIsNotNone(first_respondent_thread)
# second respondent can retrieve the message they sent
second_respondent_thread = Retriever.retrieve_thread(
second_respondent_thread_id, self.second_user_respondent)
self.assertIsNotNone(second_respondent_thread)
# first respondent shouldn't be able to retrieve second respondent's message
with self.assertRaises(Forbidden):
Retriever.retrieve_thread(first_respondent_thread_id,
self.second_user_respondent)
# second respondent shouldn't be able to retrieve first respondent's message
with self.assertRaises(Forbidden):
Retriever.retrieve_thread(second_respondent_thread_id,
self.user_respondent)
def get(thread_id):
"""Get messages by thread id"""
logger.info("Getting messages from thread",
thread_id=thread_id,
user_uuid=g.user.user_uuid)
conversation = Retriever.retrieve_thread(thread_id, g.user)
conversation_metadata = Retriever.retrieve_conversation_metadata(
thread_id)
logger.info("Successfully retrieved messages from thread",
thread_id=thread_id,
user_uuid=g.user.user_uuid)
messages = []
for message in conversation.all():
msg = message.serialize(g.user, body_summary=False)
messages.append(msg)
if conversation_metadata and conversation_metadata.is_closed:
return jsonify({
"messages":
add_users_and_business_details(messages),
"is_closed":
conversation_metadata.is_closed,
"closed_by":
conversation_metadata.closed_by,
"closed_by_uuid":
conversation_metadata.closed_by_uuid,
"closed_at":
conversation_metadata.closed_at.isoformat()
})
return jsonify({
"messages": add_users_and_business_details(messages),
"is_closed": False
})
