global client_test_cert_files

if not client_test_cert_files:

client_test_cert_files = generate_cert()

"""Tests to create a new nomcom"""

def check_url_status(self, url, status):

response = self.client.get(url)

self.assertEqual(response.status_code, status)

return response

def setUp(self):

super().setUp()

setup_test_public_keys_dir(self)

nomcom_test_data()

self.cert_file, self.privatekey_file = get_cert_files()

self.year = NOMCOM_YEAR

self.email_from = settings.NOMCOM_FROM_EMAIL.format(year=self.year)

self.assertIn(self.year, self.email_from)

# private urls

self.private_index_url = reverse('ietf.nomcom.views.private_index', kwargs={'year': self.year})

self.private_merge_person_url = reverse('ietf.nomcom.views.private_merge_person', kwargs={'year': self.year})

self.private_merge_nominee_url = reverse('ietf.nomcom.views.private_merge_nominee', kwargs={'year': self.year})

self.edit_members_url = reverse('ietf.nomcom.views.edit_members', kwargs={'year': self.year})

self.edit_nomcom_url = reverse('ietf.nomcom.views.edit_nomcom', kwargs={'year': self.year})

self.private_nominate_url = reverse('ietf.nomcom.views.private_nominate', kwargs={'year': self.year})

self.private_nominate_newperson_url = reverse('ietf.nomcom.views.private_nominate_newperson', kwargs={'year': self.year})

self.add_questionnaire_url = reverse('ietf.nomcom.views.private_questionnaire', kwargs={'year': self.year})

self.private_feedback_url = reverse('ietf.nomcom.views.private_feedback', kwargs={'year': self.year})

self.positions_url = reverse('ietf.nomcom.views.list_positions', kwargs={'year': self.year})

self.edit_position_url = reverse('ietf.nomcom.views.edit_position', kwargs={'year': self.year})

# public urls

self.index_url = reverse('ietf.nomcom.views.year_index', kwargs={'year': self.year})

self.history_url = reverse('ietf.nomcom.views.history')

self.requirements_url = reverse('ietf.nomcom.views.requirements', kwargs={'year': self.year})

self.questionnaires_url = reverse('ietf.nomcom.views.questionnaires', kwargs={'year': self.year})

self.public_feedback_url = reverse('ietf.nomcom.views.public_feedback', kwargs={'year': self.year})

self.public_nominate_url = reverse('ietf.nomcom.views.public_nominate', kwargs={'year': self.year})

self.public_nominate_newperson_url = reverse('ietf.nomcom.views.public_nominate_newperson', kwargs={'year': self.year})

def tearDown(self):

teardown_test_public_keys_dir(self)

super().tearDown()

def access_member_url(self, url):

login_testing_unauthorized(self, COMMUNITY_USER, url)

login_testing_unauthorized(self, CHAIR_USER, url)

self.check_url_status(url, 200)

self.client.logout()

login_testing_unauthorized(self, MEMBER_USER, url)

return self.check_url_status(url, 200)

def access_chair_url(self, url):

login_testing_unauthorized(self, COMMUNITY_USER, url)

login_testing_unauthorized(self, MEMBER_USER, url)

login_testing_unauthorized(self, CHAIR_USER, url)

return self.check_url_status(url, 200)

def access_secretariat_url(self, url):

login_testing_unauthorized(self, COMMUNITY_USER, url)

login_testing_unauthorized(self, CHAIR_USER, url)

login_testing_unauthorized(self, SECRETARIAT_USER, url)

return self.check_url_status(url, 200)

def test_private_index_view(self):

"""Verify private home view"""

self.access_member_url(self.private_index_url)

# Verify that nominee table has links to person and feedback pages

nom_pos = self.create_nominee('accepted', COMMUNITY_USER, 'APP')

person_url = reverse('ietf.person.views.profile',

kwargs={'email_or_name': nom_pos.nominee.name()})

feedback_url = reverse('ietf.nomcom.views.view_feedback_nominee',

kwargs={'year': self.year, 'nominee_id': nom_pos.nominee.pk})

# With a single nominee, the first row will have our data.

# Require that the row have at least one link to the person URL

# and one to the feedback URL.

response = self.client.get(self.private_index_url)

q = PyQuery(response.content)

row_q = q('#nominee-position-table tbody tr').eq(0)

self.assertTrue(row_q('a[href="%s"]' % (person_url)),

'Nominee table does not link to nominee profile page')

self.assertTrue(row_q('a[href="%s#comment"]' % (feedback_url)),

'Nominee table does not link to nominee feedback page')

