def test_add_event(self) -> None:
"""
Recipients of the message receive the reaction event
and event contains relevant data
"""
pm_sender = self.example_user('hamlet')
pm_recipient = self.example_user('othello')
reaction_sender = pm_recipient
result = self.api_post(pm_sender.email,
"/api/v1/messages", {"type": "private",
"content": "Test message",
"to": pm_recipient.email})
self.assert_json_success(result)
pm_id = result.json()['id']
expected_recipient_ids = set([pm_sender.id, pm_recipient.id])
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.api_put(reaction_sender.email, '/api/v1/messages/%s/emoji_reactions/smile' % (pm_id,))
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_user_ids = set(events[0]['users'])
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event['user']['email'], reaction_sender.email)
self.assertEqual(event['type'], 'reaction')
self.assertEqual(event['op'], 'add')
self.assertEqual(event['emoji_name'], 'smile')
self.assertEqual(event['message_id'], pm_id)
def test_send_notification_to_self_event(self) -> None:
"""
Sending stopped typing notification to yourself
is successful.
"""
user = self.example_user('hamlet')
email = user.email
expected_recipient_emails = set([email])
expected_recipient_ids = set([user.id])
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.api_post(email, '/api/v1/typing', {'to': email,
'op': 'stop'})
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_recipient_emails = set(user['email'] for user in event['recipients'])
event_user_ids = set(events[0]['users'])
event_recipient_user_ids = set(user['user_id'] for user in event['recipients'])
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event['sender']['email'], email)
self.assertEqual(event['type'], 'typing')
self.assertEqual(event['op'], 'stop')
def test_send_notification_to_another_user_event(self):
# type: () -> None
"""
Sending stopped typing notification to another user
is successful.
"""
sender = self.example_user('hamlet')
recipient = self.example_user('othello')
expected_recipients = set([sender, recipient])
expected_recipient_emails = set([user.email for user in expected_recipients])
expected_recipient_ids = set([user.id for user in expected_recipients])
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.client_post('/api/v1/typing', {'to': recipient.email,
'op': 'stop'},
**self.api_auth(sender.email))
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_recipient_emails = set(user['email'] for user in event['recipients'])
event_user_ids = set(events[0]['users'])
event_recipient_user_ids = set(user['user_id'] for user in event['recipients'])
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event['sender']['email'], sender.email)
self.assertEqual(event['type'], 'typing')
self.assertEqual(event['op'], 'stop')
def test_change_regular_member_to_guest(self) -> None:
iago = self.example_user("iago")
self.login(iago.email)
hamlet = self.example_user("hamlet")
self.assertFalse(hamlet.is_guest)
# Test failure of making user both admin and guest
req = dict(is_guest=ujson.dumps(True), is_admin=ujson.dumps(True))
result = self.client_patch('/json/users/{}'.format(hamlet.id), req)
self.assert_json_error(result, 'Guests cannot be organization administrators')
self.assertFalse(hamlet.is_guest)
self.assertFalse(hamlet.is_realm_admin)
hamlet = self.example_user("hamlet")
req = dict(is_guest=ujson.dumps(True))
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.client_patch('/json/users/{}'.format(hamlet.id), req)
self.assert_json_success(result)
hamlet = self.example_user("hamlet")
self.assertTrue(hamlet.is_guest)
person = events[0]['event']['person']
self.assertEqual(person['email'], hamlet.email)
self.assertTrue(person['is_guest'])
def test_multiple_recipients(self):
# type: () -> None
"""
Sending typing notification to a single recipient is successful
"""
sender = self.example_user('hamlet')
recipient = [self.example_user('othello'), self.example_user('cordelia')]
expected_recipients = set(recipient) | set([sender])
expected_recipient_emails = set([user.email for user in expected_recipients])
expected_recipient_ids = set([user.id for user in expected_recipients])
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.client_post('/api/v1/typing', {'to': ujson.dumps([user.email for user in recipient]),
'op': 'start'},
**self.api_auth(sender.email))
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_recipient_emails = set(user['email'] for user in event['recipients'])
event_user_ids = set(events[0]['users'])
event_recipient_user_ids = set(user['user_id'] for user in event['recipients'])
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event['sender']['email'], sender.email)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event['type'], 'typing')
self.assertEqual(event['op'], 'start')
def test_change_guest_to_admin(self) -> None:
iago = self.example_user("iago")
self.login(iago.email)
polonius = self.example_user("polonius")
self.assertTrue(polonius.is_guest)
self.assertFalse(polonius.is_realm_admin)
# Test failure of making a guest to admin without revoking guest status
req = dict(is_admin=ujson.dumps(True))
result = self.client_patch('/json/users/{}'.format(polonius.id), req)
self.assert_json_error(result, 'Guests cannot be organization administrators')
# Test changing a user from guest to admin and revoking guest status
polonius = self.example_user("polonius")
self.assertFalse(polonius.is_realm_admin)
req = dict(is_admin=ujson.dumps(True), is_guest=ujson.dumps(False))
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.client_patch('/json/users/{}'.format(polonius.id), req)
self.assert_json_success(result)
polonius = self.example_user("polonius")
self.assertFalse(polonius.is_guest)
self.assertTrue(polonius.is_realm_admin)
person = events[0]['event']['person']
self.assertEqual(person['email'], polonius.email)
self.assertTrue(person['is_admin'])
person = events[1]['event']['person']
self.assertEqual(person['email'], polonius.email)
self.assertFalse(person['is_guest'])
def test_bot_add_subscription(self) -> None:
"""
Calling POST /json/users/me/subscriptions should successfully add
streams, and a stream to the
list of subscriptions and confirm the right number of events
are generated.
When 'principals' has a bot, no notification message event or invitation email
is sent when add_subscriptions_backend is called in the above api call.
"""
self.login(self.example_email('hamlet'))
# Normal user i.e. not a bot.
request_data = {
'principals': '["' + self.example_email('iago') + '"]'
}
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.common_subscribe_to_streams(self.example_email('hamlet'), ['Rome'], request_data)
self.assert_json_success(result)
msg_event = [e for e in events if e['event']['type'] == 'message']
self.assert_length(msg_event, 1) # Notification message event is sent.
# Create a bot.
self.assert_num_bots_equal(0)
result = self.create_bot()
self.assert_num_bots_equal(1)
# A bot
bot_request_data = {
'principals': '["*****@*****.**"]'
}
events_bot = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events_bot):
result = self.common_subscribe_to_streams(self.example_email('hamlet'), ['Rome'], bot_request_data)
self.assert_json_success(result)
# No notification message event or invitation email is sent because of bot.
msg_event = [e for e in events_bot if e['event']['type'] == 'message']
self.assert_length(msg_event, 0)
self.assertEqual(len(events_bot), len(events) - 1)
# Test runner automatically redirects all sent email to a dummy 'outbox'.
self.assertEqual(len(mail.outbox), 0)
def test_update_realm_name_events(self) -> None:
realm = get_realm('zulip')
new_name = u'Puliz'
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
do_set_realm_property(realm, 'name', new_name)
event = events[0]['event']
self.assertEqual(event, dict(
type='realm',
op='update',
property='name',
value=new_name,
))
def test_update_realm_description_events(self) -> None:
realm = get_realm('zulip')
new_description = u'zulip dev group'
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
do_set_realm_property(realm, 'description', new_description)
event = events[0]['event']
self.assertEqual(event, dict(
type='realm',
op='update',
property='description',
value=new_description,
))
def test_update_realm_description_events(self) -> None:
realm = get_realm('zulip')
new_description = u'zulip dev group'
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
do_set_realm_property(realm, 'description', new_description)
event = events[0]['event']
self.assertEqual(event, dict(
type='realm',
op='update',
property='description',
value=new_description,
))
def test_update_realm_name_events(self) -> None:
realm = get_realm('zulip')
new_name = u'Puliz'
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
do_set_realm_property(realm, 'name', new_name)
event = events[0]['event']
self.assertEqual(event, dict(
type='realm',
op='update',
property='name',
value=new_name,
))
def test_multiple_recipients_by_user_ids(self) -> None:
"""
Sending typing notification to multiple recipients (using user IDs)
is successful
"""
sender = self.example_user('hamlet')
recipient_users = [
self.example_user('othello'),
self.example_user('cordelia')
]
expected_recipients = set(recipient_users) | set([sender])
expected_recipient_emails = set(
[user.email for user in expected_recipients])
expected_recipient_ids = set([user.id for user in expected_recipients])
huddle_hash = get_huddle_hash(list(expected_recipient_ids))
self.assertFalse(
Huddle.objects.filter(huddle_hash=huddle_hash).exists())
events = [] # type: List[Mapping[str, Any]]
params = dict(
to=ujson.dumps([user.id for user in recipient_users]),
op='start',
)
with queries_captured() as queries:
with tornado_redirected_to_list(events):
result = self.api_post(sender.email, '/api/v1/typing', params)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
self.assertEqual(len(queries), 15)
# TODO: Fix this somewhat evil side effect of sending
# typing indicators.
self.assertTrue(
Huddle.objects.filter(huddle_hash=huddle_hash).exists())
event = events[0]['event']
event_recipient_emails = set(user['email']
for user in event['recipients'])
event_user_ids = set(events[0]['users'])
event_recipient_user_ids = set(user['user_id']
for user in event['recipients'])
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event['sender']['email'], sender.email)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event['type'], 'typing')
self.assertEqual(event['op'], 'start')
def test_remove_event(self) -> None:
"""
Recipients of the message receive the reaction event
and event contains relevant data
"""
pm_sender = self.example_user("hamlet")
pm_recipient = self.example_user("othello")
reaction_sender = pm_recipient
result = self.api_post(
pm_sender,
"/api/v1/messages",
{
"type": "private",
"content": "Test message",
"to": pm_recipient.email
},
)
self.assert_json_success(result)
content = result.json()
pm_id = content["id"]
expected_recipient_ids = {pm_sender.id, pm_recipient.id}
reaction_info = {
"emoji_name": "smile",
}
add = self.api_post(reaction_sender,
f"/api/v1/messages/{pm_id}/reactions",
reaction_info)
self.assert_json_success(add)
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
result = self.api_delete(reaction_sender,
f"/api/v1/messages/{pm_id}/reactions",
reaction_info)
self.assert_json_success(result)
self.assert_length(events, 1)
event = events[0]["event"]
event_user_ids = set(events[0]["users"])
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event["user"]["email"], reaction_sender.email)
self.assertEqual(event["type"], "reaction")
self.assertEqual(event["op"], "remove")
self.assertEqual(event["emoji_name"], "smile")
self.assertEqual(event["message_id"], pm_id)
def test_remove_event(self) -> None:
"""
Recipients of the message receive the reaction event
and event contains relevant data
"""
pm_sender = self.example_user('hamlet')
pm_recipient = self.example_user('othello')
reaction_sender = pm_recipient
result = self.client_post("/api/v1/messages", {"type": "private",
"content": "Test message",
"to": pm_recipient.email},
**self.api_auth(pm_sender.email))
self.assert_json_success(result)
content = result.json()
pm_id = content['id']
expected_recipient_ids = set([pm_sender.id, pm_recipient.id])
reaction_info = {
'emoji_name': 'hamburger',
'emoji_code': '1f354',
'reaction_type': 'unicode_emoji',
}
add = self.client_post('/api/v1/messages/%s/reactions' % (pm_id,),
reaction_info,
**self.api_auth(reaction_sender.email))
self.assert_json_success(add)
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.client_delete('/api/v1/messages/%s/reactions' % (pm_id,),
reaction_info,
**self.api_auth(reaction_sender.email))
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_user_ids = set(events[0]['users'])
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event['user']['user_id'], reaction_sender.id)
self.assertEqual(event['user']['email'], reaction_sender.email)
self.assertEqual(event['user']['full_name'], reaction_sender.full_name)
self.assertEqual(event['type'], 'reaction')
self.assertEqual(event['op'], 'remove')
self.assertEqual(event['message_id'], pm_id)
self.assertEqual(event['emoji_name'], reaction_info['emoji_name'])
self.assertEqual(event['emoji_code'], reaction_info['emoji_code'])
self.assertEqual(event['reaction_type'], reaction_info['reaction_type'])
def test_start_to_multiple_recipients(self) -> None:
sender = self.example_user('hamlet')
recipient_users = [
self.example_user('othello'),
self.example_user('cordelia')
]
expected_recipients = set(recipient_users) | set([sender])
expected_recipient_emails = set(
[user.email for user in expected_recipients])
expected_recipient_ids = set([user.id for user in expected_recipients])
huddle_hash = get_huddle_hash(list(expected_recipient_ids))
self.assertFalse(
Huddle.objects.filter(huddle_hash=huddle_hash).exists())
events = [] # type: List[Mapping[str, Any]]
params = dict(
to=ujson.dumps([user.id for user in recipient_users]),
op='start',
)
with queries_captured() as queries:
with tornado_redirected_to_list(events):
result = self.api_post(sender, '/api/v1/typing', params)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
self.assertEqual(len(queries), 5)
# We should not be adding new Huddles just because
# a user started typing in the compose box. Let's
# wait till they send an actual message.
self.assertFalse(
Huddle.objects.filter(huddle_hash=huddle_hash).exists())
event = events[0]['event']
event_recipient_emails = set(user['email']
for user in event['recipients'])
event_user_ids = set(events[0]['users'])
event_recipient_user_ids = set(user['user_id']
for user in event['recipients'])
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event['sender']['email'], sender.email)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event['type'], 'typing')
self.assertEqual(event['op'], 'start')
def test_update_realm_name_events(self) -> None:
realm = get_realm("zulip")
new_name = "Puliz"
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
do_set_realm_property(realm, "name", new_name, acting_user=None)
event = events[0]["event"]
self.assertEqual(
event,
dict(
type="realm",
op="update",
property="name",
value=new_name,
),
)
def test_update_realm_description_events(self) -> None:
realm = get_realm("zulip")
new_description = "zulip dev group"
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
do_set_realm_property(realm, "description", new_description)
event = events[0]["event"]
self.assertEqual(
event,
dict(
type="realm",
op="update",
property="description",
value=new_description,
),
)
def test_mark_all_in_stream_read(self) -> None:
self.login("hamlet")
user_profile = self.example_user("hamlet")
stream = self.subscribe(user_profile, "test_stream")
self.subscribe(self.example_user("cordelia"), "test_stream")
message_id = self.send_stream_message(self.example_user("hamlet"), "test_stream", "hello")
unrelated_message_id = self.send_stream_message(
self.example_user("hamlet"), "Denmark", "hello"
)
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
result = self.client_post(
"/json/mark_stream_as_read",
{
"stream_id": stream.id,
},
)
self.assert_json_success(result)
self.assertTrue(len(events) == 1)
event = events[0]["event"]
expected = dict(
operation="add",
messages=[message_id],
flag="read",
type="update_message_flags",
all=False,
)
differences = [key for key in expected if expected[key] != event[key]]
self.assertTrue(len(differences) == 0)
hamlet = self.example_user("hamlet")
um = list(UserMessage.objects.filter(message=message_id))
for msg in um:
if msg.user_profile.email == hamlet.email:
self.assertTrue(msg.flags.read)
else:
self.assertFalse(msg.flags.read)
unrelated_messages = list(UserMessage.objects.filter(message=unrelated_message_id))
for msg in unrelated_messages:
if msg.user_profile.email == hamlet.email:
self.assertFalse(msg.flags.read)
def test_remove_event(self) -> None:
"""
Recipients of the message receive the reaction event
and event contains relevant data
"""
pm_sender = self.example_user('hamlet')
pm_recipient = self.example_user('othello')
reaction_sender = pm_recipient
pm_id = self.send_personal_message(pm_sender, pm_recipient)
expected_recipient_ids = {pm_sender.id, pm_recipient.id}
reaction_info = {
'emoji_name': 'hamburger',
'emoji_code': '1f354',
'reaction_type': 'unicode_emoji',
}
add = self.api_post(
reaction_sender,
f'/api/v1/messages/{pm_id}/reactions',
reaction_info,
)
self.assert_json_success(add)
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
result = self.api_delete(
reaction_sender,
f'/api/v1/messages/{pm_id}/reactions',
reaction_info,
)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_user_ids = set(events[0]['users'])
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event['user']['user_id'], reaction_sender.id)
self.assertEqual(event['user']['email'], reaction_sender.email)
self.assertEqual(event['user']['full_name'], reaction_sender.full_name)
self.assertEqual(event['type'], 'reaction')
self.assertEqual(event['op'], 'remove')
self.assertEqual(event['message_id'], pm_id)
self.assertEqual(event['emoji_name'], reaction_info['emoji_name'])
self.assertEqual(event['emoji_code'], reaction_info['emoji_code'])
self.assertEqual(event['reaction_type'],
reaction_info['reaction_type'])
def test_remove_event(self) -> None:
"""
Recipients of the message receive the reaction event
and event contains relevant data
"""
pm_sender = self.example_user("hamlet")
pm_recipient = self.example_user("othello")
reaction_sender = pm_recipient
pm_id = self.send_personal_message(pm_sender, pm_recipient)
expected_recipient_ids = {pm_sender.id, pm_recipient.id}
reaction_info = {
"emoji_name": "hamburger",
"emoji_code": "1f354",
"reaction_type": "unicode_emoji",
}
add = self.api_post(
reaction_sender,
f"/api/v1/messages/{pm_id}/reactions",
reaction_info,
)
self.assert_json_success(add)
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
result = self.api_delete(
reaction_sender,
f"/api/v1/messages/{pm_id}/reactions",
reaction_info,
)
self.assert_json_success(result)
self.assert_length(events, 1)
event = events[0]["event"]
event_user_ids = set(events[0]["users"])
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event["user"]["user_id"], reaction_sender.id)
self.assertEqual(event["user"]["email"], reaction_sender.email)
self.assertEqual(event["user"]["full_name"], reaction_sender.full_name)
self.assertEqual(event["type"], "reaction")
self.assertEqual(event["op"], "remove")
self.assertEqual(event["message_id"], pm_id)
self.assertEqual(event["emoji_name"], reaction_info["emoji_name"])
self.assertEqual(event["emoji_code"], reaction_info["emoji_code"])
self.assertEqual(event["reaction_type"],
reaction_info["reaction_type"])
def test_change_guest_to_regular_member(self) -> None:
iago = self.example_user("iago")
self.login(iago.email)
polonius = self.example_user("polonius")
self.assertTrue(polonius.is_guest)
req = dict(is_guest=ujson.dumps(False))
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.client_patch('/json/users/{}'.format(polonius.id), req)
self.assert_json_success(result)
polonius = self.example_user("polonius")
self.assertFalse(polonius.is_guest)
person = events[0]['event']['person']
self.assertEqual(person['email'], polonius.email)
self.assertFalse(person['is_guest'])
def test_remove_event(self) -> None:
"""
Recipients of the message receive the reaction event
and event contains relevant data
"""
pm_sender = self.example_user('hamlet')
pm_recipient = self.example_user('othello')
reaction_sender = pm_recipient
result = self.api_post(pm_sender, "/api/v1/messages", {
"type": "private",
"content": "Test message",
"to": pm_recipient.email
})
self.assert_json_success(result)
content = result.json()
pm_id = content['id']
expected_recipient_ids = {pm_sender.id, pm_recipient.id}
reaction_info = {
'emoji_name': 'smile',
}
add = self.api_post(reaction_sender,
f'/api/v1/messages/{pm_id}/reactions',
reaction_info)
self.assert_json_success(add)
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
result = self.api_delete(reaction_sender,
f'/api/v1/messages/{pm_id}/reactions',
reaction_info)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_user_ids = set(events[0]['users'])
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event['user']['email'], reaction_sender.email)
self.assertEqual(event['type'], 'reaction')
self.assertEqual(event['op'], 'remove')
self.assertEqual(event['emoji_name'], 'smile')
self.assertEqual(event['message_id'], pm_id)
def test_change_guest_to_regular_member(self) -> None:
iago = self.example_user("iago")
self.login(iago.email)
polonius = self.example_user("polonius")
self.assertTrue(polonius.is_guest)
req = dict(is_guest=ujson.dumps(False))
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.client_patch('/json/users/{}'.format(polonius.id), req)
self.assert_json_success(result)
polonius = self.example_user("polonius")
self.assertFalse(polonius.is_guest)
person = events[0]['event']['person']
self.assertEqual(person['email'], polonius.email)
self.assertFalse(person['is_guest'])
def test_update_realm_description(self) -> None:
self.login('iago')
new_description = 'zulip dev group'
data = dict(description=ujson.dumps(new_description))
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
result = self.client_patch('/json/realm', data)
self.assert_json_success(result)
realm = get_realm('zulip')
self.assertEqual(realm.description, new_description)
event = events[0]['event']
self.assertEqual(event, dict(
type='realm',
op='update',
property='description',
value=new_description,
))
def test_start_to_another_user(self) -> None:
"""
Sending typing notification to another user
is successful.
"""
sender = self.example_user('hamlet')
recipient = self.example_user('othello')
expected_recipients = {sender, recipient}
expected_recipient_emails = {
user.email
for user in expected_recipients
}
expected_recipient_ids = {user.id for user in expected_recipients}
params = dict(
to=ujson.dumps([recipient.id]),
op='start',
)
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
result = self.api_post(sender, '/api/v1/typing', params)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_recipient_emails = {
user['email']
for user in event['recipients']
}
event_user_ids = set(events[0]['users'])
event_recipient_user_ids = {
user['user_id']
for user in event['recipients']
}
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event['sender']['email'], sender.email)
self.assertEqual(event['type'], 'typing')
self.assertEqual(event['op'], 'start')
def test_mark_all_in_stream_topic_read(self):
# type: () -> None
self.login(self.example_email("hamlet"))
user_profile = self.example_user('hamlet')
self.subscribe(user_profile, "test_stream")
message_id = self.send_stream_message(self.example_email("hamlet"),
"test_stream", "hello",
"test_topic")
unrelated_message_id = self.send_stream_message(
self.example_email("hamlet"), "Denmark", "hello", "Denmark2")
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.client_post(
"/json/mark_topic_as_read", {
"stream_id": get_stream("test_stream",
user_profile.realm).id,
"topic_name": "test_topic",
})
self.assert_json_success(result)
self.assertTrue(len(events) == 1)
event = events[0]['event']
expected = dict(operation='add',
messages=[message_id],
flag='read',
type='update_message_flags',
all=False)
differences = [key for key in expected if expected[key] != event[key]]
self.assertTrue(len(differences) == 0)
um = list(UserMessage.objects.filter(message=message_id))
for msg in um:
if msg.user_profile.email == self.example_email("hamlet"):
self.assertTrue(msg.flags.read)
unrelated_messages = list(
UserMessage.objects.filter(message=unrelated_message_id))
for msg in unrelated_messages:
if msg.user_profile.email == self.example_email("hamlet"):
self.assertFalse(msg.flags.read)
def test_start_to_another_user(self) -> None:
"""
Sending typing notification to another user
is successful.
"""
sender = self.example_user("hamlet")
recipient = self.example_user("othello")
expected_recipients = {sender, recipient}
expected_recipient_emails = {
user.email
for user in expected_recipients
}
expected_recipient_ids = {user.id for user in expected_recipients}
params = dict(
to=orjson.dumps([recipient.id]).decode(),
op="start",
)
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
result = self.api_post(sender, "/api/v1/typing", params)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]["event"]
event_recipient_emails = {
user["email"]
for user in event["recipients"]
}
event_user_ids = set(events[0]["users"])
event_recipient_user_ids = {
user["user_id"]
for user in event["recipients"]
}
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event["sender"]["email"], sender.email)
self.assertEqual(event["type"], "typing")
self.assertEqual(event["op"], "start")
def test_update_realm_description(self) -> None:
email = self.example_email("iago")
self.login(email)
realm = get_realm('zulip')
new_description = u'zulip dev group'
data = dict(description=ujson.dumps(new_description))
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.client_patch('/json/realm', data)
self.assert_json_success(result)
realm = get_realm('zulip')
self.assertEqual(realm.description, new_description)
event = events[0]['event']
self.assertEqual(event, dict(
type='realm',
op='update',
property='description',
value=new_description,
))
def test_start_to_single_recipient(self) -> None:
sender = self.example_user("hamlet")
recipient_user = self.example_user("othello")
expected_recipients = {sender, recipient_user}
expected_recipient_emails = {
user.email
for user in expected_recipients
}
expected_recipient_ids = {user.id for user in expected_recipients}
params = dict(
to=orjson.dumps([recipient_user.id]).decode(),
op="start",
)
events: List[Mapping[str, Any]] = []
with queries_captured() as queries:
with tornado_redirected_to_list(events):
result = self.api_post(sender, "/api/v1/typing", params)
self.assert_json_success(result)
self.assert_length(events, 1)
self.assert_length(queries, 4)
event = events[0]["event"]
event_recipient_emails = {
user["email"]
for user in event["recipients"]
}
event_user_ids = set(events[0]["users"])
event_recipient_user_ids = {
user["user_id"]
for user in event["recipients"]
}
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event["sender"]["email"], sender.email)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event["type"], "typing")
self.assertEqual(event["op"], "start")
def test_add_bot_with_default_sending_stream_private_allowed(self) -> None:
self.login(self.example_email('hamlet'))
user_profile = self.example_user('hamlet')
stream = get_stream("Denmark", user_profile.realm)
self.subscribe(user_profile, stream.name)
do_change_stream_invite_only(stream, True)
self.assert_num_bots_equal(0)
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.create_bot(default_sending_stream='Denmark')
self.assert_num_bots_equal(1)
self.assertEqual(result['default_sending_stream'], 'Denmark')
email = '*****@*****.**'
realm = get_realm('zulip')
profile = get_user(email, realm)
assert(profile.default_sending_stream is not None)
self.assertEqual(profile.default_sending_stream.name, 'Denmark')
event = [e for e in events if e['event']['type'] == 'realm_bot'][0]
self.assertEqual(
dict(
type='realm_bot',
op='add',
bot=dict(email='*****@*****.**',
user_id=profile.id,
full_name='The Bot of Hamlet',
bot_type=profile.bot_type,
is_active=True,
api_key=result['api_key'],
avatar_url=result['avatar_url'],
default_sending_stream='Denmark',
default_events_register_stream=None,
default_all_public_streams=False,
services=[],
owner=self.example_email('hamlet'))
),
event['event']
)
self.assertEqual(event['users'], {user_profile.id, })
def test_start_to_single_recipient(self) -> None:
sender = self.example_user('hamlet')
recipient_user = self.example_user('othello')
expected_recipients = {sender, recipient_user}
expected_recipient_emails = {
user.email
for user in expected_recipients
}
expected_recipient_ids = {user.id for user in expected_recipients}
params = dict(
to=ujson.dumps([recipient_user.id]),
op='start',
)
events = [] # type: List[Mapping[str, Any]]
with queries_captured() as queries:
with tornado_redirected_to_list(events):
result = self.api_post(sender, '/api/v1/typing', params)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
self.assertEqual(len(queries), 4)
event = events[0]['event']
event_recipient_emails = {
user['email']
for user in event['recipients']
}
event_user_ids = set(events[0]['users'])
event_recipient_user_ids = {
user['user_id']
for user in event['recipients']
}
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event['sender']['email'], sender.email)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event['type'], 'typing')
self.assertEqual(event['op'], 'start')
def test_update_realm_description(self) -> None:
self.login("iago")
new_description = "zulip dev group"
data = dict(description=orjson.dumps(new_description).decode())
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
result = self.client_patch("/json/realm", data)
self.assert_json_success(result)
realm = get_realm("zulip")
self.assertEqual(realm.description, new_description)
event = events[0]["event"]
self.assertEqual(
event,
dict(
type="realm",
op="update",
property="description",
value=new_description,
),
)
def test_mark_all_in_stream_read(self):
# type: () -> None
self.login("*****@*****.**")
user_profile = get_user_profile_by_email("*****@*****.**")
self.subscribe_to_stream(user_profile.email, "test_stream", user_profile.realm)
message_id = self.send_message("*****@*****.**", "test_stream", Recipient.STREAM, "hello")
unrelated_message_id = self.send_message("*****@*****.**", "Denmark", Recipient.STREAM, "hello")
events = [] # type: List[Dict[str, Any]]
with tornado_redirected_to_list(events):
result = self.client_post("/json/messages/flags", {"messages": ujson.dumps([]),
"op": "add",
"flag": "read",
"stream_name": "test_stream"})
self.assert_json_success(result)
self.assertTrue(len(events) == 1)
event = events[0]['event']
expected = dict(operation='add',
messages=[message_id],
flag='read',
type='update_message_flags',
all=False)
differences = [key for key in expected if expected[key] != event[key]]
self.assertTrue(len(differences) == 0)
um = list(UserMessage.objects.filter(message=message_id))
for msg in um:
if msg.user_profile.email == "*****@*****.**":
self.assertTrue(msg.flags.read)
else:
self.assertFalse(msg.flags.read)
unrelated_messages = list(UserMessage.objects.filter(message=unrelated_message_id))
for msg in unrelated_messages:
if msg.user_profile.email == "*****@*****.**":
self.assertFalse(msg.flags.read)
def test_mark_all_in_stream_read(self):
# type: () -> None
self.login(self.example_email("hamlet"))
user_profile = self.example_user('hamlet')
stream = self.subscribe(user_profile, "test_stream")
self.subscribe(self.example_user("cordelia"), "test_stream")
message_id = self.send_stream_message(self.example_email("hamlet"), "test_stream", "hello")
unrelated_message_id = self.send_stream_message(self.example_email("hamlet"), "Denmark", "hello")
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.client_post("/json/mark_stream_as_read", {
"stream_id": stream.id
})
self.assert_json_success(result)
self.assertTrue(len(events) == 1)
event = events[0]['event']
expected = dict(operation='add',
messages=[message_id],
flag='read',
type='update_message_flags',
all=False)
differences = [key for key in expected if expected[key] != event[key]]
self.assertTrue(len(differences) == 0)
um = list(UserMessage.objects.filter(message=message_id))
for msg in um:
if msg.user_profile.email == self.example_email("hamlet"):
self.assertTrue(msg.flags.read)
else:
self.assertFalse(msg.flags.read)
unrelated_messages = list(UserMessage.objects.filter(message=unrelated_message_id))
for msg in unrelated_messages:
if msg.user_profile.email == self.example_email("hamlet"):
self.assertFalse(msg.flags.read)
def test_add_bot(self) -> None:
self.login(self.example_email('hamlet'))
self.assert_num_bots_equal(0)
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.create_bot()
self.assert_num_bots_equal(1)
email = '*****@*****.**'
realm = get_realm('zulip')
bot = get_user(email, realm)
event = [e for e in events if e['event']['type'] == 'realm_bot'][0]
self.assertEqual(
dict(
type='realm_bot',
op='add',
bot=dict(email='*****@*****.**',
user_id=bot.id,
bot_type=bot.bot_type,
full_name='The Bot of Hamlet',
is_active=True,
api_key=result['api_key'],
avatar_url=result['avatar_url'],
default_sending_stream=None,
default_events_register_stream=None,
default_all_public_streams=False,
services=[],
owner=self.example_email('hamlet'))
),
event['event']
)
users_result = self.client_get('/json/users')
members = ujson.loads(users_result.content)['members']
bots = [m for m in members if m['email'] == '*****@*****.**']
self.assertEqual(len(bots), 1)
bot = bots[0]
self.assertEqual(bot['bot_owner'], self.example_email('hamlet'))
self.assertEqual(bot['user_id'], get_user(email, realm).id)
def test_start_to_multiple_recipients(self) -> None:
sender = self.example_user("hamlet")
recipient_users = [self.example_user("othello"), self.example_user("cordelia")]
expected_recipients = set(recipient_users) | {sender}
expected_recipient_emails = {user.email for user in expected_recipients}
expected_recipient_ids = {user.id for user in expected_recipients}
huddle_hash = get_huddle_hash(list(expected_recipient_ids))
self.assertFalse(Huddle.objects.filter(huddle_hash=huddle_hash).exists())
events: List[Mapping[str, Any]] = []
params = dict(
to=orjson.dumps([user.id for user in recipient_users]).decode(),
op="start",
)
with queries_captured() as queries:
with tornado_redirected_to_list(events):
result = self.api_post(sender, "/api/v1/typing", params)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
self.assertEqual(len(queries), 5)
# We should not be adding new Huddles just because
# a user started typing in the compose box. Let's
# wait till they send an actual message.
self.assertFalse(Huddle.objects.filter(huddle_hash=huddle_hash).exists())
event = events[0]["event"]
event_recipient_emails = {user["email"] for user in event["recipients"]}
event_user_ids = set(events[0]["users"])
event_recipient_user_ids = {user["user_id"] for user in event["recipients"]}
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event["sender"]["email"], sender.email)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event["type"], "typing")
self.assertEqual(event["op"], "start")
def test_start_to_self(self) -> None:
"""
Sending typing notification to yourself (using user IDs)
is successful.
"""
user = self.example_user("hamlet")
email = user.email
expected_recipient_emails = {email}
expected_recipient_ids = {user.id}
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
result = self.api_post(
user,
"/api/v1/typing",
{
"to": orjson.dumps([user.id]).decode(),
"op": "start",
},
)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]["event"]
event_recipient_emails = {
user["email"]
for user in event["recipients"]
}
event_user_ids = set(events[0]["users"])
event_recipient_user_ids = {
user["user_id"]
for user in event["recipients"]
}
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event["sender"]["email"], email)
self.assertEqual(event["type"], "typing")
self.assertEqual(event["op"], "start")
def test_start_to_self(self) -> None:
"""
Sending typing notification to yourself (using user IDs)
is successful.
"""
user = self.example_user('hamlet')
email = user.email
expected_recipient_emails = {email}
expected_recipient_ids = {user.id}
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
result = self.api_post(
user,
'/api/v1/typing',
{
'to': ujson.dumps([user.id]),
'op': 'start',
},
)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_recipient_emails = {
user['email']
for user in event['recipients']
}
event_user_ids = set(events[0]['users'])
event_recipient_user_ids = {
user['user_id']
for user in event['recipients']
}
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event['sender']['email'], email)
self.assertEqual(event['type'], 'typing')
self.assertEqual(event['op'], 'start')
def test_single_recipient_by_user_id(self) -> None:
"""
Sending typing notification to a single recipient (using user IDs)
is successful
"""
sender = self.example_user('hamlet')
recipient_user = self.example_user('othello')
expected_recipients = set([sender, recipient_user])
expected_recipient_emails = set(
[user.email for user in expected_recipients])
expected_recipient_ids = set([user.id for user in expected_recipients])
params = dict(
to=ujson.dumps([recipient_user.id]),
op='start',
)
events = [] # type: List[Mapping[str, Any]]
with queries_captured() as queries:
with tornado_redirected_to_list(events):
result = self.api_post(sender.email, '/api/v1/typing', params)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
self.assertEqual(len(queries), 8)
event = events[0]['event']
event_recipient_emails = set(user['email']
for user in event['recipients'])
event_user_ids = set(events[0]['users'])
event_recipient_user_ids = set(user['user_id']
for user in event['recipients'])
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event['sender']['email'], sender.email)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event['type'], 'typing')
self.assertEqual(event['op'], 'start')
def test_add_bot(self) -> None:
self.login(self.example_email('hamlet'))
self.assert_num_bots_equal(0)
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.create_bot()
self.assert_num_bots_equal(1)
email = '*****@*****.**'
realm = get_realm('zulip')
bot = get_user(email, realm)
event = [e for e in events if e['event']['type'] == 'realm_bot'][0]
self.assertEqual(
dict(
type='realm_bot',
op='add',
bot=dict(email='*****@*****.**',
user_id=bot.id,
bot_type=bot.bot_type,
full_name='The Bot of Hamlet',
is_active=True,
api_key=result['api_key'],
avatar_url=result['avatar_url'],
default_sending_stream=None,
default_events_register_stream=None,
default_all_public_streams=False,
owner=self.example_email('hamlet'))
),
event['event']
)
users_result = self.client_get('/json/users')
members = ujson.loads(users_result.content)['members']
bots = [m for m in members if m['email'] == '*****@*****.**']
self.assertEqual(len(bots), 1)
bot = bots[0]
self.assertEqual(bot['bot_owner'], self.example_email('hamlet'))
self.assertEqual(bot['user_id'], get_user(email, realm).id)
def test_add_bot_with_default_sending_stream_private_allowed(self) -> None:
self.login(self.example_email('hamlet'))
user_profile = self.example_user('hamlet')
stream = get_stream("Denmark", user_profile.realm)
self.subscribe(user_profile, stream.name)
do_change_stream_invite_only(stream, True)
self.assert_num_bots_equal(0)
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.create_bot(default_sending_stream='Denmark')
self.assert_num_bots_equal(1)
self.assertEqual(result['default_sending_stream'], 'Denmark')
email = '*****@*****.**'
realm = get_realm('zulip')
profile = get_user(email, realm)
self.assertEqual(profile.default_sending_stream.name, 'Denmark')
event = [e for e in events if e['event']['type'] == 'realm_bot'][0]
self.assertEqual(
dict(
type='realm_bot',
op='add',
bot=dict(email='*****@*****.**',
user_id=profile.id,
full_name='The Bot of Hamlet',
bot_type=profile.bot_type,
is_active=True,
api_key=result['api_key'],
avatar_url=result['avatar_url'],
default_sending_stream='Denmark',
default_events_register_stream=None,
default_all_public_streams=False,
owner=self.example_email('hamlet'))
),
event['event']
)
self.assertEqual(event['users'], {user_profile.id, })
def test_remove_event(self) -> None:
"""
Recipients of the message receive the reaction event
and event contains relevant data
"""
pm_sender = self.example_user('hamlet')
pm_recipient = self.example_user('othello')
reaction_sender = pm_recipient
pm_id = self.send_personal_message(pm_sender.email, pm_recipient.email)
expected_recipient_ids = set([pm_sender.id, pm_recipient.id])
reaction_info = {
'emoji_name': 'hamburger',
'emoji_code': '1f354',
'reaction_type': 'unicode_emoji',
}
add = self.post_reaction(reaction_info, message_id=pm_id, sender=reaction_sender.short_name)
self.assert_json_success(add)
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.delete_reaction(reaction_info,
message_id=pm_id,
sender=reaction_sender.short_name)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_user_ids = set(events[0]['users'])
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event['user']['user_id'], reaction_sender.id)
self.assertEqual(event['user']['email'], reaction_sender.email)
self.assertEqual(event['user']['full_name'], reaction_sender.full_name)
self.assertEqual(event['type'], 'reaction')
self.assertEqual(event['op'], 'remove')
self.assertEqual(event['message_id'], pm_id)
self.assertEqual(event['emoji_name'], reaction_info['emoji_name'])
self.assertEqual(event['emoji_code'], reaction_info['emoji_code'])
self.assertEqual(event['reaction_type'], reaction_info['reaction_type'])
def test_stop_to_self(self) -> None:
"""
Sending stopped typing notification to yourself
is successful.
"""
user = self.example_user('hamlet')
email = user.email
expected_recipient_emails = {email}
expected_recipient_ids = {user.id}
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
params = dict(
to=orjson.dumps([user.id]).decode(),
op='stop',
)
result = self.api_post(user, '/api/v1/typing', params)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_recipient_emails = {
user['email']
for user in event['recipients']
}
event_user_ids = set(events[0]['users'])
event_recipient_user_ids = {
user['user_id']
for user in event['recipients']
}
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event['sender']['email'], email)
self.assertEqual(event['type'], 'typing')
self.assertEqual(event['op'], 'stop')
def test_stop_to_self(self) -> None:
"""
Sending stopped typing notification to yourself
is successful.
"""
user = self.example_user("hamlet")
email = user.email
expected_recipient_emails = {email}
expected_recipient_ids = {user.id}
events: List[Mapping[str, Any]] = []
with tornado_redirected_to_list(events):
params = dict(
to=orjson.dumps([user.id]).decode(),
op="stop",
)
result = self.api_post(user, "/api/v1/typing", params)
self.assert_json_success(result)
self.assert_length(events, 1)
event = events[0]["event"]
event_recipient_emails = {
user["email"]
for user in event["recipients"]
}
event_user_ids = set(events[0]["users"])
event_recipient_user_ids = {
user["user_id"]
for user in event["recipients"]
}
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event["sender"]["email"], email)
self.assertEqual(event["type"], "typing")
self.assertEqual(event["op"], "stop")
def test_add_event(self) -> None:
"""
Recipients of the message receive the reaction event
and event contains relevant data
"""
pm_sender = self.example_user('hamlet')
pm_recipient = self.example_user('othello')
reaction_sender = pm_recipient
pm_id = self.send_personal_message(pm_sender.email, pm_recipient.email)
expected_recipient_ids = set([pm_sender.id, pm_recipient.id])
reaction_info = {
'emoji_name': 'hamburger',
'emoji_code': '1f354',
'reaction_type': 'unicode_emoji',
}
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.post_reaction(reaction_info,
message_id=pm_id,
sender=reaction_sender.short_name)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_user_ids = set(events[0]['users'])
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event['user']['user_id'], reaction_sender.id)
self.assertEqual(event['user']['email'], reaction_sender.email)
self.assertEqual(event['user']['full_name'], reaction_sender.full_name)
self.assertEqual(event['type'], 'reaction')
self.assertEqual(event['op'], 'add')
self.assertEqual(event['message_id'], pm_id)
self.assertEqual(event['emoji_name'], reaction_info['emoji_name'])
self.assertEqual(event['emoji_code'], reaction_info['emoji_code'])
self.assertEqual(event['reaction_type'],
reaction_info['reaction_type'])
def test_add_event(self):
# type: () -> None
"""
Recipients of the message receive the reaction event
and event contains relevant data
"""
pm_sender = self.example_user('hamlet')
pm_recipient = self.example_user('othello')
reaction_sender = pm_recipient
result = self.client_post("/api/v1/messages", {
"type": "private",
"content": "Test message",
"to": pm_recipient.email
}, **self.api_auth(pm_sender.email))
self.assert_json_success(result)
pm_id = result.json()['id']
expected_recipient_ids = set([pm_sender.id, pm_recipient.id])
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.client_put(
'/api/v1/messages/%s/emoji_reactions/smile' % (pm_id, ),
**self.api_auth(reaction_sender.email))
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_user_ids = set(events[0]['users'])
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event['user']['email'], reaction_sender.email)
self.assertEqual(event['type'], 'reaction')
self.assertEqual(event['op'], 'add')
self.assertEqual(event['emoji_name'], 'smile')
self.assertEqual(event['message_id'], pm_id)
def test_single_recipient_by_user_id(self) -> None:
"""
Sending typing notification to a single recipient (using user IDs)
is successful
"""
sender = self.example_user('hamlet')
recipient_user = self.example_user('othello')
expected_recipients = set([sender, recipient_user])
expected_recipient_emails = set([user.email for user in expected_recipients])
expected_recipient_ids = set([user.id for user in expected_recipients])
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.api_post(
sender.email,
'/api/v1/typing',
{
'to': ujson.dumps([recipient_user.id]),
'op': 'start'
}
)
self.assert_json_success(result)
self.assertEqual(len(events), 1)
event = events[0]['event']
event_recipient_emails = set(user['email'] for user in event['recipients'])
event_user_ids = set(events[0]['users'])
event_recipient_user_ids = set(user['user_id'] for user in event['recipients'])
self.assertEqual(expected_recipient_ids, event_recipient_user_ids)
self.assertEqual(expected_recipient_ids, event_user_ids)
self.assertEqual(event['sender']['email'], sender.email)
self.assertEqual(event_recipient_emails, expected_recipient_emails)
self.assertEqual(event['type'], 'typing')
self.assertEqual(event['op'], 'start')
def test_admin_api(self) -> None:
self.login(self.example_email("hamlet"))
admin = self.example_user('hamlet')
user = self.example_user('othello')
realm = admin.realm
do_change_is_admin(admin, True)
# Make sure we see is_admin flag in /json/users
result = self.client_get('/json/users')
self.assert_json_success(result)
members = result.json()['members']
hamlet = find_dict(members, 'email', self.example_email("hamlet"))
self.assertTrue(hamlet['is_admin'])
othello = find_dict(members, 'email', self.example_email("othello"))
self.assertFalse(othello['is_admin'])
# Giveth
req = dict(is_admin=ujson.dumps(True))
events = [] # type: List[Mapping[str, Any]]
with tornado_redirected_to_list(events):
result = self.client_patch('/json/users/{}'.format(self.example_user("othello").id), req)
self.assert_json_success(result)
admin_users = realm.get_admin_users()
self.assertTrue(user in admin_users)
person = events[0]['event']['person']
self.assertEqual(person['email'], self.example_email("othello"))
self.assertEqual(person['is_admin'], True)
# Taketh away
req = dict(is_admin=ujson.dumps(False))
events = []
with tornado_redirected_to_list(events):
result = self.client_patch('/json/users/{}'.format(self.example_user("othello").id), req)
self.assert_json_success(result)
admin_users = realm.get_admin_users()
self.assertFalse(user in admin_users)
person = events[0]['event']['person']
self.assertEqual(person['email'], self.example_email("othello"))
self.assertEqual(person['is_admin'], False)
# Cannot take away from last admin
self.login(self.example_email("iago"))
req = dict(is_admin=ujson.dumps(False))
events = []
with tornado_redirected_to_list(events):
result = self.client_patch('/json/users/{}'.format(self.example_user("hamlet").id), req)
self.assert_json_success(result)
admin_users = realm.get_admin_users()
self.assertFalse(admin in admin_users)
person = events[0]['event']['person']
self.assertEqual(person['email'], self.example_email("hamlet"))
self.assertEqual(person['is_admin'], False)
with tornado_redirected_to_list([]):
result = self.client_patch('/json/users/{}'.format(self.example_user("iago").id), req)
self.assert_json_error(result, 'Cannot remove the only organization administrator')
# Make sure only admins can patch other user's info.
self.login(self.example_email("othello"))
result = self.client_patch('/json/users/{}'.format(self.example_user("hamlet").id), req)
self.assert_json_error(result, 'Insufficient permission')
