def test_transform_empty_question_to_yes_no(self):
q = Question(desc='si_no question', si_no=False)
q.save()
self.assertTrue(q.si_no == False)
q.si_no = True
self.assertTrue(q.si_no == True)
def test_edit_yes_no_question_desc(self):
q = Question(desc='si_no question', si_no=True)
q.save()
self.assertTrue(q.si_no == True)
q.desc = 'si_no question modificada'
self.assertTrue(q.desc == 'si_no question modificada')
def test_three_candidates_voting_senate(self):
u = User(username='******')
u.set_password('senator')
u.save()
u1 = User(username='******')
u1.set_password('senator1')
u1.save()
u2 = User(username='******')
u2.set_password('senator2')
u2.save()
u3 = User(username='******')
u3.set_password('senator3')
u3.save()
q = Question(desc='Choose')
q.save()
opt1 = QuestionOption(question=q, option='senator')
opt1.save()
opt2 = QuestionOption(question=q, option='senator1')
opt2.save()
opt3 = QuestionOption(question=q, option='senator2')
opt3.save()
opt4 = QuestionOption(question=q, option='senator3')
opt4.save()
political_party = PoliticalParty(name='Partido Popular',
acronym='PP',
description='test',
headquarters='test')
political_party.save()
birthdate = date(2000, 2, 28)
userProfile = UserProfile(related_political_party=political_party,
birthdate=birthdate,
sex='F',
related_user=u,
province='S',
employment='S')
userProfile.save()
userProfile1 = UserProfile(related_political_party=political_party,
birthdate=birthdate,
sex='F',
related_user=u1,
province='S',
employment='S')
userProfile1.save()
userProfile2 = UserProfile(related_political_party=political_party,
birthdate=birthdate,
sex='F',
related_user=u2,
province='S',
employment='S')
userProfile2.save()
userProfile3 = UserProfile(related_political_party=political_party,
birthdate=birthdate,
sex='F',
related_user=u3,
province='S',
employment='S')
userProfile3.save()
v = Voting(name='test voting', question=q, tipe='S', province='S')
v.save()
a, _ = Auth.objects.get_or_create(url=settings.BASEURL,
defaults={
'me': True,
'name': 'test auth'
})
a.save()
v.auths.add(a)
self.assertRaises(ValidationError, v.clean)
def setUp(self):
self.client = APIClient()
mods.mock_query(self.client)
voter1 = User(username='******', id="9")
voter1.set_password('voter')
voter1.save()
admin = User(username='******', is_staff=True)
admin.set_password('admin')
admin.is_superuser = True
admin.save()
q = Question(desc='Preferences question', preferences=True)
q.save()
for i in range(2):
optPref = QuestionOption(question=q,
option='option {}'.format(i + 1),
number='{}'.format(i + 1))
optPref.save()
q1 = Question(desc='Simple question1')
q1.save()
for i in range(3):
optPref = QuestionOption(question=q1,
option='option {}'.format(i + 1))
optPref.save()
q2 = Question(desc='Simple question1')
q2.save()
for i in range(3):
optPref = QuestionOption(question=q2,
option='option {}'.format(i + 1))
optPref.save()
a, _ = Auth.objects.get_or_create(url=settings.BASEURL,
defaults={
'me': True,
'name': 'test auth'
})
a.save()
a2, _ = Auth.objects.get_or_create(url=settings.BASEURL,
defaults={
'me': True,
'name': 'test auth'
})
a2.save()
v1 = Voting(name='test voting', id="4")
v1.save()
v1.auths.add(a)
v1.question.add(q)
v1.save()
v = Voting(name='test voting', id="2")
v.save()
v.auths.add(a)
v.question.add(q1)
v.question.add(q2)
v.save()
v2 = Voting(name='test voting 2', id='3')
v2.save()
v2.auths.add(a2)
v2.question.add(q1)
v2.question.add(q2)
census = Census(voting_id=2, voter_id=9)
census = Census(voting_id=4, voter_id=9)
census = Census(voting_id=1, voter_id=9)
census.save()
options = webdriver.ChromeOptions()
options.add_argument('--no-sandbox')
options.headless = True
self.driver = webdriver.Chrome(options=options)
super().setUp()
class Github(StaticLiveServerTestCase):
def create_voting(self):
self.q = Question(desc='Prueba votación')
self.q.save()
for i in range(2):
opt = QuestionOption(question=self.q,
option='Opción {}'.format(i + 1))
opt.save()
self.v = Voting(name='Prueba votación', question=self.q, slug="prueba")
self.v.save()
self.a, _ = Auth.objects.get_or_create(url=settings.BASEURL,
defaults={
'me': True,
'name': 'test auth'
})
self.a.save()
self.v.auths.add(self.a)
self.v.create_pubkey()
self.v.start_date = timezone.now()
self.v.save()
def setUp(self):
self.base = BaseTestCase()
self.base.setUp()
self.vars = {}
self.create_voting()
options = webdriver.ChromeOptions()
options.headless = True
self.driver = webdriver.Chrome(options=options)
self.driver = webdriver.Firefox()
super().setUp()
def tearDown(self):
super().tearDown()
self.driver.quit()
self.base.tearDown()
self.v.delete()
'''
#Sólo se ejecuta correctamente en local
def test_login_correcto_github(self):
#Redirección a la votación creada
self.driver.get(f'{self.live_server_url}/booth/{self.v.pk}')
assert self.driver.find_element(By.CSS_SELECTOR, ".voting > h1").text == f"{self.v.pk} - Prueba votación"
#Inicio sesión con github
self.driver.find_element(By.LINK_TEXT, "Login con GitHub").click()
self.driver.find_element(By.CSS_SELECTOR, "p:nth-child(2)").click()
assert self.driver.find_element(By.CSS_SELECTOR, "strong:nth-child(3)").text == "AuthenticationApp"
self.driver.find_element(By.ID, "login_field").click()
self.driver.find_element(By.ID, "login_field").send_keys("decideautenticacion")
self.driver.find_element(By.ID, "password").click()
self.driver.find_element(By.ID, "password").send_keys("pruebadecide11")
self.driver.find_element(By.NAME, "commit").click()
#Esperamos 4 segundos debido a las diferentes redirecciones hasta llegar de nuevo a la página de votación
time.sleep(3)
assert self.driver.find_element(By.CSS_SELECTOR, ".btn").text == "Vote"
'''
#Usuario introduce una contraseña incorrecta de su cuenta de Github
def test_login_incorrect_password(self):
#Redirección a la votación creada
self.driver.get(f'{self.live_server_url}/booth/{self.v.pk}')
assert self.driver.find_element(
By.CSS_SELECTOR,
".voting > h1").text == f"{self.v.pk} - Prueba votación"
#Inicio sesión con github
self.driver.find_element(By.LINK_TEXT, "Login con GitHub").click()
self.driver.find_element(By.CSS_SELECTOR, "p:nth-child(2)").click()
assert self.driver.find_element(
By.CSS_SELECTOR, "strong:nth-child(3)").text == "AuthenticationApp"
self.driver.find_element(By.ID, "login_field").click()
self.driver.find_element(
By.ID, "login_field").send_keys("decideautenticacion")
self.driver.find_element(By.ID, "password").click()
self.driver.find_element(By.ID, "password").send_keys("1234")
self.driver.find_element(By.NAME, "commit").click()
#Mensaje error
assert self.driver.find_element(
By.CSS_SELECTOR,
".flash > .container-lg").text == "Incorrect username or password."
#Usuario introduce un username incorrecto de su cuenta de Github
def test_login_incorrect_username(self):
#Redirección a la votación creada
self.driver.get(f'{self.live_server_url}/booth/{self.v.pk}')
assert self.driver.find_element(
By.CSS_SELECTOR,
".voting > h1").text == f"{self.v.pk} - Prueba votación"
#Inicio sesión con github
self.driver.find_element(By.LINK_TEXT, "Login con GitHub").click()
self.driver.find_element(By.CSS_SELECTOR, "p:nth-child(2)").click()
assert self.driver.find_element(
By.CSS_SELECTOR, "strong:nth-child(3)").text == "AuthenticationApp"
self.driver.find_element(By.ID, "login_field").click()
self.driver.find_element(
By.ID, "login_field").send_keys("decideautenticacionn")
self.driver.find_element(By.ID, "password").click()
self.driver.find_element(By.ID, "password").send_keys("pruebadecide11")
self.driver.find_element(By.NAME, "commit").click()
#Mensaje error
assert self.driver.find_element(
By.CSS_SELECTOR,
".flash > .container-lg").text == "Incorrect username or password."
class TestGoogle(StaticLiveServerTestCase):
def create_voting(self):
self.q = Question(desc='Prueba votación')
self.q.save()
for i in range(2):
opt = QuestionOption(question=self.q,
option='Opción {}'.format(i + 1))
opt.save()
self.v = Voting(name='Prueba votación', question=self.q, slug="prueba")
self.v.save()
self.a, _ = Auth.objects.get_or_create(url=settings.BASEURL,
defaults={
'me': True,
'name': 'test auth'
})
self.a.save()
self.v.auths.add(self.a)
self.v.create_pubkey()
self.v.start_date = timezone.now()
self.v.save()
def setUp(self):
self.base = BaseTestCase()
self.base.setUp()
self.vars = {}
self.create_voting()
options = webdriver.ChromeOptions()
options.headless = True
self.driver = webdriver.Chrome(options=options)
self.wait = WebDriverWait(self.driver, 10)
self.driver.maximize_window()
self.driver.implicitly_wait(10)
self.driver = webdriver.Firefox()
super().setUp()
def tearDown(self):
super().tearDown()
self.driver.quit()
self.base.tearDown()
self.v.delete()
def test_google(self):
self.driver.get(f'{self.live_server_url}/booth/{self.v.pk}')
assert self.driver.find_element(
By.CSS_SELECTOR,
".voting > h1").text == f"{self.v.pk} - Prueba votación"
self.driver.find_element(By.LINK_TEXT, "Login con Google").click()
#introducir un email mal
self.driver.find_element(By.ID, "identifierId").send_keys("test")
self.driver.find_element(By.ID, "identifierId").send_keys(Keys.ENTER)
self.driver.find_element(By.ID,
"identifierId").send_keys(Keys.BACKSPACE)
self.driver.find_element(By.ID,
"identifierId").send_keys(Keys.BACKSPACE)
self.driver.find_element(By.ID,
"identifierId").send_keys(Keys.BACKSPACE)
self.driver.find_element(By.ID,
"identifierId").send_keys(Keys.BACKSPACE)
# introducir un email que si existe
self.driver.find_element(
By.ID, "identifierId").send_keys("*****@*****.**")
self.driver.find_element(By.ID, "identifierId").send_keys(Keys.ENTER)
class CensusTestCase(BaseTestCase):
def setUp(self):
super().setUp()
self.question = Question(desc='desc')
self.question.save()
v1 = Voting(id=1,
name='voting_testing1',
min_age=5,
max_age=120,
question=self.question,
escanios=30)
v1.save()
v2 = Voting(id=3,
name='voting_testing2',
question=self.question,
escanios=10)
v2.save()
user1 = User(id=5, username='******', password='******')
user1.save()
user2 = User(id=6, username='******', password='******')
user2.save()
self.census = Census(id=21,
voting_id=1,
voter_id=5,
adscripcion='Colegio1',
date=date.today())
self.census.save()
c2 = Census(id=22,
voting_id=3,
voter_id=5,
adscripcion='Colegio1',
date=date.today())
c2.save()
c3 = Census(id=23,
voting_id=1,
voter_id=6,
adscripcion='Colegio2',
date=date.today())
c3.save()
def tearDown(self):
super().tearDown()
self.census = None
def test_check_vote_permissions(self):
response = self.client.get('/census/{}/?voter_id={}'.format(1, 2),
format='json')
self.assertEqual(response.status_code, 401)
self.assertEqual(response.json(), 'Invalid voter')
response = self.client.get('/census/{}/?voter_id={}'.format(1, 5),
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), 'Valid voter')
def test_list_voting(self):
response = self.client.get('/census/?voting_id={}'.format(1),
format='json')
self.assertEqual(response.status_code, 401)
self.login(user='******')
response = self.client.get('/census/?voting_id={}'.format(1),
format='json')
self.assertEqual(response.status_code, 403)
self.login()
response = self.client.get('/census/?voting_id={}'.format(1),
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), {'voters': [5, 6]})
def test_add_new_voters_conflict(self):
data = {'voting_id': 1, 'voters': [5]}
response = self.client.post('/census/', data, format='json')
self.assertEqual(response.status_code, 401)
self.login(user='******')
response = self.client.post('/census/', data, format='json')
self.assertEqual(response.status_code, 403)
self.login()
response = self.client.post('/census/', data, format='json')
self.assertEqual(response.status_code, 409)
def test_add_new_voters(self):
data = {
'voting_id': 2,
'voters': [1, 2, 3, 4],
'adscripcion': 'Colegio 1'
}
response = self.client.post('/census/', data, format='json')
self.assertEqual(response.status_code, 401)
self.login(user='******')
response = self.client.post('/census/', data, format='json')
self.assertEqual(response.status_code, 403)
self.login(user='******')
response = self.client.post('/census/', data, format='json')
self.assertEqual(response.status_code, 201)
self.assertEqual(len(data.get('voters')), 4)
def test_destroy_voter(self):
data = {'voters': [1]}
response = self.client.delete('/census/{}/'.format(1),
data,
format='json')
self.assertEqual(response.status_code, 204)
self.assertEqual(0, len(Census.objects.filter(voter_id=1)))
def test_model(self):
c = Census.objects.get(adscripcion='Colegio2')
c.date = date.today
self.assertEqual(c.voting_id, 1)
self.assertEqual(c.voter_id, 6)
self.assertEqual(c.adscripcion, 'Colegio2')
self.assertEqual(c.date, date.today)
def test_model_functions(self):
c = self.census
self.assertEqual(c.voting_name, 'voting_testing1')
self.assertEqual(c.voting_question, 'desc')
self.assertEqual(c.voter_username, 'voter1')
def test_all_census(self):
u = User(username='******', password='******')
u.save()
census = Census.objects.all()
rf = RequestFactory()
request = rf.get('/census/all_census/')
request.user = u
response = views.all_census(request)
for c in census:
self.assertContains(response, c)
def test_group_by_adscripcion(self):
u = User(username='******', password='******')
u.save()
c1 = Census.objects.get(id=21)
c2 = Census.objects.get(id=22)
rf = RequestFactory()
request = rf.get('/census/group_by_adscripcion/')
request.user = u
response = views.group_by_adscripcion(request, 'Colegio1')
self.assertEqual(response.status_code, 200)
self.assertContains(response, c1)
self.assertContains(response, c2)
def test_group_by_voting(self):
u = User(username='******', password='******')
u.save()
c1 = Census.objects.get(id=21)
c2 = Census.objects.get(id=23)
rf = RequestFactory()
request = rf.get('/census/group_by_voting/')
request.user = u
response = views.group_by_voting(request, 1)
self.assertEqual(response.status_code, 200)
self.assertContains(response, c1)
self.assertContains(response, c2)
def test_group_by_voter(self):
u = User(username='******', password='******')
u.save()
c1 = Census.objects.get(id=21)
c2 = Census.objects.get(id=22)
rf = RequestFactory()
request = rf.get('/census/group_by_voter/')
request.user = u
response = views.group_by_voter(request, 5)
self.assertEqual(response.status_code, 200)
self.assertContains(response, c1)
self.assertContains(response, c2)
def test_group_by_date(self):
u = User(username='******', password='******')
u.save()
c1 = Census.objects.get(id=21)
c2 = Census.objects.get(id=22)
c3 = Census.objects.get(id=23)
rf = RequestFactory()
request = rf.get('/census/group_by_date/')
request.user = u
response = views.group_by_date(request, str(date.today()))
self.assertEqual(response.status_code, 200)
self.assertContains(response, c1)
self.assertContains(response, c2)
self.assertContains(response, c3)
def test_group_by_question(self):
u = User(username='******', password='******')
u.save()
c1 = Census.objects.get(id=21)
c2 = Census.objects.get(id=22)
c3 = Census.objects.get(id=23)
rf = RequestFactory()
request = rf.get('/census/group_by_question/')
request.user = u
response = views.group_by_question(request, 'desc')
self.assertEqual(response.status_code, 200)
self.assertContains(response, c1)
self.assertContains(response, c2)
self.assertContains(response, c3)
def test_export_census_user(self):
rf = RequestFactory()
request = rf.get('/census/export_by_voting/{}'.format(1))
response = views.export_by_voting(request, '1')
self.assertEqual(response.status_code, 200)
content = response.content.decode('utf-8')
csv_reader = csv.reader(io.StringIO(content))
num_row = sum(1 for row in csv_reader)
#headers + 2 censos con voting_id == 1
self.assertEqual(num_row, 3)
csv_reader = csv.reader(io.StringIO(content))
headers = next(csv_reader)
self.assertIn('voter_id', headers)
self.assertIn('adscripcion', headers)
self.assertIn('date', headers)
def test_export_census_user_void(self):
rf = RequestFactory()
request = rf.get('/census/export_by_voting/{}'.format(2))
response = views.export_by_voting(request, '2')
self.assertEqual(response.status_code, 200)
content = response.content.decode('utf-8')
csv_reader = csv.reader(io.StringIO(content))
num_row = sum(1 for row in csv_reader)
#solo hay headers ya que no existe el voting con id 2
self.assertEqual(num_row, 1)
csv_reader = csv.reader(io.StringIO(content))
headers = next(csv_reader)
self.assertIn('voter_id', headers)
self.assertIn('adscripcion', headers)
self.assertIn('date', headers)
def test_export_census_admin(self):
census = Census.objects.all()
rf = RequestFactory()
request = rf.post('', {'action': 'export_as_csv'})
response = admin.CensusAdmin.export_as_csv(self, request, census)
self.assertEqual(response.status_code, 200)
content = response.content.decode('utf-8')
csv_reader = csv.reader(io.StringIO(content))
num_row = sum(1 for row in csv_reader)
#headers + 3 censos
self.assertEqual(num_row, 4)
csv_reader = csv.reader(io.StringIO(content))
headers = next(csv_reader)
self.assertIn('voter_id', headers)
self.assertIn('adscripcion', headers)
self.assertIn('date', headers)
def test_import_census_user_correct(self):
csv = open("census/testing_files/csv_user.csv", 'rb')
data = SimpleUploadedFile(content=csv.read(),
name=csv.name,
content_type='multipart/form-data')
u = User(username='******', password='******')
u.save()
rf = RequestFactory()
content_type = 'multipart/form-data'
headers = {
'HTTP_CONTENT_TYPE': content_type,
'HTTP_CONTENT_DISPOSITION': 'attachment; filename=csv_user.csv'
}
request = rf.post('upload.html', {'file': data}, **headers)
request.user = u
response = views.import_by_voting(request)
self.assertEqual(response.status_code, 200)
for row1, row2 in zip(request.FILES['file'], data):
cadena1 = row1.decode('utf-8')
cadena2 = row2.decode('utf-8')
self.assertEqual(cadena1, cadena2)
csv.close()
def test_import_census_admin_correct(self):
csv = open("census/testing_files/csv_admin.csv", 'rb')
data = SimpleUploadedFile(content=csv.read(),
name=csv.name,
content_type='multipart/form-data')
u = User(username='******', password='******')
u.save()
rf = RequestFactory()
content_type = 'multipart/form-data'
headers = {
'HTTP_CONTENT_TYPE': content_type,
'HTTP_CONTENT_DISPOSITION': 'attachment; filename=csv_admin.csv'
}
request = rf.post('upload.html', {'file': data}, **headers)
request.user = u
response = admin.CensusAdmin.import_from_csv(self, request)
self.assertEqual(response.status_code, 200)
for row1, row2 in zip(request.FILES['file'], data):
cadena1 = row1.decode('utf-8')
cadena2 = row2.decode('utf-8')
self.assertEqual(cadena1, cadena2)
csv.close()
def test_census_estatistics(self):
census_per_voters = views.census_per_voters()
self.assertEquals(census_per_voters['voter1'], 2)
self.assertEquals(census_per_voters['voter2'], 1)
escanios = views.escanios()
self.assertEquals(escanios['voting_testing1'], 30)
self.assertEquals(escanios['voting_testing2'], 10)
voters = views.voters()
self.assertEquals(voters['voting_testing1'], 2)
self.assertEquals(voters['voting_testing2'], 1)
def test_create_user_data_wrong_max_age(self):
user1 = User(id=100, username='******', password='******')
user1.save()
user1_data = UserData(age=12312323, user=user1)
with self.assertRaises(ValidationError):
user1_data.full_clean()
def test_create_user_data_wrong_min_age(self):
user1 = User(id=100, username='******', password='******')
user1.save()
user1_data = UserData(age=0, user=user1)
with self.assertRaises(ValidationError):
user1_data.full_clean()
def test_create_user_data(self):
user1 = User(id=100, username='******', password='******')
user1.save()
user1_data = UserData(age=20, user=user1)
user1_data.save()
usuario = UserData.objects.get(user=user1)
self.assertEquals(usuario.age, 20)
def test_user_data_tostring(self):
user1 = User(id=100, username='******', password='******')
user1.save()
user1_data = UserData(age=20, user=user1)
user1_data.save()
usuario = UserData.objects.get(user=user1)
self.assertEquals(usuario.__str__(), "Datos del usuario : user")
def test_census_add_user_form_invalid_max_age(self):
user1 = User(id=100, username='******', password='******')
user1.save()
user1_data = UserData(age=122, user=user1)
user1_data.save()
rf = RequestFactory()
request = rf.post('/panel/{}'.format(1), data={'user_to_add': 100})
request.user = user1
response = views.voting_census(request, '1')
self.assertEqual(response.status_code, 200)
self.assertContains(response,
"El usuario no cumple con la edad máxima",
html=True)
def test_census_add_user_form_invalid_min_age(self):
user1 = User(id=100, username='******', password='******')
user1.save()
user1_data = UserData(age=2, user=user1)
user1_data.save()
rf = RequestFactory()
request = rf.post('/panel/{}'.format(1), data={'user_to_add': 100})
request.user = user1
response = views.voting_census(request, '1')
self.assertEqual(response.status_code, 200)
self.assertContains(response,
"El usuario no cumple con la edad mínima",
html=True)
def test_census_add_user_form_invalid_no_age(self):
user1 = User(id=100, username='******', password='******')
user1.save()
rf = RequestFactory()
request = rf.post('/panel/{}'.format(1), data={'user_to_add': 100})
request.user = user1
response = views.voting_census(request, '1')
self.assertEqual(response.status_code, 200)
self.assertContains(response,
"El usuario a agregar no tiene edad registrada",
html=True)
def test_census_add_user_form(self):
user1 = User(id=100, username='******', password='******')
user1.save()
user1_data = UserData(age=20, user=user1)
user1_data.save()
rf = RequestFactory()
request = rf.post('/panel/{}'.format(1), data={'user_to_add': 100})
request.user = user1
response = views.voting_census(request, '1')
self.assertEqual(response.status_code, 302)
def createQuestion():
# Create the Question
q = Question(desc='pregunta 1')
q.save()
return q
def gen_voting(self, pk):
voting = Voting(pk=pk, name='v1', postproc_type=PostProcType.IDENTITY,
start_date=timezone.now(), end_date=timezone.now() + datetime.timedelta(days=1))
voting.save()
q = Question(desc='qwerty', voting=voting)
q.save()
class Login2FA(StaticLiveServerTestCase):
def create_voting(self):
self.q = Question(desc='Prueba votación')
self.q.save()
for i in range(2):
opt = QuestionOption(question=self.q, option='Opción {}'.format(i+1))
opt.save()
self.v= Voting(name='Prueba votación', question=self.q, slug="prueba")
self.v.save()
self.a, _ = Auth.objects.get_or_create(url=settings.BASEURL,defaults={'me': True, 'name': 'test auth'})
self.a.save()
self.v.auths.add(self.a)
self.v.create_pubkey()
self.v.start_date = timezone.now()
self.v.save()
def createUsers(self):
self.user_with_2fa = User(username='******')
self.user_with_2fa.set_password('qwerty')
self.user_with_2fa.save()
self.user_no_2fa = User(username="******")
self.user_no_2fa.set_password('qwerty')
self.user_no_2fa.save()
self.extra = Extra(phone='020304050')
self.extra.totp_code = 'S3K3TPI5MYA2M67V'
self.extra.user = self.user_with_2fa
self.extra.save()
def setUp(self):
self.base = BaseTestCase()
self.base.setUp()
self.vars = {}
self.create_voting()
self.createUsers()
options = webdriver.ChromeOptions()
options.headless = True
self.driver = webdriver.Chrome(options=options)
super().setUp()
def tearDown(self):
super().tearDown()
self.driver.quit()
self.base.tearDown()
self.v.delete()
#Un usuario con 2fa no puede logearse si no lo introduce
def test_login2faWithoutIt(self):
self.driver.get(f'{self.live_server_url}/booth/{self.v.pk}')
self.driver.set_window_size(1366, 728)
self.driver.find_element(By.ID, "username").click()
self.driver.find_element(By.ID, "username").send_keys("user2fa")
self.driver.find_element(By.ID, "password").click()
self.driver.find_element(By.ID, "password").send_keys("qwerty")
self.driver.find_element(By.CSS_SELECTOR, ".btn").click()
assert self.driver.find_element(By.ID, "__BVID__11__BV_label_").text == "Username"
#Un usuario sin 2fa puede logearse bien
def test_logino2fa(self):
self.driver.get(f'{self.live_server_url}/booth/{self.v.pk}')
self.driver.set_window_size(1366, 728)
# self.driver.find_element(By.ID, "__BVID__19__BV_label_").click()
self.driver.find_element(By.ID, "username").click()
self.driver.find_element(By.ID, "username").send_keys("usernofa")
self.driver.find_element(By.ID, "password").send_keys("qwerty")
self.driver.find_element(By.CSS_SELECTOR, ".btn").click()
elements = self.driver.find_elements(By.CSS_SELECTOR, ".btn")
assert len(elements) > 0
#Un usuario sin 2fa no puede logearse en el formulario para 2fa
def test_loginno2fain2fa(self):
self.driver.get(f'{self.live_server_url}/booth/{self.v.pk}')
self.driver.set_window_size(1366, 728)
self.driver.find_element(By.CSS_SELECTOR, ".custom-control:nth-child(2) > .custom-control-label").click()
self.driver.find_element(By.ID, "username").click()
self.driver.find_element(By.ID, "username").send_keys("usuarionofa")
self.driver.find_element(By.ID, "password").send_keys("qwerty")
self.driver.find_element(By.CSS_SELECTOR, ".btn").click()
assert self.driver.find_element(By.ID, "__BVID__11__BV_label_").text == "Username"
def test(self):
#Create and save question
q = Question(desc='Question1')
q.save()
#Create and save question options
for i in range(2):
opt = QuestionOption(question=q, option='option {}'.format(i+1))
opt.save()
#Create and save votation with question
v = Voting(name='Votation1')
v.save()
v.questions.add(q)
#Add auth to votation and save it
a, _ = Auth.objects.get_or_create(url=settings.BASEURL,
defaults={'me': True, 'name': 'test auth'})
a.save()
v.auths.add(a)
#Create and save multiple voters for votation
for i in range(2):
u, _ = User.objects.get_or_create(username='******'.format(i+1))
u.is_active = True
u.save()
c = Census(voter_id=u.id, voting_id=v.id)
c.save()
#...
#Votation created
#...
#Start votation
v.create_pubkey()
v.start_date = timezone.now()
v.save()
#...
#Votation started
#...
#Method copy from voting/test.py
#Create and add votes
voters = list(Census.objects.filter(voting_id=v.id))
voter = voters.pop()
clear = {}
for opt in v.questions.first().options.all():
clear[opt.number] = 0
for i in range(2):
a, b = self.encrypt_msg(opt.number, v)
data = {
'voting': v.id,
'voter': voter.voter_id,
'vote': { 'a': a, 'b': b },
}
clear[opt.number] += 1
user = self.get_or_create_user(voter.voter_id)
self.login(user=user.username)
#voter = voters.pop()
mods.post('store', json=data)
#Login with admin
self.login()
#Tally Done
v.tally_votes()
#...
#Votation ended
#...
#Method for test views's method
response = self.client.get('/visualizer/{}/'.format(v.pk))
self.assertEqual(response.status_code, 200)
#Check 1
self.assertEqual(response.context['voting_id'], v.pk)
#Check 2
self.assertEqual('Votation1' in response.context['voting'].values() , True)
#Check 3
varTemp = response.context['voting']
self.assertEqual('Question1' in varTemp['questions'][0].values() , True)
def setUp(self):
q = Question(desc="Descripcion")
q.save()
que1 = Question(desc="Descripcion1")
que1.save()
que2 = Question(desc="Descripcion2")
que2.save()
opt1 = QuestionOption(question=q, option="option1")
opt1.save()
opt2 = QuestionOption(question=q, option="option2")
opt2.save()
q_prefer = QuestionPrefer(question=q,
prefer="YES",
number=4,
option="option1")
q_prefer.save()
q_ordering = QuestionOrdering(question=q,
number=5,
option="prueba de ordenacion",
ordering=1)
q_ordering.save()
party1 = Party(abreviatura="PC")
party1.save()
self.candidate1 = Candidate(name="test",
age=21,
number=1,
auto_community="AN",
sex="H",
political_party=party1)
self.candidate1.save()
self.v1 = ReadonlyVoting(name="VotacionRO",
question=que1,
desc="example")
self.v2 = MultipleVoting(name="VotacionM", desc="example")
self.v2.save()
self.v2.question.add(que1)
self.v2.question.add(que2)
self.v = Voting(name="Votacion", question=q)
self.v.save()
self.v1.save()
self.v2.save()
super().setUp()
def setUp(self):
q = Question(desc='multiple test question')
q2 = Question(desc='multiple test question 2')
q3 = Question(desc='multiple test question 3')
q.save()
q2.save()
q3.save()
for i in range(3):
opt = QuestionOption(question=q, option='option {}'.format(i + 1))
opt.save()
for i in range(4):
opt = QuestionOption(question=q2, option='option {}'.format(i + 1))
opt.save()
for i in range(5):
opt = QuestionOption(question=q3, option='option {}'.format(i + 1))
opt.save()
self.v = MultipleVoting(name="Votacion", desc="example")
self.v.save()
self.v.question.add(q)
self.v.question.add(q2)
self.v.save()
self.v = MultipleVoting(name="Votacion2", desc="example2")
self.v.save()
self.v.question.add(q)
self.v.save()
super().setUp()
def test_edit_yes_no_question_add_opt(self):
q = Question(desc='si_no question', si_no=True)
q.save()
self.assertTrue(q.si_no == True)
opt = QuestionOption(question=q, option='option 3', number='3')
self.assertRaises(ValidationError, opt.clean)
class StoreTextCase(BaseTestCase):
def setUp(self):
super().setUp()
self.question = Question(desc='qwerty')
self.question.save()
self.voting = Voting(
pk=5001,
name='voting example',
question=self.question,
start_date=timezone.now(),
)
self.voting.save()
def tearDown(self):
super().tearDown()
def gen_voting(self, pk):
voting = Voting(pk=pk,
name='v1',
question=self.question,
start_date=timezone.now(),
end_date=timezone.now() + datetime.timedelta(days=1))
voting.save()
def get_or_create_user(self, pk):
user, _ = User.objects.get_or_create(pk=pk)
user.username = '******'.format(pk)
user.set_password('qwerty')
user.save()
return user
def gen_votes(self):
votings = [random.randint(1, 5000) for i in range(10)]
users = [random.randint(3, 5002) for i in range(50)]
for v in votings:
a = random.randint(2, 500)
b = random.randint(2, 500)
self.gen_voting(v)
random_user = random.choice(users)
user = self.get_or_create_user(random_user)
self.login(user=user.username)
census = Census(voting_id=v, voter_id=random_user)
census.save()
data = {
"voting": v,
"voter": random_user,
"vote": {
"a": a,
"b": b
}
}
response = self.client.post('/store/', data, format='json')
self.assertEqual(response.status_code, 200)
self.logout()
return votings, users
def test_gen_vote_invalid(self):
data = {"voting": 1, "voter": 1, "vote": {"a": 1, "b": 1}}
response = self.client.post('/store/', data, format='json')
self.assertEqual(response.status_code, 401)
def test_store_vote(self):
VOTING_PK = 345
CTE_A = 96
CTE_B = 184
census = Census(voting_id=VOTING_PK, voter_id=1)
census.save()
self.gen_voting(VOTING_PK)
data = {
"voting": VOTING_PK,
"voter": 1,
"vote": {
"a": CTE_A,
"b": CTE_B
}
}
user = self.get_or_create_user(1)
self.login(user=user.username)
response = self.client.post('/store/', data, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(Vote.objects.count(), 1)
self.assertEqual(Vote.objects.first().voting_id, VOTING_PK)
self.assertEqual(Vote.objects.first().voter_id, 1)
self.assertEqual(Vote.objects.first().a, CTE_A)
self.assertEqual(Vote.objects.first().b, CTE_B)
def test_vote(self):
self.gen_votes()
response = self.client.get('/store/', format='json')
self.assertEqual(response.status_code, 401)
self.login(user='******')
response = self.client.get('/store/', format='json')
self.assertEqual(response.status_code, 403)
self.login()
response = self.client.get('/store/', format='json')
self.assertEqual(response.status_code, 200)
votes = response.json()
self.assertEqual(len(votes), Vote.objects.count())
self.assertEqual(votes[0],
VoteSerializer(Vote.objects.all().first()).data)
def test_filter(self):
votings, voters = self.gen_votes()
v = votings[0]
response = self.client.get('/store/?voting_id={}'.format(v),
format='json')
self.assertEqual(response.status_code, 401)
self.login(user='******')
response = self.client.get('/store/?voting_id={}'.format(v),
format='json')
self.assertEqual(response.status_code, 403)
self.login()
response = self.client.get('/store/?voting_id={}'.format(v),
format='json')
self.assertEqual(response.status_code, 200)
votes = response.json()
self.assertEqual(len(votes), Vote.objects.filter(voting_id=v).count())
v = voters[0]
response = self.client.get('/store/?voter_id={}'.format(v),
format='json')
self.assertEqual(response.status_code, 200)
votes = response.json()
self.assertEqual(len(votes), Vote.objects.filter(voter_id=v).count())
def test_hasvote(self):
votings, voters = self.gen_votes()
vo = Vote.objects.first()
v = vo.voting_id
u = vo.voter_id
response = self.client.get('/store/?voting_id={}&voter_id={}'.format(
v, u),
format='json')
self.assertEqual(response.status_code, 401)
self.login(user='******')
response = self.client.get('/store/?voting_id={}&voter_id={}'.format(
v, u),
format='json')
self.assertEqual(response.status_code, 403)
self.login()
response = self.client.get('/store/?voting_id={}&voter_id={}'.format(
v, u),
format='json')
self.assertEqual(response.status_code, 200)
votes = response.json()
self.assertEqual(len(votes), 1)
self.assertEqual(votes[0]["voting_id"], v)
self.assertEqual(votes[0]["voter_id"], u)
def test_voting_status(self):
data = {"voting": 5001, "voter": 1, "vote": {"a": 30, "b": 55}}
census = Census(voting_id=5001, voter_id=1)
census.save()
# not opened
self.voting.start_date = timezone.now() + datetime.timedelta(days=1)
self.voting.save()
user = self.get_or_create_user(1)
self.login(user=user.username)
response = self.client.post('/store/', data, format='json')
self.assertEqual(response.status_code, 401)
# not closed
self.voting.start_date = timezone.now() - datetime.timedelta(days=1)
self.voting.save()
self.voting.end_date = timezone.now() + datetime.timedelta(days=1)
self.voting.save()
response = self.client.post('/store/', data, format='json')
self.assertEqual(response.status_code, 200)
# closed
self.voting.end_date = timezone.now() - datetime.timedelta(days=1)
self.voting.save()
response = self.client.post('/store/', data, format='json')
self.assertEqual(response.status_code, 401)
def test_create_multiquestion_all_types_voting(self):
q1 = Question(desc='question1')
q1.save()
for i in range(5):
opt = QuestionOption(question=q1, option='option {}'.format(i + 1))
opt.save()
q2 = Question(desc='preferences', preferences=True)
q2.save()
for i in range(5):
opt = QuestionOption(question=q2, option='option {}'.format(i + 1))
opt.save()
q3 = Question(desc='question si/no', si_no=True)
q3.save()
v = Voting(name='test voting')
v.save()
a, _ = Auth.objects.get_or_create(url=settings.BASEURL,
defaults={
'me': True,
'name': 'test auth'
})
a.save()
v.auths.add(a)
v.question.add(q1)
v.question.add(q2)
v.question.add(q3)
a = v.question.all().count() == 3
b = v.question.all()[1].preferences == True
c = v.question.all()[2].si_no == True
self.assertTrue(a and b and c)
class Facebook(StaticLiveServerTestCase):
def create_voting(self):
self.q = Question(desc='Prueba votación')
self.q.save()
for i in range(2):
opt = QuestionOption(question=self.q,
option='Opción {}'.format(i + 1))
opt.save()
self.v = Voting(name='Prueba votación', question=self.q, slug="prueba")
self.v.save()
self.a, _ = Auth.objects.get_or_create(url=settings.BASEURL,
defaults={
'me': True,
'name': 'test auth'
})
self.a.save()
self.v.auths.add(self.a)
self.v.create_pubkey()
self.v.start_date = timezone.now()
self.v.save()
def setUp(self):
self.base = BaseTestCase()
self.base.setUp()
self.vars = {}
self.create_voting()
options = webdriver.ChromeOptions()
options.headless = True
self.driver = webdriver.Chrome(options=options)
self.wait = WebDriverWait(self.driver, 10)
self.driver.maximize_window()
self.driver.implicitly_wait(10)
self.driver = webdriver.Firefox()
super().setUp()
def tearDown(self):
super().tearDown()
self.driver.quit()
self.base.tearDown()
self.v.delete()
def test_emailincorrecto(self):
self.driver.get(f'{self.live_server_url}/booth/{self.v.pk}')
assert self.driver.find_element(
By.CSS_SELECTOR,
".voting > h1").text == f"{self.v.pk} - Prueba votación"
self.driver.find_element(By.LINK_TEXT, "Login con Facebook").click()
self.driver.find_element(By.ID, "email").send_keys("*****@*****.**")
self.driver.find_element(By.ID, "email").send_keys(Keys.ENTER)
assert self.driver.find_element(By.ID, "email").text == ""
assert self.driver.find_element(By.ID, "pass").text == ""
def test_contraseaincorrecta(self):
self.driver.get(f'{self.live_server_url}/booth/{self.v.pk}')
assert self.driver.find_element(
By.CSS_SELECTOR,
".voting > h1").text == f"{self.v.pk} - Prueba votación"
self.driver.set_window_size(824, 824)
self.driver.find_element(By.LINK_TEXT, "Login con Facebook").click()
self.driver.find_element(By.ID,
"email").send_keys("*****@*****.**")
self.driver.find_element(By.ID, "pass").send_keys("fdasffa")
self.driver.find_element(By.ID, "pass").send_keys(Keys.ENTER)
assert self.driver.find_element(By.ID, "pass").text == ""