self.client.logout()

def create_nominee(self, base_state, username, pos_name):

cnominee = Nominee.objects.get(email__person__user__username=username)

position = Position.objects.get(name=pos_name)

return NomineePosition.objects.create(position=position,

nominee=cnominee,

state=NomineePositionStateName.objects.get(slug=base_state))

def create_nominees_for_states(self, base_state):

nom_pos = self.create_nominee(base_state, COMMUNITY_USER, 'APP')

self.create_nominee(base_state, COMMUNITY_USER, 'INT')

self.create_nominee(base_state, COMMUNITY_USER, 'OAM')

return nom_pos

def test_private_index_post_accept(self):

nom_pos = self.create_nominees_for_states('pending')

login_testing_unauthorized(self, CHAIR_USER, self.private_index_url)

test_data = {"action": "set_as_accepted",

"selected": [nom_pos.pk]}

r = self.client.post(self.private_index_url, test_data)

self.assertEqual(r.status_code, 200)

q = PyQuery(r.content)

self.assertTrue(q('.alert-success'))

self.assertEqual(NomineePosition.objects.filter(state='accepted').count (), 1)

self.client.logout()

def test_private_index_post_decline(self):

nom_pos = self.create_nominees_for_states('pending')

login_testing_unauthorized(self, CHAIR_USER, self.private_index_url)

test_data = {"action": "set_as_declined",

"selected": [nom_pos.pk]}

r = self.client.post(self.private_index_url, test_data)

self.assertEqual(r.status_code, 200)

q = PyQuery(r.content)

self.assertTrue(q('.alert-success'))

self.assertEqual(NomineePosition.objects.filter(state='declined').count (), 1)

self.client.logout()

def test_private_index_post_pending(self):

nom_pos = self.create_nominees_for_states('declined')

login_testing_unauthorized(self, CHAIR_USER, self.private_index_url)

test_data = {"action": "set_as_pending",

"selected": [nom_pos.pk]}

r = self.client.post(self.private_index_url, test_data)

self.assertEqual(r.status_code, 200)

q = PyQuery(r.content)

self.assertTrue(q('.alert-success'))

self.assertEqual(NomineePosition.objects.filter(state='pending').count (), 1)

self.client.logout()

def test_private_merge_view(self):

"""Verify private nominee merge view"""

nominees = ['nominee0@example.com',

'nominee1@example.com',

'nominee2@example.com',

'nominee3@example.com']

# do nominations

login_testing_unauthorized(self, COMMUNITY_USER, self.public_nominate_url)

self.nominate_view(public=True,

nominee_email=nominees[0],

position='IAOC')

self.nominate_view(public=True,

nominee_email=nominees[0],

position='IAOC')

self.nominate_view(public=True,

nominee_email=nominees[0],

position='IAB')

self.nominate_view(public=True,

nominee_email=nominees[0],

position='TSV')

self.nominate_view(public=True,

nominee_email=nominees[1],

position='IAOC')

self.nominate_view(public=True,

nominee_email=nominees[1],

position='IAOC')

self.nominate_view(public=True,

nominee_email=nominees[2],

position='IAB')

self.nominate_view(public=True,

nominee_email=nominees[2],

position='IAB')

self.nominate_view(public=True,

nominee_email=nominees[3],

position='TSV')

self.nominate_view(public=True,

nominee_email=nominees[3],

position='TSV')

# Check nominee positions

self.assertEqual(NomineePosition.objects.count(), 6)

self.assertEqual(Feedback.objects.nominations().count(), 10)

# Accept and declined nominations

nominee_position = NomineePosition.objects.get(position__name='IAOC',

nominee__email__address=nominees[0])

nominee_position.state = NomineePositionStateName.objects.get(slug='accepted')

nominee_position.save()

nominee_position = NomineePosition.objects.get(position__name='IAOC',

nominee__email__address=nominees[1])

nominee_position.state = NomineePositionStateName.objects.get(slug='declined')

nominee_position.save()

nominee_position = NomineePosition.objects.get(position__name='IAB',

nominee__email__address=nominees[2])

nominee_position.state = NomineePositionStateName.objects.get(slug='declined')

nominee_position.save()

nominee_position = NomineePosition.objects.get(position__name='TSV',

nominee__email__address=nominees[3])

nominee_position.state = NomineePositionStateName.objects.get(slug='accepted')

nominee_position.save()

self.client.logout()

# fill questionnaires (internally the function does new nominations)

