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

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