Differential D11707 Diff 38828 bid_main/tests/test_login_register.py

Changeset View

Standalone View

bid_main/tests/test_login_register.py

	from urllib.parse import urlencode			from urllib.parse import urlencode

				from django.test import override_settings
	from django.urls import reverse, reverse_lazy			from django.urls import reverse, reverse_lazy
	from django.contrib.auth import get_user_model			from django.contrib.auth import get_user_model
	from django.test import TestCase			from django.test import TestCase
				import responses

	import oauth2_provider.models as oa2_models			import oauth2_provider.models as oa2_models

				import bid_main.recaptcha

	Application = oa2_models.get_application_model()			Application = oa2_models.get_application_model()
	AccessToken = oa2_models.get_access_token_model()			AccessToken = oa2_models.get_access_token_model()
	UserModel = get_user_model()			UserModel = get_user_model()

				RECAPTCHA_SUCCESS = {
				'success': True,
				'challenge_ts': '2021-06-03T10:15:05Z',
				'hostname': 'id.local',
				'score': 0.9,
				'action': 'submit',
				}


	class RegisterTest(TestCase):			class RegisterTest(TestCase):
				maxDiff = None

	@classmethod			@classmethod
	def setUpClass(cls):			def setUpClass(cls):
	super().setUpClass()			super().setUpClass()
	cls.user = UserModel.objects.create_user("test@user.com", "123456")			cls.user = UserModel.objects.create_user("test@user.com", "123456")

	def test_register_happy(self):			def test_register_valiation_error_missing_required_fields(self):
				response = self.client.post(reverse("bid_main:register"), {})

				self.assertEqual(200, response.status_code, f"response: {response}")
				self.assertDictEqual(
				{
				'agree_privacy_policy': [
				'It is not possible to register a Blender ID account '
				'without agreeing to the privacy policy',
				],
				'email': ['This field is required.'],
				'full_name': ['This field is required.'],
				'password': ['This field is required.'],
				'password_confirm': ['This field is required.'],
				'recaptcha_token': ['This field is required.'],
				},
				response.context['form'].errors,
				)
				self.assertEqual(1, len(UserModel.objects.all()))

				@responses.activate
				@override_settings(GOOGLE_RECAPTCHA_SITE_KEY='fake-key', GOOGLE_RECAPTCHA_SECRET_KEY='fake-key')
				def test_register_valiation_error_mismatching_passwords(self):
				responses.add(
				responses.POST,
				bid_main.recaptcha.VERIFY_URL,
				json=RECAPTCHA_SUCCESS,
				)
	response = self.client.post(			response = self.client.post(
	reverse("bid_main:register"),			reverse("bid_main:register"),
	{			{
	"full_name": "Šuper Ũseŕ",			"full_name": "Šuper Ũseŕ",
	"email": "super@hero.com",			"email": "super@hero.com",
	"nickname": "Apenút",			"password": "correct_horse_battery_staple",
				"password_confirm": "correct_horse_silvery_maple",
	"agree_privacy_policy": True,			"agree_privacy_policy": True,
	}			"recaptcha_token": "fake-token",
				},
				)

				self.assertEqual(200, response.status_code, f"response: {response}")
				self.assertDictEqual(
				{'password_confirm': ['The two password fields didn’t match.']},
				response.context['form'].errors,
				)
				self.assertEqual(1, len(UserModel.objects.all()))

				@responses.activate
				@override_settings(GOOGLE_RECAPTCHA_SITE_KEY='fake-key', GOOGLE_RECAPTCHA_SECRET_KEY='fake-key')
				def test_register_valiation_error_password_validators_are_called(self):
				responses.add(
				responses.POST,
				bid_main.recaptcha.VERIFY_URL,
				json=RECAPTCHA_SUCCESS,
				)
				response = self.client.post(
				reverse("bid_main:register"),
				{
				"full_name": "Šuper Ũseŕ",
				"email": "super@hero.com",
				"password": "1234",
				"password_confirm": "1234",
				"agree_privacy_policy": True,
				"recaptcha_token": "fake-token",
				},
				)

				self.assertEqual(200, response.status_code, f"response: {response}")
				self.assertDictEqual(
				{
				'password_confirm': [
				'This password is too short. It must contain at least 8 characters.',
				'This password is too common.',
				'This password is entirely numeric.',
				]
				},
				response.context['form'].errors,
				)
				self.assertEqual(1, len(UserModel.objects.all()))

				@responses.activate
				@override_settings(GOOGLE_RECAPTCHA_SITE_KEY='fake-key', GOOGLE_RECAPTCHA_SECRET_KEY='fake-key')
				def test_register_valiation_error_recaptcha_unavailable(self):
				responses.add(
				responses.POST,
				bid_main.recaptcha.VERIFY_URL,
				status=500,
				)
				response = self.client.post(
				reverse("bid_main:register"),
				{
				"full_name": "Šuper Ũseŕ",
				"email": "super@hero.com",
				"password": "correct_horse_battery_staple",
				"password_confirm": "correct_horse_battery_staple",
				"agree_privacy_policy": True,
				"recaptcha_token": "fake-token",
				},
				)

				self.assertEqual(200, response.status_code, f"response: {response}")
				self.assertDictEqual(
				{
				'recaptcha_token': [
				'There was a communication error checking reCAPTCHA. Please try again later.'
				]
				},
				response.context['form'].errors,
				)
				self.assertEqual(1, len(UserModel.objects.all()))

				@responses.activate
				@override_settings(GOOGLE_RECAPTCHA_SITE_KEY='fake-key', GOOGLE_RECAPTCHA_SECRET_KEY='fake-key')
				def test_register_saves_new_user_and_logs_them_in(self):
				responses.add(
				responses.POST,
				bid_main.recaptcha.VERIFY_URL,
				json=RECAPTCHA_SUCCESS,
				)
				response = self.client.post(
				reverse("bid_main:register"),
				{
				"full_name": "Šuper Ũseŕ",
				"email": "super@hero.com",
				"password": "correct_horse_battery_staple",
				"password_confirm": "correct_horse_battery_staple",
				"agree_privacy_policy": True,
				"recaptcha_token": "fake-token",
				},
	)			)
	self.assertEqual(302, response.status_code, f"response: {response}")			self.assertEqual(302, response.status_code, f"response: {response}")
	redirect_url = reverse("bid_main:register-done")			redirect_url = reverse("bid_main:index")
	self.assertEqual(redirect_url, response["location"])			self.assertEqual(redirect_url, response["location"])

	# Check the user's info
	db_user = UserModel.objects.get(email="super@hero.com")			db_user = UserModel.objects.get(email="super@hero.com")
				# Check that login was successful
				self.assertEqual(int(self.client.session['_auth_user_id']), db_user.pk)

				# Check the user's info
	self.assertEqual("Šuper Ũseŕ", db_user.full_name)			self.assertEqual("Šuper Ũseŕ", db_user.full_name)
	self.assertEqual(2, len(UserModel.objects.all()))			self.assertEqual(2, len(UserModel.objects.all()))
				self.assertTrue(db_user.nickname.startswith("Šuper-Ũseŕ"), db_user.nickname)
				self.assertTrue(db_user.privacy_policy_agreed)
				self.assertTrue(db_user.is_active)
				self.assertFalse(db_user.is_staff)
				self.assertFalse(db_user.is_superuser)
				self.assertEqual(db_user.login_count, 1)
				self.assertIsNone(db_user.confirmed_email_at)
				self.assertEqual('127.0.0.1', db_user.current_login_ip)

				@responses.activate
				@override_settings(GOOGLE_RECAPTCHA_SITE_KEY='fake-key', GOOGLE_RECAPTCHA_SECRET_KEY='fake-key')
				def test_register_saves_new_user_and_logs_them_in_and_redirects_to_next(self):
				responses.add(
				responses.POST,
				bid_main.recaptcha.VERIFY_URL,
				json=RECAPTCHA_SUCCESS,
				)
				password = "correct_horse_battery_staple"
				response = self.client.post(
				reverse("bid_main:register") + '?next=/oauth/authorize',
				{
				"full_name": "Šuper Ũseŕ",
				"email": "super@hero.com",
				"password": password,
				"password_confirm": password,
				"agree_privacy_policy": True,
				"recaptcha_token": "fake-token",
				},
				)
				self.assertEqual(302, response.status_code, f"response: {response}")
				self.assertEqual('/oauth/authorize', response["location"])
				self.assertEqual(2, len(UserModel.objects.all()))

				db_user = UserModel.objects.get(email="super@hero.com")
				# Check that login was successful
				self.assertEqual(int(self.client.session['_auth_user_id']), db_user.pk)
				self.assertIsNotNone(db_user.password)
				self.assertNotEqual(db_user.password, password)
				self.assertTrue(db_user.nickname.startswith("Šuper-Ũseŕ"), db_user.nickname)

				# Check that it's possible to login with the provided password
				self.client.logout()
				login_url = reverse("bid_main:login")
				response = self.client.get(login_url)
				# Should be logged out now:
				self.assertTrue(response.context['user'].is_anonymous)
				response = self.client.post(
				login_url, {'username': db_user.email, 'password': password}, follow=True
				)
				# Should be logged in now:
				self.assertTrue(response.context['user'].is_active)
				self.assertEqual(int(self.client.session['_auth_user_id']), db_user.pk)

	def test_user_already_exists(self):			def test_user_already_exists(self):
	response = self.client.post(			response = self.client.post(
	reverse("bid_main:register"),			reverse("bid_main:register"),
	{			{
	"full_name": "Šuper Ũseŕ",			"full_name": "Šuper Ũseŕ",
	"email": self.user.email,			"email": self.user.email,
	"nickname": "Apenút",			"nickname": "Apenút",
	▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines