altf4arnold/datatracker
1
0
Fork 0
Code Issues Pull requests Actions 3 Packages Projects Releases Wiki Activity
datatracker/ietf/submit/tests.py
Ole Laursen ecf68dbb05 Revamp and clean up submit models: 
- Rename IdSubmissionDetail to Submission
- Rename various submission fields to correspond to the conventions in
  the new schema
- Use a name model for the states instead of IdSubmissionStatus
- Drop the TempIdAuthor model which is based on splitting up author
  names
- Add a simple textual SubmissionEvent for tracking events in the
  lifetime of a submission
- Delete a bunch of obsolete fields
- Make sure all submission have an access key so we can depend on it
- Add state for when approval is needed from previous authors

A couple of migrations take care of transforming the
IdSubmissionDetail and moving data over/cleaning it up.

Also revamp the submit view code:

- Make form code do validation/cleaning only so there's a clear
  separation of concerns
- Reduce uses of inheritance that made the code hard to follow -
  forms now don't inherit from each other, views don't call each other
  but instead reuse common utilities, templates share CSS/utilities
  instead of relying on inheritance
- Move email rendering/sending to separate file
- Drop the in-grown terminology use (auto post vs. manual posts)
- Make the status page explain who is emailed for what purpose
- Add history table with recorded events
- Make the status page handle its post actions by itself instead of
  duplicating most of the setup logic in a number of simple views
- Fix a couple of minor bugs and handle some edge cases better
- Expand tests with a couple of more cases

Possibly the submit tool could still use more help text added to
explain the process, ideally what's explained in the tool instructions
page should be inlined or self-evident.
 - Legacy-Id: 6714
2013-11-15 13:30:32 +00:00

604 lines
25 KiB
Python
Raw Blame History