self.access_chair_url(self.add_questionnaire_url)

self.add_questionnaire(public=False,

nominee_email=nominees[0],

position='IAOC')

self.add_questionnaire(public=False,

nominee_email=nominees[1],

position='IAOC')

self.add_questionnaire(public=False,

nominee_email=nominees[2],

position='IAB')

self.add_questionnaire(public=False,

nominee_email=nominees[3],

position='TSV')

self.assertEqual(Feedback.objects.questionnaires().count(), 4)

self.client.logout()

## Add feedbacks (internally the function does new nominations)

self.access_member_url(self.private_feedback_url)

self.feedback_view(public=False,

nominee_email=nominees[0],

position='IAOC')

self.feedback_view(public=False,

nominee_email=nominees[1],

position='IAOC')

self.feedback_view(public=False,

nominee_email=nominees[2],

position='IAB')

self.feedback_view(public=False,

nominee_email=nominees[3],

position='TSV')

self.assertEqual(Feedback.objects.comments().count(), 4)

self.assertEqual(Feedback.objects.nominations().count(), 18)

self.assertEqual(Feedback.objects.nominations().filter(nominees__email__address=nominees[0]).count(), 6)

self.assertEqual(Feedback.objects.nominations().filter(nominees__email__address=nominees[1]).count(), 4)

self.assertEqual(Feedback.objects.nominations().filter(nominees__email__address=nominees[2]).count(), 4)

self.assertEqual(Feedback.objects.nominations().filter(nominees__email__address=nominees[3]).count(), 4)

for nominee in nominees:

self.assertEqual(Feedback.objects.comments().filter(nominees__email__address=nominee).count(),

1)

self.assertEqual(Feedback.objects.questionnaires().filter(nominees__email__address=nominee).count(),

1)

self.client.logout()

## merge nominations

self.access_chair_url(self.private_merge_nominee_url)

test_data = {"secondary_emails": "%s, %s" % (nominees[0], nominees[1]),

"primary_email": nominees[0]}

response = self.client.post(self.private_merge_nominee_url, test_data)

self.assertEqual(response.status_code, 200)

q = PyQuery(response.content)

self.assertTrue(q("form .is-invalid"))

test_data = {"primary_email": nominees[0],

"secondary_emails": ""}

response = self.client.post(self.private_merge_nominee_url, test_data)

self.assertEqual(response.status_code, 200)

q = PyQuery(response.content)

self.assertTrue(q("form .is-invalid"))

test_data = {"primary_email": "",

"secondary_emails": nominees[0]}

response = self.client.post(self.private_merge_nominee_url, test_data)

self.assertEqual(response.status_code, 200)

q = PyQuery(response.content)

self.assertTrue(q("form .is-invalid"))

test_data = {"primary_email": "unknown@example.com",

"secondary_emails": nominees[0]}

response = self.client.post(self.private_merge_nominee_url, test_data)

self.assertEqual(response.status_code, 200)

q = PyQuery(response.content)

self.assertTrue(q("form .is-invalid"))

test_data = {"primary_email": nominees[0],

"secondary_emails": "unknown@example.com"}

response = self.client.post(self.private_merge_nominee_url, test_data)

self.assertEqual(response.status_code, 200)

q = PyQuery(response.content)

self.assertTrue(q("form .is-invalid"))

test_data = {"secondary_emails": [nominees[1], nominees[2], nominees[3]],

"primary_email": nominees[0]}

response = self.client.post(self.private_merge_nominee_url, test_data)

self.assertEqual(response.status_code, 302)

redirect_url = response["Location"]

redirect_path = urlparse(redirect_url).path

self.assertEqual(redirect_path, reverse('ietf.nomcom.views.private_index', kwargs={"year": NOMCOM_YEAR}))

response = self.client.get(redirect_url)

self.assertEqual(response.status_code, 200)

self.assertContains(response, "alert-success")

self.assertEqual(Nominee.objects.filter(email__address=nominees[1],

duplicated__isnull=False).count(), 1)

self.assertEqual(Nominee.objects.filter(email__address=nominees[2],

duplicated__isnull=False).count(), 1)

self.assertEqual(Nominee.objects.filter(email__address=nominees[3],

duplicated__isnull=False).count(), 1)

nominee = Nominee.objects.get(email__address=nominees[0])

self.assertEqual(Nomination.objects.filter(nominee=nominee).count(), 18)

self.assertEqual(Feedback.objects.nominations().filter(nominees__in=[nominee]).count(),

18)

