async def test_finds_successfully(self) -> None:
users = [UserMother.random()]
self._mock_user_repository.find_all.return_value = users
res = await self._sut()
self._mock_user_repository.find_all.assert_called_once()
assert len(res) == 1
assert res[0].id == users[0].id().value()
assert res[0].email == users[0].email().value()
def test_change_password() -> None:
old_plain_password = '******'
old_password = UserPasswordMother.create(old_plain_password, False)
user = UserMother.from_password(old_password)
new_password = UserPasswordMother.random()
user.change_password(old_plain_password, new_password)
assert user.password() == new_password
events = user.pull_aggregate_events()
assert len(events) == 1
assert isinstance(events[0], UserPasswordChanged)
def test_forget_password() -> None:
user = UserMother.from_password(
UserPasswordMother.create(value='secret123456', hashed=False))
assert user.refresh_token() is None
assert user.refresh_token_expiration_in() is None
user.forget_password()
assert user.refresh_token() is not None
assert user.refresh_token_expiration_in() is not None
events = user.pull_aggregate_events()
assert len(events) == 1
assert isinstance(events[0], UserPasswordForgotten)
async def test_find_successfully(self) -> None:
user = UserMother.random()
self._mock_user_repository.find.return_value = user
kwargs = {'user_id': user.id()}
res = await self._sut(**kwargs)
self._mock_user_repository.find.assert_called_once_with(kwargs['user_id'])
assert res.id == user.id().value()
assert res.email == user.email().value()
def test_to_document_and_to_aggregate() -> None:
user = UserMother.random()
sut = MongoDBAuthMapper()
doc = sut.to_document(user)
agg = sut.to_aggregate(doc)
assert agg.id().value() == user.id().value()
assert agg.email().value() == user.email().value()
assert agg.password().value() == user.password().value()
def test_reset_password() -> None:
user = UserMother.from_password_and_forgotten_password(
UserPasswordMother.create(value='secret123456', hashed=False),
UserRefreshTokenMother.random(),
UserRefreshTokenExpirationInMother.random(),
)
new_password = UserPasswordMother.random()
user.reset_password(new_password)
assert user.password() == new_password
events = user.pull_aggregate_events()
assert len(events) == 1
assert isinstance(events[0], UserPasswordResetted)
async def test_delete_successfully(self) -> None:
user = UserMother.random()
self._mock_user_repository.find.return_value = user
kwargs = {
'user_id': user.id(),
}
await self._sut(**kwargs)
self._mock_user_repository.find.assert_called_once_with(kwargs['user_id'])
self._mock_user_repository.delete_and_publish.assert_called_once_with(user)
async def test_find_successfully(self) -> None:
user = UserMother.random_with_forgotten_password()
self._mock_user_repository.find.return_value = user
kwargs = {'user_id': user.id()}
res = await self._sut(**kwargs)
self._mock_user_repository.find.assert_called_once_with(kwargs['user_id'])
assert res.id == user.id().value()
assert res.email == user.email().value()
assert res.refresh_token == user.refresh_token().value()
assert res.refresh_token_expiration_in == user.refresh_token_expiration_in().value()
async def test_register_fails_when_user_already_exists(self) -> None:
user = UserMother.random()
self._mock_user_repository.search.return_value = user
kwargs = {
'user_id': user.id(),
'email': user.email(),
'password': user.password(),
}
with pytest.raises(UserAlreadyExistError):
await self._sut(**kwargs)
self._mock_user_repository.search.assert_called_once_with(
kwargs['user_id'])
self._mock_user_repository.save_and_publish.assert_not_called()
async def test_change_password_successfully(self) -> None:
old_password = '******'
user = UserMother.from_password(UserPasswordMother.create(value=old_password, hashed=False))
self._mock_user_repository.find.return_value = user
self._mock_user_repository.save_and_publish.return_value = None
kwargs = {
'user_id': user.id(),
'old_password': old_password,
'new_password': UserPasswordMother.random(),
}
await self._sut(**kwargs)
self._mock_user_repository.find.assert_called_once_with(kwargs['user_id'])
self._mock_user_repository.save_and_publish.assert_called_once_with(user)
async def test_reset_password_successfully(self) -> None:
user = UserMother.from_password(
UserPasswordMother.create(value='secret123456', hashed=False),
)
self._mock_user_repository.find_email.return_value = user
self._mock_user_notifier.notify_user_password_forgotten.return_value = None
self._mock_user_repository.save_and_publish.return_value = None
kwargs = {
'user_email': user.email(),
}
await self._sut(**kwargs)
self._mock_user_repository.find_email.assert_called_once_with(kwargs['user_email'])
self._mock_user_notifier.notify_user_password_forgotten.assert_called_once()
self._mock_user_repository.save_and_publish.assert_called_once_with(user)
async def test_generate_token_successfully(self) -> None:
password = '******'
user = UserMother.from_password(
UserPasswordMother.create(value=password, hashed=False))
access_token = 'token'
self._mock_auth_repository.find.return_value = user
self._mock_token_factory.generate.return_value = access_token
kwargs = {
'email': user.email(),
'password': password,
}
res = await self._sut(**kwargs)
self._mock_auth_repository.find.assert_called_once_with(
kwargs['email'])
self._mock_token_factory.generate.assert_called_once_with(
user.id(), self._expiration_days)
assert res.user_id == user.id().value()
assert res.access_token == access_token
assert res.token_type == self._token_type
async def test_reset_password_successfully(self) -> None:
user = UserMother.from_password_and_forgotten_password(
UserPasswordMother.create(value='secret123456', hashed=False),
UserRefreshTokenMother.random(),
UserRefreshTokenExpirationInMother.random(),
)
self._mock_user_repository.find_email_and_refresh_token.return_value = user
self._mock_user_notifier.notify_user_password_resetted.return_value = None
self._mock_user_repository.save_and_publish.return_value = None
kwargs = {
'user_email': user.email(),
'user_refresh_token': user.refresh_token(),
'new_password': UserPasswordMother.random(),
}
await self._sut(**kwargs)
self._mock_user_repository.find_email_and_refresh_token.assert_called_once_with(
kwargs['user_email'], kwargs['user_refresh_token'])
self._mock_user_notifier.notify_user_password_resetted.assert_called_once(
)
self._mock_user_repository.save_and_publish.assert_called_once_with(
user)
def test_user_registered_notified() -> None:
user = UserMother.random()
user.user_registered_notified()
events = user.pull_aggregate_events()
assert len(events) == 1
assert isinstance(events[0], UserRegisteredNotified)
async def test_mongodb_user_repository(
mongodb_disposable_connection: MongoDBConnection) -> None:
sut = MongoDBUserRepository(
mongodb_disposable_connection,
MongoDBUserMapper(),
InternalEventPublisher(SimpleEventBus([])),
)
user = UserMother.random()
user_id = user.id()
assert await sut.search(user_id) is None
await sut.save_and_publish(user)
user = await sut.find(user_id)
assert user.id().value() == user_id.value()
await sut.save_and_publish(user)
users_ids = [user.id().value() for user in await sut.find_all()]
assert user_id.value() in users_ids
user = await sut.find_email(user.email())
assert user.id().value() == user_id.value()
user = await sut.find_id_and_email(user_id, user.email())
assert user.id().value() == user_id.value()
await sut.delete_and_publish(user)
with pytest.raises(UserNotFoundError):
await sut.find(user_id)
with pytest.raises(UserNotFoundError):
await sut.find_email(UserEmailMother.random())
with pytest.raises(UserNotFoundError):
await sut.find_id_and_email(user_id, UserEmailMother.random())
with pytest.raises(UserNotFoundError):
await sut.find_email_and_refresh_token(UserEmailMother.random(),
UserRefreshTokenMother.random())
user_mock = Mock()
user_mock.id.side_effect = [lambda: raise_(Exception()), user_id]
with pytest.raises(UserNotSavedError):
await sut.save_and_publish(user_mock)
user_mock = Mock()
user_mock.id.side_effect = [lambda: raise_(Exception()), user_id]
with pytest.raises(UserNotDeletedError):
await sut.delete_and_publish(user_mock)
user = UserMother.random_with_forgotten_password()
await sut.save_and_publish(user)
user_response = await sut.find_email_and_refresh_token(
user.email(), user.refresh_token())
assert user.id().value() == user_response.id().value()
assert user.refresh_token().value() == user_response.refresh_token().value(
)
assert user.refresh_token_expiration_in().value(
) == user_response.refresh_token_expiration_in().value()
await sut.delete_and_publish(user_response)
def test_deleted() -> None:
user = UserMother.random()
user.delete()
events = user.pull_aggregate_events()
assert len(events) == 1
assert isinstance(events[0], UserDeleted)
def test_validate_password() -> None:
plain_password = '******'
user = UserMother.from_password(
UserPasswordMother.create(plain_password, False))
user.validate_password(plain_password)
def test_validate_password_fails() -> None:
user = UserMother.random()
pytest.raises(UserPasswordNotMatchError,
lambda: user.validate_password('fakeSecret123456'))