def setUpTestData(cls):
cls.user_with_auth = MoodyUtil.create_user(username='******')
cls.user_without_auth = MoodyUtil.create_user(
username='******')
cls.spotify_auth = MoodyUtil.create_spotify_auth(cls.user_with_auth)
cls.factory = RequestFactory()
def setUpTestData(cls):
cls.user = MoodyUtil.create_user()
cls.other_user = MoodyUtil.create_user(username='******')
cls.url = reverse('spotify:spotify-auth-callback')
cls.success_url = reverse('spotify:export')
cls.failure_url = reverse('spotify:spotify-auth-failure')
cls.state = 'state-key'
def setUpTestData(cls):
cls.emotion = Emotion.objects.get(name=Emotion.HAPPY)
cls.test_playlist_name = 'test-playlist'
cls.user = MoodyUtil.create_user()
cls.user_with_no_auth = MoodyUtil.create_user(username='******')
cls.url = reverse('spotify:export')
cls.spotify_auth = MoodyUtil.create_spotify_auth(cls.user)
def setUpTestData(cls):
cls.user_with_profile = MoodyUtil.create_user()
cls.user_without_profile = MoodyUtil.create_user(
username='******')
cls.url = reverse('accounts:user-profile')
cls.user_profile = MoodyUtil.create_user_profile(
cls.user_with_profile, has_rejected_spotify_auth=False)
def test_happy_path(self, mock_update_top_artist_task):
user_1 = MoodyUtil.create_user(username='******')
user_2 = MoodyUtil.create_user(username='******')
MoodyUtil.create_spotify_auth(user_1, spotify_user_id='test_user_1')
MoodyUtil.create_spotify_auth(user_2, spotify_user_id='test_user_2')
RefreshTopArtistsFromSpotifyTask().run()
self.assertEqual(mock_update_top_artist_task.call_count, 2)
def test_happy_path(self):
user = MoodyUtil.create_user(email='*****@*****.**')
uid = urlsafe_base64_encode(force_bytes(user.pk))
token = PasswordResetTokenGenerator().make_token(user)
url = reverse('accounts:password-reset-confirm',
kwargs={
'uidb64': uid,
'token': token
})
initial_resp = self.client.get(url)
reset_url = initial_resp['Location']
expected_redirect = reverse('accounts:password-reset-complete')
data = {'new_password1': 'password', 'new_password2': 'password'}
resp = self.client.post(reset_url, data=data)
self.assertRedirects(resp,
expected_redirect,
fetch_redirect_response=False)
# Test password updated OK
user.refresh_from_db()
updated_user = authenticate(username=user.username,
password=data['new_password1'])
self.assertEqual(user.pk, updated_user.pk)
def test_post_save_user_creates_all_user_emotion_records(self):
user = MoodyUtil.create_user(username='******')
existing_emotions = Emotion.objects.all()
for emotion in existing_emotions:
self.assertTrue(user.useremotion_set.filter(emotion__name=emotion.name).exists())
def test_updating_user_with_existing_username_is_rejected(self):
user = MoodyUtil.create_user()
other_user = MoodyUtil.create_user(username='******')
self.client.login(username=user.username,
password=MoodyUtil.DEFAULT_USER_PASSWORD)
request_data = {'username': other_user.username}
resp = self.client.post(self.url, data=request_data)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertEqual(
MoodyUser.objects.filter(username=user.username).count(), 1)
self.assertEqual(
MoodyUser.objects.filter(username=other_user.username).count(), 1)
self.assertIn(
b'This username is already taken. Please choose a different one',
resp.content)
def test_clean_username_for_taken_username_is_invalid(self):
user = MoodyUtil.create_user()
data = {
'username': user.username,
'password': '******',
'confirm_password': '******'
}
form = BaseUserForm(data)
self.assertFalse(form.is_valid())
def setUpTestData(cls):
cls.user = MoodyUtil.create_user()
cls.auth = MoodyUtil.create_spotify_auth(cls.user)
cls.playlist_name = 'new_playlist'
cls.playlist_id = 'spotify:playlist:id'
cls.songs = []
for i in range(30):
cls.songs.append(MoodyUtil.create_song().code)
def test_happy_path(self, mock_generate_password):
user = MoodyUtil.create_user()
password = '******'
mock_generate_password.return_value = password
call_command('accounts_recover_user_account', user.username)
user.refresh_from_db()
updated_user = authenticate(username=user.username, password=password)
self.assertEqual(user.pk, updated_user.pk)
def test_authenticated_request_redirects_to_profile_page(self):
user = MoodyUtil.create_user()
self.client.login(username=user.username,
password=MoodyUtil.DEFAULT_USER_PASSWORD)
expected_redirect = reverse('accounts:profile')
resp = self.client.get(self.url)
self.assertRedirects(resp, expected_redirect)
messages = get_messages_from_response(resp)
self.assertIn('Your password has been updated!', messages)
def test_updating_user_with_empty_email_deletes_email_value_from_record(
self):
user = MoodyUtil.create_user(email='*****@*****.**')
self.client.login(username=user.username,
password=MoodyUtil.DEFAULT_USER_PASSWORD)
request_data = {'username': user.username, 'email': ''}
resp = self.client.post(self.url, data=request_data, follow=True)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
user.refresh_from_db()
self.assertEqual(user.email, '')
def test_get_request_populates_form_with_initial_user_data(self):
user = MoodyUtil.create_user(email='*****@*****.**')
self.client.login(username=user.username,
password=MoodyUtil.DEFAULT_USER_PASSWORD)
resp = self.client.get(self.url)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
# Ensure that the form's initial data is set to the current data for the user
self.assertEqual(resp.context['form'].initial['username'],
user.username)
self.assertEqual(resp.context['form'].initial['email'], user.email)
def test_send_email_to_user_raises_exception(self, mock_mail, mock_logger):
user = MoodyUtil.create_user()
user.email = '*****@*****.**'
user.save()
exc = SMTPException()
mock_mail.side_effect = exc
call_command('accounts_recover_user_account', user.username)
mock_logger.assert_called_with(
'Unable to send password reset email to user {}'.format(
user.username),
output_stream='stderr',
log_level=logging.ERROR,
extra={'exc': exc})
def test_creating_user_with_existing_username_is_rejected(self):
user = MoodyUtil.create_user()
request_data = {
'username': user.username,
'password': '******',
'confirm_password': '******'
}
resp = self.client.post(self.url, data=request_data)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertEqual(
MoodyUser.objects.filter(username=user.username).count(), 1)
self.assertIn(
b'This username is already taken. Please choose a different one',
resp.content)
def test_happy_path(self):
user = MoodyUtil.create_user()
self.client.login(username=user.username,
password=MoodyUtil.DEFAULT_USER_PASSWORD)
update_data = {
'username': '******',
'email': '*****@*****.**',
}
resp = self.client.post(self.url, data=update_data, follow=True)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
user.refresh_from_db()
self.assertEqual(user.username, update_data['username'])
self.assertEqual(user.email, update_data['email'])
def test_task_is_only_called_on_create(self, mock_on_commit):
user = MoodyUtil.create_user()
data = {
'user': user,
'spotify_user_id': 'spotify_user',
'access_token': 'access_token',
'refresh_token': 'refresh_token'
}
auth = SpotifyAuth.objects.create(**data)
# Because we wrap the task call in the `on_commit` method using a lambda,
# we lose the reference to the task call itself because it is being called
# through an anonymous function. Mocking the `on_commit` call to ensure it
# has the proper number of calls works just as well for our purposes
mock_on_commit.assert_called_once()
auth.save()
self.assertEqual(mock_on_commit.call_count, 1)
def test_send_email_to_user_happy_path(self, mock_mail,
mock_generate_password):
user = MoodyUtil.create_user()
user.email = '*****@*****.**'
user.save()
password = '******'
mock_generate_password.return_value = password
call_command('accounts_recover_user_account', user.username)
expected_body = RecoverCommand.email_body.format(
password=password,
site='{}{}'.format(settings.SITE_HOSTNAME,
reverse('accounts:login')))
mock_mail.assert_called_once_with(RecoverCommand.email_subject,
expected_body,
settings.SYSTEM_EMAIL_ADDRESS,
[user.email])
def test_non_matching_passwords_are_rejected(self):
user = MoodyUtil.create_user(email='*****@*****.**')
uid = urlsafe_base64_encode(force_bytes(user.pk))
token = PasswordResetTokenGenerator().make_token(user)
url = reverse('accounts:password-reset-confirm',
kwargs={
'uidb64': uid,
'token': token
})
initial_resp = self.client.get(url)
reset_url = initial_resp['Location']
data = {'new_password1': 'foo', 'new_password2': 'bar'}
resp = self.client.post(reset_url, data=data)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertIn(SetPasswordForm.error_messages['password_mismatch'],
resp.context['form'].errors['new_password2'])
def test_updating_user_with_invalid_username_is_rejected(self):
user = MoodyUtil.create_user()
self.client.login(username=user.username,
password=MoodyUtil.DEFAULT_USER_PASSWORD)
request_data = {
'username': '******',
}
old_username = user.username
resp = self.client.post(self.url, data=request_data)
user.refresh_from_db()
self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertEqual(
user.username,
old_username) # Ensure user username was not updated to bad value
self.assertIn(
b'Enter a valid username. This value may contain only letters, numbers, and @/./+/-/_ characters.',
resp.content)
def setUpTestData(cls):
cls.user = MoodyUtil.create_user()
cls.song = MoodyUtil.create_song()
cls.emotion = Emotion.objects.get(name=Emotion.HAPPY)
def setUp(self):
self.mixin = ValidateRequestDataMixin()
self.factory = APIRequestFactory()
self.user = MoodyUtil.create_user()
def setUpTestData(cls):
cls.url = reverse('tunes:playlist')
cls.user = MoodyUtil.create_user()
cls.song = MoodyUtil.create_song()
cls.emotion = Emotion.objects.get(name=Emotion.HAPPY)
def test_post_save_admin_does_not_create_user_emotion_records(self):
user = MoodyUtil.create_user(username='******', is_superuser=True)
self.assertFalse(user.useremotion_set.all())
def setUpTestData(cls):
cls.user_without_auth = MoodyUtil.create_user(username='******')
cls.user_with_auth = MoodyUtil.create_user(username='******')
cls.url = reverse('spotify:spotify-auth-revoke')
cls.redirect_url = reverse('accounts:profile')
def setUpTestData(cls):
cls.url = reverse('accounts:reset-password')
cls.user = MoodyUtil.create_user(email='*****@*****.**')
def setUpTestData(cls):
cls.user = MoodyUtil.create_user()
cls.url = reverse('spotify:suggest')
def setUpTestData(cls):
cls.user = MoodyUtil.create_user()
cls.app_url = 'https://moodytuns.vm/accounts/logout/'
cls.admin_url = 'https://admin.moodytunes.vm/logout/'
def setUpTestData(cls):
cls.url = reverse('accounts:login')
cls.user = MoodyUtil.create_user(create_user_profile=True)
