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_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_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_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_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_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_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)
