def test_profile_view_reversal(self):
"""
The profile view can be reversed for usernames containing "weird" but
valid username characters.
"""
for username in ['asdf', '@asdf', 'asd-f', 'as.df', 'as+df']:
reverse('user_profile', host='www', args=[username])
def auphonic_callback(request, slug):
token = request.GET["code"]
show = Show.objects.get(slug=slug)
if not request.user.has_perm('radioportal.change_show', show):
return HttpResponse('Unauthorized', status=401)
url = "https://auphonic.com/oauth2/token/"
cb = reverse('admin-show-notification-auphonic-callback', kwargs={'slug': slug}, host='dashboard')
data = {
'client_id': settings.AUPHONIC_CLIENT_ID,
'client_secret': settings.AUPHONIC_CLIENT_SECRET,
'redirect_uri': cb,
'grant_type': "authorization_code",
'code': token
}
r = requests.post(url, data=data)
if r.status_code == 200:
res = r.json()
token = res["access_token"]
url = "https://auphonic.com/api/user.json"
headers = {"Authorization": "Bearer %s" % token}
r = requests.get(url, headers=headers)
if r.status_code == 200:
res = r.json()
account, created = AuphonicAccount.objects.get_or_create(userid=res["data"]["user_id"], primarynotification__show__slug=slug)
account.access_token = token
account.username = res["data"]["username"]
account.save()
if created:
start = NotificationTemplate()
start.save()
stop = NotificationTemplate()
stop.save()
rollover = NotificationTemplate()
rollover.save()
noti = PrimaryNotification(path=account, start=start, stop=stop,
rollover=rollover, show=show)
noti.save()
kwargs = {'slug': slug, "path": "auphonic", "nslug": noti.id}
url = reverse('admin-show-notification-edit',
kwargs=kwargs, host='dashboard')
url = reverse('admin-show-notification',
kwargs={'slug': slug}, host='dashboard')
return redirect(url)
def done(self, form_list, **kwargs):
new_user = form_list[0].save(commit=False)
new_username = ("%s%s" % (new_user.first_name, new_user.last_name)).lower()
user_pw = None
if User.objects.filter(username=new_username, email=new_user.email).exists():
user = User.objects.get(username=new_username, email=new_user.email)
else:
user = new_user
user_pw = User.objects.make_random_password()
user.set_password(user_pw)
user.username = new_username
user.save()
show = form_list[1].save()
channel = form_list[2].save(commit=False)
channel.mapping_method = '["find-from-title","make-from-title","find-or-make-live"]'
channel.save()
channel.show.add(show)
stream = form_list[3].save(commit=False)
stream.user = "******"
stream_pw = User.objects.make_random_password()
stream.password = stream_pw
stream.channel = channel
stream.save()
assign('radioportal.change_channel', user, channel)
assign('radioportal.change_stream', user, channel)
assign('radioportal.change_episodes', user, show)
assign('radioportal.change_show', user, show)
mail_data = {
'username': user.username,
'password': user_pw,
'dashboard_url': reverse('dashboard', host='dashboard'),
'wiki_url': reverse('landing', host='wiki'),
'wiki_communication_url': reverse('wiki-category-page', kwargs={'category': 'project', 'page': 'communication'}, host='wiki'),
}
mail_text = render_to_string("radioportal/dashboard/usercreatedmail_user.txt", mail_data)
mail_subject = _("[xenim] Neuer Nutzer erstellt")
send_mail(mail_subject, mail_text, "*****@*****.**", [user.email,])
if 'rt_id' in self.storage.extra_data:
mail_data_rt = {'username': user.username, 'showname': show.name, 'channel': channel.cluster, 'streamname': stream.mount}
mail_text_rt = render_to_string("radioportal/dashboard/usercreatedmail_rt.txt", mail_data_rt)
mail_subject_rt = _("[xsn #%i] Neuer Nutzer") % self.storage.extra_data['rt_id']
send_mail(mail_subject_rt, mail_text_rt, "*****@*****.**", ["*****@*****.**",])
return HttpResponseRedirect(reverse('dashboard', host='dashboard'))
def document_url(doc):
if doc.path:
kwargs = {
'lang': doc.release.lang,
'version': doc.release.version,
'url': doc.path,
}
return reverse('document-detail', host='docs', kwargs=kwargs)
else:
kwargs = {
'lang': doc.release.lang,
'version': doc.release.version,
}
return reverse('document-index', host='docs', kwargs=kwargs)
def test_register(self):
"""Testing the registration process"""
# we will check that another user has been created at the end of the process
original_user_count = EmailUser.objects.count()
# check user is not logged in at this point
self.assertNotIn('_auth_user_id', self.client.session)
response = self.client.post(reverse('social:complete', kwargs={'backend': "email"}, host='ledger'), {'email': NEW_USER_EMAIL})
# check response status is 302 - REDIRECT and redirects to validation complete
# self.assertRedirects(response, reverse('accounts:validation_sent', host='ledger'), status_code=302, target_status_code=200)
# check user is not logged in at this point
self.assertNotIn('_auth_user_id', self.client.session)
# check that a login token has been emailed to the user
self.assertEqual(len(mail.outbox), 1)
received_email = mail.outbox[0]
# check the email is from the system
self.assertEqual(received_email.from_email, settings.EMAIL_FROM)
# check that the content contains a link
self.assertIn('http', received_email.body)
login_verification_url = re.search('(?P<url>https?://[^\s]+)', received_email.body).group('url')
response = self.client.get(login_verification_url, follow=True)
def ical_feed(request, show_name=None):
cal = vobject.iCalendar()
cal.add('method').value = 'PUBLISH' # IE/Outlook needs this
str = ""
if show_name:
show = get_object_or_404(Show, slug=show_name)
str= " for %s" % show.name
cal.add('X-WR-CALNAME').value = "Upcoming episodes%s on xsn" % str
cal.add('X-WR-TIMEZONE').value = settings.TIME_ZONE
ep = Episode.objects.filter(status='UPCOMING')
if show_name:
ep = ep.filter(show__slug=show_name)
for episode in ep.annotate(beginfilter=Min('parts__begin')).order_by('-beginfilter')[:30]:
vevent = cal.add('vevent')
val = "%s: %s" % (episode.slug, episode.title())
vevent.add('summary').value = val
vevent.add('description').value = episode.description()
vevent.add('dtstart').value = episode.begin()
if episode.end():
vevent.add('dtend').value = episode.end()
vevent.add('uid').value = '%s' % episode.pk
kwargs = {'show_name': episode.show.slug, 'slug': episode.slug}
vevent.add('url').value = reverse("episode", kwargs=kwargs, host='www')
icalstream = cal.serialize()
response = HttpResponse(icalstream, content_type='text/calendar')
#response['Filename'] = 'filename.ics' # IE needs this
#response['Content-Disposition'] = 'attachment; filename=filename.ics'
return response
def item_extra_kwargs(self, item):
#print type(item), type(item.begin), type(item.end)
tz = pytz.timezone(settings.TIME_ZONE)
begin = item.begin()
if begin:
begin = tz.localize(begin)
end = item.end
if end:
end = tz.localize(end)
extra_dict = {
'begin': begin,
'end': end,
}
if item.status == "RUNNING":
try:
extra_dict['streams'] = []
for stream in item.channel.stream_set.all():
if not stream.running:
continue
url = reverse("mount", kwargs={'stream':stream.mount}, host='www')
extra_dict['streams'].append(url)
extra_dict['listener'] = str(item.channel.listener)
extra_dict['channel'] = item.channel.cluster
extra_dict['current_song'] = item.channel.streamCurrentSong
except Channel.DoesNotExist:
pass
if item.show.icon:
extra_dict['icon'] = item.show.icon.url
if item.url:
extra_dict['website'] = item.url()
extra_dict['slug'] = item.slug
return extra_dict
def test_metric_json(self):
TracTicketMetric.objects.get(slug='new-tickets-week').data.create(measurement=42)
request = self.factory.get(reverse('metric-json', args=['new-tickets-week'],
host='dashboard'))
response = metric_json(request, 'new-tickets-week')
self.assertEqual(json.loads(response.content.decode())['data'][0][1], 42)
self.assertEqual(response.status_code, 200)
def test_add_document_successful_route(self):
response = self.client.post(reverse('file-upload', kwargs={'slug': self.estate.slug}),
data={'name': 'Document',
'occupant_viewable': 'True',
'folder': self.folder.id,
'file': SimpleUploadedFile('file.txt', 'file_content')})
self.assertEquals(response.status_code, 302)
def test_update_document_unsuccessful_route(self):
response = self.client.post(reverse('file-update', kwargs={'slug': self.estate.slug}),
data={'id': self.document.id,
'name': '',
'folder': self.folder.id,
'occupant_viewable': ''})
self.assertEquals(response.status_code, 302)
self.assertNotEquals(self.estate.document_set.first().name, '')
def get_absolute_url(self):
kwargs = {
"year": self.pub_date.year,
"month": self.pub_date.strftime("%b").lower(),
"day": self.pub_date.strftime("%d").lower(),
"slug": self.slug,
}
return reverse("weblog:entry", kwargs=kwargs)
def get_absolute_url(self):
kwargs = {
'year': self.pub_date.year,
'month': self.pub_date.strftime('%b').lower(),
'day': self.pub_date.strftime('%d').lower(),
'slug': self.slug,
}
return reverse('weblog:entry', kwargs=kwargs)
def test_index(self):
for MC in Metric.__subclasses__():
for metric in MC.objects.filter(show_on_dashboard=True):
metric.data.create(measurement=42)
request = self.factory.get(reverse('dashboard-index', host='dashboard'))
response = index(request)
self.assertContains(response, 'Development dashboard')
self.assertEqual(response.content.count(b'<div class="metric'), 13)
self.assertEqual(response.content.count(b'42'), 13)
def test_metric_404(self):
request = self.factory.get(reverse('metric-detail', args=['new-tickets-week'],
host='dashboard'))
self.assertRaisesRegexp(
Http404,
'Could not find metric with slug [\w-]+',
metric_detail,
request,
'404'
)
def fetch_initial(self):
id = self.kwargs.get('id', None)
if not id:
return
kwargs = {'api_name': 'v1', 'resource_name': 'application', 'pk': id}
url = reverse('api_dispatch_detail', kwargs=kwargs, host="review")
header = {'Authorization': 'ApiKey %s:%s' % (self.request.user.username, self.request.user.api_key.key)}
r = requests.get(url, params={'format':'json'}, headers=header, verify=False)
if not r.status_code == 200:
return
return r.json()
def test_logout(self):
"""Testing that a user can logout"""
self.client.force_login(EmailUser.objects.first(), backend=settings.AUTHENTICATION_BACKENDS[0])
response = self.client.get(reverse('accounts:logout', host='ledger'))
# check response status is 302 - REDIRECT
self.assertRedirects(response, settings.SOCIAL_AUTH_LOGIN_REDIRECT_URL, status_code=302, target_status_code=200)
# check user is not logged out
self.assertNotIn('_auth_user_id', self.client.session)
def get_absolute_url(self):
reverse_args = {
'viewname': self._view(),
'args': self._reverse_args(),
}
if 'django_hosts' in settings.INSTALLED_APPS:
reverse_args.update({
'host': self._host_name(),
'port': meringue_settings.PORT,
})
return reverse(**reverse_args)
def auphonic_gettoken(request, slug):
show = Show.objects.get(slug=slug)
if not request.user.has_perm('radioportal.change_show', show):
return HttpResponse('Unauthorized', status=401)
url = "https://auphonic.com/oauth2/authorize/?client_id={client_id}&redirect_uri={redirect_uri}&response_type=code"
cb = reverse('admin-show-notification-auphonic-callback', kwargs={'slug': slug}, host='dashboard')
cb = quote_plus(cb)
return redirect(url.format(client_id=settings.AUPHONIC_CLIENT_ID, redirect_uri=cb))
def redirect_search(request):
"""
Legacy search view to handle old queries correctly, e.g. in scraping
sites, command line interface etc.
"""
release = DocumentRelease.objects.current()
kwargs = {"lang": release.lang, "version": release.version}
search_url = reverse("document-search", host="docs", kwargs=kwargs)
q = request.GET.get("q") or None
if q:
search_url += "?q=%s" % q
return redirect(search_url)
def twitter_gettoken(request, slug, path):
"""
Request auth tokens from twitter and redirect user to confirm
authorization. Solved with redirect to prevent timeout of tokens.
"""
twitter = Twython(settings.TWITTER_CONSUMER_KEY,
settings.TWITTER_CONSUMER_SECRET)
cb = reverse('admin-show-notification-twitter-callback',
kwargs={'slug': slug, 'path': path}, host='dashboard')
auth = twitter.get_authentication_tokens(callback_url=cb)
request.session['twitter_%s_oauth_token' % path] = auth['oauth_token']
request.session[
'twitter_%s_oauth_token_secret' % path] = auth['oauth_token_secret']
return redirect(auth['auth_url'])
def redirect_search(request):
"""
Legacy search view to handle old queries correctly, e.g. in scraping
sites, command line interface etc.
"""
release = DocumentRelease.objects.current()
kwargs = {
'lang': release.lang,
'version': release.version,
}
search_url = reverse('document-search', host='docs', kwargs=kwargs)
q = request.GET.get('q') or None
if q:
search_url += '?q=%s' % q
return redirect(search_url)
def sitemap_index(request, sitemaps):
"""
Simplified version of django.contrib.sitemaps.views.index that uses
django_hosts for URL reversing.
"""
sites = []
for section in sitemaps.keys():
sitemap_url = reverse('document-sitemap', host='docs', kwargs={'section': section})
sites.append(sitemap_url)
return TemplateResponse(
request,
'sitemap_index.xml',
{'sitemaps': sites},
content_type='application/xml',
)
def search_suggestions(request, lang, version, per_page=20):
"""
The endpoint for the OpenSearch browser integration.
This will do a simple prefix match against the title to catch
documents with a meaningful title.
The link list contains redirect URLs so that IE will correctly
redirect to those documents.
"""
try:
release = DocumentRelease.objects.get_by_version_and_lang(version, lang)
except DocumentRelease.DoesNotExist:
raise Http404
form = DocSearchForm(request.GET or None, release=release)
suggestions = []
if form.is_valid():
q = form.cleaned_data.get('q')
if q:
search = DocumentDocType.search()
search = (search.query(query.SimpleQueryString(fields=['title^10',
'content'],
query=q,
analyzer='stop',
default_operator='and'))
.filter('term', release__lang=release.lang)
.filter('term', release__version=release.version)
.source(includes=['title']))
suggestions.append(q)
titles = []
links = []
content_type = ContentType.objects.get_for_model(Document)
results = search[0:per_page].execute()
for result in results:
titles.append(result.title)
kwargs = {
'content_type_id': content_type.pk,
'object_id': result.meta.id,
}
links.append(reverse('contenttypes-shortcut', kwargs=kwargs))
suggestions.append(titles)
suggestions.append([])
suggestions.append(links)
return JsonResponse(suggestions, safe=False)
def search_suggestions(request, lang, version, per_page=20):
"""
The endpoint for the OpenSearch browser integration.
This will do a simple prefix match against the title to catch
documents with a meaningful title.
The link list contains redirect URLs so that IE will correctly
redirect to those documents.
"""
try:
release = DocumentRelease.objects.get_by_version_and_lang(version, lang)
except DocumentRelease.DoesNotExist:
raise Http404
activate(lang)
form = DocSearchForm(request.GET or None, release=release)
suggestions = []
if form.is_valid():
q = form.cleaned_data.get('q')
if q:
results = Document.objects.filter(
release__lang=release.lang,
).filter(
release__release__version=release.version,
).filter(
title__contains=q,
)
suggestions.append(q)
titles = []
links = []
content_type = ContentType.objects.get_for_model(Document)
for result in results:
titles.append(result.title)
kwargs = {
'content_type_id': content_type.pk,
'object_id': result.id,
}
links.append(reverse('contenttypes-shortcut', kwargs=kwargs))
suggestions.append(titles)
suggestions.append([])
suggestions.append(links)
return JsonResponse(suggestions, safe=False)
def release_notes(version, show_version=False):
version_x_dot_y = version[:3]
is_pre_release = any(c in version for c in ("a", "b", "c"))
# links for prereleases don't have their own release notes
display_version = version_x_dot_y if is_pre_release else version
if show_version:
anchor_text = _("%(version)s release notes") % {"version": display_version}
else:
anchor_text = _("Online documentation")
release_notes_path = "releases/%s" % display_version
return format_html(
'<a href="{url}">{anchor_text}</a>',
url=reverse(
"document-detail", host="docs", kwargs={"lang": "en", "version": version_x_dot_y, "url": release_notes_path}
),
anchor_text=anchor_text,
)
def release_notes(version, show_version=False):
version_x_dot_y = version[:3]
is_pre_release = any(c in version for c in ('a', 'b', 'c'))
# links for prereleases don't have their own release notes
display_version = version_x_dot_y if is_pre_release else version
if show_version:
anchor_text = _('%(version)s release notes') % {'version': display_version}
else:
anchor_text = _('Online documentation')
release_notes_path = 'releases/%s' % display_version
return '<a href="%(url)s">%(anchor_text)s</a>' % {
'url': reverse(
'document-detail',
host='docs',
kwargs={'lang': 'en', 'version': version_x_dot_y, 'url': release_notes_path},
),
'anchor_text': anchor_text,
}
def search_suggestions(request, lang, version, per_page=20):
"""
The endpoint for the OpenSearch browser integration.
This will do a simple prefix match against the title to catch
documents with a meaningful title.
The link list contains redirect URLs so that IE will correctly
redirect to those documents.
"""
release = get_object_or_404(DocumentRelease, version=version, lang=lang)
form = DocSearchForm(request.GET or None, release=release)
suggestions = []
if form.is_valid():
q = form.cleaned_data.get("q")
if q:
search = DocumentDocType.search()
search = (
search.query(
query.SimpleQueryString(
fields=["title^10", "content"], query=q, analyzer="stop", default_operator="and"
)
)
.filter("term", release__lang=release.lang)
.filter("term", release__version=release.version)
.fields(["title", "_source"])
)
suggestions.append(q)
titles = []
links = []
content_type = ContentType.objects.get_for_model(Document)
results = search[0:per_page].execute()
for result in results:
titles.append(result.title)
kwargs = {"content_type_id": content_type.pk, "object_id": result.meta.id}
links.append(reverse("django.contrib.contenttypes.views.shortcut", kwargs=kwargs))
suggestions.append(titles)
suggestions.append([])
suggestions.append(links)
return JsonResponse(suggestions, safe=False)
def release_notes(version, show_version=False):
version_x_dot_y = '.'.join(str(x) for x in LooseVersion(version).version[:2])
is_pre_release = any(c in version for c in ('a', 'b', 'c'))
# links for prereleases don't have their own release notes
display_version = version_x_dot_y if is_pre_release else version
if show_version:
anchor_text = _('%(version)s release notes') % {'version': display_version}
else:
anchor_text = _('Online documentation')
release_notes_path = 'releases/%s' % display_version
return format_html(
'<a href="{url}">{anchor_text}</a>',
url=reverse(
'document-detail',
host='docs',
kwargs={'lang': 'en', 'version': version_x_dot_y, 'url': release_notes_path},
),
anchor_text=anchor_text,
)
def get_absolute_url(self):
return reverse('shortener',
kwargs={'shortcode': self.shortcode},
host='www',
scheme='http',
port='8000')
def test_valid_log_url(self):
expected_url = reverse('logs', host="staff", args=(1,))
[context] = MessageDeletionContext.objects.all()
self.assertEqual(context.log_url, expected_url)
def test_accepts_valid_data_and_sets_actor(self):
url = reverse('bot:messagedeletioncontext-list', host='api')
response = self.client.post(url, data=self.data)
self.assertEqual(response.status_code, 201)
[context] = MessageDeletionContext.objects.all()
self.assertEqual(context.actor.id, self.actor.id)
def test_partial_update_returns_401(self):
url = reverse('bot:infraction-detail', args=(5, ), host='api')
response = self.client.patch(url, data={'reason': 'Have a nice day.'})
self.assertEqual(response.status_code, 401)
def test_create_returns_401(self):
url = reverse('bot:infraction-list', host='api')
response = self.client.post(url, data={'reason': 'Have a nice day.'})
self.assertEqual(response.status_code, 401)
def test_list_all_packages_shows_created_package(self):
url = reverse('bot:documentationlink-list', host='api')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), [self.doc_json])
def test_authenticated(self):
"""If the user is authenticated, the homepage should redirect to their profile."""
user = UserFactory()
response = http_get_response(self.url, self.view, user)
eq_(response.status_code, 302)
eq_(response.url, reverse('profile', host='foiamachine'))
def assertView(self, name):
self.assertContains(self.client.get(reverse(name, host='www')), 'django')
def test_filter_search(self):
url = reverse('bot:reminder-list', host='api')
response = self.client.get(f'{url}?search={self.author.name}')
self.assertEqual(response.status_code, 200)
self.assertCountEqual(response.json(), [self.rem_dict_one, self.rem_dict_two])
def test_list_returns_401(self):
url = reverse('bot:reminder-list', host='api')
response = self.client.get(url)
self.assertEqual(response.status_code, 401)
def test_can_access_healthcheck_view(self):
url = reverse('healthcheck', host='api')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), {'status': 'ok'})
def get_short_url(self):
url_path = reverse("scode",
kwargs={'shortcode': self.shortcode},
host='www',
scheme='http')
return url_path
def test_create_invalid_body_returns_400(self):
url = reverse('bot:documentationlink-list', host='api')
response = self.client.post(url, data={'i': 'am', 'totally': 'valid'})
self.assertEqual(response.status_code, 400)
def test_create_returns_401(self):
url = reverse('bot:documentationlink-list', host='api')
response = self.client.post(url, data={'hi': 'there'})
self.assertEqual(response.status_code, 401)
def get_absolute_url(self):
return reverse('fundraising:thank-you', kwargs={'donation': self.id})
def test_returns_empty_for_no_match(self):
url = reverse('bot:infraction-list', host='api')
response = self.client.get(f'{url}?type=ban&search=poop')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()), 0)
def test_package_in_full_list(self):
url = reverse('bot:documentationlink-list', host='api')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), [self.body])
def test_ignores_bad_filters(self):
url = reverse('bot:infraction-list', host='api')
response = self.client.get(f'{url}?type=ban&hidden=maybe&foo=bar')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()), 2)
def test_list_all_returns_empty_list(self):
url = reverse('bot:documentationlink-list', host='api')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), [])
def test_retrieve_returns_404_for_absent_id(self):
url = reverse('bot:infraction-detail', args=(1337, ), host='api')
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
def setUp(self):
self.view = auth.views.login
self.url = reverse('login', host='foiamachine')
self.password = '******'
self.user = UserFactory(password=self.password)
def test_detail_lookup_returns_401(self):
url = reverse('bot:infraction-detail', args=(5, ), host='api')
response = self.client.get(url)
self.assertEqual(response.status_code, 401)
def assertView(self, name):
self.assertContains(self.client.get(reverse(name, host='www')), 'django')
def setUp(self):
self.view = auth.views.password_reset
self.url = reverse('password-reset', host='foiamachine')
self.user = UserFactory()
def test_delete_known_reminder_returns_204(self):
url = reverse('bot:reminder-detail', args=(self.reminder.id,), host='api')
response = self.client.delete(url)
self.assertEqual(response.status_code, 204)
self.assertRaises(Reminder.DoesNotExist, Reminder.objects.get, id=self.reminder.id)
def setUp(self):
self.view = views.Signup.as_view()
self.url = reverse('signup', host='foiamachine')
def test_reminders_in_full_list(self):
url = reverse('bot:reminder-list', host='api')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertCountEqual(response.json(), [self.rem_dict_one, self.rem_dict_two])
def get_absolute_url(self):
kwargs = {
'lang': self.lang,
'version': self.version,
}
return reverse('document-index', host='docs', kwargs=kwargs)
def test_filter_field(self):
url = reverse('bot:reminder-list', host='api')
response = self.client.get(f'{url}?active=true')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), [self.rem_dict_one])
def test_scanmodalview(self):
resolvers.reverse('scanner_modal', host='dashboard')
self.assertTrue(True)
def get_absolute_url(self):
return reverse('fundraising:thank-you', kwargs={'donation': self.id})
def get_short_url(self):
return reverse('scode',
kwargs={'shortcode': self.shortcode},
host='www',
scheme='http')
