class TestGetBenefits(unittest.TestCase):
def setUp(self):
call("./setup/start_testing.sh")
self.profile_one = PersonProfile(1)
self.profile_two = PersonProfile(2)
self.profile_three = PersonProfile(10)
def tearDown(self):
call("./setup/finish_testing.sh")
def test_get_person_benefits_one(self):
actual_result = self.profile_one.get_benefits()
expected_result = [{
"idBenefit": 3,
"name": "Plano Dental Sorriso"
}, {
"idBenefit": 1,
"name": "Plano de Saúde Norte Europa"
}]
self.assertEqual(actual_result, expected_result)
def test_get_person_benefits_two(self):
actual_result = self.profile_two.get_benefits()
expected_result = []
self.assertEqual(actual_result, expected_result)
def test_get_person_benefits_three(self):
actual_result = self.profile_three.get_benefits()
expected_result = []
self.assertEqual(actual_result, expected_result)
def test_get_person_benefits_doesnt_exist(self):
with self.assertRaises(Exception):
PersonProfile(1111111111).get_benefits()
def test_get_person_benefits_string_input(self):
with self.assertRaises(TypeError):
PersonProfile("274q38").get_benefits()
def test_get_person_benefits_float_input(self):
with self.assertRaises(TypeError):
PersonProfile(1.0).get_benefits()
def test_get_person_benefits_datatype_input(self):
with self.assertRaises(TypeError):
PersonProfile(float).get_benefits()
def test_get_person_benefits_none_input(self):
with self.assertRaises(TypeError):
PersonProfile(None).get_benefits()
def test_get_person_benefits_empy_input(self):
with self.assertRaises(TypeError):
PersonProfile().get_benefits()
def test_get_person_benefits_boolean_input(self):
with self.assertRaises(TypeError):
PersonProfile(True).get_benefits()
class TestGetAdmin(unittest.TestCase):
def setUp(self):
call("./setup/start_testing.sh")
self.profile_one = PersonProfile(1)
self.profile_two = PersonProfile(2)
self.profile_three = PersonProfile(10)
def tearDown(self):
call("./setup/finish_testing.sh")
def test_get_person_admin_one(self):
actual_result = self.profile_one.get_admin()
expected_result = {"level": 1, "name": "Admin"}
self.assertEqual(actual_result, expected_result)
def test_get_person_admin_two(self):
actual_result = self.profile_two.get_admin()
expected_result = {"level": 1, "name": "Admin"}
self.assertEqual(actual_result, expected_result)
def test_get_person_admin_three(self):
actual_result = self.profile_three.get_admin()
expected_result = {"level": 0, "name": "Colaborador"}
self.assertEqual(actual_result, expected_result)
def test_get_person_name_doesnt_exist(self):
with self.assertRaises(Exception):
PersonProfile(1111111111).get_admin()
def test_get_person_name_string_input(self):
with self.assertRaises(TypeError):
PersonProfile("274q38").get_admin()
def test_get_person_name_float_input(self):
with self.assertRaises(TypeError):
PersonProfile(1.0).get_admin()
def test_get_person_name_datatype_input(self):
with self.assertRaises(TypeError):
PersonProfile(float).get_admin()
def test_get_person_name_none_input(self):
with self.assertRaises(TypeError):
PersonProfile(None).get_admin()
def test_get_person_name_empy_input(self):
with self.assertRaises(TypeError):
PersonProfile().get_admin()
def test_get_person_name_boolean_input(self):
with self.assertRaises(TypeError):
PersonProfile(True).get_admin()
def people_edit_benefits(idWho):
""" It receives the person's id and checks if the user can edit that person's
benefits. Then it proceeds in checking the list of benefits added and or excluded
from the person's profile. If new data might be necessary (needs_data_check), it
returns the people_register_data with a list of all combined data (new and current)
for data input. Benefit_updated_data_types is only True when the benefit updates its
list of data types and those data types don't match the person's data in the database,
requiring new data inputs """
idWho = validate_person_idwho(idWho, session['idCompany'])
if idWho:
if request.method == "POST":
ids_benefits = str_list_to_int(request.form.getlist("idBenefit"))
needs_data_check = update_person_benefits(idWho, ids_benefits)
benefit_updated_data_types = request.form.get("force_update")
if needs_data_check or benefit_updated_data_types:
combined_data = get_combined_data_for_person(ids_benefits, idWho)
return render_template("people_register_data.html",
combined_data = combined_data,
header = get_header(session),
person_id = idWho)
return redirect("/pessoas/perfil/{}".format(idWho))
else: # 'GET'
return render_template("people_edit_benefits.html",
header = get_header(session),
profile = PersonProfile(idWho).get_profile(),
benefits_list = CompanyProfile(session['idCompany']).get_benefits())
else:
whoops = "Este perfil não existe, por favor selecione uma pessoa da lista."
people_list = CompanyProfile(session["idCompany"]).get_people()
return render_template("people_list.html", header = get_header(session),
people_list = people_list, whoops = whoops)
def benefits_registration_card(idBenefit, idPerson):
""" Receives idBenefit and idPerson and checks if the user can see that benefit's
registration card (benefit must be registered with the user's company as well as the person must
be a company employee). If the information checks out, the employee's (person) benefit
registration card is returned with all correlated data """
if validate_registration_card(idBenefit, idPerson, session['idCompany']):
idBenefit = int(idBenefit)
idPerson = int(idPerson)
benefit_profile = BenefitProfile(idBenefit).get_profile()
person_profile = PersonProfile(idPerson).get_profile()
person_data = get_combined_data_for_person([idBenefit,], idPerson)
admission_date = get_person_admission_date(idPerson, idBenefit)
return render_template("benefits_registration_card.html", header = get_header(session),
benefit = benefit_profile,
person = person_profile,
person_data = person_data,
admission_date = admission_date)
else:
whoops = "Este Cartão de Registro não existe."
return render_template("index.html", header = get_header(session),
whoops = whoops)
return render_template("benefits_registration_card.html", header = get_header(session),
benefit = benefit_profile,
person = person_profile,
admission_date = admission_date)
def people_delete_profile():
""" Receives (through form) the id of the person to be deleted. First the
person id is checked and then deleted. The person's row in the person table,
and all other data connected to that person is also deleted. """
idPerson = str_to_int(request.form.get("idPerson"))
person_admin = PersonProfile(idPerson).get_admin()
if person_admin['name'] != "Admin":
delete_person_profile(idPerson)
return redirect("/pessoas/lista")
else:
whoops = """Este perfil não pode ser deletado, por favor selecione outra pessoa
da lista."""
people_list = CompanyProfile(session["idCompany"]).get_people()
return render_template("people_list.html", header = get_header(session),
people_list = people_list, whoops = whoops)
def people_profile(idWho):
""" Receives the person's id (idWho) and checks if the user is allowed to see
that person's profile. This is an upgrade from the last version in which anyone could
see any person, even if the person wasn't part of the company. If that is the case an
alert is shown to the user. Otherwise the person's profile is returned."""
idWho = validate_person_idwho(idWho, session['idCompany'])
if idWho:
profile = PersonProfile(idWho).get_profile()
return render_template("people_profile.html", header = get_header(session),
profile = profile)
else:
whoops = "Este perfil não existe, por favor selecione uma pessoa da lista."
people_list = CompanyProfile(session["idCompany"]).get_people()
return render_template("people_list.html", header = get_header(session),
people_list = people_list, whoops = whoops)
def people_edit_data(idWho):
""" It receives the person's id and checks if the user can edit that person's
data. Then it proceeds in getting a list of all data for that person
and returns the people_register_data page """
idWho = validate_person_idwho(idWho, session['idCompany'])
if idWho:
person_data = PersonProfile(idWho).get_data()
return render_template("people_register_data.html",
combined_data = person_data,
header = get_header(session),
person_id = idWho)
else:
whoops = "Este perfil não existe, por favor selecione uma pessoa da lista."
people_list = CompanyProfile(session["idCompany"]).get_people()
return render_template("people_list.html", header = get_header(session),
people_list = people_list, whoops = whoops)
def get_combined_data_for_person(chosen_benefits, new_person_id):
""" This is a tricky one. Receives a list of benefit ids and a person's
id and returns a list of dictionaries with the combined information
(data types) between benefits and person. Reserved data types such as
name, cpf and data admissão are treated differently according """
all_benefits_data = []
for benefit_id in chosen_benefits:
benefit_data = BenefitProfile(benefit_id).get_data_types()
for data_type in benefit_data:
if data_type not in all_benefits_data:
all_benefits_data.append(data_type)
person_profile = PersonProfile(new_person_id).get_profile()
combined_data = []
for data_type in all_benefits_data:
if data_type['name'] == 'Nome':
combined_data.append({
'idDatatype': data_type['idDatatype'],
'name': data_type['name'],
'data': person_profile['name'],
'example': data_type['example']
})
elif data_type['name'] == 'CPF':
combined_data.append({
'idDatatype': data_type['idDatatype'],
'name': data_type['name'],
'data': person_profile['cpf'],
'example': data_type['example']
})
elif data_type['name'] == 'Data Admissão':
combined_data.append({
'idDatatype': data_type['idDatatype'],
'name': data_type['name'],
'data': data_type['example'],
'example': data_type['example']
})
else:
combined_data.append({
'idDatatype':
data_type['idDatatype'],
'name':
data_type['name'],
'data':
get_person_one_data(new_person_id, data_type['idDatatype']),
'example':
data_type['example']
})
return (combined_data)
def people_data_registration():
""" This function simply registers the additional data for person submitted by calling
register_data_to_person() and returns the persons updated profile """
idPerson = str_to_int(request.form.get("idPerson"))
ids_datatype = str_list_to_int(request.form.getlist("idDatatype"))
data_values = request.form.getlist("data_value")
if len(ids_datatype) > 0 and len(data_values) > 0:
for i in range(len(data_values)):
if ids_datatype[i] not in [1, 2, 3]: # reserved data types
try:
register_data_to_person(ids_datatype[i], data_values[i], idPerson)
except:
update_data_from_person(ids_datatype[i], data_values[i], idPerson)
return redirect("/pessoas/perfil/{}".format(idPerson))
else:
whoops = "Você não terminou o cadastro. Clique no plano selecionado e termine o cadastro."
profile = PersonProfile(idPerson).get_profile()
return render_template("people_profile.html", header = get_header(session),
profile = profile, whoops = whoops)
def update_person_benefits(idPerson, ids_benefit):
""" Receives a person's id and a list of ids of benefits.
This function is called when a person is enrolling in new benefits or
unenrolling in current ones. This function first checks if any changes are
necessary. Returns true if a new benefit was added so we can later get the
new data necessary for enrollment. Returns false in case there's no new
benefit enrollment, and True if there is."""
if not person_exists(idPerson):
raise Exception("Person doesn't exist")
flag = 0
current_benefits = PersonProfile(idPerson).get_benefits()
submitted_benefits = []
if len(ids_benefit) > 0:
for id_benefit in ids_benefit:
submitted_benefits.append({
"idBenefit":
id_benefit,
"name":
BenefitProfile(id_benefit).get_name()
})
# Check if person had benefits and got them all taken away
if len(submitted_benefits) == 0 and len(current_benefits) > 0:
for benefit in current_benefits:
remove_person_from_benefit(idPerson, benefit['idBenefit'])
else:
for benefit in submitted_benefits:
if benefit in current_benefits:
pass
elif benefit not in current_benefits:
register_person_to_benefit(idPerson, benefit['idBenefit'])
flag = 1
for current_benefit in current_benefits:
if current_benefit not in submitted_benefits:
remove_person_from_benefit(idPerson,
current_benefit['idBenefit'])
if flag == 1:
return True
else:
return False
def login():
""" This function receives the user's cpf and checks it's values before
allowing them to login. There's no security measure implemented whatsoever.
If the cpf matches one of the admins, it proceeds to load all information
necessary on the session (dict) for further use regarding the user and
their company."""
session.clear()
if request.method == "POST":
cpf = request.form.get("cpf")
if not cpf:
whoops = "Por favor insira seu CPF"
return render_template("login.html", header = get_header(session),
whoops = whoops)
if not isCpfValid(cpf):
whoops = "Número de CPF não válido"
return render_template("login.html", header = get_header(session),
whoops = whoops)
person_id = get_person_id_by_cpf(cpf)
if person_id is None:
whoops = "Número de CPF não encontrado"
return render_template("login.html", header = get_header(session),
whoops = whoops)
person_profile = PersonProfile(person_id).get_profile()
if person_profile['admin']['level'] == 0:
whoops = (person_profile['name'] + ", você não tem autorização para entrar no sistema")
return render_template("login.html", header = get_header(session),
whoops = whoops)
company_name = CompanyProfile(person_profile['idCompany']).get_name()
session["id"] = person_profile['id']
session["name"] = person_profile['name']
session["idCompany"] = person_profile['idCompany']
session["company"] = company_name
session["admin_name"] = person_profile['admin']['name']
return redirect("/")
else: # 'GET'
return render_template("login.html", header = get_header(session))
def setUp(self):
call("./setup/start_testing.sh")
self.profile_one = PersonProfile(1)
self.profile_two = PersonProfile(2)
self.profile_three = PersonProfile(10)
self.profile_one_data = {
"id":
1,
"name":
"Pessoa da Wonka",
"idCompany":
1,
"cpf":
"230.841.911-31",
"admin": {
"level": 1,
"name": "Admin"
},
"benefits": [{
"idBenefit": 3,
"name": "Plano Dental Sorriso"
}, {
"idBenefit": 1,
"name": "Plano de Saúde Norte Europa"
}],
"data": [{
"idDatatype": 5,
"name": "Peso (kg)",
"data": "78"
}, {
"idDatatype": 6,
"name": "Altura (cm)",
"data": "180"
}, {
"idDatatype": 8,
"name": "Email",
"data": "*****@*****.**"
}]
}
self.profile_two_data = {
"id": 2,
"name": "Pessoa da Tio Patinhas",
"idCompany": 2,
"cpf": "985.105.727-47",
"admin": {
"level": 1,
"name": "Admin"
},
"benefits": [],
"data": []
}
self.profile_three_data = {
"id": 10,
"name": "Augusto Wozniak",
"idCompany": 3,
"cpf": "007.123.232-12",
"admin": {
"level": 0,
"name": "Colaborador"
},
"benefits": [],
"data": []
}
class TestGetProfile(unittest.TestCase):
def setUp(self):
call("./setup/start_testing.sh")
self.profile_one = PersonProfile(1)
self.profile_two = PersonProfile(2)
self.profile_three = PersonProfile(10)
self.profile_one_data = {
"id":
1,
"name":
"Pessoa da Wonka",
"idCompany":
1,
"cpf":
"230.841.911-31",
"admin": {
"level": 1,
"name": "Admin"
},
"benefits": [{
"idBenefit": 3,
"name": "Plano Dental Sorriso"
}, {
"idBenefit": 1,
"name": "Plano de Saúde Norte Europa"
}],
"data": [{
"idDatatype": 5,
"name": "Peso (kg)",
"data": "78"
}, {
"idDatatype": 6,
"name": "Altura (cm)",
"data": "180"
}, {
"idDatatype": 8,
"name": "Email",
"data": "*****@*****.**"
}]
}
self.profile_two_data = {
"id": 2,
"name": "Pessoa da Tio Patinhas",
"idCompany": 2,
"cpf": "985.105.727-47",
"admin": {
"level": 1,
"name": "Admin"
},
"benefits": [],
"data": []
}
self.profile_three_data = {
"id": 10,
"name": "Augusto Wozniak",
"idCompany": 3,
"cpf": "007.123.232-12",
"admin": {
"level": 0,
"name": "Colaborador"
},
"benefits": [],
"data": []
}
def tearDown(self):
call("./setup/finish_testing.sh")
def test_get_profile_one(self):
for key in self.profile_one_data.keys():
actual_result = self.profile_one.get_profile().get(key)
expected_result = self.profile_one_data.get(key)
self.assertEqual(actual_result, expected_result)
def test_get_profile_two(self):
for key in self.profile_two_data.keys():
actual_result = self.profile_two.get_profile().get(key)
expected_result = self.profile_two_data.get(key)
self.assertEqual(actual_result, expected_result)
def test_get_profile_three(self):
for key in self.profile_three_data.keys():
actual_result = self.profile_three.get_profile().get(key)
expected_result = self.profile_three_data.get(key)
self.assertEqual(actual_result, expected_result)
def test_get_person_data_boolean_input(self):
with self.assertRaises(TypeError):
PersonProfile(False).get_data()
def test_get_person_data_empy_input(self):
with self.assertRaises(TypeError):
PersonProfile().get_data()
def test_get_person_data_float_input(self):
with self.assertRaises(TypeError):
PersonProfile(13.9).get_data()
def test_get_person_name_boolean_input(self):
with self.assertRaises(TypeError):
PersonProfile(True).get_admin()
def test_get_person_benefits_boolean_input(self):
with self.assertRaises(TypeError):
PersonProfile(True).get_benefits()
class TestGetData(unittest.TestCase):
def setUp(self):
call("./setup/start_testing.sh")
self.profile_one = PersonProfile(1)
self.profile_two = PersonProfile(2)
self.profile_three = PersonProfile(10)
def tearDown(self):
call("./setup/finish_testing.sh")
def test_get_person_data_one(self):
actual_result = self.profile_one.get_data()
expected_result = [{
"idDatatype": 5,
"name": "Peso (kg)",
"data": "78"
}, {
"idDatatype": 6,
"name": "Altura (cm)",
"data": "180"
}, {
"idDatatype": 8,
"name": "Email",
"data": "*****@*****.**"
}]
self.assertEqual(actual_result, expected_result)
def test_get_person_data_two(self):
actual_result = self.profile_two.get_data()
expected_result = []
self.assertEqual(actual_result, expected_result)
def test_get_person_data_three(self):
actual_result = self.profile_three.get_data()
expected_result = []
self.assertEqual(actual_result, expected_result)
def test_get_person_data_doesnt_exist(self):
with self.assertRaises(Exception):
PersonProfile(10292).get_data()
def test_get_person_data_string_input(self):
with self.assertRaises(TypeError):
PersonProfile('whoops').get_data()
def test_get_person_data_float_input(self):
with self.assertRaises(TypeError):
PersonProfile(13.9).get_data()
def test_get_person_data_datatype_input(self):
with self.assertRaises(TypeError):
PersonProfile(list).get_data()
def test_get_person_data_none_input(self):
with self.assertRaises(TypeError):
PersonProfile(None).get_data()
def test_get_person_data_empy_input(self):
with self.assertRaises(TypeError):
PersonProfile().get_data()
def test_get_person_data_boolean_input(self):
with self.assertRaises(TypeError):
PersonProfile(False).get_data()
def test_get_person_name_string_input(self):
with self.assertRaises(TypeError):
PersonProfile("274q38").get_admin()
def test_get_person_benefits_empy_input(self):
with self.assertRaises(TypeError):
PersonProfile().get_benefits()
def test_get_person_benefits_string_input(self):
with self.assertRaises(TypeError):
PersonProfile("274q38").get_benefits()
def test_get_person_benefits_doesnt_exist(self):
with self.assertRaises(Exception):
PersonProfile(1111111111).get_benefits()
def test_get_person_name_datatype_input(self):
with self.assertRaises(TypeError):
PersonProfile(float).get_admin()
class TestGetDetails(unittest.TestCase):
def setUp(self):
call("./setup/start_testing.sh")
self.profile_one = PersonProfile(1)
self.profile_two = PersonProfile(2)
self.profile_three = PersonProfile(10)
def tearDown(self):
call("./setup/finish_testing.sh")
def test_get_person_name_idcompany_cpf_one(self):
actual_result = self.profile_one.get_details()
expected_result = {
"name": "Pessoa da Wonka",
"idCompany": 1,
"cpf": "230.841.911-31"
}
self.assertEqual(actual_result, expected_result)
def test_get_person_name_idcompany_cpf_two(self):
actual_result = self.profile_two.get_details()
expected_result = {
"name": "Pessoa da Tio Patinhas",
"idCompany": 2,
"cpf": "985.105.727-47"
}
self.assertEqual(actual_result, expected_result)
def test_get_person_name_idcompany_cpf_three(self):
actual_result = self.profile_three.get_details()
expected_result = {
"name": "Augusto Wozniak",
"idCompany": 3,
"cpf": "007.123.232-12"
}
self.assertEqual(actual_result, expected_result)
def test_get_person_name_doesnt_exist(self):
with self.assertRaises(Exception):
PersonProfile(1111111111).get_details()
def test_get_person_name_string_input(self):
with self.assertRaises(TypeError):
PersonProfile("274q38").get_details()
def test_get_person_name_float_input(self):
with self.assertRaises(TypeError):
PersonProfile(1.0).get_details()
def test_get_person_name_datatype_input(self):
with self.assertRaises(TypeError):
PersonProfile(float).get_details()
def test_get_person_name_none_input(self):
with self.assertRaises(TypeError):
PersonProfile(None).get_details()
def test_get_person_name_empy_input(self):
with self.assertRaises(TypeError):
PersonProfile().get_details()
def test_get_person_name_boolean_input(self):
with self.assertRaises(TypeError):
PersonProfile(True).get_details()
def test_get_person_data_doesnt_exist(self):
with self.assertRaises(Exception):
PersonProfile(10292).get_data()
def setUp(self):
call("./setup/start_testing.sh")
self.profile_one = PersonProfile(1)
self.profile_two = PersonProfile(2)
self.profile_three = PersonProfile(10)
def test_get_person_data_string_input(self):
with self.assertRaises(TypeError):
PersonProfile('whoops').get_data()
def test_get_person_benefits_datatype_input(self):
with self.assertRaises(TypeError):
PersonProfile(float).get_benefits()
def test_get_person_name_empy_input(self):
with self.assertRaises(TypeError):
PersonProfile().get_admin()
