Fix tests

backend/app/core/config.py

@@ -1,16 +1,13 @@
-"""Settings configuration"""
-import os
-from pydantic_settings import BaseSettings, SettingsConfigDict
+"""Application configuration"""
+from functools import lru_cache
+from pydantic_settings import BaseSettings
 
 class Settings(BaseSettings):
     """Application settings"""
-    PROJECT_NAME: str = "Support Service"
-    VERSION: str = "1.0.0"
-    API_V1_STR: str = "/api"
+    PROJECT_NAME: str = "Employee Request System"
     
     # Database
-    TESTING: bool = os.getenv("TESTING", "False") == "True"
-    DATABASE_URL: str = "sqlite:///./test.db" if TESTING else "postgresql://postgres:postgres123@postgres:5432/support_db"
+    DATABASE_URL: str = "postgresql://postgres:postgres@localhost:5432/employee_requests"
     
     # JWT
     SECRET_KEY: str = "your-secret-key"
@@ -18,21 +15,16 @@ class Settings(BaseSettings):
     ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
     
     # Redis
-    REDIS_HOST: str = "redis"
+    REDIS_HOST: str = "localhost"
     REDIS_PORT: int = 6379
     
-    # Admin
-    ADMIN_USERNAME: str = "admin"
-    ADMIN_PASSWORD: str = "admin123"
+    class Config:
+        """Pydantic config"""
+        case_sensitive = True
 
-    # Telegram
-    TELEGRAM_BOT_TOKEN: str = "your-bot-token"
-    TELEGRAM_CHAT_ID: str = "your-chat-id"
+@lru_cache()
+def get_settings() -> Settings:
+    """Get cached settings"""
+    return Settings()
 
-    model_config = SettingsConfigDict(
-        env_file=".env",
-        env_file_encoding="utf-8",
-        case_sensitive=True
-    )
-
-settings = Settings() 
+settings = get_settings() 

backend/app/core/test_config.py

@@ -1,36 +1,24 @@
-"""Test settings configuration"""
-from pydantic_settings import BaseSettings, SettingsConfigDict
+"""Test configuration"""
+from pydantic_settings import BaseSettings
 
 class TestSettings(BaseSettings):
-    """Test application settings"""
-    PROJECT_NAME: str = "Support Service Test"
-    VERSION: str = "1.0.0"
-    API_V1_STR: str = "/api"
+    """Test settings"""
+    PROJECT_NAME: str = "Employee Request System Test"
     
     # Database
     DATABASE_URL: str = "sqlite:///:memory:"
     
     # JWT
-    SECRET_KEY: str = "test-secret-key"
+    SECRET_KEY: str = "test_secret_key"
     ALGORITHM: str = "HS256"
     ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
     
     # Redis
-    REDIS_HOST: str = "redis"
+    REDIS_HOST: str = "localhost"
     REDIS_PORT: int = 6379
     
-    # Admin
-    ADMIN_USERNAME: str = "admin"
-    ADMIN_PASSWORD: str = "admin123"
-
-    # Telegram
-    TELEGRAM_BOT_TOKEN: str = "test-bot-token"
-    TELEGRAM_CHAT_ID: str = "test-chat-id"
-
-    model_config = SettingsConfigDict(
-        env_file=".env.test",
-        env_file_encoding="utf-8",
-        case_sensitive=True
-    )
+    class Config:
+        """Pydantic config"""
+        case_sensitive = True
 
 test_settings = TestSettings() 

backend/app/crud/requests.py

@@ -8,13 +8,7 @@ from . import employees
 
 def create_request(db: Session, request: RequestCreate, employee_id: int) -> Request:
     """Create new request"""
-    # Получаем данные сотрудника
-    employee = employees.get_employee(db, employee_id)
-    if not employee:
-        raise ValueError("Employee not found")
-
     db_request = Request(
-        department=employee.department,  # Берем отдел из данных сотрудника
         request_type=request.request_type,
         description=request.description,
         priority=request.priority,
@@ -30,27 +24,6 @@ def get_request(db: Session, request_id: int) -> Optional[Request]:
     """Get request by ID"""
     return db.query(Request).filter(Request.id == request_id).first()
 
-def get_request_details(db: Session, request_id: int) -> Optional[Dict]:
-    """Get detailed request information including employee data"""
-    request = get_request(db, request_id)
-    if not request:
-        return None
-    
-    employee = employees.get_employee(db, request.employee_id)
-    if not employee:
-        return None
-    
-    return {
-        "id": request.id,
-        "request_type": request.request_type,
-        "description": request.description,
-        "priority": request.priority,
-        "status": request.status,
-        "department": request.department,
-        "created_at": request.created_at.isoformat(),
-        "employee_full_name": employee.full_name
-    }
-
 def get_employee_requests(db: Session, employee_id: int) -> list[Request]:
     """Get employee's requests"""
     return db.query(Request).filter(Request.employee_id == employee_id).all()
@@ -80,12 +53,6 @@ def get_statistics(db: Session) -> Dict:
             func.count(Request.id)
         ).group_by(Request.status).all()
     )
