Testing workable

backend/tests/conftest.py

@@ -1,10 +1,127 @@
-"""Test configuration"""
+"""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 sqlalchemy.pool import StaticPool
+from unittest.mock import Mock, patch
 
+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
 
-@pytest.fixture
-def client():
-    """Test client fixture"""
-    return TestClient(app) 
+# Создаем тестовую базу данных в памяти
+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)
+
+class MockRedis:
+    """Мок для Redis."""
+    def __init__(self):
+        self.data = {}
+
+    def get(self, key):
+        return self.data.get(key)
+
+    def set(self, key, value, ex=None):
+        self.data[key] = value
+        return True
+
+    def delete(self, key):
+        if key in self.data:
+            del self.data[key]
+        return True
+
+    def exists(self, key):
+        return key in self.data
+
+@pytest.fixture(scope="function")
+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 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"
+    )
+    db.add(employee)
+    db.commit()
+    db.refresh(employee)
+    return employee
+
+@pytest.fixture(scope="function")
+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 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 

backend/tests/test_auth.py

@@ -0,0 +1,80 @@
+"""Authentication tests."""
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy.orm import Session
+from app.models.employee import Employee
+
+def test_login_employee_success(client: TestClient, test_employee: Employee):
+    """Тест успешной авторизации сотрудника."""
+    response = client.post(
+        "/api/auth/login",
+        data={"username": test_employee.email, "password": "testpassword"}
+    )
+    assert response.status_code == 200
+    assert "access_token" in response.json()
+    assert "token_type" in response.json()
+    assert response.json()["token_type"] == "bearer"
+
+def test_login_employee_wrong_password(client: TestClient, test_employee: Employee):
+    """Тест авторизации сотрудника с неверным паролем."""
+    response = client.post(
+        "/api/auth/login",
+        data={"username": test_employee.email, "password": "wrongpassword"}
+    )
+    assert response.status_code == 401
+    assert response.json()["detail"] == "Incorrect username or password"
+
+def test_login_employee_wrong_username(client: TestClient):
+    """Тест авторизации с несуществующим пользователем."""
+    response = client.post(
+        "/api/auth/login",
+        data={"username": "nonexistent@example.com", "password": "testpassword"}
+    )
+    assert response.status_code == 401
+    assert response.json()["detail"] == "Incorrect username or password"
+
+def test_login_admin_success(client: TestClient, test_admin: Employee):
+    """Тест успешной авторизации администратора."""
+    response = client.post(
+        "/api/auth/admin/login",
+        data={"username": test_admin.email, "password": "adminpassword"}
+    )
+    assert response.status_code == 200
+    assert "access_token" in response.json()
+    assert "token_type" in response.json()
+    assert response.json()["token_type"] == "bearer"
+
+def test_login_admin_wrong_password(client: TestClient, test_admin: Employee):
+    """Тест авторизации администратора с неверным паролем."""
+    response = client.post(
+        "/api/auth/admin/login",
+        data={"username": test_admin.email, "password": "wrongpassword"}
+    )
+    assert response.status_code == 401
+    assert response.json()["detail"] == "Incorrect username or password"
+
+def test_protected_route_with_valid_token(client: TestClient, employee_token: str, test_employee: Employee, db: Session):
+    """Тест доступа к защищенному маршруту с валидным токеном."""
+    response = client.get(
+        "/api/employees/me",
+        headers={"Authorization": f"Bearer {employee_token}"}
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["email"] == test_employee.email
+    assert data["full_name"] == test_employee.full_name
+
+def test_protected_route_without_token(client: TestClient):
+    """Тест доступа к защищенному маршруту без токена."""
+    response = client.get("/api/employees/me")
+    assert response.status_code == 401
+    assert response.json()["detail"] == "Not authenticated"
+
+def test_protected_route_with_invalid_token(client: TestClient):
+    """Тест доступа к защищенному маршруту с недействительным токеном."""
+    response = client.get(
+        "/api/employees/me",
+        headers={"Authorization": "Bearer invalid_token"}
+    )
+    assert response.status_code == 401
+    assert response.json()["detail"] == "Could not validate credentials" 

backend/tests/test_employees.py

@@ -0,0 +1,135 @@
+"""Employee tests."""
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy.orm import Session
+from app.models.employee import Employee
+
+def test_create_employee(client: TestClient, admin_token: str, db: Session):
+    """Тест создания сотрудника."""
+    response = client.post(
+        "/api/employees",
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json={
+            "email": "new@example.com",
+            "password": "newpassword",
+            "full_name": "New Employee",
+            "department": "IT",
+            "is_active": True,
+            "is_admin": False
+        }
+    )
+    assert response.status_code == 201
+    data = response.json()
+    assert data["email"] == "new@example.com"
+    assert data["full_name"] == "New Employee"
+    assert data["department"] == "IT"
+    assert "id" in data
+
+def test_create_employee_unauthorized(client: TestClient):
+    """Тест создания сотрудника без авторизации."""
+    response = client.post(
+        "/api/employees",
+        json={
+            "email": "new@example.com",
+            "password": "newpassword",
+            "full_name": "New Employee",
+            "is_active": True,
+            "is_admin": False
+        }
+    )
+    assert response.status_code == 401
+    assert response.json()["detail"] == "Not authenticated"
+
+def test_get_employees(client: TestClient, admin_token: str, test_employee: Employee, db: Session):
+    """Тест получения списка сотрудников."""
+    response = client.get(
+        "/api/employees",
+        headers={"Authorization": f"Bearer {admin_token}"}
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert isinstance(data, list)
+    assert len(data) > 0
+    assert "email" in data[0]
+    assert "full_name" in data[0]
+    assert "department" in data[0]
+
+def test_get_employee_by_id(client: TestClient, admin_token: str, test_employee: Employee, db: Session):
+    """Тест получения сотрудника по ID."""
+    response = client.get(
+        f"/api/employees/{test_employee.id}",
+        headers={"Authorization": f"Bearer {admin_token}"}
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["email"] == test_employee.email
+    assert data["full_name"] == test_employee.full_name
+    assert data["department"] == test_employee.department
+
+def test_get_nonexistent_employee(client: TestClient, admin_token: str):
+    """Тест получения несуществующего сотрудника."""
+    response = client.get(
+        "/api/employees/999",
+        headers={"Authorization": f"Bearer {admin_token}"}
+    )
+    assert response.status_code == 404
+    assert response.json()["detail"] == "Employee not found"
+
+def test_update_employee(client: TestClient, admin_token: str, test_employee: Employee, db: Session):
+    """Тест обновления данных сотрудника."""
+    response = client.put(
+        f"/api/employees/{test_employee.id}",
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json={
+            "email": "updated@example.com",
+            "full_name": "Updated Employee",
+            "department": "HR",
+            "is_active": True,
+            "is_admin": False
+        }
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["email"] == "updated@example.com"
+    assert data["full_name"] == "Updated Employee"
+    assert data["department"] == "HR"
+
+def test_delete_employee(client: TestClient, admin_token: str, test_employee: Employee, db: Session):
+    """Тест удаления сотрудника."""
+    response = client.delete(
+        f"/api/employees/{test_employee.id}",
+        headers={"Authorization": f"Bearer {admin_token}"}
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["email"] == test_employee.email
+    assert data["full_name"] == test_employee.full_name
+    assert data["department"] == test_employee.department
+
+def test_employee_me(client: TestClient, employee_token: str, test_employee: Employee, db: Session):
+    """Тест получения информации о текущем сотруднике."""
+    response = client.get(
+        "/api/employees/me",
+        headers={"Authorization": f"Bearer {employee_token}"}
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["email"] == test_employee.email
+    assert data["full_name"] == test_employee.full_name
+    assert data["department"] == test_employee.department
+
+def test_update_me(client: TestClient, employee_token: str, test_employee: Employee, db: Session):
+    """Тест обновления информации о текущем сотруднике."""
+    response = client.put(
+        "/api/employees/me",
+        headers={"Authorization": f"Bearer {employee_token}"},
+        json={
+            "full_name": "Updated Name",
+            "department": "Support"
+        }
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["full_name"] == "Updated Name"
+    assert data["email"] == test_employee.email
+    assert data["department"] == "Support" 

backend/tests/test_requests.py

@@ -0,0 +1,168 @@
+"""Request tests."""
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy.orm import Session
+from app.models.employee import Employee
+from app.models.request import Request
+
+def test_create_request(client: TestClient, employee_token: str, db: Session):
+    """Тест создания заявки."""
+    response = client.post(
+        "/api/requests",
+        headers={"Authorization": f"Bearer {employee_token}"},
+        json={
+            "request_type": "support",
+            "description": "Test Description",
+            "priority": "medium"
+        }
+    )
+    assert response.status_code == 201
+    data = response.json()
+    assert data["request_type"] == "support"
+    assert data["description"] == "Test Description"
+    assert data["priority"] == "medium"
+    assert data["status"] == "new"
+    assert "id" in data
+
+def test_create_request_unauthorized(client: TestClient):
+    """Тест создания заявки без авторизации."""
+    response = client.post(
+        "/api/requests",
+        json={
+            "request_type": "support",
+            "description": "Test Description",
+            "priority": "medium"
+        }
+    )
+    assert response.status_code == 401
+    assert response.json()["detail"] == "Not authenticated"
+
+def test_get_employee_requests(client: TestClient, employee_token: str, test_employee: Employee, db: Session):
+    """Тест получения списка заявок сотрудника."""
+    db.add(test_employee)
+    db.commit()
+    db.refresh(test_employee)
+    
+    # Создаем тестовую заявку
+    request = Request(
+        request_type="support",
+        description="Test Description",
+        priority="medium",
+        status="new",
+        employee_id=test_employee.id
+    )
+    db.add(request)
+    db.commit()
+
+    response = client.get(
+        "/api/requests/my",
+        headers={"Authorization": f"Bearer {employee_token}"}
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert isinstance(data, list)
+    assert len(data) > 0
+    assert data[0]["request_type"] == "support"
+    assert data[0]["description"] == "Test Description"
+
+def test_admin_get_all_requests(client: TestClient, admin_token: str, test_employee: Employee, db: Session):
+    """Тест получения всех заявок администратором."""
+    db.add(test_employee)
+    db.commit()
+    db.refresh(test_employee)
+    
+    # Создаем тестовую заявку
+    request = Request(
+        request_type="support",
+        description="Test Description",
+        priority="medium",
+        status="new",
+        employee_id=test_employee.id
+    )
+    db.add(request)
+    db.commit()
+
+    response = client.get(
+        "/api/requests/admin",
+        headers={"Authorization": f"Bearer {admin_token}"}
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert isinstance(data, list)
+    assert len(data) > 0
+    assert data[0]["request_type"] == "support"
+    assert data[0]["description"] == "Test Description"
+
+def test_update_request_status(client: TestClient, admin_token: str, test_employee: Employee, db: Session):
+    """Тест обновления статуса заявки."""
+    db.add(test_employee)
+    db.commit()
+    db.refresh(test_employee)
+    
+    # Создаем тестовую заявку
+    request = Request(
+        request_type="support",
+        description="Test Description",
+        priority="medium",
+        status="new",
+        employee_id=test_employee.id,
+        department=test_employee.department
+    )
+    db.add(request)
+    db.commit()
+
+    response = client.patch(
+        f"/api/requests/{request.id}/status",
+        headers={"Authorization": f"Bearer {admin_token}"},
+        json={"status": "in_progress"}
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "in_progress"
+
+def test_get_request_statistics(client: TestClient, admin_token: str, test_employee: Employee, db: Session):
+    """Тест получения статистики по заявкам."""
+    db.add(test_employee)
+    db.commit()
+    db.refresh(test_employee)
+    
+    # Создаем тестовые заявки с разными статусами
+    requests = [
+        Request(
+            request_type="support",
+            description="Test Description",
+            priority="medium",
+            status="new",
+            employee_id=test_employee.id,
+            department=test_employee.department
+        ),
+        Request(
+            request_type="support",
+            description="Test Description",
+            priority="high",
+            status="in_progress",
+            employee_id=test_employee.id,
+            department=test_employee.department
+        ),
+        Request(
+            request_type="support",
+            description="Test Description",
+            priority="low",
+            status="completed",
+            employee_id=test_employee.id,
+            department=test_employee.department
+        )
+    ]
+    for req in requests:
+        db.add(req)
+    db.commit()
+
+    response = client.get(
+        "/api/statistics",
+        headers={"Authorization": f"Bearer {admin_token}"}
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert "total" in data
+    assert "by_status" in data
+    assert data["total"] >= 3