Pre_Seg_Server/backend/tests/test_media.py

def test_upload_rejects_unsupported_file_type(client):
    response = client.post(
        "/api/media/upload",
        files={"file": ("notes.txt", b"text", "text/plain")},
    )

    assert response.status_code == 400
    assert "Unsupported file type" in response.json()["detail"]


def test_upload_auto_creates_project(client, monkeypatch):
    uploaded = []
    monkeypatch.setattr("routers.media.upload_file", lambda object_name, data, content_type, length: uploaded.append(object_name))
    monkeypatch.setattr("routers.media.get_presigned_url", lambda object_name, expires=3600: f"http://storage/{object_name}")

    response = client.post(
        "/api/media/upload",
        files={"file": ("clip.mp4", b"video", "video/mp4")},
    )

    assert response.status_code == 201
    data = response.json()
    assert data["project_id"] is not None
    assert data["object_name"] == f"uploads/{data['project_id']}/clip.mp4"
    assert uploaded == ["uploads/general/clip.mp4", f"uploads/{data['project_id']}/clip.mp4"]


def test_upload_links_existing_project(client, monkeypatch):
    project = client.post("/api/projects", json={"name": "Existing"}).json()
    monkeypatch.setattr("routers.media.upload_file", lambda *args, **kwargs: None)
    monkeypatch.setattr("routers.media.get_presigned_url", lambda object_name, expires=3600: f"http://storage/{object_name}")

    response = client.post(
        "/api/media/upload",
        data={"project_id": str(project["id"])},
        files={"file": ("clip.mp4", b"video", "video/mp4")},
    )

    assert response.status_code == 201
    detail = client.get(f"/api/projects/{project['id']}").json()
    assert detail["video_path"] == f"uploads/{project['id']}/clip.mp4"


def test_upload_dicom_batch_filters_files_and_creates_project(client, monkeypatch):
    uploaded = []
    monkeypatch.setattr("routers.media.upload_file", lambda object_name, data, content_type, length: uploaded.append(object_name))

    response = client.post(
        "/api/media/upload/dicom",
        files=[
            ("files", ("a.dcm", b"dcm", "application/dicom")),
            ("files", ("skip.txt", b"text", "text/plain")),
        ],
    )

    assert response.status_code == 201
    data = response.json()
    assert data["uploaded_count"] == 1
    assert uploaded == [f"uploads/{data['project_id']}/dicom/a.dcm"]


def test_parse_media_queues_background_task(client, monkeypatch):
    project = client.post("/api/projects", json={
        "name": "Parse Me",
        "video_path": "uploads/1/clip.mp4",
        "source_type": "video",
        "parse_fps": 5,
    }).json()

    class FakeAsyncResult:
        id = "celery-1"

    queued = []
    monkeypatch.setattr("routers.media.parse_project_media.delay", lambda task_id: queued.append(task_id) or FakeAsyncResult())
    published = []
    monkeypatch.setattr("routers.media.publish_task_progress_event", lambda task: published.append(task.id))

    response = client.post(f"/api/media/parse?project_id={project['id']}")

    assert response.status_code == 202
    data = response.json()
    assert data["task_type"] == "parse_video"
    assert data["status"] == "queued"
    assert data["progress"] == 0
    assert data["project_id"] == project["id"]
    assert data["celery_task_id"] == "celery-1"
    assert data["payload"] == {
        "source_type": "video",
        "parse_fps": 5.0,
        "max_frames": None,
        "target_width": 640,
    }
    assert queued == [data["id"]]
    assert published == [data["id"]]

    detail = client.get(f"/api/tasks/{data['id']}")
    assert detail.status_code == 200
    assert detail.json()["status"] == "queued"
    project_detail = client.get(f"/api/projects/{project['id']}").json()
    assert project_detail["status"] == "parsing"


