def test_viewing_saved_notepad_content(self):
self.login_as(email='*****@*****.**', password='******')
data = {
'name':
'My last semister Assignment',
'short_description':
'',
'content':
open("/".join(
[settings.ROOT_PATH, 'users', 'fixtures',
'assignment.py'])).read(),
'public':
True
}
response = self.client.post(
path=url_reverse('users.views.view_notepad'), data=data)
self.assertTrue(response)
response = self.client.get(
url_reverse('users.views.view_note',
args=(Note.objects.get(name=data['name']).id, )))
self.assertTrue(response)
self.assertEquals(response['Content-Type'], 'text/plain')
self.assertEquals(
str(response.content).strip(),
str(data['content']).strip())
def view_webresume(request):
userprofile = loggedin_userprofile(request)
if userprofile.can_update_slug():
from users.messages import NEED_TO_PICK_A_WEBRESUME_URL_MESSAGE
messages.error(request, NEED_TO_PICK_A_WEBRESUME_URL_MESSAGE)
return HttpResponseRedirect(url_reverse('users.views.view_account_settings'))
return HttpResponseRedirect(redirect_to=url_reverse('users.views.view_userprofile', args=(userprofile.slug,)))
def test_modify_snippet_url(self):
self.assertEquals(Snippet.objects.count(), 0)
login_done = self.client.login(username='******', password='******')
self.assertTrue(login_done)
form_data = {'title':'Some Snippet',
'explanation':'Some Snippet',
'code':'x=0',
'public':False,
'lang':'py',
'tags':'angry pythonista'}
self.client.post(url_reverse('quest.views.view_add_snippet'),
form_data)
snippet = Snippet.objects.latest()
response = self.client.get(url_reverse('quest.views.view_modify_snippet',
args=(snippet.id, snippet.slug)))
self.assertTrue(response)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'add_snippet.html')
context = response.context[0]
form = context.get('form')
self.assertFalse(form.errors)
self.assertEquals(form.cleaned_data.get('title'), form_data['title'])
self.assertEquals(form.cleaned_data.get('explanation'), form_data['explanation'])
self.assertEquals(form.cleaned_data.get('code'), form_data['code'])
self.assertEquals(form.cleaned_data.get('lang'), form_data['lang'])
self.assertFalse(form.cleaned_data.get('public'))
def test_userprofilepage_success_response(self):
userprofile = UserProfile.objects.get(
user__email='*****@*****.**')
response = self.client.get(path=url_reverse(
'users.views.view_userprofile', args=(userprofile.slug, )))
self.assertTrue(response)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'user_profile.html')
context = response.context[0]
self.assertTrue(context.has_key('userprofile'))
userprofile = context.get('userprofile')
self.assertEquals(
userprofile.user.email,
UserProfile.objects.get(
user__email='*****@*****.**').user.email)
self.assertTrue(context.has_key('public_notes'))
self.login_as(email='*****@*****.**', password='******')
form_data = {
'name': 'My Python Assignment',
'short_description': 'Hello World',
'content': 'print "Hello World"',
'public': True
}
response = self.client.post(
path=url_reverse('users.views.view_notepad'), data=form_data)
self.logout()
response = self.client.get(path=url_reverse(
'users.views.view_userprofile', args=(userprofile.slug, )))
context = response.context[0]
public_notes = context.get('public_notes')
self.assertTrue(public_notes)
self.assertEquals(len(public_notes), 1)
self.assertEquals(form_data['name'], public_notes[0]['name'])
self.assertTrue(context.has_key('asked_questions'))
self.assertTrue(context.has_key('answered_questions'))
def test_valid_signup(self):
form_data = {
'email': '*****@*****.**',
'password': '******',
'name': 'somename',
'college': 'CBIT, Hyderabad.'
}
response = self.client.post(
path='/accounts/studentregister/', #TODO:url hardcoding is bad.
data=form_data)
self.assertRedirects(
response,
expected_url=url_reverse('users.views.view_homepage'),
status_code=302,
target_status_code=200)
response = self.client.get(
path=url_reverse('users.views.view_homepage'))
self.assertTemplateUsed(response, 'dashboard.html')
context = response.context[0]
self.assertTrue(context.has_key('userprofile'))
userprofile = context.get('userprofile')
self.assertTrue(userprofile)
self.assertEquals(userprofile.user.email, form_data['email'])
self.assertTrue(userprofile.check_password(form_data['password']))
self.assertTrue(context.has_key('userprofilegroup'))
userprofilegroup = context.get('userprofilegroup')
self.assertEquals(userprofilegroup, 'Student')
def test_saving_domain_url_once_and_twice(self):
self.login_as(email='*****@*****.**', password='******')
response = self.client.get(path=url_reverse('users.views.view_account_settings'))
context = response.context[0]
self.assertTrue(context.has_key('personal_form'))
personal_form = context.get('personal_form')
self.assertTrue(personal_form.errors)
data = {'name':'Nanda.B',
'new_password':'******',
'slug':'nandakishore'}
response = self.client.post(path=url_reverse('users.views.view_save_personal_settings'),
data=data,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertTrue(response)
context = response.context
self.assertTrue(context.has_key('personal_form'))
personal_form = context.get('personal_form')
self.assertFalse(personal_form.errors)
userprofile = context.get('userprofile')
self.assertTrue(userprofile.check_password(data['new_password']))
from django.contrib.sites.models import Site
self.assertEqual(userprofile.domain, ".".join([userprofile.slug, Site.objects.get(id=settings.SITE_ID).domain]))
self.assertEqual(userprofile.name, data['name'])
response = self.client.get(path=url_reverse('users.views.view_account_settings'))
self.assertTrue(userprofile.domain in response.content)
from users.models import CantUpdateSlugAgainException
self.assertRaises(CantUpdateSlugAgainException,
userprofile.update_slug,
new_slug_name='newslug')
def test_asking_a_question_with_xss(self):
self.login_as(email='*****@*****.**', password='******')
question_data = {
'title': 'How is Stud2dotoh Hiring ?',
'description':
'Stud2dotoh! <script>alert("I will shoot you in the head")</script>',
'tags': 'sometag'
}
response = self.client.post(
url_reverse('quest.views.view_ask_question'), question_data)
question = Question.objects.latest()
self.assertRedirects(response,
expected_url=url_reverse(
'quest.views.view_question',
args=(question.id, question.slug)),
status_code=302,
target_status_code=200)
response = self.client.get(
url_reverse('quest.views.view_question',
args=(question.id, question.slug)))
self.assertTrue(response)
context = response.context[0]
question = context.get('question')
question_description = question.description
self.assertTrue(question_description)
self.assertFalse(question_data['description'] in question_description)
self.assertFalse('<script>' in question_description)
def test_unaccepting_an_answer_of_a_question(self):
question = Question.objects.latest()
answer = question.answers[0]
self.login_as(email='*****@*****.**', password='******')
response = self.client.post(url_reverse(
'quest.views.view_accept_answer', args=(question.id, )),
data={
'question_id': question.id,
'answer_id': answer.id
})
self.assertTrue(response)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'answers.html')
self.assertTrue(Answer.objects.get(id=answer.id).accepted)
answer = question.answers[1]
response = self.client.post(url_reverse(
'quest.views.view_accept_answer', args=(question.id, )),
data={
'question_id': question.id,
'answer_id': answer.id
})
self.assertTrue(response)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'answers.html')
self.assertTrue(Answer.objects.get(id=answer.id).accepted)
def test_asking_a_question(self):
self.login_as(email='*****@*****.**', password='******')
question_data = {
'title': 'How is Stud2dotoh Hiring ?',
'description':
'Just interested in the process of hiring for Stud2dotoh',
'tags': ('hiring', )
}
old_questions_count = Question.objects.count()
response = self.client.post(
url_reverse('quest.views.view_ask_question'), question_data)
new_questions_count = Question.objects.count()
self.assertEquals(new_questions_count, old_questions_count + 1)
question = Question.objects.latest()
self.assertTrue(question)
self.assertEquals(question.title, question_data['title'])
self.assertEquals(question.description, question_data['description'])
tags = question.tags.all()
self.assertEquals(tags.count(), 1)
self.assertEquals(tags[0].name, question_data['tags'][0])
self.assertEquals(
UserProfile.objects.get(user__email='*****@*****.**').id,
question.raised_by.id)
self.assertRedirects(response,
expected_url=url_reverse(
'quest.views.view_question',
args=(question.id, question.slug)),
status_code=302,
target_status_code=200)
def view_contactgroup(request, group_type, group_id, contactgroup_template):
userprofile = loggedin_userprofile(request)
if group_type == 'college':
group = get_object_or_404(College, id=int(group_id))
to = "%s Students" % group.name
redirect_url = url_reverse('users.views.view_college', args=(group_id, group.slug))
elif group_type == 'company':
group = get_object_or_404(Company, id=int(group_id))
to = "%s Employees" % group.name
redirect_url = url_reverse('users.views.view_company', args=(group_id, group.slug))
else:
raise Http404
if request.method == 'POST':
contactgroupform = ContactGroupForm(post_data(request))
if contactgroupform.is_valid():
mail_group(group_type=group_type,
group=group,
from_email=userprofile.user.email,
message=contactgroupform.cleaned_data.get('message'),
from_name=userprofile.name,
subject=contactgroupform.cleaned_data.get('subject'))
from users.messages import CONTACTED_SUCCESSFULLY
messages.success(request, CONTACTED_SUCCESSFULLY)
return HttpResponseRedirect(redirect_to=redirect_url)
contactgroupform = ContactGroupForm({'to':to})
return response(request, contactgroup_template, {'contactgroupform':contactgroupform,
'group_type':group_type,
'group_id':group_id})
def test_anonymous_user_logout(self):
response = self.client.get(path=url_reverse('users.views.view_logout'))
self.assertRedirects(
response,
expected_url=url_reverse('users.views.view_homepage'),
status_code=302,
target_status_code=200)
def test_userprofilepage_success_response(self):
userprofile = UserProfile.objects.get(user__email='*****@*****.**')
response = self.client.get(path=url_reverse('users.views.view_userprofile', args=(userprofile.slug,)))
self.assertTrue(response)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'user_profile.html')
context = response.context[0]
self.assertTrue(context.has_key('userprofile'))
userprofile = context.get('userprofile')
self.assertEquals(userprofile.user.email, UserProfile.objects.get(user__email='*****@*****.**').user.email)
self.assertTrue(context.has_key('public_notes'))
self.login_as(email='*****@*****.**', password='******')
form_data = {'name': 'My Python Assignment',
'short_description': 'Hello World',
'content': 'print "Hello World"',
'public': True}
response = self.client.post(path=url_reverse('users.views.view_notepad'),
data=form_data)
self.logout()
response = self.client.get(path=url_reverse('users.views.view_userprofile', args=(userprofile.slug,)))
context = response.context[0]
public_notes = context.get('public_notes')
self.assertTrue(public_notes)
self.assertEquals(len(public_notes), 1)
self.assertEquals(form_data['name'], public_notes[0]['name'])
self.assertTrue(context.has_key('asked_questions'))
self.assertTrue(context.has_key('answered_questions'))
def auth_page(request):
response = HttpResponseRedirect(url_reverse('auth_page'))
if request.method == 'POST':
post_data = request.POST.dict()
login = post_data.get('login')
password = post_data.get('password')
try:
User.objects.get(username=login)
except User.DoesNotExist:
messages.error(request, 'No such user in system')
return response
user = auth.authenticate(username=login, password=password)
if user and user.is_active:
messages.success(request, 'Welcome to system')
auth.login(request, user)
response = HttpResponseRedirect(url_reverse('index'))
elif user and not user.is_active:
messages.info(request, 'Your profile is blocked.')
else:
messages.error(request, 'Wrong login or password')
else:
response = render(request, 'c_auth_page/auth_page.html',
{'title': 'Authentication'})
return response
def test_logout_link_visibility(self):
response = self.client.get(
path=url_reverse('users.views.view_homepage'))
self.assertTrue('Logout' not in response.content)
self.login_as(email='*****@*****.**', password='******')
response = self.client.get(
path=url_reverse('users.views.view_homepage'))
self.assertTrue('Logout' in response.content)
def test_valid_userlogin(self):
form_data = {"email": "*****@*****.**", "password": "******"}
response = self.client.post(path=url_reverse("users.views.view_login"), data=form_data)
self.assertRedirects(
response, expected_url=url_reverse("feeds.views.view_homepage"), status_code=302, target_status_code=200
)
response = self.client.get(url_reverse("feeds.views.view_homepage"))
self.assertEquals(response.context[0].get("user").email, form_data["email"])
def test_answer_page_fresh_access(self):
question = Question.objects.latest()
self.login_as(email='*****@*****.**', password='******')
response = self.client.get(url_reverse('quest.views.view_give_answer', args=(question.id,)))
self.assertRedirects(response,
expected_url=url_reverse('quest.views.view_question', args=(question.id, question.slug)),
status_code=302,
target_status_code=200)
def test_valid_usersignup(self):
form_data = {"name": "Some Empty User", "email": "*****@*****.**", "password": "******"}
response = self.client.post(path=url_reverse("users.views.view_register"), data=form_data)
self.assertRedirects(
response, expected_url=url_reverse("feeds.views.view_homepage"), status_code=302, target_status_code=200
)
userprofile = UserProfile.objects.latest()
self.assertTrue(userprofile)
self.assertEquals(userprofile.email, form_data["email"])
def test_valid_userlogin(self):
form_data = {'email': '*****@*****.**',
'password': '******'}
response = self.client.post(path=url_reverse('users.views.view_login'),
data=form_data)
self.assertRedirects(response,
expected_url=url_reverse('users.views.view_homepage'),
status_code=302,
target_status_code=200)
response = self.client.get(url_reverse('users.views.view_homepage'))
self.assertEquals(response.context[0].get('user').email, form_data['email'])
def test_answer_page_fresh_access(self):
question = Question.objects.latest()
self.login_as(email='*****@*****.**', password='******')
response = self.client.get(
url_reverse('quest.views.view_give_answer', args=(question.id, )))
self.assertRedirects(response,
expected_url=url_reverse(
'quest.views.view_question',
args=(question.id, question.slug)),
status_code=302,
target_status_code=200)
def test_valid_userlogin(self):
form_data = {'email': '*****@*****.**', 'password': '******'}
response = self.client.post(path=url_reverse('users.views.view_login'),
data=form_data)
self.assertRedirects(
response,
expected_url=url_reverse('users.views.view_homepage'),
status_code=302,
target_status_code=200)
response = self.client.get(url_reverse('users.views.view_homepage'))
self.assertEquals(response.context[0].get('user').email,
form_data['email'])
def test_authenticated_user_logout(self):
self.login_as(email='*****@*****.**', password='******')
response = self.client.get(path=url_reverse('users.views.view_logout'))
self.assertRedirects(response,
expected_url=url_reverse('users.views.view_homepage'),
status_code=302,
target_status_code=200)
response = self.client.get(path=url_reverse('users.views.view_notepad'))
self.assertRedirects(response,
expected_url='/accounts/login/?next=/notepad/',
status_code=302,
target_status_code=200)
def test_valid_usersignup(self):
form_data = {'name': 'Some Empty User',
'email': '*****@*****.**',
'password': '******'}
response = self.client.post(path=url_reverse('users.views.view_register'),
data=form_data)
self.assertRedirects(response,
expected_url=url_reverse('quest.views.view_homepage'),
status_code=302,
target_status_code=200)
userprofile = UserProfile.objects.latest()
self.assertTrue(userprofile)
self.assertEquals(userprofile.email, form_data['email'])
def test_viewing_saved_notepad_content(self):
self.login_as(email='*****@*****.**', password='******')
data = {'name':'My last semister Assignment',
'short_description':'',
'content':open("/".join([settings.ROOT_PATH, 'users', 'fixtures', 'assignment.py'])).read(),
'public':True}
response = self.client.post(path=url_reverse('users.views.view_notepad'),
data=data)
self.assertTrue(response)
response = self.client.get(url_reverse('users.views.view_note', args=(Note.objects.get(name=data['name']).id,)))
self.assertTrue(response)
self.assertEquals(response['Content-Type'], 'text/plain')
self.assertEquals(str(response.content).strip(), str(data['content']).strip())
def test_saving_modified_achievement_as_loggedin_user(self):
self.login_as(email='*****@*****.**', password='******')
achievement = Achievement.objects.latest()
data = {'title':achievement.title.replace('real', 'fake'),
'description':2*achievement.description}
response = self.client.post(path=url_reverse('users.views.view_edit_achievement', args=(achievement.id,)), data=data)
self.assertRedirects(response,
expected_url=url_reverse('users.views.view_all_achievements'),
status_code=302,
target_status_code=200)
achievement = Achievement.objects.latest()
self.assertEquals(achievement.title, data['title'])
self.assertEquals(achievement.description, data['description'])
def test_edit_question_with_valid_content(self):
self.login_as(email='*****@*****.**', password='******')
question = Question.objects.latest()
valid_question_data = {'title':"Some Valid title",
'description':'Some valid description',
'tags':'valid'}
response = self.client.post(url_reverse('quest.views.view_edit_question', args=(question.id, question.slug)), data=valid_question_data)
self.assertRedirects(response,
expected_url=url_reverse('quest.views.view_question', args=(question.id, question.slug)),
status_code=302,
target_status_code=200)
question = Question.objects.get(id=question.id)
self.assertEquals(valid_question_data['title'], question.title)
self.assertEquals(valid_question_data['description'], question.description)
def test_authenticated_user_logout(self):
self.login_as(email='*****@*****.**', password='******')
response = self.client.get(path=url_reverse('users.views.view_logout'))
self.assertRedirects(
response,
expected_url=url_reverse('users.views.view_homepage'),
status_code=302,
target_status_code=200)
response = self.client.get(
path=url_reverse('users.views.view_notepad'))
self.assertRedirects(response,
expected_url='/accounts/login/?next=/notepad/',
status_code=302,
target_status_code=200)
def test_asking_a_question_with_blocked_htmltags(self):
self.login_as(email='*****@*****.**', password='******')
question_data = {'title':'How is Stud2dotoh Hiring ?',
'description':'Stud2dotoh! <script>alert("I will shoot you in the head")</script><input type=\'text\' name=\'head_name\' value=\'Your Name\'/><marquee>I am big distracting rolling banner</marquee>',
'tags':'sometag'}
self.client.post(url_reverse('quest.views.view_ask_question'), question_data)
question = Question.objects.latest()
response = self.client.get(url_reverse('quest.views.view_question', args=(question.id, question.slug)))
self.assertTrue(response)
context = response.context[0]
question = context.get('question')
question_description = question.description
for tag in settings.FILTER_HTML_TAGS.split(' '):
self.assertFalse(tag in question_description)
def test_unaccepting_an_answer_of_a_question(self):
question = Question.objects.latest()
answer = question.answers[0]
self.login_as(email='*****@*****.**', password='******')
response = self.client.post(url_reverse('quest.views.view_accept_answer', args=(question.id,)), data={'question_id':question.id, 'answer_id':answer.id})
self.assertTrue(response)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'answers.html')
self.assertTrue(Answer.objects.get(id=answer.id).accepted)
answer = question.answers[1]
response = self.client.post(url_reverse('quest.views.view_accept_answer', args=(question.id,)), data={'question_id':question.id, 'answer_id':answer.id})
self.assertTrue(response)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'answers.html')
self.assertTrue(Answer.objects.get(id=answer.id).accepted)
def test_creating_achievement_as_loggedin_user(self):
self.login_as(email='*****@*****.**', password='******')
data = {'title':2*'I did this this this',
'description':50*'blah'}
response = self.client.post(url_reverse('users.views.view_add_achievement'),
data=data)
self.assertRedirects(response,
expected_url=url_reverse('users.views.view_all_achievements'),
status_code=302,
target_status_code=200)
latest_achievement = Achievement.objects.latest()
response = self.client.get(url_reverse("users.views.view_all_achievements"))
context = response.context[0]
userprofile = context.get('userprofile')
self.assertTrue(userprofile.is_my_achievement(latest_achievement))
def _contest_home_admin(request, contest, last_log_entry=None):
button = <x:frag />
show_nothing = False
if contest.state == Contest.UNASSIGNED:
if contest.intended_start_date <= now():
button = <button class="btn btn-success">Start</button>
button_action = 'contest-start'
else:
show_nothing = True
elif contest.state == Contest.STARTED:
if contest.get_time_left() > 0.0:
button = <button class="btn btn-warning">Pause</button>
button_action = 'contest-pause'
else:
button = <button class="btn btn-danger">Stop</button>
button_action = 'contest-stop'
elif contest.state == Contest.PAUSED:
button = <button class="btn btn-success">Resume</button>
button_action = 'contest-start'
elif contest.state == Contest.STOPPED:
show_nothing = True
else:
raise Http404 #TODO: just in case of inconsistency...
if show_nothing == False:
button.setAttribute('class',
button.getAttribute('class') + ' js-post-btn')
button.setAttribute('data-action',
url_reverse(button_action, args=(contest.id,)))
entries = LogEntry.get_all_entries(contest.id, last_log_entry)
new_last_log_entry = 0
if entries:
new_last_log_entry = entries[0].id
content_entries = <div id="log-entries" />
for entry in entries:
content_entries.appendChild(<cs:log-entry entry={entry} />)
content = \
<div class="contest-activity-log">
<div class="btn-toolbar pull-right">
{button}
<button class="btn js-get-btn"
data-href={url_reverse('admin:contests_contest_change',
args=(contest.id,))}>
Edit
def test_saving_academic_settings_by_student_and_professor(self):
login_details = (('*****@*****.**', 'nopassword'),
('*****@*****.**', 'nopassword'))
for login in login_details:
self.login_as(email=login[0], password=login[1])
data = {
'branch': 'CSE',
'college': 'Vasavi College of Engg.',
'start_year': 1998,
'end_year': 1999
}
response = self.client.post(
path=url_reverse('users.views.view_save_acad_settings'),
data=data,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertTrue(response)
context = response.context
self.assertTrue(context.has_key('acad_form'))
acad_form = context.get('acad_form')
self.assertFalse(acad_form.errors)
userprofile = context.get('userprofile')
acad_details = userprofile.acad_details
self.assertEquals(acad_details[0], data['branch'])
self.assertEquals(acad_details[1].name, data['college'])
self.assertEquals(acad_details[2], data['start_year'])
self.assertEquals(acad_details[3], data['end_year'])
self.logout()
def test_anonymous_access_to_achievements_page(self):
response = self.client.get(url_reverse("users.views.view_all_achievements"))
self.assertTrue(response)
self.assertRedirects(response,
expected_url='/accounts/login/?next=/achievements/',
status_code=302,
target_status_code=200)
def test_fresh_settings_page_access_by_professor(self):
self.login_as(email='*****@*****.**', password='******')
response = self.client.get(url_reverse('users.views.view_account_settings'))
self.assertTrue(response)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'personal_settings.html')
context = response.context[0]
self.assertTrue(context.has_key('personal_form'))
form = context.get('personal_form')
self.assertTrue(form.errors)
self.assertTrue(form.errors.get('slug'))
self.assertFalse(form.errors.get('name'))
self.assertFalse(form.errors.get('new_password'))
self.assertTemplateUsed(response, 'acad_settings.html')
self.assertTrue(context.has_key('acad_form'))
form = context.get('acad_form')
self.assertTrue(form.errors)
self.assertTrue(form.errors.get('branch'))
self.assertTrue(form.errors.get('college'))
self.assertFalse(form.errors.get('start_year'))
self.assertFalse(form.errors.get('end_year'))
self.assertTrue(context.has_key('workinfo_form'))
form = context.get('workinfo_form')
self.assertTrue(form.errors)
self.assertTrue(form.errors.get('workplace'))
self.assertFalse(form.errors.get('designation'))
self.assertTrue(form.errors.get('years_of_exp'))
def test_invalidlink_for_userprofilepage(self):
userprofile = UserProfile.objects.get(
user__email='*****@*****.**')
response = self.client.get(path=url_reverse(
'users.views.view_userprofile', args=('madness', )))
self.assertTrue(response)
self.assertEquals(response.status_code, 404)
def test_access_to_notepad_page(self):
response = self.client.get(path=url_reverse('users.views.view_notepad'))
self.assertRedirects(response,
expected_url='/accounts/login/?next=/notepad/',
status_code=302,
target_status_code=200)
self.login_as(email='*****@*****.**', password='******')
response = self.client.get(path=url_reverse('users.views.view_notepad'))
self.assertTrue(response)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'notepad.html')
context = response.context[0]
form = context.get('form')
self.assertFalse(form.is_bound)
self.assertFalse(form.errors)
self.assertTrue(context.has_key('all_notes'))
def maskurl(given_url, *args, **kwargs):
"""
Probable usage:
- {% url 'main' %} ->
{% maskurl 'main' %}
- {% url 'list' 4 %} ->
{% maskurl 'main' 4 %}
- {% url 'list' 'blah' %} ->
{% maskurl 'main' 'blah' %}
- {% url 'list' object.id %} ->
{% maskurl 'main' object.id %}
- {% url 'list' obj1.id obj2.id %} ->
{% maskurl 'main' obj1.id obj2.id %}
- {% url 'list' obj1.name|title obj2.id|lower %} ->
{% maskurl 'main' obj1.id|title obj2.id|lower %}
- {{ reversed_url }} ->
{% maskurl reversed_url %}
After Django 1.7.0 version url built in
templatetag returns quoted paths
"""
maskedurl = ""
match = given_url.find("/") == -1
if match:
reversed_url = url_reverse(given_url, args=args, kwargs=kwargs)
resolved_url = urlunquote(reversed_url)
maskedurl = dumps(resolved_url.lstrip('/'))
else:
maskedurl = dumps(given_url.lstrip('/'))
if DJANGO_VERSION >= 170:
maskedurl = urlquote(maskedurl)
return '/%s' % maskedurl
def test_settings_page_access_anonymously(self):
response = self.client.get(
url_reverse('users.views.view_account_settings'))
self.assertRedirects(response,
expected_url='/accounts/login/?next=/settings/',
status_code=302,
target_status_code=200)
def test_fresh_settings_page_access_by_employee(self):
self.login_as(email='*****@*****.**', password='******')
response = self.client.get(
url_reverse('users.views.view_account_settings'))
self.assertTrue(response)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'personal_settings.html')
context = response.context[0]
self.assertTrue(context.has_key('personal_form'))
form = context.get('personal_form')
self.assertFalse(form.errors)
self.assertTemplateUsed(response, 'acad_settings.html')
self.assertTrue(context.has_key('acad_form'))
form = context.get('acad_form')
self.assertTrue(form.errors)
self.assertTrue(form.errors.get('branch'))
self.assertTrue(form.errors.get('college'))
self.assertFalse(form.errors.get('start_year'))
self.assertFalse(form.errors.get('end_year'))
self.assertTrue(context.has_key('workinfo_form'))
form = context.get('workinfo_form')
self.assertTrue(form.errors)
self.assertTrue(form.errors.get('workplace'))
self.assertFalse(form.errors.get('designation'))
self.assertTrue(form.errors.get('years_of_exp'))
def test_fresh_access_as_authenticated_user(self):
self.login_as(email='*****@*****.**', password='******')
response = self.client.get('/accounts/register/')
self.assertRedirects(response,
expected_url=url_reverse('users.views.view_homepage'),
status_code=302,
target_status_code=200)
def view_give_answer(request, question_id, give_answer_template,
question_template):
question = get_object_or_404(Question, id=int(question_id))
if request.method == 'POST':
form = GiveAnswerForm(post_data(request))
if form.is_valid():
userprofile = loggedin_userprofile(request)
new_answer = Answer.objects.create_answer(
question=question,
description=form.cleaned_data.get('description'),
userprofile=userprofile)
new_anwer_emailer(question, new_answer)
from quest.messages import ANSWER_POSTING_SUCCESSFUL
messages.success(request, ANSWER_POSTING_SUCCESSFUL)
give_answer_form = GiveAnswerForm()
return response(request, question_template, {
'question': question,
'give_answer_form': give_answer_form
})
return response(request, question_template, {
'question': question,
'give_answer_form': form
})
return HttpResponseRedirect(redirect_to=url_reverse(
'quest.views.view_question', args=(question.id, question.slug)))
def test_login_access_to_homepage(self):
self.login_as(email='*****@*****.**', password='******')
response = self.client.get(
path=url_reverse('users.views.view_homepage'))
self.assertTrue(response)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'homepage.html')
def test_editing_achievement_as_anonymous_user(self):
achievement = Achievement.objects.latest()
response = self.client.get(url_reverse('users.views.view_edit_achievement', args=(achievement.id,)))
self.assertRedirects(response,
expected_url='/accounts/login/?next=/edit_achievement/%s/' % achievement.id,
status_code=302,
target_status_code=200)
def build_table_row(row_obj, table_obj, onclick_column=None, target_link=None):
print(
'--->onclick',
onclick_column,
)
row_ele = "<tr>"
for index, column_name in enumerate(table_obj.list_display):
column_data = row_obj._meta.get_field(column_name)._get_val_from_obj(
row_obj)
print column_data
# if column_name in table_obj.choice_fields:
# column_data = getattr(row_obj,'get_%s_display'%column_name)()
if column_name in table_obj.fk_fields:
column_data = getattr(row_obj, column_name).__str__()
if onclick_column == column_name:
column = ''' <td><a href=%s>%s</a></td> ''' % (url_reverse(
target_link, args=(column_data, )), column_data)
else:
column = "<td>%s</td>" % column_data
row_ele += column
#for dynamic display
if table_obj.dynamic_fk:
if hasattr(row_obj, table_obj.dynamic_fk):
#print("----dynamic:",getattr(row_obj,table_obj.dynamic_fk), row_obj)
#print(row_obj.networkdevice)
dy_fk = getattr(row_obj, table_obj.dynamic_fk) #拿到的是asset_type的值
if hasattr(row_obj, dy_fk):
dy_fk_obj = getattr(row_obj, dy_fk)
print("-->type", type(dy_fk_obj), dy_fk_obj)
for index, column_name in enumerate(
table_obj.dynamic_list_display):
if hasattr(dy_fk_obj, column_name):
if column_name in table_obj.dynamic_choice_fields:
column_data = getattr(
dy_fk_obj, 'get_%s_display' % column_name)()
else:
column_data = dy_fk_obj._meta.get_field(
column_name)._get_val_from_obj(dy_fk_obj)
print("dynamic column data", column_data)
column = "<td>%s</td>" % column_data
else:
column = "<td>n/a</td>"
row_ele += column
else:
#这个关联的表还没创建呢， 但也要创建空的html td占位符
for index, column_name in enumerate(
table_obj.dynamic_list_display):
row_ele += "<td></td>"
for field in table_obj.m2m_fields:
m2m_obj = getattr(row_obj, field)
column = "<td> "
for obj in m2m_obj.select_related():
column += "<span style='display:inline-block' class='label label-mint label-info'>%s</span>" % obj.__str__(
)
column += "</td>"
row_ele += column
row_ele += "</tr>"
return mark_safe(row_ele)
def test_valid_notepad_saving(self):
self.login_as(email='*****@*****.**', password='******')
form_data = {
'name': 'My Python Assignment',
'short_description': 'Hello World',
'content': 'print "Hello World"',
'public': True
}
previous_count = Note.objects.filter(
userprofile=UserProfile.objects.get(
user__email='*****@*****.**')).count()
response = self.client.post(
path=url_reverse('users.views.view_notepad'), data=form_data)
self.assertTrue(response)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'notepad.html')
context = response.context[0]
self.assertTrue(context.has_key('form'))
form = context.get('form')
self.assertFalse(form.is_bound)
self.assertFalse(form.errors)
self.assertTrue(context.has_key('all_notes'))
all_notes = context.get('all_notes')
self.assertTrue(all_notes)
self.assertEquals(len(all_notes), previous_count + 1)
self.assertEquals(all_notes[0]['name'], form_data['name'])
def test_saving_personal_settings_by_student(self):
self.login_as(email='*****@*****.**', password='******')
data = {
'name': 'Nanda.B',
'new_password': '******',
'slug': 'nandakishore'
}
response = self.client.post(
path=url_reverse('users.views.view_save_personal_settings'),
data=data,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertTrue(response)
context = response.context
self.assertTrue(context.has_key('personal_form'))
personal_form = context.get('personal_form')
self.assertFalse(personal_form.errors)
userprofile = context.get('userprofile')
self.assertTrue(userprofile.check_password(data['new_password']))
from django.contrib.sites.models import Site
self.assertEqual(
userprofile.domain, ".".join([
userprofile.slug,
Site.objects.get(id=settings.SITE_ID).domain
]))
self.assertEqual(userprofile.name, data['name'])
def test_edit_question_page_fresh_access_anonymous_user(self):
question = Question.objects.latest()
response = self.client.get(url_reverse('quest.views.view_edit_question', args=(question.id, question.slug)))
self.assertRedirects(response,
expected_url='/accounts/login/?next=/questions/%s/%s/edit/' % (question.id, question.slug),
status_code=302,
target_status_code=200)
def view_edit_question(request, question_id, question_slug, edit_question_template):
userprofile = loggedin_userprofile(request)
question = get_object_or_404(Question, id=int(question_id))
if userprofile.is_my_question(question):
asked_questions = list(userprofile.asked_questions)
for question_info in asked_questions:
if question_info['id'] == int(question_id):
asked_questions.remove({'title':question.title,
'id':int(question_id),
'slug':question_slug})
if request.method == 'GET':
question_data = {'title':question.title,
'description':question.description,
'tags':",".join([tag['name'] for tag in question.tags.values('name')])}
form = AskQuestionForm(question_data)
return response(request, edit_question_template, {'form':form,
'question':question,
'previous_questions':asked_questions})
form = AskQuestionForm(post_data(request))
if form.is_valid():
Question.objects.update_question(question,
title=form.cleaned_data.get('title'),
description=form.cleaned_data.get('description'),
tags=form.cleaned_data.get('tags'))
from quest.messages import QUESTION_UPDATED_SUCCESSFULLY
messages.success(request, QUESTION_UPDATED_SUCCESSFULLY)
return HttpResponseRedirect(redirect_to=url_reverse('quest.views.view_question', args=(question.id, question.slug)))
return response(request, edit_question_template, {'form':form,
'question':question,
'previous_questions':asked_questions})
raise Http404
def test_web_invite(self):
try:
contact_ids = []
with mock.patch(
"contactstore.openinviter.get_contacts") as mock_importer:
mock_importer.return_value = self.data_list
imported_contacts = import_contacts(self.importing,
self.importing.email,
IMPORTER_PASSWORD)
contact_ids += [contact["id"] for contact in imported_contacts]
self.assertTrue(
self.client.login(username=self.importing.username,
password=IMPORTER_PASSWORD))
invite_url = url_reverse("contactstore.views.create_invites")
data = urllib.urlencode({"contact_id": contact_ids}, doseq=True)
response = self.client.post(
invite_url,
data=data,
content_type="application/x-www-form-urlencoded")
self.assertEquals(response.status_code, 200)
invites = EmailInvite.objects.filter(contact__id__in=contact_ids)
self.assertEquals(len(invites), len(contact_ids))
finally:
pass
def test_web_import(self):
"Assert that the web client can POST a username and password and get back the list of contacts"
try:
with mock.patch(
"contactstore.openinviter.get_contacts") as mock_importer:
mock_importer.return_value = self.data_list
self.assertTrue(
self.client.login(username=self.importing.username,
password=IMPORTER_PASSWORD))
import_url = url_reverse(
'contactstore.views.download_contacts')
response = self.client.post(import_url, {
"email": self.importing.email,
"password": IMPORTER_PASSWORD
})
self.assertEquals(200, response.status_code)
# Check we have all the users
xpath = "//ul[@class='friends']//li[text()='%s']"
assertXpath(response.content, xpath % (self.email1), html=True)
assertXpath(response.content, xpath % (self.email2), html=True)
assertXpath(response.content, xpath % (self.email3), html=True)
finally:
pass
def view_edit_achievement(request, achievement_id, edit_achievement_template):
userprofile = loggedin_userprofile(request)
achievement = get_object_or_404(Achievement, id=int(achievement_id))
if userprofile.is_my_achievement(achievement):
achievements = list(userprofile.achievements)
for achievment_info in achievements:
if achievment_info['id'] == int(achievement_id):
achievements.remove({'title':achievement.title,
'id':int(achievement_id),
'description':achievement.description})
break
if request.method == 'GET':
form = AddAchievementForm({'title':achievement.title,
'description':achievement.description})
return response(request, edit_achievement_template, {'achievement':achievement,
'form':form,
'previous_achievements':achievements})
form = AddAchievementForm(post_data(request))
if form.is_valid():
achievement.update(title=form.cleaned_data.get('title'),
description=form.cleaned_data.get('description'),)
from users.messages import ACHIEVEMENT_UPDATED_SUCCESSFULLY
messages.success(request, ACHIEVEMENT_UPDATED_SUCCESSFULLY)
return HttpResponseRedirect(redirect_to=url_reverse('users.views.view_all_achievements'))
return response(request, edit_achievement_template, {'achievement':achievement,
'form':form,
'previous_achievements':achievements})
raise Http404
def test_web_invite(self):
try:
contact_ids = []
with mock.patch("contactstore.openinviter.get_contacts") as mock_importer:
mock_importer.return_value = self.data_list
imported_contacts = import_contacts(
self.importing,
self.importing.email,
IMPORTER_PASSWORD
)
contact_ids += [contact["id"] for contact in imported_contacts]
self.assertTrue(self.client.login(
username=self.importing.username,
password=IMPORTER_PASSWORD
))
invite_url = url_reverse("contactstore.views.create_invites")
data = urllib.urlencode({
"contact_id": contact_ids
}, doseq=True)
response = self.client.post(
invite_url,
data=data,
content_type="application/x-www-form-urlencoded"
)
self.assertEquals(response.status_code, 200)
invites = EmailInvite.objects.filter(contact__id__in=contact_ids)
self.assertEquals(len(invites), len(contact_ids))
finally:
pass
def test_web_import(self):
"Assert that the web client can POST a username and password and get back the list of contacts"
try:
with mock.patch("contactstore.openinviter.get_contacts") as mock_importer:
mock_importer.return_value = self.data_list
self.assertTrue(self.client.login(
username=self.importing.username,
password=IMPORTER_PASSWORD
))
import_url = url_reverse('contactstore.views.download_contacts')
response = self.client.post(import_url, {
"email": self.importing.email,
"password": IMPORTER_PASSWORD
})
self.assertEquals(200, response.status_code)
# Check we have all the users
xpath = "//ul[@class='friends']//li[text()='%s']"
assertXpath(
response.content, xpath % (self.email1),
html=True
)
assertXpath(
response.content, xpath % (self.email2),
html=True
)
assertXpath(
response.content, xpath % (self.email3),
html=True
)
finally:
pass
def ajax_command(request, command):
'''Executa os commands do django via ajax assincrono'''
url = url_reverse('command', kwargs={'comando': command})
context = {'comando': command,
'url': url,
'STATIC_URL': settings.STATIC_URL}
return render_to_response("admin/ajax.html", context)
def test_editing_other_persons_achievement_content(self):
self.login_as(email='*****@*****.**', password='******')
achievement = Achievement.objects.latest()
response = self.client.get(
url_reverse('users.views.view_edit_achievement',
args=(achievement.id, )))
self.assertTrue(response)
self.assertEquals(response.status_code, 404)
def run_request(self, url_name: str, data: dict, method="post"):
"""Helper for request
"""
cl = Client()
return getattr(cl, method,
cl.get)(url_reverse("activity:{}".format(url_name)),
json.dumps(data),
content_type="application/json")
