Тесты для бекенда

backend/tests/conftest.py

@@ -1,34 +1,101 @@
 import pytest
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
-from fastapi.testclient import TestClient
-from app.database import Base, get_db
+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
 
-SQLALCHEMY_DATABASE_URL = "postgresql://postgres:postgres123@postgres:5432/support_db_test"
-
-engine = create_engine(SQLALCHEMY_DATABASE_URL)
+# Используем SQLite для тестов
+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)
 
-@pytest.fixture
-def db_session():
-    Base.metadata.drop_all(bind=engine)  # Сначала удаляем все таблицы
-    Base.metadata.create_all(bind=engine)  # Создаем таблицы заново
-    session = TestingSessionLocal()
-    try:
-        yield session
-    finally:
-        session.close()
-        Base.metadata.drop_all(bind=engine)
+# Создаем мок для Redis
+class RedisMock:
+    def __init__(self):
+        self.data = {}
 
-@pytest.fixture
-def client(db_session):
-    def override_get_db():
-        try:
-            yield db_session
-        finally:
-            db_session.close()
-            
-    app.dependency_overrides[get_db] = override_get_db
-    yield TestClient(app)
-    del app.dependency_overrides[get_db] 
+    def setex(self, name, time, value):
+        self.data[name] = 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]
+        return True
+
+@pytest.fixture(autouse=True)
+def mock_redis(monkeypatch):
+    redis_mock = RedisMock()
+    monkeypatch.setattr("app.utils.jwt.redis", redis_mock)
+    return redis_mock
+
+@pytest.fixture(scope="function")
+def test_db():
+    # Удаляем все таблицы
+    Base.metadata.drop_all(bind=engine)
+    # Создаем все таблицы заново
+    Base.metadata.create_all(bind=engine)
+    
+    # Создаем сессию
+    db = TestingSessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+@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"
+    )
+    employee = employees.create_employee(test_db, employee_data, hashed_password)
+    return employee
+
+@pytest.fixture(scope="function")
+def test_token(test_db, test_employee):
+    token = create_and_save_token(test_employee.id, test_db)
+    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 

backend/tests/test_auth.py

@@ -1,70 +1,98 @@
 import pytest
-from app.models.employee import Employee
-from app.utils.auth import get_password_hash
+from fastapi.testclient import TestClient
+from sqlalchemy.orm import Session
+from app.main import app
+from app.crud import employees
+from app.utils.auth import verify_password, get_password_hash
+from app.schemas.employee import EmployeeCreate
 
-def test_admin_login(client):
-    """Test admin login endpoint"""
-    response = client.post("/api/auth/admin", json={
-        "username": "admin",
-        "password": "admin123"
-    })
+client = TestClient(app)
+
+def test_login_success(test_db: Session):
+    # Создаем тестового сотрудника
+    hashed_password = get_password_hash("testpass123")
+    employee_data = EmployeeCreate(
+        first_name="Test",
+        last_name="User",
+        department="IT",
+        office="101",
+        password="testpass123"
+    )
+    employee = employees.create_employee(test_db, employee_data, hashed_password)
+    
+    response = client.post(
+        "/api/auth/login",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        data={
+            "username": "User",
+            "password": "testpass123"
+        }
+    )
+    
     assert response.status_code == 200
     assert "access_token" in response.json()
+    assert response.json()["token_type"] == "bearer"
 
