230725e

Author: josechval

apiflaskdemo/__init__.py

@@ -1,15 +1,15 @@
 from apiflask import APIFlask
 from apiflaskdemo.project.models import db, Alumno, User
-from apiflaskdemo.project.blueprints import abc_alumnos
+from apiflaskdemo.project.alumno.blueprints import abc_alumnos
 from apiflaskdemo.project.auth.blueprints import auth_bp
-from sqlalchemy import inspect
 from data.alumnos import data_alumnos as alumnos
 
 def create_app():
     '''Función principal de la aplicación'''
     # Crear el objeto app
     app = APIFlask(__name__)
 
+    
     # Obtener la configuración de la aplicación a partir de settings.py
     app.config.from_pyfile("settings.py")
 
@@ -37,7 +37,7 @@ def create_app():
                 db.session.commit()
 
     # Registra los blueprints con los endpoints
-    app.register_blueprint(abc_alumnos, url_prefix='/api')
+    app.register_blueprint(abc_alumnos, url_prefix='/api/alumno/')
     app.register_blueprint(auth_bp, url_prefix='/auth')
 
     #Regresa la aplicación

apiflaskdemo/project/alumno/__init__.py

@@ -1,51 +1,60 @@
+"""Módulo de gestión de alumnos"""
+
+
 from apiflask import APIBlueprint, abort
 from apiflaskdemo.project.auth import login_required
 from apiflaskdemo.project.models import db, Alumno
 from apiflaskdemo.project.schemas import AlumnoSchema, AlumnoInSchema
-from marshmallow.exceptions import ValidationError
 
-abc_alumnos = APIBlueprint('abc_alumno', __name__)
+abc_alumnos = APIBlueprint('Gestión de alumnos', __name__)
+
 
-@abc_alumnos.get("/alumnos/")
+@abc_alumnos.get("/alumnos")
 @abc_alumnos.output(AlumnoSchema(many=True))
-def vuelca_base():
+def vuelca_base() -> list[Alumno]:
+    """Devuelve todos los alumnos"""
     return Alumno.query.all()
 
-@abc_alumnos.get("/alumno/<int:cuenta>")
+
+@abc_alumnos.get("/<int:cuenta>")
 @abc_alumnos.output(AlumnoSchema)
-def despliega_alumno(cuenta):
+def despliega_alumno(cuenta: int) -> Alumno:
+    """Devuelve un alumno al ingresar su cuenta"""
     return Alumno.query.get_or_404(cuenta)
 
-@abc_alumnos.delete("/alumno/<int:cuenta>")
-@abc_alumnos.output(AlumnoSchema)
+
+@abc_alumnos.delete("/<int:cuenta>")
+@abc_alumnos.output({}, 200)
 @login_required
-def elimina_alumno(cuenta):
+def elimina_alumno(cuenta: int) -> None:
     alumno = Alumno.query.get_or_404(cuenta)
     db.session.delete(alumno)
     db.session.commit()
-    return alumno
-    
-@abc_alumnos.post("/alumno/<int:cuenta>")
+    return None
+
+
+@abc_alumnos.post("/<int:cuenta>")
 @abc_alumnos.output(AlumnoSchema, status_code=201)
 @abc_alumnos.input(AlumnoInSchema)
-def crea_alumno(cuenta, data):
+def crea_alumno(cuenta: int, data: dict) -> Alumno:
     if Alumno.query.filter_by(cuenta=cuenta).first():
         abort(409)
-    else: 
+    else:
         data["cuenta"] = cuenta
         alumno = Alumno(**AlumnoSchema().load(data))
         db.session.add(alumno)
         db.session.commit()
         return alumno, 201
 
-@abc_alumnos.put("/alumno/<int:cuenta>")
+
+@abc_alumnos.put("/<int:cuenta>")
 @abc_alumnos.output(AlumnoSchema)
 @abc_alumnos.input(AlumnoInSchema)
-def sustituye_alumno(cuenta, data):
+def sustituye_alumno(cuenta: int, data: dict) -> Alumno:
     alumno = Alumno.query.get_or_404(cuenta)
     db.session.delete(alumno)
     data["cuenta"] = cuenta
     nuevo_alumno = Alumno(**data)
     db.session.add(nuevo_alumno)
     db.session.commit()
-    return  nuevo_alumno
+    return nuevo_alumno

apiflaskdemo/project/blueprints.py renamed to apiflaskdemo/project/alumno/blueprints.py

@@ -1,10 +1,11 @@
 from functools import wraps
-from flask import g, abort 
+from flask import g, abort
+
 
 def login_required(view):
     @wraps(view)
     def wrapped_view(*args, **kwargs):
         if g.user is None:
             return abort(403)
-        return view(*args,**kwargs)
-    return wrapped_view
+        return view(*args, **kwargs)
+    return wrapped_view

apiflaskdemo/project/auth/__init__.py

@@ -1,19 +1,22 @@
+"""Blueprints for the auth module."""
+
 from apiflaskdemo.project.models import User
 from apiflask import APIBlueprint, abort
-from apiflask.fields import String
 from apiflaskdemo.project.auth.schemas import LoginSchema
 from flask import session, g
 
 auth_bp = APIBlueprint("auth_bp", __name__)
 
+
 @auth_bp.before_app_request
 def user_checkout():
     user_id = session.get("user_id")
     if user_id is None:
-        g.user =None
+        g.user = None
     else:
         g.user = User.query.filter_by(id=user_id).first()
 
+
 @auth_bp.post("/login")
 @auth_bp.input(LoginSchema)
 def login(data):