def test_parse_media_accepts_frame_sequence_options(client, monkeypatch):
    project = client.post("/api/projects", json={
        "name": "Parse Options",
        "video_path": "uploads/1/clip.mp4",
        "source_type": "video",
        "parse_fps": 30,
    }).json()

    class FakeAsyncResult:
        id = "celery-options"

    monkeypatch.setattr("routers.media.parse_project_media.delay", lambda task_id: FakeAsyncResult())
    monkeypatch.setattr("routers.media.publish_task_progress_event", lambda task: None)

    response = client.post(
        f"/api/media/parse?project_id={project['id']}&parse_fps=15&max_frames=120&target_width=960"
    )

    assert response.status_code == 202
    data = response.json()
    assert data["payload"] == {
        "source_type": "video",
        "parse_fps": 15.0,
        "max_frames": 120,
        "target_width": 960,
    }
    assert client.get(f"/api/projects/{project['id']}").json()["parse_fps"] == 15.0


def test_parse_task_runner_registers_frames(client, db_session, monkeypatch, tmp_path):
    from models import ProcessingTask
    from services.media_task_runner import run_parse_media_task

    project = client.post("/api/projects", json={
        "name": "Parse Me",
        "video_path": "uploads/1/clip.mp4",
        "source_type": "video",
        "parse_fps": 5,
    }).json()
    task = ProcessingTask(
        task_type="parse_video",
        status="queued",
        progress=0,
        project_id=project["id"],
        payload={"source_type": "video"},
    )
    db_session.add(task)
    db_session.commit()
    db_session.refresh(task)
    frame_file = tmp_path / "frame_000001.jpg"
    frame_file.write_bytes(b"fake image")

    monkeypatch.setattr("services.media_task_runner.download_file", lambda object_name: b"video")
    monkeypatch.setattr(
        "services.media_task_runner.parse_video",
        lambda local_path, output_dir, fps, max_frames=None, target_width=640: ([str(frame_file)], 25.0),
    )
    monkeypatch.setattr("services.media_task_runner.extract_thumbnail", lambda local_path, thumbnail_path: open(thumbnail_path, "wb").write(b"thumb"))
    monkeypatch.setattr("services.media_task_runner.upload_file", lambda *args, **kwargs: None)
    monkeypatch.setattr("services.media_task_runner.upload_frames_to_minio", lambda frame_files, project_id: [f"projects/{project_id}/frames/frame_000001.jpg"])
    monkeypatch.setattr("routers.projects.get_presigned_url", lambda object_name, expires=3600: f"http://storage/{object_name}")
    published = []
    monkeypatch.setattr(
        "services.media_task_runner.publish_task_progress_event",
        lambda event_task: published.append((event_task.status, event_task.progress, event_task.message)),
    )

    result = run_parse_media_task(db_session, task.id)

    assert result["frames_extracted"] == 1
    assert result["frame_sequence"] == {
        "original_fps": 25.0,
        "parse_fps": 5.0,
        "frame_count": 1,
        "duration_ms": 0.0,
        "target_width": 640,
        "frame_width": None,
        "frame_height": None,
        "max_frames": None,
        "object_prefix": f"projects/{project['id']}/frames",
    }
    db_session.refresh(task)
    assert task.status == "success"
    assert task.progress == 100
    assert ("running", 5, "后台解析已启动") in published
    assert ("success", 100, "解析完成") in published
    project_detail = client.get(f"/api/projects/{project['id']}").json()
    assert project_detail["status"] == "ready"
    frames = client.get(f"/api/projects/{project['id']}/frames").json()
    assert "frame_000001.jpg" in frames[0]["image_url"]
    assert frames[0]["timestamp_ms"] == 0.0
    assert frames[0]["source_frame_number"] == 0


def test_parse_task_runner_skips_already_cancelled_task(db_session):
    from models import ProcessingTask
    from services.media_task_runner import run_parse_media_task

    task = ProcessingTask(
        task_type="parse_video",
        status="cancelled",
        progress=100,
        message="任务已取消",
        project_id=1,
        payload={"source_type": "video"},
    )
    db_session.add(task)
    db_session.commit()
    db_session.refresh(task)

    result = run_parse_media_task(db_session, task.id)

    assert result["status"] == "cancelled"
    assert result["message"] == "任务已取消"