self.assertEqual(Feedback.objects.comments().filter(nominees__in=[nominee]).count(),

4)

self.assertEqual(Feedback.objects.questionnaires().filter(nominees__in=[nominee]).count(),

4)

for nominee_email in nominees[1:]:

self.assertEqual(Feedback.objects.nominations().filter(nominees__email__address=nominee_email).count(),

0)

self.assertEqual(Feedback.objects.comments().filter(nominees__email__address=nominee_email).count(),

0)

self.assertEqual(Feedback.objects.questionnaires().filter(nominees__email__address=nominee_email).count(),

0)

self.assertEqual(NomineePosition.objects.filter(nominee=nominee).count(), 3)

# Check nominations state

self.assertEqual(NomineePosition.objects.get(position__name='TSV',

nominee=nominee).state.slug, 'accepted')

self.assertEqual(NomineePosition.objects.get(position__name='IAOC',

nominee=nominee).state.slug, 'accepted')

self.assertEqual(NomineePosition.objects.get(position__name='IAB',

nominee=nominee).state.slug, 'declined')

self.client.logout()

def change_members(self, members=None, liaisons=None):

test_data = {}

if members is not None:

members_emails = ['%s%s' % (member, EMAIL_DOMAIN) for member in members]

test_data['members'] = members_emails

if liaisons is not None:

liaisons_emails = ['%s%s' % (liaison, EMAIL_DOMAIN) for liaison in liaisons]

test_data['liaisons'] = liaisons_emails

self.client.post(self.edit_members_url, test_data)

def test_edit_members_view(self):

"""Verify edit member view"""

self.access_chair_url(self.edit_members_url)

self.change_members([CHAIR_USER, COMMUNITY_USER])

# check member actions

self.client.login(username=COMMUNITY_USER,password=COMMUNITY_USER+"+password")

self.check_url_status(self.private_index_url, 200)

self.client.logout()

# revert edit nomcom members

login_testing_unauthorized(self, CHAIR_USER, self.edit_members_url)

self.change_members([CHAIR_USER])

self.client.logout()

self.client.login(username=COMMUNITY_USER,password=COMMUNITY_USER+"+password")

self.check_url_status(self.private_index_url, 403)

self.client.logout()

def test_edit_members_only_removes_member_roles(self):

"""Removing a member or liaison should not affect other roles"""

# log in and set up members/liaisons lists

self.access_chair_url(self.edit_members_url)

self.change_members(

members=[CHAIR_USER, COMMUNITY_USER],

liaisons=[CHAIR_USER, COMMUNITY_USER],

)

nomcom_group = Group.objects.get(acronym=f'nomcom{self.year}')

self.assertCountEqual(

nomcom_group.role_set.filter(name='member').values_list('email__address', flat=True),

[CHAIR_USER + EMAIL_DOMAIN, COMMUNITY_USER + EMAIL_DOMAIN],

)

self.assertCountEqual(

nomcom_group.role_set.filter(name='liaison').values_list('email__address', flat=True),

[CHAIR_USER + EMAIL_DOMAIN, COMMUNITY_USER + EMAIL_DOMAIN],

)

# remove a member who is also a liaison and check that the liaisons list is unchanged

self.change_members(

members=[COMMUNITY_USER],

liaisons=[CHAIR_USER, COMMUNITY_USER],

)

nomcom_group = Group.objects.get(pk=nomcom_group.pk) # refresh from db

self.assertCountEqual(

nomcom_group.role_set.filter(name='member').values_list('email__address', flat=True),

[COMMUNITY_USER + EMAIL_DOMAIN],

)

self.assertCountEqual(

nomcom_group.role_set.filter(name='liaison').values_list('email__address', flat=True),

[CHAIR_USER + EMAIL_DOMAIN, COMMUNITY_USER + EMAIL_DOMAIN],

)

# remove a liaison who is also a member and check that the members list is unchanged

self.change_members(

members=[COMMUNITY_USER],

liaisons=[CHAIR_USER],

)

nomcom_group = Group.objects.get(pk=nomcom_group.pk) # refresh from db

self.assertCountEqual(

nomcom_group.role_set.filter(name='member').values_list('email__address', flat=True),

[COMMUNITY_USER + EMAIL_DOMAIN],

)

self.assertCountEqual(

nomcom_group.role_set.filter(name='liaison').values_list('email__address', flat=True),

[CHAIR_USER + EMAIL_DOMAIN],

)

def test_edit_nomcom_view(self):

r = self.access_chair_url(self.edit_nomcom_url)