@@ -25,7 +28,8 @@ def login(data):
     else:
         abort(403)
 
+
 @auth_bp.get("/logout")
 def logout():
     session.clear()
-    return {"msg": "logged out"}
+    return {"msg": "logged out"}

apiflaskdemo/project/auth/blueprints.py

@@ -1,7 +1,9 @@
+"""Schemas for the auth module."""
+
 from apiflask import Schema
 from apiflask.fields import String
 
+
 class LoginSchema(Schema):
     username = String(required=True)
     password = String(required=True)
-    

apiflaskdemo/project/auth/schemas.py

@@ -1,9 +1,14 @@
+"""Módulo de modelos de la aplicación"""
+
 from flask_sqlalchemy import SQLAlchemy
 from flask_login.mixins import UserMixin
 
+# Instancia de SQLAlchemy
 db = SQLAlchemy()
 
+
 class Alumno(UserMixin, db.Model):
+    """Modelo de alumno"""
     __tablename__ = 'alumnos'
     cuenta = db.Column(db.Integer, primary_key=True)
     nombre = db.Column(db.String(50))
@@ -14,11 +19,13 @@ class Alumno(UserMixin, db.Model):
     promedio = db.Column(db.Float)
     al_corriente = db.Column(db.Boolean)
 
+
 class User(UserMixin, db.Model):
+    """Modelo de usuario"""
     __tablename__ = "user"
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     email = db.Column(db.String(255), nullable=False, unique=True)
-    username= db.Column(db.String(25), nullable=False, unique=True)
+    username = db.Column(db.String(25), nullable=False, unique=True)
     password = db.Column(db.String(255))
     active = db.Column(db.Boolean())
     authenticated = db.Column(db.Boolean())

apiflaskdemo/project/models.py

@@ -1,10 +1,19 @@
+"""Esquemas de validación de datos de entrada y salida"""
+
 from apiflask.validators import OneOf, Length, Range
 from apiflask.fields import String, Integer, Float, Boolean
 from apiflask import Schema
 
-carreras = ("Sistemas", "Derecho", "Actuaría", "Arquitectura", "Administración")
+# Lista de carreras válidas
+carreras = ("Sistemas",
+            "Derecho",
+            "Actuaría",
+            "Arquitectura",
+            "Administración")
+
 
 class AlumnoSchema(Schema):
+    """Esquema de salida de alumno"""
     cuenta = Integer(required=True, validate=Range(min=1000000, max=9999999))
     nombre = String(required=True, validate=Length(min=2, max=50))
     primer_apellido = String(required=True, validate=Length(min=2, max=50))
@@ -14,11 +23,13 @@ class AlumnoSchema(Schema):
     promedio = Float(required=True, validate=Range(min=1, max=10))
     al_corriente = Boolean(required=True)
 
+
 class AlumnoInSchema(Schema):
+    """Esquema de entrada de alumno"""
     nombre = String(required=True, validate=Length(min=2, max=50))
     primer_apellido = String(required=True, validate=Length(min=2, max=50))
     segundo_apellido = String(required=False, validate=Length(min=2, max=50))
     carrera = String(required=True, validate=OneOf(carreras))
     semestre = Integer(required=True, validate=Range(min=1, max=50))
     promedio = Float(required=True, validate=Range(min=0, max=10))
-    al_corriente = Boolean(required=True)
+    al_corriente = Boolean(required=True)

apiflaskdemo/project/schemas.py

@@ -1,3 +1,5 @@
+"""Módulo que contiene los tests de los endpoints de la API"""
+
 import pytest
 from app import create_app
 from apiflaskdemo.project.models import db, Alumno
@@ -16,7 +18,7 @@ def client() -> Request:
 
 def test_get_alumnos(client) -> None:
     """Test que comprueba que se pueden obtener los alumnos"""
-    r = client.get('/api/alumnos/')
+    r = client.get('/api/alumno/alumnos')
     print("Validando que se puedan obtener los alumnos...")
     assert r.status_code == 200
     print("Se pueden obtener los alumnos.")
@@ -91,6 +93,7 @@ def test_post_cuenta_duplicada(client):
     print("Validando que se pueda crear un alumno...")
     assert r.status_code == 409
 
+
 def test_put_alumno(client) -> None:
     """Test que comprueba que se puede actualizar un alumno"""
     alumno = {
@@ -119,6 +122,7 @@ def test_login_required(client) -> None:
     print("Validando que se necesite iniciar sesión para eliminar un alumno...")
     assert r.status_code == 403
     print("Se necesita iniciar sesión para eliminar un alumno.")
+    
 
 def test_login(client) -> None:
     """Test que comprueba que se puede iniciar sesión"""
@@ -144,12 +148,11 @@ def test_del_alumno(client) -> None:
     print("Se puede iniciar sesión.")
     r = client.delete(f'/api/alumno/{data_alumnos[0]["cuenta"]}')
     print("Validando que se pueda eliminar un alumno...")
-    assert r.status_code == 200
+    assert r.status_code == 204
     print("Se puede eliminar un alumno.")
-    print("Validando que los datos del alumno eliminado sean correctos...")
-    alumno_response = AlumnoSchema().dump(r.json)
-    assert alumno_response == data_alumnos[0]
-    print("Datos del alumno eliminado son correctos.")
+    print("Validando que el alumno haya sido eliminado...")
+    r = client.get(f'/api/alumno/{data_alumnos[0]["cuenta"]}')
+    assert r.status_code == 404
 
 
 def test_logout(client) -> None: