from datetime import date from pathlib import Path from tempfile import TemporaryDirectory from unittest.mock import patch import requests from django.db import IntegrityError from django.test import SimpleTestCase, TestCase, override_settings from django.core.files.uploadedfile import SimpleUploadedFile from django.urls import reverse from django.contrib.auth import get_user_model from django.utils import timezone from .importers import ( GENNERA_USER_AGENT, build_aluno_export_file, export_pessoa_record, export_vinculo_record, fetch_gennera_pessoas_ingressantes_page, fetch_gennera_vinculos_censup_page, import_alunos, import_carga_horaria_from_gennera, import_cursos, import_pessoa_record, import_pessoas_ingressantes_from_gennera, import_vinculo_record, import_vinculos_from_gennera, import_vinculos_ingressantes_from_gennera, import_polos, load_max_carga_horaria_by_curso, ) from .models import AnoCenso, Curso, Instituicao, Municipio, Pais, Pessoa, Polo, UF, Vinculo from .views import CRUD_CONFIGS class FakeGenneraResponse: def __init__(self, json_data=None, headers=None, status_code=200, text=""): self._json = json_data self.headers = headers or {} self.status_code = status_code self.text = text def raise_for_status(self) -> None: if self.status_code >= 400: raise requests.HTTPError(f"{self.status_code} error", response=self) def json(self): return self._json class AuthenticatedViewTestCase(TestCase): def setUp(self) -> None: self.user = get_user_model().objects.create_user( username="tester", password="secret", ) self.client.force_login(self.user) class HomeViewTests(AuthenticatedViewTestCase): def test_home_page_requires_login(self) -> None: self.client.logout() response = self.client.get(reverse("home")) self.assertEqual(response.status_code, 302) self.assertIn(reverse("login"), response["Location"]) def test_home_page_returns_ok(self) -> None: response = self.client.get(reverse("home")) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, "base.html") self.assertTemplateUsed(response, "core/home.html") self.assertContains(response, "Autocensup") self.assertContains(response, "cdn.jsdelivr.net/npm/@tabler/core") def test_home_page_displays_course_vinculo_summary(self) -> None: year = timezone.localdate().year - 1 uf = UF.objects.create(codigo=22, nome="Piaui") municipio = Municipio.objects.create(codigo=2211001, nome="Teresina", uf=uf) pais = Pais.objects.create(codigo="BRA", nome="Brasil") curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", situacao_funcionamento_curso="Em atividade", carga_horaria_total=3200, ) statuses = [ Vinculo.Situacao.DESVINCULADO, Vinculo.Situacao.CURSANDO, Vinculo.Situacao.TRANSFERENCIA_INTERNA, Vinculo.Situacao.FALECIDO, Vinculo.Situacao.FORMADO, Vinculo.Situacao.NAO_INFORMADA, ] for index, status in enumerate(statuses, start=1): pessoa = Pessoa.objects.create( nome=f"Aluno {index}", cpf=f"{index:011d}", data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, uf_nascimento=uf, municipio_nascimento=municipio, pais_origem=pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) Vinculo.objects.create( pessoa=pessoa, ano_censo_id=year, periodo_referencia=Vinculo.PeriodoReferencia.PRIMEIRO_SEMESTRE, curso=curso, turno=Vinculo.Turno.NOTURNO, situacao=status, semestre_ingresso=f"01{year}", ingresso_vestibular=True, ingresso_enem=False, ingresso_avaliacao_seriada=False, ingresso_selecao_simplificada=False, ingresso_egresso_bi_li=False, ingresso_pec_g=False, ingresso_transferencia_ex_officio=False, ingresso_decisao_judicial=False, ingresso_vagas_remanescentes=False, ingresso_programas_especiais=False, apoio_social=False, atividade_extracurricular=False, carga_horaria_total_aluno=3200, carga_horaria_integralizada=3200, ingressou_acao_afirmativa=False, ) response = self.client.get(reverse("home")) self.assertContains(response, "Vinculos por curso") self.assertContains(response, "Pedagogia") self.assertContains(response, "Desvinculado") self.assertContains(response, "Cursando") self.assertContains(response, "Transferido") self.assertContains(response, "Falecido") self.assertContains(response, "Formado") self.assertContains(response, "Pendente") self.assertContains(response, "Quantidade de vinculos") self.assertContains(response, "1", count=5) self.assertContains(response, "bg-yellow-lt text-yellow") self.assertContains(response, "6") class ModelTests(SimpleTestCase): def test_uf_string_representation(self) -> None: uf = UF(codigo=22, nome="Piaui") self.assertEqual(str(uf), "Piaui") def test_municipio_string_representation(self) -> None: uf = UF(codigo=22, nome="Piaui") municipio = Municipio(codigo=2211001, nome="Teresina", uf=uf) self.assertEqual(str(municipio), "Teresina - Piaui") def test_pais_string_representation(self) -> None: pais = Pais(codigo="BRA", nome="Brasil") self.assertEqual(str(pais), "Brasil") def test_curso_string_representation(self) -> None: curso = Curso( codigo_mec=123, descricao="Analise e Desenvolvimento de Sistemas", carga_horaria_total=2400, ) self.assertEqual(str(curso), "Analise e Desenvolvimento de Sistemas") def test_instituicao_string_representation(self) -> None: instituicao = Instituicao(codigo_inep=123456, nome="Centro Universitario") self.assertEqual(str(instituicao), "Centro Universitario") def test_polo_string_representation(self) -> None: polo = Polo(codigo=654321, descricao="Polo Centro") self.assertEqual(str(polo), "Polo Centro") def test_pessoa_string_representation(self) -> None: pais = Pais(codigo="BRA", nome="Brasil") pessoa = Pessoa( nome="Maria Silva", cpf="12345678901", data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) self.assertEqual(str(pessoa), "Maria Silva") class ModelDatabaseTests(TestCase): def setUp(self) -> None: self.pais = Pais.objects.create(codigo="BRA", nome="Brasil") self.pessoa = Pessoa.objects.create( nome="Maria Silva", cpf="12345678901", data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=self.pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) self.curso = Curso.objects.create( codigo_mec=123, descricao="Analise e Desenvolvimento de Sistemas", carga_horaria_total=2400, ) def test_cpf_must_be_unique(self) -> None: with self.assertRaises(IntegrityError): Pessoa.objects.create( nome="Outra Pessoa", cpf=self.pessoa.cpf, data_nascimento=date(2001, 1, 1), cor_raca=Pessoa.CorRaca.BRANCA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=self.pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) def test_vinculo_string_representation(self) -> None: vinculo = self.create_vinculo() self.assertEqual( str(vinculo), "Maria Silva - Analise e Desenvolvimento de Sistemas", ) def test_pessoa_can_have_more_than_one_vinculo(self) -> None: self.create_vinculo() outro_curso = Curso.objects.create( codigo_mec=456, descricao="Sistemas de Informacao", carga_horaria_total=3000, ) vinculo = self.create_vinculo(curso=outro_curso) self.assertEqual(vinculo.pessoa, self.pessoa) def test_pessoa_can_have_same_course_vinculo_in_different_years(self) -> None: self.create_vinculo(ano_censo=2025) vinculo = self.create_vinculo(ano_censo=2026) self.assertEqual(vinculo.curso, self.curso) def test_vinculo_must_be_unique_by_pessoa_curso_and_year(self) -> None: self.create_vinculo() with self.assertRaises(IntegrityError): self.create_vinculo() def create_vinculo( self, curso: Curso | None = None, ano_censo: int = 2025, ) -> Vinculo: return Vinculo.objects.create( pessoa=self.pessoa, ano_censo_id=ano_censo, periodo_referencia=Vinculo.PeriodoReferencia.PRIMEIRO_SEMESTRE, curso=curso or self.curso, situacao=Vinculo.Situacao.CURSANDO, semestre_ingresso="012025", ingresso_vestibular=True, ingresso_enem=False, ingresso_avaliacao_seriada=False, ingresso_selecao_simplificada=False, ingresso_egresso_bi_li=False, ingresso_pec_g=False, ingresso_transferencia_ex_officio=False, ingresso_decisao_judicial=False, ingresso_vagas_remanescentes=False, ingresso_programas_especiais=False, apoio_social=False, atividade_extracurricular=False, carga_horaria_total_aluno=2400, carga_horaria_integralizada=120, ingressou_acao_afirmativa=False, ) class CrudViewTests(AuthenticatedViewTestCase): def test_menu_defaults_to_previous_year(self) -> None: expected_year = timezone.localdate().year - 1 response = self.client.get(reverse("home")) self.assertEqual(response.status_code, 200) self.assertContains(response, f'value="{expected_year}" selected') def test_selected_year_is_persisted_from_menu(self) -> None: selected_year = timezone.localdate().year - 2 AnoCenso.objects.create(ano=selected_year) response = self.client.post( reverse("set_ano_censo"), {"ano_censo": selected_year, "next": reverse("home")}, ) self.assertRedirects(response, reverse("home")) self.assertEqual(self.client.session["ano_censo"], selected_year) def test_vinculos_list_uses_selected_year(self) -> None: current_year = timezone.localdate().year - 1 previous_year = current_year - 1 AnoCenso.objects.get_or_create(ano=current_year) AnoCenso.objects.get_or_create(ano=previous_year) pais = Pais.objects.create(codigo="BRA", nome="Brasil") pessoa_atual = Pessoa.objects.create( nome="Aluno Atual", cpf="12345678901", data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) pessoa_anterior = Pessoa.objects.create( nome="Aluno Anterior", cpf="12345678902", data_nascimento=date(2001, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) self.create_test_vinculo(pessoa_atual, curso, current_year) self.create_test_vinculo(pessoa_anterior, curso, previous_year) response = self.client.get(reverse("crud_list", kwargs={"slug": "vinculos"})) self.assertContains(response, "Aluno Atual") self.assertNotContains(response, "Aluno Anterior") session = self.client.session session["ano_censo"] = previous_year session.save() response = self.client.get(reverse("crud_list", kwargs={"slug": "vinculos"})) self.assertContains(response, "Aluno Anterior") self.assertNotContains(response, "Aluno Atual") def test_vinculos_list_searches_by_matricula(self) -> None: current_year = timezone.localdate().year - 1 AnoCenso.objects.get_or_create(ano=current_year) pais = Pais.objects.create(codigo="BRA", nome="Brasil") pessoa = Pessoa.objects.create( nome="Aluno Matricula", cpf="12345678901", data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) outra_pessoa = Pessoa.objects.create( nome="Aluno Fora", cpf="12345678902", data_nascimento=date(2001, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) vinculo = self.create_test_vinculo(pessoa, curso, current_year) vinculo.matricula = "MAT-953" vinculo.save(update_fields=["matricula"]) self.create_test_vinculo(outra_pessoa, curso, current_year) response = self.client.get( reverse("crud_list", kwargs={"slug": "vinculos"}), {"q": "MAT-953"}, ) self.assertContains(response, "Aluno Matricula") self.assertNotContains(response, "Aluno Fora") def test_vinculo_detail_shows_person_vinculos_navigation(self) -> None: AnoCenso.objects.get_or_create(ano=2025) AnoCenso.objects.get_or_create(ano=2026) pais = Pais.objects.create(codigo="BRA", nome="Brasil") pessoa = Pessoa.objects.create( nome="Aluno Navegacao", cpf="12345678901", data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) pedagogia = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) sistemas = Curso.objects.create( codigo_mec=456, descricao="Sistemas de Informacao", carga_horaria_total=3000, ) vinculo_atual = self.create_test_vinculo(pessoa, pedagogia, 2026) outro_vinculo = self.create_test_vinculo(pessoa, sistemas, 2025) response = self.client.get( reverse("crud_detail", kwargs={"slug": "vinculos", "pk": vinculo_atual.pk}) ) self.assertContains(response, "Vínculos de Aluno Navegacao") self.assertContains(response, "Pedagogia") self.assertContains(response, "Sistemas de Informacao") self.assertContains(response, "Atual") self.assertContains(response, "Próximo vínculo") self.assertContains(response, "Ver vínculo") self.assertContains( response, reverse("crud_detail", kwargs={"slug": "vinculos", "pk": outro_vinculo.pk}), ) def create_test_vinculo( self, pessoa: Pessoa, curso: Curso, ano_censo: int, ) -> Vinculo: return Vinculo.objects.create( pessoa=pessoa, ano_censo_id=ano_censo, periodo_referencia=Vinculo.PeriodoReferencia.PRIMEIRO_SEMESTRE, curso=curso, situacao=Vinculo.Situacao.CURSANDO, semestre_ingresso=f"01{ano_censo}", ingresso_vestibular=True, ingresso_enem=False, ingresso_avaliacao_seriada=False, ingresso_selecao_simplificada=False, ingresso_egresso_bi_li=False, ingresso_pec_g=False, ingresso_transferencia_ex_officio=False, ingresso_decisao_judicial=False, ingresso_vagas_remanescentes=False, ingresso_programas_especiais=False, apoio_social=False, atividade_extracurricular=False, carga_horaria_total_aluno=curso.carga_horaria_total, carga_horaria_integralizada=120, ingressou_acao_afirmativa=False, ) def test_all_crud_lists_return_ok(self) -> None: for slug in CRUD_CONFIGS: with self.subTest(slug=slug): response = self.client.get(reverse("crud_list", kwargs={"slug": slug})) self.assertEqual(response.status_code, 200) def test_crud_search_and_pagination(self) -> None: for index in range(25): UF.objects.create(codigo=index + 1, nome=f"Estado {index + 1}") response = self.client.get(reverse("crud_list", kwargs={"slug": "ufs"})) self.assertEqual(response.status_code, 200) self.assertContains(response, "Pagina 1 de 2") response = self.client.get( reverse("crud_list", kwargs={"slug": "ufs"}), {"q": "Estado 25"}, ) self.assertEqual(response.status_code, 200) self.assertContains(response, "Estado 25") self.assertNotContains(response, "Estado 24") def test_crud_create_detail_update_and_delete(self) -> None: create_response = self.client.post( reverse("crud_create", kwargs={"slug": "ufs"}), {"codigo": 22, "nome": "Piaui"}, ) uf = UF.objects.get(codigo=22) self.assertRedirects( create_response, reverse("crud_detail", kwargs={"slug": "ufs", "pk": uf.pk}), ) detail_response = self.client.get( reverse("crud_detail", kwargs={"slug": "ufs", "pk": uf.pk}), ) self.assertContains(detail_response, "Piaui") update_response = self.client.post( reverse("crud_update", kwargs={"slug": "ufs", "pk": uf.pk}), {"codigo": 22, "nome": "Piauí"}, ) self.assertRedirects( update_response, reverse("crud_detail", kwargs={"slug": "ufs", "pk": uf.pk}), ) self.assertEqual(UF.objects.get(codigo=22).nome, "Piauí") delete_response = self.client.post( reverse("crud_delete", kwargs={"slug": "ufs", "pk": uf.pk}), ) self.assertRedirects(delete_response, reverse("crud_list", kwargs={"slug": "ufs"})) self.assertFalse(UF.objects.filter(codigo=22).exists()) def test_crud_list_sorts_by_clicked_column(self) -> None: UF.objects.create(codigo=1, nome="Zeta") UF.objects.create(codigo=2, nome="Alfa") response_asc = self.client.get( reverse("crud_list", kwargs={"slug": "ufs"}), {"sort": "nome", "dir": "asc"} ) response_desc = self.client.get( reverse("crud_list", kwargs={"slug": "ufs"}), {"sort": "nome", "dir": "desc"} ) self.assertEqual( [uf.nome for uf in response_asc.context["page_obj"].object_list], ["Alfa", "Zeta"], ) self.assertEqual( [uf.nome for uf in response_desc.context["page_obj"].object_list], ["Zeta", "Alfa"], ) def test_crud_list_ignores_unknown_sort_field(self) -> None: UF.objects.create(codigo=1, nome="Piaui") response = self.client.get( reverse("crud_list", kwargs={"slug": "ufs"}), {"sort": "bogus"} ) self.assertEqual(response.status_code, 200) self.assertEqual(response.context["sort"], "") def test_crud_list_pagination_links_preserve_sort(self) -> None: for index in range(25): UF.objects.create(codigo=index + 1, nome=f"UF {index:02d}") response = self.client.get( reverse("crud_list", kwargs={"slug": "ufs"}), {"sort": "nome", "dir": "desc"} ) self.assertContains(response, "sort=nome&dir=desc&page=2") def test_crud_list_sorts_vinculos_by_related_pessoa_name(self) -> None: pais = Pais.objects.create(codigo="BRA", nome="Brasil") curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200 ) for nome, cpf in (("Zeta Aluno", "11111111111"), ("Alfa Aluno", "22222222222")): pessoa = Pessoa.objects.create( nome=nome, cpf=cpf, data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) Vinculo.objects.create( pessoa=pessoa, ano_censo_id=timezone.localdate().year - 1, curso=curso, situacao=Vinculo.Situacao.CURSANDO, semestre_ingresso="012025", carga_horaria_total_aluno=3200, carga_horaria_integralizada=0, **REQUIRED_VINCULO_BOOL_DEFAULTS, ) response = self.client.get( reverse("crud_list", kwargs={"slug": "vinculos"}), {"sort": "pessoa", "dir": "asc"} ) self.assertEqual( [v.pessoa.nome for v in response.context["page_obj"].object_list], ["Alfa Aluno", "Zeta Aluno"], ) def test_crud_update_marks_pessoa_as_atualizado_manualmente(self) -> None: pais = Pais.objects.create(codigo="BRA", nome="Brasil") pessoa = Pessoa.objects.create( nome="Maria Silva", cpf="12345678901", cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) self.assertFalse(pessoa.atualizado_manualmente) form_url = reverse("crud_update", kwargs={"slug": "pessoas", "pk": pessoa.pk}) form_page = self.client.get(form_url) self.assertNotContains(form_page, "atualizado_manualmente") response = self.client.post( form_url, { "nome": "Maria Silva Editada", "cpf": "12345678901", "cor_raca": Pessoa.CorRaca.PARDA, "nacionalidade": Pessoa.Nacionalidade.BRASILEIRA_NATA, "pais_origem": pais.pk, "aluno_com_deficiencia": Pessoa.SimNaoNaoDispoe.NAO, "tipo_escola_ensino_medio": Pessoa.TipoEscolaEnsinoMedio.PUBLICA, }, ) self.assertRedirects( response, reverse("crud_detail", kwargs={"slug": "pessoas", "pk": pessoa.pk}), ) pessoa.refresh_from_db() self.assertEqual(pessoa.nome, "Maria Silva Editada") self.assertTrue(pessoa.atualizado_manualmente) def test_pending_required_fields_view_lists_courses_without_carga(self) -> None: Curso.objects.create( codigo_mec=123, descricao="Curso sem carga", carga_horaria_total=0, ) response = self.client.get(reverse("pending_required_fields")) self.assertEqual(response.status_code, 200) self.assertContains(response, "Curso sem carga") self.assertContains(response, "Carga Horaria Total") def test_course_list_uses_check_icon_for_true_boolean(self) -> None: Curso.objects.create( codigo_mec=123, descricao="Curso EaD", situacao_funcionamento_curso="Em atividade", ead=True, carga_horaria_total=1000, ) response = self.client.get(reverse("crud_list", kwargs={"slug": "cursos"})) self.assertEqual(response.status_code, 200) self.assertContains(response, "ti ti-check") self.assertContains(response, "bg-green-lt text-green") self.assertContains(response, "Em atividade") def test_course_list_uses_yellow_badge_for_extinction_status(self) -> None: Curso.objects.create( codigo_mec=123, descricao="Curso em extincao", situacao_funcionamento_curso="Em extinção", carga_horaria_total=1000, ) response = self.client.get(reverse("crud_list", kwargs={"slug": "cursos"})) self.assertEqual(response.status_code, 200) self.assertContains(response, "bg-yellow-lt text-yellow") self.assertContains(response, "Em extinção") class ImportCursosTests(TestCase): def test_load_max_carga_horaria_by_curso(self) -> None: with TemporaryDirectory() as tmp_dir: alunos_path = Path(tmp_dir) / "alunos.txt" alunos_path.write_text( "\n".join( [ "40|1131", self.vinculo_line(codigo_curso=123, carga_horaria=2400), self.vinculo_line(codigo_curso=123, carga_horaria=2600), self.vinculo_line(codigo_curso=456, carga_horaria=1800), ] ), encoding="utf-8", ) cargas = load_max_carga_horaria_by_curso(alunos_path) self.assertEqual(cargas[123], 2600) self.assertEqual(cargas[456], 1800) def test_import_cursos_creates_and_updates_courses(self) -> None: Curso.objects.create( codigo_mec=123, descricao="Descricao antiga", carga_horaria_total=1, ) with TemporaryDirectory() as tmp_dir: tmp_path = Path(tmp_dir) csv_path = tmp_path / "cursos.csv" alunos_path = tmp_path / "alunos.txt" csv_path.write_text( "\ufeffCODIGO_CURSO;NOME_CURSO;SITUACAO_FUNCIONAMENTO_CURSO;FORMATO_OFERTA;GRAU_ACADEMICO\n" "123;PEDAGOGIA;Em atividade;EaD;Licenciatura\n" "456;ENGENHARIA;Em extincao;Presencial;Bacharelado\n" "789;GESTAO;Em atividade;Semipresencial;Tecnológico\n", encoding="utf-8", ) alunos_path.write_text( "\n".join( [ self.vinculo_line(codigo_curso=123, carga_horaria=3000), self.vinculo_line(codigo_curso=123, carga_horaria=3200), self.vinculo_line(codigo_curso=456, carga_horaria=4000), ] ), encoding="utf-8", ) result = import_cursos(csv_path=csv_path, alunos_path=alunos_path) curso_atualizado = Curso.objects.get(codigo_mec=123) curso_criado = Curso.objects.get(codigo_mec=456) curso_sem_carga = Curso.objects.get(codigo_mec=789) self.assertEqual(result.total, 3) self.assertEqual(result.created, 2) self.assertEqual(result.updated, 1) self.assertEqual(result.without_carga_horaria, 1) self.assertEqual(curso_atualizado.descricao, "PEDAGOGIA") self.assertEqual(curso_atualizado.situacao_funcionamento_curso, "Em atividade") self.assertTrue(curso_atualizado.licenciatura) self.assertTrue(curso_atualizado.ead) self.assertEqual(curso_atualizado.carga_horaria_total, 3200) self.assertFalse(curso_criado.licenciatura) self.assertFalse(curso_criado.ead) self.assertEqual(curso_criado.carga_horaria_total, 4000) self.assertEqual(curso_sem_carga.carga_horaria_total, 0) def test_import_cursos_from_cursos_csv_without_support_file(self) -> None: Curso.objects.create( codigo_mec=123, descricao="Descricao antiga", carga_horaria_total=3200, ) csv_text = ( "\ufeffCODIGO_IES;NOME_IES;CODIGO_CURSO;NOME_CURSO;" "CURSO_ATUALIZADO;SITUACAO_FUNCIONAMENTO_CURSO;FORMATO_OFERTA;GRAU_ACADEMICO\n" "1131;IES;123;PEDAGOGIA;Sim;Em atividade;EaD;Licenciatura\n" "1131;IES;456;ENGENHARIA;Sim;Em extinção;Presencial;Bacharelado\n" ) result = import_cursos(csv_text=csv_text) curso_atualizado = Curso.objects.get(codigo_mec=123) curso_criado = Curso.objects.get(codigo_mec=456) self.assertEqual(result.total, 2) self.assertEqual(result.created, 1) self.assertEqual(result.updated, 1) self.assertEqual(result.without_carga_horaria, 2) self.assertEqual(curso_atualizado.descricao, "PEDAGOGIA") self.assertEqual(curso_atualizado.carga_horaria_total, 3200) self.assertTrue(curso_atualizado.licenciatura) self.assertTrue(curso_atualizado.ead) self.assertTrue(curso_atualizado.exportar) self.assertEqual(curso_criado.carga_horaria_total, 0) self.assertFalse(curso_criado.licenciatura) self.assertFalse(curso_criado.ead) self.assertFalse(curso_criado.exportar) def vinculo_line(self, codigo_curso: int, carga_horaria: int) -> str: fields = [""] * 73 fields[0] = "42" fields[3] = str(codigo_curso) fields[55] = str(carga_horaria) return "|".join(fields) class ImportPolosTests(TestCase): def test_import_polos_creates_polos_and_links_ead_courses(self) -> None: Curso.objects.create( codigo_mec=123, descricao="Curso EaD", ead=True, carga_horaria_total=2000, ) Curso.objects.create( codigo_mec=456, descricao="Curso Presencial", ead=False, carga_horaria_total=2000, ) with TemporaryDirectory() as tmp_dir: csv_path = Path(tmp_dir) / "cursos_locais.csv" csv_path.write_text( "\ufeffCODIGOCURSO;CODIGOLOCALOFERTA;NOMELOCALOFERTA\n" "123;10;Polo Centro\n" "456;20;Unidade Presencial\n", encoding="utf-8", ) result = import_polos(csv_path) curso_ead = Curso.objects.get(codigo_mec=123) curso_presencial = Curso.objects.get(codigo_mec=456) self.assertEqual(result.created, 2) self.assertEqual(result.cursos_vinculados, 1) self.assertEqual(curso_ead.polo.descricao, "Polo Centro") self.assertIsNone(curso_presencial.polo) class ProcessarSituacaoTests(AuthenticatedViewTestCase): def setUp(self) -> None: super().setUp() self.year = timezone.localdate().year - 1 self.pais = Pais.objects.create(codigo="BRA", nome="Brasil") self.curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", situacao_funcionamento_curso="Em atividade", carga_horaria_total=3200, ) def test_processar_situacao_link_is_in_import_menu(self) -> None: response = self.client.get(reverse("home")) self.assertContains(response, "Importacoes") self.assertContains(response, "Processar Situacao") self.assertContains(response, reverse("processar_situacao")) def test_processar_situacao_updates_selected_year_by_matricula(self) -> None: selected_year_vinculo = self.create_vinculo( matricula="IES-1", cpf="12345678901", ano_censo=self.year, ) second_selected_year_vinculo = self.create_vinculo( matricula="IES-2", cpf="12345678902", ano_censo=self.year, ) other_year_vinculo = self.create_vinculo( matricula="IES-1", cpf="12345678903", ano_censo=self.year - 1, ) response = self.client.post( reverse("processar_situacao"), { "matriculas": "IES-1\nIES-2\nNAO-EXISTE", "situacao": Vinculo.Situacao.FORMADO, }, ) self.assertEqual(response.status_code, 200) self.assertContains(response, "Vinculos atualizados") self.assertContains(response, "NAO-EXISTE") selected_year_vinculo.refresh_from_db() second_selected_year_vinculo.refresh_from_db() other_year_vinculo.refresh_from_db() self.assertEqual(selected_year_vinculo.situacao, Vinculo.Situacao.FORMADO) self.assertEqual(second_selected_year_vinculo.situacao, Vinculo.Situacao.FORMADO) self.assertEqual(other_year_vinculo.situacao, Vinculo.Situacao.CURSANDO) def create_vinculo( self, matricula: str, cpf: str, ano_censo: int, ) -> Vinculo: pessoa = Pessoa.objects.create( nome=f"Aluno {cpf}", cpf=cpf, data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=self.pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) return Vinculo.objects.create( pessoa=pessoa, ano_censo_id=ano_censo, matricula=matricula, periodo_referencia=Vinculo.PeriodoReferencia.PRIMEIRO_SEMESTRE, curso=self.curso, turno=Vinculo.Turno.NOTURNO, situacao=Vinculo.Situacao.CURSANDO, semestre_ingresso=f"01{ano_censo}", ingresso_vestibular=True, ingresso_enem=False, ingresso_avaliacao_seriada=False, ingresso_selecao_simplificada=False, ingresso_egresso_bi_li=False, ingresso_pec_g=False, ingresso_transferencia_ex_officio=False, ingresso_decisao_judicial=False, ingresso_vagas_remanescentes=False, ingresso_programas_especiais=False, apoio_social=False, atividade_extracurricular=False, carga_horaria_total_aluno=3200, carga_horaria_integralizada=120, ingressou_acao_afirmativa=False, ) class ImportAlunosTests(AuthenticatedViewTestCase): def setUp(self) -> None: super().setUp() self.uf = UF.objects.create(codigo=22, nome="Piaui") self.municipio = Municipio.objects.create( codigo=2211001, nome="Teresina", uf=self.uf, ) self.pais = Pais.objects.create(codigo="BRA", nome="Brasil") self.curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", situacao_funcionamento_curso="Em atividade", licenciatura=True, ead=False, carga_horaria_total=3200, ) def test_import_alunos_creates_pessoa_and_vinculo(self) -> None: result = import_alunos( [ self.pessoa_line(nome="Maria Silva", nascimento="01012000"), self.vinculo_line(codigo_curso=123, carga_horaria=9999), ], ano_censo=2025, ) pessoa = Pessoa.objects.get(cpf="12345678901") vinculo = Vinculo.objects.get(pessoa=pessoa, curso=self.curso, ano_censo=2025) self.assertEqual(result.pessoas_created, 1) self.assertEqual(result.vinculos_created, 1) self.assertTrue(pessoa.anos_censo.filter(ano=2025).exists()) self.assertEqual(vinculo.carga_horaria_total_aluno, 3200) self.assertEqual(vinculo.situacao, Vinculo.Situacao.NAO_INFORMADA) def test_import_alunos_updates_pessoa_but_preserves_name_and_birth_date(self) -> None: Pessoa.objects.create( nome="Nome Original", cpf="12345678901", data_nascimento=date(1999, 1, 1), cor_raca=Pessoa.CorRaca.BRANCA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=self.pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PRIVADA, ) result = import_alunos( [ self.pessoa_line(nome="Nome Novo", nascimento="02022000"), ], ano_censo=2025, ) pessoa = Pessoa.objects.get(cpf="12345678901") self.assertEqual(result.pessoas_updated, 1) self.assertTrue(pessoa.anos_censo.filter(ano=2025).exists()) self.assertEqual(pessoa.nome, "Nome Original") self.assertEqual(pessoa.data_nascimento, date(1999, 1, 1)) self.assertEqual(pessoa.cor_raca, Pessoa.CorRaca.PARDA) def test_import_alunos_does_not_overwrite_manually_edited_pessoa(self) -> None: Pessoa.objects.create( nome="Nome Original", cpf="12345678901", data_nascimento=date(1999, 1, 1), cor_raca=Pessoa.CorRaca.BRANCA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=self.pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PRIVADA, atualizado_manualmente=True, ) result = import_alunos( [self.pessoa_line(nome="Nome Novo", nascimento="02022000")], ano_censo=2025, ) pessoa = Pessoa.objects.get(cpf="12345678901") self.assertEqual(result.pessoas_updated, 1) self.assertEqual(pessoa.cor_raca, Pessoa.CorRaca.BRANCA) self.assertEqual(pessoa.tipo_escola_ensino_medio, Pessoa.TipoEscolaEnsinoMedio.PRIVADA) def test_import_alunos_does_not_overwrite_manually_edited_vinculo(self) -> None: pessoa = Pessoa.objects.create( nome="Maria Silva", cpf="12345678901", data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=self.pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) Vinculo.objects.create( pessoa=pessoa, ano_censo_id=2025, curso=self.curso, situacao=Vinculo.Situacao.FORMADO, semestre_ingresso="012020", carga_horaria_total_aluno=3200, carga_horaria_integralizada=3200, atualizado_manualmente=True, ingresso_vestibular=True, ingresso_enem=False, ingresso_avaliacao_seriada=False, ingresso_selecao_simplificada=False, ingresso_egresso_bi_li=False, ingresso_pec_g=False, ingresso_transferencia_ex_officio=False, ingresso_decisao_judicial=False, ingresso_vagas_remanescentes=False, ingresso_programas_especiais=False, apoio_social=False, atividade_extracurricular=False, ingressou_acao_afirmativa=False, ) import_alunos( [ self.pessoa_line(nome="Maria Silva", nascimento="01012000"), self.vinculo_line(codigo_curso=123, carga_horaria=1), ], ano_censo=2025, ) vinculo = Vinculo.objects.get(pessoa=pessoa, curso=self.curso, ano_censo=2025) self.assertEqual(vinculo.situacao, Vinculo.Situacao.FORMADO) self.assertEqual(vinculo.carga_horaria_integralizada, 3200) def test_import_alunos_view_accepts_upload(self) -> None: uploaded = SimpleUploadedFile( "aluno_exportacao.txt", ( self.pessoa_line(nome="Maria Silva", nascimento="01012000") + "\n" + self.vinculo_line(codigo_curso=123, carga_horaria=9999) ).encode("utf-8"), content_type="text/plain", ) response = self.client.post( reverse("import_alunos"), {"ano_censo": 2025, "arquivo": uploaded}, ) self.assertEqual(response.status_code, 200) self.assertContains(response, "Pessoas criadas") self.assertEqual(Pessoa.objects.count(), 1) self.assertEqual(Vinculo.objects.count(), 1) class ImportCursosViewTests(AuthenticatedViewTestCase): def test_import_cursos_view_accepts_upload(self) -> None: uploaded = SimpleUploadedFile( "cursos.csv", ( "\ufeffCODIGO_IES;NOME_IES;CODIGO_CURSO;NOME_CURSO;" "CURSO_ATUALIZADO;SITUACAO_FUNCIONAMENTO_CURSO;FORMATO_OFERTA;GRAU_ACADEMICO\n" "1131;IES;123;PEDAGOGIA;Sim;Em atividade;EaD;Licenciatura\n" ).encode("utf-8"), content_type="text/csv", ) response = self.client.post( reverse("import_cursos"), {"arquivo": uploaded}, ) self.assertEqual(response.status_code, 200) self.assertContains(response, "Cursos criados") self.assertEqual(Curso.objects.count(), 1) curso = Curso.objects.get(codigo_mec=123) self.assertEqual(curso.descricao, "PEDAGOGIA") self.assertTrue(curso.licenciatura) self.assertTrue(curso.ead) def pessoa_line(self, nome: str, nascimento: str) -> str: return "|".join( [ "41", "1", nome, "12345678901", "", nascimento, "3", "1", "22", "2211001", "BRA", "0", "", "", "", "", "", "", "", "", "", "", "1", ] ) def vinculo_line(self, codigo_curso: int, carga_horaria: int) -> str: fields = [""] * 73 fields[0] = "42" fields[1] = "IES-1" fields[3] = str(codigo_curso) fields[6] = "-1" fields[12] = "012025" for index in range(13, 23): fields[index] = "0" fields[46] = "0" fields[55] = str(carga_horaria) fields[57] = "0" return "|".join(fields) REQUIRED_VINCULO_BOOL_DEFAULTS = { "ingresso_vestibular": True, "ingresso_enem": False, "ingresso_avaliacao_seriada": False, "ingresso_selecao_simplificada": False, "ingresso_egresso_bi_li": False, "ingresso_pec_g": False, "ingresso_transferencia_ex_officio": False, "ingresso_decisao_judicial": False, "ingresso_vagas_remanescentes": False, "ingresso_programas_especiais": False, "apoio_social": False, "atividade_extracurricular": False, "ingressou_acao_afirmativa": False, } class ExportAlunoRecordTests(TestCase): def setUp(self) -> None: self.uf = UF.objects.create(codigo=22, nome="Piaui") self.municipio = Municipio.objects.create( codigo=2211001, nome="Teresina", uf=self.uf, ) self.pais = Pais.objects.create(codigo="BRA", nome="Brasil") self.curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", situacao_funcionamento_curso="Em atividade", licenciatura=False, ead=False, carga_horaria_total=3200, ) AnoCenso.objects.get_or_create(ano=2025) def make_pessoa(self, **overrides: object) -> Pessoa: defaults = dict( nome="Maria Silva", cpf="12345678901", data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, uf_nascimento=self.uf, municipio_nascimento=self.municipio, pais_origem=self.pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) defaults.update(overrides) return Pessoa.objects.create(**defaults) def make_vinculo(self, pessoa: Pessoa, **overrides: object) -> Vinculo: defaults = dict( pessoa=pessoa, ano_censo_id=2025, curso=self.curso, matricula="MAT-1", situacao=Vinculo.Situacao.CURSANDO, semestre_ingresso="012025", carga_horaria_total_aluno=3200, carga_horaria_integralizada=100, **REQUIRED_VINCULO_BOOL_DEFAULTS, ) defaults.update(overrides) return Vinculo.objects.create(**defaults) def test_export_pessoa_record_round_trips_through_import(self) -> None: pessoa = self.make_pessoa() line = export_pessoa_record(pessoa) reimported, created = import_pessoa_record(line.split("|")) self.assertFalse(created) self.assertEqual(reimported.pk, pessoa.pk) self.assertEqual(reimported.cor_raca, pessoa.cor_raca) self.assertEqual(reimported.nacionalidade, pessoa.nacionalidade) self.assertEqual(reimported.uf_nascimento_id, pessoa.uf_nascimento_id) self.assertEqual(reimported.municipio_nascimento_id, pessoa.municipio_nascimento_id) self.assertEqual(reimported.pais_origem_id, pessoa.pais_origem_id) self.assertEqual(reimported.aluno_com_deficiencia, pessoa.aluno_com_deficiencia) self.assertEqual(reimported.tipo_escola_ensino_medio, pessoa.tipo_escola_ensino_medio) def test_export_pessoa_record_handles_null_data_nascimento(self) -> None: pessoa = self.make_pessoa(data_nascimento=None) line = export_pessoa_record(pessoa) self.assertEqual(line.split("|")[5], "") def test_export_vinculo_record_round_trips_through_import(self) -> None: pessoa = self.make_pessoa() vinculo = self.make_vinculo(pessoa) line = export_vinculo_record(vinculo) reimported, created = import_vinculo_record(line.split("|"), pessoa, 2025) self.assertFalse(created) self.assertEqual(reimported.pk, vinculo.pk) self.assertEqual(reimported.matricula, vinculo.matricula) self.assertEqual(reimported.situacao, vinculo.situacao) self.assertEqual(reimported.semestre_ingresso, vinculo.semestre_ingresso) self.assertEqual(reimported.carga_horaria_integralizada, vinculo.carga_horaria_integralizada) self.assertEqual(reimported.ingresso_vestibular, vinculo.ingresso_vestibular) def test_export_vinculo_record_writes_polo_codigo_not_polo_pk(self) -> None: # Two polos so the auto PK is guaranteed to differ from `codigo`. Polo.objects.create(codigo=999, descricao="Polo Descartavel") polo = Polo.objects.create(codigo=555, descricao="Polo Real") self.assertNotEqual(polo.pk, polo.codigo) pessoa = self.make_pessoa() vinculo = self.make_vinculo(pessoa, polo=polo) line = export_vinculo_record(vinculo) self.assertEqual(line.split("|")[4], str(polo.codigo)) def test_export_vinculo_record_falls_back_to_curso_polo_when_vinculo_polo_is_none( self, ) -> None: # Vinculos importados via API Gennera nunca preenchem Vinculo.polo diretamente # (ver import_gennera_vinculo_group) -- o polo EaD fica so em Curso.polo. Polo.objects.create(codigo=999, descricao="Polo Descartavel") polo_do_curso = Polo.objects.create(codigo=777, descricao="Polo do Curso EaD") self.curso.ead = True self.curso.polo = polo_do_curso self.curso.save(update_fields=["ead", "polo"]) pessoa = self.make_pessoa() vinculo = self.make_vinculo(pessoa, polo=None) line = export_vinculo_record(vinculo) self.assertEqual(line.split("|")[4], str(polo_do_curso.codigo)) def test_export_vinculo_record_writes_minus_one_for_nao_informada_situacao(self) -> None: pessoa = self.make_pessoa() vinculo = self.make_vinculo(pessoa, situacao=Vinculo.Situacao.NAO_INFORMADA) line = export_vinculo_record(vinculo) self.assertEqual(line.split("|")[6], "-1") def test_export_vinculo_record_writes_situacao_int_for_other_values(self) -> None: pessoa = self.make_pessoa() vinculo = self.make_vinculo(pessoa, situacao=Vinculo.Situacao.FORMADO) line = export_vinculo_record(vinculo) self.assertEqual(line.split("|")[6], str(int(Vinculo.Situacao.FORMADO))) def test_build_aluno_export_file_emits_header_once_and_groups_by_pessoa(self) -> None: curso_2 = Curso.objects.create( codigo_mec=456, descricao="Direito", carga_horaria_total=3600, ) pessoa_a = self.make_pessoa(cpf="11111111111", nome="Ana") pessoa_b = self.make_pessoa(cpf="22222222222", nome="Bruno") self.make_vinculo(pessoa_a) self.make_vinculo(pessoa_a, curso=curso_2, carga_horaria_total_aluno=3600) self.make_vinculo(pessoa_b) vinculos = list( Vinculo.objects.filter(ano_censo=2025).order_by("pessoa__nome", "pessoa_id") ) content = build_aluno_export_file(vinculos, ies_codigo=1131) lines = content.splitlines() self.assertEqual(lines[0], "40|1131") record_types = [line.split("|")[0] for line in lines[1:]] self.assertEqual(record_types, ["41", "42", "42", "41", "42"]) self.assertTrue(content.endswith("\n")) def test_build_aluno_export_file_empty_queryset_is_header_only(self) -> None: content = build_aluno_export_file(Vinculo.objects.none(), ies_codigo=1131) self.assertEqual(content, "40|1131\n") class ExportAlunosViewTests(AuthenticatedViewTestCase): def setUp(self) -> None: super().setUp() self.uf = UF.objects.create(codigo=22, nome="Piaui") self.municipio = Municipio.objects.create( codigo=2211001, nome="Teresina", uf=self.uf, ) self.pais = Pais.objects.create(codigo="BRA", nome="Brasil") self.curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) self.ano_2025, _ = AnoCenso.objects.get_or_create(ano=2025) AnoCenso.objects.get_or_create(ano=2024) self.client.post( reverse("set_ano_censo"), {"ano_censo": 2025, "next": reverse("home")}, ) def make_pessoa(self, cpf: str = "12345678901", **overrides: object) -> Pessoa: defaults = dict( nome="Maria Silva", cpf=cpf, data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=self.pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) defaults.update(overrides) return Pessoa.objects.create(**defaults) def make_vinculo(self, pessoa: Pessoa, **overrides: object) -> Vinculo: defaults = dict( pessoa=pessoa, ano_censo_id=2025, curso=self.curso, situacao=Vinculo.Situacao.CURSANDO, semestre_ingresso="012025", carga_horaria_total_aluno=3200, carga_horaria_integralizada=0, **REQUIRED_VINCULO_BOOL_DEFAULTS, ) defaults.update(overrides) return Vinculo.objects.create(**defaults) @override_settings(CENSUP_IES_CODIGO="1131") def test_export_requires_login(self) -> None: self.client.logout() response = self.client.get(reverse("export_alunos", args=["todos"])) self.assertEqual(response.status_code, 302) @override_settings(CENSUP_IES_CODIGO="1131") def test_export_unknown_filtro_returns_404(self) -> None: response = self.client.get(reverse("export_alunos", args=["bogus"])) self.assertEqual(response.status_code, 404) @override_settings(CENSUP_IES_CODIGO="") def test_export_missing_ies_codigo_redirects_with_message(self) -> None: response = self.client.get(reverse("export_alunos", args=["todos"]), follow=True) self.assertRedirects(response, reverse("home")) self.assertContains(response, "CENSUP_IES_CODIGO") @override_settings(CENSUP_IES_CODIGO="1131") def test_export_todos_includes_all_situacoes(self) -> None: pessoa_a = self.make_pessoa(cpf="11111111111") pessoa_b = self.make_pessoa(cpf="22222222222") self.make_vinculo(pessoa_a, situacao=Vinculo.Situacao.CURSANDO) self.make_vinculo(pessoa_b, situacao=Vinculo.Situacao.FORMADO) response = self.client.get(reverse("export_alunos", args=["todos"])) content = response.content.decode() self.assertIn("11111111111", content) self.assertIn("22222222222", content) @override_settings(CENSUP_IES_CODIGO="1131") def test_export_filters_by_situacao_cursando(self) -> None: pessoa_a = self.make_pessoa(cpf="11111111111") pessoa_b = self.make_pessoa(cpf="22222222222") self.make_vinculo(pessoa_a, situacao=Vinculo.Situacao.CURSANDO) self.make_vinculo(pessoa_b, situacao=Vinculo.Situacao.FORMADO) response = self.client.get(reverse("export_alunos", args=["cursando"])) content = response.content.decode() self.assertIn("11111111111", content) self.assertNotIn("22222222222", content) @override_settings(CENSUP_IES_CODIGO="1131") def test_export_ingressantes_filters_by_semestre_ingresso_year_suffix(self) -> None: pessoa_a = self.make_pessoa(cpf="11111111111") pessoa_b = self.make_pessoa(cpf="22222222222") self.make_vinculo(pessoa_a, semestre_ingresso="012025") self.make_vinculo(pessoa_b, semestre_ingresso="012020") response = self.client.get(reverse("export_alunos", args=["ingressantes"])) content = response.content.decode() self.assertIn("11111111111", content) self.assertNotIn("22222222222", content) @override_settings(CENSUP_IES_CODIGO="1131") def test_export_ingressantes_accepts_second_semester_suffix(self) -> None: pessoa = self.make_pessoa() self.make_vinculo(pessoa, semestre_ingresso="022025") response = self.client.get(reverse("export_alunos", args=["ingressantes"])) self.assertIn("12345678901", response.content.decode()) @override_settings(CENSUP_IES_CODIGO="1131") def test_export_scopes_by_selected_ano_censo(self) -> None: pessoa = self.make_pessoa() self.make_vinculo(pessoa, ano_censo_id=2024) response = self.client.get(reverse("export_alunos", args=["todos"])) self.assertNotIn("12345678901", response.content.decode()) @override_settings(CENSUP_IES_CODIGO="1131") def test_export_only_includes_matching_vinculos_not_all_of_pessoa(self) -> None: curso_2 = Curso.objects.create( codigo_mec=456, descricao="Direito", carga_horaria_total=3600, ) pessoa = self.make_pessoa() self.make_vinculo(pessoa, situacao=Vinculo.Situacao.CURSANDO) self.make_vinculo( pessoa, curso=curso_2, situacao=Vinculo.Situacao.DESVINCULADO, carga_horaria_total_aluno=3600, ) response = self.client.get(reverse("export_alunos", args=["cursando"])) lines = response.content.decode().splitlines() record_types = [line.split("|")[0] for line in lines[1:]] self.assertEqual(record_types, ["41", "42"]) @override_settings(CENSUP_IES_CODIGO="1131") def test_export_empty_queryset_returns_header_only(self) -> None: response = self.client.get(reverse("export_alunos", args=["falecido"])) self.assertEqual(response.content.decode(), "40|1131\n") @override_settings(CENSUP_IES_CODIGO="1131") def test_export_content_disposition_header_and_filename(self) -> None: response = self.client.get(reverse("export_alunos", args=["cursando"])) self.assertEqual( response["Content-Disposition"], 'attachment; filename="aluno_exportacao_cursando_2025.txt"', ) @override_settings(CENSUP_IES_CODIGO="1131") def test_export_menu_links_present_on_home_page(self) -> None: response = self.client.get(reverse("home")) for filtro in ( "todos", "ingressantes", "desvinculado", "cursando", "transferido", "falecido", "formado", ): self.assertContains(response, reverse("export_alunos", args=[filtro])) @override_settings(CENSUP_IES_CODIGO="1131") def test_export_output_is_reimportable(self) -> None: pessoa = self.make_pessoa() self.make_vinculo(pessoa) response = self.client.get(reverse("export_alunos", args=["todos"])) content = response.content.decode() lines = [line for line in content.splitlines() if line.split("|")[0] != "40"] result = import_alunos(lines, ano_censo=2025) self.assertEqual(result.errors, []) self.assertEqual(result.pessoas_created, 0) self.assertEqual(result.pessoas_updated, 1) self.assertEqual(result.vinculos_created, 0) self.assertEqual(result.vinculos_updated, 1) class ImportPessoasGenneraTests(AuthenticatedViewTestCase): def setUp(self) -> None: super().setUp() self.pais = Pais.objects.create(codigo="BRA", nome="Brasil") AnoCenso.objects.create(ano=2026) def test_import_pessoas_ingressantes_from_gennera_creates_pessoa(self) -> None: result = import_pessoas_ingressantes_from_gennera( primeiro_ano=2026, base_url="http://api.example.test", token="token", pages=[ ( 1, 1, 1, [ { "aluno_com_deficiencia": None, "cor_raca": None, "cpf": "025.426.183-30", "data_nascimento": "Fri, 03 Dec 2004 00:00:00 GMT", "idPerson": 2824600, "nacionalidade": "Brasil", "nome": "Maria Silva", "pais_origem": "Brasil", "tipo_escola_ensino_medio": "Publico", } ], ) ], ) pessoa = Pessoa.objects.get(cpf="02542618330") self.assertEqual(result.created, 1) self.assertTrue(pessoa.anos_censo.filter(ano=2026).exists()) self.assertEqual(pessoa.nome, "Maria Silva") self.assertEqual(pessoa.id_aluno_inep, 2824600) self.assertEqual(pessoa.data_nascimento, date(2004, 12, 3)) self.assertEqual(pessoa.nacionalidade, Pessoa.Nacionalidade.BRASILEIRA_NATA) self.assertEqual(pessoa.pais_origem, self.pais) self.assertEqual( pessoa.tipo_escola_ensino_medio, Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) def test_import_pessoas_ingressantes_from_gennera_skips_existing_pessoa(self) -> None: Pessoa.objects.create( nome="Nome Existente", cpf="02542618330", data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=self.pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) result = import_pessoas_ingressantes_from_gennera( primeiro_ano=2026, base_url="http://api.example.test", token="token", pages=[ ( 1, 1, 1, [ { "aluno_com_deficiencia": None, "cor_raca": None, "cpf": "025.426.183-30", "data_nascimento": "Fri, 03 Dec 2004 00:00:00 GMT", "idPerson": 2824600, "nacionalidade": "Brasil", "nome": "Maria Silva", "pais_origem": "Brasil", "tipo_escola_ensino_medio": "Publico", } ], ) ], ) pessoa = Pessoa.objects.get(cpf="02542618330") self.assertEqual(result.created, 0) self.assertEqual(result.skipped, 1) self.assertEqual(result.total, 1) self.assertEqual(pessoa.nome, "Nome Existente") self.assertIsNone(pessoa.id_aluno_inep) def test_fetch_gennera_pessoas_ingressantes_page_sends_auth_token_header(self) -> None: response = FakeGenneraResponse( {"data": []}, headers={"X-Total-Count": "0", "X-Total-Pages": "1"} ) with patch( "core.importers._gennera_session.get", return_value=response ) as get_mock: result, total_count, total_pages = fetch_gennera_pessoas_ingressantes_page( base_url="http://api.example.test", token="env-token", primeiro_ano=2026, page=1, ) url = get_mock.call_args.args[0] headers = get_mock.call_args.kwargs["headers"] self.assertEqual(result, []) self.assertEqual(total_count, 0) self.assertEqual(total_pages, 1) self.assertIn("/api/censup_person_ingressantes?", url) self.assertIn("primeiroAno=2026", url) self.assertEqual(headers["auth_token"], "env-token") self.assertEqual(headers["User-Agent"], GENNERA_USER_AGENT) def test_fetch_gennera_vinculos_censup_page_uses_censup_vinculos_endpoint(self) -> None: response = FakeGenneraResponse( { "data": [ { "cpf": "02542618330", "turno": "Noite", "referenceYear": "2026/1", "course": "Pedagogia", "course_code": "123", "ano": 2026, "carga_horaria_acumulada": 1600, } ] }, headers={"X-Total-Count": "1", "X-Total-Pages": "1"}, ) with patch( "core.importers._gennera_session.get", return_value=response ) as get_mock: result, total_count, total_pages = fetch_gennera_vinculos_censup_page( base_url="http://api.example.test", token="env-token", cpf="02542618330", page=1, ) url = get_mock.call_args.args[0] headers = get_mock.call_args.kwargs["headers"] self.assertEqual(result[0]["course"], "Pedagogia") self.assertEqual(total_count, 1) self.assertEqual(total_pages, 1) self.assertIn("/api/censup_vinculos?", url) self.assertIn("cpf=02542618330", url) self.assertEqual(headers["auth_token"], "env-token") self.assertEqual(headers["User-Agent"], GENNERA_USER_AGENT) def test_fetch_gennera_pessoas_ingressantes_page_retries_on_connection_error( self, ) -> None: response = FakeGenneraResponse( {"data": []}, headers={"X-Total-Count": "0", "X-Total-Pages": "1"} ) with ( patch( "core.importers._gennera_session.get", side_effect=[requests.ConnectionError("boom"), response], ) as get_mock, patch("core.importers.time.sleep") as sleep_mock, ): result, total_count, total_pages = fetch_gennera_pessoas_ingressantes_page( base_url="http://api.example.test", token="env-token", primeiro_ano=2026, page=1, ) self.assertEqual(result, []) self.assertEqual(total_count, 0) self.assertEqual(total_pages, 1) self.assertEqual(get_mock.call_count, 2) sleep_mock.assert_called_once() def test_fetch_gennera_pessoas_ingressantes_page_does_not_retry_on_http_error( self, ) -> None: response = FakeGenneraResponse({}, status_code=500, text="boom") with patch( "core.importers._gennera_session.get", return_value=response ) as get_mock: with self.assertRaises(ValueError) as ctx: fetch_gennera_pessoas_ingressantes_page( base_url="http://api.example.test", token="env-token", primeiro_ano=2026, page=1, ) self.assertEqual(get_mock.call_count, 1) self.assertIn("HTTP 500", str(ctx.exception)) self.assertIn("boom", str(ctx.exception)) def test_import_vinculos_from_gennera_uses_course_code_as_codigo_mec(self) -> None: pessoa_com_vinculo = Pessoa.objects.create( nome="Maria Silva", cpf="02542618330", data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=self.pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) Pessoa.objects.create( nome="Joao Sem Vinculo", cpf="11122233344", data_nascimento=date(2001, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=self.pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) requested_cpfs = [] def fetcher( base_url: str, token: str, ano: int, cpf: str, ) -> list[dict[str, object]]: requested_cpfs.append(cpf) if cpf == pessoa_com_vinculo.cpf: return [ { "cpf": cpf, "turno": "Noite", "referenceYear": "2026/2", "course": "Pedagogia", "course_code": "123", "ano": 2026, "carga_horaria_acumulada": 1600, } ] return [] result = import_vinculos_from_gennera( ano=2026, base_url="http://api.example.test", token="token", ingressantes_fetcher=lambda *a, **k: ([], 0, 1), fetcher=fetcher, ) vinculo = Vinculo.objects.get( pessoa=pessoa_com_vinculo, curso=curso, ano_censo=2026, ) self.assertEqual(requested_cpfs, ["11122233344", "02542618330"]) self.assertEqual(result.pessoas_processed, 2) self.assertEqual(result.pessoas_without_vinculo, 1) self.assertEqual(result.created, 1) self.assertTrue(pessoa_com_vinculo.anos_censo.filter(ano=2026).exists()) self.assertEqual(vinculo.situacao, Vinculo.Situacao.CURSANDO) self.assertEqual(vinculo.turno, Vinculo.Turno.NOTURNO) self.assertEqual( vinculo.periodo_referencia, Vinculo.PeriodoReferencia.SEGUNDO_SEMESTRE, ) self.assertEqual(vinculo.semestre_ingresso, "022026") self.assertEqual(vinculo.carga_horaria_total_aluno, 3200) self.assertEqual(vinculo.carga_horaria_integralizada, 1600) def test_import_vinculos_from_gennera_uses_oldest_record_for_semestre_ingresso(self) -> None: pessoa = self.create_gennera_pessoa("Aluno Ingresso Antigo", "02542618330") curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) import_vinculos_from_gennera( ano=2026, base_url="http://api.example.test", token="token", ingressantes_fetcher=lambda *a, **k: ([], 0, 1), fetcher=lambda base_url, token, ano, cpf: [ { "cpf": cpf, "turno": "Noite", "referenceYear": "2026/2", "course": "Pedagogia", "course_code": "123", "ano": 2026, "carga_horaria_acumulada": 1600, }, { "cpf": cpf, "turno": "Noite", "referenceYear": "2026/1", "course": "Pedagogia", "course_code": "123", "ano": 2026, "carga_horaria_acumulada": 800, }, ], ) vinculo = Vinculo.objects.get(pessoa=pessoa, curso=curso, ano_censo=2026) self.assertEqual( vinculo.periodo_referencia, Vinculo.PeriodoReferencia.SEGUNDO_SEMESTRE, ) self.assertEqual(vinculo.semestre_ingresso, "012026") def test_import_vinculos_from_gennera_sets_formado_by_workload(self) -> None: pessoa = self.create_gennera_pessoa("Aluno Formado", "02542618330") curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) result = import_vinculos_from_gennera( ano=2026, base_url="http://api.example.test", token="token", ingressantes_fetcher=lambda *a, **k: ([], 0, 1), fetcher=lambda base_url, token, ano, cpf: [ { "cpf": cpf, "turno": "Noite", "referenceYear": "2026/1", "course": "Pedagogia", "course_code": "123", "ano": 2026, "carga_horaria_acumulada": 3200, }, { "cpf": cpf, "turno": "Noite", "referenceYear": "2026/2", "course": "Pedagogia", "course_code": "123", "ano": 2026, "carga_horaria_acumulada": 3200, }, ], ) vinculo = Vinculo.objects.get(pessoa=pessoa, curso=curso, ano_censo=2026) self.assertEqual(result.created, 1) self.assertEqual(vinculo.situacao, Vinculo.Situacao.FORMADO) def test_import_vinculos_from_gennera_sets_desvinculado_for_semester_one_only(self) -> None: pessoa = self.create_gennera_pessoa("Aluno Desvinculado", "02542618330") curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) import_vinculos_from_gennera( ano=2026, base_url="http://api.example.test", token="token", ingressantes_fetcher=lambda *a, **k: ([], 0, 1), fetcher=lambda base_url, token, ano, cpf: [ { "cpf": cpf, "turno": "Noite", "referenceYear": "2026/1", "course": "Pedagogia", "course_code": "123", "ano": 2026, "carga_horaria_acumulada": 1600, } ], ) vinculo = Vinculo.objects.get(pessoa=pessoa, curso=curso, ano_censo=2026) self.assertEqual(vinculo.situacao, Vinculo.Situacao.DESVINCULADO) def test_import_vinculos_from_gennera_requires_course_code(self) -> None: self.create_gennera_pessoa("Aluno Sem Codigo Curso", "02542618330") Curso.objects.create( codigo_mec=123, descricao="ADMINISTRAÇÃO", carga_horaria_total=3200, ) result = import_vinculos_from_gennera( ano=2025, base_url="http://api.example.test", token="token", ingressantes_fetcher=lambda *a, **k: ([], 0, 1), fetcher=lambda base_url, token, ano, cpf: [ { "cpf": cpf, "turno": "Noturno", "referenceYear": "2025/2", "course": "Bacharelado em Administração", "course_code": None, "ano": 2025, "carga_horaria_acumulada": 774, } ], ) self.assertEqual(Vinculo.objects.count(), 0) self.assertEqual(len(result.errors or []), 1) self.assertIn("Codigo MEC do curso obrigatorio", result.errors[0].message) def test_import_vinculos_ingressantes_from_gennera_tracks_only_successful_cpfs( self, ) -> None: self.create_gennera_pessoa("Aluno Ok", "02542618330") self.create_gennera_pessoa("Aluno Sem Curso", "11122233344") Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) def fetcher(base_url, token, ano, page, page_size): rows = [ { "cpf": "02542618330", "turno": "Noite", "referenceYear": "2026/1", "course": "Pedagogia", "course_code": "123", "ano": 2026, "carga_horaria_acumulada": 800, }, { "cpf": "11122233344", "turno": "Noite", "referenceYear": "2026/1", "course": "Curso Inexistente", "course_code": None, "ano": 2026, "carga_horaria_acumulada": 100, }, { "cpf": "99988877766", "turno": "Noite", "referenceYear": "2026/1", "course": "Pedagogia", "course_code": "123", "ano": 2026, "carga_horaria_acumulada": 100, }, ] return rows, len(rows), 1 result = import_vinculos_ingressantes_from_gennera( ano=2026, base_url="http://api.example.test", token="token", fetcher=fetcher, ) self.assertEqual(result.cpfs_resolvidos, {"02542618330"}) self.assertEqual(result.pessoas_nao_encontradas, 1) error_identifiers = {error.identifier for error in result.errors} self.assertIn("99988877766", error_identifiers) self.assertIn("11122233344", error_identifiers) def test_import_vinculos_from_gennera_skips_per_cpf_refetch_for_bulk_resolved_cpf( self, ) -> None: self.create_gennera_pessoa("Aluno Bulk", "02542618330") self.create_gennera_pessoa("Aluno Per Cpf", "11122233344") Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) def ingressantes_fetcher(base_url, token, ano, page, page_size): rows = [ { "cpf": "02542618330", "turno": "Noite", "referenceYear": "2026/1", "course": "Pedagogia", "course_code": "123", "ano": 2026, "carga_horaria_acumulada": 800, } ] return rows, len(rows), 1 requested_cpfs = [] def fetcher(base_url, token, ano, cpf): requested_cpfs.append(cpf) return [] import_vinculos_from_gennera( ano=2026, base_url="http://api.example.test", token="token", ingressantes_fetcher=ingressantes_fetcher, fetcher=fetcher, ) self.assertNotIn("02542618330", requested_cpfs) self.assertIn("11122233344", requested_cpfs) def test_import_vinculos_from_gennera_retries_bulk_cpf_that_failed_ingressantes_step( self, ) -> None: self.create_gennera_pessoa("Aluno Falha Bulk", "02542618330") def ingressantes_fetcher(base_url, token, ano, page, page_size): rows = [ { "cpf": "02542618330", "turno": "Noite", "referenceYear": "2026/1", "course": "Curso Inexistente", "course_code": None, "ano": 2026, "carga_horaria_acumulada": 100, } ] return rows, len(rows), 1 requested_cpfs = [] def fetcher(base_url, token, ano, cpf): requested_cpfs.append(cpf) return [] import_vinculos_from_gennera( ano=2026, base_url="http://api.example.test", token="token", ingressantes_fetcher=ingressantes_fetcher, fetcher=fetcher, ) self.assertIn("02542618330", requested_cpfs) def test_import_vinculos_from_gennera_keeps_existing_formado(self) -> None: pessoa = self.create_gennera_pessoa("Aluno Formado", "02542618330") curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) Vinculo.objects.create( pessoa=pessoa, ano_censo_id=2026, periodo_referencia=Vinculo.PeriodoReferencia.PRIMEIRO_SEMESTRE, curso=curso, situacao=Vinculo.Situacao.FORMADO, semestre_ingresso="012026", ingresso_vestibular=False, ingresso_enem=False, ingresso_avaliacao_seriada=False, ingresso_selecao_simplificada=False, ingresso_egresso_bi_li=False, ingresso_pec_g=False, ingresso_transferencia_ex_officio=False, ingresso_decisao_judicial=False, ingresso_vagas_remanescentes=False, ingresso_programas_especiais=False, apoio_social=False, atividade_extracurricular=False, carga_horaria_total_aluno=3200, carga_horaria_integralizada=3200, ingressou_acao_afirmativa=False, ) import_vinculos_from_gennera( ano=2026, base_url="http://api.example.test", token="token", ingressantes_fetcher=lambda *a, **k: ([], 0, 1), fetcher=lambda base_url, token, ano, cpf: [ { "cpf": cpf, "turno": "Noite", "referenceYear": "2026/1", "course": "Pedagogia", "course_code": "123", "ano": 2026, "carga_horaria_acumulada": 1600, } ], ) vinculo = Vinculo.objects.get(pessoa=pessoa, curso=curso, ano_censo=2026) self.assertEqual(vinculo.situacao, Vinculo.Situacao.FORMADO) self.assertEqual(vinculo.carga_horaria_integralizada, 3200) def test_import_carga_horaria_from_gennera_skips_formado_vinculo(self) -> None: pessoa = self.create_gennera_pessoa("Aluno Formado", "02542618330") curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) vinculo = Vinculo.objects.create( pessoa=pessoa, ano_censo_id=2026, matricula="MAT-1", periodo_referencia=Vinculo.PeriodoReferencia.PRIMEIRO_SEMESTRE, curso=curso, situacao=Vinculo.Situacao.FORMADO, semestre_ingresso="012026", ingresso_vestibular=False, ingresso_enem=False, ingresso_avaliacao_seriada=False, ingresso_selecao_simplificada=False, ingresso_egresso_bi_li=False, ingresso_pec_g=False, ingresso_transferencia_ex_officio=False, ingresso_decisao_judicial=False, ingresso_vagas_remanescentes=False, ingresso_programas_especiais=False, apoio_social=False, atividade_extracurricular=False, carga_horaria_total_aluno=3200, carga_horaria_integralizada=3200, ingressou_acao_afirmativa=False, ) result = import_carga_horaria_from_gennera( base_url="http://api.example.test", token="token", fetcher=lambda base_url, token, matricula, page_size: [ {"ano": 2026, "carga_horaria": 999} ], ) vinculo.refresh_from_db() self.assertEqual(vinculo.carga_horaria_integralizada, 3200) self.assertEqual(result.vinculos_atualizados, 0) def test_import_vinculos_from_gennera_sets_desvinculado_when_no_remote_vinculo(self) -> None: pessoa = self.create_gennera_pessoa("Aluno Sem Remoto", "02542618330") curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) Vinculo.objects.create( pessoa=pessoa, ano_censo_id=2026, periodo_referencia=Vinculo.PeriodoReferencia.SEGUNDO_SEMESTRE, curso=curso, situacao=Vinculo.Situacao.CURSANDO, semestre_ingresso="022026", ingresso_vestibular=False, ingresso_enem=False, ingresso_avaliacao_seriada=False, ingresso_selecao_simplificada=False, ingresso_egresso_bi_li=False, ingresso_pec_g=False, ingresso_transferencia_ex_officio=False, ingresso_decisao_judicial=False, ingresso_vagas_remanescentes=False, ingresso_programas_especiais=False, apoio_social=False, atividade_extracurricular=False, carga_horaria_total_aluno=3200, carga_horaria_integralizada=1600, ingressou_acao_afirmativa=False, ) result = import_vinculos_from_gennera( ano=2026, base_url="http://api.example.test", token="token", ingressantes_fetcher=lambda *a, **k: ([], 0, 1), fetcher=lambda base_url, token, ano, cpf: [], ) vinculo = Vinculo.objects.get(pessoa=pessoa, curso=curso, ano_censo=2026) self.assertEqual(result.pessoas_without_vinculo, 1) self.assertEqual(vinculo.situacao, Vinculo.Situacao.DESVINCULADO) def test_import_vinculos_from_gennera_ignores_remote_vinculo_from_other_year(self) -> None: pessoa = self.create_gennera_pessoa("Aluno Outro Ano", "02542618330") curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) Vinculo.objects.create( pessoa=pessoa, ano_censo_id=2026, periodo_referencia=Vinculo.PeriodoReferencia.SEGUNDO_SEMESTRE, curso=curso, situacao=Vinculo.Situacao.CURSANDO, semestre_ingresso="022026", ingresso_vestibular=False, ingresso_enem=False, ingresso_avaliacao_seriada=False, ingresso_selecao_simplificada=False, ingresso_egresso_bi_li=False, ingresso_pec_g=False, ingresso_transferencia_ex_officio=False, ingresso_decisao_judicial=False, ingresso_vagas_remanescentes=False, ingresso_programas_especiais=False, apoio_social=False, atividade_extracurricular=False, carga_horaria_total_aluno=3200, carga_horaria_integralizada=1600, ingressou_acao_afirmativa=False, ) result = import_vinculos_from_gennera( ano=2026, base_url="http://api.example.test", token="token", ingressantes_fetcher=lambda *a, **k: ([], 0, 1), fetcher=lambda base_url, token, ano, cpf: [ { "cpf": cpf, "turno": "Noite", "referenceYear": "2025/2", "course": "Pedagogia", "course_code": "123", "ano": 2025, "carga_horaria_acumulada": 3200, } ], ) vinculo = Vinculo.objects.get(pessoa=pessoa, curso=curso, ano_censo=2026) self.assertEqual(result.pessoas_without_vinculo, 1) self.assertEqual(vinculo.situacao, Vinculo.Situacao.DESVINCULADO) def test_import_vinculos_from_gennera_does_not_overwrite_manually_edited_vinculo( self, ) -> None: pessoa = self.create_gennera_pessoa("Aluno Editado Manualmente", "02542618330") curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) Vinculo.objects.create( pessoa=pessoa, ano_censo_id=2026, curso=curso, situacao=Vinculo.Situacao.TRANSFERENCIA_INTERNA, semestre_ingresso="012026", atualizado_manualmente=True, ingresso_vestibular=False, ingresso_enem=False, ingresso_avaliacao_seriada=False, ingresso_selecao_simplificada=False, ingresso_egresso_bi_li=False, ingresso_pec_g=False, ingresso_transferencia_ex_officio=False, ingresso_decisao_judicial=False, ingresso_vagas_remanescentes=False, ingresso_programas_especiais=False, apoio_social=False, atividade_extracurricular=False, carga_horaria_total_aluno=3200, carga_horaria_integralizada=1600, ingressou_acao_afirmativa=False, ) import_vinculos_from_gennera( ano=2026, base_url="http://api.example.test", token="token", ingressantes_fetcher=lambda *a, **k: ([], 0, 1), fetcher=lambda base_url, token, ano, cpf: [ { "cpf": cpf, "turno": "Noite", "referenceYear": "2026/2", "course": "Pedagogia", "course_code": "123", "ano": 2026, "carga_horaria_acumulada": 3200, } ], ) vinculo = Vinculo.objects.get(pessoa=pessoa, curso=curso, ano_censo=2026) self.assertEqual(vinculo.situacao, Vinculo.Situacao.TRANSFERENCIA_INTERNA) self.assertEqual(vinculo.carga_horaria_integralizada, 1600) def test_import_vinculos_from_gennera_desvinculado_skips_manually_edited(self) -> None: pessoa = self.create_gennera_pessoa("Aluno Sem Remoto Manual", "02542618330") curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) Vinculo.objects.create( pessoa=pessoa, ano_censo_id=2026, curso=curso, situacao=Vinculo.Situacao.CURSANDO, semestre_ingresso="012026", atualizado_manualmente=True, ingresso_vestibular=False, ingresso_enem=False, ingresso_avaliacao_seriada=False, ingresso_selecao_simplificada=False, ingresso_egresso_bi_li=False, ingresso_pec_g=False, ingresso_transferencia_ex_officio=False, ingresso_decisao_judicial=False, ingresso_vagas_remanescentes=False, ingresso_programas_especiais=False, apoio_social=False, atividade_extracurricular=False, carga_horaria_total_aluno=3200, carga_horaria_integralizada=1600, ingressou_acao_afirmativa=False, ) import_vinculos_from_gennera( ano=2026, base_url="http://api.example.test", token="token", ingressantes_fetcher=lambda *a, **k: ([], 0, 1), fetcher=lambda base_url, token, ano, cpf: [], ) vinculo = Vinculo.objects.get(pessoa=pessoa, curso=curso, ano_censo=2026) self.assertEqual(vinculo.situacao, Vinculo.Situacao.CURSANDO) def test_import_vinculos_from_gennera_fixes_situacao_nao_informada(self) -> None: pessoa = self.create_gennera_pessoa("Aluno Nao Informado", "02542618330") curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) # Outro curso com dados remotos, so a API nao "zera" o pessoa via # mark_person_vinculos_as_desvinculado (que so roda quando a API nao # retorna NENHUM vinculo pra pessoa) -- assim o vinculo NAO_INFORMADA # abaixo fica intocado pelo loop principal e so a nova etapa final o pega. Curso.objects.create( codigo_mec=999, descricao="Direito", carga_horaria_total=3600, ) vinculo = Vinculo.objects.create( pessoa=pessoa, ano_censo_id=2026, curso=curso, matricula="MAT-1", situacao=Vinculo.Situacao.NAO_INFORMADA, semestre_ingresso="012026", ingresso_vestibular=False, ingresso_enem=False, ingresso_avaliacao_seriada=False, ingresso_selecao_simplificada=False, ingresso_egresso_bi_li=False, ingresso_pec_g=False, ingresso_transferencia_ex_officio=False, ingresso_decisao_judicial=False, ingresso_vagas_remanescentes=False, ingresso_programas_especiais=False, apoio_social=False, atividade_extracurricular=False, carga_horaria_total_aluno=3200, carga_horaria_integralizada=0, ingressou_acao_afirmativa=False, ) with patch("core.importers.fetch_gennera_carga_horaria") as fetch_mock: fetch_mock.return_value = [{"ano": 2026, "carga_horaria": 1800}] result = import_vinculos_from_gennera( ano=2026, base_url="http://api.example.test", token="token", ingressantes_fetcher=lambda *a, **k: ([], 0, 1), fetcher=lambda base_url, token, ano, cpf: [ { "cpf": cpf, "turno": "Noite", "referenceYear": "2026/1", "course": "Direito", "course_code": "999", "ano": 2026, "carga_horaria_acumulada": 100, } ], ) vinculo.refresh_from_db() self.assertEqual(vinculo.situacao, Vinculo.Situacao.DESVINCULADO) self.assertEqual(vinculo.carga_horaria_integralizada, 1800) self.assertEqual(result.situacao_nao_informada_corrigidos, 1) fetch_mock.assert_called_once_with("http://api.example.test", "token", "MAT-1") def test_import_vinculos_from_gennera_skips_manually_edited_nao_informada(self) -> None: pessoa = self.create_gennera_pessoa("Aluno Nao Informado Manual", "02542618330") curso = Curso.objects.create( codigo_mec=123, descricao="Pedagogia", carga_horaria_total=3200, ) vinculo = Vinculo.objects.create( pessoa=pessoa, ano_censo_id=2026, curso=curso, matricula="MAT-1", situacao=Vinculo.Situacao.NAO_INFORMADA, semestre_ingresso="012026", atualizado_manualmente=True, ingresso_vestibular=False, ingresso_enem=False, ingresso_avaliacao_seriada=False, ingresso_selecao_simplificada=False, ingresso_egresso_bi_li=False, ingresso_pec_g=False, ingresso_transferencia_ex_officio=False, ingresso_decisao_judicial=False, ingresso_vagas_remanescentes=False, ingresso_programas_especiais=False, apoio_social=False, atividade_extracurricular=False, carga_horaria_total_aluno=3200, carga_horaria_integralizada=0, ingressou_acao_afirmativa=False, ) with patch("core.importers.fetch_gennera_carga_horaria") as fetch_mock: result = import_vinculos_from_gennera( ano=2026, base_url="http://api.example.test", token="token", ingressantes_fetcher=lambda *a, **k: ([], 0, 1), fetcher=lambda base_url, token, ano, cpf: [], ) vinculo.refresh_from_db() self.assertEqual(vinculo.situacao, Vinculo.Situacao.NAO_INFORMADA) self.assertEqual(vinculo.carga_horaria_integralizada, 0) self.assertEqual(result.situacao_nao_informada_corrigidos, 0) fetch_mock.assert_not_called() def create_gennera_pessoa(self, nome: str, cpf: str) -> Pessoa: return Pessoa.objects.create( nome=nome, cpf=cpf, data_nascimento=date(2000, 1, 1), cor_raca=Pessoa.CorRaca.PARDA, nacionalidade=Pessoa.Nacionalidade.BRASILEIRA_NATA, pais_origem=self.pais, aluno_com_deficiencia=Pessoa.SimNaoNaoDispoe.NAO, tipo_escola_ensino_medio=Pessoa.TipoEscolaEnsinoMedio.PUBLICA, ) def test_task_pages_are_in_menu(self) -> None: response = self.client.get(reverse("home")) self.assertContains(response, reverse("task_page", args=["pessoas-ingressantes"])) self.assertContains(response, reverse("task_page", args=["vinculos-censup"])) self.assertContains(response, reverse("task_page", args=["carga-horaria-censup"])) def test_start_task_view_dispatches_pessoas_ingressantes_task(self) -> None: with patch( "core.views.import_pessoas_ingressantes_task.delay" ) as delay_mock: delay_mock.return_value.id = "task-123" response = self.client.post( reverse("start_task", args=["pessoas-ingressantes"]), {"primeiro_ano": "2026"}, ) self.assertEqual(response.status_code, 200) delay_mock.assert_called_once_with(primeiro_ano=2026, page_size=100) self.assertEqual(response.json(), {"task_id": "task-123", "already_running": False}) def test_start_task_blocks_second_start_while_running(self) -> None: with patch("core.views.import_carga_horaria_censup_task.delay") as delay_mock: delay_mock.return_value.id = "task-abc" first = self.client.post(reverse("start_task", args=["carga-horaria-censup"])) with patch("core.views.AsyncResult") as async_result_cls: async_result_cls.return_value.state = "PROGRESS" second = self.client.post(reverse("start_task", args=["carga-horaria-censup"])) self.assertEqual(first.json()["task_id"], "task-abc") self.assertEqual(second.json(), {"task_id": "task-abc", "already_running": True})