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 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_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 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 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))