def test_aluno_deve_ser_capaz_de_listar_as_materias_de_seu_curso(
self, cria_curso_com_materias):
curso = cria_curso_com_materias
expected = [materia_nome_1, materia_nome_2, materia_nome_3]
aluno = Aluno(aluno_nome_1).inscreve_curso(curso)
actual = aluno.lista_materias()
assert actual == expected
def test_aluno_nao_pode_increver_curso_sem_materias(self):
curso = Curso(curso_nome_1)
aluno = Aluno(aluno_nome_1)
with raises(
Exception,
match="Número mínimo que matérias é três. Adicione mais 3"):
aluno.inscreve_curso(curso)
def _tuple_para_objeto(self, linha):
(id_, aluno_id, curso_id) = linha
aluno = Aluno()
aluno.define_id(aluno_id)
curso = Curso()
curso.define_id(curso_id)
return aluno, curso
def test_aluno_deve_ser_capaz_de_listar_materias_faltantes(
self, cria_curso_com_materias):
aluno = Aluno(aluno_nome_1).inscreve_curso(cria_curso_com_materias)
materias = {materia_nome_2: 7, materia_nome_3: 9}
expected = [materia_nome_1]
aluno.atualiza_materias_cursadas(materias)
actual = aluno.lista_materias_faltantes()
assert actual == expected
def test_aluno_pode_pegar_lista_materias_cursadas(self,
cria_curso_com_materias):
curso = cria_curso_com_materias
materias = {materia_nome_2: 7, materia_nome_3: 9}
expected = materias
aluno = Aluno(aluno_nome_1).inscreve_curso(curso)
aluno.atualiza_materias_cursadas(materias)
actual = aluno.lista_materias_cursadas()
assert actual == expected
def __init__(self):
self.store = Store()
self.aluno = Aluno()
self.grupo = Grupo()
self.atividade = Atividade()
self.evento = Evento()
self.tarefa = Tarefa()
self.apresentacao = Apresentacao()
def test_coordenador_curso_2_nao_pode_listar_alunos_curso_1(self):
expected = {"alunos": []}
aluno = Aluno("maria")
curso = Curso("fisica")
curso.atualiza_materias(Materia("optica"))
curso.atualiza_materias(Materia("mecanica"))
curso.atualiza_materias(Materia("eletrica"))
coordenador_2 = CoordenadorCurso(curso)
aluno.inscreve_curso(self.curso)
actual = coordenador_2.listar_detalhe_alunos()
assert actual == expected
def test_define_situacao_retorna_aluno_com_situacao_atualizada(
self, cria_curso_com_materias):
materias = {materia_nome_1: 8, materia_nome_2: 8, materia_nome_3: 8}
expected = "aprovado"
aluno = Aluno(aluno_nome_1)
aluno.inscreve_curso(cria_curso_com_materias)
aluno.atualiza_materias_cursadas(materias)
aluno.define_situacao(Situacao.aprovado.value)
actual = aluno.pega_situacao()
assert actual == expected
def _tuple_para_aluno(self, linha):
(id_, nome, cr, situacao) = linha
aluno = Aluno(nome)
aluno.define_id(id_)
aluno.define_cr(cr)
aluno.define_situacao(situacao)
return aluno
def _atualiza_aluno(argumentos):
aluno_id = "--aluno-id"
situacao = "--situacao"
nome = "--nome"
materia = "--materia"
nota = "--nota"
aluno = Aluno()
try:
if aluno_id in argumentos:
id_ = _pega_valor(argumentos, aluno_id)
Controller(aluno, bd).atualiza(id_)
if nome in argumentos:
nome_ = _pega_valor(argumentos, nome)
aluno.define_nome(nome_)
Controller(aluno, bd).atualiza(id_)
if situacao in argumentos:
situacao_ = _pega_valor(argumentos, situacao)
aluno.define_situacao(situacao_)
Controller(aluno, bd).atualiza(id_)
if materia in argumentos and nota in argumentos:
materia_ = _pega_valor(argumentos, materia)
nota_ = _pega_valor(argumentos, nota)
materias = {materia_: nota_}
aluno.atualiza_materias_cursadas(materias)
Controller(aluno, bd).atualiza(id_)
print(f"Aluno com identificador {id_} atualizado com sucesso.")
except Exception:
raise
def _salva_aluno_banco(self, cria_banco, id, nome, cr, situacao):
aluno = Aluno(nome)
aluno.define_cr(cr)
aluno.define_id(id)
aluno.define_situacao(situacao)
dao = DaoAluno(aluno, cria_banco)
dao.salva()
return aluno, dao
def test_admin_pode_listar_todos_alunos(self):
Aluno(aluno_nome_1)
Aluno(aluno_nome_2)
Aluno(aluno_nome_3)
expected = {
"alunos": [{
"nome": aluno_nome_1
}, {
"nome": aluno_nome_2
}, {
"nome": aluno_nome_3
}]
}
actual = Adminstrador().lista_alunos()
assert actual == expected
def test_situaca_aluno_muda_para__em_curso__apos_inscricao(
self, cria_banco_real):
Controller(Aluno(aluno_nome_1), cria_banco_real).salva()
Controller(Curso(curso_nome_1), cria_banco_real).salva()
expected = "em curso"
parametros = [
"inscreve-aluno-curso", "--aluno-id", self.aluno_id, "--curso-id",
self.curso_id
]
executa_comando(parametros)
InscricaoAlunoCurso(self.aluno_id, self.curso_id)
aluno = Controller(Aluno().define_id(self.aluno_id),
cria_banco_real).pega_registro_por_id(self.aluno_id)
actual = aluno.pega_situacao()
assert actual == expected
def _setup_objetos(self, cria_banco):
controller_aluno = Controller(Aluno(aluno_nome_1), cria_banco)
controller_aluno.salva()
aluno = controller_aluno.pega_registro_por_id(id_=1)
controller_curso = Controller(Curso(curso_nome_1), cria_banco)
controller_curso.salva()
curso = controller_curso.pega_registro_por_id(id_=1)
Controller(InscricaoAlunoCurso(aluno_id=1, curso_id=1),
cria_banco).salva()
controller_materia = Controller(Materia(materia_nome_1), cria_banco)
controller_materia.salva()
materia_1 = controller_materia.pega_registro_por_id(id_=1)
controller_materia = Controller(Materia(materia_nome_1), cria_banco)
controller_materia.salva()
materia_2 = controller_materia.pega_registro_por_id(id_=2)
controller_materia = Controller(Materia(materia_nome_1), cria_banco)
controller_materia.salva()
materia_3 = controller_materia.pega_registro_por_id(id_=3)
Controller(AssociaCursoMateria(curso_id=1, materia_id=1),
cria_banco).salva()
Controller(AssociaCursoMateria(curso_id=1, materia_id=2),
cria_banco).salva()
Controller(AssociaCursoMateria(curso_id=1, materia_id=3),
cria_banco).salva()
controller_coordenador_geral = Controller(CoordenadorGeral(),
cria_banco)
controller_coordenador_geral.salva()
coordenador_geral = controller_coordenador_geral \
.pega_registro_por_id(id_=1)
curso.atualiza_materias(materia_1)
curso.atualiza_materias(materia_2)
curso.atualiza_materias(materia_3)
aluno.inscreve_curso(curso)
return coordenador_geral
def test_aluno_nao_pode_se_inscrever_em_curso_cancelado(
self, cria_curso_cancelado):
curso = cria_curso_cancelado
with pytest.raises(
Exception,
match="O aluno não pode se inscrever em um curso cancelado"):
Aluno(aluno_nome_1).inscreve_curso(curso)
def test_aluno_pode_atualizar_situacao(self, cria_curso_materias_real):
aluno, curso, _ = cria_curso_materias_real
expected = "trancado"
Controller(InscricaoAlunoCurso(aluno, curso), self.bd).salva()
self._atualiza_aluno_por_cli(aluno.pega_id(), situacao=expected)
aluno = Controller(Aluno(), self.bd).pega_registro_por_id(aluno.pega_id())
actual = aluno.pega_situacao()
assert actual == expected
def test_retorna_excecao_quando_curso_id_nao_existe(self, cria_banco_real):
expected = "Curso não encontrado."
Controller(Aluno(None), cria_banco_real).salva()
parametros = [
"inscreve-aluno-curso", "--aluno-id", self.aluno_id, "--curso-id",
self.curso_id
]
actual = executa_comando(parametros)
assert expected in actual
def cria_massa_dados(cria_banco_real):
bd = cria_banco_real
bd.deleta_tabela(cursos)
bd.deleta_tabela(alunos)
aluno_id = Controller(Aluno(aluno_nome_1), bd).salva()
curso_id = Controller(Curso(curso_nome_1), bd).salva()
yield aluno_id, curso_id
bd.deleta_tabela(cursos)
bd.deleta_tabela(alunos)
def test_aluno_pode_atualizar_nome(self, cria_massa_dados):
cria_massa_dados
aluno_id = "1"
nome = aluno_nome_2
expected = nome
self._atualiza_aluno_por_cli(aluno_id, nome)
aluno = Controller(Aluno(), self.bd).pega_registro_por_id(aluno_id)
actual = aluno.pega_nome()
assert actual == expected
def segundo_init(self):
self.store = Store()
self.aluno = Aluno(model=self)
self.grupo = Grupo(model=self)
self.atividade = Atividade(model=self)
self.sobre = Sobre(model=self)
self.apresentacao = Apresentacao(model=self)
def _cria_aluno(argumentos):
nome_parametro = "--nome"
numero_parametros = 4
if nome_parametro in argumentos and len(argumentos) == numero_parametros:
nome = _pega_valor(argumentos, nome_parametro)
aluno = Aluno(nome)
controller = Controller(aluno, bd)
controller.salva()
print(f"Aluno {nome} criado com sucesso.")
else:
raise ListaParametrosInvalida(LISTA_PARAMETROS_INVALIDA)
class Model(object):
def __init__(self):
self.store = Store()
self.aluno = Aluno()
self.grupo = Grupo()
self.atividade = Atividade()
self.evento = Evento()
self.tarefa = Tarefa()
self.apresentacao = Apresentacao()
def iniciar(self):
self.aluno.iniciar(model=self)
self.grupo.iniciar(model=self)
self.atividade.iniciar(model=self)
self.evento.iniciar(model=self)
self.tarefa.iniciar(model=self)
self.apresentacao.iniciar(model=self)
def test_aluno_inscrito_curso_salvo_banco_dados(self, cria_banco_real):
Controller(Aluno(aluno_nome_1), cria_banco_real).salva()
Controller(Curso(curso_nome_1), cria_banco_real).salva()
expected = [tuple((1, self.aluno_id, self.curso_id))]
parametros = [
"inscreve-aluno-curso", "--aluno-id", self.aluno_id, "--curso-id",
self.curso_id
]
executa_comando(parametros)
inscricao = InscricaoAlunoCurso(self.aluno_id, self.curso_id)
actual = Controller(inscricao, cria_banco_real).pega_registros()
assert actual == expected
def test_aluno_pode_ser_inscrito_curso(self, cria_banco_real,
cria_curso_banco_real):
expected = (f"Aluno identificado por {self.aluno_id} inscrito no curso"
f" identificado por {self.curso_id}.")
Controller(Aluno(None), cria_banco_real).salva()
cria_curso_banco_real
parametros = [
"inscreve-aluno-curso", "--aluno-id", self.aluno_id, "--curso-id",
self.curso_id
]
actual = executa_comando(parametros)
assert actual == expected
def test_aluno_so_pode_se_inscrever_um_curso(self,
cria_curso_com_materias):
expected = "O aluno só pode se inscrever apenas em um curso"
curso_1 = cria_curso_com_materias
curso_2 = cria_curso_com_materias
aluno = Aluno(None)
aluno.inscreve_curso(curso_1)
with pytest.raises(Exception, match=expected):
aluno.inscreve_curso(curso_2)
def cria_massa_dados_em_memoria(cria_banco):
Controller(Aluno(aluno_nome_1), cria_banco).salva()
Controller(Curso(curso_nome_1), cria_banco).salva()
Controller(Materia(materia_nome_1), cria_banco).salva()
Controller(Materia(materia_nome_2), cria_banco).salva()
Controller(Materia(materia_nome_3), cria_banco).salva()
Controller(AssociaCursoMateria(curso_id=1, materia_id=1),
cria_banco).salva()
Controller(AssociaCursoMateria(curso_id=2, materia_id=1),
cria_banco).salva()
Controller(AssociaCursoMateria(curso_id=3, materia_id=1),
cria_banco).salva()
Controller(InscricaoAlunoCurso(aluno_id=1, curso_id=1), cria_banco)
yield
cria_banco.deleta_tabela(cursos)
cria_banco.deleta_tabela(alunos)
def test_inscricao_aluno_curso_pode_ser_criado_banco_dados(
self, cria_banco):
id_ = 1
aluno = Aluno(aluno_nome_1).define_id(id_)
DaoAluno(aluno, cria_banco).salva()
curso = Curso(curso_nome_1).define_id(id_)
DaoCurso(curso, cria_banco).salva()
materias = [materia_nome_1, materia_nome_2, materia_nome_3]
for materia in materias:
materia_obj = Materia(materia)
DaoMateria(materia_obj, cria_banco).salva()
associa_curso_materia = AssociaCursoMateria(curso, materia_obj)
DaoAssociaCursoMateria(associa_curso_materia, cria_banco).salva()
expected = [tuple((1, self.aluno_id, self.curso_id))]
dao = DaoInscricao(InscricaoAlunoCurso(aluno, curso), cria_banco)
dao.salva()
actual = dao.pega_tudo()
assert actual == expected
def test_coordenador_geral_lista_detalhes_quando_2_cursos_com_alunos(self):
nome_1 = "joao"
nome_2 = "maria"
expected = {
"alunos": [{
"nome": nome_1,
"coeficiente rendimento": 0,
"materias": {},
"curso": self.curso_1.pega_nome()
}, {
"nome": nome_2,
"coeficiente rendimento": 0,
"materias": {},
"curso": self.curso_2.pega_nome()
}]
}
aluno_1 = Aluno(nome_1)
aluno_2 = Aluno(nome_2)
aluno_1.inscreve_curso(self.curso_1)
aluno_2.inscreve_curso(self.curso_2)
coordenador = CoordenadorGeral()
actual = coordenador.listar_detalhe_alunos()
assert actual == expected
def cria_curso_materias_real(cria_banco_real):
bd = cria_banco_real
bd.deleta_tabela(cursos)
bd.deleta_tabela(alunos)
bd.deleta_tabela(materias)
aluno = Aluno(aluno_nome_1)
aluno = Controller(aluno, bd).salva()
curso = Curso(curso_nome_1)
curso = Controller(curso, bd).salva()
Controller(InscricaoAlunoCurso(aluno, curso), bd).salva()
lista_materias = [materia_nome_1, materia_nome_2, materia_nome_3]
lista_materia_obj = []
for materia in lista_materias:
materia_obj = Materia(materia)
materia_obj = Controller(materia_obj, bd).salva()
lista_materia_obj.append(materia_obj)
Controller(AssociaCursoMateria(curso, materia), bd).salva()
yield aluno, curso, lista_materia_obj
def test_coordenador_geral_lista_detalhes_alunos_quando_um_aluno(self):
nome = "maria"
materias = {"civil": 6}
cr = 6
expected = {
"alunos": [{
"nome": nome,
"materias": materias,
"coeficiente rendimento": cr,
"curso": self.curso_1.pega_nome()
}]
}
aluno = Aluno("maria")
aluno.inscreve_curso(self.curso_1)
aluno.atualiza_materias_cursadas(materias)
coordenador = CoordenadorGeral()
actual = coordenador.listar_detalhe_alunos()
assert actual == expected
