feat: Refactor database models and update API endpoints for Aluno and Curso; add test configurations

Author: Vitinho163

database.py

@@ -1,6 +1,5 @@
 from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.orm import sessionmaker, declarative_base
 import os
 
 # Caminho para o arquivo SQLite (pode ser ajustado conforme necessário)
@@ -12,13 +11,11 @@
 )
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
-Base = declarative_base()
+Base = declarative_base() # type: ignore
 
 def get_db():
     db = SessionLocal()
     try:
         yield db
     finally:
         db.close()
-
-

escola.db

@@ -0,0 +1,2 @@
+[pytest]
+pythonpath = .

pytest.ini

@@ -0,0 +1,2 @@
+pytest
+httpx

requirements-dev.txt

@@ -1,7 +1,7 @@
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from typing import List, Union
-from schemas import Aluno
+from schemas import Aluno, AlunoBase
 from models import Aluno as ModelAluno
 from database import get_db
 
@@ -14,7 +14,7 @@ def read_alunos(db: Session = Depends(get_db)):
 
     """
     alunos = db.query(ModelAluno).all()
-    return [Aluno.from_orm(aluno) for aluno in alunos]
+    return [Aluno.model_validate(aluno) for aluno in alunos]
 
 @alunos_router.get("/alunos/{aluno_id}", response_model=Aluno)
 def read_aluno(aluno_id: int, db: Session = Depends(get_db)):
@@ -30,24 +30,24 @@ def read_aluno(aluno_id: int, db: Session = Depends(get_db)):
     db_aluno = db.query(ModelAluno).filter(ModelAluno.id == aluno_id).first()
     if db_aluno is None:
         raise HTTPException(status_code=404, detail="Aluno não encontrado")
-    return Aluno.from_orm(db_aluno)
+    return Aluno.model_validate(db_aluno)
 
 @alunos_router.post("/alunos", response_model=Aluno)
-def create_aluno(aluno: Aluno, db: Session = Depends(get_db)):
+def create_aluno(aluno: AlunoBase, db: Session = Depends(get_db)):
     """
     Cria um novo aluno com os dados fornecidos.
 
     Args:
