feat(aura): #52 coverage and tests

- updated pydantic

- created simple test for user model

- used a test database file, in memory doesn't work too well

- modified routing plural naming to singular

.github/workflows/pr-conventional-commits.yml

@@ -13,4 +13,4 @@ jobs:
         with:
           task_types: '["feat","fix","docs","test","ci","refac", 
             "perf","chore","revert"]'
-          add_label: 'false'
+          add_label: 'true'

aura/api/endpoints/activity.py

@@ -23,29 +23,29 @@
 router = APIRouter()
 
 
-@router.post("/activities/", response_model=ActivityInDBBase)
+@router.post("/activity/", response_model=ActivityInDBBase)
 def create_activity_endpoint(
     activity: ActivityCreate, db: Session = Depends(get_db)
 ) -> ActivityInDBBase:
     return create_activity(db, activity)
 
 
-@router.get("/activities/{activity_id}", response_model=ActivityInDBBase)
+@router.get("/activity/{activity_id}", response_model=ActivityInDBBase)
 def read_activity(activity_id: int, db: Session = Depends(get_db)) -> ActivityInDBBase:
     activity = get_activity(db, activity_id)
     if activity is None:
         raise HTTPException(status_code=404, detail="Activity not found")
     return activity
 
 
-@router.get("/activities/", response_model=list[ActivityInDBBase])
+@router.get("/activity/", response_model=list[ActivityInDBBase])
 def read_activities(
     skip: int = 0, limit: int = 10, db: Session = Depends(get_db)
 ) -> list[ActivityInDBBase]:
     return get_activities(db, skip, limit)
 
 
-@router.put("/activities/{activity_id}", response_model=ActivityInDBBase)
+@router.put("/activity/{activity_id}", response_model=ActivityInDBBase)
 def update_activity_endpoint(
     activity_id: int, activity: ActivityUpdate, db: Session = Depends(get_db)
 ) -> ActivityInDBBase:
@@ -55,7 +55,7 @@ def update_activity_endpoint(
     return update_activity(db, activity_id, activity.model_dump())
 
 
-@router.delete("/activities/{activity_id}", response_model=ActivityInDBBase)
+@router.delete("/activity/{activity_id}", response_model=ActivityInDBBase)
 def delete_activity_endpoint(
     activity_id: int, db: Session = Depends(get_db)
 ) -> ActivityInDBBase:

aura/api/endpoints/answer.py

@@ -23,29 +23,29 @@
 router = APIRouter()
 
 
-@router.post("/answers/", response_model=AnswerInDBBase)
+@router.post("/answer/", response_model=AnswerInDBBase)
 def create_answer_endpoint(
     answer: AnswerCreate, db: Session = Depends(get_db)
 ) -> AnswerInDBBase:
     return create_answer(db, answer)
 
 
-@router.get("/answers/{answer_id}", response_model=AnswerInDBBase)
+@router.get("/answer/{answer_id}", response_model=AnswerInDBBase)
 def read_answer(answer_id: int, db: Session = Depends(get_db)) -> AnswerInDBBase:
     answer = get_answer(db, answer_id)
     if answer is None:
         raise HTTPException(status_code=404, detail="Answer not found")
     return answer
 
 
-@router.get("/answers/", response_model=list[AnswerInDBBase])
+@router.get("/answer/", response_model=list[AnswerInDBBase])
 def read_answers(
     skip: int = 0, limit: int = 10, db: Session = Depends(get_db)
 ) -> list[AnswerInDBBase]:
     return get_answers(db, skip, limit)
 
 
-@router.put("/answers/{answer_id}", response_model=AnswerInDBBase)
+@router.put("/answer/{answer_id}", response_model=AnswerInDBBase)
 def update_answer_endpoint(
     answer_id: int, answer: AnswerUpdate, db: Session = Depends(get_db)
 ) -> AnswerInDBBase:
@@ -55,7 +55,7 @@ def update_answer_endpoint(
     return update_answer(db, answer_id, answer.model_dump())
 
 
-@router.delete("/answers/{answer_id}", response_model=AnswerInDBBase)
+@router.delete("/answer/{answer_id}", response_model=AnswerInDBBase)
 def delete_answer_endpoint(
     answer_id: int, db: Session = Depends(get_db)
 ) -> AnswerInDBBase:

aura/api/endpoints/question.py

@@ -23,29 +23,29 @@
 router = APIRouter()
 
 
-@router.post("/questions/", response_model=QuestionInDBBase)
+@router.post("/question/", response_model=QuestionInDBBase)
 def create_question_endpoint(
     question: QuestionCreate, db: Session = Depends(get_db)
 ) -> QuestionInDBBase:
     return create_question(db, question)
 
 
-@router.get("/questions/{question_id}", response_model=QuestionInDBBase)
+@router.get("/question/{question_id}", response_model=QuestionInDBBase)
 def read_question(question_id: int, db: Session = Depends(get_db)) -> QuestionInDBBase:
     question = get_question(db, question_id)
     if question is None:
         raise HTTPException(status_code=404, detail="Question not found")
     return question
 
 
-@router.get("/questions/", response_model=list[QuestionInDBBase])
+@router.get("/question/", response_model=list[QuestionInDBBase])
 def read_questions(
     skip: int = 0, limit: int = 10, db: Session = Depends(get_db)
 ) -> list[QuestionInDBBase]:
     return get_questions(db, skip, limit)
 
 
-@router.put("/questions/{question_id}", response_model=QuestionInDBBase)
+@router.put("/question/{question_id}", response_model=QuestionInDBBase)
 def update_question_endpoint(
     question_id: int, question: QuestionUpdate, db: Session = Depends(get_db)
 ) -> QuestionInDBBase:
@@ -55,7 +55,7 @@ def update_question_endpoint(
     return update_question(db, question_id, question.model_dump())
 
 
-@router.delete("/questions/{question_id}", response_model=QuestionInDBBase)
+@router.delete("/question/{question_id}", response_model=QuestionInDBBase)
 def delete_question_endpoint(
     question_id: int, db: Session = Depends(get_db)
 ) -> QuestionInDBBase:

aura/api/endpoints/study_session.py

@@ -23,14 +23,14 @@
 router = APIRouter()
 
 
-@router.post("/study_sessions/", response_model=StudySessionInDBBase)
+@router.post("/study_session/", response_model=StudySessionInDBBase)
 def create_study_session_endpoint(
     study_session: StudySessionCreate, db: Session = Depends(get_db)
 ) -> StudySessionInDBBase:
     return create_study_session(db, study_session)
 
 
-@router.get("/study_sessions/{study_session_id}", response_model=StudySessionInDBBase)
+@router.get("/study_session/{study_session_id}", response_model=StudySessionInDBBase)
 def read_study_session(
     study_session_id: int, db: Session = Depends(get_db)
 ) -> StudySessionInDBBase:
@@ -40,14 +40,14 @@ def read_study_session(
     return study_session
 
 
-@router.get("/study_sessions/", response_model=list[StudySessionInDBBase])
+@router.get("/study_session/", response_model=list[StudySessionInDBBase])
 def read_study_sessions(
     skip: int = 0, limit: int = 10, db: Session = Depends(get_db)
 ) -> list[StudySessionInDBBase]:
     return get_study_sessions(db, skip, limit)
 
 
-@router.put("/study_sessions/{study_session_id}", response_model=StudySessionInDBBase)
+@router.put("/study_session/{study_session_id}", response_model=StudySessionInDBBase)
 def update_study_session_endpoint(
     study_session_id: int,
     study_session: StudySessionUpdate,
@@ -59,9 +59,7 @@ def update_study_session_endpoint(
     return update_study_session(db, study_session_id, study_session.model_dump())
 
 
-@router.delete(
-    "/study_sessions/{study_session_id}", response_model=StudySessionInDBBase
-)
+@router.delete("/study_session/{study_session_id}", response_model=StudySessionInDBBase)
 def delete_study_session_endpoint(
     study_session_id: int, db: Session = Depends(get_db)
 ) -> StudySessionInDBBase:

aura/api/endpoints/user.py

@@ -23,29 +23,29 @@
 router = APIRouter()
 
 
-@router.post("/users/", response_model=UserInDBBase)
+@router.post("/user/", response_model=UserInDBBase)
 def create_user_endpoint(
     user: UserCreate, db: Session = Depends(get_db)
 ) -> UserInDBBase:
     return create_user(db, user)
 
 
-@router.get("/users/{user_id}", response_model=UserInDBBase)
+@router.get("/user/{user_id}", response_model=UserInDBBase)
 def read_user(user_id: int, db: Session = Depends(get_db)) -> UserInDBBase:
     user = get_user(db, user_id)
     if user is None:
         raise HTTPException(status_code=404, detail="User not found")
     return user
 
 
-@router.get("/users/", response_model=list[UserInDBBase])
+@router.get("/user/", response_model=list[UserInDBBase])
 def read_users(
     skip: int = 0, limit: int = 10, db: Session = Depends(get_db)
 ) -> list[UserInDBBase]:
     return get_users(db, skip, limit)
 
 
-@router.put("/users/{user_id}", response_model=UserInDBBase)
+@router.put("/user/{user_id}", response_model=UserInDBBase)
 def update_user_endpoint(
     user_id: int, user: UserUpdate, db: Session = Depends(get_db)
 ) -> UserInDBBase:
@@ -55,7 +55,7 @@ def update_user_endpoint(
     return update_user(db, user_id, user.model_dump())
 
 
-@router.delete("/users/{user_id}", response_model=UserInDBBase)
+@router.delete("/user/{user_id}", response_model=UserInDBBase)
 def delete_user_endpoint(user_id: int, db: Session = Depends(get_db)) -> UserInDBBase:
     user = delete_user(db, user_id)
     if user is None:

aura/database/models.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from enum import Enum
 from sqlalchemy import (
     Column,
@@ -12,8 +13,16 @@
 from aura.database.session import Base
 
 
-class ActivityType(Enum):
+class UserRole(str, Enum):
+    student = "student"
+    teacher = "teacher"
+    admin = "admin"
+
+
+class ActivityType(str, Enum):
     question = "question"
+    answer = "answer"
+    note = "note"
 
 
 class User(Base):
@@ -22,9 +31,9 @@ class User(Base):
     id = Column(Integer, primary_key=True, index=True)
     username = Column(String, unique=True, index=True)
     email = Column(String, unique=True, index=True)
-    role = Column(String)
-    created_at = Column(DateTime)
-    updated_at = Column(DateTime)
+    role = Column(SQLEnum(UserRole), nullable=False)
+    created_at = Column(DateTime, default=datetime.now())
+    updated_at = Column(DateTime, default=datetime.now(), onupdate=datetime.now())
 
     study_sessions = relationship("StudySession", back_populates="user")
     activities = relationship("Activity", back_populates="user")
@@ -52,7 +61,7 @@ class Activity(Base):
     study_session_id = Column(Integer, ForeignKey("study_sessions.id"))
     type = Column(SQLEnum(ActivityType), nullable=False)
     activity = Column(String)
-    created_at = Column(DateTime)
+    created_at = Column(DateTime, default=datetime.now())
 
     user = relationship("User", back_populates="activities")
     study_session = relationship("StudySession", back_populates="activities")

aura/repositories/activity_repository.py

@@ -1,10 +1,12 @@
+# aura/repositories/activity_repository.py
+
 from sqlalchemy.orm import Session
 from aura.database.models import Activity
 from aura.schemas.activity import ActivityCreate, ActivityUpdate
 
 
 def create_activity(db: Session, activity: ActivityCreate) -> Activity:
-    db_activity = Activity(**activity.dict())
+    db_activity = Activity(**activity.model_dump())
     db.add(db_activity)
     db.commit()
     db.refresh(db_activity)
@@ -22,9 +24,14 @@ def get_activities(db: Session, skip: int = 0, limit: int = 10) -> list[Activity
 def update_activity(
     db: Session, activity_id: int, activity: ActivityUpdate
 ) -> Activity:
-    db.query(Activity).filter(Activity.id == activity_id).update(activity.dict())
-    db.commit()
-    return db.query(Activity).filter(Activity.id == activity_id).first()
+    db_activity = db.query(Activity).filter(Activity.id == activity_id).first()
+    if db_activity:
+        update_data = activity.model_dump(exclude_unset=True)
+        for key, value in update_data.items():
+            setattr(db_activity, key, value)
+        db.commit()
+        db.refresh(db_activity)
+    return db_activity
 
 
 def delete_activity(db: Session, activity_id: int) -> Activity:

aura/repositories/answer_repository.py

@@ -1,10 +1,12 @@
+# aura/repositories/answer_repository.py
+
 from sqlalchemy.orm import Session
 from aura.database.models import Answer
 from aura.schemas.answer import AnswerCreate, AnswerUpdate
 
 
 def create_answer(db: Session, answer: AnswerCreate) -> Answer:
-    db_answer = Answer(**answer.dict())
+    db_answer = Answer(**answer.model_dump())
     db.add(db_answer)
     db.commit()
     db.refresh(db_answer)
@@ -20,9 +22,14 @@ def get_answers(db: Session, skip: int = 0, limit: int = 10) -> list[Answer]:
 
 
 def update_answer(db: Session, answer_id: int, answer: AnswerUpdate) -> Answer:
-    db.query(Answer).filter(Answer.id == answer_id).update(answer.dict())
-    db.commit()
-    return db.query(Answer).filter(Answer.id == answer_id).first()
+    db_answer = db.query(Answer).filter(Answer.id == answer_id).first()
+    if db_answer:
+        update_data = answer.model_dump(exclude_unset=True)
+        for key, value in update_data.items():
+            setattr(db_answer, key, value)
+        db.commit()
+        db.refresh(db_answer)
+    return db_answer
 
 
 def delete_answer(db: Session, answer_id: int) -> Answer:

aura/repositories/question_repository.py

@@ -24,9 +24,14 @@ def get_questions(db: Session, skip: int = 0, limit: int = 10) -> list[Question]
 def update_question(
     db: Session, question_id: int, question: QuestionUpdate
 ) -> Question:
-    db.query(Question).filter(Question.id == question_id).update(question.model_dump())
-    db.commit()
-    return db.query(Question).filter(Question.id == question_id).first()
+    db_question = db.query(Question).filter(Question.id == question_id).first()
+    if db_question:
+        update_data = question.model_dump(exclude_unset=True)
+        for key, value in update_data.items():
+            setattr(db_question, key, value)
+        db.commit()
+        db.refresh(db_question)
+    return db_question
 
 
 def delete_question(db: Session, question_id: int) -> Question:

aura/repositories/study_session_repository.py

@@ -28,11 +28,16 @@ def get_study_sessions(
 def update_study_session(
     db: Session, study_session_id: int, study_session: StudySessionUpdate
 ) -> StudySession:
-    db.query(StudySession).filter(StudySession.id == study_session_id).update(
-        study_session.model_dump()
+    db_study_session = (
+        db.query(StudySession).filter(StudySession.id == study_session_id).first()
     )
-    db.commit()
-    return db.query(StudySession).filter(StudySession.id == study_session_id).first()
+    if db_study_session:
+        update_data = study_session.model_dump(exclude_unset=True)
+        for key, value in update_data.items():
+            setattr(db_study_session, key, value)
+        db.commit()
+        db.refresh(db_study_session)
+    return db_study_session
 
 
 def delete_study_session(db: Session, study_session_id: int) -> StudySession:

aura/repositories/user_repository.py

@@ -6,7 +6,7 @@
 
 
 def create_user(db: Session, user: UserCreate) -> User:
-    db_user = User(**user.dict())
+    db_user = User(**user.model_dump())
     db.add(db_user)
     db.commit()
     db.refresh(db_user)
@@ -22,9 +22,14 @@ def get_users(db: Session, skip: int = 0, limit: int = 10) -> list[User]:
 
 
 def update_user(db: Session, user_id: int, user: UserUpdate) -> User:
-    db.query(User).filter(User.id == user_id).update(user.dict())
-    db.commit()
-    return db.query(User).filter(User.id == user_id).first()
+    db_user = db.query(User).filter(User.id == user_id).first()
+    if db_user:
+        update_data = user.model_dump(exclude_unset=True)
+        for key, value in update_data.items():
+            setattr(db_user, key, value)
+        db.commit()
+        db.refresh(db_user)
+    return db_user
 
 
 def delete_user(db: Session, user_id: int) -> User: