def test_resurrect(self):
draft = make_test_data()
path = os.path.join(self.repository_dir, draft.filename_with_rev())
with open(path, 'w') as file:
file.write('test')
expire_draft(draft)
email_url = urlreverse('ietf.secr.drafts.views.email',
kwargs={'id': draft.name}) + "?action=resurrect"
confirm_url = urlreverse('ietf.secr.drafts.views.confirm',
kwargs={'id': draft.name})
do_action_url = urlreverse('ietf.secr.drafts.views.do_action',
kwargs={'id': draft.name})
view_url = urlreverse('ietf.secr.drafts.views.view',
kwargs={'id': draft.name})
self.client.login(username="******", password="******")
response = self.client.get(email_url)
self.assertEqual(response.status_code, 200)
post_data = {
'action': 'resurrect',
'to': '*****@*****.**',
'cc': '*****@*****.**',
'subject': 'test',
'body': 'draft resurrected',
'submit': 'Save'
}
response = self.client.post(email_url, post_data)
response = self.client.post(confirm_url, post_data)
response = self.client.post(do_action_url, post_data)
self.assertRedirects(response, view_url)
draft = Document.objects.get(name=draft.name)
self.assertTrue(draft.get_state_slug('draft') == 'active')
def send_submission_confirmation(request, submission, chair_notice=False):
subject = 'Confirm submission of I-D %s' % submission.name
from_email = settings.IDSUBMIT_FROM_EMAIL
(to_email, cc) = gather_address_lists('sub_confirmation_requested',
submission=submission)
confirm_url = settings.IDTRACKER_BASE_URL + urlreverse(
'ietf.submit.views.confirm_submission',
kwargs=dict(submission_id=submission.pk,
auth_token=generate_access_token(submission.auth_key)))
status_url = settings.IDTRACKER_BASE_URL + urlreverse(
'ietf.submit.views.submission_status',
kwargs=dict(submission_id=submission.pk,
access_token=submission.access_token()))
send_mail(request,
to_email,
from_email,
subject,
'submit/confirm_submission.txt', {
'submission': submission,
'confirm_url': confirm_url,
'status_url': status_url,
'chair_notice': chair_notice,
},
cc=cc)
all_addrs = to_email
all_addrs.extend(cc)
return all_addrs
def test_withdraw(self):
draft = make_test_data()
url = urlreverse('ietf.secr.drafts.views.withdraw',
kwargs={'id': draft.name})
email_url = urlreverse('ietf.secr.drafts.views.email',
kwargs={'id': draft.name})
confirm_url = urlreverse('ietf.secr.drafts.views.confirm',
kwargs={'id': draft.name})
do_action_url = urlreverse('ietf.secr.drafts.views.do_action',
kwargs={'id': draft.name})
view_url = urlreverse('ietf.secr.drafts.views.view',
kwargs={'id': draft.name})
self.client.login(username="******", password="******")
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
get_data = {
'action': 'withdraw',
'withdraw_type': 'ietf',
}
post_data = {
'action': 'withdraw',
'withdraw_type': 'ietf',
'to': '*****@*****.**',
'cc': '*****@*****.**',
'subject': 'test',
'body': 'draft resurrected',
'submit': 'Save'
}
response = self.client.get(email_url + '?' + urlencode(get_data))
self.assertEqual(response.status_code, 200)
response = self.client.post(confirm_url, post_data)
response = self.client.post(do_action_url, post_data)
self.assertRedirects(response, view_url)
draft = Document.objects.get(name=draft.name)
self.assertTrue(draft.get_state_slug('draft') == 'ietf-rm')
def test_sessions_json(self):
meeting = make_meeting_test_data()
url = urlreverse("ietf.meeting.ajax.sessions_json",
kwargs=dict(num=meeting.number))
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
info = json.loads(r.content)
self.assertEqual(
set([x['short_name'] for x in info]),
set([
s.session.short_name
for s in meeting.agenda.assignments.filter(
session__type_id='session')
]))
schedule = meeting.agenda
url = urlreverse("ietf.meeting.ajax.assignments_json",
kwargs=dict(num=meeting.number,
owner=schedule.owner_email(),
name=schedule.name))
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
info = json.loads(r.content)
self.assertEqual(len(info), schedule.assignments.count())
def email_reviewer_reminder(review_request):
team = review_request.team
deadline_days = (review_request.deadline - datetime.date.today()).days
subject = "Reminder: deadline for review of {} in {} is {}".format(
review_request.doc_id, team.acronym,
review_request.deadline.isoformat())
import ietf.ietfauth.views
overview_url = urlreverse(ietf.ietfauth.views.review_overview)
import ietf.doc.views_review
request_url = urlreverse(ietf.doc.views_review.review_request,
kwargs={
"name": review_request.doc_id,
"request_id": review_request.pk
})
domain = Site.objects.get_current().domain
settings = ReviewerSettings.objects.filter(
person=review_request.reviewer.person, team=team).first()
remind_days = settings.remind_days_before_deadline if settings else 0
send_mail(
None, [review_request.reviewer.formatted_email()], None, subject,
"review/reviewer_reminder.txt", {
"reviewer_overview_url": "https://{}{}".format(
domain, overview_url),
"review_request_url": "https://{}{}".format(domain, request_url),
"review_request": review_request,
"deadline_days": deadline_days,
"remind_days": remind_days,
})
def admin(request, state):
"""Administrative disclosure listing. For non-posted disclosures"""
states = IprDisclosureStateName.objects.filter(
slug__in=[state, "rejected"] if state == "removed" else [state])
if not states:
raise Http404
iprs = IprDisclosureBase.objects.filter(state__in=states).order_by('-time')
tabs = [
t + (t[0].lower() == state.lower(), ) for t in [
('Pending',
urlreverse('ietf.ipr.views.admin', kwargs={'state': 'pending'})),
('Removed',
urlreverse('ietf.ipr.views.admin', kwargs={'state': 'removed'})),
('Parked',
urlreverse('ietf.ipr.views.admin', kwargs={'state': 'parked'})),
]
]
return render(
request, 'ipr/admin_list.html', {
'iprs': iprs,
'tabs': tabs,
'states': states,
'administrative_list': state,
})
def test_change_review_secretary_settings(self):
doc = make_test_data()
review_req = make_review_data(doc)
secretary = Person.objects.get(user__username="******")
url = urlreverse(ietf.group.views.change_review_secretary_settings, kwargs={
"acronym": review_req.team.acronym,
})
login_testing_unauthorized(self, secretary.user.username, url)
url = urlreverse(ietf.group.views.change_review_secretary_settings, kwargs={
"group_type": review_req.team.type_id,
"acronym": review_req.team.acronym,
})
# get
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
# set settings
r = self.client.post(url, {
"remind_days_before_deadline": "6"
})
self.assertEqual(r.status_code, 302)
settings = ReviewSecretarySettings.objects.get(person=secretary, team=review_req.team)
self.assertEqual(settings.remind_days_before_deadline, 6)
def make_rev_history(doc):
# return document history data for inclusion in doc.json (used by timeline)
def get_predecessors(doc):
predecessors = []
if hasattr(doc, 'relateddocument_set'):
for alias in doc.related_that_doc('replaces'):
if alias.document not in predecessors:
predecessors.append(alias.document)
predecessors.extend(get_predecessors(alias.document))
return predecessors
def get_ancestors(doc):
ancestors = []
if hasattr(doc, 'relateddocument_set'):
for alias in doc.related_that('replaces'):
if alias.document not in ancestors:
ancestors.append(alias.document)
ancestors.extend(get_ancestors(alias.document))
return ancestors
def get_replaces_tree(doc):
tree = get_predecessors(doc)
tree.extend(get_ancestors(doc))
return tree
history = {}
docs = get_replaces_tree(doc)
if docs is not None:
docs.append(doc)
for d in docs:
for e in d.docevent_set.filter(type='new_revision').distinct():
if hasattr(e, 'newrevisiondocevent'):
url = urlreverse("ietf.doc.views_doc.document_main", kwargs=dict(name=d)) + e.newrevisiondocevent.rev + "/"
history[url] = {
'name': d.name,
'rev': e.newrevisiondocevent.rev,
'published': e.time.isoformat(),
'url': url,
}
if d.history_set.filter(rev=e.newrevisiondocevent.rev).exists():
history[url]['pages'] = d.history_set.filter(rev=e.newrevisiondocevent.rev).first().pages
if doc.type_id == "draft":
e = doc.latest_event(type='published_rfc')
else:
e = doc.latest_event(type='iesg_approved')
if e:
url = urlreverse("ietf.doc.views_doc.document_main", kwargs=dict(name=e.doc))
history[url] = {
'name': e.doc.canonical_name(),
'rev': e.doc.canonical_name(),
'published': e.time.isoformat(),
'url': url
}
if hasattr(e, 'newrevisiondocevent') and doc.history_set.filter(rev=e.newrevisiondocevent.rev).exists():
history[url]['pages'] = doc.history_set.filter(rev=e.newrevisiondocevent.rev).first().pages
history = history.values()
return sorted(history, key=lambda x: x['published'])
def test_update(self):
draft = make_test_data()
path = os.path.join(self.repository_dir, draft.filename_with_rev())
with open(path, 'w') as file:
file.write('test')
expire_draft(draft)
url = urlreverse('ietf.secr.drafts.views.update',
kwargs={'id': draft.name})
email_url = urlreverse('ietf.secr.drafts.views.email',
kwargs={'id': draft.name})
confirm_url = urlreverse('ietf.secr.drafts.views.confirm',
kwargs={'id': draft.name})
do_action_url = urlreverse('ietf.secr.drafts.views.do_action',
kwargs={'id': draft.name})
view_url = urlreverse('ietf.secr.drafts.views.view',
kwargs={'id': draft.name})
self.client.login(username="******", password="******")
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
post_data = {
'title': draft.title,
'pages': str(draft.pages),
'abstract': draft.abstract,
}
formats = [
'txt',
]
files = {}
for format in formats:
files[format] = submission_file(draft.name, '02', draft.group,
format,
"test_submission.%s" % format)
post_data.update(files)
response = self.client.post(url, post_data)
self.assertRedirects(
response,
email_url + '?action=update&filename=%s-02' % (draft.name))
post_data = {
'action': 'update',
'to': '*****@*****.**',
'cc': '*****@*****.**',
'subject': 'test',
'body': 'text',
'submit': 'Save'
}
response = self.client.post(
email_url + '?action=update&filename=%s-02' % (draft.name),
post_data)
response = self.client.post(confirm_url, post_data)
response = self.client.post(do_action_url, post_data)
self.assertRedirects(response, view_url)
draft = Document.objects.get(name=draft.name)
expires = datetime.datetime.now() + datetime.timedelta(
settings.INTERNET_DRAFT_DAYS_TO_EXPIRE)
self.assertTrue(draft.get_state_slug('draft') == 'active')
self.assertEqual(draft.rev, '02')
expiration_discrepancy_seconds = abs(
(draft.expires - expires).total_seconds())
self.assertLess(expiration_discrepancy_seconds, 60)
def test_admin_change(self):
draft = Document.objects.get(name="draft-ietf-mars-test")
today = datetime.date.today()
telechat_date = TelechatDate.objects.get(date=draft.telechat_date())
url = urlreverse('admin:iesg_telechatdate_change', args=(telechat_date.id,))
self.client.login(username="******", password="******")
r = self.client.post(url, {'date':today.strftime('%Y-%m-%d')})
self.assertRedirects(r, urlreverse('admin:iesg_telechatdate_changelist'))
self.assertEqual(draft.telechat_date(),today)
def get_absolute_url(self):
import ietf.community.views
if self.user:
return urlreverse(ietf.community.views.view_list,
kwargs={'username': self.user.username})
elif self.group:
return urlreverse("ietf.group.views.group_documents",
kwargs={'acronym': self.group.acronym})
return ""
def get_details_tabs(ipr, selected):
return [
t + (t[0].lower() == selected.lower(), )
for t in [('Disclosure',
urlreverse('ietf.ipr.views.show', kwargs={'id': ipr.pk})),
('History',
urlreverse('ietf.ipr.views.history', kwargs={'id': ipr.pk})
)]
]
def get_details_tabs(stmt, selected):
return [
t + (t[0].lower() == selected.lower(), )
for t in [('Statement',
urlreverse('ietf.liaisons.views.liaison_detail',
kwargs={'object_id': stmt.pk})),
('History',
urlreverse('ietf.liaisons.views.liaison_history',
kwargs={'object_id': stmt.pk}))]
]
def test_show_triggers(self):
url = urlreverse('ietf.mailtrigger.views.show_triggers')
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
self.assertTrue('ballot_saved' in unicontent(r))
url = urlreverse('ietf.mailtrigger.views.show_triggers',kwargs=dict(mailtrigger_slug='ballot_saved'))
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
self.assertTrue('ballot_saved' in unicontent(r))
def test_show_recipients(self):
url = urlreverse('ietf.mailtrigger.views.show_recipients')
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
self.assertTrue('doc_group_mail_list' in unicontent(r))
url = urlreverse('ietf.mailtrigger.views.show_recipients',kwargs=dict(recipient_slug='doc_group_mail_list'))
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
self.assertTrue('doc_group_mail_list' in unicontent(r))
def test_meeting_stats(self):
# create some data for the statistics
make_test_data()
meeting = MeetingFactory(type_id='ietf',
date=datetime.date.today(),
number="96")
MeetingRegistration.objects.create(first_name='John',
last_name='Smith',
country_code='US',
email="*****@*****.**",
meeting=meeting)
CountryAlias.objects.get_or_create(
alias="US", country=CountryName.objects.get(slug="US"))
MeetingRegistration.objects.create(first_name='Jaume',
last_name='Guillaume',
country_code='FR',
email="*****@*****.**",
meeting=meeting)
CountryAlias.objects.get_or_create(
alias="FR", country=CountryName.objects.get(slug="FR"))
# check redirect
url = urlreverse(ietf.stats.views.meeting_stats)
authors_url = urlreverse(ietf.stats.views.meeting_stats,
kwargs={"stats_type": "overview"})
r = self.client.get(url)
self.assertEqual(r.status_code, 302)
self.assertTrue(authors_url in r["Location"])
# check various stats types
for stats_type in ["overview", "country", "continent"]:
url = urlreverse(ietf.stats.views.meeting_stats,
kwargs={"stats_type": stats_type})
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
q = PyQuery(r.content)
self.assertTrue(q('#chart'))
if stats_type == "overview":
self.assertTrue(q('table.stats-data'))
for stats_type in ["country", "continent"]:
url = urlreverse(ietf.stats.views.meeting_stats,
kwargs={
"stats_type": stats_type,
"num": meeting.number
})
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
q = PyQuery(r.content)
self.assertTrue(q('#chart'))
self.assertTrue(q('table.stats-data'))
def chart_newrevisiondocevent(request):
return render(
request, "doc/stats/highstock.html", {
"title":
"Document Statistics",
"confurl":
urlreverse("ietf.doc.views_stats.chart_conf_newrevisiondocevent"),
"dataurl":
urlreverse("ietf.doc.views_stats.chart_data_newrevisiondocevent"),
"queryargs":
request.GET.urlencode(),
})
def test_review_stats(self):
doc = make_test_data()
review_req = make_review_data(doc)
# check redirect
url = urlreverse(ietf.stats.views.review_stats)
login_testing_unauthorized(self, "secretary", url)
completion_url = urlreverse(ietf.stats.views.review_stats,
kwargs={"stats_type": "completion"})
r = self.client.get(url)
self.assertEqual(r.status_code, 302)
self.assertTrue(completion_url in r["Location"])
self.client.logout()
self.client.login(username="******", password="******")
r = self.client.get(completion_url)
self.assertEqual(r.status_code, 403)
# check tabular
self.client.login(username="******", password="******")
for stats_type in ["completion", "results", "states"]:
url = urlreverse(ietf.stats.views.review_stats,
kwargs={"stats_type": stats_type})
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
q = PyQuery(r.content)
if stats_type != "results":
self.assertTrue(q('.review-stats td:contains("1")'))
# check chart
url = urlreverse(ietf.stats.views.review_stats,
kwargs={"stats_type": "time"})
url += "?team={}".format(review_req.team.acronym)
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
q = PyQuery(r.content)
self.assertTrue(q('.stats-time-graph'))
# check reviewer level
url = urlreverse(ietf.stats.views.review_stats,
kwargs={
"stats_type": "completion",
"acronym": review_req.team.acronym
})
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
q = PyQuery(r.content)
self.assertTrue(q('.review-stats td:contains("1")'))
def test_email_open_review_assignments(self):
doc = make_test_data()
review_req1 = make_review_data(doc)
DBTemplateFactory.create(path='/group/defaults/email/open_assignments.txt',
type_id='django',
content = """
{% autoescape off %}
Reviewer Deadline Draft
{% for r in review_requests %}{{ r.reviewer.person.plain_name|ljust:"22" }} {{ r.deadline|date:"Y-m-d" }} {{ r.doc_id }}-{% if r.requested_rev %}{{ r.requested_rev }}{% else %}{{ r.doc.rev }}{% endif %}
{% endfor %}
{% if rotation_list %}Next in the reviewer rotation:
{% for p in rotation_list %} {{ p }}
{% endfor %}{% endif %}
{% endautoescape %}
""")
group = review_req1.team
url = urlreverse(ietf.group.views.email_open_review_assignments, kwargs={ 'acronym': group.acronym })
login_testing_unauthorized(self, "secretary", url)
url = urlreverse(ietf.group.views.email_open_review_assignments, kwargs={ 'acronym': group.acronym, 'group_type': group.type_id })
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
q = PyQuery(r.content)
generated_text = q("[name=body]").text()
self.assertTrue(review_req1.doc.name in generated_text)
self.assertTrue(unicode(Person.objects.get(user__username="******")) in generated_text)
empty_outbox()
r = self.client.post(url, {
"to": '*****@*****.**',
"cc": '*****@*****.**',
"reply_to": '*****@*****.**',
"frm" : '*****@*****.**',
"subject": "Test subject",
"body": "Test body",
"action": "email",
})
self.assertEqual(r.status_code, 302)
self.assertEqual(len(outbox), 1)
self.assertTrue('toaddr' in outbox[0]["To"])
self.assertTrue('ccaddr' in outbox[0]["Cc"])
self.assertTrue('replytoaddr' in outbox[0]["Reply-To"])
self.assertTrue('fromaddr' in outbox[0]["From"])
self.assertEqual(outbox[0]["subject"], "Test subject")
self.assertTrue("Test body" in outbox[0].get_payload(decode=True).decode("utf-8"))
def test_discrepancies(self):
make_test_data()
# draft approved but no RFC Editor state
doc = Document.objects.create(name="draft-ietf-test1", type_id="draft")
doc.set_state(
State.objects.get(used=True, type="draft-iesg", slug="ann"))
r = self.client.get(urlreverse("ietf.sync.views.discrepancies"))
self.assertTrue(doc.name in unicontent(r))
# draft with IANA state "In Progress" but RFC Editor state not IANA
doc = Document.objects.create(name="draft-ietf-test2", type_id="draft")
doc.set_state(
State.objects.get(used=True, type="draft-iesg", slug="rfcqueue"))
doc.set_state(
State.objects.get(used=True,
type="draft-iana-action",
slug="inprog"))
doc.set_state(
State.objects.get(used=True, type="draft-rfceditor", slug="auth"))
r = self.client.get(urlreverse("ietf.sync.views.discrepancies"))
self.assertTrue(doc.name in unicontent(r))
# draft with IANA state "Waiting on RFC Editor" or "RFC-Ed-Ack"
# but RFC Editor state is IANA
doc = Document.objects.create(name="draft-ietf-test3", type_id="draft")
doc.set_state(
State.objects.get(used=True, type="draft-iesg", slug="rfcqueue"))
doc.set_state(
State.objects.get(used=True,
type="draft-iana-action",
slug="waitrfc"))
doc.set_state(
State.objects.get(used=True, type="draft-rfceditor", slug="iana"))
r = self.client.get(urlreverse("ietf.sync.views.discrepancies"))
self.assertTrue(doc.name in unicontent(r))
# draft with state other than "RFC Ed Queue" or "RFC Published"
# that are in RFC Editor or IANA queues
doc = Document.objects.create(name="draft-ietf-test4", type_id="draft")
doc.set_state(
State.objects.get(used=True, type="draft-iesg", slug="ann"))
doc.set_state(
State.objects.get(used=True, type="draft-rfceditor", slug="auth"))
r = self.client.get(urlreverse("ietf.sync.views.discrepancies"))
self.assertTrue(doc.name in unicontent(r))
def send_manual_post_request(request, submission, errors):
subject = u'Manual Post Requested for %s' % submission.name
from_email = settings.IDSUBMIT_FROM_EMAIL
(to_email, cc) = gather_address_lists('sub_manual_post_requested',
submission=submission)
checker = DraftIdnitsChecker(
options=[]) # don't use the default --submitcheck limitation
file_name = os.path.join(settings.IDSUBMIT_STAGING_PATH,
'%s-%s.txt' % (submission.name, submission.rev))
nitspass, nitsmsg, nitserr, nitswarn, nitsresult = checker.check_file_txt(
file_name)
send_mail(request,
to_email,
from_email,
subject,
'submit/manual_post_request.txt', {
'submission':
submission,
'url':
settings.IDTRACKER_BASE_URL +
urlreverse('ietf.submit.views.submission_status',
kwargs=dict(submission_id=submission.pk)),
'errors':
errors,
'idnits':
nitsmsg,
},
cc=cc)
def test_initial_submission(self):
doc = Document.objects.get(name='conflict-review-imaginary-irtf-submission')
url = urlreverse('ietf.doc.views_conflict_review.submit',kwargs=dict(name=doc.name))
login_testing_unauthorized(self, "ad", url)
# normal get
r = self.client.get(url)
self.assertEqual(r.status_code,200)
q = PyQuery(r.content)
self.assertTrue(q('textarea[name="content"]')[0].text.strip().startswith("[Edit this page"))
# Faulty posts using textbox
# Right now, nothing to test - we let people put whatever the web browser will let them put into that textbox
# sane post using textbox
path = os.path.join(settings.CONFLICT_REVIEW_PATH, '%s-%s.txt' % (doc.canonical_name(), doc.rev))
self.assertEqual(doc.rev,u'00')
self.assertFalse(os.path.exists(path))
r = self.client.post(url,dict(content="Some initial review text\n",submit_response="1"))
self.assertEqual(r.status_code,302)
doc = Document.objects.get(name='conflict-review-imaginary-irtf-submission')
self.assertEqual(doc.rev,u'00')
with open(path) as f:
self.assertEqual(f.read(),"Some initial review text\n")
f.close()
self.assertTrue( "submission-00" in doc.latest_event(NewRevisionDocEvent).desc)
def test_edit_notices(self):
doc = Document.objects.get(name='conflict-review-imaginary-irtf-submission')
url = urlreverse('ietf.doc.views_doc.edit_notify;conflict-review',kwargs=dict(name=doc.name))
login_testing_unauthorized(self, "ad", url)
# normal get
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
q = PyQuery(r.content)
self.assertEqual(len(q('form input[name=notify]')),1)
self.assertEqual(doc.notify,q('form input[name=notify]')[0].value)
# change notice list
newlist = '"Foo Bar" <*****@*****.**>'
r = self.client.post(url,dict(notify=newlist,save_addresses="1"))
self.assertEqual(r.status_code,302)
doc = Document.objects.get(name='conflict-review-imaginary-irtf-submission')
self.assertEqual(doc.notify,newlist)
self.assertTrue(doc.latest_event(DocEvent,type="added_comment").desc.startswith('Notification list changed'))
# Ask the form to regenerate the list
r = self.client.post(url,dict(regenerate_addresses="1"))
self.assertEqual(r.status_code,200)
doc = Document.objects.get(name='conflict-review-imaginary-irtf-submission')
# Regenerate does not save!
self.assertEqual(doc.notify,newlist)
q = PyQuery(r.content)
self.assertEqual(None,q('form input[name=notify]')[0].value)
def test_addemail(self):
make_test_data()
ipr = IprDisclosureBase.objects.get(title='Statement regarding rights')
url = urlreverse('ietf.ipr.views.add_email', kwargs={"id": ipr.id})
self.client.login(username="******", password="******")
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
# post
r = self.client.post(
url, {
"direction":
'incoming',
"message":
"""From: [email protected]
To: [email protected]
Subject: RE: The Cisco Statement
Date: Wed, 24 Sep 2014 14:25:02 -0700
Hello,
I would like to revoke this declaration.
"""
})
msg = Message.objects.get(frm='*****@*****.**')
qs = ipr.iprevent_set.filter(type='msgin', message=msg)
self.assertTrue(qs.count(), 1)
def test_update_bad_post(self):
draft = make_test_data()
url = urlreverse("ietf.ipr.views.new", kwargs={"type": "specific"})
# successful post
empty_outbox()
r = self.client.post(
url, {
"updates": "this is supposed to be an integer",
"holder_legal_name": "Test Legal",
"holder_contact_name": "Test Holder",
"holder_contact_email": "*****@*****.**",
"iprdocrel_set-TOTAL_FORMS": 1,
"iprdocrel_set-INITIAL_FORMS": 0,
"iprdocrel_set-0-document":
"%s" % draft.docalias_set.first().pk,
"iprdocrel_set-0-revisions": '00',
"patent_info": "none",
"has_patent_pending": False,
"licensing": "royalty-free",
"submitter_name": "Test Holder",
"submitter_email": "*****@*****.**",
})
self.assertEqual(r.status_code, 200)
q = PyQuery(r.content)
self.assertTrue(
q("#id_updates").parents(".form-group").hasClass("has-error"))
def test_iprs_for_drafts(self):
draft = make_test_data()
ipr = IprDisclosureBase.objects.get(title='Statement regarding rights')
r = self.client.get(urlreverse("ietf.ipr.views.by_draft_txt"))
self.assertEqual(r.status_code, 200)
self.assertTrue(draft.name in unicontent(r))
self.assertTrue(str(ipr.pk) in unicontent(r))
def test_ipr_history(self):
make_test_data()
ipr = IprDisclosureBase.objects.get(title='Statement regarding rights')
r = self.client.get(
urlreverse("ietf.ipr.views.history", kwargs=dict(id=ipr.pk)))
self.assertEqual(r.status_code, 200)
self.assertTrue(ipr.title in unicontent(r))
def about_url(self):
# bridge gap between group-type prefixed URLs and /group/ ones
from django.urls import reverse as urlreverse
kwargs = { 'acronym': self.acronym }
if self.type_id in ("wg", "rg", "ag"):
kwargs["group_type"] = self.type_id
return urlreverse(self.features.about_page, kwargs=kwargs)
def delete_correction(request, correction_id):
correction = get_object_or_404(WayCorrection, id=correction_id)
request.page = Page()
request.page.title = "Slet rettelse %s" % correction.id
msg = ""
if request.method == "POST":
comment = request.POST.get("comment")
if comment:
correction.deleted = datetime.datetime.now()
correction.deleted_by_id = request.session["osm_user"]
correction.deleted_comment = comment
correction.save()
return HttpResponseRedirect(urlreverse("correction_details", kwargs=dict(correction_id=correction.id)))
else:
msg = "Du skal skrive en forklaring."
request.page.content = render_to_string(
"delete-correction.html", {
"c": correction,
"msg": msg
}, request=request)
return render_page(request)
def prepare_value(self, value):
if not value:
value = ""
if isinstance(value, (int, long)):
value = str(value)
if isinstance(value, basestring):
pks = self.parse_select2_value(value)
value = self.model.objects.filter(pk__in=pks)
filter_args = {}
if self.model == DocAlias:
filter_args["document__type"] = self.doc_type
else:
filter_args["type"] = self.doc_type
value = value.filter(**filter_args)
if isinstance(value, self.model):
value = [value]
self.widget.attrs["data-pre"] = select2_id_doc_name_json(value)
# doing this in the constructor is difficult because the URL
# patterns may not have been fully constructed there yet
self.widget.attrs["data-ajax-url"] = urlreverse(
'ietf.doc.views_search.ajax_select2_search_docs',
kwargs={
"doc_type": self.doc_type,
"model_name": self.model.__name__.lower()
})
return u",".join(unicode(o.pk) for o in value)
def register_and_verify(self, email):
url = urlreverse(ietf.ietfauth.views.create_account)
# register email
empty_outbox()
r = self.client.post(url, { 'email': email })
self.assertEqual(r.status_code, 200)
self.assertIn("Account request received", unicontent(r))
self.assertEqual(len(outbox), 1)
# go to confirm page
confirm_url = self.extract_confirm_url(outbox[-1])
r = self.client.get(confirm_url)
self.assertEqual(r.status_code, 200)
# password mismatch
r = self.client.post(confirm_url, { 'password': '******', 'password_confirmation': 'nosecret' })
self.assertEqual(r.status_code, 200)
self.assertEqual(User.objects.filter(username=email).count(), 0)
# confirm
r = self.client.post(confirm_url, { 'name': 'User Name', 'ascii': 'User Name', 'password': '******', 'password_confirmation': 'secret' })
self.assertEqual(r.status_code, 200)
self.assertEqual(User.objects.filter(username=email).count(), 1)
self.assertEqual(Person.objects.filter(user__username=email).count(), 1)
self.assertEqual(Email.objects.filter(person__user__username=email).count(), 1)
self.assertTrue(self.username_in_htpasswd_file(email))
def create_way_correction(request):
if "osm_user" not in request.session:
return HttpResponseForbidden("Must be authorized via OpenStreetMap OAuth.")
form = WayCorrectionForm(request.POST)
if form.is_valid():
correction = form.save(commit=False)
correction.created_by_id = request.session["osm_user"]
correction.save()
old_corrections = WayCorrection.objects.filter(
municipality_no=correction.municipality_no,
street_no=correction.street_no,
old_name=correction.old_name,
deleted=None,
).exclude(id=correction.id)
for o in old_corrections:
o.deleted = correction.created
o.deleted_by = correction.created_by
o.deleted_comment = "Erstattet af %s" % correction.id
o.deleted_replaced_by = correction
o.save()
replaced = ""
if old_corrections:
replaced = " (erstattede %s %s)" % (
len(old_corrections),
"rettelse" if len(old_corrections) == 1 else "rettelser")
report_url = urlreverse("correction_details", kwargs=dict(correction_id=correction.id))
result = 'Oprettede <a href="%s">ny rettelse</a>%s. Du kan <a href="http://osm.ter.dk/address_street.php?MunicipalityCode=%s&StreetCode=%s">genimportere adressepunkterne med importeringsscriptet</a>.' % (report_url, replaced, correction.municipality_no, correction.street_no)
else:
result = "Fejl ved fortolkning af indsendte data."
return JsonResponse({
"result": result,
})