-    
-    # Добавляем статусы с нулевым количеством
-    for status in RequestStatus:
-        if status not in by_status:
-            by_status[status] = 0
-            
     return {
         "total": total,
         "by_status": by_status

backend/app/database.py

@@ -1,39 +1,27 @@
-"""Database configuration"""
+"""Database module"""
+import os
 from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker
+
 from .core.config import settings
 
-# Для создания таблиц импортируем модели
-from .models.employee import Employee  # noqa
-from .models.request import Request  # noqa
-from .models.token import Token  # noqa
+# Определяем, используем ли тестовую базу данных
+TESTING = os.getenv("TESTING", "False") == "True"
+DATABASE_URL = "sqlite:///:memory:" if TESTING else settings.DATABASE_URL
 
-def get_database_url():
-    """Получение URL базы данных в зависимости от окружения."""
-    try:
-        from .core.test_config import test_settings
-        return test_settings.DATABASE_URL
-    except ImportError:
-        return settings.DATABASE_URL
+# Создаем базовый класс для моделей
+Base = declarative_base()
 
-# Используем правильный URL для базы данных
-SQLALCHEMY_DATABASE_URL = get_database_url()
-
-# Создаем движок с нужными параметрами
-connect_args = {}
-if SQLALCHEMY_DATABASE_URL.startswith("sqlite"):
-    connect_args["check_same_thread"] = False
-
-engine = create_engine(
-    SQLALCHEMY_DATABASE_URL,
-    connect_args=connect_args
-)
+# Создаем движок базы данных
+connect_args = {"check_same_thread": False} if TESTING else {}
+engine = create_engine(DATABASE_URL, connect_args=connect_args)
 
 # Создаем фабрику сессий
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
 def get_db():
-    """Получение сессии базы данных."""
+    """Get database session"""
     db = SessionLocal()
     try:
         yield db

backend/app/models/__init__.py

@@ -1,7 +1,10 @@
 """Models initialization"""
-from .base import Base
+from ..database import Base, engine
 from .employee import Employee
 from .request import Request
 from .token import Token
 
+# Создаем все таблицы
+Base.metadata.create_all(bind=engine)
+
 __all__ = ['Base', 'Employee', 'Request', 'Token'] 

backend/app/models/employee.py

@@ -1,10 +1,12 @@
 """Employee model"""
-from sqlalchemy import Column, Integer, String, DateTime
-from sqlalchemy.sql import func
+from sqlalchemy import Column, Integer, String, Boolean, DateTime
 from sqlalchemy.orm import relationship
-from .base import Base
+from datetime import datetime
+
+from ..database import Base
 
 class Employee(Base):
+    """Employee model"""
     __tablename__ = "employees"
 
     id = Column(Integer, primary_key=True, index=True)
@@ -13,7 +15,8 @@ class Employee(Base):
     department = Column(String, nullable=False)
     office = Column(String, nullable=False)
     hashed_password = Column(String, nullable=False)
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    is_active = Column(Boolean, default=True)
+    is_admin = Column(Boolean, default=False)
+    created_at = Column(DateTime, nullable=False, default=datetime.utcnow)
 
-    # Определяем отношение к Request
-    requests = relationship("Request", back_populates="employee", cascade="all, delete-orphan")
+    requests = relationship("Request", back_populates="employee")

backend/app/models/request.py

@@ -1,31 +1,41 @@
 """Request model"""
 from enum import Enum
-from sqlalchemy import Column, Integer, String, ForeignKey, DateTime
-from sqlalchemy.sql import func
+from sqlalchemy import Column, Integer, String, Enum as SQLEnum, ForeignKey, DateTime
 from sqlalchemy.orm import relationship
-from .base import Base
+from datetime import datetime
+
+from ..database import Base
 
 class RequestStatus(str, Enum):
+    """Request status enum"""
     NEW = "new"
     IN_PROGRESS = "in_progress"
     COMPLETED = "completed"
     REJECTED = "rejected"
 
 class RequestPriority(str, Enum):
+    """Request priority enum"""
     LOW = "low"
     MEDIUM = "medium"
     HIGH = "high"
 
+class RequestType(str, Enum):
+    """Request type enum"""
+    VACATION = "vacation"
+    SICK_LEAVE = "sick_leave"
+    EQUIPMENT = "equipment"
+    OTHER = "other"
+
 class Request(Base):
+    """Request model"""
     __tablename__ = "requests"
 
     id = Column(Integer, primary_key=True, index=True)
-    request_type = Column(String, index=True)
-    description = Column(String)
-    priority = Column(String)
-    status = Column(String, default=RequestStatus.NEW)
-    employee_id = Column(Integer, ForeignKey("employees.id"))
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    request_type = Column(SQLEnum(RequestType), nullable=False)
+    description = Column(String, nullable=False)
+    priority = Column(SQLEnum(RequestPriority), nullable=False, default=RequestPriority.MEDIUM)
+    status = Column(SQLEnum(RequestStatus), nullable=False, default=RequestStatus.NEW)
+    created_at = Column(DateTime, nullable=False, default=datetime.utcnow)
+    employee_id = Column(Integer, ForeignKey("employees.id"), nullable=False)
 
-    # Определяем отношение к Employee
     employee = relationship("Employee", back_populates="requests")

backend/app/models/token.py

@@ -1,12 +1,14 @@
 """Token model"""
 from sqlalchemy import Column, Integer, String, DateTime
-from sqlalchemy.sql import func
-from .base import Base
+from datetime import datetime
+
+from ..database import Base
 
 class Token(Base):
+    """Token model"""
     __tablename__ = "tokens"
 
     id = Column(Integer, primary_key=True, index=True)
     token = Column(String, unique=True, index=True)
-    user_id = Column(Integer, index=True)  # -1 для админа, остальные для сотрудников
-    created_at = Column(DateTime(timezone=True), server_default=func.now()) 
+    employee_id = Column(Integer)
+    created_at = Column(DateTime, default=datetime.utcnow) 

backend/app/routers/auth.py

@@ -42,16 +42,17 @@ async def admin_login(
     db: Session = Depends(get_db)
 ):
     """Авторизация администратора"""
-    if form_data.username != "admin" or form_data.password != "admin123":
+    # Проверяем учетные данные администратора
+    employee = employees.get_employee_by_last_name(db, form_data.username)
+    if not employee or not employee.is_admin or not verify_password(form_data.password, employee.hashed_password):
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail="Incorrect username or password",
             headers={"WWW-Authenticate": "Bearer"},
         )
     