import datetime
import os
import shutil
import re
from django.conf import settings
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse as urlreverse
import django.test
from StringIO import StringIO
from pyquery import PyQuery
from ietf.utils.test_utils import login_testing_unauthorized
from ietf.utils.test_data import make_test_data
from ietf.utils.mail import outbox
from ietf.person.models import Person, Email
from ietf.group.models import Group, Role
from ietf.doc.models import *
from ietf.submit.models import Submission, Preapproval
class SubmitTests(django.test.TestCase):
def setUp(self):
self.staging_dir = os.path.abspath("tmp-submit-staging-dir")
os.mkdir(self.staging_dir)
settings.IDSUBMIT_STAGING_PATH = self.staging_dir
self.repository_dir = os.path.abspath("tmp-submit-repository-dir")
os.mkdir(self.repository_dir)
settings.INTERNET_DRAFT_PATH = settings.IDSUBMIT_REPOSITORY_PATH = self.repository_dir
self.archive_dir = os.path.abspath("tmp-submit-archive-dir")
os.mkdir(self.archive_dir)
settings.INTERNET_DRAFT_ARCHIVE_DIR = self.archive_dir
def tearDown(self):
shutil.rmtree(self.staging_dir)
shutil.rmtree(self.repository_dir)
shutil.rmtree(self.archive_dir)
def submission_txt_file(self, name, rev):
# construct appropriate text draft
f = open(os.path.join(settings.BASE_DIR, "submit", "test_submission.txt"))
template = f.read()
f.close()
submission_text = template % dict(
date=datetime.date.today().strftime("%d %B %Y"),
expire=(datetime.date.today() + datetime.timedelta(days=100)).strftime("%Y-%m-%d"),
year=datetime.date.today().strftime("%Y"),
month_year=datetime.date.today().strftime("%B, %Y"),
name="%s-%s" % (name, rev),
)
txt_file = StringIO(str(submission_text))
txt_file.name = "somename.txt"
return txt_file
def do_submission(self, name, rev):
# break early in case of missing configuration
self.assertTrue(os.path.exists(settings.IDSUBMIT_IDNITS_BINARY))
# get
url = urlreverse('submit_upload_submission')
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('input[type=file][name=txt]')), 1)
# submit
txt_file = self.submission_txt_file(name, rev)
r = self.client.post(url,
dict(txt=txt_file))
self.assertEquals(r.status_code, 302)
status_url = r["Location"]
self.assertTrue(os.path.exists(os.path.join(self.staging_dir, u"%s-%s.txt" % (name, rev))))
self.assertEquals(Submission.objects.filter(name=name).count(), 1)
submission = Submission.objects.get(name=name)
self.assertTrue(re.search('\s+Summary:\s+0\s+errors|No nits found', submission.idnits_message))
self.assertEquals(len(submission.authors_parsed()), 1)
author = submission.authors_parsed()[0]
self.assertEquals(author["name"], "Author Name")
self.assertEquals(author["email"], "author@example.com")
return status_url
def supply_submitter(self, name, status_url, submitter_name, submitter_email):
# check the page
r = self.client.get(status_url)
q = PyQuery(r.content)
post_button = q('input[type=submit][value*="Post"]')
self.assertEquals(len(post_button), 1)
action = post_button.parents("form").find('input[type=hidden][name="action"]').val()
# post submitter info
r = self.client.post(status_url, {
"action": action,
"submitter-name": submitter_name,
"submitter-email": submitter_email,
})
submission = Submission.objects.get(name=name)
self.assertEquals(submission.submitter, u"%s <%s>" % (submitter_name, submitter_email))
return r
def extract_confirm_url(self, confirm_email):
# dig out confirm_email link
msg = confirm_email.get_payload(decode=True)
line_start = "http"
confirm_url = None
for line in msg.split("\n"):
if line.strip().startswith(line_start):
confirm_url = line.strip()
self.assertTrue(confirm_url)
return confirm_url
def test_submit_new_wg(self):
# submit new -> supply submitter info -> approve
draft = make_test_data()
name = "draft-ietf-mars-testing-tests"
rev = "00"
status_url = self.do_submission(name, rev)
# supply submitter info, then draft should be in and ready for approval
mailbox_before = len(outbox)
r = self.supply_submitter(name, status_url, "Author Name", "author@example.com")
self.assertEquals(r.status_code, 302)
status_url = r["Location"]
self.assertEquals(len(outbox), mailbox_before + 1)
self.assertTrue("New draft waiting for approval" in outbox[-1]["Subject"])
self.assertTrue(name in outbox[-1]["Subject"])
# as chair of WG, we should see approval button
self.client.login(remote_user="marschairman")
r = self.client.get(status_url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
approve_button = q('input[type=submit][value*="Approve"]')
self.assertEquals(len(approve_button), 1)
action = approve_button.parents("form").find('input[type=hidden][name="action"]').val()
# approve submission
mailbox_before = len(outbox)
r = self.client.post(status_url, dict(action=action))
self.assertEquals(r.status_code, 302)
draft = Document.objects.get(docalias__name=name)
self.assertEquals(draft.rev, rev)
new_revision = draft.latest_event()
self.assertEquals(draft.group.acronym, "mars")
self.assertEquals(new_revision.type, "new_revision")
self.assertEquals(new_revision.by.name, "Author Name")
self.assertTrue(not os.path.exists(os.path.join(self.staging_dir, u"%s-%s.txt" % (name, rev))))
self.assertTrue(os.path.exists(os.path.join(self.repository_dir, u"%s-%s.txt" % (name, rev))))
self.assertEquals(draft.type_id, "draft")
self.assertEquals(draft.stream_id, "ietf")
self.assertTrue(draft.expires >= datetime.datetime.now() + datetime.timedelta(days=settings.INTERNET_DRAFT_DAYS_TO_EXPIRE - 1))
self.assertEquals(draft.get_state("draft-stream-%s" % draft.stream_id).slug, "wg-doc")
self.assertEquals(draft.authors.count(), 1)
self.assertEquals(draft.authors.all()[0].get_name(), "Author Name")
self.assertEquals(draft.authors.all()[0].address, "author@example.com")
self.assertEquals(len(outbox), mailbox_before + 2)
self.assertTrue((u"I-D Action: %s" % name) in outbox[-2]["Subject"])
self.assertTrue("Author Name" in unicode(outbox[-2]))
self.assertTrue("New Version Notification" in outbox[-1]["Subject"])
self.assertTrue(name in unicode(outbox[-1]))
self.assertTrue("mars" in unicode(outbox[-1]))
def test_submit_existing(self):
# submit new revision of existing -> supply submitter info -> prev authors confirm
draft = make_test_data()
prev_author = draft.documentauthor_set.all()[0]
# pretend IANA reviewed it
draft.set_state(State.objects.get(used=True, type="draft-iana-review", slug="not-ok"))
# pretend it was approved to check that we notify the RFC Editor
e = DocEvent(type="iesg_approved", doc=draft)
e.time = draft.time
e.by = Person.objects.get(name="(System)")
e.desc = "The IESG approved the document"
e.save()
# make a discuss to see if the AD gets an email
ballot_position = BallotPositionDocEvent()
ballot_position.ballot = draft.latest_event(BallotDocEvent, type="created_ballot")
ballot_position.pos_id = "discuss"
ballot_position.type = "changed_ballot_position"
ballot_position.doc = draft
ballot_position.ad = ballot_position.by = Person.objects.get(user__username="ad2")
ballot_position.save()
name = draft.name
rev = "%02d" % (int(draft.rev) + 1)
# write the old draft in a file so we can check it's moved away
old_rev = draft.rev
with open(os.path.join(self.repository_dir, "%s-%s.txt" % (name, old_rev)), 'w') as f:
f.write("a" * 2000)
status_url = self.do_submission(name, rev)
# supply submitter info, then previous authors get a confirmation email
mailbox_before = len(outbox)
r = self.supply_submitter(name, status_url, "Submitter Name", "submitter@example.com")
self.assertEquals(r.status_code, 302)
status_url = r["Location"]
r = self.client.get(status_url)
self.assertEquals(r.status_code, 200)
self.assertTrue("The submission is pending approval by the authors" in r.content)
self.assertEquals(len(outbox), mailbox_before + 1)
confirm_email = outbox[-1]
self.assertTrue("Confirm submission" in confirm_email["Subject"])
self.assertTrue(name in confirm_email["Subject"])
self.assertTrue(prev_author.author.address in confirm_email["To"])
# submitter and new author can't confirm
self.assertTrue("author@example.com" not in confirm_email["To"])
self.assertTrue("submitter@example.com" not in confirm_email["To"])
confirm_url = self.extract_confirm_url(confirm_email)
# go to confirm page
r = self.client.get(confirm_url)
q = PyQuery(r.content)
self.assertEquals(len(q('input[type=submit][value*="Confirm"]')), 1)
# confirm
mailbox_before = len(outbox)
r = self.client.post(confirm_url)
self.assertEquals(r.status_code, 302)
draft = Document.objects.get(docalias__name=name)
self.assertEquals(draft.rev, rev)
self.assertEquals(draft.group.acronym, name.split("-")[2])
self.assertEquals(draft.docevent_set.all()[1].type, "new_revision")
self.assertEquals(draft.docevent_set.all()[1].by.name, "Submitter Name")
self.assertTrue(not os.path.exists(os.path.join(self.repository_dir, "%s-%s.txt" % (name, old_rev))))
self.assertTrue(os.path.exists(os.path.join(self.archive_dir, "%s-%s.txt" % (name, old_rev))))
self.assertTrue(not os.path.exists(os.path.join(self.staging_dir, u"%s-%s.txt" % (name, rev))))
self.assertTrue(os.path.exists(os.path.join(self.repository_dir, u"%s-%s.txt" % (name, rev))))
self.assertEquals(draft.type_id, "draft")
self.assertEquals(draft.stream_id, "ietf")
self.assertEquals(draft.get_state_slug("draft-stream-%s" % draft.stream_id), "wg-doc")
self.assertEquals(draft.get_state_slug("draft-iana-review"), "changed")
self.assertEquals(draft.authors.count(), 1)
self.assertEquals(draft.authors.all()[0].get_name(), "Author Name")
self.assertEquals(draft.authors.all()[0].address, "author@example.com")
self.assertEquals(len(outbox), mailbox_before + 3)
self.assertTrue((u"I-D Action: %s" % name) in outbox[-3]["Subject"])
self.assertTrue((u"I-D Action: %s" % name) in draft.message_set.order_by("-time")[0].subject)
self.assertTrue("Author Name" in unicode(outbox[-3]))
self.assertTrue("New Version Notification" in outbox[-2]["Subject"])
self.assertTrue(name in unicode(outbox[-2]))
self.assertTrue("mars" in unicode(outbox[-2]))
self.assertTrue(draft.ad.role_email("ad").address in unicode(outbox[-2]))
self.assertTrue(ballot_position.ad.role_email("ad").address in unicode(outbox[-2]))
self.assertTrue("New Version Notification" in outbox[-1]["Subject"])
self.assertTrue(name in unicode(outbox[-1]))
self.assertTrue("mars" in unicode(outbox[-1]))
def test_submit_new_individual(self):
# submit new -> supply submitter info -> confirm
draft = make_test_data()
name = "draft-authorname-testing-tests"
rev = "00"
status_url = self.do_submission(name, rev)
# supply submitter info, then draft should be be ready for email auth
mailbox_before = len(outbox)
r = self.supply_submitter(name, status_url, "Submitter Name", "submitter@example.com")
self.assertEquals(r.status_code, 302)
status_url = r["Location"]
r = self.client.get(status_url)
self.assertEquals(r.status_code, 200)
self.assertTrue("The submission is pending email authentication" in r.content)
self.assertEquals(len(outbox), mailbox_before + 1)
confirm_email = outbox[-1]
self.assertTrue("Confirm submission" in confirm_email["Subject"])
self.assertTrue(name in confirm_email["Subject"])
# both submitter and author get email
self.assertTrue("author@example.com" in confirm_email["To"])
self.assertTrue("submitter@example.com" in confirm_email["To"])
confirm_url = self.extract_confirm_url(outbox[-1])
# go to confirm page
r = self.client.get(confirm_url)
q = PyQuery(r.content)
self.assertEquals(len(q('input[type=submit][value*="Confirm"]')), 1)
# confirm
mailbox_before = len(outbox)
r = self.client.post(confirm_url)
self.assertEquals(r.status_code, 302)
draft = Document.objects.get(docalias__name=name)
self.assertEquals(draft.rev, rev)
new_revision = draft.latest_event()
self.assertEquals(new_revision.type, "new_revision")
self.assertEquals(new_revision.by.name, "Submitter Name")
def test_submit_new_wg_with_dash(self):
draft = make_test_data()
group = Group.objects.create(acronym="mars-special", name="Mars Special", type_id="wg", state_id="active")
name = "draft-ietf-%s-testing-tests" % group.acronym
self.do_submission(name, "00")
self.assertEquals(Submission.objects.get(name=name).group.acronym, group.acronym)
def test_submit_new_irtf(self):
draft = make_test_data()
group = Group.objects.create(acronym="saturnrg", name="Saturn", type_id="rg", state_id="active")
name = "draft-irtf-%s-testing-tests" % group.acronym
self.do_submission(name, "00")
self.assertEquals(Submission.objects.get(name=name).group.acronym, group.acronym)
self.assertEquals(Submission.objects.get(name=name).group.type_id, group.type_id)
def test_submit_new_iab(self):
draft = make_test_data()
name = "draft-iab-testing-tests"
self.do_submission(name, "00")
self.assertEquals(Submission.objects.get(name=name).group.acronym, "iab")
def test_cancel_submission(self):
# submit -> cancel
draft = make_test_data()
name = "draft-ietf-mars-testing-tests"
rev = "00"
status_url = self.do_submission(name, rev)
# check we got cancel button
r = self.client.get(status_url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
cancel_button = q('input[type=submit][value*="Cancel"]')
self.assertEquals(len(cancel_button), 1)
action = cancel_button.parents("form").find("input[type=hidden][name=\"action\"]").val()
# cancel
r = self.client.post(status_url, dict(action=action))
self.assertTrue(not os.path.exists(os.path.join(self.staging_dir, u"%s-%s.txt" % (name, rev))))
def test_edit_submission_and_force_post(self):
# submit -> edit
draft = make_test_data()
name = "draft-ietf-mars-testing-tests"
rev = "00"
status_url = self.do_submission(name, rev)
# check we got edit button
r = self.client.get(status_url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
adjust_button = q('input[type=submit][value*="Adjust"]')
self.assertEquals(len(adjust_button), 1)
action = adjust_button.parents("form").find('input[type=hidden][name="action"]').val()
# go to edit, we do this by posting, slightly weird
r = self.client.post(status_url, dict(action=action))
self.assertEquals(r.status_code, 302)
edit_url = r['Location']
# check page
r = self.client.get(edit_url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('input[name=edit-title]')), 1)
# edit
mailbox_before = len(outbox)
document_date = datetime.date.today() - datetime.timedelta(days=-3)
r = self.client.post(edit_url, {
"edit-title": "some title",
"edit-rev": "00",
"edit-document_date": document_date.strftime("%Y-%m-%d"),
"edit-abstract": "some abstract",
"edit-pages": "123",
"submitter-name": "Some Random Test Person",
"submitter-email": "random@example.com",
"edit-note": "no comments",
"authors-0-name": "Person 1",
"authors-0-email": "person1@example.com",
"authors-1-name": "Person 2",
"authors-1-email": "person2@example.com",
"authors-prefix": ["authors-", "authors-0", "authors-1"],
})
self.assertEquals(r.status_code, 302)
submission = Submission.objects.get(name=name)
self.assertEquals(submission.title, "some title")
self.assertEquals(submission.document_date, document_date)
self.assertEquals(submission.abstract, "some abstract")
self.assertEquals(submission.pages, 123)
self.assertEquals(submission.note, "no comments")
self.assertEquals(submission.submitter, "Some Random Test Person <random@example.com>")
self.assertEquals(submission.state_id, "manual")
authors = submission.authors_parsed()
self.assertEquals(len(authors), 2)
self.assertEquals(authors[0]["name"], "Person 1")
self.assertEquals(authors[0]["email"], "person1@example.com")
self.assertEquals(authors[1]["name"], "Person 2")
self.assertEquals(authors[1]["email"], "person2@example.com")
self.assertEquals(len(outbox), mailbox_before + 1)
self.assertTrue("Manual Post Requested" in outbox[-1]["Subject"])
self.assertTrue(name in outbox[-1]["Subject"])
# as Secretariat, we should see the force post button
self.client.login(remote_user="secretary")
r = self.client.get(status_url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
post_button = q('input[type=submit][value*="Force"]')
self.assertEquals(len(post_button), 1)
action = post_button.parents("form").find('input[type=hidden][name="action"]').val()
# force post
mailbox_before = len(outbox)
r = self.client.post(status_url, dict(action=action))
self.assertEquals(r.status_code, 302)
draft = Document.objects.get(docalias__name=name)
self.assertEquals(draft.rev, rev)
def test_request_full_url(self):
# submit -> request full URL to be sent
draft = make_test_data()
name = "draft-ietf-mars-testing-tests"
rev = "00"
self.do_submission(name, rev)
submission = Submission.objects.get(name=name)
url = urlreverse('submit_submission_status', kwargs=dict(submission_id=submission.pk))
# check we got request full URL button
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
request_button = q('input[type=submit][value*="Request full access"]')
self.assertEquals(len(request_button), 1)
# request URL to be sent
mailbox_before = len(outbox)
action = request_button.parents("form").find("input[type=hidden][name=\"action\"]").val()
r = self.client.post(url, dict(action=action))
self.assertEquals(r.status_code, 200)
self.assertEquals(len(outbox), mailbox_before + 1)
self.assertTrue("Full URL for managing submission" in outbox[-1]["Subject"])
self.assertTrue(name in outbox[-1]["Subject"])
def test_submit_all_file_types(self):
draft = make_test_data()
name = "draft-ietf-mars-testing-tests"
rev = "00"
txt_file = self.submission_txt_file(name, rev)
# the checks for other file types are currently embarrassingly
# dumb, so don't bother constructing proper XML/PS/PDF draft
# files
xml_file = StringIO('<?xml version="1.0" encoding="utf-8"?>\n<draft>This is XML</draft>')
xml_file.name = "somename.xml"
pdf_file = StringIO('%PDF-1.5\nThis is PDF')
pdf_file.name = "somename.pdf"
ps_file = StringIO('%!PS-Adobe-2.0\nThis is PostScript')
ps_file.name = "somename.ps"
r = self.client.post(urlreverse('submit_upload_submission'), dict(
txt=txt_file,
xml=xml_file,
pdf=pdf_file,
ps=ps_file,
))
self.assertEquals(r.status_code, 302)
self.assertEquals(Submission.objects.filter(name=name).count(), 1)
self.assertTrue(os.path.exists(os.path.join(self.staging_dir, u"%s-%s.txt" % (name, rev))))
self.assertTrue(name in open(os.path.join(self.staging_dir, u"%s-%s.txt" % (name, rev))).read())
self.assertTrue(os.path.exists(os.path.join(self.staging_dir, u"%s-%s.xml" % (name, rev))))
self.assertTrue('This is XML' in open(os.path.join(self.staging_dir, u"%s-%s.xml" % (name, rev))).read())
self.assertTrue(os.path.exists(os.path.join(self.staging_dir, u"%s-%s.pdf" % (name, rev))))
self.assertTrue('This is PDF' in open(os.path.join(self.staging_dir, u"%s-%s.pdf" % (name, rev))).read())
self.assertTrue(os.path.exists(os.path.join(self.staging_dir, u"%s-%s.ps" % (name, rev))))
self.assertTrue('This is PostScript' in open(os.path.join(self.staging_dir, u"%s-%s.ps" % (name, rev))).read())
class ApprovalsTests(django.test.TestCase):
def test_approvals(self):
make_test_data()
url = urlreverse('submit_approvals')
self.client.login(remote_user="marschairman")
Preapproval.objects.create(name="draft-ietf-mars-foo", by=Person.objects.get(user__username="marschairman"))
Preapproval.objects.create(name="draft-ietf-mars-baz", by=Person.objects.get(user__username="marschairman"))
Submission.objects.create(name="draft-ietf-mars-foo",
group_id=Group.objects.get(acronym="mars").pk,
submission_date=datetime.date.today(),
rev="00",
state_id="posted",
access_key="abc")
Submission.objects.create(name="draft-ietf-mars-bar",
group_id=Group.objects.get(acronym="mars").pk,
submission_date=datetime.date.today(),
rev="00",
state_id="grp-appr",
access_key="def")
# get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('.approvals a:contains("draft-ietf-mars-foo")')), 0)
self.assertEquals(len(q('.approvals a:contains("draft-ietf-mars-bar")')), 1)
self.assertEquals(len(q('.preapprovals td:contains("draft-ietf-mars-foo")')), 0)
self.assertEquals(len(q('.preapprovals td:contains("draft-ietf-mars-baz")')), 1)
self.assertEquals(len(q('.recently-approved a:contains("draft-ietf-mars-foo")')), 1)
def test_add_preapproval(self):
make_test_data()
url = urlreverse('submit_add_preapproval')
login_testing_unauthorized(self, "marschairman", url)
# get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('input[type=submit]')), 1)
# faulty post
r = self.client.post(url, dict(name="draft-test-nonexistingwg-something"))
self.assertEquals(r.status_code, 200)
self.assertTrue("errorlist" in r.content)
# add
name = "draft-ietf-mars-foo"
r = self.client.post(url, dict(name=name))
self.assertEquals(r.status_code, 302)
self.assertEquals(len(Preapproval.objects.filter(name=name)), 1)
def test_cancel_preapproval(self):
make_test_data()
preapproval = Preapproval.objects.create(name="draft-ietf-mars-foo", by=Person.objects.get(user__username="marschairman"))
url = urlreverse('submit_cancel_preapproval', kwargs=dict(preapproval_id=preapproval.pk))
login_testing_unauthorized(self, "marschairman", url)
# get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('input[type=submit]')), 1)
# cancel
r = self.client.post(url, dict(action="cancel"))
self.assertEquals(r.status_code, 302)
self.assertEquals(len(Preapproval.objects.filter(name=preapproval.name)), 0)
Reference in a new issue View git blame Copy permalink