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_sends_assertion_to_mozilla_with_domain(self, mock_post):
backend = PersonaAuthenticationBackend()
backend.authenticate('an assertion')
mock_post.assert_called_once_with(PERSONA_VERIFY_URL,
data={
'assertion': 'an assertion',
'audience': settings.DOMAIN
})
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)
)
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_return_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) #
)
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, '*****@*****.**')
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):
backend = PersonaAuthenticationBackend()
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 = {}
backend = PersonaAuthenticationBackend()
user = 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 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.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.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 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 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 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 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_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)
class AuthenticateTest(TestCase):
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()
def test_sends_assertion_to_mozilla_with_domain(self, mock_post):
'''
1: Create instance of our backend, call authenticate function on string
2: Verify that there was response.post object sent with string under key "assertion"
and domain under key "audience". This is testing the request sent more than the function
'''
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):
'''
1: Modify mock return_value to false and the json.return value to what it would be
2: Authenticate user with this data
3: Verify that the
'''
mock_post.return_value.ok = False
mock_post.return_value.json.return_value = {} # 1
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_returns_none_if_status_not_okay(self, mock_post):
'''
1: We change a value in the json this time instead
'''
mock_post.return_value.json.return_value = {'status': 'not okay!'} #1
user = self.backend.authenticate('an assertion')
self.assertIsNone(user)
def test_finds_existing_user_with_email(self, mock_post):
'''
1: Create mock post object as if persona returned verified user
2: Use ORM API to create User object using email provided in mock_post
3: Run auth backend function with string as input
4: Validate that our auth funciton takes the object we created previously
and authenticates him, ei that request.post[data] and backend authentication are bound
'''
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):
'''
1: Persona response object with stats: ok and user json object for valid assertion
2: Run authenticate on persona object
3: Retrive user by email, assuming User.objects.create() was run
4: Validate that create() was run with proper user data
'''
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 #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
)
