def setUp(self):
self.staff_user = UserFactory()
group = Group.objects.get(name=CompanyUser.GROUP_NAME)
self.staff_user.groups.add(group)
self.staff_user.save()
self.company = CompanyFactory()
self.company.save()
self.admin = CompanyUserFactory(user=self.staff_user,
company=self.company)
self.admin.save()
self.microsite = MicrositeFactory(company=self.company)
self.microsite.save()
self.client = TestClient()
self.client.login_user(self.staff_user)
self.candidate_user = UserFactory(email="*****@*****.**")
SavedSearchFactory(user=self.candidate_user,
url='http://test.jobs/search?q=django',
label='test Jobs')
self.candidate_user.save()
for i in range(5):
# Create 5 new users
user = UserFactory(email='*****@*****.**' % i)
for search in SEARCH_OPTS:
# Create 15 new searches and assign three per user
SavedSearchFactory(user=user,
url='http://test.jobs/search?q=%s' % search,
label='%s Jobs' % search)
def test_expired_request(self):
"""
Expired requests should not be authenticated.
"""
# required for django admin during tests, apparently
self.user.is_superuser = True
self.user.save()
# give us a handle to the unhashed access code
access_code = '1234ABCD'
requesting_user = UserFactory(email="*****@*****.**")
yesterday = datetime.datetime.now(tz=pytz.UTC) - datetime.timedelta(
days=1)
request = CompanyAccessRequestFactory(
access_code=hashlib.md5(access_code).hexdigest(),
requested_by=requesting_user)
# force the request to be expired
request.requested_on = yesterday
request.save()
self.assertTrue(request.expired)
data = {"company": self.company.pk, "verification_code": access_code}
admin_url = reverse("admin:myjobs_companyaccessrequest_change",
args=(request.pk, ))
response = self.client.post(path=admin_url, data=data, follow=True)
# object is cached so we need to refetch it
access_request = CompanyAccessRequest.objects.get(pk=request.pk)
self.assertEqual(access_request.authorized_by, None)
def test_invitation_emails_unverified_user(self):
"""
Invitations to unverified users should contain activation links, in
addition to the information that admin_invitation tests for.
"""
company = CompanyFactory()
user = UserFactory(email='*****@*****.**', is_verified=False)
body = self.admin_invitation(user, company)
ap = ActivationProfile.objects.get(email=user.email)
# There should be two anchors present, one of which was tested for in
# admin_invitation...
self.assertEqual(len(body.select('a')), 2)
# ...and the remaining anchor should be an activation link.
expected_activation_href = 'https://secure.my.jobs%s?verify=%s' % (
reverse('invitation_activate', args=[ap.activation_key
]), user.user_guid)
self.assertTrue(body.select('a[href="%s"]' % expected_activation_href))
self.client.logout()
# Test the activation link from the email.
self.client.get(expected_activation_href)
# If it was a valid link, the current user should now be verified.
user = User.objects.get(pk=user.pk)
self.assertTrue(user.is_verified)
def test_approval_form_authenticates_request(self):
"""
Submitting a valid authentication code should result in the request
being updated and a new admin being assigned.
"""
# required for django admin during tests, apparently
self.user.is_superuser = True
self.user.save()
# give us a handle to the unhashed access code
access_code = '1234ABCD'
requesting_user = UserFactory(email="*****@*****.**")
request = CompanyAccessRequestFactory(
access_code=hashlib.md5(access_code).hexdigest(),
requested_by=requesting_user)
# code shouldn't have been authorized yet
self.assertFalse(request.authorized_by)
data = {"company": self.company.pk, "verification_code": access_code}
admin_url = "%s%s/" % (reverse(
"admin:myjobs_companyaccessrequest_changelist"), request.pk)
self.client.post(path=admin_url, data=data)
# object is cached so we need to refetch it
access_request = CompanyAccessRequest.objects.get(pk=request.pk)
self.assertEqual(access_request.authorized_by, self.user)
def setUp(self):
super(SavedSearchHelperTests, self).setUp()
self.user = UserFactory()
self.valid_url = 'http://www.my.jobs/search?location=chicago&q=nurse'
self.r = Replacer()
self.r.replace('urllib2.urlopen', return_file)
def test_primary_name_save_multiuser(self):
"""
Saving primary names when multiple users are present accurately
sets and retrieves the correct name
"""
self.user_2 = UserFactory(email='*****@*****.**')
user_2_initial_name = PrimaryNameFactory(user=self.user_2)
user_2_new_name = NewPrimaryNameFactory(user=self.user_2)
initial_name = PrimaryNameFactory(user=self.user)
new_name = NewPrimaryNameFactory(user=self.user)
user_2_initial_name = Name.objects.get(given_name='Alice',
user=self.user_2)
user_2_new_name = Name.objects.get(given_name='Alicia',
user=self.user_2)
initial_name = Name.objects.get(given_name='Alice', user=self.user)
self.assertTrue(new_name.primary)
self.assertFalse(initial_name.primary)
self.assertTrue(user_2_new_name.primary)
self.assertFalse(user_2_initial_name.primary)
with self.assertRaises(MultipleObjectsReturned):
Name.objects.get(primary=True)
Name.objects.get(primary=False)
Name.objects.get(given_name='Alice')
Name.objects.get(given_name='Alicia')
Name.objects.get(primary=True, user=self.user_2)
def setUp(self):
self.user = UserFactory()
self.form = EditAccountForm(user=self.user, data={})
self.context = Context({'form': self.form})
self.template = Template(
'{% load form_tags %}'
'{% add_required_label form.visible_fields.2 %}')
def test_non_staff_user(self):
self.client.logout()
user = UserFactory(email='*****@*****.**')
user.set_password('secret')
self.client.login(username=user.email, password='******')
response = self.client.get(reverse('source_code_upload'))
self.assertTrue('Log in' in response.content)
def test_not_disabled(self):
"""
An anonymous user who provides the :verify: query string or
user with is_disabled set to True should be redirected to the home
page. An anonymous user who does not should see a 404. A user with
is_active set to False should proceed to their destination.
"""
client = TestClient()
user = UserFactory(email="*****@*****.**")
# Anonymous user
resp = client.get(reverse('view_profile'))
path = resp.request.get('PATH_INFO')
self.assertRedirects(resp, reverse('home') + '?next=' + path)
# This is ugly, but it is an artifact of the way Django redirects
# users who fail the `user_passes_test` decorator.
qs = '?verify=%s' % user.user_guid
next_qs = '?next=' + urlquote('/profile/view/%s' % qs)
# Anonymous user navigates to url with :verify: in query string
resp = client.get(reverse('view_profile') + qs)
# Old path + qs is urlquoted and added to the url as the :next: param
self.assertRedirects(resp, "http://testserver/" + next_qs)
# Active user
client.login_user(user)
resp = client.get(reverse('view_profile'))
self.assertTrue(resp.status_code, 200)
# Disabled user
user.is_disabled = True
user.save()
resp = client.get(reverse('view_profile'))
self.assertRedirects(resp, "http://testserver/?next=/profile/view/")
def test_user_only_linked_to_contact_after_pss_created(self):
"""
A contact who's email so happens to coincide with an existing user's
should not be attached to that user until after a partner saved search
is created for it.
"""
# we don't have a saved search, so the contact shouldn't be associated
# with a user
contact = ContactFactory(user=None,
email="*****@*****.**",
partner=self.partner)
user = UserFactory(email=contact.email)
self.assertFalse(contact.user)
self.partner_search_data['email'] = contact.email
form = PartnerSavedSearchForm(partner=self.partner,
data=self.partner_search_data,
request=self.request)
instance = form.instance
instance.provider = self.company
instance.partner = self.partner
instance.created_by = self.user
instance.custom_message = instance.partner_message
self.assertTrue(form.is_valid())
form.save()
# after the saved search was created, the user should have been
# associated automatically
contact = Contact.objects.get(id=contact.id)
self.assertTrue(contact.user)
def setUp(self):
super(MySearchViewTests, self).setUp()
self.client = TestClient()
self.user = UserFactory()
self.client.login_user(self.user)
self.new_form_data = {
'url': 'www.my.jobs/jobs',
'feed': 'http://www.my.jobs/jobsfeed/rss?',
'label': 'Jobs Label',
'email': self.user.email,
'frequency': 'D',
'is_active': 'True',
'sort_by': 'Relevance',
}
self.new_digest_data = {
'is_active': 'True',
'user': self.user,
'email': self.user.email,
'frequency': 'M',
'day_of_month': 1,
}
self.new_form = forms.SavedSearchForm(user=self.user,
data=self.new_form_data)
self.r = Replacer()
self.r.replace('urllib2.urlopen', return_file)
def test_bad_events_deactivate_user(self):
now = datetime.datetime.now()
for event in STOP_SENDING + BAD_EMAIL:
u = UserFactory(email="*****@*****.**",
is_verified=True, opt_in_myjobs=True)
self.make_email_logs(u.email, event, now, False, 3)
process_batch_events()
u = User.objects.get(pk=u.pk)
self.assertEqual(u.deactivate_type, event)
# Users start this test case with is_verified=True
# is_verified should only change if the modifying event
# is a block or drop
self.assertEqual(u.is_verified, event in STOP_SENDING)
self.assertFalse(u.opt_in_myjobs)
infos = u.messageinfo_set.all()
self.assertEqual(len(infos), 1)
message = infos[0].message
if u.deactivate_type in STOP_SENDING:
text = 'stop communications'
else:
text = 'Attempts to send messages to'
self.assertTrue(text in message.body)
EmailLog.objects.all().delete()
u.delete()
def setUp(self):
self.user = UserFactory()
self.auth_callback_url = 'https://secure.my.jobs/account'
self.auth_callback = '?auth_callback=%s' % self.auth_callback_url
self.key_qs = '%s&key=%s'
self.client = TestClient()
self.client.login_user(self.user)
def setUp(self):
self.user = UserFactory()
self.client = TestClient()
create_api_key(User, instance=self.user, created=True)
self.data = {'email': '*****@*****.**',
'username': self.user.email,
'api_key': self.user.api_key.key
}
def setUp(self):
super(MyJobsHelpersTests, self).setUp()
self.user = UserFactory()
self.client = TestClient()
self.login_params = {
'username': '******',
'password': '******',
'action': 'login'
}
def test_group_status(self):
"""
Should return True if user is assigned a role for at least one company.
This method will hopefully be deprecated soon.
"""
user = UserFactory(email="*****@*****.**")
self.assertFalse(User.objects.is_group_member(user, "dummy"))
user.roles.add(self.role)
self.assertTrue(User.objects.is_group_member(user, "dummy"))
def test_message_made_sent_to_multiple(self):
"""
Test that one message can be received by multiple users.
"""
user = UserFactory(email="*****@*****.**")
user.groups.add(Group.objects.get(id=1))
user.claim_messages()
self.assertEqual(Message.objects.count(), 1)
self.assertEqual(MessageInfo.objects.count(), 2)
self.assertEqual(self.message, self.user.messageinfo_set.get().message)
def test_message_made_sent_to_multiple(self):
m = Message.objects.all().count()
UserFactory(email="*****@*****.**")
n_u = User.objects.get(email="*****@*****.**")
n_u.groups.add(Group.objects.get(id=1).pk)
n_u.save()
n_u.messages_unread()
message_info = MessageInfo.objects.all().count()
self.assertEqual(m, 1)
self.assertEqual(message_info, 2)
def test_raise_error_if_email_is_already_taken(self):
"""
Verifies that if the email provided belongs to a user that is not
signed in, an error is raised from user_creation_retrieval
"""
UserFactory(email="*****@*****.**")
with self.assertRaises(ValueError,
msg="ValueError should have raised!"
" Email provided was in use."):
user_creation_retrieval(self.user, "*****@*****.**")
def test_login_fail(self):
password = '******'
user = UserFactory(password=password)
block = LoginBlock.objects.get()
data = {
'username': user.email,
'password': '******',
block.submit_btn_name(): ''
}
response = self.client.post(reverse('login'), data=data, follow=True)
self.assertFalse(response.context['request'].user.is_authenticated())
def setUp(self):
super(SavedSearchResourceTests, self).setUp()
self.user = UserFactory()
self.client = TestClient()
self.data = {'email':'*****@*****.**', 'url':'www.my.jobs/jobs'}
create_api_key(User, instance=self.user, created=True)
self.credentials = (self.user.email, self.user.api_key.key)
self.r = Replacer()
self.r.replace('urllib2.urlopen', return_file)
def setUp(self):
super(RemoteAccessRequestModelTests, self).setUp()
self.password = '******'
self.client = TestClient()
self.client.login(email=self.user.email, password=self.password)
self.account_owner = UserFactory(email='*****@*****.**',
password=self.password)
self.impersonate_url = reverse('impersonate-start',
kwargs={'uid': self.account_owner.pk})
self.site = SeoSite.objects.first()
def test_unsubscribe_unowned_search(self):
"""
Attempting to unsubscribe using a search that isn't yours
should result in nothing happening to the search
"""
user = UserFactory(email='*****@*****.**')
search = SavedSearchFactory(user=user)
response = self.client.get(reverse('unsubscribe')+'?id=%s' % search.id)
search = models.SavedSearch.objects.get(id=search.id)
self.assertTrue(search.is_active)
self.assertEqual(response.status_code, 404)
def setUp(self):
self.user = UserFactory()
self.message = Message(subject='subject',
body='body',
message_type='success')
self.message.save()
for group in Group.objects.all():
self.message.group.add(group.pk)
self.message.save()
self.messageInfo = MessageInfo(user=User.objects.get(id=1),
message=self.message)
self.messageInfo.save()
def test_delete_user(self):
"""
Tests deleting a user
"""
new_user = UserFactory(email='*****@*****.**',
roles=self.user.roles.all())
response = self.client.delete(reverse('api_remove_user',
args=[self.user.pk]))
output = json.loads(response.content)
self.assertEqual(output['errors'], [])
def test_delete_unowned_search(self):
"""
Attempting to delete a search that isn't yours should
result in nothing happening to the search
"""
user = UserFactory(email='*****@*****.**')
search = SavedSearchFactory(user=user)
response = self.client.get(
reverse('delete_saved_search') + '?id=%s' % search.id)
self.assertEqual(models.SavedSearch.objects.count(), 1)
self.assertEqual(response.status_code, 404)
def test_login(self):
password = '******'
user = UserFactory(password=password)
block = LoginBlock.objects.get()
data = {
'username': user.email,
'password': password,
block.submit_btn_name(): ''
}
response = self.client.post(reverse('login'), data=data, follow=True)
self.assertTrue(response.context['request'].user.is_authenticated())
last_redirect = response.redirect_chain[-1][0]
self.assertTrue(last_redirect.endswith(reverse('home')))
def test_partner_saved_search_form_from_instance(self):
user = UserFactory(email='*****@*****.**')
ContactFactory(user=user, partner=self.partner)
partner_saved_search = PartnerSavedSearchFactory(
created_by=self.staff_user,
provider=self.company,
partner=self.partner,
user=user,
notes='')
response = self.client.get(
reverse('partner_edit_search') + '?partner=%s&id=%s' %
(self.partner.pk, partner_saved_search.pk))
self.assertTrue(partner_saved_search.feed in response.content)
def setUp(self):
super(MyJobsAdminTests, self).setUp()
self.user.set_password('5UuYquA@')
self.user.is_superuser = True
self.user.save()
self.account_owner = UserFactory(email='*****@*****.**')
SeoSiteFactory(domain='secure.my.jobs')
mail.outbox = []
self.data = {
'_selected_action': [unicode(self.account_owner.pk)],
'action': 'request_account_access'
}
def test_partner_saved_search_delete_contact(self):
"""
When a contact gets deleted, we should log it and disable any partner
saved searches for that contact
"""
user = UserFactory(email='*****@*****.**')
self.contact.user = user
self.contact.save()
self.contact = Contact.objects.get(pk=self.contact.pk)
owner = UserFactory(email='*****@*****.**')
partner_saved_search = PartnerSavedSearchFactory(created_by=owner,
provider=self.company,
partner=self.partner,
user=user,
notes='')
self.assertTrue(partner_saved_search.is_active)
self.contact.delete()
partner_saved_search = PartnerSavedSearch.objects.get(
pk=partner_saved_search.pk)
self.assertFalse(partner_saved_search.is_active)
self.assertTrue(self.contact.name in partner_saved_search.notes)
