class UserAuthCodeTest(unittest.TestCase):
def setUp(self):
self.encoder = UserAuthCode('secret')
self.user = UserFactory(is_active=False)
def tearDown(self):
self.encoder = None
self.user.delete()
self.user = None
def test_user(self):
self.assertIsNotNone(self.user.date_joined)
self.assertTrue(self.user.date_joined >= self.user.last_login)
def test_salt(self):
salt = self.encoder.salt()
self.assertEqual(8, len(salt))
def test_auth_code(self):
code = self.encoder.auth_code(self.user)
self.assertIsNotNone(code)
def test_complete_activation(self):
code = self.encoder.auth_code(self.user)
self.assertTrue(self.encoder.is_valid(self.user, code))
def test_wrong_key(self):
self.assertFalse(self.encoder.is_valid(self.user, 'aaa'))
def test_already_activated(self):
code = self.encoder.auth_code(self.user)
self.user.last_login = timezone.now()
self.user.save()
self.assertFalse(self.encoder.is_valid(self.user, code))
class TestMessage(unittest.TestCase):
"""
Test messages
"""
def setUp(self):
self.user = UserFactory()
self.region = RegionFactory()
self.message = MessageFactory.build(georegion=self.region)
def tearDown(self):
self.user.delete()
self.region.delete()
self.message = None
def test_message_unicode(self):
self.assertEqual(self.message.title, "%s" % self.message)
def test_message_save(self):
self.message.save()
self.assertIsNotNone(self.message.pk)
self.message.delete()
def test_message_remove(self):
self.message.is_removed = True
self.assertTrue(self.message.is_removed)
def test_message_restore(self):
self.message.is_removed = True
self.assertTrue(self.message.is_removed)
self.message.is_removed = False
self.assertFalse(self.message.is_removed)
def test_knownuser_form(self):
''' Form for authenticated user contain initial data for some fields'''
user = UserFactory(is_active=True)
form = self.app.get(
'/message/pomogite/dobavit',
user=user.username).forms['mainForm']
self.assertEqual(user.first_name, form['contact_first_name'].value)
self.assertEqual(user.last_name, form['contact_last_name'].value)
self.assertEqual(user.email, form['contact_mail'].value)
self.assertEqual(user.profile.phones, form['contact_phone'].value)
user.delete()
class TestUserMessage(unittest.TestCase):
def setUp(self):
self.user = UserFactory()
def tearDown(self):
self.user.delete()
self.user = None
def test_user_message(self):
msg = MessageFactory(user=self.user)
self.assertIsNotNone(msg)
self.assertEqual(self.user, msg.user)
def test_knownuser_message(self):
''' Authenticated user send message and this message must be
linked to user profile'''
before = Message.objects.count()
user = UserFactory(is_active=True)
form = self.app.get(
'/message/pomogite/dobavit',
user=user.username).forms['mainForm']
form['title'] = 'Test message'
form['message'] = "This is simple test message"
form['georegion'] = self.region.pk
form['address'] = 'Some address'
form.submit()
self.assertEqual(before + 1, Message.objects.count())
msg = Message.objects.all().select_related().reverse()[0]
self.assertEqual(msg.user, user)
user.delete()
class TestUserActivation(unittest.TestCase):
def setUp(self):
encoder = UserAuthCode(settings.SECRET_KEY)
self.user = UserFactory(is_active=False)
self.code = encoder.auth_code(self.user)
def tearDown(self):
self.user.delete()
self.code = None
def test_user_activation(self):
self.assertTrue(activate_user(self.user, self.code))
self.assertTrue(self.user.is_active)
def test_wrong_code(self):
self.assertFalse(activate_user(self.user, 'self.code'))
self.assertFalse(self.user.is_active)
class IonTest(unittest.TestCase):
'''Authorization tests'''
def setUp(self):
self.ion = IonAuth()
self.user = UserFactory.build(
is_active=True
)
self.user.password = self.ion.password_hash('123')
self.active_user = UserFactory(is_active=True)
self.inactive_user = UserFactory(is_active=False)
def tearDown(self):
self.active_user.delete()
self.inactive_user.delete()
self.user = None
def test_ion_auth(self):
self.assertEquals(40, len(self.user.password))
def test_password_rewrite(self):
'''
If user enters correct ion password, backend will
rehash password to django-specific password hash.
'''
self.user.save()
u2 = self.ion.authenticate(username=self.user.email, password='******')
self.assertIsNotNone(u2)
self.assertFalse(u2.is_anonymous())
self.assertNotEqual(self.user.password, u2.password)
self.user.delete()
def test_inactive_user(self):
u2 = self.ion.authenticate(
username=self.inactive_user.email, password='******')
self.assertIsNone(u2)
def test_unexists_user(self):
u2 = self.ion.authenticate(username="******", password='******')
self.assertIsNone(u2)
def test_wrong_password(self):
u2 = self.ion.authenticate(
username=self.active_user.email, password='******')
self.assertIsNone(u2)
class TestMessageCleanData(unittest.TestCase):
"""
Test message cleaf functionality.
"""
def setUp(self):
self.user = UserFactory()
self.region = RegionFactory()
self.message = MessageFactory.build(georegion=self.region)
def tearDown(self):
self.message = None
self.region.delete()
self.user.delete()
def catch_wrong_data(self):
""" Common test missed data"""
with self.assertRaises(ValidationError):
self.message.save()
self.message.delete()
def test_no_message_contacts(self):
self.message.contact_phone = None
self.message.contact_mail = None
self.catch_wrong_data()
def test_invalid_email(self):
self.message.contact_mail = "notamail"
self.catch_wrong_data()
def test_phone_contact(self):
self.message.contact_mail = ""
self.message.save()
self.assertIsNotNone(self.message.pk)
self.message.delete()
def test_email_contact(self):
self.message.contact_phone = ""
self.message.save()
self.assertIsNotNone(self.message.pk)
self.message.delete()
class TestSimpleRequestForm(unittest.TestCase):
def setUp(self):
self.form = SimpleRequestForm()
self.user = UserFactory()
self.region = RegionFactory()
self.data = {
"title": lorem_ipsum(words_count=3),
"message": lorem_ipsum(),
"messageType": MessageType.TYPE_REQUEST,
"contact_first_name": self.user.first_name,
"contact_last_name": self.user.last_name,
"contact_mail": self.user.email,
"georegion": self.region.pk,
"location_0": 0.0,
"location_1": 0.0,
"address": lorem_ipsum(words_count=4),
}
def tearDown(self):
self.region.delete()
self.region = None
self.form = None
self.user.delete()
def test_form_type(self):
self.assertEqual(1, self.form.fields["messageType"].initial)
def test_send_data(self):
form = SimpleRequestForm(self.data)
self.assertTrue(form.is_bound)
self.assertTrue(form.is_valid(), form.errors)
msg = form.save(commit=True)
self.assertIsNotNone(msg)
self.assertIsNotNone(msg.pk)
self.assertEqual(1, msg.status)
self.assertEqual(1, msg.messageType)
msg.delete()
class TestForgotPasswordForm(unittest.TestCase):
'''
First step reset password functionality - validate email
'''
def setUp(self):
self.user = UserFactory()
def tearDown(self):
self.user.delete()
def test_reset_password(self):
data = {'email': self.user.email}
form = ForgotPasswordForm(data)
self.assertTrue(form.is_bound)
self.assertTrue(form.is_valid())
def test_unknown_email(self):
data = {'email': '*****@*****.**',}
form = ForgotPasswordForm(data)
self.assertTrue(form.is_bound)
self.assertFalse(form.is_valid())
self.assertEqual([_(u'This email isn\'t registered'),],
form['email'].errors)
class SimpleRegistrationFormTest(unittest.TestCase):
''' Registration form test'''
def setUp(self):
self.data = {
'first_name': 'test',
'last_name': 'user',
'email': '*****@*****.**',
'password1': '123',
'password2': '123'
}
self.user = UserFactory()
def tearDown(self):
self.data = None
self.user.delete()
Profile.objects.all().delete()
def test_user_creation(self):
form = SimpleRegistrationForm(self.data)
self.assertTrue(form.is_bound)
self.assertTrue(form.is_valid())
def test_lost_firstname(self):
self.data['first_name'] = None
form = SimpleRegistrationForm(self.data)
self.assertTrue(form.is_bound)
self.assertFalse(form.is_valid())
self.assertEqual([_(u'This field is required.'), ],
form['first_name'].errors)
def test_empty_firstname(self):
self.data['first_name'] = ' '
form = SimpleRegistrationForm(self.data)
self.assertTrue(form.is_bound)
self.assertFalse(form.is_valid())
self.assertEqual([_(u'You must provide a first name!'), ],
form['first_name'].errors)
def test_lost_lastname(self):
self.data['last_name'] = None
form = SimpleRegistrationForm(self.data)
self.assertTrue(form.is_bound)
self.assertFalse(form.is_valid())
self.assertEqual([_(u'This field is required.'), ],
form['last_name'].errors)
def test_empty_lastname(self):
self.data['last_name'] = ' '
form = SimpleRegistrationForm(self.data)
self.assertTrue(form.is_bound)
self.assertFalse(form.is_valid())
self.assertEqual([_(u'You must provide a last name!'), ],
form['last_name'].errors)
def test_existing_email(self):
self.data['email'] = self.user.email
form = SimpleRegistrationForm(self.data)
self.assertTrue(form.is_bound)
self.assertFalse(form.is_valid())
self.assertEqual([_(u'This email already registered'), ],
form['email'].errors)
def test_passwords_diff(self):
self.data['password1'] = 'qwe'
form = SimpleRegistrationForm(self.data)
self.assertTrue(form.is_bound)
self.assertFalse(form.is_valid())
self.assertEqual([_(u'The password fields did not match'), ],
form.errors['__all__'])