q = PyQuery(r.content)

reminder_date = '%s-09-30' % self.year

f = io.open(self.cert_file.name)

response = self.client.post(self.edit_nomcom_url, {

'public_key': f,

'reminderdates_set-TOTAL_FORMS': q('input[name="reminderdates_set-TOTAL_FORMS"]').val(),

'reminderdates_set-INITIAL_FORMS': q('input[name="reminderdates_set-INITIAL_FORMS"]').val(),

'reminderdates_set-MAX_NUM_FORMS': q('input[name="reminderdates_set-MAX_NUM_FORMS"]').val(),

'reminderdates_set-0-date': reminder_date,

})

f.close()

self.assertEqual(response.status_code, 200)

nominee = Nominee.objects.get(email__person__user__username=COMMUNITY_USER)

position = Position.objects.get(name='OAM')

comment_text = 'Plain text. Comments with accents äöåÄÖÅ éáíóú âêîôû ü àèìòù.'

nomcom = get_nomcom_by_year(self.year)

feedback = Feedback.objects.create(nomcom=nomcom,

comments=nomcom.encrypt(comment_text),

type=FeedbackTypeName.objects.get(slug='nomina'))

feedback.positions.add(position)

feedback.nominees.add(nominee)

# to check feedback comments are saved like enrypted data

self.assertNotEqual(feedback.comments, comment_text)

self.assertEqual(check_comments(feedback.comments, comment_text, self.privatekey_file), True)

# Check that the set reminder date is present

reminder_dates = dict([ (d.id,str(d.date)) for d in nomcom.reminderdates_set.all() ])

self.assertIn(reminder_date, list(reminder_dates.values()))

# Remove reminder date

q = PyQuery(response.content) # from previous post

r = self.client.post(self.edit_nomcom_url, {

'reminderdates_set-TOTAL_FORMS': q('input[name="reminderdates_set-TOTAL_FORMS"]').val(),

'reminderdates_set-INITIAL_FORMS': q('input[name="reminderdates_set-INITIAL_FORMS"]').val(),

'reminderdates_set-MAX_NUM_FORMS': q('input[name="reminderdates_set-MAX_NUM_FORMS"]').val(),

'reminderdates_set-0-id': str(list(reminder_dates.keys())[0]),

'reminderdates_set-0-date': '',

})

self.assertEqual(r.status_code, 200)

# Check that reminder date has been removed

reminder_dates = dict([ (d.id,str(d.date)) for d in ReminderDates.objects.filter(nomcom=nomcom) ])

self.assertNotIn(reminder_date, list(reminder_dates.values()))

self.client.logout()

def test_list_positions(self):

login_testing_unauthorized(self, CHAIR_USER, self.positions_url)

def test_list_positions_add(self):

nomcom = get_nomcom_by_year(self.year)

count = nomcom.position_set.all().count()

login_testing_unauthorized(self, CHAIR_USER, self.edit_position_url)

test_data = {"action" : "add", "name": "testpos" }

r = self.client.post(self.edit_position_url, test_data)

self.assertEqual(r.status_code, 302)

self.assertEqual(nomcom.position_set.all().count(), count+1)

def test_index_view(self):

"""Verify home view"""

self.check_url_status(self.index_url, 200)

def test_history_view(self):

"""Verify history view"""

self.check_url_status(self.history_url, 200)

def test_announcements_view(self):

nomcom = Group.objects.get(acronym="nomcom%s" % self.year, type="nomcom")

msg = Message.objects.create(

by=Person.objects.all()[0],

subject="This is a test",

to="test@example.com",

frm="nomcomchair@example.com",

body="Hello World!",

content_type="text/plain",

)

msg.related_groups.add(nomcom)

r = self.client.get(reverse('ietf.nomcom.views.announcements'))

self.assertEqual(r.status_code, 200)

self.assertContains(r, ("Messages from %s" % nomcom.time.year))

self.assertContains(r, nomcom.role_set.filter(name="chair")[0].person.email_address())

self.assertContains(r, msg.subject)

def test_requirements_view(self):

"""Verify requirements view"""

self.check_url_status(self.requirements_url, 200)

def test_questionnaires_view(self):

"""Verify questionnaires view"""

self.check_url_status(self.questionnaires_url, 200)

def test_public_nominate(self):

login_testing_unauthorized(self, COMMUNITY_USER, self.public_nominate_url)

messages_before = len(outbox)

self.nominate_view(public=True,confirmation=True)

self.assertEqual(len(outbox), messages_before + 3)

