def test_returns_none_if_no_user_with_email(self):
backend = PersonaAuthenticationBackend()
other_user = User(email='*****@*****.**')
other_user.username = '******'
other_user.save()
found_user = backend.get_user('*****@*****.**')
self.assertIsNone(found_user)
def test_sends_assertion_to_mozilla_with_domain(self, mock_post):
backend = PersonaAuthenticationBackend()
backend.authenticate('an assertion')
mock_post.asesrt_called_once_with(
PERSONA_VERIFY_URL,
data={'assertion': 'an assertion', 'audience': DOMAIN}
)
def test_returns_none_if_no_user_with_that_email(self):
backend = PersonaAuthenticationBackend()
user = User(email='*****@*****.**')
self.assertIsNone(
backend.get_user(user.pk)
)
def test_returns_none_if_user_does_not_exist(self, mock_User_get):
def raise_no_user_error(*_, **__):
raise User.DoesNotExist()
mock_User_get.side_effect = raise_no_user_error
backend = PersonaAuthenticationBackend()
self.assertIsNone(backend.get_user('*****@*****.**'))
def test_gets_user_email(self):
backend = PersonaAuthenticationBackend()
mystical_user = User(email='*****@*****.**')
mystical_user.username = '******'
mystical_user.save()
desired_user = User.objects.create(email='*****@*****.**')
found_user = backend.get_user('*****@*****.**')
self.assertEqual(desired_user, found_user)
def test_gets_user_by_email(self):
backend = PersonaAuthenticationBackend()
other_user = User(email='*****@*****.**')
other_user.username = '******'
other_user.save()
desired_user = User.objects.create(email='*****@*****.**')
found_user = backend.get_user('*****@*****.**')
self.assertEqual(found_user, desired_user)
def test_gets_user_by_email(self):
backend = PersonaAuthenticationBackend()
# to fail the test until a user was specified...
other_user = User(email="*****@*****.**")
other_user.username = "******"
other_user.save()
desired_user = User.objects.create(email="*****@*****.**")
found_user = backend.get_user("*****@*****.**")
self.assertEqual(found_user, desired_user)
class AuthenticateTest(TestCase):
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User(email="*****@*****.**")
user.username = '******'
user.save()
def test_sends_assertion_to_mozilla_with_domain(self, mock_post):
self.backend.authenticate('an assertion')
mock_post.assert_called_once_with(
PERSONA_VERIFY_URL,
data={'assertion': "an assertion", 'audience': settings.DOMAIN}
)
def test_returns_one_if_response_errors(self, mock_post):
mock_post.return_value.ok = False
user = self.backend.authenticate("an assertion")
self.assertIsNone(user)
def test_returns_none_if_status_not_okay(self, mock_post):
mock_post.return_value.json.return_value = {'status': "not okay!"}
user = self.backend.authenticate("an assertion")
self.assertIsNone(user)
def test_finds_existing_user_with_email(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'okay',
'email': '*****@*****.**'}
actual_user = User.objects.create(email="*****@*****.**")
found_user = self.backend.authenticate("an assertion")
self.assertEqual(found_user, actual_user)
def test_returns_none_if_response_errors(self, mock_post):
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {}
user = self.backend.authenticate("an assertion")
self.assertIsNone(user)
def test_create_new_user_if_necessary_for_valid_assertion(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'okay',
'email': '*****@*****.**'}
found_user = self.backend.authenticate("an assertion")
new_user = User.objects.get(email="*****@*****.**")
self.assertEqual(found_user, new_user)
def test_logs_non_okay_response_from_persona(self, mock_post):
response_json = {
'status': 'not okay',
'reason': 'eg, audience mismatch'
}
mock_post.return_value.ok = True
mock_post.return_value.json.return_value = response_json
logger = logging.getLogger('accounts.authentication')
with patch.object(logger, 'warning') as mock_log_warning:
self.backend.authenticate("an assertion")
mock_log_warning.assert_called_once_with(
"Persona says no. Json was: {}".format(response_json)
)
def test_gets_user_by_email(self):
'''
1: Create dummy user
2: Create new user by email
3: Retrieve new user by email by passing his email to get_user()
4: Test that created new user and retrieved new user are same
'''
backend = PersonaAuthenticationBackend()
other_user = User(email='*****@*****.**')
other_user.username = '******'
other_user.save() # 1
desired_user = User.objects.create(email='*****@*****.**') # 2
found_user = backend.get_user('*****@*****.**') # 3
self.assertEqual(found_user, desired_user) # 4
class GetUserTest(TestCase):
def setUp(self):
self.backend = PersonaAuthenticationBackend()
def test_gets_user_by_email(self):
other_user = User(email="*****@*****.**")
other_user.username = "******"
other_user.save()
desired_user = User.objects.create(email="*****@*****.**")
found_user = self.backend.get_user("*****@*****.**")
self.assertEqual(found_user, desired_user)
def test_returns_none_if_no_user_with_that_email(self):
self.assertIsNone(self.backend.get_user("*****@*****.**"))
class AuthenticateTest(TestCase):
def setUp(self):
self.backend = PersonaAuthenticationBackend()
self.mock_response = mock_post.return_value
self.mock_response.ok = True
self.mock_response.json.return_value = {
'status': 'okay', 'email': '*****@*****.**'
}
def tearDown(self):
mock_post.reset_mock()
def test_sends_assertion_to_mozilla_with_domain(self):
self.backend.authenticate('an assertion')
mock_post.assert_called_once_with(
PERSONA_VERIFY_URL,
data={'assertion': 'an assertion', 'audience': DOMAIN}
)
def test_return_none_if_response_error(self):
self.mock_response.json.return_value = {'status': 'not okay'}
self.mock_response.ok = False
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_returns_non_if_status_not_okay(self):
self.mock_response.json.return_value = {'status': 'not okay'}
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_finds_existing_user_with_email(self):
self.mock_response.json.return_value = {
'status': 'okay', 'email': '*****@*****.**'}
self.backend.get_user = Mock()
mock_user = self.backend.get_user.return_value
user = self.backend.authenticate('an assertion')
self.assertEqual(user, mock_user)
def test_calls_get_user_with_email(self):
self.mock_response.json.return_value = {
'status': 'okay', 'email': '*****@*****.**'}
self.backend.get_user = Mock()
self.backend.authenticate('an assertion')
self.backend.get_user.assert_called_once_with('*****@*****.**')
def test_creates_new_user_if_required(self):
def raise_no_user_error(_):
raise User.DoesNotExist()
self.backend.get_user = raise_no_user_error
user = self.backend.authenticate('an assertion')
new_user = User.objects.all()[0]
self.assertEqual(user, new_user)
self.assertEqual(user.email, '*****@*****.**')
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User(email='*****@*****.**')
# By default, Django's users have a username attribute, which must
# be unique.
user.username = '******'
user.save()
def setUp(self):
self.backend = PersonaAuthenticationBackend() # 现在我们可以在 setUp 函数中准备所有测试都会用到的变量
user = User(email="*****@*****.**")
# 在默认情况下，Django 的用户都有 username 属性，其值必须具有唯一性。
# 这里使用的值只是一个占位符，方便我们创建多个用户。后面我们要使用电子邮件做主键，到时候就不用用户名了。
user.username = "******"
user.save()
def setUp(self):
self.backend = PersonaAuthenticationBackend()
self.mock_response = mock_post.return_value
self.mock_response.ok = True
self.mock_response.json.return_value = {
'status': 'okay', 'email': '*****@*****.**'
}
def setUp(self):
'''
Notice we mock up requests.post so we don't send actual request
'''
self.backend = PersonaAuthenticationBackend()
user = User(email='*****@*****.**')
user.username = '******'
user.save()
class AuthenticateTest(TestCase):
def setUp(self):
self.backend = PersonaAuthenticationBackend() # 现在我们可以在 setUp 函数中准备所有测试都会用到的变量
user = User(email="*****@*****.**")
# 在默认情况下，Django 的用户都有 username 属性，其值必须具有唯一性。
# 这里使用的值只是一个占位符，方便我们创建多个用户。后面我们要使用电子邮件做主键，到时候就不用用户名了。
user.username = "******"
user.save()
def test_sends_assertion_to_mozilla_with_domain(self, mock_post):
self.backend.authenticate("an assertion")
mock_post.assert_called_once_with(
PERSONA_VERIFY_URL,
data={"assertion": "an assertion", "audience": settings.DOMAIN}
)
def test_returns_none_if_response_errors(self, mock_post):
# 现在每个测试只调整需要设定的变量，而没有设定一堆重复的样板代码，所以测试更具易读性
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {}
user = self.backend.authenticate("an assertion")
self.assertIsNone(user)
def test_returns_none_if_status_not_okay(self, mock_post):
# 现在每个测试只调整需要设定的变量，而没有设定一堆重复的样板代码，所以测试更具易读性
mock_post.return_value.json.return_value = {
"status": "not okay!"}
user = self.backend.authenticate("an assertion")
self.assertIsNone(user)
def test_finds_existing_user_with_email(self, mock_post):
mock_post.return_value.json.return_value = {"status": "okay", "email": "*****@*****.**"}
actual_user = User.objects.create(email="*****@*****.**")
found_user = self.backend.authenticate("an assertion")
self.assertEqual(found_user, actual_user)
def test_creates_new_user_if_necessary_for_valid_assertion(self, mock_post):
mock_post.return_value.json.return_value = {"status": "okay", "email": "*****@*****.**"}
found_user = self.backend.authenticate("an assertion")
new_user = User.objects.get(email="*****@*****.**")
self.assertEqual(found_user, new_user)
def test_logs_non_okay_responses_from_persona(self, mock_post):
response_json = {"status": "not okay", "reason": "eg, audience mismatch"}
mock_post.return_value_ok = True
mock_post.return_value.json.return_value = response_json # 给测试提供一些数据，触发日志记录器
logger = logging.getLogger("accounts.authentication") # 获取正在测试的这个模块的日志记录器
# 使用 patch.object 临时模块这个日志记录器的 warning 函数。使用 with 的目的是把这个驭件作为测试目标函数的上下文管理器
with patch.object(logger, "warning") as mock_log_warning:
self.backend.authenticate("an assertion")
# 然后可以使用这个驭件声明断言
mock_log_warning.assert_called_once_with("Persona says no. Json was: {}".format(response_json))
class AuthenticateTest(TestCase):
# setup applies DRY
# always a user in db
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User(email="*****@*****.**")
user.username = "******" # 1
user.save()
def test_sends_assertion_to_mozilla_with_domain(self, mock_post):
self.backend.authenticate("an assertion")
mock_post.assert_called_once_with(
PERSONA_VERIFY_URL, data={"assertion": "an assertion", "audience": settings.DOMAIN}
)
# no user gives none
def test_returns_none_if_response_errors(self, mock_post):
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {}
user = self.backend.authenticate("an assertion")
self.assertIsNone(user)
def test_returns_none_if_status_not_okay(self, mock_post):
mock_post.return_value.json.return_value = {"status": "not okay!"}
user = self.backend.authenticate("an assertion")
self.assertIsNone(user)
def test_finds_existing_user_with_email(self, mock_post):
mock_post.return_value.json.return_value = {"status": "okay", "email": "*****@*****.**"}
actual_user = User.objects.create(email="*****@*****.**")
found_user = self.backend.authenticate("an assertion")
self.assertEqual(found_user, actual_user)
def test_creates_new_user_if_necessary_for_valid_assertion(self, mock_post):
mock_post.return_value.json.return_value = {"status": "okay", "email": "*****@*****.**"}
# this line return a user, that's not there
found_user = self.backend.authenticate("an assertion")
# later this fail cus email aint in db
new_user = User.objects.get(email="*****@*****.**")
self.assertEqual(found_user, new_user)
# for logging
def test_logs_non_okay_responses_from_persona(self, mock_post):
response_json = {"status": "not okay", "reason": "eg, audience mismatch"}
mock_post.return_value.ok = True
mock_post.return_value.json.return_value = response_json # 1
logger = logging.getLogger("accounts.authentication") # 2
with patch.object(logger, "warning") as mock_log_warning: # 3
self.backend.authenticate("an assertion")
mock_log_warning.assert_called_once_with("Persona says no. Json was: {}".format(response_json)) # 4
class AuthenticateTest(TestCase):
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User(email='*****@*****.**')
user.username = '******'
user.save()
def test_sends_assertion_to_mozilla_with_domain(self, mock_post):
user = self.backend.authenticate('an assertion')
# print('user in the response is: ', user)
mock_post.assert_called_once_with(
PERSONA_VERIFY_URL,
data={'assertion': 'an assertion', 'audience': DOMAIN}
)
def test_returns_none_if_response_errors(self, mock_post):
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {}
user = self.backend.authenticate('an assertion')
# print('the response including user: '******'status': 'not okay!'}
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_finds_existing_user_with_email(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'okay', 'email': '*****@*****.**'}
actual_user = User.objects.create(email='*****@*****.**')
# print('actual user created: ', actual_user.email)
found_user = self.backend.authenticate('an assertion')
# print('post user found: ', found_user.email)
self.assertEqual(found_user, actual_user)
def test_creates_new_user_if_neccessary_for_valid_assertion(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'okay', 'email': '*****@*****.**'}
found_user = self.backend.authenticate('an assertion')
new_user = User.objects.get(email='*****@*****.**')
self.assertEqual(found_user, new_user)
class AuthenticateTest(TestCase):
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User(email="*****@*****.**")
user.username = "******"
user.save()
def test_send_assertion_to_mozilla_with_domain(self, mock_post):
self.backend.authenticate("an assertion")
mock_post.assert_called_once_with(PERSONA_VERIFY_URL, data={"assertion": "an assertion", "audience": DOMAIN})
def test_returns_none_if_response_errors(self, mock_post):
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {}
user = self.backend.authenticate("an assertion")
self.assertIsNone(user)
def test_returns_none_if_status_errors(self, mock_post):
mock_post.return_value.json.return_value = {"status": "not okay!"}
user = self.backend.authenticate("an assertion")
self.assertIsNone(user)
def test_finds_existing_user_with_email(self, mock_post):
mock_post.return_value.json.return_value = {"status": "okay", "email": "*****@*****.**"}
actual_user = User.objects.create(email="*****@*****.**")
found_user = self.backend.authenticate("an assertion")
self.assertEqual(found_user, actual_user)
def test_creates_new_user_if_necessary_for_valid_assertion(self, mock_post):
mock_post.return_value.json.return_value = {"status": "okay", "email": "*****@*****.**"}
found_user = self.backend.authenticate("an assertion")
new_user = User.objects.get(email="*****@*****.**")
self.assertEqual(found_user, new_user)
class AuthenticateTest(TestCase):
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User(email='*****@*****.**')
user.save()
def test_sends_assertion_to_mozilla_with_domain(self, mock_post):
self.backend.authenticate('an assertion')
mock_post.assert_called_once_with(
PERSONA_VERIFY_URL,
data = {'assertion': 'an assertion', 'audience': settings.DOMAIN}
)
def test_returns_none_if_response_errors(self, mock_post):
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {}
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_returns_none_if_status_not_okay(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'not okay!'}
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_finds_existing_user_with_email(self, mock_post):
existing_user = User.objects.create(email='*****@*****.**')
mock_post.return_value.json.return_value = {
'status': 'okay', 'email': '*****@*****.**'
}
returned_user = self.backend.authenticate('an assertion')
self.assertEqual(existing_user, returned_user)
def test_creates_new_user_if_necessary_for_valid_assertion(self, mock_post):
mock_post.return_value.json.return_value = {
'status': 'okay', 'email': '*****@*****.**'
}
returned_user = self.backend.authenticate('an assertion')
self.assertEqual(User.objects.count(), 2)
self.assertNotEqual(returned_user, User.objects.get(email='*****@*****.**'))
self.assertEqual(returned_user, User.objects.get(email='*****@*****.**'))
class AuthenticateTest(TestCase):
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User.objects.create(email='*****@*****.**')
def test_sends_assertion_to_mozilla_with_domain(self, mock_post):
self.backend.authenticate('an assertion')
mock_post.assert_called_once_with(
PERSONA_VERIFY_URL,
data={'assertion': 'an assertion', 'audience': DOMAIN}
)
def test_returns_None_if_response_errors(self, mock_post):
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {}
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_response_JSON_has_status_okay(self, mock_post):
mock_post.return_value.ok = True
mock_post.return_value.json.return_value = {'status': 'not okay!'}
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_finds_existing_user_with_email(self, mock_post):
mock_post.return_value.ok = True
mock_post.return_value.json.return_value = {'status': 'okay', 'email': '*****@*****.**'}
actual_user = User.objects.create(email='*****@*****.**')
found_user = self.backend.authenticate('an assertion')
self.assertEqual(found_user, actual_user)
def test_creates_new_user_if_necessary_for_valid_assertion(self, mock_post):
mock_post.return_value.ok = True
mock_post.return_value.json.return_value = {'status': 'okay', 'email': '*****@*****.**'}
found_user = self.backend.authenticate('an assertion')
new_user = User.objects.get(email='*****@*****.**')
self.assertEqual(found_user, new_user)
class AuthenticationTest(TestCase):
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User(email='*****@*****.**')
user.username = '******'
user.save()
def test_sends_assertion_to_mozilla_with_domain(self, mock_post):
self.backend.authenticate('the assertion')
mock_post.assert_called_once_with(
PERSONA_VERIFY_URL,
data={'assertion': 'the assertion', 'audience': DOMAIN}
)
def test_returns_none_on_response_error(self, mock_post):
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {}
user = self.backend.authenticate('the assertion')
self.assertIsNone(user)
def test_returns_none_if_status_not_okay(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'foobard'}
user = self.backend.authenticate('the assertion')
self.assertIsNone(user)
def test_finds_existing_user_with_email(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'okay', 'email': '*****@*****.**'}
actual_user = User.objects.create(email='*****@*****.**')
found_user = self.backend.authenticate('the assertion')
self.assertEqual(found_user, actual_user)
def test_creates_new_user_if_necessary_on_valid_assertion(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'okay', 'email': '*****@*****.**'}
found_user = self.backend.authenticate('the assertion')
created_user = User.objects.get(email='*****@*****.**')
self.assertEqual(User.objects.all().count(), 2)
self.assertEqual(found_user, created_user)
class AuthenticationTest(TestCase):
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User(email='*****@*****.**')
user.username = '******'
user.save()
def test_sends_assertion_to_mozilla_with_domain(self, mock_post):
self.backend.authenticate('an assertion')
# we assure, that patched method is called with following args
mock_post.assert_called_once_with(
PERSONA_VERIFY_URL,
data={'assertion': 'an assertion', 'audience': DOMAIN}
)
def test_returns_none_if_errors_in_response(self, mock_post):
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {}
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_returns_none_if_status_not_okay(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'not okay!'}
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_finds_existing_user_with_email(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'okay', 'email': '[email protected]'}
actual_user = User.objects.create(email='[email protected]')
found_user = self.backend.authenticate('an assertion')
self.assertEqual(found_user, actual_user)
def test_creates_new_user_if_necessary_for_valid_assertion(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'okay', 'email': '[email protected]'}
found_user = self.backend.authenticate('an assertion')
new_user = User.objects.get(email='[email protected]')
self.assertEqual(found_user, new_user)
class AuthenticateTest(TestCase):
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User(email='*****@*****.**')
user.username = '******'
user.save()
def test_sends_assertion_to_mozilla_with_domain(self, mock_post):
self.backend.authenticate('an assertion')
mock_post.assert_called_once_with(
PERSONA_VERIFY_URL,
data={'assertion': 'an assertion', 'audience': settings.DOMAIN}
)
def test_returns_none_if_response_errors(self, mock_post):
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {}
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_returns_none_if_status_not_okay(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'not okay!'}
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_finds_existing_user_with_email(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'okay', 'email': '*****@*****.**'}
actual_user = User.objects.create(email='*****@*****.**')
found_user = self.backend.authenticate('an assertion')
self.assertEqual(found_user, actual_user)
def test_creates_new_user_if_necessary_for_valid_assertion(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'okay', 'email': '*****@*****.**'}
found_user = self.backend.authenticate('an assertion')
new_user = User.objects.get(email='*****@*****.**')
self.assertEqual(found_user, new_user)
class testAuthentication(TestCase):
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User(email='*****@*****.**')
user.username = '******'
user.save()
def test_sends_assertion_to_mozilla_with_domain(self, mock_post):
self.backend.authenticate('assert this')
mock_post.assert_called_once_with(
PERSONA_VERIFY_URL,
data={'assertion':'assert this','audience':settings.DOMAIN}
)
def test_returns_none_if_response_error(self, mock_post):
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {}
user = self.backend.authenticate('assert this')
self.assertIsNone(user)
def test_returns_none_if_status_not_okay(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'not okay!'}
user = self.backend.authenticate('assert this')
self.assertIsNone(user)
def test_finds_existing_user_with_email(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'okay', 'email': '*****@*****.**'}
actual_user = User.objects.create(email='*****@*****.**')
found_user = self.backend.authenticate('assert this')
self.assertEqual(found_user, actual_user)
def test_creates_new_user_if_necessary_for_valid_assertion(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'okay', 'email': '*****@*****.**'}
found_user = self.backend.authenticate('assert this')
new_user = User.objects.get(email='*****@*****.**')
self.assertEqual(found_user, new_user)
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User(email='*****@*****.**')
user.username = '******'
user.save()
def test_returns_none_if_response_errors(self, mock_post):
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {}
backend = PersonaAuthenticationBackend()
user = backend.authenticate('an assertion')
self.assertIsNone(user)
def test_returns_none_if_no_user_with_that_email(self):
backend = PersonaAuthenticationBackend()
self.assertIsNone(backend.get_user("*****@*****.**"))
def test_returns_none_if_no_user_with_that_email(self):
backend = PersonaAuthenticationBackend()
found_user = backend.get_user('*****@*****.**')
self.assertIsNone(found_user)
def test_gets_user_from_ORM_using_email(self, mock_User_get):
backend = PersonaAuthenticationBackend()
found_user = backend.get_user('*****@*****.**')
self.assertEqual(found_user, mock_User_get.return_value)
mock_User_get.assert_called_once_with(email='*****@*****.**')
def test_gets_user_from_ORM_using_email(self, mock_User_get):
backend = PersonaAuthenticationBackend()
found_user = backend.get_user('*****@*****.**')
self.assertEqual(found_user, mock_User_get.return_value)
mock_User_get.assert_called_once_with(email='*****@*****.**')
def test_returns_none_if_no_user_with_that_email(self):
backend = PersonaAuthenticationBackend()
assert backend.get_user('*****@*****.**') is None
def test_returns_none_if_no_user_with_that_email(self):
backend = PersonaAuthenticationBackend()
self.assertIsNone(backend.get_user('*****@*****.**'))
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User(email='*****@*****.**')
user.username = '******'
user.save()
class AuthenticateTest(TestCase):
def setUp(self):
self.backend = PersonaAuthenticationBackend()
user = User(email='*****@*****.**')
user.username = '******'
user.save()
def test_sends_assertion_to_mozilla_with_domain(self, mock_post):
self.backend.authenticate('an assertion')
mock_post.assert_called_once_with(PERSONA_VERIFY_URL,
data={
'assertion': 'an assertion',
'audience': settings.DOMAIN
})
def test_returns_none_if_response_errors(self, mock_post):
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {}
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_returns_none_if_status_not_okay(self, mock_post):
mock_post.return_value.json.return_value = {'status': 'not okay!'}
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_finds_existing_user_with_email(self, mock_post):
mock_post.return_value.json.return_value = {
'status': 'okay',
'email': '*****@*****.**'
}
actual_user = User.objects.create(email='*****@*****.**')
found_user = self.backend.authenticate('an assertion')
self.assertEqual(found_user, actual_user)
def test_creates_new_user_if_necessary_for_valid_assertion(
self, mock_post):
mock_post.return_value.json.return_value = {
'status': 'okay',
'email': '*****@*****.**'
}
found_user = self.backend.authenticate('an assertion')
new_user = User.objects.get(email='*****@*****.**')
self.assertEqual(found_user, new_user)
def test_logs_non_okay_responses_from_persona(self, mock_post):
response_json = {
'status': 'not okay',
'reason': 'eg, audience mismatch'
}
mock_post.return_value.ok = True
mock_post.return_value.json.return_value = response_json
logger = logging.getLogger('accounts.authentication')
with patch.object(logger, 'warning') as mock_log_warning:
self.backend.authenticate('an assertion')
mock_log_warning.assert_called_once_with(
'Persona says no. Json was: {}'.format(response_json))
def test_returns_none_if_response_errors(self,mock_post):
mock_post.return_value.ok = False
mock_post.return_value.json.return_value={}
backend = PersonaAuthenticationBackend()
user = backend.authenticate('an assertion')
self.assertIsNone(user)
