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, })