-        aluno: Dados do aluno a ser criado.
+        aluno: Dados do aluno (sem id) a ser criado.
 
     Returns:
         Aluno: aluno criado.
     """ 
-    db_aluno = ModelAluno(**aluno.dict(exclude={"id"})) 
+    db_aluno = ModelAluno(**aluno.model_dump()) 
     db.add(db_aluno)
     db.commit()
     db.refresh(db_aluno)
-    return Aluno.from_orm(db_aluno)
+    return Aluno.model_validate(db_aluno)
 
 @alunos_router.put("/alunos/{aluno_id}", response_model=Aluno)
 def update_aluno(aluno_id: int, aluno: Aluno, db: Session = Depends(get_db)):
@@ -68,12 +68,12 @@ def update_aluno(aluno_id: int, aluno: Aluno, db: Session = Depends(get_db)):
     if db_aluno is None:
         raise HTTPException(status_code=404, detail="Aluno não encontrado")
 
-    for key, value in aluno.dict(exclude_unset=True).items():
+    for key, value in aluno.model_dump(exclude_unset=True).items():
         setattr(db_aluno, key, value)
 
     db.commit()
     db.refresh(db_aluno)
-    return Aluno.from_orm(db_aluno)
+    return Aluno.model_validate(db_aluno)
 
 @alunos_router.delete("/alunos/{aluno_id}", response_model=Aluno)
 def delete_aluno(aluno_id: int, db: Session = Depends(get_db)):
@@ -93,7 +93,7 @@ def delete_aluno(aluno_id: int, db: Session = Depends(get_db)):
     if db_aluno is None:
         raise HTTPException(status_code=404, detail="Aluno não encontrado")
 
-    aluno_deletado = Aluno.from_orm(db_aluno)
+    aluno_deletado = Aluno.model_validate(db_aluno)
 
     db.delete(db_aluno)
     db.commit()
@@ -120,9 +120,9 @@ def read_aluno_por_nome(nome_aluno: str, db: Session = Depends(get_db)):
         raise HTTPException(status_code=404, detail="Nenhum aluno encontrado com esse nome")
 
     if len(db_alunos) == 1:  # Retorna um único Aluno se houver apenas uma correspondência
-        return Aluno.from_orm(db_alunos[0])
+        return Aluno.model_validate(db_alunos[0])
 
-    return [Aluno.from_orm(aluno) for aluno in db_alunos]
+    return [Aluno.model_validate(aluno) for aluno in db_alunos]
 
 @alunos_router.get("/alunos/email/{email_aluno}", response_model=Aluno)
 def read_aluno_por_email(email_aluno: str, db: Session = Depends(get_db)):
@@ -143,4 +143,4 @@ def read_aluno_por_email(email_aluno: str, db: Session = Depends(get_db)):
     if db_aluno is None:
         raise HTTPException(status_code=404, detail="Nenhum aluno encontrado com esse email")
 
-    return Aluno.from_orm(db_aluno)
+    return Aluno.model_validate(db_aluno)

routers/alunos.py

@@ -10,23 +10,23 @@
 @cursos_router.get("/cursos", response_model=List[Curso])
 def read_cursos(db: Session = Depends(get_db)):
     cursos = db.query(ModelCurso).all()
-    return [Curso.from_orm(curso) for curso in cursos]
+    return [Curso.model_validate(curso) for curso in cursos]
 
 @cursos_router.post("/cursos", response_model=Curso)
 def create_curso(curso: Curso, db: Session = Depends(get_db)):
-    db_curso = ModelCurso(**curso.dict(exclude={"id"}))
+    db_curso = ModelCurso(**curso.model_dump(exclude={"id"}))
     db.add(db_curso)
     db.commit()
     db.refresh(db_curso)
-    return Curso.from_orm(db_curso)
+    return Curso.model_validate(db_curso)
 
 @cursos_router.put("/cursos/{codigo_curso}", response_model=Curso)
 def update_curso(codigo_curso: str, curso: Curso, db: Session = Depends(get_db)):
     db_curso = db.query(ModelCurso).filter(ModelCurso.codigo == codigo_curso).first()
     if db_curso is None:
         raise HTTPException(status_code=404, detail="Curso não encontrado")
 
-    for key, value in curso.dict(exclude_unset=True, exclude={"id"}).items():
+    for key, value in curso.model_dump(exclude_unset=True, exclude={"id"}).items():
         setattr(db_curso, key, value)
 
     db.commit()
@@ -38,7 +38,7 @@ def read_curso_por_codigo(codigo_curso: str, db: Session = Depends(get_db)):
     db_curso = db.query(ModelCurso).filter(ModelCurso.codigo == codigo_curso).first()
     if db_curso is None:
         raise HTTPException(status_code=404, detail="Nenhum curso encontrado com esse código")
-    return Curso.from_orm(db_curso)
+    return Curso.model_validate(db_curso)
 
 
 # Não buscar um curso pelo ID nem deletar em nenhuma hipótese

routers/cursos.py

@@ -16,11 +16,11 @@ def create_matricula(matricula: Matricula, db: Session = Depends(get_db)):
     if db_aluno is None or db_curso is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Aluno ou Curso não encontrado")
 
-    db_matricula = ModelMatricula(**matricula.dict())
+    db_matricula = ModelMatricula(**matricula.model_dump())
     db.add(db_matricula)
     db.commit()
     db.refresh(db_matricula)
-    return Matricula.from_orm(db_matricula)
+    return Matricula.model_validate(db_matricula)
 
 
 

routers/matriculas.py

@@ -1,32 +1,29 @@
-from pydantic import BaseModel, EmailStr
+from pydantic import BaseModel, EmailStr, ConfigDict
 from typing import List
 
 class Matricula(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
     aluno_id: int
     curso_id: int
 
-    class Config:
-        from_attributes = True
-        from_attributes = True
-
 Matriculas = List[Matricula]
 
-class Aluno(BaseModel):
+class AlunoBase(BaseModel):
     nome: str
     email: EmailStr
     telefone: str
 
-    class Config:
-        from_attributes = True
+class Aluno(AlunoBase):
+    model_config = ConfigDict(from_attributes=True)
+    id: int
 
 Alunos = List[Aluno]
 
 class Curso(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
     nome: str
     codigo: str
     descricao: str
-
-    class Config:
-        from_attributes = True
-
 Cursos = List[Curso]

schemas.py

@@ -0,0 +1,63 @@
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+import os
+
+from app import app
+from database import Base, get_db
+
+# --- Configuração do Banco de Dados de Teste ---
+TEST_DATABASE_URL = "sqlite:///./test_escola.db"
+
+engine = create_engine(
+    TEST_DATABASE_URL, connect_args={"check_same_thread": False}
+)
+TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# --- Fixture para gerenciar a criação e destruição do banco de dados ---
+@pytest.fixture(scope="session")
+def setup_database():
+    """
+    Cria as tabelas do banco de dados de teste antes de todos os testes
+    e apaga o arquivo do banco de dados depois que todos os testes terminam.
+    """
+    # Garante que o banco de dados de teste antigo seja removido, se existir
+    if os.path.exists("./test_escola.db"):
+        os.remove("./test_escola.db")
+        
+    # Cria todas as tabelas
+    Base.metadata.create_all(bind=engine)
+    
+    yield  # Aqui é onde os testes são executados
+    
+    # --- Teardown ---
+    # Primeiro, garantimos que todas as conexões com o banco de dados sejam fechadas.
+    # O objeto 'engine' gerencia um pool de conexões, e precisamos descartá-lo para liberar o arquivo.
+    engine.dispose()
+
+    # Apaga o banco de dados de teste após a conclusão de todos os testes
+    if os.path.exists("./test_escola.db"):
+        os.remove("./test_escola.db")
+
+# --- Fixture para fornecer um cliente de API com uma sessão de banco de dados isolada ---
+@pytest.fixture(scope="function")
+def client(setup_database):
+    """
+    Fornece um TestClient que usa uma sessão transacional para cada teste.
+    Isso garante que cada teste seja executado de forma isolada.
+    """
+    connection = engine.connect()
+    transaction = connection.begin()
+    db_session = TestingSessionLocal(bind=connection)
+
+    # Sobrescreve a dependência get_db para usar a sessão de teste
+    app.dependency_overrides[get_db] = lambda: db_session
+
+    yield TestClient(app)
+
+    # Desfaz a transação, limpando o banco de dados, e fecha a conexão
+    db_session.close()
+    transaction.rollback()
+    connection.close()
+    app.dependency_overrides.clear()

tests/conftest.py

@@ -0,0 +1,52 @@
+from fastapi.testclient import TestClient
+
+def test_read_main(client: TestClient):
+    """Testa se a rota raiz da documentação está acessível."""
+    response = client.get("/docs")
+    assert response.status_code == 200
+
+def test_create_and_read_aluno(client: TestClient):
+    """Testa a criação de um aluno e a subsequente leitura pelo ID."""
+    novo_aluno_data = {
+        "nome": "Aluno Teste E2E",
+        "email": "teste.e2e@example.com",
+        "telefone": "11987654321"
+    }
+
+    # 1. Criar o aluno (POST)
+    response_create = client.post("/alunos", json=novo_aluno_data)
+    assert response_create.status_code == 200 # Idealmente, seria 201 (Created)
+    data = response_create.json()
+    assert data["nome"] == novo_aluno_data["nome"]
+    assert data["email"] == novo_aluno_data["email"]
+    assert "id" in data
+    aluno_id = data["id"]
+
+    # 2. Ler o aluno recém-criado pelo ID retornado
+    response_read = client.get(f"/alunos/{aluno_id}")
+    assert response_read.status_code == 200
+    read_data = response_read.json()
+    assert read_data["nome"] == novo_aluno_data["nome"]
+    assert read_data["email"] == novo_aluno_data["email"]
+    assert read_data["id"] == aluno_id
+
+def test_read_alunos(client: TestClient):
+    """Testa o endpoint de listagem de alunos, garantindo que ele retorne os dados criados no teste."""
+    # Como cada teste é isolado, o banco de dados começa vazio.
+    # Primeiro, criamos alguns dados para o teste.
+    client.post("/alunos", json={"nome": "Aluno 1", "email": "aluno1@test.com", "telefone": "111"})
+    client.post("/alunos", json={"nome": "Aluno 2", "email": "aluno2@test.com", "telefone": "222"})
+
+    response = client.get("/alunos")
+    assert response.status_code == 200
+    data = response.json()
+    assert isinstance(data, list)
+    assert len(data) == 2
+    assert data[0]["nome"] == "Aluno 1"
+    assert data[1]["nome"] == "Aluno 2"
+
+def test_read_non_existent_aluno(client: TestClient):
+    """Testa a busca por um aluno que não existe em um banco de dados vazio."""
+    response = client.get("/alunos/999999")
+    assert response.status_code == 404
+    assert response.json() == {"detail": "Aluno não encontrado"}