def test_team_bots_return_team_bots_list_without_token(self): data = MagicMock() '''Mocked outputs''' user = User(user_id=0) user.team_id = 0 bot1 = Bot(bot_id=1, name="Bot-Test1", callback=None, token="Test-Token") bot2 = Bot(bot_id=2, name="Bot-Test2", callback=None, token="Test-Token") bots = [bot1, bot2] sys.modules[ "models.authentication"].Authenticator.authenticate_team.return_value = user sys.modules[ "daos.bots"].BotDatabaseClient.get_team_bots.return_value = bots response = BotService.team_bots(data) self.assertEqual(UserResponseStatus.LIST.value, response.json().get("status")) self.assertEqual(1, response.json().get("bots")[0].get("id")) self.assertEqual(2, response.json().get("bots")[1].get("id")) self.assertEqual("Bot-Test1", response.json().get("bots")[0].get("name")) self.assertEqual("Bot-Test2", response.json().get("bots")[1].get("name")) self.assertIsNone(response.json().get("bots")[0].get("callback")) self.assertIsNone(response.json().get("bots")[1].get("callback")) self.assertFalse("token" in response.json().get("bots")[0]) self.assertFalse("token" in response.json().get("bots")[1]) self.assertIsInstance(response, SuccessfulBotListResponse)
def test_create_bot_with_correct_data_works_properly(self): data = MagicMock() '''Mocked outputs''' mod = User(user_id=0) mod.team_id = 0 def add_client(): from tests.test_services import test_bots client = RegularClient(client_id=0) MockedBotDatabase.batch_clients = client return client def add_bot(bot): from tests.test_services import test_bots MockedBotDatabase.batch_bots = bot def add_team_bot(team_bot): from tests.test_services import test_bots MockedBotDatabase.batch_team_bots = team_bot def commit(): from tests.test_services import test_bots MockedBotDatabase.stored_clients += [ MockedBotDatabase.batch_clients ] MockedBotDatabase.stored_bots += [MockedBotDatabase.batch_bots] MockedBotDatabase.stored_team_bots += [ MockedBotDatabase.batch_team_bots ] MockedBotDatabase.batch_clients = None MockedBotDatabase.batch_bots = None MockedBotDatabase.batch_team_bots = None sys.modules[ "models.authentication"].Authenticator.authenticate_team.return_value = mod sys.modules["daos.users"].UserDatabaseClient.add_client = MagicMock( side_effect=add_client) sys.modules["daos.bots"].BotDatabaseClient.add_bot = MagicMock( side_effect=add_bot) sys.modules["daos.teams"].TeamDatabaseClient.add_team_user = MagicMock( side_effect=add_team_bot) sys.modules["daos.database"].DatabaseClient.commit = MagicMock( side_effect=commit) response = BotService.create_bot(data) self.assertIsNone(MockedBotDatabase.batch_bots) self.assertIsNone(MockedBotDatabase.batch_clients) self.assertIsNone(MockedBotDatabase.batch_team_bots) self.assertEqual(1, len(MockedBotDatabase.stored_bots)) self.assertEqual(0, MockedBotDatabase.stored_bots[0].id) self.assertEqual(1, len(MockedBotDatabase.stored_clients)) self.assertEqual(0, MockedBotDatabase.stored_clients[0].id) self.assertEqual(1, len(MockedBotDatabase.stored_team_bots)) self.assertEqual(0, MockedBotDatabase.stored_team_bots[0].user_id) self.assertEqual(0, MockedBotDatabase.stored_team_bots[0].team_id) self.assertEqual(TeamRoles.BOT.value, MockedBotDatabase.stored_team_bots[0].role) self.assertEqual(UserResponseStatus.OK.value, response.status) self.assertIsInstance(response, SuccessfulUserMessageResponse)
def test_create_bot_with_name_in_use_returns_bad_request(self): data = MagicMock() '''Mocked outputs''' mod = User(user_id=0) mod.team_id = 0 def add_client(): from tests.test_services import test_bots client = RegularClient(client_id=0) MockedBotDatabase.batch_clients = client return client def add_bot(bot): from tests.test_services import test_bots MockedBotDatabase.batch_bots = bot def add_team_bot(team_bot): from tests.test_services import test_bots MockedBotDatabase.batch_team_bots = team_bot def commit(): raise IntegrityError(mock, mock, mock) def rollback(): from tests.test_services import test_bots MockedBotDatabase.batch_clients = None MockedBotDatabase.batch_bots = None MockedBotDatabase.batch_team_bots = None sys.modules[ "models.authentication"].Authenticator.authenticate_team.return_value = mod sys.modules["daos.users"].UserDatabaseClient.add_client = MagicMock( side_effect=add_client) sys.modules["daos.bots"].BotDatabaseClient.add_bot = MagicMock( side_effect=add_bot) sys.modules["daos.teams"].TeamDatabaseClient.add_team_user = MagicMock( side_effect=add_team_bot) sys.modules["daos.database"].DatabaseClient.commit = MagicMock( side_effect=commit) sys.modules["daos.database"].DatabaseClient.rollback = MagicMock( side_effect=rollback) sys.modules[ "daos.bots"].BotDatabaseClient.get_bot_by_name.return_value = MagicMock( ) response = BotService.create_bot(data) self.assertIsNone(MockedBotDatabase.batch_bots) self.assertIsNone(MockedBotDatabase.batch_clients) self.assertIsNone(MockedBotDatabase.batch_team_bots) self.assertEqual(0, len(MockedBotDatabase.stored_bots)) self.assertEqual(0, len(MockedBotDatabase.stored_clients)) self.assertEqual(0, len(MockedBotDatabase.stored_team_bots)) self.assertEqual(UserResponseStatus.ALREADY_REGISTERED.value, response.status) self.assertIsInstance(response, BadRequestUserMessageResponse)
def test_logout_user_works_properly(self): data = MagicMock() def update_user(_): from tests.test_services import test_users MockedUserDatabase.batch_login = False MockedUserDatabase.batch_token = None def commit(): from tests.test_services import test_users MockedUserDatabase.stored_login = MockedUserDatabase.batch_login MockedUserDatabase.stored_token = MockedUserDatabase.batch_token MockedUserDatabase.batch_login = True MockedUserDatabase.batch_token = "TEST" '''Mocked outputs''' user = User(user_id=0) sys.modules[ "models.authentication"].Authenticator.authenticate.return_value = user sys.modules["daos.users"].UserDatabaseClient.update_user = MagicMock( side_effect=update_user) sys.modules["daos.database"].DatabaseClient.commit = MagicMock( side_effect=commit) response = UserService.logout_user(data) self.assertTrue(MockedUserDatabase.batch_login) self.assertFalse(MockedUserDatabase.stored_login) self.assertIsNotNone(MockedUserDatabase.batch_token) self.assertIsNone(MockedUserDatabase.stored_token) self.assertIsInstance(response, SuccessfulUserMessageResponse)
def test_app_user_login_with_correct_password_works_properly(self): data = MagicMock() data.facebook_token = None def update_user(_): from tests.test_services import test_users MockedUserDatabase.batch_login = True def commit(): from tests.test_services import test_users MockedUserDatabase.stored_login = MockedUserDatabase.batch_login MockedUserDatabase.batch_login = False '''Mocked outputs''' user = User(user_id=0) sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_email.return_value = user sys.modules["daos.users"].UserDatabaseClient.update_user = MagicMock( side_effect=update_user) sys.modules["daos.database"].DatabaseClient.commit = MagicMock( side_effect=commit) sys.modules[ "passlib.apps"].custom_app_context.verify.return_value = True response = UserService.login_user(data) self.assertFalse(MockedUserDatabase.batch_login) self.assertTrue(MockedUserDatabase.stored_login) self.assertIsInstance(response, SuccessfulUserResponse)
def test_authenticating_to_non_existing_channel_channel_throws_exception( self): user_id = 0 team_id = 0 channel_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token authentication.team_id = team_id authentication.channel_id = channel_id '''Mocked outputs''' user = User(user_id=user_id, token=token) team_user = PublicUser(user_id=user_id) team_user.team_role = TeamRoles.MEMBER.value team_user.team_id = team_id sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_team_user_by_ids.return_value = team_user sys.modules[ "daos.users"].UserDatabaseClient.get_channel_user_by_ids.return_value = None sys.modules[ "daos.channels"].ChannelDatabaseClient.get_channel_by_id.return_value = None self.assertRaises(ChannelNotFoundError, Authenticator.authenticate_channel, authentication)
def test_set_user_offline_works_properly(self): data = MagicMock() def update_user(_): from tests.test_services import test_users MockedUserDatabase.batch_online = False def commit(): from tests.test_services import test_users MockedUserDatabase.stored_online = MockedUserDatabase.batch_online MockedUserDatabase.batch_online = True '''Mocked outputs''' user = User(user_id=0) sys.modules[ "models.authentication"].Authenticator.authenticate.return_value = user sys.modules["daos.users"].UserDatabaseClient.update_user = MagicMock( side_effect=update_user) sys.modules["daos.database"].DatabaseClient.commit = MagicMock( side_effect=commit) response = UserService.set_user_offline(data) self.assertTrue(MockedUserDatabase.batch_online) self.assertFalse(MockedUserDatabase.stored_online) self.assertIsInstance(response, SuccessfulUserResponse)
def test_team_regular_member_authenticating_to_not_belonging_channel_throws_exception( self): user_id = 0 team_id = 0 channel_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token authentication.team_id = team_id authentication.channel_id = channel_id '''Mocked outputs''' user = User(user_id=user_id, token=token) team_user = PublicUser(user_id=user_id) team_user.team_role = TeamRoles.MEMBER.value team_user.team_id = team_id channel = Channel(channel_id=channel_id, team_id=team_id, name="test", creator=None) sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_team_user_by_ids.return_value = team_user sys.modules[ "daos.users"].UserDatabaseClient.get_channel_user_by_ids.return_value = None sys.modules[ "daos.channels"].ChannelDatabaseClient.get_channel_by_id.return_value = channel self.assertRaises(NoPermissionsError, Authenticator.authenticate_channel, authentication)
def tearDown(self): MockedUserDatabase.batch_recoveries = 0 MockedUserDatabase.stored_recoveries = 1 MockedUserDatabase.recovery_token_sent = None MockedUserDatabase.batch_user = User(user_id=0) MockedUserDatabase.stored_user = User(user_id=0, username="******") MockedUserDatabase.batch_online = True MockedUserDatabase.stored_online = True MockedUserDatabase.batch_token = "" MockedUserDatabase.stored_token = "" MockedUserDatabase.batch_login = False MockedUserDatabase.stored_login = False MockedUserDatabase.batch_users = [] MockedUserDatabase.stored_users = [] MockedUserDatabase.batch_clients = [] MockedUserDatabase.stored_clients = []
def test_team_member_authenticates_just_to_channels_he_belongs(self): user_id = 0 team_id = 0 channel_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token authentication.team_id = team_id authentication.channel_id = channel_id '''Mocked outputs''' user = User(user_id=user_id, token=token) team_user = PublicUser(user_id=user_id) team_user.team_role = TeamRoles.MEMBER.value team_user.team_id = team_id channel_user = PublicUser(user_id=user_id) channel_user.team_id = team_id channel_user.channel_id = channel_id channel_user.is_channel_creator = False sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_team_user_by_ids.return_value = team_user sys.modules[ "daos.users"].UserDatabaseClient.get_channel_user_by_ids.return_value = channel_user authenticated_user = Authenticator.authenticate_channel(authentication) self.assertEqual(user_id, authenticated_user.id) self.assertEqual(team_id, authenticated_user.team_id) self.assertEqual(channel_id, authenticated_user.channel_id) self.assertFalse(authenticated_user.is_channel_creator)
def test_app_user_authenticating_to_team_with_role_verifying_authenticates( self): user_id = 0 team_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token authentication.team_id = team_id def verifying_function(_): return True '''Mocked outputs''' user = User(user_id=user_id, token=token) team_user = PublicUser(user_id=user_id) team_user.team_role = TeamRoles.CREATOR.value team_user.team_id = team_id sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_team_user_by_ids.return_value = team_user authenticated_user = Authenticator.authenticate_team( authentication, verifying_function) self.assertEqual(user_id, authenticated_user.id)
def test_user_teams_channels_for_user_with_two_channels_returns_full_list( self): data = MagicMock() '''Mocked outputs''' user = User(user_id=0) channels = [ Channel(channel_id=1, team_id=0, name="TEST1", creator=ChannelCreator(user_id=0, username="******", first_name="TESTER", last_name="TESTER")), Channel(channel_id=2, team_id=0, name="TEST2", creator=ChannelCreator(user_id=0, username="******", first_name="TESTER", last_name="TESTER")), ] sys.modules[ "models.authentication"].Authenticator.authenticate.return_value = user sys.modules[ "daos.channels"].ChannelDatabaseClient.get_user_channels_by_user_id.return_value = channels response = UserService.channels_for_user(data) self.assertIsInstance(response, SuccessfulChannelsListResponse) self.assertEqual(2, len(response.channels))
def test_update_user_with_new_unused_username_works_properly(self): data = MagicMock() data.updated_user = {"username": "******"} def update_user(user): from tests.test_services import test_users MockedUserDatabase.batch_user.username = user.username def commit(): from tests.test_services import test_users MockedUserDatabase.stored_user = MockedUserDatabase.batch_user MockedUserDatabase.batch_user = User(user_id=0) '''Mocked outputs''' user = User(user_id=0) sys.modules[ "models.authentication"].Authenticator.authenticate.return_value = user sys.modules["daos.users"].UserDatabaseClient.update_user = MagicMock( side_effect=update_user) sys.modules["daos.database"].DatabaseClient.commit = MagicMock( side_effect=commit) response = UserService.update_user(data) self.assertEqual(0, MockedUserDatabase.batch_user.id) self.assertEqual(0, MockedUserDatabase.stored_user.id) self.assertEqual("UPDATED-TEST", MockedUserDatabase.stored_user.username) self.assertIsInstance(response, SuccessfulUserResponse)
def test_facebook_user_login_with_already_in_use_token_returns_works_properly( self): data = MagicMock() data.facebook_token = 0 def update_user(_): from tests.test_services import test_users MockedUserDatabase.batch_login = True def commit(): from tests.test_services import test_users MockedUserDatabase.stored_login = MockedUserDatabase.batch_login MockedUserDatabase.batch_login = False '''Mocked outputs''' user = User(user_id=0) sys.modules[ "services.facebook"].FacebookService.get_user_from_facebook = MagicMock( ) sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_facebook_id.return_value = user sys.modules["daos.users"].UserDatabaseClient.update_user = MagicMock( side_effect=update_user) sys.modules["daos.database"].DatabaseClient.commit = MagicMock( side_effect=commit) response = UserService.login_user(data) self.assertFalse(MockedUserDatabase.batch_login) self.assertTrue(MockedUserDatabase.stored_login) self.assertIsInstance(response, SuccessfulUserResponse)
def test_user_with_same_token_in_database_authenticates(self): user_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = User( user_id=user_id, token=token) authenticated_user = Authenticator.authenticate(authentication) self.assertTrue(authenticated_user.id == user_id)
def test_user_with_different_token_in_database_throws_exception(self): user_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token '''Mocked outputs''' user = User(user_id=user_id, token="DIFFERENT-TOKEN") sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user self.assertRaises(WrongTokenError, Authenticator.authenticate, authentication)
class MockedUserDatabase: batch_recoveries = 0 stored_recoveries = 1 recovery_token_sent = None batch_user = User(user_id=0) stored_user = User(user_id=0, username="******") batch_online = True stored_online = True batch_token = "" stored_token = "" batch_login = False stored_login = False batch_users = [] stored_users = [] batch_clients = [] stored_clients = []
def test_regenerate_token_with_not_found_password_recovery_data_returns_bad_request( self): data = MagicMock() '''Mocked outputs''' user = User(user_id=0, username="******") sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_email.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_password_recovery_by_id.return_value = None response = UserService.regenerate_token(data) self.assertIsInstance(response, BadRequestUserMessageResponse)
def to_user(cls, user_entry): return User(user_id=user_entry.user_id, role=user_entry.role, online=user_entry.online, token=user_entry.auth_token, first_name=user_entry.first_name, last_name=user_entry.last_name, profile_pic=user_entry.profile_pic, password=user_entry.password, email=user_entry.email, username=user_entry.username, created=user_entry.created, facebook_id=user_entry.facebook_id ) if user_entry is not None else None
def test_app_user_authenticating_to_unknown_team_throws_exception(self): user_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = User( user_id=user_id, token=token) sys.modules[ "daos.users"].UserDatabaseClient.get_team_user_by_ids.return_value = None sys.modules[ "daos.teams"].TeamDatabaseClient.get_team_by_id.return_value = None self.assertRaises(TeamNotFoundError, Authenticator.authenticate_team, authentication)
def test_user_teams_for_user_with_two_team_returns_full_list(self): data = MagicMock() '''Mocked outputs''' user = User(user_id=0) teams = [Team(name="TEST1"), Team(name="TEST2")] sys.modules[ "models.authentication"].Authenticator.authenticate.return_value = user sys.modules[ "daos.teams"].TeamDatabaseClient.get_user_teams_by_user_id.return_value = teams response = UserService.teams_for_user(data) self.assertIsInstance(response, SuccessfulTeamsListResponse) self.assertEqual(2, len(response.teams))
def test_user_teams_channels_for_user_without_any_channel_returns_empty_list( self): data = MagicMock() '''Mocked outputs''' user = User(user_id=0) channels = [] sys.modules[ "models.authentication"].Authenticator.authenticate.return_value = user sys.modules[ "daos.channels"].ChannelDatabaseClient.get_user_channels_by_user_id.return_value = channels response = UserService.channels_for_user(data) self.assertIsInstance(response, SuccessfulChannelsListResponse) self.assertEqual(0, len(response.channels))
def test_app_user_doesnt_belonging_to_team_throws_exception(self): user_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = User( user_id=user_id, token=token) sys.modules[ "daos.users"].UserDatabaseClient.get_team_user_by_ids.return_value = None sys.modules[ "daos.teams"].TeamDatabaseClient.get_team_by_id.return_value = Team( name=None) self.assertRaises(NoPermissionsError, Authenticator.authenticate_team, authentication)
def test_app_user_authenticating_to_team_with_no_role_verifying_throws_exception( self): user_id = 0 team_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token authentication.team_id = team_id def verifying_function(_): return False sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = User( user_id=user_id, token=token) self.assertRaises(NoPermissionsError, Authenticator.authenticate_team, authentication, verifying_function)
def test_admin_user_authenticates_to_every_team(self): user_id = 0 team_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token authentication.team_id = team_id '''Mocked outputs''' user = User(user_id=user_id, token=token, role=UserRoles.ADMIN.value) sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user authenticated_user = Authenticator.authenticate_team(authentication) self.assertEqual(user_id, authenticated_user.id) self.assertEqual(team_id, authenticated_user.team_id) self.assertEqual(UserRoles.ADMIN.value, authenticated_user.role)
def test_regenerate_token_with_failing_database_returns_unsuccessful_response( self): data = MagicMock() def delete_recovery(_): from tests.test_services import test_users MockedUserDatabase.batch_recoveries += 1 def update_user(_): from tests.test_services import test_users MockedUserDatabase.batch_online = True def commit(): raise IntegrityError(mock, mock, mock) def rollback(): from tests.test_services import test_users MockedUserDatabase.batch_recoveries = 0 MockedUserDatabase.batch_online = False '''Mocked outputs''' user = User(user_id=0, username="******") password_recovery = PasswordRecovery(user_id=0, token="TEST") sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_email.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_password_recovery_by_id.return_value = password_recovery sys.modules[ "daos.users"].UserDatabaseClient.delete_password_recovery = MagicMock( side_effect=delete_recovery) sys.modules["daos.users"].UserDatabaseClient.update_user = MagicMock( side_effect=update_user) sys.modules["daos.database"].DatabaseClient.commit = MagicMock( side_effect=commit) sys.modules["daos.database"].DatabaseClient.rollback = MagicMock( side_effect=rollback) response = UserService.regenerate_token(data) self.assertFalse(MockedUserDatabase.batch_online) self.assertEqual(0, MockedUserDatabase.batch_recoveries) self.assertIsInstance(response, UnsuccessfulClientResponse)
def test_update_user_with_used_username_returns_bad_request(self): data = MagicMock() data.updated_user = {"username": "******"} def commit(): raise IntegrityError(mock, mock, mock) '''Mocked outputs''' user = User(user_id=0) sys.modules[ "models.authentication"].Authenticator.authenticate.return_value = user sys.modules["daos.database"].DatabaseClient.commit = MagicMock( side_effect=commit) sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_username.return_value = MagicMock( ) response = UserService.update_user(data) self.assertIsInstance(response, BadRequestUserMessageResponse)
def test_regenerate_token_with_correct_password_recovery_data_works_properly( self): data = MagicMock() def delete_recovery(_): from tests.test_services import test_users MockedUserDatabase.batch_recoveries += 1 def update_user(_): from tests.test_services import test_users MockedUserDatabase.batch_online = True def commit(): from tests.test_services import test_users MockedUserDatabase.stored_recoveries -= MockedUserDatabase.batch_recoveries MockedUserDatabase.stored_online = MockedUserDatabase.batch_online MockedUserDatabase.batch_recoveries = 0 MockedUserDatabase.batch_online = False '''Mocked outputs''' user = User(user_id=0, username="******") password_recovery = PasswordRecovery(user_id=0, token="TEST") sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_email.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_password_recovery_by_id.return_value = password_recovery sys.modules[ "daos.users"].UserDatabaseClient.delete_password_recovery = MagicMock( side_effect=delete_recovery) sys.modules["daos.users"].UserDatabaseClient.update_user = MagicMock( side_effect=update_user) sys.modules["daos.database"].DatabaseClient.commit = MagicMock( side_effect=commit) response = UserService.regenerate_token(data) self.assertFalse(MockedUserDatabase.batch_online) self.assertTrue(MockedUserDatabase.stored_online) self.assertEqual(0, MockedUserDatabase.batch_recoveries) self.assertEqual(0, MockedUserDatabase.batch_recoveries) self.assertIsInstance(response, SuccessfulUserResponse)
def test_recover_password_with_old_recover_request_done_returns_same_token( self): data = MagicMock() '''Mocked outputs''' user = User(user_id=0, username="******") password_recovery = PasswordRecovery(user_id=0, token="TEST") def send_email(email_data): from tests.test_services import test_users MockedUserDatabase.recovery_token_sent = email_data.token sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_email.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_password_recovery_by_id.return_value = password_recovery sys.modules["services.emails"].EmailService.send_email = MagicMock( side_effect=send_email) response = UserService.recover_password(data) self.assertEqual(MockedUserDatabase.recovery_token_sent, "TEST") self.assertIsInstance(response, SuccessfulUserMessageResponse)
def test_channel_regular_member_authenticating_to_channel_moderation_throws_exception( self): user_id = 0 team_id = 0 channel_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token authentication.team_id = team_id authentication.channel_id = channel_id '''Mocked outputs''' user = User(user_id=user_id, token=token) team_user = PublicUser(user_id=user_id) team_user.team_role = TeamRoles.MEMBER.value team_user.team_id = team_id channel_user = PublicUser(user_id=user_id) channel_user.team_id = team_id channel_user.channel_id = channel_id channel_user.is_channel_creator = False sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_team_user_by_ids.return_value = team_user sys.modules[ "daos.users"].UserDatabaseClient.get_channel_user_by_ids.return_value = channel_user self.assertRaises(NoPermissionsError, Authenticator.authenticate_channel, authentication, TeamRoles.is_channel_creator) channel_user.is_channel_creator = True sys.modules[ "daos.users"].UserDatabaseClient.get_channel_user_by_ids.return_value = channel_user authenticated_user = Authenticator.authenticate_channel( authentication, TeamRoles.is_channel_creator) self.assertEqual(user_id, authenticated_user.id) self.assertEqual(team_id, authenticated_user.team_id) self.assertEqual(channel_id, authenticated_user.channel_id) self.assertTrue(authenticated_user.is_channel_creator)