def test_invalid_sender(self) -> None:
user = self.example_user('hamlet')
recipients: List[str] = []
Request = namedtuple('Request', ['POST'])
request = Request(POST=dict()) # no sender
with self.assertRaises(InvalidMirrorInput):
create_mirrored_message_users(request, user, recipients)
def test_invalid_sender(self) -> None:
user = self.example_user("hamlet")
recipients: List[str] = []
Request = namedtuple("Request", ["POST"])
request = Request(POST={}) # no sender
with self.assertRaises(InvalidMirrorInput):
create_mirrored_message_users(request, user, recipients)
def test_invalid_client(self) -> None:
user = self.example_user("hamlet")
sender = user
recipients: List[str] = []
message_type = "private"
client = get_client("banned_mirror")
with self.assertRaises(InvalidMirrorInput):
create_mirrored_message_users(client, user, recipients,
sender.email, message_type)
def test_invalid_client(self) -> None:
user = self.example_user("hamlet")
sender = user
recipients: List[str] = []
post_data = dict(sender=sender.email, type="private")
request = HostRequestMock(post_data=post_data,
client_name="banned_mirror")
with self.assertRaises(InvalidMirrorInput):
create_mirrored_message_users(request, user, recipients)
def test_invalid_client(self) -> None:
client = get_client(name="banned_mirror") # Invalid!!!
user = self.example_user("hamlet")
sender = user
recipients: List[str] = []
Request = namedtuple("Request", ["POST", "client"])
request = Request(POST=dict(sender=sender.email, type="private"),
client=client)
with self.assertRaises(InvalidMirrorInput):
create_mirrored_message_users(request, user, recipients)
def test_invalid_client(self) -> None:
client = get_client(name='banned_mirror') # Invalid!!!
user = self.example_user('hamlet')
sender = user
recipients: List[str] = []
Request = namedtuple('Request', ['POST', 'client'])
request = Request(POST = dict(sender=sender.email, type='private'),
client = client)
with self.assertRaises(InvalidMirrorInput):
create_mirrored_message_users(request, user, recipients)
def test_jabber_mirror(self) -> None:
reset_emails_in_zulip_realm()
client = get_client(name='jabber_mirror')
sender = self.example_user('hamlet')
user = sender
recipients = [self.nonreg_email('alice'), self.nonreg_email('bob'), self.nonreg_email('cordelia')]
# Now make the request.
Request = namedtuple('Request', ['POST', 'client'])
request = Request(POST = dict(sender=sender.email, type='private'),
client = client)
mirror_sender = create_mirrored_message_users(request, user, recipients)
self.assertEqual(mirror_sender, sender)
realm_users = UserProfile.objects.filter(realm=sender.realm)
realm_emails = {user.email for user in realm_users}
self.assertIn(self.nonreg_email('alice'), realm_emails)
self.assertIn(self.nonreg_email('bob'), realm_emails)
bob = get_user(self.nonreg_email('bob'), sender.realm)
self.assertTrue(bob.is_mirror_dummy)
def test_invalid_email(self) -> None:
invalid_email = "alice AT example.com"
recipients = [invalid_email]
# We use an MIT user here to maximize code coverage
user = self.mit_user("starnine")
sender = user
post_data = dict(sender=sender.email, type="private")
for client_name in ["zephyr_mirror", "irc_mirror", "jabber_mirror"]:
request = HostRequestMock(post_data=post_data,
client_name=client_name)
with self.assertRaises(InvalidMirrorInput):
create_mirrored_message_users(request, user, recipients)
def test_jabber_mirror(self) -> None:
reset_emails_in_zulip_realm()
client = get_client(name="jabber_mirror")
sender = self.example_user("hamlet")
user = sender
recipients = [
self.nonreg_email("alice"),
self.nonreg_email("bob"),
self.nonreg_email("cordelia"),
]
# Now make the request.
Request = namedtuple("Request", ["POST", "client"])
request = Request(POST=dict(sender=sender.email, type="private"),
client=client)
mirror_sender = create_mirrored_message_users(request, user,
recipients)
self.assertEqual(mirror_sender, sender)
realm_users = UserProfile.objects.filter(realm=sender.realm)
realm_emails = {user.email for user in realm_users}
self.assertIn(self.nonreg_email("alice"), realm_emails)
self.assertIn(self.nonreg_email("bob"), realm_emails)
bob = get_user(self.nonreg_email("bob"), sender.realm)
self.assertTrue(bob.is_mirror_dummy)
def test_jabber_mirror(self) -> None:
reset_emails_in_zulip_realm()
sender = self.example_user("hamlet")
user = sender
recipients = [
self.nonreg_email("alice"),
self.nonreg_email("bob"),
self.nonreg_email("cordelia"),
]
# Now make the request.
post_data = dict(sender=sender.email, type="private")
request = HostRequestMock(post_data=post_data,
client_name="jabber_mirror")
mirror_sender = create_mirrored_message_users(request, user,
recipients)
self.assertEqual(mirror_sender, sender)
realm_users = UserProfile.objects.filter(realm=sender.realm)
realm_emails = {user.email for user in realm_users}
self.assertIn(self.nonreg_email("alice"), realm_emails)
self.assertIn(self.nonreg_email("bob"), realm_emails)
bob = get_user(self.nonreg_email("bob"), sender.realm)
self.assertTrue(bob.is_mirror_dummy)
def test_invalid_email(self) -> None:
invalid_email = "alice AT example.com"
recipients = [invalid_email]
# We use an MIT user here to maximize code coverage
user = self.mit_user("starnine")
sender = user
message_type = "private"
for client_name in ["zephyr_mirror", "irc_mirror", "jabber_mirror"]:
client = get_client(client_name)
with self.assertRaises(InvalidMirrorInput):
create_mirrored_message_users(client, user, recipients,
sender.email, message_type)
def test_zephyr_mirror_new_recipient(self, ignored: object) -> None:
"""Test mirror dummy user creation for PM recipients"""
user = self.mit_user("starnine")
sender = self.mit_user("sipbtest")
new_user_email = "*****@*****.**"
new_user_realm = get_realm("zephyr")
recipients = [user.email, new_user_email]
message_type = "private"
client = get_client("zephyr_mirror")
mirror_sender = create_mirrored_message_users(client, user, recipients,
sender.email,
message_type)
self.assertEqual(mirror_sender, sender)
realm_users = UserProfile.objects.filter(realm=sender.realm)
realm_emails = {user.email for user in realm_users}
self.assertIn(user.email, realm_emails)
self.assertIn(new_user_email, realm_emails)
bob = get_user(new_user_email, new_user_realm)
self.assertTrue(bob.is_mirror_dummy)
def test_jabber_mirror(self) -> None:
reset_emails_in_zulip_realm()
user = self.example_user("hamlet")
sender = user
recipients = [
self.nonreg_email("alice"),
self.nonreg_email("bob"),
self.nonreg_email("cordelia"),
]
message_type = "private"
client = get_client("jabber_mirror")
mirror_sender = create_mirrored_message_users(client, user, recipients,
sender.email,
message_type)
self.assertEqual(mirror_sender, sender)
realm_users = UserProfile.objects.filter(realm=sender.realm)
realm_emails = {user.email for user in realm_users}
self.assertIn(self.nonreg_email("alice"), realm_emails)
self.assertIn(self.nonreg_email("bob"), realm_emails)
bob = get_user(self.nonreg_email("bob"), sender.realm)
self.assertTrue(bob.is_mirror_dummy)
def test_zephyr_mirror_new_recipient(self, ignored: object) -> None:
"""Test mirror dummy user creation for PM recipients"""
client = get_client(name="zephyr_mirror")
user = self.mit_user("starnine")
sender = self.mit_user("sipbtest")
new_user_email = "*****@*****.**"
new_user_realm = get_realm("zephyr")
recipients = [user.email, new_user_email]
# Now make the request.
Request = namedtuple("Request", ["POST", "client"])
request = Request(POST=dict(sender=sender.email, type="private"),
client=client)
mirror_sender = create_mirrored_message_users(request, user,
recipients)
self.assertEqual(mirror_sender, sender)
realm_users = UserProfile.objects.filter(realm=sender.realm)
realm_emails = {user.email for user in realm_users}
self.assertIn(user.email, realm_emails)
self.assertIn(new_user_email, realm_emails)
bob = get_user(new_user_email, new_user_realm)
self.assertTrue(bob.is_mirror_dummy)
def test_invalid_email(self) -> None:
invalid_email = "alice AT example.com"
recipients = [invalid_email]
# We use an MIT user here to maximize code coverage
user = self.mit_user("starnine")
sender = user
Request = namedtuple("Request", ["POST", "client"])
for client_name in ["zephyr_mirror", "irc_mirror", "jabber_mirror"]:
client = get_client(name=client_name)
request = Request(POST=dict(sender=sender.email, type="private"),
client=client)
with self.assertRaises(InvalidMirrorInput):
create_mirrored_message_users(request, user, recipients)
def test_invalid_email(self) -> None:
invalid_email = 'alice AT example.com'
recipients = [invalid_email]
# We use an MIT user here to maximize code coverage
user = self.mit_user('starnine')
sender = user
Request = namedtuple('Request', ['POST', 'client'])
for client_name in ['zephyr_mirror', 'irc_mirror', 'jabber_mirror']:
client = get_client(name=client_name)
request = Request(POST = dict(sender=sender.email, type='private'),
client = client)
with self.assertRaises(InvalidMirrorInput):
create_mirrored_message_users(request, user, recipients)
def test_zephyr_mirror_new_sender(self, ignored: object) -> None:
"""Test mirror dummy user creation for sender when sending to stream"""
user = self.mit_user("starnine")
sender_email = "*****@*****.**"
recipients = ["stream_name"]
message_type = "stream"
client = get_client("zephyr_mirror")
mirror_sender = create_mirrored_message_users(client, user, recipients,
sender_email,
message_type)
assert mirror_sender is not None
self.assertEqual(mirror_sender.email, sender_email)
self.assertTrue(mirror_sender.is_mirror_dummy)
def test_zephyr_mirror_new_sender(self, ignored: object) -> None:
"""Test mirror dummy user creation for sender when sending to stream"""
user = self.mit_user("starnine")
sender_email = "*****@*****.**"
recipients = ["stream_name"]
# Now make the request.
post_data = dict(sender=sender_email, type="stream")
request = HostRequestMock(post_data=post_data,
client_name="zephyr_mirror")
mirror_sender = create_mirrored_message_users(request, user,
recipients)
assert mirror_sender is not None
self.assertEqual(mirror_sender.email, sender_email)
self.assertTrue(mirror_sender.is_mirror_dummy)
def test_zephyr_mirror_new_sender(self, ignored: object) -> None:
"""Test mirror dummy user creation for sender when sending to stream"""
client = get_client(name='zephyr_mirror')
user = self.mit_user('starnine')
sender_email = '*****@*****.**'
recipients = ['stream_name']
# Now make the request.
Request = namedtuple('Request', ['POST', 'client'])
request = Request(POST = dict(sender=sender_email, type='stream'),
client = client)
mirror_sender = create_mirrored_message_users(request, user, recipients)
assert(mirror_sender is not None)
self.assertEqual(mirror_sender.email, sender_email)
self.assertTrue(mirror_sender.is_mirror_dummy)
def test_zephyr_mirror_new_sender(self, ignored: object) -> None:
"""Test mirror dummy user creation for sender when sending to stream"""
client = get_client(name="zephyr_mirror")
user = self.mit_user("starnine")
sender_email = "*****@*****.**"
recipients = ["stream_name"]
# Now make the request.
Request = namedtuple("Request", ["POST", "client"])
request = Request(POST=dict(sender=sender_email, type="stream"),
client=client)
mirror_sender = create_mirrored_message_users(request, user,
recipients)
assert mirror_sender is not None
self.assertEqual(mirror_sender.email, sender_email)
self.assertTrue(mirror_sender.is_mirror_dummy)