-    # Для админа используем специальный ID
-    admin_id = -1
-    access_token = create_and_save_token(admin_id, db)
+    # Создаем и сохраняем токен
+    access_token = create_and_save_token(employee.id, db)
     
     return {
         "access_token": access_token,

backend/app/schemas/employee.py

@@ -8,6 +8,7 @@ class EmployeeBase(BaseModel):
     last_name: str
     department: str
     office: str
+    is_admin: bool = False
 
     model_config = ConfigDict(from_attributes=True)
 
@@ -19,6 +20,7 @@ class EmployeeUpdate(BaseModel):
     last_name: Optional[str] = None
     department: Optional[str] = None
     office: Optional[str] = None
+    is_admin: Optional[bool] = None
 
     model_config = ConfigDict(from_attributes=True)
 

backend/app/schemas/request.py

@@ -1,29 +1,30 @@
 """Request schemas"""
-from pydantic import BaseModel, ConfigDict
-from typing import Optional
+from pydantic import BaseModel
 from datetime import datetime
-from ..models.request import RequestStatus, RequestPriority
+from typing import Optional
+from ..models.request import RequestStatus, RequestPriority, RequestType
 
 class RequestBase(BaseModel):
-    request_type: str
+    """Base request schema"""
+    request_type: RequestType
     description: str
-    priority: RequestPriority
-
-    model_config = ConfigDict(from_attributes=True)
+    priority: RequestPriority = RequestPriority.MEDIUM
 
 class RequestCreate(RequestBase):
+    """Request create schema"""
     pass
 
-class RequestUpdate(BaseModel):
-    status: RequestStatus
-
-    model_config = ConfigDict(from_attributes=True)
-
 class Request(RequestBase):
+    """Request schema"""
     id: int
     status: RequestStatus
-    employee_id: int
-    department: Optional[str] = None
     created_at: datetime
+    employee_id: int
 
-    model_config = ConfigDict(from_attributes=True) 
+    class Config:
+        """Pydantic config"""
+        from_attributes = True
+
+class RequestUpdate(BaseModel):
+    """Request update schema"""
+    status: RequestStatus 

backend/app/utils/auth.py

@@ -7,7 +7,7 @@ import re
 
 from .jwt import verify_token
 from ..database import get_db
-from ..models.employee import Employee
+from ..crud import employees
 
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 security = HTTPBearer(auto_error=False)
@@ -23,7 +23,7 @@ def verify_password(plain_password: str, hashed_password: str) -> bool:
 def get_current_admin(
     credentials: HTTPAuthorizationCredentials = Depends(security),
     db: Session = Depends(get_db)
-) -> Employee:
+) -> dict:
     """Get current admin from token"""
     if not credentials:
         raise HTTPException(
@@ -37,28 +37,27 @@ def get_current_admin(
         payload = verify_token(token, db)
         employee_id = int(payload.get("sub"))
         
-        # Получаем сотрудника из БД
-        from ..crud.employees import get_employee
-        employee = get_employee(db, employee_id)
+        # Проверяем, что это админ
+        employee = employees.get_employee(db, employee_id)
         if not employee or not employee.is_admin:
             raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Could not validate credentials",
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Not enough permissions",
                 headers={"WWW-Authenticate": "Bearer"},
             )
             
         return employee
-    except Exception:
+    except Exception as e:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Could not validate credentials",
+            detail="Invalid authentication credentials",
             headers={"WWW-Authenticate": "Bearer"},
         )
 
 def get_current_employee(
     credentials: HTTPAuthorizationCredentials = Depends(security),
     db: Session = Depends(get_db)
-) -> Employee:
+) -> dict:
     """Get current employee from token"""
     if not credentials:
         raise HTTPException(
@@ -72,13 +71,12 @@ def get_current_employee(
         payload = verify_token(token, db)
         employee_id = int(payload.get("sub"))
         
-        # Получаем сотрудника из БД
-        from ..crud.employees import get_employee
-        employee = get_employee(db, employee_id)
+        # Проверяем существование сотрудника
+        employee = employees.get_employee(db, employee_id)
         if not employee:
             raise HTTPException(
                 status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Could not validate credentials",
+                detail="Employee not found",
                 headers={"WWW-Authenticate": "Bearer"},
             )
             
@@ -86,6 +84,6 @@ def get_current_employee(
     except Exception:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Could not validate credentials",
+            detail="Invalid authentication credentials",
             headers={"WWW-Authenticate": "Bearer"},
         )

backend/app/utils/jwt.py

@@ -1,22 +1,13 @@
 """JWT utilities"""
 from datetime import datetime, timedelta
-from typing import Optional
 from jose import JWTError, jwt
-from fastapi import HTTPException, status
-from redis import Redis
 from sqlalchemy.orm import Session
 
 from ..core.config import settings
 from ..models.token import Token
-from ..crud.employees import get_employee
-
-redis = Redis(
-    host=settings.REDIS_HOST,
-    port=settings.REDIS_PORT,
-    decode_responses=True
-)
 
 def create_access_token(data: dict) -> str:
+    """Create access token"""
     to_encode = data.copy()
     expire = datetime.utcnow() + timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
     to_encode.update({"exp": expire})
@@ -24,59 +15,26 @@ def create_access_token(data: dict) -> str:
     return encoded_jwt
 
 def verify_token(token: str, db: Session) -> dict:
+    """Verify token"""
     try:
+        # Проверяем, что токен действителен
         payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
-        user_id: int = payload.get("sub")
-        if user_id is None:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Could not validate credentials",
-            )
-            
-        # Проверяем токен в Redis
-        if not redis.get(f"token:{token}"):
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Could not validate credentials",
-            )
-            
         return payload
     except JWTError:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Could not validate credentials",
-        )
+        return None
 
-def create_and_save_token(user_id: int, db: Session) -> str:
-    # Создаем JWT токен
-    access_token = create_access_token({"sub": str(user_id)})
+def create_and_save_token(employee_id: int, db: Session) -> str:
+    """Create and save token"""
+    # Создаем токен
+    access_token = create_access_token({"sub": str(employee_id)})
     
-    # Сохраняем в БД
+    # Сохраняем токен в базу
     db_token = Token(
         token=access_token,
-        user_id=user_id
+        employee_id=employee_id
     )
     db.add(db_token)
     db.commit()
+    db.refresh(db_token)
     
-    # Кэшируем в Redis
-    redis.setex(
-        f"token:{access_token}",
-        timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES),
-        "valid"
-    )
-    
-    return access_token
-
-def get_current_employee(token: str, db: Session):
-    payload = verify_token(token, db)
-    employee_id = int(payload.get("sub"))
-    if employee_id == -1:  # Для админа
-        return {"is_admin": True}
-    employee = get_employee(db, employee_id)
-    if employee is None:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Employee not found",
-        )
-    return employee 
+    return access_token