-def test_admin_login_invalid_credentials(client):
-    """Test admin login with invalid credentials"""
-    response = client.post("/api/auth/admin", json={
-        "username": "wrong",
-        "password": "wrong"
-    })
-    assert response.status_code == 401
-    assert response.json()["detail"] == "Invalid credentials"
-
-def test_employee_login(client, db_session):
-    """Test employee login endpoint"""
-    # Create test employee
-    hashed_password = get_password_hash("test123")
-    employee = Employee(
+def test_login_wrong_password(test_db: Session):
+    # Создаем тестового сотрудника
+    hashed_password = get_password_hash("testpass123")
+    employee_data = EmployeeCreate(
         first_name="Test",
         last_name="User",
         department="IT",
-        office="A101",
-        password=hashed_password
+        office="101",
+        password="testpass123"
     )
-    db_session.add(employee)
-    db_session.commit()
+    employees.create_employee(test_db, employee_data, hashed_password)
+    
+    response = client.post(
+        "/api/auth/login",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        data={
+            "username": "User",
+            "password": "wrongpass"
+        }
+    )
+    
+    assert response.status_code == 401
+    assert "detail" in response.json()
 
-    # Try to login
-    response = client.post("/api/auth/login", json={
-        "last_name": "User",
-        "password": "test123"
-    })
+def test_login_nonexistent_user(test_db: Session):
+    response = client.post(
+        "/api/auth/login",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        data={
+            "username": "NonExistent",
+            "password": "testpass123"
+        }
+    )
+    
+    assert response.status_code == 401
+    assert "detail" in response.json()
+
+def test_admin_login_success():
+    response = client.post(
+        "/api/auth/admin/login",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        data={
+            "username": "admin",
+            "password": "admin123"
+        }
+    )
+    
     assert response.status_code == 200
-    data = response.json()
-    assert data["first_name"] == "Test"
-    assert data["last_name"] == "User"
-    assert data["department"] == "IT"
-    assert data["office"] == "A101"
-    assert "access_token" in data
+    assert "access_token" in response.json()
+    assert response.json()["token_type"] == "bearer"
 
-def test_employee_login_invalid_credentials(client, db_session):
-    """Test employee login with invalid credentials"""
-    # Create test employee
-    hashed_password = get_password_hash("test123")
-    employee = Employee(
-        first_name="Test",
-        last_name="User",
-        department="IT",
-        office="A101",
-        password=hashed_password
+def test_admin_login_wrong_password():
+    response = client.post(
+        "/api/auth/admin/login",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        data={
+            "username": "admin",
+            "password": "wrongpass"
+        }
     )
-    db_session.add(employee)
-    db_session.commit()
-
-    # Try to login with wrong password
-    response = client.post("/api/auth/login", json={
-        "last_name": "User",
-        "password": "wrong"
-    })
+    
     assert response.status_code == 401
-    assert response.json()["detail"] == "Неверный пароль" 
+    assert "detail" in response.json() 

backend/tests/test_employees.py

@@ -1,18 +1,15 @@
 import pytest
-from app.models.employee import Employee
+from fastapi.testclient import TestClient
+from sqlalchemy.orm import Session
+from app.main import app
+from app.crud import employees
 from app.utils.auth import get_password_hash
+from app.schemas.employee import EmployeeCreate
 
-def test_create_employee(client):
+client = TestClient(app)
+
+def test_create_employee(test_db: Session, admin_auth_header):
     """Test creating a new employee"""
-    # Login as admin
-    admin_response = client.post("/api/auth/admin", json={
-        "username": "admin",
-        "password": "admin123"
-    })
-    assert admin_response.status_code == 200
-    admin_token = admin_response.json()["access_token"]
-
-    # Create employee
     employee_data = {
         "first_name": "John",
         "last_name": "Doe",
@@ -20,8 +17,12 @@ def test_create_employee(client):
         "office": "B205",
         "password": "test123"
     }
-    headers = {"Authorization": f"Bearer {admin_token}"}
-    response = client.post("/api/employees/", json=employee_data, headers=headers)
+    
+    response = client.post(
+        "/api/employees/",
+        json=employee_data,
+        headers=admin_auth_header
+    )
     
     assert response.status_code == 200
     data = response.json()
@@ -31,48 +32,20 @@ def test_create_employee(client):
     assert data["office"] == employee_data["office"]
     assert "password" not in data
 
-def test_get_employees(client, db_session):
+def test_get_employees(test_db: Session, test_employee, admin_auth_header):
     """Test getting list of employees"""
-    # Create test employee
-    hashed_password = get_password_hash("test123")
-    employee = Employee(
-        first_name="Test",
-        last_name="User",
-        department="IT",
-        office="A101",
-        password=hashed_password
-    )
-    db_session.add(employee)
-    db_session.commit()
-    
-    # Сохраняем значения для проверки
-    expected_first_name = employee.first_name
-    expected_last_name = employee.last_name
-    expected_department = employee.department
-    expected_office = employee.office
-    
-    # Login as admin
-    admin_response = client.post("/api/auth/admin", json={
-        "username": "admin",
-        "password": "admin123"
-    })
-    assert admin_response.status_code == 200
-    admin_token = admin_response.json()["access_token"]
-    
-    # Get employees list
-    headers = {"Authorization": f"Bearer {admin_token}"}
-    response = client.get("/api/employees/", headers=headers)
+    response = client.get("/api/employees/", headers=admin_auth_header)
     
     assert response.status_code == 200
     data = response.json()
-    assert len(data) == 1
-    assert data[0]["first_name"] == expected_first_name
-    assert data[0]["last_name"] == expected_last_name
-    assert data[0]["department"] == expected_department
-    assert data[0]["office"] == expected_office
+    assert len(data) >= 1
+    assert data[0]["first_name"] == test_employee.first_name
+    assert data[0]["last_name"] == test_employee.last_name
+    assert data[0]["department"] == test_employee.department
+    assert data[0]["office"] == test_employee.office
     assert "password" not in data[0]
 
-def test_create_employee_unauthorized(client):
+def test_create_employee_unauthorized(test_db: Session):
     """Test creating employee without authorization"""
     employee_data = {
         "first_name": "John",
@@ -82,82 +55,42 @@ def test_create_employee_unauthorized(client):
         "password": "test123"
     }
     response = client.post("/api/employees/", json=employee_data)
-    assert response.status_code == 401
+    assert response.status_code == 401  # Unauthorized
 
-def test_get_employees_unauthorized(client):
+def test_get_employees_unauthorized(test_db: Session):
     """Test getting employees list without authorization"""
     response = client.get("/api/employees/")
-    assert response.status_code == 401
+    assert response.status_code == 401  # Unauthorized
 
-def test_get_employee_by_id(client, db_session):
+def test_get_employee_by_id(test_db: Session, test_employee, admin_auth_header):
     """Test getting employee by ID"""
-    # Create test employee
-    hashed_password = get_password_hash("test123")
-    employee = Employee(
-        first_name="Test",
-        last_name="User",
-        department="IT",
-        office="A101",
-        password=hashed_password
+    response = client.get(
+        f"/api/employees/{test_employee.id}",
+        headers=admin_auth_header
     )
-    db_session.add(employee)
-    db_session.commit()
-    
-    employee_id = employee.id
-    
-    # Login as admin
-    admin_response = client.post("/api/auth/admin", json={
-        "username": "admin",
-        "password": "admin123"
-    })
-    assert admin_response.status_code == 200
-    admin_token = admin_response.json()["access_token"]
-    
-    # Get employee
-    headers = {"Authorization": f"Bearer {admin_token}"}
-    response = client.get(f"/api/employees/{employee_id}", headers=headers)
     
     assert response.status_code == 200
     data = response.json()
-    assert data["first_name"] == "Test"
-    assert data["last_name"] == "User"
-    assert data["department"] == "IT"
-    assert data["office"] == "A101"
+    assert data["first_name"] == test_employee.first_name
+    assert data["last_name"] == test_employee.last_name
+    assert data["department"] == test_employee.department
+    assert data["office"] == test_employee.office
     assert "password" not in data
 
-def test_update_employee(client, db_session):
+def test_update_employee(test_db: Session, test_employee, admin_auth_header):
     """Test updating employee data"""
-    # Create test employee
-    hashed_password = get_password_hash("test123")
-    employee = Employee(
-        first_name="Test",
-        last_name="User",
-        department="IT",
-        office="A101",
-        password=hashed_password
-    )
-    db_session.add(employee)
-    db_session.commit()
-    
-    employee_id = employee.id
-    
-    # Login as admin
-    admin_response = client.post("/api/auth/admin", json={
-        "username": "admin",
-        "password": "admin123"
-    })
-    assert admin_response.status_code == 200
-    admin_token = admin_response.json()["access_token"]
-    
-    # Update employee
     update_data = {
         "first_name": "Updated",
         "last_name": "Name",
         "department": "HR",
         "office": "B202"
     }
-    headers = {"Authorization": f"Bearer {admin_token}"}
-    response = client.put(f"/api/employees/{employee_id}", json=update_data, headers=headers)
+    
+    response = client.put(
+        f"/api/employees/{test_employee.id}",
+        json=update_data,
+        headers=admin_auth_header
+    )
     
     assert response.status_code == 200
     data = response.json()
@@ -167,36 +100,18 @@ def test_update_employee(client, db_session):
     assert data["office"] == update_data["office"]
     assert "password" not in data
 
-def test_delete_employee(client, db_session):
+def test_delete_employee(test_db: Session, test_employee, admin_auth_header):
     """Test deleting employee"""
-    # Create test employee
-    hashed_password = get_password_hash("test123")
-    employee = Employee(
-        first_name="Test",
-        last_name="User",
-        department="IT",
-        office="A101",
-        password=hashed_password
+    response = client.delete(
+        f"/api/employees/{test_employee.id}",
+        headers=admin_auth_header
     )
-    db_session.add(employee)
-    db_session.commit()
-    
-    employee_id = employee.id
-    
-    # Login as admin
-    admin_response = client.post("/api/auth/admin", json={
-        "username": "admin",
-        "password": "admin123"
-    })
-    assert admin_response.status_code == 200
-    admin_token = admin_response.json()["access_token"]
-    
-    # Delete employee
-    headers = {"Authorization": f"Bearer {admin_token}"}
-    response = client.delete(f"/api/employees/{employee_id}", headers=headers)
     
     assert response.status_code == 200
     
     # Verify employee is deleted
-    get_response = client.get(f"/api/employees/{employee_id}", headers=headers)
+    get_response = client.get(
+        f"/api/employees/{test_employee.id}",
+        headers=admin_auth_header
+    )
     assert get_response.status_code == 404 

backend/tests/test_requests.py

@@ -1,333 +1,164 @@
 import pytest
-from app.models.request import Request, RequestStatus, RequestPriority
-from app.models.employee import Employee
-from app.utils.auth import get_password_hash
-from datetime import datetime, timedelta
+from fastapi.testclient import TestClient
+from sqlalchemy.orm import Session
+from app.main import app
+from app.models.request import RequestStatus, RequestPriority
+from app.crud import requests
+from app.schemas.request import RequestCreate
 
-def test_create_request(client, db_session):
+client = TestClient(app)
+
+def test_create_request(test_db: Session, test_employee, test_auth_header):
     """Test creating a new request"""
-    # Create test employee
-    hashed_password = get_password_hash("test123")
-    employee = Employee(
-        first_name="Test",
-        last_name="User",
-        department="IT",
-        office="A101",
-        password=hashed_password
-    )
-    db_session.add(employee)
-    db_session.commit()
-    employee_id = employee.id
-
-    # Login as employee
-    login_response = client.post("/api/auth/login", json={
-        "last_name": "User",
-        "password": "test123"
-    })
-    assert login_response.status_code == 200
-    token = login_response.json()["access_token"]
-
-    # Create request
     request_data = {
-        "title": "Test Request",
+        "department": "IT",
+        "request_type": "hardware",
         "description": "This is a test request",
         "priority": RequestPriority.MEDIUM.value
     }
-    headers = {"Authorization": f"Bearer {token}"}
-    response = client.post("/api/requests/", json=request_data, headers=headers)
+    
+    response = client.post(
+        "/api/requests/",
+        json=request_data,
+        headers=test_auth_header
+    )
     
     assert response.status_code == 200
     data = response.json()
-    assert data["title"] == request_data["title"]
+    assert data["department"] == request_data["department"]
     assert data["description"] == request_data["description"]
     assert data["priority"] == request_data["priority"]
     assert data["status"] == RequestStatus.NEW.value
-    assert data["employee_id"] == employee_id
+    assert "employee_id" in data
 
-def test_get_employee_requests(client, db_session):
+def test_get_employee_requests(test_db: Session, test_employee, test_auth_header):
     """Test getting employee's requests"""
-    # Create test employee
-    hashed_password = get_password_hash("test123")
-    employee = Employee(
-        first_name="Test",
-        last_name="User",
+    # Создаем тестовую заявку
+    request_data = RequestCreate(
         department="IT",
-        office="A101",
-        password=hashed_password
-    )
-    db_session.add(employee)
-    db_session.commit()
-    employee_id = employee.id
-
-    # Create test request and save its data
-    request = Request(
-        title="Test Request",
+        request_type="hardware",
         description="This is a test request",
-        priority=RequestPriority.MEDIUM.value,
-        status=RequestStatus.NEW.value,
-        employee_id=employee_id
+        priority=RequestPriority.MEDIUM.value
     )
-    db_session.add(request)
-    db_session.commit()
+    test_request = requests.create_request(test_db, request_data, test_employee.id)
     
-    # Сохраняем данные для сравнения
-    expected_data = {
-        "title": request.title,
-        "description": request.description,
-        "priority": request.priority,
-        "status": request.status,
-        "employee_id": request.employee_id
-    }
-
-    # Login as employee
-    login_response = client.post("/api/auth/login", json={
-        "last_name": "User",
-        "password": "test123"
-    })
-    assert login_response.status_code == 200
-    token = login_response.json()["access_token"]
-
-    # Get requests
-    headers = {"Authorization": f"Bearer {token}"}
-    response = client.get("/api/requests/my", headers=headers)
+    response = client.get("/api/requests/my", headers=test_auth_header)
     
     assert response.status_code == 200
     data = response.json()
     assert len(data) == 1
-    assert data[0]["title"] == expected_data["title"]
-    assert data[0]["description"] == expected_data["description"]
-    assert data[0]["priority"] == expected_data["priority"]
-    assert data[0]["status"] == expected_data["status"]
-    assert data[0]["employee_id"] == expected_data["employee_id"]
+    assert data[0]["department"] == test_request.department
+    assert data[0]["description"] == test_request.description
+    assert data[0]["priority"] == test_request.priority
+    assert data[0]["status"] == test_request.status
+    assert data[0]["employee_id"] == test_request.employee_id
 
-def test_update_request_status(client, db_session):
+def test_update_request_status(test_db: Session, test_employee, admin_auth_header):
     """Test updating request status"""
-    # Create test employee and request
-    hashed_password = get_password_hash("test123")
-    employee = Employee(
-        first_name="Test",
-        last_name="User",
+    # Создаем тестовую заявку
+    request_data = RequestCreate(
         department="IT",
-        office="A101",
-        password=hashed_password
-    )
-    db_session.add(employee)
-    db_session.commit()
-    employee_id = employee.id
-
-    request = Request(
-        title="Test Request",
+        request_type="hardware",
         description="This is a test request",
-        priority=RequestPriority.MEDIUM.value,
-        status=RequestStatus.NEW.value,
-        employee_id=employee_id
+        priority=RequestPriority.MEDIUM.value
     )
-    db_session.add(request)
-    db_session.commit()
-    request_id = request.id
-
-    # Login as admin
-    admin_response = client.post("/api/auth/admin", json={
-        "username": "admin",
-        "password": "admin123"
-    })
-    assert admin_response.status_code == 200
-    admin_token = admin_response.json()["access_token"]
-
-    # Update request status
+    test_request = requests.create_request(test_db, request_data, test_employee.id)
+    
     update_data = {"status": RequestStatus.IN_PROGRESS.value}
-    headers = {"Authorization": f"Bearer {admin_token}"}
-    response = client.patch(f"/api/requests/{request_id}/status", json=update_data, headers=headers)
-
+    response = client.patch(
+        f"/api/requests/{test_request.id}/status",
+        json=update_data,
+        headers=admin_auth_header
+    )
+    
     assert response.status_code == 200
     data = response.json()
     assert data["status"] == RequestStatus.IN_PROGRESS.value
 
-def test_get_all_requests_admin(client, db_session):
+def test_get_all_requests_admin(test_db: Session, test_employee, admin_auth_header):
     """Test getting all requests as admin"""
-    # Create test employees and requests
-    hashed_password = get_password_hash("test123")
-    employee1 = Employee(
-        first_name="Test1",
-        last_name="User1",
+    # Создаем тестовую заявку
+    request_data = RequestCreate(
         department="IT",
-        office="A101",
-        password=hashed_password
+        request_type="hardware",
+        description="This is a test request",
+        priority=RequestPriority.MEDIUM.value
     )
-    employee2 = Employee(
-        first_name="Test2",
-        last_name="User2",
-        department="HR",
-        office="B202",
-        password=hashed_password
-    )
-    db_session.add_all([employee1, employee2])
-    db_session.commit()
-
-    request1 = Request(
-        title="Test Request 1",
-        description="This is test request 1",
-        priority=RequestPriority.HIGH.value,
-        status=RequestStatus.NEW.value,
-        employee_id=employee1.id
-    )
-    request2 = Request(
-        title="Test Request 2",
-        description="This is test request 2",
-        priority=RequestPriority.MEDIUM.value,
-        status=RequestStatus.IN_PROGRESS.value,
-        employee_id=employee2.id
-    )
-    db_session.add_all([request1, request2])
-    db_session.commit()
+    test_request = requests.create_request(test_db, request_data, test_employee.id)
     
-    # Сохраняем данные для сравнения
-    expected_titles = {request1.title, request2.title}
-
-    # Login as admin
-    admin_response = client.post("/api/auth/admin", json={
-        "username": "admin",
-        "password": "admin123"
-    })
-    assert admin_response.status_code == 200
-    admin_token = admin_response.json()["access_token"]
-
-    # Get all requests
-    headers = {"Authorization": f"Bearer {admin_token}"}
-    response = client.get("/api/requests/admin", headers=headers)
-
-    assert response.status_code == 200
-    data = response.json()
-    assert len(data) == 2
-    received_titles = {r["title"] for r in data}
-    assert received_titles == expected_titles
-
-def test_get_requests_by_status(client, db_session):
-    """Test filtering requests by status"""
-    # Create test employee and requests
-    hashed_password = get_password_hash("test123")
-    employee = Employee(
-        first_name="Test",
-        last_name="User",
-        department="IT",
-        office="A101",
-        password=hashed_password
-    )
-    db_session.add(employee)
-    db_session.commit()
-
-    request1 = Request(
-        title="New Request",
-        description="This is a new request",
-        priority=RequestPriority.HIGH.value,
-        status=RequestStatus.NEW.value,
-        employee_id=employee.id
-    )
-    request2 = Request(
-        title="In Progress Request",
-        description="This is an in progress request",
-        priority=RequestPriority.MEDIUM.value,
-        status=RequestStatus.IN_PROGRESS.value,
-        employee_id=employee.id
-    )
-    db_session.add_all([request1, request2])
-    db_session.commit()
+    response = client.get("/api/requests/admin", headers=admin_auth_header)
     
-    # Сохраняем данные для сравнения
-    expected_data = {
-        "title": request1.title,
-        "status": request1.status
-    }
-
-    # Login as admin
-    admin_response = client.post("/api/auth/admin", json={
-        "username": "admin",
-        "password": "admin123"
-    })
-    assert admin_response.status_code == 200
-    admin_token = admin_response.json()["access_token"]
-
-    # Get requests filtered by status
-    headers = {"Authorization": f"Bearer {admin_token}"}
-    response = client.get(f"/api/requests/admin?status={RequestStatus.NEW.value}", headers=headers)
-
     assert response.status_code == 200
     data = response.json()
     assert len(data) == 1
-    assert data[0]["title"] == expected_data["title"]
-    assert data[0]["status"] == expected_data["status"]
+    assert data[0]["department"] == test_request.department
 
-def test_get_request_statistics(client, db_session):
-    """Test getting request statistics"""
-    # Create test employee and requests
-    hashed_password = get_password_hash("test123")
-    employee = Employee(
-        first_name="Test",
-        last_name="User",
+def test_get_requests_by_status(test_db: Session, test_employee, admin_auth_header):
+    """Test filtering requests by status"""
+    # Создаем тестовую заявку
+    request_data = RequestCreate(
         department="IT",
-        office="A101",
-        password=hashed_password
+        request_type="hardware",
+        description="This is a test request",
+        priority=RequestPriority.MEDIUM.value
     )
-    db_session.add(employee)
-    db_session.commit()
-
-    # Create requests with different statuses
-    requests_data = [
-        {"status": RequestStatus.NEW.value, "priority": RequestPriority.HIGH.value},
-        {"status": RequestStatus.IN_PROGRESS.value, "priority": RequestPriority.MEDIUM.value},
-        {"status": RequestStatus.COMPLETED.value, "priority": RequestPriority.LOW.value},
-        {"status": RequestStatus.NEW.value, "priority": RequestPriority.HIGH.value}
-    ]
-
-    for i, data in enumerate(requests_data):
-        request = Request(
-            title=f"Request {i+1}",
-            description=f"This is request {i+1}",
-            priority=data["priority"],
-            status=data["status"],
-            employee_id=employee.id
-        )
-        db_session.add(request)
-    db_session.commit()
-
-    # Login as admin
-    admin_response = client.post("/api/auth/admin", json={
-        "username": "admin",
-        "password": "admin123"
-    })
-    assert admin_response.status_code == 200
-    admin_token = admin_response.json()["access_token"]
-
-    # Get statistics
-    headers = {"Authorization": f"Bearer {admin_token}"}
-    response = client.get("/api/requests/statistics", headers=headers)
-
+    test_request = requests.create_request(test_db, request_data, test_employee.id)
+    
+    response = client.get(
+        f"/api/requests/admin?status={RequestStatus.NEW.value}",
+        headers=admin_auth_header
+    )
+    
     assert response.status_code == 200
     data = response.json()
-    
-    # Проверяем статистику
-    assert "total_requests" in data
-    assert data["total_requests"] == 4
-    assert "by_status" in data
-    assert data["by_status"]["new"] == 2
-    assert data["by_status"]["in_progress"] == 1
-    assert data["by_status"]["completed"] == 1
-    assert "by_priority" in data
-    assert data["by_priority"]["high"] == 2
-    assert data["by_priority"]["medium"] == 1
-    assert data["by_priority"]["low"] == 1
+    assert len(data) == 1
+    assert data[0]["status"] == RequestStatus.NEW.value
 
-def test_create_request_unauthorized(client):
+def test_get_request_statistics(test_db: Session, test_employee, admin_auth_header):
+    """Test getting request statistics"""
+    # Создаем тестовые заявки с разными статусами
+    requests_data = [
+        RequestCreate(
+            department="IT",
+            request_type="hardware",
+            description="Test request 1",
+            priority=RequestPriority.HIGH.value
+        ),
+        RequestCreate(
+            department="IT",
+            request_type="software",
+            description="Test request 2",
+            priority=RequestPriority.MEDIUM.value
+        )
+    ]
+    
+    for data in requests_data:
+        requests.create_request(test_db, data, test_employee.id)
+    
+    response = client.get("/api/requests/statistics", headers=admin_auth_header)
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert "total" in data
+    assert "by_status" in data
+    assert data["total"] == 2
+    assert data["by_status"][RequestStatus.NEW.value] == 2
+    assert data["by_status"][RequestStatus.IN_PROGRESS.value] == 0
+    assert data["by_status"][RequestStatus.COMPLETED.value] == 0
+    assert data["by_status"][RequestStatus.REJECTED.value] == 0
+
+def test_create_request_unauthorized(test_db: Session):
     """Test creating request without authorization"""
     request_data = {
-        "title": "Test Request",
+        "department": "IT",
+        "request_type": "hardware",
         "description": "This is a test request",
         "priority": RequestPriority.MEDIUM.value
     }
     response = client.post("/api/requests/", json=request_data)
     assert response.status_code == 401
 
-def test_get_requests_unauthorized(client):
+def test_get_requests_unauthorized(test_db: Session):
     """Test getting requests without authorization"""
     response = client.get("/api/requests/my")
     assert response.status_code == 401