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_search_updates_facet_counts(self):
# Add ProfileData to the candidate_user
EducationFactory(user=self.candidate_user)
AddressFactory(user=self.candidate_user)
LicenseFactory(user=self.candidate_user)
self.candidate_user.save()
# Create a new user with ProfileData
user = UserFactory(email="*****@*****.**")
SavedSearchFactory(user=user,
url='http://test.jobs/search?q=python',
feed='http://test.jobs/jobs/feed/rss?',
label='Python Jobs')
EducationFactory(user=user)
AddressFactory(user=user)
LicenseFactory(user=user)
user.save()
update_solr_task(settings.TEST_SOLR_INSTANCE)
# Assert there are two users with country codes
country_tag = '#Country-details-table .facet-count'
q = '?company={company}'
q = q.format(company=str(self.company.id))
response = self.client.post(reverse('dashboard') + q)
soup = BeautifulSoup(response.content)
self.assertEqual(int(soup.select(country_tag)[0].text), 2)
# When we search, the facet count updates.
q = '?company={company}&search={search}'
q = q.format(company=str(self.company.id), search='find')
response = self.client.post(reverse('dashboard') + q)
soup = BeautifulSoup(response.content)
self.assertEqual(int(soup.select(country_tag)[0].text), 1)
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()
#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_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()
class SavedSearchDeletionTests(MyJobsBase):
# Creating an entire test class for this is kind of overkill but it doesn't
# fit with any of the others.
def setUp(self):
super(SavedSearchDeletionTests, self).setUp()
self.user = UserFactory()
self.creator = UserFactory(email='*****@*****.**')
self.search = SavedSearchFactory(user=self.user)
self.partner_search = PartnerSavedSearchFactory(user=self.user,
created_by=self.creator)
def test_deletion_and_preservation(self):
"""
When a user is deleted, that user's saved searches should be deleted.
Partner saved searches should be left alone with the exception of
nullifying the recipient.
"""
mail.outbox = []
self.assertEqual(MessageInfo.objects.count(), 0)
self.user.delete()
with self.assertRaises(SavedSearch.DoesNotExist):
SavedSearch.objects.get(pk=self.search.pk)
SavedSearch.objects.get(pk=self.partner_search.pk)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(MessageInfo.objects.count(), 1)
class SavedSearchTemplateTagTests(MyJobsBase):
def setUp(self):
super(SavedSearchTemplateTagTests, self).setUp()
self.user = UserFactory(is_active=True)
self.search = SavedSearchFactory(user=self.user)
def test_confirm_creation_active_user(self):
expected = reverse('view_full_feed') + '?id={id}&verify={guid}'.format(
id=self.search.pk, guid=self.user.user_guid)
actual = get_created_url(self.search)
self.assertEqual(actual, expected)
def test_confirm_creation_inactive_user(self):
self.user.is_active = False
self.user.save()
user_with_profile = UserFactory(email='*****@*****.**',
is_active=False)
profile_search = SavedSearchFactory(user=user_with_profile)
ActivationProfile.objects.create(user=user_with_profile,
email=user_with_profile.email)
for saved_search in [self.search, profile_search]:
actual = get_created_url(saved_search)
profile = ActivationProfile.objects.get(user=saved_search.user)
expected = reverse('registration_activate',
args=[profile.activation_key]) + \
'?verify={guid}'.format(guid=saved_search.user.user_guid)
self.assertEqual(actual, expected)
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)
class NewUserTests(SeleniumTestCase):
"""Tests Account creation"""
def setUp(self):
self.user = UserFactory(first_name="John", last_name="Doe")
def test_home_page_works(self):
"""
As John, navigating to https://secure.my.jobs should send me to a page
titled "My.jobs".
"""
self.browser.get(self.live_server_url)
self.assertIn(self.browser.title, 'My.jobs')
def test_cant_log_in_without_account(self):
"""
As John, I shouldn't be able to log into My.jobs without registering
first.
"""
self.browser.get('/'.join([self.live_server_url, 'prm', 'view']))
# attempt to log in
username = self.find('id_username')
username.send_keys(self.user.email)
self.find('id_password').send_keys(self.user.password)
self.find('login').click()
self.assertEqual(username.get_attribute('placeholder'),
'Please enter a correct email.')
def test_user_registration(self):
"""
As John, I should be able to register on My.jobs and log in.
"""
user = UserFactory.build(email='*****@*****.**')
self.browser.get('/'.join([self.live_server_url, 'prm', 'view']))
# register
self.find('id_email').send_keys(user.email)
self.find('id_password1').send_keys(user.password)
self.find('id_password2').send_keys(user.password)
self.find('register').click()
self.assertEqual(self.find('profile').get_attribute(
'innerHTML'),
'Skip: Take me to my profile')
def test_user_login(self):
self.user.set_password("test")
self.user.save()
self.find('id_username').send_keys(self.user.email)
self.find('id_password').send_keys("test")
self.find('login').click()
class MessageManagerTests(MyJobsBase):
def setUp(self):
super(MessageManagerTests, self).setUp()
self.user = UserFactory()
self.user.groups.add(Group.objects.get(pk=1))
def test_create_message_by_group(self):
message = Message.objects.create_message(
subject='subject', body='message body',
groups=Group.objects.all())
self.user.claim_messages()
infos = self.user.messageinfo_set.all()
self.assertEqual(len(infos), 1)
self.assertEqual(infos[0].message, message)
def test_create_message_creates_messageinfo(self):
message = Message.objects.create_message(
users=self.user, subject='subject', body='message body')
infos = MessageInfo.objects.all()
self.assertEqual(infos.count(), 1)
self.assertEqual(infos[0].user, self.user)
self.assertEqual(infos[0].message, message)
def test_create_message_with_users_and_groups(self):
new_user = UserFactory(email='*****@*****.**')
message = Message.objects.create_message(
users=new_user, subject='subject', body='message body',
groups=Group.objects.get(pk=1))
[user.claim_messages() for user in [new_user, self.user]]
get_messages = lambda u: list(u.message_set.all())
group_user_messages = get_messages(self.user)
new_user_messages = get_messages(new_user)
self.assertEqual(group_user_messages, new_user_messages)
self.assertEqual(len(group_user_messages), 1)
self.assertEqual(group_user_messages[0], message)
def test_create_message_sets_expiration(self):
message = Message.objects.create_message(
subject='subject', body='message body',
groups=Group.objects.get(pk=1), expires=False)
self.assertTrue(message.expire_at is None)
self.user.claim_messages()
info = self.user.messageinfo_set.first()
self.assertFalse(info.expired_time())
def test_activities(self):
"""
`User.get_activities(company)` should return a list of activities
associated with this user and company.
"""
user = UserFactory(email="*****@*****.**")
self.assertItemsEqual(user.get_activities(self.company), [])
user.roles.add(self.role)
activities = self.role.activities.values_list('name', flat=True)
self.assertItemsEqual(user.get_activities(self.company), activities)
def test_deleting_user_does_not_cascade(self):
"""
Deleting a user shouldn't delete related objects such as partner saved
searches and reports.
"""
user = UserFactory(email="*****@*****.**")
company = CompanyFactory()
pss = PartnerSavedSearchFactory(created_by=user)
report = Report.objects.create(created_by=user, owner=company)
user.delete()
self.assertIn(pss, PartnerSavedSearch.objects.all())
self.assertIn(report, Report.objects.all())
def test_gravatar_url(self):
"""
Test that email is hashed correctly and returns a 200 response
"""
user = UserFactory()
gravatar_url = "http://www.gravatar.com/avatar/c160f8cc69a4f0b" \
"f2b0362752353d060?s=20&d=mm"
no_gravatar_url = ("<div class='gravatar-blank gravatar-danger' "
"style='height: 20px; width: 20px'>"
"<span class='gravatar-text' "
"style='font-size:13.0px;'>A</span></div>")
generated_gravatar_url = user.get_gravatar_url()
self.assertEqual(no_gravatar_url, generated_gravatar_url)
status_code = urllib.urlopen(gravatar_url).getcode()
self.assertEqual(status_code, 200)
class RedirectMiddlewareTests(MyJobsBase):
def setUp(self):
super(RedirectMiddlewareTests, self).setUp()
self.user = UserFactory()
self.redirect_middleware = PasswordChangeRedirectMiddleware()
self.request_factory = RequestFactory()
def test_logged_in_no_redirect(self):
"""
A logged in user whose password_change flag is not set
should proceed to their original destination
"""
request = self.request_factory.get(reverse('edit_account'))
request.user = self.user
response = self.redirect_middleware.process_request(request)
self.assertEqual(response, None)
def test_logged_in_autocreated_user_redirects(self):
"""
A logged in user whose password_change flag is set should
be redirected to the password change form
"""
self.user.password_change = True
self.user.save()
request = self.request_factory.get(reverse('saved_search_main'))
request.user = self.user
response = self.redirect_middleware.process_request(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.get('location'),
reverse('edit_account')+"#as-password")
def test_not_logged_in_returns_forbidden(self):
"""
An anonymous user that tries to post to a private url should
receive a 403 Forbidden status
"""
request = self.request_factory.get(reverse('saved_search_main'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
new_request = request.GET.copy()
new_request['next'] = reverse('home')
request.GET = new_request
request.REQUEST.dicts = (new_request, request.POST)
request.user = AnonymousUser()
response = self.redirect_middleware.process_request(request)
self.assertEqual(response.status_code, 403)
def setUp(self):
super(AdminTests, self).setUp()
self.site = AdminSite()
settings.SITE = SeoSite.objects.first()
self.request = RequestFactory().get("/")
self.user = UserFactory(is_superuser=True)
self.request.user = self.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',
'jobs_per_email': 5,
'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.patcher = patch('urllib2.urlopen', return_file())
self.patcher.start()
class AccountFormTests(MyJobsBase):
def setUp(self):
super(AccountFormTests, self).setUp()
self.user = UserFactory()
self.name = PrimaryNameFactory(user=self.user)
def test_password_form(self):
invalid_data = [
{ 'data': {'password': '******',
'new_password1': '7dY=Ybtk',
'new_password2': '7dY=Ybtk'},
u'errors': [['password', [u"Wrong password."]]]},
{ 'data': {'password': '******',
'new_password1': '7dY=Ybtk',
'new_password2': 'notnewpassword'},
u'errors':
[[u'new_password2', [u'The new password fields did not match.']],
[u'new_password1', [u'The new password fields did not match.']]],
},
]
for item in invalid_data:
form = ChangePasswordForm(user=self.user, data=item['data'])
self.failIf(form.is_valid())
self.assertEqual(form.errors[item[u'errors'][0][0]],
item[u'errors'][0][1])
form = ChangePasswordForm(user=self.user,data={'password': '******',
'new_password1': '7dY=Ybtk',
'new_password2': '7dY=Ybtk'})
self.failUnless(form.is_valid())
form.save()
self.failUnless(self.user.check_password('7dY=Ybtk'))
def setUp(self):
super(EmailForwardTests, self).setUp()
self.redirect_guid = JOB['guid']
self.redirect = RedirectFactory(buid=JOB['buid'],
guid='{%s}' %
uuid.UUID(self.redirect_guid))
self.password = '******'
self.user = UserFactory(email='*****@*****.**')
self.user.set_password(self.password)
self.user.save()
self.contact = CompanyEmail.objects.create(
buid=self.redirect.buid,
email=self.user.email)
self.email = self.user.email.replace('@', '%40')
self.auth = {
'bad': [
'',
'Basic %s' % base64.b64encode('bad%40email:wrong_pass')],
'good':
'Basic %s' % base64.b64encode('%s:%s' % (self.user.email.\
replace('@', '%40'),
self.password))}
self.post_dict = {'to': '*****@*****.**',
'from': '*****@*****.**',
'text': 'Questions about stuff',
'html': '<b>Questions about stuff</b>',
'subject': 'Bad Email',
'attachments': 0}
self.r = Replacer()
self.r.replace('pysolr.Solr.search', mock_search)
def setUp(self):
super(MyDashboardViewsTests, self).setUp()
group = Group.objects.get(name=CompanyUser.GROUP_NAME)
self.user.groups.add(group)
self.business_unit = BusinessUnitFactory()
self.company.job_source_ids.add(self.business_unit)
self.admin = CompanyUserFactory(user=self.user,
company=self.company)
self.microsite = SeoSiteFactory()
self.microsite.business_units.add(self.business_unit)
self.candidate_user = UserFactory(email="*****@*****.**")
SavedSearchFactory(user=self.candidate_user,
feed='http://test.jobs/jobs/feed/rss?',
url='http://test.jobs/search?q=django',
label='test Jobs')
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,
feed='http://test.jobs/jobs/feed/rss?',
label='%s Jobs' % search)
update_solr_task(settings.TEST_SOLR_INSTANCE)
def setUp(self):
super(PartnerSavedSearchTests, self).setUp()
self.user = UserFactory()
self.digest = SavedSearchDigestFactory(user=self.user)
self.company = CompanyFactory()
self.partner = PartnerFactory(owner=self.company)
self.contact = ContactFactory(user=self.user,
partner=self.partner)
self.partner_search = PartnerSavedSearchFactory(user=self.user,
created_by=self.user,
provider=self.company,
partner=self.partner)
# Partner searches are normally created with a form, which creates
# invitations as a side effect. We're not testing the form, so we
# can fake an invitation here.
Invitation(invitee_email=self.partner_search.email,
invitee=self.partner_search.user,
inviting_user=self.partner_search.created_by,
inviting_company=self.partner_search.partner.owner,
added_saved_search=self.partner_search).save()
self.patcher = patch('urllib2.urlopen', return_file())
self.mock_urlopen = self.patcher.start()
self.num_occurrences = lambda text, search_str: [match.start()
for match
in re.finditer(
search_str, text)]
# classes and ids may get stripped out when pynliner inlines css.
# all jobs contain a default (blank) icon, so we can search for that if
# we want a job count
self.job_icon = 'http://png.nlx.org/100x50/logo.gif'
def setUp(self):
super(SavedSearchHelperTests, self).setUp()
self.user = UserFactory()
self.valid_url = 'http://www.my.jobs/jobs?location=chicago&q=nurse'
self.patcher = patch('urllib2.urlopen', return_file())
self.patcher.start()
def setUp(self):
super(SavedSearchDeletionTests, self).setUp()
self.user = UserFactory()
self.creator = UserFactory(email='*****@*****.**')
self.search = SavedSearchFactory(user=self.user)
self.partner_search = PartnerSavedSearchFactory(user=self.user,
created_by=self.creator)
def test_search_domain(self):
"""We should be able to search for domain."""
user = UserFactory(email="*****@*****.**")
SavedSearchFactory(user=user,
url='http://test.jobs/search?q=python',
feed='http://test.jobs/jobs/feed/rss?',
label='Python Jobs')
user.save()
update_solr_task(settings.TEST_SOLR_INSTANCE)
q = '?company={company}&search={search}'
q = q.format(company=str(self.company.id), search='shouldWork.com')
url = reverse('dashboard') + q
response = self.client.post(url)
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select('#row-link-table tr')), 1)
class MyReportsTestCase(TestCase):
"""
Base class for all MyReports Tests. Identical to `django.test.TestCase`
except that it provides a MyJobs TestClient instance and a logged in user.
"""
def setUp(self):
self.client = TestClient()
self.user = UserFactory(email='*****@*****.**')
self.user.set_password('aa')
self.company = CompanyFactory(name='Test Company')
self.partner = PartnerFactory(name='Test Partner', owner=self.company)
# associate company to user
CompanyUserFactory(user=self.user, company=self.company)
self.client.login_user(self.user)
create_full_fixture()
def test_inactive_user_sees_message(self):
"""
A user with is_verified or is_active set to False should see an
activation message instead of the content they were originally meaning
to see.
"""
client = TestClient(path=reverse('saved_search_main'))
user = UserFactory()
# Active user
client.login_user(user)
resp = client.get()
self.assertIn('Saved Search', resp.content)
# Inactive user
user.is_verified= False
user.save()
resp = client.get()
self.assertIn('unavailable', resp.content)
def test_is_active(self):
"""
A user with is_active set to False should be redirected to the home
page, while a user with is_active set to True should proceed to their
destination.
"""
client = TestClient()
user = UserFactory()
quoted_email = urllib.quote(user.email)
# Active user
client.login_user(user)
resp = client.get(reverse('saved_search_main'))
self.assertTrue(resp.status_code, 200)
# Inactive user
user.is_active = False
user.save()
resp = client.get(reverse('saved_search_main'))
self.assertRedirects(resp, "http://testserver/?next=/saved-search/view/")
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_can_method_with_app_access(self):
"""
``User.can`` should return False when a user isn't associated with the
correct activities and True when they are.
"""
user = UserFactory(email="*****@*****.**", roles=[self.role])
self.role.activities = self.activities
activities = self.role.activities.values_list('name', flat=True)
# check for a single activity
self.assertTrue(user.can(self.company, activities[0]))
self.assertFalse(user.can(self.company, "eat a burrito"))
# check for multiple activities
self.assertTrue(user.can(self.company, *activities))
self.assertFalse(user.can(
self.company, activities[0], "eat a burrito"))
class AdminTests(MyJobsBase):
def setUp(self):
super(AdminTests, self).setUp()
self.site = AdminSite()
settings.SITE = SeoSite.objects.first()
self.request = RequestFactory().get("/")
self.user = UserFactory(is_superuser=True)
self.request.user = self.user
def test_admin_request_form(self):
"""
The forms used by ValueEventAdmin and CronEventAdmin should have the
current request as attributes.
"""
for Admin, Model in [(ValueEventAdmin, ValueEvent), (CronEventAdmin, CronEvent)]:
admin = Admin(Model, self.site)
form = admin.get_form(self.request)()
self.assertEqual(form.request, self.request)
def test_non_superuser_form(self):
"""
The email_template queryset should have an appropriate WHERE clause
if the current user is not a company user.
"""
company = CompanyUserFactory(user=self.user).company
admin = ValueEventAdmin(ValueEvent, self.site)
for superuser in [True, False]:
self.user.is_superuser = superuser
self.user.save()
form = admin.get_form(self.request)()
email_template = form.fields["email_template"]
query = str(email_template.queryset.query)
if superuser:
self.assertFalse("WHERE" in query)
else:
if connection.vendor == "sqlite":
test = 'WHERE ("myemails_emailtemplate"."owner_id" = %s'
else:
test = "WHERE (`myemails_emailtemplate`.`owner_id` = %s"
self.assertTrue(test % company.pk in query)
def setUp(self):
super(MyJobsViewsTests, self).setUp()
self.user = UserFactory()
self.client = TestClient()
self.client.login_user(self.user)
self.events = ['open', 'delivered', 'click']
self.email_user = UserFactory(email='*****@*****.**')
self.auth = '%s:%s' % (settings.SENDGRID_BATCH_POST_USER,
settings.SENDGRID_BATCH_POST_PASSWORD)
self.auth = base64.b64encode(self.auth)
def test_contact_user_relationship(self):
"""
Tests adding a User to Contact. Then tests to make sure User cascading
delete doesn't delete the Contact and instead turns Contact.user to
None.
"""
self.contact.user = UserFactory(email=self.contact.email)
self.contact.save()
self.assertIsNotNone(self.contact.user)
self.assertEqual(self.contact.name, self.contact.__unicode__())
user = User.objects.get(email=self.contact.email)
user.delete()
contact = Contact.objects.get(name=self.contact.name)
self.assertIsNone(contact.user)
def test_send_link_respects_permissions(self):
# The send_saved_search view requires that DEBUG be enabled.
settings.DEBUG = True
self.user.is_superuser = True
self.user.save()
search = SavedSearchFactory(user=self.user)
search_2 = SavedSearchFactory(user=UserFactory(email='*****@*****.**'))
send_url = reverse('send_saved_search') + '?id=%s'
self.assertEqual(len(mail.outbox), 0)
response = self.client.get(send_url % search.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(len(mail.outbox), 1)
response = self.client.get(send_url % search_2.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(len(mail.outbox), 2)
settings.DEBUG = False
def setUp(self):
super(MyJobsBase, self).setUp()
settings.ROOT_URLCONF = "myjobs_urls"
settings.PROJECT = "myjobs"
self.app_access = AppAccessFactory()
self.activities = [
ActivityFactory(name=activity, app_access=self.app_access)
for activity in [
"create communication record", "create contact",
"create partner saved search", "create partner", "create role",
"create tag", "create user", "delete tag", "delete partner",
"delete role", "delete user", "read contact",
"read communication record", "read partner saved search",
"read partner", "read role", "read user", "read tag",
"update communication record", "update contact",
"update partner", "update role", "update tag", "update user",
"read outreach email address", "create outreach email address",
"delete outreach email address",
"update outreach email address", "read outreach record",
"convert outreach record", "view analytics"
]
]
self.company = CompanyFactory(app_access=[self.app_access])
# this role will be populated by activities on a test-by-test basis
self.role = RoleFactory(company=self.company, name="Admin")
self.user = UserFactory(roles=[self.role], is_staff=True)
cache.clear()
clear_url_caches()
self.ms_solr = Solr(settings.SOLR['seo_test'])
self.ms_solr.delete(q='*:*')
self.base_context_processors = settings.TEMPLATE_CONTEXT_PROCESSORS
context_processors = self.base_context_processors + (
'mymessages.context_processors.message_lists', )
setattr(settings, 'TEMPLATE_CONTEXT_PROCESSORS', context_processors)
setattr(settings, 'MEMOIZE', False)
self.patcher = patch('urllib2.urlopen', return_file())
self.mock_urlopen = self.patcher.start()
self.client = TestClient()
self.client.login_user(self.user)
def test_api_returns_error_if_email_is_taken(self):
"""
Verifies that the secure saved searched API returns an error if the
provided email is taken by another user
"""
taken_email = '*****@*****.**'
UserFactory(email=taken_email)
request_data = {'email': taken_email, 'url': self.child_url}
response = make_cors_request(self.client,
self.secure_ss_url,
json.dumps(request_data),
http_origin="http://%s" % self.domain)
response_msg = json.loads(response.content)
self.assertTrue(response_msg['error'],
msg="Expected an error but none raised! API returned"
": %s" % response_msg['error'])
self.assertFalse(response_msg['search_activated'])
def test_confirm_creation_inactive_user(self):
self.user.is_active = False
self.user.save()
user_with_profile = UserFactory(email='*****@*****.**',
is_active=False)
profile_search = SavedSearchFactory(user=user_with_profile)
ActivationProfile.objects.create(user=user_with_profile,
email=user_with_profile.email)
for saved_search in [self.search, profile_search]:
actual = get_created_url(saved_search)
profile = ActivationProfile.objects.get(user=saved_search.user)
expected = reverse('registration_activate',
args=[profile.activation_key]) + \
'?verify={guid}'.format(guid=saved_search.user.user_guid)
self.assertEqual(actual, expected)
def test_delete_all_searches(self):
"""
Deleting all searches should only remove regular saved searches if the
partner saved searches weren't created by the user trying to use it.
"""
user = UserFactory(email='*****@*****.**')
company = CompanyFactory(id=2423, name="Bacon Factory",
user_created=False)
SavedSearchFactory(user=self.user)
pss = PartnerSavedSearchFactory(user=self.user, created_by=user,
provider=company)
response = self.client.get(reverse('delete_saved_search') +
'?id=ALL')
self.assertEqual(response.status_code, 302)
# partner saved search should still exist...
self.assertTrue(models.PartnerSavedSearch.objects.filter(
pk=pss.pk).exists())
# ... but the regular saved search shouldn't
self.assertFalse(models.SavedSearch.objects.filter(
partnersavedsearch__isnull=True).exists())
def test_can_method_with_app_access(self):
"""
``User.can`` should return False when a user isn't associated with the
correct activities and True when they are.
"""
user = UserFactory(email="*****@*****.**", roles=[self.role])
self.role.activities = self.activities
activities = self.role.activities.values_list('name', flat=True)
# check for a single activity
self.assertTrue(user.can(self.company, activities[0]))
self.assertFalse(user.can(self.company, "eat a burrito"))
# check for multiple activities
self.assertTrue(user.can(self.company, *activities))
self.assertFalse(user.can(self.company, activities[0],
"eat a burrito"))
def setUp(self):
super(TestContactsDataSource, self).setUp()
# A company to work with
self.company = CompanyFactory(name='right')
self.company.save()
# A separate company that should not show up in results.
self.other_company = CompanyFactory(name='wrong')
self.other_company.save()
self.partner = PartnerFactory(owner=self.company)
self.other_partner = PartnerFactory(owner=self.other_company)
self.partner_a = PartnerFactory(owner=self.company, name="aaa")
self.partner_b = PartnerFactory(owner=self.company, name="bbb")
# An unapproved parther. Associated data should be filtered out.
self.partner_unapp = PartnerFactory(
owner=self.company,
name="unapproved",
approval_status__code=Status.UNPROCESSED)
# An archived parther. Associated data should be filtered out.
self.partner_archived = PartnerFactory(owner=self.company)
self.east_tag = TagFactory.create(company=self.company,
name='east',
hex_color="aaaaaa")
self.west_tag = TagFactory.create(company=self.company,
name='west',
hex_color="bbbbbb")
self.left_tag = TagFactory.create(company=self.company,
name='left',
hex_color="cccccc")
self.right_tag = TagFactory.create(company=self.company,
name='right',
hex_color="dddddd")
self.bad_tag = TagFactory.create(company=self.company,
name='bad',
hex_color="cccccc")
self.partner_a.tags.add(self.left_tag)
self.partner_b.tags.add(self.right_tag)
self.john_user = UserFactory(email="*****@*****.**")
self.john = ContactFactory(partner=self.partner_a,
name='john adams',
user=self.john_user,
email="*****@*****.**",
last_action_time='2015-10-03')
self.john.locations.add(
LocationFactory.create(city="Indianapolis", state="IN"))
self.john.locations.add(
LocationFactory.create(city="Chicago", state="IL"))
self.john.tags.add(self.east_tag)
self.sue_user = UserFactory(email="*****@*****.**")
self.sue = ContactFactory(partner=self.partner_b,
name='Sue Baxter',
user=self.sue_user,
email="*****@*****.**",
last_action_time='2015-09-30 13:23')
self.sue.locations.add(
LocationFactory.create(address_line_one="123",
city="Los Angeles",
state="CA"))
self.sue.locations.add(
LocationFactory.create(address_line_one="234",
city="Los Angeles",
state="CA"))
self.sue.tags.add(self.west_tag)
# Poision data. Should never show up.
self.archived_partner_user = (UserFactory(
email="*****@*****.**"))
self.archived_partner = ContactFactory(
partner=self.partner_archived,
name='Archived Partner Contact',
user=self.archived_partner_user,
email="*****@*****.**",
last_action_time='2015-09-30 13:23')
self.archived_partner.locations.add(
LocationFactory.create(address_line_one="123",
city="Nowhere",
state="NO"))
self.archived_partner.locations.add(
LocationFactory.create(address_line_one="234",
city="Nowhere",
state="NO"))
self.archived_partner.tags.add(self.west_tag)
# Poision data. Should never show up.
self.archived_contact_user = (UserFactory(
email="*****@*****.**"))
self.archived_contact = ContactFactory(
partner=self.partner_b,
name='Archived Contact',
user=self.archived_contact_user,
email="*****@*****.**",
last_action_time='2015-09-30 13:23')
self.archived_contact.locations.add(
LocationFactory.create(address_line_one="123",
city="Nowhere",
state="NO"))
self.archived_contact.locations.add(
LocationFactory.create(address_line_one="234",
city="Nowhere",
state="NO"))
self.archived_contact.tags.add(self.west_tag)
# Poision data. Should never show up.
self.unapproved_partner_user = (UserFactory(
email="*****@*****.**"))
self.unapproved_partner_contact = ContactFactory(
partner=self.partner_unapp,
name='Unapproved Partner Contact',
user=self.unapproved_partner_user,
email="*****@*****.**",
last_action_time='2015-09-30 13:23')
self.unapproved_partner_contact.locations.add(
LocationFactory.create(address_line_one="123",
city="Nowhere",
state="NO"))
self.unapproved_partner_contact.locations.add(
LocationFactory.create(address_line_one="234",
city="Nowhere",
state="NO"))
self.unapproved_partner_contact.tags.add(self.west_tag)
# Poision data. Should never show up.
self.unapproved_contact_user = (UserFactory(
email="*****@*****.**"))
self.unapproved_contact = ContactFactory(
partner=self.partner_b,
name='Unapproved Contact',
user=self.unapproved_contact_user,
email="*****@*****.**",
last_action_time='2015-09-30 13:23',
approval_status__code=Status.UNPROCESSED)
self.unapproved_contact.locations.add(
LocationFactory.create(address_line_one="123",
city="Nowhere",
state="NO"))
self.unapproved_contact.locations.add(
LocationFactory.create(address_line_one="234",
city="Nowhere",
state="NO"))
self.unapproved_contact.tags.add(self.west_tag)
# Poision data. Should never show up.
self.wrong_user = UserFactory(email="*****@*****.**")
self.wrong = ContactFactory(partner=self.other_partner,
name='wrong person',
user=self.wrong_user,
email="*****@*****.**",
last_action_time='2015-09-03')
self.wrong.locations.add(
LocationFactory.create(city="Los Angeles", state="CA"))
self.wrong.tags.add(self.east_tag)
self.wrong.tags.add(self.west_tag)
self.wrong.tags.add(self.bad_tag)
# Archive archived data here. Doing this earlier in the set up results
# in odd exceptions.
self.partner_archived.archive()
self.archived_contact.archive()
class MyDashboardViewsTests(TestCase):
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_number_of_searches_and_users_is_correct(self):
response = self.client.post(
reverse('dashboard') + '?company=' + str(self.company.id),
{'microsite': 'test.jobs'})
soup = BeautifulSoup(response.content)
# 10 searches total, two rows per search
self.assertEqual(len(soup.select('#row-link-table tr')), 20)
old_search = SavedSearch.objects.all()[0]
old_search.created_on -= timedelta(days=31)
old_search.save()
response = self.client.post(
reverse('dashboard') + '?company=' + str(self.company.id),
{'microsite': 'test.jobs'})
soup = BeautifulSoup(response.content)
self.assertEqual(len(soup.select('#row-link-table tr')), 20)
# Tests to see if redirect from /candidates/ goes to candidates/view/
def test_redirect_to_candidates_views_default_page(self):
response = self.client.post('/candidates/')
# response returns HttpResponsePermanentRedirect which returns a 301
# status code instead of the normal 302 redirect status code
self.assertRedirects(response,
'/candidates/view/',
status_code=301,
target_status_code=200)
response = self.client.post(reverse('dashboard'))
self.assertEqual(response.status_code, 200)
soup = BeautifulSoup(response.content)
company_name = soup.find('h1')
company_name = company_name.next
self.assertEqual(company_name, self.company.name)
# Eventually these opted-in/out will be changed to
# track if user is part of company's activity feed
def test_candidate_has_opted_in(self):
response = self.client.post(
reverse('candidate_information', ) + '?company=' +
str(self.company.id) + '&user='******'candidate_information', ) + '?company=' +
str(self.company.id) + '&user='******'candidate_information', ) + '?company=' +
str(self.company.id) + '&user='******'div', {
'id': 'candidate-content'
}).findAll('a', {'class': 'accordion-toggle'})
info = soup.find('div', {'id': 'candidate-content'}).findAll('li')
self.assertEqual(len(titles), 6)
self.assertEqual(len(info), 16)
self.assertEqual(response.status_code, 200)
def test_candidate_page_load_without_profileunits_with_activites(self):
response = self.client.post(
reverse('candidate_information', ) + '?company=' +
str(self.company.id) + '&user='******'div', {
'id': 'candidate-content'
}).findAll('a', {'class': 'accordion-toggle'})
info = soup.find('div', {'id': 'candidate-content'}).findAll('li')
self.assertEqual(len(titles), 1)
self.assertEqual(len(info), 3)
self.assertEqual(response.status_code, 200)
def test_candidate_page_load_without_profileunits_and_activites(self):
saved_search = SavedSearch.objects.get(user=self.candidate_user)
saved_search.delete()
response = self.client.post(
reverse('candidate_information', ) + '?company=' +
str(self.company.id) + '&user='******'div', {'id': 'candidate-content'})
self.assertFalse(info)
self.assertEqual(response.status_code, 404)
def test_export_csv(self):
response = self.client.post(
reverse('export_candidates') + '?company=' + str(self.company.id) +
'&ex-t=csv')
self.assertTrue(response.content)
self.assertEqual(response.status_code, 200)
def test_export_pdf(self):
response = self.client.post(
reverse('export_candidates') + '?company=' + str(self.company.id) +
'&ex-t=pdf')
self.assertTrue(response.content.index('PDF'))
self.assertEqual(response.templates[0].name,
'mydashboard/export/candidate_listing.html')
self.assertEqual(response.status_code, 200)
def test_export_xml(self):
response = self.client.post(
reverse('export_candidates') + '?company=' + str(self.company.id) +
'&ex-t=xml')
self.assertTrue(response.content.index('candidates'))
self.assertEqual(response.status_code, 200)
def test_export_json(self):
response = self.client.post(
reverse('export_candidates') + '?company=' + str(self.company.id) +
'&ex-t=json')
self.assertTrue(response.content.index('candidates'))
self.assertEqual(response.status_code, 200)
def setUp(self):
super(MyProfileTests, self).setUp()
self.user = UserFactory()
def test_staff_user_type(self):
"""Staff user type"""
user = UserFactory.create(email='*****@*****.**')
user.is_staff = True
self.assert_user_type('STAFF', user)
def setUp(self):
self.user = UserFactory()
self.name = PrimaryNameFactory(user=self.user)
class AccountFormTests(TestCase):
def setUp(self):
self.user = UserFactory()
self.name = PrimaryNameFactory(user=self.user)
def test_password_form(self):
invalid_data = [
{
'data': {
'password': '******',
'new_password1': 'newpassword',
'new_password2': 'newpassword'
},
u'errors': [['password', [u"Wrong password."]]]
},
{
'data': {
'password': '******',
'new_password1': 'newpassword',
'new_password2': 'notnewpassword'
},
u'errors': [[
u'new_password2',
[u'The new password fields did not match.']
],
[
u'new_password1',
[u'The new password fields did not match.']
]],
},
]
for item in invalid_data:
form = ChangePasswordForm(user=self.user, data=item['data'])
self.failIf(form.is_valid())
self.assertEqual(form.errors[item[u'errors'][0][0]],
item[u'errors'][0][1])
form = ChangePasswordForm(user=self.user,
data={
'password': '******',
'new_password1': 'anothersecret',
'new_password2': 'anothersecret'
})
self.failUnless(form.is_valid())
form.save()
self.failUnless(self.user.check_password('anothersecret'))
def test_no_name_account_form(self):
"""
Leaving both the first and last name fields blank produces a valid save.
It also deletes the primary name object from the Name model.
"""
data = {"gravatar": "*****@*****.**", "user": self.user}
form = EditAccountForm(data, **{'user': self.user})
self.assertTrue(form.is_valid())
form.save(self.user)
self.assertEqual(Name.objects.count(), 0)
def test_both_names_account_form(self):
"""
Filling out both name fields produces a valid save.
"""
data = {
"given_name": "Alicia",
"family_name": "Smith",
"gravatar": "*****@*****.**"
}
form = EditAccountForm(data, **{'user': self.user})
self.assertTrue(form.is_valid())
def test_partial_name_account_form(self):
"""
Filling out only the first name or only the last name produces an error.
"""
data = {
"given_name": "Alicia",
"gravatar": "*****@*****.**",
"user": self.user
}
form = EditAccountForm(data, **{'user': self.user})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['family_name'][0],
"Both a first and last name required.")
def setUp(self):
super(CommonTagsTests, self).setUp()
self.user = UserFactory()
self.context = Context({'user': self.user})
class AccountFormTests(TestCase):
def setUp(self):
self.user = UserFactory()
self.name = PrimaryNameFactory(user=self.user)
self.client = TestClient()
def test_password_form(self):
invalid_data = [
{
'data': {
'password': '******',
'new_password1': 'newpassword',
'new_password2': 'newpassword'
},
u'errors': [['password', [u"Wrong password."]]]
},
{
'data': {
'password': '******',
'new_password1': 'newpassword',
'new_password2': 'notnewpassword'
},
u'errors': [[
u'new_password2',
[u'The new password fields did not match.']
],
[
u'new_password1',
[u'The new password fields did not match.']
]],
},
]
for item in invalid_data:
form = ChangePasswordForm(user=self.user, data=item['data'])
self.failIf(form.is_valid())
self.assertEqual(form.errors[item[u'errors'][0][0]],
item[u'errors'][0][1])
form = ChangePasswordForm(user=self.user,
data={
'password': '******',
'new_password1': 'anothersecret',
'new_password2': 'anothersecret'
})
self.failUnless(form.is_valid())
form.save()
self.failUnless(self.user.check_password('anothersecret'))
def test_no_name_account_form(self):
"""
Leaving both the first and last name fields blank produces a valid save.
It also deletes the primary name object from the Name model.
"""
data = {"gravatar": "*****@*****.**", "user": self.user}
form = EditAccountForm(data, **{'user': self.user})
self.assertTrue(form.is_valid())
form.save(self.user)
self.assertEqual(Name.objects.count(), 0)
def test_both_names_account_form(self):
"""
Filling out both name fields produces a valid save.
"""
data = {
"given_name": "Alicia",
"family_name": "Smith",
"gravatar": "*****@*****.**"
}
form = EditAccountForm(data, **{'user': self.user})
self.assertTrue(form.is_valid())
def test_partial_name_account_form(self):
"""
Filling out only the first name or only the last name produces an error.
"""
data = {
"given_name": "Alicia",
"gravatar": "*****@*****.**",
"user": self.user
}
form = EditAccountForm(data, **{'user': self.user})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['family_name'][0],
"Both a first and last name required.")
def test_gravatar_email_list(self):
"""
Dropdowns for selecting the user's preferred Gravatar email should be
the only dropdowns that include "Do not use Gravatar" as an option -
others should default to the user's primary email address.
"""
self.client.login_user(self.user)
response = self.client.get(reverse('edit_communication'))
soup = BeautifulSoup(response.content)
options = soup.select('#id_digest_email option')
self.assertEqual(len(options), 1)
self.assertTrue(self.user.gravatar in options[0])
response = self.client.get(reverse('edit_basic'))
soup = BeautifulSoup(response.content)
options = soup.select('#id_gravatar option')
self.assertEqual(len(options), 2)
self.assertTrue('Do not use Gravatar' in options[0])
self.assertTrue(self.user.gravatar in options[1])
def setUp(self):
self.user = UserFactory()
self.name = PrimaryNameFactory(user=self.user)
self.client = TestClient()
class MyProfileTests(TestCase):
user_info = {
'password1': 'complicated_password',
'email': '*****@*****.**'
}
def setUp(self):
super(MyProfileTests, self).setUp()
self.user = UserFactory()
def test_primary_name_save(self):
"""
Saving a primary name when one already exists replaces it with
the new primary name.
"""
initial_name = PrimaryNameFactory(user=self.user)
self.assertTrue(initial_name.primary)
new_name = NewPrimaryNameFactory(user=self.user)
initial_name = Name.objects.get(given_name='Alice')
self.assertTrue(new_name.primary)
self.assertFalse(initial_name.primary)
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 test_email_activation_creation(self):
"""
Creating a new secondary email creates a corresponding unactivated
ActivationProfile.
"""
secondary_email = SecondaryEmailFactory(user=self.user)
activation = ActivationProfile.objects.get(email=secondary_email.email)
self.assertEqual(secondary_email.email, activation.email)
def test_send_activation(self):
"""
The send_activation method in SecondaryEmail should send an
activation link to the email address
"""
secondary_email = SecondaryEmailFactory(user=self.user)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].to, [secondary_email.email])
self.assertTrue('secondary email' in mail.outbox[0].body)
def test_verify_email(self):
"""
Clicking the activation link sets the ActivationProfile object to
activated and sets the SecondaryEmail object to verified.
"""
secondary_email = SecondaryEmailFactory(user=self.user)
activation = ActivationProfile.objects.get(user=self.user,
email=secondary_email.email)
response = self.client.get(
reverse('registration_activate', args=[activation.activation_key])
+ '?verify-email=%s' % self.user.email)
secondary_email = SecondaryEmail.objects.get(
user=self.user, email=secondary_email.email)
activation = ActivationProfile.objects.get(user=self.user,
email=secondary_email.email)
self.assertEqual(response.status_code, 200)
self.assertTrue(secondary_email.verified)
def test_set_primary_email(self):
"""
Calling the set_as_primary method in the SecondaryEmail removes it from
SecondaryEmail, replaces the current address on the User model, and
adds the replaced address to the SecondaryEmail table.
"""
old_primary = self.user.email
secondary_email = SecondaryEmailFactory(user=self.user)
new_primary = secondary_email.email
for email in [old_primary, new_primary]:
# Emails must be verified to make them primary.
activation = ActivationProfile.objects.get_or_create(
user=self.user, email=email)[0]
ActivationProfile.objects.activate_user(activation.activation_key)
secondary_email = SecondaryEmail.objects.get(email=new_primary)
secondary_email.set_as_primary()
with self.assertRaises(SecondaryEmail.DoesNotExist):
SecondaryEmail.objects.get(email=new_primary)
old_email = SecondaryEmail.objects.get(email=old_primary)
self.assertTrue(old_email.verified)
user = User.objects.get(email=new_primary)
def test_duplicate_same_primary_name(self):
"""
Makes sure that one can not create duplicate primary names.
"""
primary_name1 = PrimaryNameFactory(user=self.user)
primary_name2 = PrimaryNameFactory(user=self.user)
num_results = self.user.profileunits_set.filter(
content_type__name='name').count()
self.assertEqual(num_results, 1)
def test_different_primary_name(self):
primary_name1 = PrimaryNameFactory(user=self.user)
primary_name2 = NewPrimaryNameFactory(user=self.user)
primary_name_count = Name.objects.filter(user=self.user,
primary=True).count()
non_primary_name_count = Name.objects.filter(user=self.user,
primary=False).count()
self.assertEqual(primary_name_count, 1)
self.assertEqual(non_primary_name_count, 1)
def test_non_primary_name_to_primary(self):
name = NewNameFactory(user=self.user)
primary_name1 = PrimaryNameFactory(user=self.user)
primary_name_count = Name.objects.filter(user=self.user,
primary=True).count()
non_primary_name_count = Name.objects.filter(user=self.user,
primary=False).count()
self.assertEqual(primary_name_count, 1)
self.assertEqual(non_primary_name_count, 0)
def test_primary_name_to_non_primary(self):
primary_name = PrimaryNameFactory(user=self.user)
primary_name.primary = False
primary_name.save()
primary_name_count = Name.objects.filter(user=self.user,
primary=True).count()
non_primary_name_count = Name.objects.filter(user=self.user,
primary=False).count()
self.assertEqual(primary_name_count, 0)
self.assertEqual(non_primary_name_count, 1)
def test_duplicate_name(self):
"""
Makes sure that duplicate names is not saving.
"""
name1 = NewNameFactory(user=self.user)
name2 = NewNameFactory(user=self.user)
num_results = Name.objects.filter(user=self.user).count()
self.assertEqual(num_results, 1)
def test_unverified_primary_email(self):
"""
Only verified emails can be set as the primary email
"""
old_primary = self.user.email
secondary_email = SecondaryEmailFactory(user=self.user)
primary = secondary_email.set_as_primary()
with self.assertRaises(SecondaryEmail.DoesNotExist):
SecondaryEmail.objects.get(email=old_primary)
self.assertFalse(primary)
user = User.objects.get(email=old_primary)
self.assertEqual(user.email, old_primary)
def test_maintain_verification_state(self):
"""
For security reasons, the state of verification of the user email
should be the same as it is when it is transferred into SecondaryEmail
"""
old_primary = self.user.email
self.user.is_active = False
self.user.save()
secondary_email = SecondaryEmailFactory(user=self.user)
activation = ActivationProfile.objects.get(user=self.user,
email=secondary_email.email)
ActivationProfile.objects.activate_user(activation.activation_key)
secondary_email = SecondaryEmail.objects.get(
user=self.user, email=secondary_email.email)
new_primary = secondary_email.email
secondary_email.set_as_primary()
old_email = SecondaryEmail.objects.get(email=old_primary)
self.assertFalse(old_email.verified)
user = User.objects.get(email=new_primary)
def test_same_secondary_email(self):
"""
All emails are unique. If an email is used as a user's primary email or
another secondary email, it may not be used as a secondary email again.
"""
secondary_email = SecondaryEmailFactory(user=self.user)
with self.assertRaises(IntegrityError):
new_secondary_email = SecondaryEmailFactory(user=self.user)
new_secondary_email = SecondaryEmailFactory(user=self.user,
email='*****@*****.**')
def test_delete_secondary_email(self):
"""
Deleting a secondary email should also delete its activation profile
"""
self.assertEqual(ActivationProfile.objects.count(), 0)
secondary_email = SecondaryEmailFactory(user=self.user)
self.assertEqual(ActivationProfile.objects.count(), 1)
secondary_email.delete()
self.assertEqual(ActivationProfile.objects.count(), 0)
def test_add_military_service(self):
military_service = MilitaryServiceFactory(user=self.user)
military_service.save()
ms_object = ProfileUnits.objects.filter(
content_type__name="military service").count()
self.assertEqual(ms_object, 1)
def test_add_license(self):
license_form = LicenseFactory(user=self.user)
license_form.save()
ms_object = ProfileUnits.objects.filter(
content_type__name="license").count()
self.assertEqual(ms_object, 1)
def test_add_website(self):
website_instance = WebsiteFactory(user=self.user)
website_instance.save()
ms_object = ProfileUnits.objects.filter(
content_type__name="website").count()
self.assertEqual(ms_object, 1)
def test_add_summary(self):
summary_instance = SummaryFactory(user=self.user)
summary_instance.save()
ms_object = ProfileUnits.objects.filter(
content_type__name="summary").count()
self.assertEqual(ms_object, 1)
def test_add_volunteer_history(self):
vh_instance = VolunteerHistoryFactory(user=self.user)
vh_instance.save()
ms_object = ProfileUnits.objects.filter(
content_type__name="volunteer history").count()
self.assertEqual(ms_object, 1)
class NewUserTests(SeleniumTestCase):
"""Tests Account creation"""
def setUp(self):
super(NewUserTests, self).setUp()
company = CompanyFactory()
self.user = UserFactory(first_name="John", last_name="Doe")
admin_role = RoleFactory(company=company, name='Admin')
self.user.roles.add(self.admin_role)
def test_home_page_works(self):
"""
As John, navigating to https://secure.my.jobs should send me to a page
titled "My.jobs".
"""
self.browser.get(self.live_server_url)
self.assertIn(self.browser.title, 'My.jobs')
def test_cant_log_in_without_account(self):
"""
As John, I shouldn't be able to log into My.jobs without registering
first.
"""
self.browser.get('/'.join([self.live_server_url, 'prm', 'view']))
# We're trying to access a private page while unauthenticated, which
# should result in a next parameter being added.
self.assertTrue('next=' in self.browser.current_url)
# attempt to log in
username = self.find('id_username')
username.send_keys(self.user.email)
self.find('id_password').send_keys(self.user.password)
self.find('login').click()
# If we've logged in, the next parameter should have went away. We
# aren't expecting to be logged in right now as the password was bad.
self.assertTrue('next=' in self.browser.current_url)
def test_user_registration(self):
"""
As John, I should be able to register on My.jobs and log in.
"""
self.browser.get('/'.join([self.live_server_url, 'prm', 'view']))
# register
self.find('id_email').send_keys('*****@*****.**')
self.find('id_password1').send_keys('aaAA11..')
self.find('id_password2').send_keys('aaAA11..')
self.find('register').click()
try:
WebDriverWait(self.browser, 10).until(
expected_conditions.presence_of_element_located(
(By.ID, 'profile')))
finally:
self.assertEqual(
self.find('profile').get_attribute('innerHTML'),
'Skip: Take me to my profile')
def test_user_login(self):
self.user.set_password("test")
self.user.save()
self.find('id_username').send_keys(self.user.email)
self.find('id_password').send_keys("test")
self.find('login').click()
def setUp(self):
super(TestCommRecordsDataSource, self).setUp()
# A company to work with
self.company = CompanyFactory(name='right')
self.company.save()
# A separate company that should not show up in results.
self.other_company = CompanyFactory(name='wrong')
self.other_company.save()
self.partner_a = PartnerFactory(owner=self.company,
uri='http://www.example.com/',
data_source="zap",
name="aaa")
self.partner_b = PartnerFactory(owner=self.company,
uri='http://www.asdf.com/',
data_source="bcd",
name="bbb")
# An unapproved parther. Associated data should be filtered out.
self.partner_unapp = PartnerFactory(
owner=self.company,
name="unapproved",
approval_status__code=Status.UNPROCESSED)
# An archived parther. Associated data should be filtered out.
self.partner_archived = PartnerFactory(owner=self.company)
self.east_tag = TagFactory.create(company=self.company,
name='east',
hex_color="aaaaaa")
self.west_tag = TagFactory.create(company=self.company,
name='west',
hex_color="bbbbbb")
self.north_tag = TagFactory.create(company=self.company,
name='north',
hex_color="cccccc")
self.south_tag = TagFactory.create(company=self.company,
name='south',
hex_color="dddddd")
self.left_tag = TagFactory.create(company=self.company,
name='left',
hex_color="eeeeee")
self.right_tag = TagFactory.create(company=self.company,
name='right',
hex_color="ffffff")
self.bad_tag = TagFactory.create(company=self.company,
name='bad',
hex_color="cccccc")
self.partner_a.tags.add(self.left_tag)
self.partner_b.tags.add(self.right_tag)
self.john_user = UserFactory(email="*****@*****.**")
self.john = ContactFactory(partner=self.partner_a,
name='john adams',
user=self.john_user,
email="*****@*****.**",
last_action_time='2015-10-03')
self.john.locations.add(
LocationFactory.create(city="Indianapolis", state="IN"))
self.john.locations.add(
LocationFactory.create(city="Chicago", state="IL"))
self.john.tags.add(self.north_tag)
self.sue_user = UserFactory(email="*****@*****.**")
self.sue = ContactFactory(partner=self.partner_b,
name='Sue Baxter',
user=self.sue_user,
email="*****@*****.**",
last_action_time='2015-09-30 13:23')
self.sue.locations.add(
LocationFactory.create(address_line_one="123",
city="Los Angeles",
state="CA"))
self.sue.locations.add(
LocationFactory.create(address_line_one="234",
city="Los Angeles",
state="CA"))
self.sue.tags.add(self.south_tag)
self.partner_a.primary_contact = self.john
self.partner_b.primary_contact = self.sue
self.partner_a.save()
self.partner_b.save()
self.record_1 = ContactRecordFactory(subject='record 1',
date_time='2015-09-30 13:23',
contact=self.john,
contact_type="Email",
partner=self.partner_a,
location='Indianapolis, IN',
tags=[self.east_tag])
self.record_2 = ContactRecordFactory(subject='record 2',
date_time='2015-01-01',
contact=self.john,
contact_type="Meeting Or Event",
partner=self.partner_a,
location='Indianapolis, IN',
tags=[self.east_tag])
self.record_3 = ContactRecordFactory(subject='record 3',
date_time='2015-10-03',
contact=self.sue,
contact_type="Phone",
partner=self.partner_b,
location='Los Angeles, CA',
tags=[self.west_tag])
# Archive archived data here. Doing this earlier in the set up results
# in odd exceptions.
self.partner_archived.archive()
def setUp(self):
self.user = UserFactory()
self.company = CompanyFactory()
self.data = {'user': self.user.id,
'company': self.company.id}
def setUp(self):
self.user = UserFactory()
self.redirect_middleware = RedirectMiddleware()
self.request_factory = RequestFactory()
def test_custom_password_reset_form(self):
form = CustomPasswordResetForm({'email':self.user.email})
self.assertTrue(form.is_valid())
user = UserFactory(email='*****@*****.**', is_active=False)
form = CustomPasswordResetForm({'email':user.email})
self.assertTrue(form.is_valid())
def setUp(self):
super(MyProfileViewsTests, self).setUp()
self.user = UserFactory()
self.client = TestClient()
self.client.login_user(self.user)
self.name = PrimaryNameFactory(user=self.user)
def setUp(self):
super(SavedSearchDeletionTests, self).setUp()
self.creator = UserFactory(email='*****@*****.**')
self.search = SavedSearchFactory(user=self.user)
self.partner_search = PartnerSavedSearchFactory(
user=self.user, created_by=self.creator)
def test_jobseeker(self):
"""User object exists but has no relevant privileges."""
user = UserFactory.create(email='*****@*****.**')
self.assert_user_type(None, user)
def setUp(self):
super(BlocksTestBase, self).setUp()
self.site = SeoSite.objects.get()
self.config = Configuration.objects.get(status=2)
self.config.browse_facet_show = True
self.config.save()
# Can't do a get_or_create here because we don't
# care about the date_crawled/date_updated fields,
# but if the BusinessUnit doesn't exist they will need
# to be supplied.
try:
self.buid = BusinessUnit.objects.get(pk=0)
except BusinessUnit.DoesNotExist:
self.buid = BusinessUnitFactory(id=0)
self.site.business_units.add(0)
self.commitment = SpecialCommitmentFactory()
self.site.special_commitments.add(self.commitment)
self.site.save()
self.tag = SiteTag.objects.create(site_tag='Test tag')
self.site.site_tags.add(self.tag)
self.site.save()
self.job = SOLR_FIXTURE[1]
self.conn.add([self.job])
self.user = UserFactory()
url = reverse('all_jobs')
self.search_results_request = RequestFactory().get(url)
self.search_results_request.user = self.user
self.q_kwargs = {'q': self.job['title']}
url = build_url(reverse('all_jobs'), self.q_kwargs)
self.search_results_with_q_request = RequestFactory().get(url)
self.search_results_with_q_request.user = self.user
self.facet = CustomFacetFactory(show_production=True,
name='%s' % self.job['title'],
name_slug='%s' %
self.job['title_slug'],
querystring='*',
blurb='Test')
self.bad_facet = CustomFacetFactory(show_production=True,
name='Bad Facet',
name_slug='bad-facet',
querystring='asfljasdlfjsadfsdf',
blurb='Test',
always_show=True)
SeoSiteFacetFactory(customfacet=self.facet, seosite=self.site)
SeoSiteFacetFactory(customfacet=self.bad_facet, seosite=self.site)
url = '%s/new-jobs/' % self.job['title_slug']
self.search_results_with_custom_facet = RequestFactory().get(url)
self.search_results_with_custom_facet.user = self.user
self.job_detail_kwargs = {
'job_id': self.job['guid'],
'title_slug': self.job['title_slug'],
'location_slug': slugify(self.job['location']),
}
url = reverse('job_detail_by_location_slug_title_slug_job_id',
kwargs=self.job_detail_kwargs)
self.job_detail_request = RequestFactory().get(url)
self.job_detail_request.user = self.user
kwargs = {'job_id': self.job['guid']}
url = reverse('job_detail_by_job_id', kwargs=kwargs)
self.job_detail_redirect_request = RequestFactory().get(url)
self.job_detail_redirect_request.user = self.user
# Send a request through middleware so all the required
# settings (from MultiHostMiddleware) actually get set.
self.client.get('/')
def test_jobseeker_user_type(self):
"""Jobseeker user type"""
user = UserFactory.create(email='*****@*****.**')
self.assert_user_type(None, user)
def setUp(self):
self.user = UserFactory()
def setUp(self):
super(NewUserTests, self).setUp()
company = CompanyFactory()
self.user = UserFactory(first_name="John", last_name="Doe")
admin_role = RoleFactory(company=company, name='Admin')
self.user.roles.add(self.admin_role)
class MyJobsAdminTests(MyJobsBase):
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_request_access_to_staff(self):
"""
Requesting access to a staff/superuser account is not allowed.
"""
self.account_owner.is_staff = True
self.account_owner.save()
# Selecting the action in the User changelist and pressing "OK" should
# immediately show a notification at the top of the page.
response = self.client.post(reverse('admin:myjobs_user_changelist'),
self.data,
follow=True)
self.assertEqual(len(mail.outbox), 0)
self.assertContains(response, ("Requesting access to staff or "
"superusers is not supported."))
# Manually constructing a post to the relevant url should redirect
# to the User changelist and not send notification emails.
response = self.client.post(
reverse('request-account-access',
kwargs={'uid': self.account_owner.pk}),
{'reason': 'reason here'})
self.assertRedirects(response, reverse('admin:myjobs_user_changelist'))
self.assertEqual(len(mail.outbox), 0)
def test_request_access_to_non_staff(self):
"""
Requesting access to a non-staff/superuser account succeeds if the
target is not a staff/superuser account and the requesting staff
member provides a reason.
"""
# Request access to an account to get to the request form.
response = self.client.post(reverse('admin:myjobs_user_changelist'),
self.data,
follow=True)
self.assertContains(response,
"What is the nature of this request?",
msg_prefix="Did not redirect to the request form")
url = reverse('request-account-access',
kwargs={'uid': self.account_owner.pk})
last_redirect = response.redirect_chain[-1][0]
# If the admin action determines that it is valid, it redirects. Ensure
# we redirected to the expected location.
self.assertTrue(last_redirect.endswith(url),
msg="Did not redirect as expected")
# Try submitting the request form without a reason.
response = self.client.post(url)
self.assertContains(response,
"This field is required.",
msg_prefix=("Form error not present on invalid "
"submission"))
self.assertEqual(len(mail.outbox),
0,
msg="Mail sent despite form errors")
# # Submit again, providing a reason.
self.client.post(url, {'reason': 'reason here'})
self.assertEqual(len(mail.outbox),
1,
msg="Mail did not send on successful form submission")
email = mail.outbox[0]
self.assertTrue(self.account_owner.email in email.to,
msg="Email was sent to the wrong user")
self.assertTrue('reason here' in email.body,
msg="Account access reason was not in the sent email")
def test_export_as_csv_admin_action(self):
"""
Tests the ability to export the list of destination manipulations as a
CSV.
"""
email = '*****@*****.**'
password = '******'
UserFactory(email=email,
password=password,
is_staff=True,
is_superuser=True)
# only superusers are allowed to use Django amin
self.client.login(username=email, password=password)
manipulations = [
DestinationManipulationFactory(view_source=i)
for i in range(200, 210)
]
# this is the format we expect results to be in if deserializing CSV
# into a list of dicts
formatted_manipulations = [{
u'View Source': unicode(m.view_source),
u'View Source Name': '',
u'BUID': unicode(m.buid),
u'Action Type': unicode(m.action_type),
u'Value 1': unicode(m.value_1),
u'Value 2': unicode(m.value_2),
u'Action': unicode(m.action)
} for m in manipulations]
args = {
'action': 'export_as_csv',
'_selected_action': [unicode(m.pk) for m in manipulations[:5]]
}
changelist_url = reverse(
"admin:redirect_destinationmanipulation_changelist")
# asking to export as csv when selected items should serialize only
# those items
response = self.client.post(changelist_url, args)
reader = csv.DictReader(response.content.split('\r\n'))
self.assertItemsEqual(list(reader), formatted_manipulations[:5])
args['select_across'] = '1'
# choosing "select all" should export all records in the queryset,
# regardless of the list of selected items passed
response = self.client.post(changelist_url, args)
reader = csv.DictReader(response.content.split('\r\n'))
self.assertItemsEqual(list(reader), formatted_manipulations)
