def test_determine_merge_order(self):
p1 = self.get_person_no_user()
p2 = PersonFactory()
p3 = self.get_person_no_user()
p4 = PersonFactory()
# target has User
results = determine_merge_order(p1, p2)
self.assertEqual(results, (p1, p2))
# source has User
results = determine_merge_order(p2, p1)
self.assertEqual(results, (p1, p2))
# neither have User
results = determine_merge_order(p1, p3)
self.assertEqual(results, (p1, p3))
# both have User
today = datetime.datetime.today()
p2.user.last_login = today
p2.user.save()
p4.user.last_login = today - datetime.timedelta(days=30)
p4.user.save()
results = determine_merge_order(p2, p4)
self.assertEqual(results, (p4, p2))
def test_handle_users(self):
source1 = self.get_person_no_user()
target1 = self.get_person_no_user()
source2 = self.get_person_no_user()
target2 = PersonFactory()
source3 = PersonFactory()
target3 = self.get_person_no_user()
source4 = PersonFactory()
target4 = PersonFactory()
# no Users
result = handle_users(source1, target1)
self.assertTrue('DATATRACKER LOGIN ACTION: none' in result)
# target user
result = handle_users(source2, target2)
self.assertTrue("DATATRACKER LOGIN ACTION: retaining login {}".format(
target2.user) in result)
# source user
user = source3.user
result = handle_users(source3, target3)
self.assertTrue("DATATRACKER LOGIN ACTION: retaining login {}".format(
user) in result)
self.assertTrue(target3.user == user)
# both have user
source_user = source4.user
target_user = target4.user
result = handle_users(source4, target4)
self.assertTrue(
"DATATRACKER LOGIN ACTION: retaining login: {}, removing login: {}"
.format(target_user, source_user) in result)
self.assertTrue(target4.user == target_user)
self.assertTrue(source4.user == None)
def test_edit_replace_user(self):
person = PersonFactory()
user = UserFactory()
url = reverse('ietf.secr.rolodex.views.edit', kwargs={'id': person.id})
redirect_url = reverse('ietf.secr.rolodex.views.view',
kwargs={'id': person.id})
self.client.login(username="******", password="******")
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
post_data = {
'name': person.name,
'ascii': person.ascii,
'ascii_short': person.ascii_short,
'affiliation': person.affiliation,
'address': person.address,
'user': user.username,
'email-0-person': person.pk,
'email-0-address': person.email_address(),
'email-TOTAL_FORMS': 1,
'email-INITIAL_FORMS': 1,
'email-MIN_NUM_FORMS': 0,
'email-MAX_NUM_FORMS': 1000,
'submit': 'Submit',
}
original_user = person.user
person_id = person.pk
response = self.client.post(url, post_data, follow=True)
person = Person.objects.get(id=person_id)
original_user = User.objects.get(id=original_user.id)
self.assertRedirects(response, redirect_url)
self.assertEqual(person.user, user)
self.assertTrue(not original_user.is_active)
def test_merge_nominees(self):
nomcom_test_data()
nomcom = NomCom.objects.first()
source = PersonFactory()
source.nominee_set.create(nomcom=nomcom, email=source.email())
target = PersonFactory()
merge_nominees(source, target)
self.assertTrue(target.nominee_set.all())
def test_move_related_objects(self):
source = PersonFactory()
target = PersonFactory()
source_email = source.email_set.first()
source_alias = source.alias_set.first()
move_related_objects(source, target, file=StringIO())
self.assertTrue(source_email in target.email_set.all())
self.assertTrue(source_alias in target.alias_set.all())
def test_merge_persons(self):
source = PersonFactory()
target = PersonFactory()
source_id = source.pk
source_email = source.email_set.first()
source_alias = source.alias_set.first()
source_user = source.user
merge_persons(source, target, file=StringIO())
self.assertTrue(source_email in target.email_set.all())
self.assertTrue(source_alias in target.alias_set.all())
self.assertFalse(Person.objects.filter(id=source_id))
self.assertFalse(source_user.is_active)
def test_dedupe_aliases(self):
person = PersonFactory()
Alias.objects.create(person=person, name='Joe')
Alias.objects.create(person=person, name='Joe')
self.assertEqual(person.alias_set.filter(name='Joe').count(), 2)
dedupe_aliases(person)
self.assertEqual(person.alias_set.filter(name='Joe').count(), 1)
def test_send_merge_notification(self):
person = PersonFactory()
len_before = len(outbox)
send_merge_notification(person, ['Record Merged'])
self.assertEqual(len(outbox), len_before + 1)
self.assertTrue(
'IETF Datatracker records merged' in outbox[-1]['Subject'])
def test_profile(self):
person = PersonFactory(with_bio=True)
self.assertTrue(person.photo is not None)
self.assertTrue(person.photo.name is not None)
url = urlreverse("ietf.person.views.profile",
kwargs={"email_or_name": person.plain_name()})
r = self.client.get(url)
#debug.show('person.name')
#debug.show('person.plain_name()')
#debug.show('person.photo_name()')
self.assertContains(r, person.photo_name(), status_code=200)
q = PyQuery(r.content)
self.assertIn("Photo of %s" % person,
q("div.bio-text img.bio-photo").attr("alt"))
bio_text = q("div.bio-text").text()
self.assertIsNotNone(bio_text)
photo_url = q("div.bio-text img.bio-photo").attr("src")
r = self.client.get(photo_url)
self.assertEqual(r.status_code, 200)
def test_manage_group_list(self):
draft = make_test_data()
url = urlreverse(ietf.community.views.manage_list, kwargs={ "acronym": draft.group.acronym })
setup_default_community_list_for_group(draft.group)
login_testing_unauthorized(self, "marschairman", url)
# test GET, rest is tested with personal list
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
# Verify GET also works with non-WG and RG groups
for gtype in ['area','program']:
g = GroupFactory.create(type_id=gtype)
# make sure the group's features have been initialized to improve coverage
_ = g.features # pyflakes:ignore
p = PersonFactory()
g.role_set.create(name_id={'area':'ad','program':'lead'}[gtype],person=p, email=p.email())
url = urlreverse(ietf.community.views.manage_list, kwargs={ "acronym": g.acronym })
setup_default_community_list_for_group(g)
self.client.login(username=p.user.username,password=p.user.username+"+password")
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
def populate_personnel(obj, create, extracted, **kwargs): # pylint: disable=no-self-argument
'''
Create a default set of role holders, unless the factory is called
with populate_personnel=False
'''
if extracted is None:
extracted = True
if create and extracted:
#roles= ['chair', 'advisor'] + ['member']*10
roles = ['chair', 'advisor', 'member']
for role in roles:
p = PersonFactory()
obj.group.role_set.create(name_id=role,
person=p,
email=p.email_set.first())
def test_merge_users(self):
make_test_data()
person = PersonFactory()
source = person.user
target = UserFactory()
mars = Group.objects.get(acronym='mars')
communitylist = CommunityList.objects.create(user=source, group=mars)
nomcom = NomComFactory()
position = PositionFactory(nomcom=nomcom)
nominee = NomineeFactory(nomcom=nomcom, person=mars.get_chair().person)
feedback = FeedbackFactory(user=source, author=person, nomcom=nomcom)
feedback.nominees.add(nominee)
nomination = NominationFactory(nominee=nominee,
user=source,
position=position,
comments=feedback)
merge_users(source, target)
self.assertIn(communitylist, target.communitylist_set.all())
self.assertIn(feedback, target.feedback_set.all())
self.assertIn(nomination, target.nomination_set.all())
def get_person_no_user(self):
person = PersonFactory()
person.user = None
person.save()
return person
def test_name_methods(self):
person = PersonFactory(name=u"Dr. Jens F. Möller", )
self.assertEqual(person.name, u"Dr. Jens F. Möller")
self.assertEqual(person.ascii_name(), u"Dr. Jens F. Moller")
self.assertEqual(person.plain_name(), u"Jens Möller")
self.assertEqual(person.plain_ascii(), u"Jens Moller")
self.assertEqual(person.initials(), u"J. F.")
self.assertEqual(person.first_name(), u"Jens")
self.assertEqual(person.last_name(), u"Möller")
person = PersonFactory(name=u"吴建平")
# The following are probably incorrect because the given name should
# be Jianping and the surname should be Wu ...
# TODO: Figure out better handling for names with CJK characters.
# Maybe use ietf.person.cjk.*
self.assertEqual(person.ascii_name(), u"Wu Jian Ping")
def test_default_email(self):
person = PersonFactory()
primary = EmailFactory(person=person, primary=True, active=True)
EmailFactory(person=person, primary=False, active=True)
EmailFactory(person=person, primary=False, active=False)
self.assertTrue(primary.address in person.formatted_email())
def test_get_extra_primary(self):
source = PersonFactory()
target = PersonFactory()
extra = get_extra_primary(source, target)
self.assertTrue(extra == list(source.email_set.filter(primary=True)))
def test_manage_review_requests(self):
doc = make_test_data()
review_req1 = make_review_data(doc)
group = review_req1.team
url = urlreverse(ietf.group.views.manage_review_requests, kwargs={ 'acronym': group.acronym, "assignment_status": "assigned" })
login_testing_unauthorized(self, "secretary", url)
assigned_url = urlreverse(ietf.group.views.manage_review_requests, kwargs={ 'acronym': group.acronym, 'group_type': group.type_id, "assignment_status": "assigned" })
unassigned_url = urlreverse(ietf.group.views.manage_review_requests, kwargs={ 'acronym': group.acronym, 'group_type': group.type_id, "assignment_status": "unassigned" })
review_req2 = ReviewRequest.objects.create(
doc=review_req1.doc,
team=review_req1.team,
type_id="early",
deadline=datetime.date.today() + datetime.timedelta(days=30),
state_id="accepted",
reviewer=review_req1.reviewer,
requested_by=Person.objects.get(user__username="******"),
)
review_req3 = ReviewRequest.objects.create(
doc=review_req1.doc,
team=review_req1.team,
type_id="early",
deadline=datetime.date.today() + datetime.timedelta(days=30),
state_id="requested",
requested_by=Person.objects.get(user__username="******"),
)
# previous reviews
ReviewRequest.objects.create(
time=datetime.datetime.now() - datetime.timedelta(days=100),
requested_by=Person.objects.get(name="(System)"),
doc=doc,
type=ReviewTypeName.objects.get(slug="early"),
team=review_req1.team,
state=ReviewRequestStateName.objects.get(slug="completed"),
result=ReviewResultName.objects.get(slug="ready-nits"),
reviewed_rev="01",
deadline=datetime.date.today() - datetime.timedelta(days=80),
reviewer=review_req1.reviewer,
)
ReviewRequest.objects.create(
time=datetime.datetime.now() - datetime.timedelta(days=100),
requested_by=Person.objects.get(name="(System)"),
doc=doc,
type=ReviewTypeName.objects.get(slug="early"),
team=review_req1.team,
state=ReviewRequestStateName.objects.get(slug="completed"),
result=ReviewResultName.objects.get(slug="ready"),
reviewed_rev="01",
deadline=datetime.date.today() - datetime.timedelta(days=80),
reviewer=review_req1.reviewer,
)
# Need one more person in review team one so we can test incrementing skip_count without immediately decrementing it
another_reviewer = PersonFactory.create(name = u"Extra TestReviewer") # needs to be lexically greater than the exsting one
another_reviewer.role_set.create(name_id='reviewer', email=another_reviewer.email(), group=review_req1.team)
# get
r = self.client.get(assigned_url)
self.assertEqual(r.status_code, 200)
self.assertTrue(review_req1.doc.name in unicontent(r))
# can't save assigned: conflict
new_reviewer = Email.objects.get(role__name="reviewer", role__group=group, person__user__username="******")
# provoke conflict by posting bogus data
r = self.client.post(assigned_url, {
"reviewrequest": [str(review_req1.pk), str(review_req2.pk), str(123456)],
# close
"r{}-existing_reviewer".format(review_req1.pk): "123456",
"r{}-action".format(review_req1.pk): "close",
"r{}-close".format(review_req1.pk): "no-response",
# assign
"r{}-existing_reviewer".format(review_req2.pk): "123456",
"r{}-action".format(review_req2.pk): "assign",
"r{}-reviewer".format(review_req2.pk): new_reviewer.pk,
"action": "save-continue",
})
self.assertEqual(r.status_code, 200)
content = unicontent(r).lower()
self.assertTrue("1 request closed" in content)
self.assertTrue("2 requests changed assignment" in content)
# can't save unassigned: conflict
r = self.client.post(unassigned_url, {
"reviewrequest": [str(123456)],
"action": "save-continue",
})
self.assertEqual(r.status_code, 200)
content = unicontent(r).lower()
self.assertTrue("1 request opened" in content)
# close and reassign assigned
new_reviewer = Email.objects.get(role__name="reviewer", role__group=group, person__user__username="******")
r = self.client.post(assigned_url, {
"reviewrequest": [str(review_req1.pk), str(review_req2.pk)],
# close
"r{}-existing_reviewer".format(review_req1.pk): review_req1.reviewer_id or "",
"r{}-action".format(review_req1.pk): "close",
"r{}-close".format(review_req1.pk): "no-response",
# assign
"r{}-existing_reviewer".format(review_req2.pk): review_req2.reviewer_id or "",
"r{}-action".format(review_req2.pk): "assign",
"r{}-reviewer".format(review_req2.pk): new_reviewer.pk,
"r{}-add_skip".format(review_req2.pk) : 1,
"action": "save",
})
self.assertEqual(r.status_code, 302)
# no change on unassigned
r = self.client.post(unassigned_url, {
"reviewrequest": [str(review_req3.pk)],
# no change
"r{}-existing_reviewer".format(review_req3.pk): review_req3.reviewer_id or "",
"r{}-action".format(review_req3.pk): "",
"r{}-close".format(review_req3.pk): "no-response",
"r{}-reviewer".format(review_req3.pk): "",
"action": "save",
})
self.assertEqual(r.status_code, 302)
review_req1, review_req2, review_req3 = reload_db_objects(review_req1, review_req2, review_req3)
self.assertEqual(review_req1.state_id, "no-response")
self.assertEqual(review_req2.state_id, "requested")
self.assertEqual(review_req2.reviewer, new_reviewer)
settings = ReviewerSettings.objects.filter(team=review_req2.team, person=new_reviewer.person).first()
self.assertEqual(settings.skip_next,1)
self.assertEqual(review_req3.state_id, "requested")