testing pipe

backend/tests/conftest.py

@@ -1,101 +1,127 @@
+"""Test configuration."""
+import os
 import pytest
+from typing import Generator
+from fastapi.testclient import TestClient
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
-from unittest.mock import MagicMock
-from app.db.base import Base
-from app.database import get_db
-from app.main import app
-from app.utils.jwt import create_and_save_token, redis
-from app.crud import employees
-from app.utils.auth import get_password_hash
-from app.models.token import Token
-from app.models.employee import Employee
-from app.models.request import Request
-from app.schemas.employee import EmployeeCreate
+from sqlalchemy.pool import StaticPool
+from unittest.mock import Mock, patch
 
-# Используем SQLite для тестов
+from app.database import Base, get_db
+from app.main import app
+from app.models.employee import Employee
+from app.utils.auth import get_password_hash
+from app.utils.jwt import create_access_token
+from app.core.config import settings
+
+# Создаем тестовую базу данных в памяти
 SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"
 engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
 TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
-# Создаем мок для Redis
-class RedisMock:
+class MockRedis:
+    """Мок для Redis."""
     def __init__(self):
         self.data = {}
 
-    def setex(self, name, time, value):
-        self.data[name] = value
+    def get(self, key):
+        return self.data.get(key)
+
+    def set(self, key, value, ex=None):
+        self.data[key] = value
         return True
 
-    def get(self, name):
-        return self.data.get(name)
-
-    def delete(self, name):
-        if name in self.data:
-            del self.data[name]
+    def delete(self, key):
+        if key in self.data:
+            del self.data[key]
         return True
 
-@pytest.fixture(autouse=True)
-def mock_redis(monkeypatch):
-    redis_mock = RedisMock()
-    monkeypatch.setattr("app.utils.jwt.redis", redis_mock)
-    return redis_mock
+    def exists(self, key):
+        return key in self.data
 
 @pytest.fixture(scope="function")
-def test_db():
-    # Удаляем все таблицы
-    Base.metadata.drop_all(bind=engine)
-    # Создаем все таблицы заново
+def redis_mock():
+    """Фикстура для мока Redis."""
+    with patch("app.utils.jwt.redis") as mock:
+        redis_instance = MockRedis()
+        mock.get.side_effect = redis_instance.get
+        mock.set.side_effect = redis_instance.set
+        mock.delete.side_effect = redis_instance.delete
+        mock.exists.side_effect = redis_instance.exists
+        yield mock
+
+@pytest.fixture(scope="function")
+def db() -> Generator:
+    """Фикстура для создания тестовой базы данных."""
     Base.metadata.create_all(bind=engine)
-    
-    # Создаем сессию
     db = TestingSessionLocal()
     try:
         yield db
     finally:
         db.close()
+        Base.metadata.drop_all(bind=engine)
 
 @pytest.fixture(scope="function")
-def test_employee(test_db):
-    hashed_password = get_password_hash("testpass123")
-    employee_data = EmployeeCreate(
-        first_name="Test",
-        last_name="User",
-        department="IT",
-        office="101",
-        password="testpass123"
+def client(db: TestingSessionLocal, redis_mock) -> Generator:
+    """Фикстура для создания тестового клиента."""
+    def override_get_db():
+        try:
+            yield db
+        finally:
+            db.close()
+    
+    app.dependency_overrides[get_db] = override_get_db
+    return TestClient(app)
+
+@pytest.fixture(scope="function")
+def test_employee(db: TestingSessionLocal) -> Employee:
+    """Фикстура для создания тестового сотрудника."""
+    employee = Employee(
+        email="test@example.com",
+        full_name="Test Employee",
+        hashed_password=get_password_hash("testpassword"),
+        is_active=True,
+        is_admin=False,
+        department="IT"
     )
-    employee = employees.create_employee(test_db, employee_data, hashed_password)
+    db.add(employee)
+    db.commit()
+    db.refresh(employee)
     return employee
 
 @pytest.fixture(scope="function")
-def test_token(test_db, test_employee):
-    token = create_and_save_token(test_employee.id, test_db)
+def test_admin(db: TestingSessionLocal) -> Employee:
+    """Фикстура для создания тестового администратора."""
+    admin = Employee(
+        email="admin@example.com",
+        full_name="Test Admin",
+        hashed_password=get_password_hash("adminpassword"),
+        is_active=True,
+        is_admin=True,
+        department="Administration"
+    )
+    db.add(admin)
+    db.commit()
+    db.refresh(admin)
+    return admin
+
+@pytest.fixture(scope="function")
+def employee_token(test_employee: Employee, db: TestingSessionLocal) -> str:
+    """Фикстура для создания токена тестового сотрудника."""
+    from app.utils.jwt import create_access_token
+    token = create_access_token({"sub": str(test_employee.id)})
+    # Сохраняем токен в Redis мок
+    from app.utils.jwt import redis
+    redis.set(f"token:{token}", "valid")
     return token
 
 @pytest.fixture(scope="function")
-def test_auth_header(test_token):
-    return {"Authorization": f"Bearer {test_token}"}
-
-@pytest.fixture(scope="function")
-def admin_token(test_db):
-    token = create_and_save_token(-1, test_db)  # -1 для админа
-    return token
-
-@pytest.fixture(scope="function")
-def admin_auth_header(admin_token):
-    return {"Authorization": f"Bearer {admin_token}"}
-
-@pytest.fixture(scope="function")
-def test_employee_id(test_employee):
-    return test_employee.id
-
-# Переопределяем зависимость для получения БД
-def override_get_db():
-    db = TestingSessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-
-app.dependency_overrides[get_db] = override_get_db 
+def admin_token(test_admin: Employee, db: TestingSessionLocal) -> str:
+    """Фикстура для создания токена администратора."""
+    from app.utils.jwt import create_access_token
+    token = create_access_token({"sub": str(test_admin.id)})
+    # Сохраняем токен в Redis мок
+    from app.utils.jwt import redis
+    redis.set(f"token:{token}", "valid")
+    return token