self.assertEqual('IETF Nomination Information', outbox[-3]['Subject'])

self.assertEqual(self.email_from, outbox[-3]['From'])

self.assertIn('nominee', outbox[-3]['To'])

self.assertEqual('Nomination Information', outbox[-2]['Subject'])

self.assertEqual(self.email_from, outbox[-2]['From'])

self.assertIn('nomcomchair', outbox[-2]['To'])

self.assertEqual('Nomination receipt', outbox[-1]['Subject'])

self.assertEqual(self.email_from, outbox[-1]['From'])

self.assertIn('plain', outbox[-1]['To'])

self.assertIn('Comments with accents äöå', get_payload_text(outbox[-1]))

# Nominate the same person for the same position again without asking for confirmation

messages_before = len(outbox)

self.nominate_view(public=True)

self.assertEqual(len(outbox), messages_before + 1)

self.assertEqual('Nomination Information', outbox[-1]['Subject'])

self.assertEqual(self.email_from, outbox[-1]['From'])

self.assertIn('nomcomchair', outbox[-1]['To'])

def test_private_nominate(self):

self.access_member_url(self.private_nominate_url)

return self.nominate_view(public=False)

self.client.logout()

def test_public_nominate_newperson(self):

login_testing_unauthorized(self, COMMUNITY_USER, self.public_nominate_url)

messages_before = len(outbox)

self.nominate_newperson_view(public=True,confirmation=True)

self.assertEqual(len(outbox), messages_before + 4)

self.assertEqual('New person is created', outbox[-4]['Subject'])

self.assertEqual(self.email_from, outbox[-4]['From'])

self.assertIn('secretariat', outbox[-4]['To'])

self.assertEqual('IETF Nomination Information', outbox[-3]['Subject'])

self.assertEqual(self.email_from, outbox[-3]['From'])

self.assertIn('nominee', outbox[-3]['To'])

self.assertEqual('Nomination Information', outbox[-2]['Subject'])

self.assertEqual(self.email_from, outbox[-2]['From'])

self.assertIn('nomcomchair', outbox[-2]['To'])

self.assertEqual('Nomination receipt', outbox[-1]['Subject'])

self.assertEqual(self.email_from, outbox[-1]['From'])

self.assertIn('plain', outbox[-1]['To'])

self.assertIn('Comments with accents äöå', get_payload_text(outbox[-1]))

# Nominate the same person for the same position again without asking for confirmation

messages_before = len(outbox)

self.nominate_view(public=True)

self.assertEqual(len(outbox), messages_before + 1)

self.assertEqual('Nomination Information', outbox[-1]['Subject'])

self.assertEqual(self.email_from, outbox[-1]['From'])

self.assertIn('nomcomchair', outbox[-1]['To'])

def test_private_nominate_newperson(self):

self.access_member_url(self.private_nominate_url)

return self.nominate_newperson_view(public=False)

self.client.logout()

def test_private_nominate_newperson_who_already_exists(self):

EmailFactory(address='nominee@example.com')

self.access_member_url(self.private_nominate_newperson_url)

return self.nominate_newperson_view(public=False)

def test_public_nominate_with_automatic_questionnaire(self):

nomcom = get_nomcom_by_year(self.year)

nomcom.send_questionnaire = True

nomcom.save()

login_testing_unauthorized(self, COMMUNITY_USER, self.public_nominate_url)

empty_outbox()

self.nominate_view(public=True)

self.assertEqual(len(outbox), 3)

# test_public_nominate checks the other messages

self.assertEqual(self.email_from, outbox[-1]['From'])

self.assertIn('Questionnaire', outbox[1]['Subject'])

self.assertIn('nominee@', outbox[1]['To'])

def nominate_view(self, *args, **kwargs):

public = kwargs.pop('public', True)

searched_email = kwargs.pop('searched_email', None)

nominee_email = kwargs.pop('nominee_email', 'nominee@example.com')

if not searched_email:

searched_email = Email.objects.filter(address=nominee_email).first()

if not searched_email:

searched_email = EmailFactory(address=nominee_email, primary=True, origin='test')

if not searched_email.person:

searched_email.person = PersonFactory()

searched_email.save()

nominator_email = kwargs.pop('nominator_email', "%s%s" % (COMMUNITY_USER, EMAIL_DOMAIN))

position_name = kwargs.pop('position', 'IAOC')

confirmation = kwargs.pop('confirmation', False)

if public:

nominate_url = self.public_nominate_url

else:

nominate_url = self.private_nominate_url

