def test_award_detail(self):
"""Can view award detail"""
user = self._get_user()
user2 = self._get_user(username='******')
b1, created = Badge.objects.get_or_create(creator=user, title="Code Badge #1")
award = b1.award_to(user2)
url = reverse('badger.views.award_detail', args=(b1.slug, award.pk,))
r = self.client.get(url, follow=True)
doc = pq(r.content)
eq_('award_detail', doc.find('body').attr('id'))
eq_(1, doc.find('.awarded_to .username:contains("%s")' % user2.username).length)
eq_(1, doc.find('.badge .title:contains("%s")' % b1.title).length)
# Now, take a look at the JSON format
url = reverse('badger.award_detail_json', args=(b1.slug, award.pk,))
r = self.client.get(url, follow=True)
data = simplejson.loads(r.content)
eq_(award.user.email, data['recipient'])
eq_('http://testserver%s' % award.get_absolute_url(),
data['evidence'])
eq_(award.badge.title, data['badge']['name'])
eq_(award.badge.description, data['badge']['description'])
eq_('http://testserver%s' % award.badge.get_absolute_url(),
data['badge']['criteria'])
def test_badge_detail(self):
"""Can view badge detail"""
user = self._get_user()
badge = Badge(creator=user,
title="Test II",
description="Another test")
badge.save()
r = self.client.get(reverse('badger.views.detail',
args=(badge.slug, )),
follow=True)
doc = pq(r.content)
eq_('badge_detail', doc.find('body').attr('id'))
eq_(badge.title, doc.find('.badge .title').text())
eq_(badge.description, doc.find('.badge .description').text())
# Now, take a look at the JSON format
url = reverse('badger.detail_json', args=(badge.slug, ))
r = self.client.get(url, follow=True)
data = simplejson.loads(r.content)
eq_(badge.title, data['name'])
eq_(badge.description, data['description'])
eq_('http://testserver%s' % badge.get_absolute_url(), data['criteria'])
def spark_sharing(request):
data = {'page': 'sharing',
'prev': reverse('eol.hall'),
'next': reverse('eol.around'),
'share_history': [(unicode(WEEK_NUMBER) % dict(num=i+1), v) for i, v in enumerate(share_history)]}
data.update(sharing_messages())
return jingo.render(request, 'eol/mobile/sharing.html', data)
def test_award_feeds(self):
"""Can view award detail"""
user = self._get_user()
user2 = self._get_user(username='******')
b1, created = Badge.objects.get_or_create(creator=user, title="Code Badge #1")
award = b1.award_to(user2)
# The award should show up in each of these feeds.
feed_urls = (
reverse('badger.feeds.awards_recent',
args=('atom', )),
reverse('badger.feeds.awards_by_badge',
args=('atom', b1.slug, )),
reverse('badger.feeds.awards_by_user',
args=('atom', user2.username,)),
)
# Check each of the feeds
for feed_url in feed_urls:
r = self.client.get(feed_url, follow=True)
# The feed should be parsed without issues by feedparser
feed = feedparser.parse(r.content)
eq_(0, feed.bozo)
# Look through entries for the badge title
found_it = False
for entry in feed.entries:
if b1.title in entry.title and user2.username in entry.title:
found_it = True
ok_(found_it)
def handle404(request):
"""Redirect to home"""
if is_mobile_request(request):
view = reverse('eol.home_mobile')
else:
view = reverse('eol.home')
return HttpResponseRedirect(view)
def award_badge(request, slug):
"""Issue an award for a badge"""
badge = get_object_or_404(Badge, slug=slug)
if not badge.allows_award_to(request.user):
return HttpResponseForbidden()
if request.method != "POST":
form = BadgeAwardForm()
else:
form = BadgeAwardForm(request.POST, request.FILES)
if form.is_valid():
email = form.cleaned_data['email']
result = badge.award_to(email=email, awarder=request.user)
if result:
if not hasattr(result, 'claim_code'):
messages.info(request, _('Award issued to %s') % email)
return HttpResponseRedirect(
reverse('badger.views.award_detail',
args=(badge.slug, result.id,)))
else:
messages.info(request, _('%s is not a known user, '
'invitation to claim award '
'sent') % email)
return HttpResponseRedirect(
reverse('badger.views.detail',
args=(badge.slug,)))
return render_to_response('badger/badge_award.html', dict(
form=form, badge=badge,
), context_instance=RequestContext(request))
def handle404(request):
"""Redirect to home"""
if is_mobile_request(request):
view = reverse('eol.home_mobile')
else:
view = reverse('eol.home')
return HttpResponseRedirect(view)
def test_pending_edit_profile(self):
# do all then reset
newbie_uniq_id, newbie_client = _create_new_user()
profile_url = reverse('profile', args=[newbie_uniq_id])
edit_profile_url = reverse('phonebook.edit_profile',
args=[newbie_uniq_id])
# original
r = newbie_client.get(profile_url)
newbie = r.context['person']
first = newbie.first_name
last = newbie.last_name
bio = newbie.biography
# update
data = dict(first_name='Hobo', last_name='LaRue',
biography='Rides the rails')
edit = newbie_client.post(edit_profile_url, data, follow=True)
eq_(200, edit.status_code, 'Edits okay')
r = newbie_client.get(profile_url)
newbie = r.context['person']
self.assertNotEqual(first, newbie.first_name)
self.assertNotEqual(last, newbie.last_name)
self.assertNotEqual(bio, newbie.biography)
display_name = "%s %s" % (newbie.first_name, newbie.last_name)
eq_(display_name, newbie.full_name,
'Editing should update display name')
# cleanup
delete_url = reverse('phonebook.delete_profile')
data = dict(unique_id=newbie_uniq_id)
r = newbie_client.post(delete_url, data, follow=True)
eq_(200, r.status_code, 'A Mozillian can delete their own account')
def spark_hall(request):
data = {'page': 'hall',
'prev': reverse('eol.home_mobile'),
'next': reverse('eol.sharing'),
'levels': level_distribution(),
'top_players': top_players}
data.update(sharing_messages())
return jingo.render(request, 'eol/mobile/hall.html', data)
def test_view_all(self):
"""Make sure the list all view displays our project."""
resp = self.client.get(reverse('projects_all'), follow=True)
self.assertContains(resp, self.project.name)
# make sure only projects with at least one topic are shown
self.project.topics.remove(self.topic)
self.project.save()
resp = self.client.get(reverse('projects_all'), follow=True)
self.assertNotContains(resp, self.project.name)
def test_view_all(self):
"""Make sure the list all view displays our project."""
resp = self.client.get(reverse('projects_all'), follow=True)
self.assertContains(resp, self.project.name)
# make sure only projects with at least one topic are shown
self.project.topics.remove(self.topic)
self.project.save()
resp = self.client.get(reverse('projects_all'), follow=True)
self.assertNotContains(resp, self.project.name)
def test_mozillian_can_vouch(self):
"""
Tests the vouching system's happy path.
Kind of a big test because we want to:
a. Test registration's happy path
b. Test vouching
c. Test account deletion
"""
newbie_uniq_id, newbie_client = _create_new_user()
newbie_profile_url = reverse('profile', args=[newbie_uniq_id])
name = 'Newbie McPal'
moz_client = self.mozillian_client
profile = moz_client.get(newbie_profile_url)
eq_(name, profile.context['person'].full_name,
'Regisration worked and we can see their profile')
# test for vouch form...
self.assertTrue(profile.context['vouch_form'], 'Newb needs a voucher')
vouch_url = reverse('phonebook.vouch')
data = dict(voucher=MOZILLIAN['uniq_id'], vouchee=newbie_uniq_id)
vouched_profile = moz_client.post(vouch_url, data, follow=True)
eq_(200, vouched_profile.status_code)
eq_('phonebook/profile.html', vouched_profile.templates[0].name)
profile = moz_client.get(newbie_profile_url)
eq_(name, profile.context['person'].full_name,
"Vouching worked and we're back on Newbie's profile")
voucher = profile.context['person'].voucher
eq_(MOZILLIAN['uniq_id'], voucher.unique_id,
'Credit given')
self.assertFalse(vouched_profile.context['vouch_form'],
'No need to vouch for this confirmed Mozillian')
delete_url = reverse('phonebook.delete_profile')
try:
data = dict(unique_id=newbie_uniq_id)
moz_client.post(delete_url, data, follow=True)
self.assertFail("A Mozillian can't delete another account")
except UNAUTHORIZED_DELETE:
pass
data = dict(unique_id=newbie_uniq_id)
delete = newbie_client.post(delete_url, data, follow=True)
eq_(200, delete.status_code,
'A Mozillian can delete their own account')
profile = moz_client.get(newbie_profile_url)
eq_(404, profile.status_code)
def pending_user_client():
client = test.Client()
# We can't use client.login for these tests
url = reverse('login')
data = dict(username=PENDING['email'], password=PASSWORD)
client.post(url, data, follow=True)
# HACK Something is seriously hozed here...
# First visit to /login always fails, so we make
# second request... WTF
client = test.Client()
url = reverse('login')
r = client.post(url, data, follow=True)
eq_(PENDING['email'], str(r.context['user']))
return client
def test_can_delete_profile(self):
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
resp = self.client.get(reverse('users_delete'), follow=True)
self.assertContains(resp, 'Delete Profile')
self.assertTrue(User.objects.get(username=self.user.username))
self.assertTrue(Profile.objects.get(pk=self.profile.pk))
resp = self.client.post(reverse('users_delete'), follow=True)
self.assertTrue(resp.redirect_chain[-1][0].endswith('/en-US/'))
with self.assertRaises(User.DoesNotExist):
User.objects.get(username=self.user.username)
with self.assertRaises(Profile.DoesNotExist):
Profile.objects.get(pk=self.profile.pk)
def test_can_delete_profile(self):
self.assertTrue(self.client.login(
username=self.user.username,
password=self.password
))
resp = self.client.get(reverse('users_delete'), follow=True)
self.assertContains(resp, 'Delete Profile')
self.assertTrue(User.objects.get(username=self.user.username))
self.assertTrue(Profile.objects.get(pk=self.profile.pk))
resp = self.client.post(reverse('users_delete'), follow=True)
self.assertTrue(resp.redirect_chain[-1][0].endswith('/en-US/'))
with self.assertRaises(User.DoesNotExist):
User.objects.get(username=self.user.username)
with self.assertRaises(Profile.DoesNotExist):
Profile.objects.get(pk=self.profile.pk)
def staff_tools(request):
"""HACK: This page offers miscellaneous tools useful to event staff.
Will go away in the future, addressed by:
https://github.com/lmorchard/django-badger/issues/35
"""
if not (request.user.is_staff or request.user.is_superuser):
return HttpResponseForbidden()
if request.method != "POST":
grant_form = DeferredAwardMultipleGrantForm()
else:
if request.REQUEST.get('is_grant', False) is not False:
grant_form = DeferredAwardMultipleGrantForm(request.POST, request.FILES)
if grant_form.is_valid():
email = grant_form.cleaned_data['email']
codes = grant_form.cleaned_data['claim_codes']
for claim_code in codes:
da = DeferredAward.objects.get(claim_code=claim_code)
da.grant_to(email, request.user)
messages.info(request, _('Badge "%s" granted to %s' %
(da.badge, email)))
url = reverse('badger.views.staff_tools')
return HttpResponseRedirect(url)
return render_to_response('badger/staff_tools.html', dict(
grant_form=grant_form
), context_instance=RequestContext(request))
def get_object(self, request, format, slug):
super(AwardsByBadgeFeed, self).get_object(request, format)
badge = get_object_or_404(Badge, slug=slug)
self.title = _('Recent awards of "%s"') % badge.title
self.link = request.build_absolute_uri(
reverse('badger.views.awards_by_badge', args=(badge.slug, )))
return badge
def claim_deferred_award(request, claim_code=None):
"""Deferred award detail view"""
if not claim_code:
claim_code = request.REQUEST.get('code', '').strip()
deferred_award = get_object_or_404(DeferredAward, claim_code=claim_code)
if not deferred_award.allows_detail_by(request.user):
return HttpResponseForbidden('Claim detail denied')
if request.method != "POST":
grant_form = DeferredAwardGrantForm()
else:
grant_form = DeferredAwardGrantForm(request.POST, request.FILES)
if not request.POST.get('is_grant', False) is not False:
return _do_claim(request, deferred_award)
else:
if not deferred_award.allows_grant_by(request.user):
return HttpResponseForbidden('Grant denied')
if grant_form.is_valid():
email = request.POST.get('email', None)
deferred_award.grant_to(email=email, granter=request.user)
messages.info(request, _('Award claim granted to %s') % email)
url = reverse('badger.views.detail',
args=(deferred_award.badge.slug,))
return HttpResponseRedirect(url)
return render_to_response('badger/claim_deferred_award.html', dict(
badge=deferred_award.badge, deferred_award=deferred_award,
grant_form=grant_form
), context_instance=RequestContext(request))
def test_awards_by_user(self):
"""Can view awards by user"""
user = self._get_user()
user2 = self._get_user(username='******')
b1, created = Badge.objects.get_or_create(creator=user,
title="Code Badge #1")
b2, created = Badge.objects.get_or_create(creator=user,
title="Code Badge #2")
b3, created = Badge.objects.get_or_create(creator=user,
title="Code Badge #3")
b1.award_to(user2)
award_badge(b2.slug, user2)
Award.objects.create(badge=b3, user=user2)
url = reverse('badger.views.awards_by_user', args=(user2.username, ))
r = self.client.get(url, follow=True)
doc = pq(r.content)
eq_('badge_awards_by_user', doc.find('body').attr('id'))
eq_(3, doc.find('.award').length)
for b in (b1, b2, b3):
eq_(
1,
doc.find('.award .badge .title:contains("%s")' %
b.title).length)
def home(request):
"""Profile home page"""
if not request.user.is_authenticated():
return HttpResponseRedirect(settings.LOGIN_REDIRECT_URL_FAILURE)
return HttpResponseRedirect(reverse('profiles.views.profile_view',
args=(request.user.username,)))
def test_issue_award(self):
"""Badge creator can issue award to another user"""
user1 = self._get_user(username="******")
user2 = self._get_user(username="******")
b1 = Badge.objects.create(creator=user1, title="Badge to awarded")
url = reverse('badger.views.award_badge', args=(b1.slug, ))
# Non-creator should be denied attempt to award badge
self.client.login(username="******", password="******")
r = self.client.get(url, follow=True)
eq_(403, r.status_code)
# But, the creator should be allowed
self.client.login(username="******", password="******")
r = self.client.get(url, follow=True)
eq_(200, r.status_code)
doc = pq(r.content)
form = doc('form#award_badge')
eq_(1, form.length)
eq_(1, form.find('*[name=user]').length)
eq_(1, form.find('input.submit,button.submit').length)
r = self.client.post(url, dict(user=user2.id, ), follow=True)
doc = pq(r.content)
logging.debug(r.content)
ok_(b1.is_awarded_to(user2))
def home(request):
"""Profile home page"""
if not request.user.is_authenticated():
return HttpResponseRedirect(settings.LOGIN_REDIRECT_URL_FAILURE)
return HttpResponseRedirect(
reverse('profiles.profile_view', args=(request.user.username, )))
def test_anonymous_or_pending_search(self):
search = reverse('phonebook.search')
for client in [self.anon_client, self.pending_client]:
r = client.get(search, dict(q='Am'), follow=True)
peeps = r.context['people']
eq_(0, len(peeps),
'Search should fail for interlopers')
def award_badge(request, slug):
"""Issue an award for a badge"""
badge = get_object_or_404(Badge, slug=slug)
if not badge.allows_award_to(request.user):
return HttpResponseForbidden()
if request.method != "POST":
form = BadgeAwardForm()
else:
form = BadgeAwardForm(request.POST, request.FILES)
if form.is_valid():
award = badge.award_to(form.cleaned_data['user'], request.user)
return HttpResponseRedirect(
reverse('badger.views.award_detail',
args=(
badge.slug,
award.id,
)))
return render_to_response('badger/badge_award.html',
dict(
form=form,
badge=badge,
),
context_instance=RequestContext(request))
def test_anonymous_home(self):
r = self.anon_client.get('/', follow=True)
self.assertEquals(200, r.status_code)
doc = pq(r.content)
login = reverse('login')
eq_(doc('a#login').attr('href'), login, 'We see a link to login')
self.assertFalse(_logged_in_html(r))
def get_object(self, request, format, username):
super(AwardsByUserFeed, self).get_object(request, format)
user = get_object_or_404(User, username=username)
self.title = _("Badges recently awarded to %s") % user.username
self.link = request.build_absolute_uri(
reverse('badger.views.awards_by_user', args=(user.username, )))
return user
def get_object(self, request, format, username):
super(AwardsByUserFeed, self).get_object(request, format)
user = get_object_or_404(User, username=username)
self.title = _("Badges recently awarded to %s") % user.username
self.link = request.build_absolute_uri(
reverse('badger.views.awards_by_user', args=(user.username,)))
return user
def item_author_link(self, obj):
if not obj.creator:
return None
else:
return self.request.build_absolute_uri(
reverse('badger.views.awards_by_user',
args=(obj.creator.username,)))
def redirect_to(request, url, permanent=True, **kwargs):
"""Like Django's redirect_to except that 'url' is passed to reverse."""
dest = reverse(url, kwargs=kwargs)
if permanent:
return HttpResponsePermanentRedirect(dest)
return HttpResponseRedirect(dest)
def redirect_to(request, url, permanent=True, **kwargs):
"""Like Django's redirect_to except that 'url' is passed to reverse."""
dest = reverse(url, kwargs=kwargs)
if permanent:
return HttpResponsePermanentRedirect(dest)
return HttpResponseRedirect(dest)
def invite(request):
if request.method == 'POST':
f = forms.InviteForm(request.POST)
if f.is_valid():
invite = f.save(commit=False)
invite.inviter = request.user.unique_id
invite.save()
subject = _('Become a Mozillian')
message = _("Hi, I'm sending you this because I think you should "
'join mozillians.org, the community directory for '
'Mozilla contributors like you. You can create a '
'profile for yourself about what you do in the '
'community as well as search for other contributors '
'to learn more about them or get in touch. Check it '
'out.')
# l10n: %s is the registration link.
link = _("Join Mozillians: %s") % invite.get_url()
message = "%s\n\n%s" % (message, link)
send_mail(subject, message, request.user.email,
[invite.recipient])
return HttpResponseRedirect(reverse(invited, args=[invite.id]))
else:
f = forms.InviteForm()
data = dict(form=f, foo='bar')
return jingo.render(request, 'phonebook/invite.html', data)
def item_author_link(self, obj):
if not obj.creator:
return None
else:
return self.request.build_absolute_uri(
reverse('badger.views.awards_by_user',
args=(obj.creator.username, )))
def item_link(self, obj):
return self.request.build_absolute_uri(
reverse('badger.views.award_detail',
args=(
obj.badge.slug,
obj.pk,
)))
def test_issue_award(self):
"""Badge creator can issue award to another user"""
user1 = self._get_user(username="******")
user2 = self._get_user(username="******")
b1 = Badge.objects.create(creator=user1, title="Badge to awarded")
url = reverse('badger.views.award_badge', args=(b1.slug,))
# Non-creator should be denied attempt to award badge
self.client.login(username="******", password="******")
r = self.client.get(url, follow=True)
eq_(403, r.status_code)
# But, the creator should be allowed
self.client.login(username="******", password="******")
r = self.client.get(url, follow=True)
eq_(200, r.status_code)
doc = pq(r.content)
form = doc('form#award_badge')
eq_(1, form.length)
eq_(1, form.find('*[name=user]').length)
eq_(1, form.find('input.submit,button.submit').length)
r = self.client.post(url, dict(
user=user2.id,
), follow=True)
doc = pq(r.content)
logging.debug(r.content)
ok_(b1.is_awarded_to(user2))
def get_object(self, request, format, slug):
super(AwardsByBadgeFeed, self).get_object(request, format)
badge = get_object_or_404(Badge, slug=slug)
self.title = _('Recent awards of "%s"') % badge.title
self.link = request.build_absolute_uri(
reverse('badger.views.awards_by_badge', args=(badge.slug,)))
return badge
def test_mozillian_home(self):
r = self.mozillian_client.get('/', follow=True)
self.assertEquals(200, r.status_code)
self.assertTrue(_logged_in_html(r))
doc = pq(r.content)
profile = reverse('profile', args=[MOZILLIAN['uniq_id']])
eq_(profile, doc('a#profile').attr('href'),
'We see a link to our profile')
def test_unfollowing(self):
"""Test that users can stop following projects."""
self.test_following()
resp = self.client.post(
reverse('projects_unfollow', kwargs={'slug': self.project.slug}),
follow=True,
)
self.assertEqual(resp.context['project'].followers.count(), 0)
def test_unfollowing(self):
"""Test that users can stop following projects."""
self.test_following()
resp = self.client.post(
reverse('projects_unfollow', kwargs={'slug': self.project.slug}),
follow=True,
)
self.assertEqual(resp.context['project'].followers.count(), 0)
def get_object(self, request, format, username):
super(BadgesByUserFeed, self).get_object(request, format)
user = get_object_or_404(User, username=username)
self.title = _(u'Badges recently created by {username}').format(
username=user.username)
self.link = request.build_absolute_uri(
reverse('badger.views.badges_by_user', args=(user.username,)))
return user
def get_object(self, request, format, username):
super(BadgesByUserFeed, self).get_object(request, format)
user = get_object_or_404(User, username=username)
self.title = _(u'Badges recently created by {username}').format(
username=user.username)
self.link = request.build_absolute_uri(
reverse('badger.views.badges_by_user', args=(user.username,)))
return user
def mozillian_client():
client = test.Client()
# We can't use c.login for these tests
url = reverse('login')
data = dict(username=MOZILLIAN['email'], password=PASSWORD)
r = client.post(url, data, follow=True)
eq_(MOZILLIAN['email'], str(r.context['user']))
return client
def vouch(request):
form = forms.VouchForm(request.POST)
if form.is_valid():
ldap = UserSession.connect(request)
data = form.cleaned_data
vouchee = data.get('vouchee')
ldap.record_vouch(data.get('voucher'), vouchee)
return redirect(reverse('profile', args=[vouchee]))
def _do_claim(request, deferred_award):
"""Perform claim of a deferred award"""
if not deferred_award.allows_claim_by(request.user):
return HttpResponseForbidden('Claim denied')
award = deferred_award.claim(request.user)
if award:
url = reverse('badger.views.award_detail',
args=(award.badge.slug, award.id,))
return HttpResponseRedirect(url)
def test_only_owner_not_allowed_to_delete(self):
"""Test a sole project owner is not shown delete form."""
self.assertTrue(
self.client.login(username=self.owner.username,
password=self.owner_password))
self.assertEqual(self.project.owners.count(), 1)
resp = self.client.get(reverse('users_delete'), follow=True)
self.assertTrue(resp.context['problem_projects'])
self.assertContains(resp, 'Oops!')
def test_non_solo_owner_allowed_to_delete(self):
"""Test a non-sole project owner is shown delete form."""
self.project.owners.add(self.profile)
self.assertTrue(
self.client.login(username=self.owner.username,
password=self.owner_password))
self.assertEqual(self.project.owners.count(), 2)
resp = self.client.get(reverse('users_delete'), follow=True)
self.assertFalse(resp.context['problem_projects'])
self.assertNotContains(resp, 'Oops!')
def spark_around(request):
mobile_continents = list(continents_sparked)
mobile_continents.reverse()
data = {'page': 'around',
'prev': reverse('eol.sharing'),
'cities': most_sparked_cities(request.locale),
'countries': most_active_countries(request.locale),
'continents': mobile_continents}
data.update(sharing_messages())
return jingo.render(request, 'eol/mobile/around.html', data)
def test_only_owner_not_allowed_to_delete(self):
"""Test a sole project owner is not shown delete form."""
self.assertTrue(self.client.login(
username=self.owner.username,
password=self.owner_password
))
self.assertEqual(self.project.owners.count(), 1)
resp = self.client.get(reverse('users_delete'), follow=True)
self.assertTrue(resp.context['problem_projects'])
self.assertContains(resp, 'Oops!')
def test_owner_cannot_add_links_without_ajax(self):
"""Test that no one can post to the addlink url without ajax"""
self.assertTrue(self.client.login(
username=self.owner.username,
password=self.owner_password
))
link_url = 'http://eldudarino.com/2012/03/12/donnie-wasnt-listening'
self.client.post(reverse(
'projects_links_add',
kwargs={'slug': self.project.slug},
), {
'name': "The Dude's Story",
'url': link_url,
})
resp = self.client.get(reverse(
'projects_links_list',
kwargs={'slug': self.project.slug},
), follow=True, HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertNotContains(resp, link_url)
def apply(request):
"""Display the form to add a new Application to the database."""
if request.method == 'POST':
form = ApplicationForm(request.POST)
if form.is_valid(): # All validation rules pass; form is savable.
form.save()
return http.HttpResponseRedirect(reverse('thanks'))
else:
form = ApplicationForm()
return jingo.render(request, 'apply/apply.html', {'form': form})
def test_delete_owner_not_delete_project(self):
self.assertTrue(
self.client.login(username=self.owner.username,
password=self.owner_password))
self.assertEqual(self.project.owners.count(), 1)
self.client.post(reverse('users_delete'), follow=True)
with self.assertRaises(User.DoesNotExist):
User.objects.get(username=self.owner.username)
with self.assertRaises(Profile.DoesNotExist):
Profile.objects.get(pk=self.owner_profile.pk)
self.assertEqual(self.project, Project.objects.get(pk=self.project.pk))
self.assertEqual(self.project.owners.count(), 0)
def test_following(self):
"""Test that users can follow projects."""
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
resp = self.client.get(self.project.get_absolute_url(), follow=True)
self.assertEqual(resp.context['project'].followers.count(), 0)
resp = self.client.post(
reverse('projects_follow', kwargs={'slug': self.project.slug}),
follow=True,
)
self.assertEqual(resp.context['project'].followers.count(), 1)
def test_owner_cannot_add_links_without_ajax(self):
"""Test that no one can post to the addlink url without ajax"""
self.assertTrue(
self.client.login(username=self.owner.username,
password=self.owner_password))
link_url = 'http://eldudarino.com/2012/03/12/donnie-wasnt-listening'
self.client.post(
reverse(
'projects_links_add',
kwargs={'slug': self.project.slug},
), {
'name': "The Dude's Story",
'url': link_url,
})
resp = self.client.get(reverse(
'projects_links_list',
kwargs={'slug': self.project.slug},
),
follow=True,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertNotContains(resp, link_url)
def test_award_feeds(self):
"""Can view award detail"""
user = self._get_user()
user2 = self._get_user(username='******')
b1, created = Badge.objects.get_or_create(creator=user,
title="Code Badge #1")
award = b1.award_to(user2)
# The award should show up in each of these feeds.
feed_urls = (
reverse('badger.feeds.awards_recent', args=('atom', )),
reverse('badger.feeds.awards_by_badge', args=(
'atom',
b1.slug,
)),
reverse('badger.feeds.awards_by_user',
args=(
'atom',
user2.username,
)),
)
# Check each of the feeds
for feed_url in feed_urls:
r = self.client.get(feed_url, follow=True)
# The feed should be parsed without issues by feedparser
feed = feedparser.parse(r.content)
eq_(0, feed.bozo)
# Look through entries for the badge title
found_it = False
for entry in feed.entries:
if b1.title in entry.title and user2.username in entry.title:
found_it = True
ok_(found_it)
def test_award_detail(self):
"""Can view award detail"""
user = self._get_user()
user2 = self._get_user(username='******')
b1, created = Badge.objects.get_or_create(creator=user,
title="Code Badge #1")
award = b1.award_to(user2)
url = reverse('badger.views.award_detail', args=(
b1.slug,
award.pk,
))
r = self.client.get(url, follow=True)
doc = pq(r.content)
eq_('award_detail', doc.find('body').attr('id'))
eq_(
1,
doc.find('.awarded_to .username:contains("%s")' %
user2.username).length)
eq_(1, doc.find('.badge .title:contains("%s")' % b1.title).length)
# Now, take a look at the JSON format
url = reverse('badger.award_detail_json', args=(
b1.slug,
award.pk,
))
r = self.client.get(url, follow=True)
data = simplejson.loads(r.content)
eq_(award.user.email, data['recipient'])
eq_('http://testserver%s' % award.get_absolute_url(), data['evidence'])
eq_(award.badge.title, data['badge']['name'])
eq_(award.badge.description, data['badge']['description'])
eq_('http://testserver%s' % award.badge.get_absolute_url(),
data['badge']['criteria'])
def test_owner_can_delete_project_links(self):
"""Test that a project owner can delete links"""
self.assertTrue(
self.client.login(username=self.owner.username,
password=self.owner_password))
link = Link.objects.create(
project=self.project,
name='Testing',
url='http://example.com',
)
resp = self.client.post(reverse('projects_links_delete',
kwargs={'pk': link.pk}),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(resp.status_code, 204)
with self.assertRaises(Link.DoesNotExist):
Link.objects.get(pk=link.pk)
def test_non_owner_cannot_delete_project_links(self):
"""Test that only the project owner can delete links"""
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
link = Link.objects.create(
project=self.project,
name='Testing',
url='http://example.com',
)
resp = self.client.post(reverse('projects_links_delete',
kwargs={'pk': link.pk}),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(resp.status_code, 403)
resp = self.client.get(self.project.get_absolute_url(), follow=True)
self.assertContains(resp, link.url)
def test_cannot_list_project_links_without_ajax(self):
"""Test that the project links list view is ajax only"""
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
Link.objects.create(
project=self.project,
name='Testing',
url='http://example.com',
)
resp = self.client.get(reverse(
'projects_links_list',
kwargs={'slug': self.project.slug},
),
follow=True)
self.assertEqual(resp.status_code, 403)
def profile_edit(request, username):
user = get_object_or_404(User, username=username)
profile = user.get_profile()
if not profile.allows_edit(request.user):
return HttpResponseForbidden()
user_form = None
if request.method != "POST":
if profile.can_change_username(user):
user_form = UserEditForm(profile=profile)
profile_form = UserProfileEditForm(instance=profile)
else:
username = profile.user.username
is_valid = True
if profile.can_change_username(user):
user_form = UserEditForm(request.POST, profile=profile)
if user_form.is_valid():
username = user_form.cleaned_data['username']
profile.change_username(username)
else:
is_valid = False
profile_form = UserProfileEditForm(request.POST,
request.FILES,
instance=profile)
if is_valid and profile_form.is_valid():
profile = profile_form.save(commit=False)
profile.save()
profile_form.save_m2m()
else:
is_valid = False
if is_valid:
return HttpResponseRedirect(
reverse('profiles.profile_view', args=(username, )))
return render_to_response('profiles/profile_edit.html',
dict(
user_form=user_form,
profile_form=profile_form,
user=user,
profile=profile,
),
context_instance=RequestContext(request))
