mineru 0.5.0

Rust client, CLI, and API server for OpenAI-compatible MinerU document parsing
Documentation
#[cfg(test)]
mod tests {
    use crate::official_api::wire::*;
    use axum::response::IntoResponse;
    use serde_json::json;

    #[test]
    fn create_request_defaults_and_validation() {
        let request: CreateTaskRequest =
            serde_json::from_value(json!({"files":[{"file_name":"a.pdf","bytes":4}]})).unwrap();
        request.validate().unwrap();
        assert_eq!(request.page_range, "");
        assert_eq!(request.output_formats, vec![TaskOutputFormat::Default]);
        let deduped: CreateTaskRequest = serde_json::from_value(json!({
            "files": [{"file_name": "a.pdf", "bytes": 4}],
            "output_formats": ["docx", "default", "docx"]
        }))
        .unwrap();
        assert_eq!(
            deduped.normalized_formats(),
            vec![TaskOutputFormat::Docx, TaskOutputFormat::Default]
        );
        assert!(
            serde_json::from_value::<CreateTaskRequest>(
                json!({"files":[{"file_name":"a","bytes":1,"local_path":"/tmp/a"}]})
            )
            .is_err()
        );
        assert!(
            serde_json::from_value::<CreateTaskRequest>(
                json!({"files":[{"file_name":"a.pdf","bytes":1}],"unexpected":true})
            )
            .is_err()
        );
        assert!(
            serde_json::from_value::<CreateTaskRequest>(
                json!({"files":[{"file_name":"a.pdf","bytes":0}]})
            )
            .unwrap()
            .validate()
            .is_err()
        );
        assert!(
            serde_json::from_value::<CreateTaskRequest>(json!({"files":[{"file_name":"a.pdf"}]}))
                .unwrap()
                .validate()
                .is_err()
        );
        assert!(
            serde_json::from_value::<CreateTaskRequest>(
                json!({"files":[{"file_name":"a.pdf","url":"https://x","bytes":1}]})
            )
            .unwrap()
            .validate()
            .is_err()
        );
        assert!(
            serde_json::from_value::<CreateTaskRequest>(json!({"files":[]}))
                .unwrap()
                .validate()
                .is_err()
        );
        assert!(
            serde_json::from_value::<CreateTaskRequest>(
                json!({"files":[{"file_name":"a.pdf","bytes":1}],"output_formats":[]})
            )
            .unwrap()
            .validate()
            .is_err()
        );
        for value in [
            "", " all ", "3-r1", "r3-5", "r1-r1", "1-1", "r3-r1", " 3 - r1 ",
        ] {
            assert!(validate_page_range(value).is_ok(), "{value}");
        }
        for value in ["r1-r3", "3-1", "r0", "+1", "01", "1,,2"] {
            assert!(validate_page_range(value).is_err(), "{value}");
        }
    }

    #[test]
    fn file_inputs_validate_names_hashes_and_sources() {
        let mut input: TaskFileInput = serde_json::from_value(json!({
            "file_name": "report.pdf", "bytes": 10
        }))
        .unwrap();
        input.validate(0).unwrap();
        input.file_name = "../escape.pdf".into();
        assert!(input.validate(0).is_err());
        input.file_name = "report.pdf".into();
        input.sha256sum = Some("A".repeat(64));
        assert!(input.validate(0).is_err());
        input.sha256sum = Some("a".repeat(64));
        input.validate(0).unwrap();
        input.page_range = Some("1-5".into());
        input.validate(0).unwrap();
        input.page_range = Some("r3-r1".into());
        input.validate(0).unwrap();
        input.page_range = Some("r1-r3".into());
        assert!(input.validate(0).is_err());
    }

    #[test]
    fn task_payloads_omit_absent_optionals_and_keep_zero_progress() {
        let created = CreateTaskResponse {
            task_id: "job_1".into(),
            status: TaskStatus::WaitingFile,
            files: vec![CreatedTaskFile {
                file_id: "file_1".into(),
                file_name: "a.pdf".into(),
                status: TaskFileState::WaitingFile,
                upload: None,
            }],
        };
        let value = serde_json::to_value(created).unwrap();
        assert_eq!(value["files"][0]["status"], "waiting-file");
        assert!(value["files"][0].get("upload").is_none());

        let detail = TaskDetailResponse {
            task_id: "job_1".into(),
            status: TaskStatus::Running,
            created_at: "2026-01-01T00:00:00Z".into(),
            started_at: None,
            finished_at: None,
            output_formats: vec![TaskOutputFormat::Default],
            progress: TaskProgress::default(),
            files: vec![TaskFileDetail {
                file_id: "file_1".into(),
                file_name: "a.pdf".into(),
                status: TaskFileState::Running,
                bytes: Some(4),
                url: None,
                upload: None,
                parse: None,
                result_url: None,
                error: None,
            }],
            error: None,
        };
        let value = serde_json::to_value(detail).unwrap();
        assert_eq!(value["progress"]["completed"], 0);
        assert_eq!(value["progress"]["failed"], 0);
        assert_eq!(value["progress"]["total"], 0);
        assert_eq!(value["created_at"], "2026-01-01T00:00:00Z");
        assert!(value.get("started_at").is_none());
    }

    #[test]
    fn health_and_error_envelope_are_official_v1() {
        let health = serde_json::to_value(Health::default()).unwrap();
        assert_eq!(health["status"], "ok");
        assert_eq!(health["version"], "4.2.3");
        assert_eq!(
            health["features"]["task_output_formats"],
            json!(["default", "docx", "html", "latex"])
        );
        assert_eq!(health["features"]["sources"], json!(["upload", "url"]));
        assert!(health.get("schema_version").is_none());

        let response = WireError::invalid("Invalid page range.", "page_range").into_response();
        assert_eq!(response.status(), axum::http::StatusCode::BAD_REQUEST);
        let response = WireError::too_large().into_response();
        assert_eq!(response.status(), axum::http::StatusCode::PAYLOAD_TOO_LARGE);

        let envelope = serde_json::to_value(ErrorResponse {
            error: ErrorDetail {
                code: "invalid_request".into(),
                message: "Invalid request".into(),
                param: None,
            },
        })
        .unwrap();
        assert!(envelope["error"].get("param").is_none());
        assert!(envelope["error"].get("type").is_none());
    }

    #[test]
    fn not_found_and_page_range_use_upstream_codes() {
        let task = WireError::task_not_found("job_1");
        assert_eq!(task.status, axum::http::StatusCode::NOT_FOUND);
        assert_eq!(task.code, "task_not_found");
        assert_eq!(task.message, "Task job_1 not found");

        let upload = WireError::upload_not_found();
        assert_eq!(upload.code, "upload_not_found");
        assert_eq!(upload.message, "Unknown file_id");

        let reversed = validate_page_range("5-2").unwrap_err();
        assert_eq!(reversed.code, "page_range_invalid");
        assert_eq!(reversed.param.as_deref(), Some("page_range"));
        assert_eq!(
            reversed.message,
            "Invalid page range '5-2': reversed ranges are not supported"
        );

        let malformed = validate_page_range("1,,2").unwrap_err();
        assert_eq!(malformed.code, "page_range_invalid");
        assert_eq!(
            malformed.message,
            "Invalid page range '1,,2': expected a page, an inclusive range, or 'all'"
        );
        assert!(validate_page_range("1-3,r1").is_ok());
    }
}