response = self.client.get(nominate_url)

self.assertEqual(response.status_code, 200)

nomcom = get_nomcom_by_year(self.year)

if not nomcom.public_key:

q = PyQuery(response.content)

self.assertEqual(len(q("#nominate-form")), 0)

# save the cert file in tmp

#nomcom.public_key.storage.location = tempfile.gettempdir()

nomcom.public_key.save('cert', File(io.open(self.cert_file.name, 'r')))

response = self.client.get(nominate_url)

self.assertEqual(response.status_code, 200)

q = PyQuery(response.content)

self.assertEqual(len(q("#nominate-form")), 1)

position = Position.objects.get(name=position_name)

comment_text = 'Test nominate view. Comments with accents äöåÄÖÅ éáíóú âêîôû ü àèìòù.'

candidate_phone = '123456'

test_data = {'searched_email': searched_email.pk,

'candidate_phone': candidate_phone,

'position': position.id,

'qualifications': comment_text,

'confirmation': confirmation}

if not public:

test_data['nominator_email'] = nominator_email

response = self.client.post(nominate_url, test_data)

self.assertEqual(response.status_code, 200)

q = PyQuery(response.content)

self.assertContains(response, "alert-success")

# check objects

nominee = Nominee.objects.get(email=searched_email)

NomineePosition.objects.get(position=position, nominee=nominee)

feedback = Feedback.objects.filter(positions__in=[position],

nominees__in=[nominee],

type=FeedbackTypeName.objects.get(slug='nomina')).latest('id')

if public:

self.assertEqual(feedback.author, nominator_email)

# to check feedback comments are saved like enrypted data

self.assertNotEqual(feedback.comments, comment_text)

self.assertEqual(check_comments(feedback.comments, comment_text, self.privatekey_file), True)

Nomination.objects.get(position=position,

candidate_name=nominee.person.plain_name(),

candidate_email=searched_email.address,

candidate_phone=candidate_phone,

nominee=nominee,

comments=feedback,

nominator_email="%s%s" % (COMMUNITY_USER, EMAIL_DOMAIN))

def nominate_newperson_view(self, *args, **kwargs):

public = kwargs.pop('public', True)

nominee_email = kwargs.pop('nominee_email', 'nominee@example.com')

nominator_email = kwargs.pop('nominator_email', "%s%s" % (COMMUNITY_USER, EMAIL_DOMAIN))

position_name = kwargs.pop('position', 'IAOC')

confirmation = kwargs.pop('confirmation', False)

if public:

nominate_url = self.public_nominate_newperson_url

else:

nominate_url = self.private_nominate_newperson_url

response = self.client.get(nominate_url)

self.assertEqual(response.status_code, 200)

nomcom = get_nomcom_by_year(self.year)

if not nomcom.public_key:

q = PyQuery(response.content)

self.assertEqual(len(q("#nominate-form")), 0)

# save the cert file in tmp

#nomcom.public_key.storage.location = tempfile.gettempdir()

nomcom.public_key.save('cert', File(io.open(self.cert_file.name, 'r')))

response = self.client.get(nominate_url)

self.assertEqual(response.status_code, 200)

q = PyQuery(response.content)

self.assertEqual(len(q("#nominate-form")), 1)

position = Position.objects.get(name=position_name)

candidate_email = nominee_email

candidate_name = 'nominee'

comment_text = 'Test nominate view. Comments with accents äöåÄÖÅ éáíóú âêîôû ü àèìòù.'

candidate_phone = '123456'

test_data = {'candidate_name': candidate_name,

'candidate_email': candidate_email,

'candidate_phone': candidate_phone,

'position': position.id,

'qualifications': comment_text,

'confirmation': confirmation}

if not public:

test_data['nominator_email'] = nominator_email

if Email.objects.filter(address=nominee_email).exists():

response = self.client.post(nominate_url, test_data,follow=True)

self.assertFalse(response.redirect_chain)

self.assertEqual(response.status_code, 200)

self.assertIn('already in the datatracker',unicontent(response))

else:

response = self.client.post(nominate_url, test_data,follow=True)

self.assertTrue(response.redirect_chain)

self.assertEqual(response.status_code, 200)

q = PyQuery(response.content)

self.assertContains(response, "alert-success")

# check objects

email = Email.objects.get(address=candidate_email)

Person.objects.get(name=candidate_name)

nominee = Nominee.objects.get(email=email)

NomineePosition.objects.get(position=position, nominee=nominee)

