def setUp(self) -> None:
self.zulip_realm = get_realm("zulip")
self.command = ZulipBaseCommand()
def setUp(self) -> None:
self.zulip_realm = get_realm("zulip")
self.command = ZulipBaseCommand()
class TestZulipBaseCommand(ZulipTestCase):
def setUp(self) -> None:
self.zulip_realm = get_realm("zulip")
self.command = ZulipBaseCommand()
def test_get_client(self) -> None:
self.assertEqual(self.command.get_client().name, "ZulipServer")
def test_get_realm(self) -> None:
self.assertEqual(self.command.get_realm(dict(realm_id='zulip')), self.zulip_realm)
self.assertEqual(self.command.get_realm(dict(realm_id=None)), None)
self.assertEqual(self.command.get_realm(dict(realm_id='1')), self.zulip_realm)
with self.assertRaisesRegex(CommandError, "There is no realm with id"):
self.command.get_realm(dict(realm_id='17'))
with self.assertRaisesRegex(CommandError, "There is no realm with id"):
self.command.get_realm(dict(realm_id='mit'))
def test_get_user(self) -> None:
mit_realm = get_realm("zephyr")
user_profile = self.example_user("hamlet")
email = user_profile.email
self.assertEqual(self.command.get_user(email, self.zulip_realm), user_profile)
self.assertEqual(self.command.get_user(email, None), user_profile)
error_message = "The realm '<Realm: zephyr 2>' does not contain a user with email"
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_user(email, mit_realm)
with self.assertRaisesRegex(CommandError, "server does not contain a user with email"):
self.command.get_user('*****@*****.**', None)
do_create_user(email, 'password', mit_realm, 'full_name', 'short_name')
with self.assertRaisesRegex(CommandError, "server contains multiple users with that email"):
self.command.get_user(email, None)
def test_get_user_profile_by_email(self) -> None:
user_profile = self.example_user("hamlet")
email = user_profile.email
self.assertEqual(get_user_profile_by_email(email), user_profile)
def get_users_sorted(self, options: Dict[str, Any], realm: Optional[Realm],
is_bot: Optional[bool]=None) -> List[UserProfile]:
user_profiles = self.command.get_users(options, realm, is_bot=is_bot)
return sorted(user_profiles, key = lambda x: x.email)
def test_get_users(self) -> None:
user_emails = self.example_email("hamlet") + "," + self.example_email("iago")
expected_user_profiles = [self.example_user("hamlet"), self.example_user("iago")]
user_profiles = self.get_users_sorted(dict(users=user_emails), self.zulip_realm)
self.assertEqual(user_profiles, expected_user_profiles)
user_profiles = self.get_users_sorted(dict(users=user_emails), None)
self.assertEqual(user_profiles, expected_user_profiles)
user_emails = self.example_email("iago") + "," + self.mit_email("sipbtest")
expected_user_profiles = [self.example_user("iago"), self.mit_user("sipbtest")]
user_profiles = self.get_users_sorted(dict(users=user_emails), None)
self.assertEqual(user_profiles, expected_user_profiles)
error_message = "The realm '<Realm: zulip 1>' does not contain a user with email"
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=user_emails), self.zulip_realm)
self.assertEqual(self.command.get_users(dict(users=self.example_email("iago")), self.zulip_realm),
[self.example_user("iago")])
self.assertEqual(self.command.get_users(dict(users=None), None), [])
def test_get_users_with_all_users_argument_enabled(self) -> None:
user_emails = self.example_email("hamlet") + "," + self.example_email("iago")
expected_user_profiles = [self.example_user("hamlet"), self.example_user("iago")]
user_profiles = self.get_users_sorted(dict(users=user_emails, all_users=False), self.zulip_realm)
self.assertEqual(user_profiles, expected_user_profiles)
error_message = "You can't use both -u/--users and -a/--all-users."
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=user_emails, all_users=True), None)
expected_user_profiles = sorted(UserProfile.objects.filter(realm=self.zulip_realm),
key = lambda x: x.email)
user_profiles = self.get_users_sorted(dict(users=None, all_users=True), self.zulip_realm)
self.assertEqual(user_profiles, expected_user_profiles)
error_message = "You have to pass either -u/--users or -a/--all-users."
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=None, all_users=False), None)
error_message = "The --all-users option requires a realm; please pass --realm."
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=None, all_users=True), None)
def test_get_non_bot_users(self) -> None:
expected_user_profiles = sorted(UserProfile.objects.filter(realm=self.zulip_realm,
is_bot=False),
key = lambda x: x.email)
user_profiles = self.get_users_sorted(dict(users=None, all_users=True),
self.zulip_realm,
is_bot=False)
self.assertEqual(user_profiles, expected_user_profiles)
class TestZulipBaseCommand(ZulipTestCase):
def setUp(self) -> None:
self.zulip_realm = get_realm("zulip")
self.command = ZulipBaseCommand()
def test_get_realm(self) -> None:
self.assertEqual(self.command.get_realm(dict(realm_id='zulip')), self.zulip_realm)
self.assertEqual(self.command.get_realm(dict(realm_id=None)), None)
self.assertEqual(self.command.get_realm(dict(realm_id='1')), self.zulip_realm)
with self.assertRaisesRegex(CommandError, "There is no realm with id"):
self.command.get_realm(dict(realm_id='17'))
with self.assertRaisesRegex(CommandError, "There is no realm with id"):
self.command.get_realm(dict(realm_id='mit'))
def test_get_user(self) -> None:
mit_realm = get_realm("zephyr")
user_profile = self.example_user("hamlet")
email = user_profile.email
self.assertEqual(self.command.get_user(email, self.zulip_realm), user_profile)
self.assertEqual(self.command.get_user(email, None), user_profile)
error_message = "The realm '<Realm: zephyr 2>' does not contain a user with email"
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_user(email, mit_realm)
with self.assertRaisesRegex(CommandError, "server does not contain a user with email"):
self.command.get_user('*****@*****.**', None)
do_create_user(email, 'password', mit_realm, 'full_name', 'short_name')
with self.assertRaisesRegex(CommandError, "server contains multiple users with that email"):
self.command.get_user(email, None)
def test_get_user_profile_by_email(self) -> None:
user_profile = self.example_user("hamlet")
email = user_profile.email
self.assertEqual(get_user_profile_by_email(email), user_profile)
def get_users_sorted(self, options: Dict[str, Any], realm: Optional[Realm]) -> List[UserProfile]:
user_profiles = self.command.get_users(options, realm)
return sorted(user_profiles, key = lambda x: x.email)
def test_get_users(self) -> None:
user_emails = self.example_email("hamlet") + "," + self.example_email("iago")
expected_user_profiles = [self.example_user("hamlet"), self.example_user("iago")]
user_profiles = self.get_users_sorted(dict(users=user_emails), self.zulip_realm)
self.assertEqual(user_profiles, expected_user_profiles)
user_profiles = self.get_users_sorted(dict(users=user_emails), None)
self.assertEqual(user_profiles, expected_user_profiles)
user_emails = self.example_email("iago") + "," + self.mit_email("sipbtest")
expected_user_profiles = [self.example_user("iago"), self.mit_user("sipbtest")]
user_profiles = self.get_users_sorted(dict(users=user_emails), None)
self.assertEqual(user_profiles, expected_user_profiles)
error_message = "The realm '<Realm: zulip 1>' does not contain a user with email"
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=user_emails), self.zulip_realm)
self.assertEqual(self.command.get_users(dict(users=self.example_email("iago")), self.zulip_realm),
[self.example_user("iago")])
self.assertEqual(self.command.get_users(dict(users=None), None), [])
def test_get_users_with_all_users_argument_enabled(self) -> None:
user_emails = self.example_email("hamlet") + "," + self.example_email("iago")
expected_user_profiles = [self.example_user("hamlet"), self.example_user("iago")]
user_profiles = self.get_users_sorted(dict(users=user_emails, all_users=False), self.zulip_realm)
self.assertEqual(user_profiles, expected_user_profiles)
error_message = "You can't use both -u/--users and -a/--all-users."
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=user_emails, all_users=True), None)
expected_user_profiles = sorted(UserProfile.objects.filter(realm=self.zulip_realm),
key = lambda x: x.email)
user_profiles = self.get_users_sorted(dict(users=None, all_users=True), self.zulip_realm)
self.assertEqual(user_profiles, expected_user_profiles)
error_message = "You have to pass either -u/--users or -a/--all-users."
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=None, all_users=False), None)
error_message = "The --all-users option requires a realm; please pass --realm."
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=None, all_users=True), None)
class TestZulipBaseCommand(ZulipTestCase):
def setUp(self) -> None:
super().setUp()
self.zulip_realm = get_realm("zulip")
self.command = ZulipBaseCommand()
def test_get_client(self) -> None:
self.assertEqual(self.command.get_client().name, "ZulipServer")
def test_get_realm(self) -> None:
self.assertEqual(self.command.get_realm(dict(realm_id="zulip")),
self.zulip_realm)
self.assertEqual(self.command.get_realm(dict(realm_id=None)), None)
self.assertEqual(
self.command.get_realm(dict(realm_id=str(self.zulip_realm.id))),
self.zulip_realm)
with self.assertRaisesRegex(CommandError, "There is no realm with id"):
self.command.get_realm(dict(realm_id="17"))
with self.assertRaisesRegex(CommandError, "There is no realm with id"):
self.command.get_realm(dict(realm_id="mit"))
def test_get_user(self) -> None:
mit_realm = get_realm("zephyr")
user_profile = self.example_user("hamlet")
email = user_profile.delivery_email
self.assertEqual(self.command.get_user(email, self.zulip_realm),
user_profile)
self.assertEqual(self.command.get_user(email, None), user_profile)
error_message = f"The realm '{mit_realm}' does not contain a user with email"
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_user(email, mit_realm)
with self.assertRaisesRegex(
CommandError, "server does not contain a user with email"):
self.command.get_user("*****@*****.**", None)
do_create_user(email,
"password",
mit_realm,
"full_name",
acting_user=None)
with self.assertRaisesRegex(
CommandError,
"server contains multiple users with that email"):
self.command.get_user(email, None)
def test_get_user_profile_by_email(self) -> None:
user_profile = self.example_user("hamlet")
email = user_profile.delivery_email
self.assertEqual(get_user_profile_by_email(email), user_profile)
def get_users_sorted(self, options: Dict[str, Any], realm: Optional[Realm],
**kwargs: Any) -> List[UserProfile]:
user_profiles = self.command.get_users(options, realm, **kwargs)
return sorted(user_profiles, key=lambda x: x.email)
def sorted_users(self, users: List[UserProfile]) -> List[UserProfile]:
return sorted(users, key=lambda x: x.email)
def test_get_users(self) -> None:
expected_user_profiles = self.sorted_users([
self.example_user("hamlet"),
self.example_user("iago"),
])
user_emails = ",".join(u.delivery_email
for u in expected_user_profiles)
user_profiles = self.get_users_sorted(dict(users=user_emails),
self.zulip_realm)
self.assertEqual(user_profiles, expected_user_profiles)
user_profiles = self.get_users_sorted(dict(users=user_emails), None)
self.assertEqual(user_profiles, expected_user_profiles)
expected_user_profiles = self.sorted_users([
self.mit_user("sipbtest"),
self.example_user("iago"),
])
user_emails = ",".join(u.delivery_email
for u in expected_user_profiles)
user_profiles = self.get_users_sorted(dict(users=user_emails), None)
self.assertEqual(user_profiles, expected_user_profiles)
error_message = f"The realm '{self.zulip_realm}' does not contain a user with email"
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=user_emails), self.zulip_realm)
self.assertEqual(
self.command.get_users(dict(users=self.example_email("iago")),
self.zulip_realm),
[self.example_user("iago")],
)
self.assertEqual(self.command.get_users(dict(users=None), None), [])
def test_get_users_with_all_users_argument_enabled(self) -> None:
expected_user_profiles = self.sorted_users([
self.example_user("hamlet"),
self.example_user("iago"),
])
user_emails = ",".join(u.delivery_email
for u in expected_user_profiles)
user_profiles = self.get_users_sorted(
dict(users=user_emails, all_users=False), self.zulip_realm)
self.assertEqual(user_profiles, expected_user_profiles)
error_message = "You can't use both -u/--users and -a/--all-users."
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=user_emails, all_users=True),
None)
# Test the default mode excluding bots and deactivated users
expected_user_profiles = sorted(
UserProfile.objects.filter(realm=self.zulip_realm,
is_active=True,
is_bot=False),
key=lambda x: x.email,
)
user_profiles = self.get_users_sorted(dict(users=None, all_users=True),
self.zulip_realm,
is_bot=False)
self.assertEqual(user_profiles, expected_user_profiles)
# Test the default mode excluding bots and deactivated users
expected_user_profiles = sorted(
UserProfile.objects.filter(realm=self.zulip_realm, is_active=True),
key=lambda x: x.email,
)
user_profiles = self.get_users_sorted(dict(users=None, all_users=True),
self.zulip_realm)
self.assertEqual(user_profiles, expected_user_profiles)
# Test include_deactivated
expected_user_profiles = sorted(UserProfile.objects.filter(
realm=self.zulip_realm, is_bot=False),
key=lambda x: x.email)
user_profiles = self.get_users_sorted(
dict(users=None, all_users=True),
self.zulip_realm,
is_bot=False,
include_deactivated=True,
)
self.assertEqual(user_profiles, expected_user_profiles)
error_message = "You have to pass either -u/--users or -a/--all-users."
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=None, all_users=False), None)
error_message = "The --all-users option requires a realm; please pass --realm."
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=None, all_users=True), None)
def test_get_non_bot_users(self) -> None:
expected_user_profiles = sorted(UserProfile.objects.filter(
realm=self.zulip_realm, is_bot=False),
key=lambda x: x.email)
user_profiles = self.get_users_sorted(dict(users=None, all_users=True),
self.zulip_realm,
is_bot=False)
self.assertEqual(user_profiles, expected_user_profiles)
def setUp(self):
# type: () -> None
self.zulip_realm = get_realm("zulip")
self.command = ZulipBaseCommand()
class TestZulipBaseCommand(ZulipTestCase):
def setUp(self):
# type: () -> None
self.zulip_realm = get_realm("zulip")
self.command = ZulipBaseCommand()
def test_get_realm(self):
# type: () -> None
self.assertEqual(self.command.get_realm(dict(realm_id='zulip')), self.zulip_realm)
self.assertEqual(self.command.get_realm(dict(realm_id=None)), None)
self.assertEqual(self.command.get_realm(dict(realm_id='1')), self.zulip_realm)
with self.assertRaisesRegex(CommandError, "There is no realm with id"):
self.command.get_realm(dict(realm_id='17'))
with self.assertRaisesRegex(CommandError, "There is no realm with id"):
self.command.get_realm(dict(realm_id='mit'))
def test_get_user(self):
# type: () -> None
mit_realm = get_realm("zephyr")
user_profile = self.example_user("hamlet")
email = user_profile.email
self.assertEqual(self.command.get_user(email, self.zulip_realm), user_profile)
self.assertEqual(self.command.get_user(email, None), user_profile)
error_message = "The realm '<Realm: zephyr 2>' does not contain a user with email"
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_user(email, mit_realm)
with self.assertRaisesRegex(CommandError, "server does not contain a user with email"):
self.command.get_user('*****@*****.**', None)
# TODO: Add a test for the MultipleObjectsReturned case once we make that possible.
def get_users_sorted(self, options, realm):
# type: (Dict[str, Any], Optional[Realm]) -> List[UserProfile]
user_profiles = self.command.get_users(options, realm)
return sorted(user_profiles, key = lambda x: x.email)
def test_get_users(self):
# type: () -> None
user_emails = self.example_email("hamlet") + "," + self.example_email("iago")
expected_user_profiles = [self.example_user("hamlet"), self.example_user("iago")]
user_profiles = self.get_users_sorted(dict(users=user_emails), self.zulip_realm)
self.assertEqual(user_profiles, expected_user_profiles)
user_profiles = self.get_users_sorted(dict(users=user_emails), None)
self.assertEqual(user_profiles, expected_user_profiles)
user_emails = self.example_email("iago") + "," + self.mit_email("sipbtest")
expected_user_profiles = [self.example_user("iago"), self.mit_user("sipbtest")]
user_profiles = self.get_users_sorted(dict(users=user_emails), None)
self.assertEqual(user_profiles, expected_user_profiles)
error_message = "The realm '<Realm: zulip 1>' does not contain a user with email"
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=user_emails), self.zulip_realm)
self.assertEqual(self.command.get_users(dict(users=self.example_email("iago")), self.zulip_realm),
[self.example_user("iago")])
self.assertEqual(self.command.get_users(dict(users=None), None), [])
def test_get_users_with_all_users_argument_enabled(self):
# type: () -> None
user_emails = self.example_email("hamlet") + "," + self.example_email("iago")
expected_user_profiles = [self.example_user("hamlet"), self.example_user("iago")]
user_profiles = self.get_users_sorted(dict(users=user_emails, all_users=False), self.zulip_realm)
self.assertEqual(user_profiles, expected_user_profiles)
error_message = "You can't use both -u/--users and -a/--all-users."
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=user_emails, all_users=True), None)
expected_user_profiles = sorted(UserProfile.objects.filter(realm=self.zulip_realm),
key = lambda x: x.email)
user_profiles = self.get_users_sorted(dict(users=None, all_users=True), self.zulip_realm)
self.assertEqual(user_profiles, expected_user_profiles)
error_message = "You have to pass either -u/--users or -a/--all-users."
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=None, all_users=False), None)
error_message = "The --all-users option requires a realm; please pass --realm."
with self.assertRaisesRegex(CommandError, error_message):
self.command.get_users(dict(users=None, all_users=True), None)
def setUp(self):
# type: () -> None
self.zulip_realm = get_realm("zulip")
self.command = ZulipBaseCommand()
