def test_build_bot_request(self) -> None:
othello = self.example_user('othello')
stream = get_stream('Denmark', othello.realm)
message_id = self.send_stream_message(
othello,
stream.name,
content="@**test**",
)
message = Message.objects.get(id=message_id)
gravatar_url = get_gravatar_url(
othello.delivery_email,
othello.avatar_version,
)
expected_message_data = {
'avatar_url': gravatar_url,
'client': 'test suite',
'content': '@**test**',
'content_type': 'text/x-markdown',
'display_recipient': 'Denmark',
'id': message.id,
'is_me_message': False,
'reactions': [],
'recipient_id': message.recipient_id,
'rendered_content': '<p>@<strong>test</strong></p>',
'sender_email': othello.email,
'sender_full_name': 'Othello, the Moor of Venice',
'sender_id': othello.id,
'sender_realm_str': 'zulip',
'stream_id': stream.id,
TOPIC_NAME: 'test',
'submessages': [],
'timestamp': datetime_to_timestamp(message.date_sent),
'topic_links': [],
'type': 'stream',
}
wide_message_dict = MessageDict.wide_dict(message)
event = {
'command': '@**test**',
'message': wide_message_dict,
'trigger': 'mention',
}
request_data = self.handler.build_bot_request(event)
request_data = json.loads(request_data)
validate_against_openapi_schema(request_data,
'/zulip-outgoing-webhook', 'post',
'200')
self.assertEqual(request_data['data'], "@**test**")
self.assertEqual(request_data['token'], "abcdef")
self.assertEqual(request_data['message'], expected_message_data)
# Make sure we didn't accidentally mutate wide_message_dict.
self.assertEqual(wide_message_dict['sender_realm_id'],
othello.realm_id)
def test_build_bot_request(self) -> None:
othello = self.example_user("othello")
stream = get_stream("Denmark", othello.realm)
message_id = self.send_stream_message(
othello,
stream.name,
content="@**test**",
)
message = Message.objects.get(id=message_id)
gravatar_url = get_gravatar_url(
othello.delivery_email,
othello.avatar_version,
)
expected_message_data = {
"avatar_url": gravatar_url,
"client": "test suite",
"content": "@**test**",
"content_type": "text/x-markdown",
"display_recipient": "Denmark",
"id": message.id,
"is_me_message": False,
"reactions": [],
"recipient_id": message.recipient_id,
"rendered_content": "<p>@<strong>test</strong></p>",
"sender_email": othello.email,
"sender_full_name": "Othello, the Moor of Venice",
"sender_id": othello.id,
"sender_realm_str": "zulip",
"stream_id": stream.id,
TOPIC_NAME: "test",
"submessages": [],
"timestamp": datetime_to_timestamp(message.date_sent),
"topic_links": [],
"type": "stream",
}
wide_message_dict = MessageDict.wide_dict(message)
event = {
"command": "@**test**",
"message": wide_message_dict,
"trigger": "mention",
}
request_data = self.handler.build_bot_request(event)
request_data = json.loads(request_data)
validate_against_openapi_schema(request_data,
"/zulip-outgoing-webhook", "post",
"200")
self.assertEqual(request_data["data"], "@**test**")
self.assertEqual(request_data["token"], "abcdef")
self.assertEqual(request_data["message"], expected_message_data)
# Make sure we didn't accidentally mutate wide_message_dict.
self.assertEqual(wide_message_dict["sender_realm_id"],
othello.realm_id)
def get_send_message_payload(msg_id: int, apply_markdown: bool,
client_gravatar: bool) -> Dict[str, Any]:
msg = reload_message(msg_id)
wide_dict = MessageDict.wide_dict(msg)
narrow_dict = MessageDict.finalize_payload(
wide_dict,
apply_markdown=apply_markdown,
client_gravatar=client_gravatar,
)
return narrow_dict
def setUp(self) -> None:
super().setUp()
# TODO: Ideally, this test would use the full flow, rather
# than making a mock message like this.
message_id = self.send_stream_message(self.example_email('othello'),
"Denmark", content="@**test**")
message = Message.objects.get(id=message_id)
wide_message_dict = MessageDict.wide_dict(message)
self.event = {
u'command': '@**test**',
u'message': wide_message_dict,
u'trigger': 'mention',
}
self.bot_user = get_user("*****@*****.**", get_realm("zulip"))
service_class = get_service_interface_class('whatever') # GenericOutgoingWebhookService
self.handler = service_class(service_name='test-service',
token='abcdef',
user_profile=self.bot_user)
def test_get_raw_db_rows(self) -> None:
cordelia = self.example_user("cordelia")
hamlet = self.example_user("hamlet")
stream_name = "Verona"
message_id = self.send_stream_message(
sender=cordelia,
stream_name=stream_name,
)
def get_raw_rows() -> List[Dict[str, Any]]:
query = SubMessage.get_raw_db_rows([message_id])
rows = list(query)
return rows
rows = get_raw_rows()
self.assertEqual(rows, [])
sm1 = SubMessage.objects.create(
msg_type="whatever",
content="stuff1",
message_id=message_id,
sender=cordelia,
)
sm2 = SubMessage.objects.create(
msg_type="whatever",
content="stuff2",
message_id=message_id,
sender=hamlet,
)
expected_data = [
dict(
id=sm1.id,
message_id=message_id,
sender_id=cordelia.id,
msg_type="whatever",
content="stuff1",
),
dict(
id=sm2.id,
message_id=message_id,
sender_id=hamlet.id,
msg_type="whatever",
content="stuff2",
),
]
self.assertEqual(get_raw_rows(), expected_data)
message = Message.objects.get(id=message_id)
message_json = MessageDict.wide_dict(message)
rows = message_json["submessages"]
rows.sort(key=lambda r: r["id"])
self.assertEqual(rows, expected_data)
msg_rows = MessageDict.get_raw_db_rows([message_id])
rows = msg_rows[0]["submessages"]
rows.sort(key=lambda r: r["id"])
self.assertEqual(rows, expected_data)
def test_raw_unread_personal_from_self(self) -> None:
hamlet = self.example_user("hamlet")
def send_unread_pm(other_user: UserProfile) -> Message:
# It is rare to send a message from Hamlet to Othello
# (or any other user) and have it be unread for
# Hamlet himself, but that is actually normal
# behavior for most API clients.
message_id = self.send_personal_message(
from_user=hamlet,
to_user=other_user,
sending_client_name="some_api_program",
)
# Check our test setup is correct--the message should
# not have looked like it was sent by a human.
message = Message.objects.get(id=message_id)
self.assertFalse(message.sent_by_human())
# And since it was not sent by a human, it should not
# be read, not even by the sender (Hamlet).
um = UserMessage.objects.get(
user_profile_id=hamlet.id,
message_id=message_id,
)
self.assertFalse(um.flags.read)
return message
othello = self.example_user("othello")
othello_msg = send_unread_pm(other_user=othello)
# And now check the unread data structure...
raw_unread_data = get_raw_unread_data(
user_profile=hamlet,
)
pm_dict = raw_unread_data["pm_dict"]
self.assertEqual(set(pm_dict.keys()), {othello_msg.id})
# For legacy reason we call the field `sender_id` here,
# but it really refers to the other user id in the conversation,
# which is Othello.
self.assertEqual(
pm_dict[othello_msg.id],
dict(sender_id=othello.id),
)
cordelia = self.example_user("cordelia")
cordelia_msg = send_unread_pm(other_user=cordelia)
apply_unread_message_event(
user_profile=hamlet,
state=raw_unread_data,
message=MessageDict.wide_dict(cordelia_msg),
flags=[],
)
self.assertEqual(
set(pm_dict.keys()),
{othello_msg.id, cordelia_msg.id},
)
# Again, `sender_id` is misnamed here.
self.assertEqual(
pm_dict[cordelia_msg.id],
dict(sender_id=cordelia.id),
)
# Send a message to ourself.
hamlet_msg = send_unread_pm(other_user=hamlet)
apply_unread_message_event(
user_profile=hamlet,
state=raw_unread_data,
message=MessageDict.wide_dict(hamlet_msg),
flags=[],
)
self.assertEqual(
set(pm_dict.keys()),
{othello_msg.id, cordelia_msg.id, hamlet_msg.id},
)
# Again, `sender_id` is misnamed here.
self.assertEqual(
pm_dict[hamlet_msg.id],
dict(sender_id=hamlet.id),
)
# Call get_raw_unread_data again.
raw_unread_data = get_raw_unread_data(
user_profile=hamlet,
)
pm_dict = raw_unread_data["pm_dict"]
self.assertEqual(
set(pm_dict.keys()),
{othello_msg.id, cordelia_msg.id, hamlet_msg.id},
)
# Again, `sender_id` is misnamed here.
self.assertEqual(
pm_dict[hamlet_msg.id],
dict(sender_id=hamlet.id),
)
def test_get_raw_db_rows(self) -> None:
cordelia = self.example_user('cordelia')
hamlet = self.example_user('hamlet')
stream_name = 'Verona'
message_id = self.send_stream_message(
sender_email=cordelia.email,
stream_name=stream_name,
)
def get_raw_rows() -> List[Dict[str, Any]]:
query = SubMessage.get_raw_db_rows([message_id])
rows = list(query)
return rows
rows = get_raw_rows()
self.assertEqual(rows, [])
sm1 = SubMessage.objects.create(
msg_type='whatever',
content='stuff1',
message_id=message_id,
sender=cordelia,
)
sm2 = SubMessage.objects.create(
msg_type='whatever',
content='stuff2',
message_id=message_id,
sender=hamlet,
)
expected_data = [
dict(
id=sm1.id,
message_id=message_id,
sender_id=cordelia.id,
msg_type='whatever',
content='stuff1',
),
dict(
id=sm2.id,
message_id=message_id,
sender_id=hamlet.id,
msg_type='whatever',
content='stuff2',
),
]
self.assertEqual(get_raw_rows(), expected_data)
message = Message.objects.get(id=message_id)
message_json = MessageDict.wide_dict(message)
rows = message_json['submessages']
rows.sort(key=lambda r: r['id'])
self.assertEqual(rows, expected_data)
msg_rows = MessageDict.get_raw_db_rows([message_id])
rows = msg_rows[0]['submessages']
rows.sort(key=lambda r: r['id'])
self.assertEqual(rows, expected_data)
def test_get_raw_db_rows(self) -> None:
cordelia = self.example_user('cordelia')
hamlet = self.example_user('hamlet')
stream_name = 'Verona'
message_id = self.send_stream_message(
sender_email=cordelia.email,
stream_name=stream_name,
)
def get_raw_rows() -> List[Dict[str, Any]]:
query = SubMessage.get_raw_db_rows([message_id])
rows = list(query)
return rows
rows = get_raw_rows()
self.assertEqual(rows, [])
sm1 = SubMessage.objects.create(
msg_type='whatever',
content='stuff1',
message_id=message_id,
sender=cordelia,
)
sm2 = SubMessage.objects.create(
msg_type='whatever',
content='stuff2',
message_id=message_id,
sender=hamlet,
)
expected_data = [
dict(
id=sm1.id,
message_id=message_id,
sender_id=cordelia.id,
msg_type='whatever',
content='stuff1',
),
dict(
id=sm2.id,
message_id=message_id,
sender_id=hamlet.id,
msg_type='whatever',
content='stuff2',
),
]
self.assertEqual(get_raw_rows(), expected_data)
message = Message.objects.get(id=message_id)
message_json = MessageDict.wide_dict(message)
rows = message_json['submessages']
rows.sort(key=lambda r: r['id'])
self.assertEqual(rows, expected_data)
msg_rows = MessageDict.get_raw_db_rows([message_id])
rows = msg_rows[0]['submessages']
rows.sort(key=lambda r: r['id'])
self.assertEqual(rows, expected_data)