feedback = Feedback.objects.filter(positions__in=[position],

nominees__in=[nominee],

type=FeedbackTypeName.objects.get(slug='nomina')).latest('id')

if public:

self.assertEqual(feedback.author, nominator_email)

# to check feedback comments are saved like enrypted data

self.assertNotEqual(feedback.comments, comment_text)

self.assertEqual(check_comments(feedback.comments, comment_text, self.privatekey_file), True)

Nomination.objects.get(position=position,

candidate_name=candidate_name,

candidate_email=candidate_email,

candidate_phone=candidate_phone,

nominee=nominee,

comments=feedback,

nominator_email="%s%s" % (COMMUNITY_USER, EMAIL_DOMAIN))

def test_add_questionnaire(self):

self.access_chair_url(self.add_questionnaire_url)

return self.add_questionnaire()

self.client.logout()

def add_questionnaire(self, *args, **kwargs):

public = kwargs.pop('public', False)

nominee_email = kwargs.pop('nominee_email', 'nominee@example.com')

nominator_email = kwargs.pop('nominator_email', "%s%s" % (COMMUNITY_USER, EMAIL_DOMAIN))

position_name = kwargs.pop('position', 'IAOC')

self.nominate_view(public=public,

nominee_email=nominee_email,

position=position_name,

nominator_email=nominator_email)

response = self.client.get(self.add_questionnaire_url)

self.assertEqual(response.status_code, 200)

nomcom = get_nomcom_by_year(self.year)

if not nomcom.public_key:

self.assertNotContains(response, "questionnnaireform")

# save the cert file in tmp

#nomcom.public_key.storage.location = tempfile.gettempdir()

nomcom.public_key.save('cert', File(io.open(self.cert_file.name, 'r')))

response = self.client.get(self.add_questionnaire_url)

self.assertEqual(response.status_code, 200)

self.assertContains(response, "questionnnaireform")

position = Position.objects.get(name=position_name)

nominee = Nominee.objects.get(email__address=nominee_email)

comment_text = 'Test add questionnaire view. Comments with accents äöåÄÖÅ éáíóú âêîôû ü àèìòù.'

test_data = {'comment_text': comment_text,

'nominee': '%s_%s' % (position.id, nominee.id)}

response = self.client.post(self.add_questionnaire_url, test_data)

self.assertContains(response, "alert-success")

## check objects

feedback = Feedback.objects.filter(positions__in=[position],

nominees__in=[nominee],

type=FeedbackTypeName.objects.get(slug='questio')).latest('id')

## to check feedback comments are saved like enrypted data

self.assertNotEqual(feedback.comments, comment_text)

self.assertEqual(check_comments(feedback.comments, comment_text, self.privatekey_file), True)

def test_public_feedback(self):

login_testing_unauthorized(self, COMMUNITY_USER, self.public_feedback_url)

position = "IAOC"

empty_outbox()

self.feedback_view(public=True, confirmation=True, position=position)

# feedback_view does a nomination internally: there is a lot of email related to that - tested elsewhere

# We're interested in the confirmation receipt here

self.assertEqual(len(outbox),3)

self.assertEqual('NomCom comment confirmation', outbox[2]['Subject'])

email_body = get_payload_text(outbox[2])

self.assertIn(position, email_body)

self.assertNotIn('$', email_body)

self.assertEqual(self.email_from, outbox[-2]['From'])

self.assertIn('plain', outbox[2]['To'])

self.assertIn('Comments with accents äöå', get_payload_text(outbox[2]))

empty_outbox()

self.feedback_view(public=True)

self.assertEqual(len(outbox),1)

self.assertNotIn('confirmation', outbox[0]['Subject'])

def test_private_feedback(self):

self.access_member_url(self.private_feedback_url)

return self.feedback_view(public=False)

def feedback_view(self, *args, **kwargs):

public = kwargs.pop('public', True)

nominee_email = kwargs.pop('nominee_email', 'nominee@example.com')

nominator_email = kwargs.pop('nominator_email', "%s%s" % (COMMUNITY_USER, EMAIL_DOMAIN))

position_name = kwargs.pop('position', 'IAOC')

confirmation = kwargs.pop('confirmation', False)

self.nominate_view(public=public,

nominee_email=nominee_email,

position=position_name,

nominator_email=nominator_email)

feedback_url = self.public_feedback_url

if not public:

feedback_url = self.private_feedback_url

response = self.client.get(feedback_url)

self.assertEqual(response.status_code, 200)

nomcom = get_nomcom_by_year(self.year)