joaju 0.1.0

A scientific academic compiler and typographical orchestrator in Rust for Typst, clinical pedigrees, and tables
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use axum::body::Body;
use axum::http::{header, Request, StatusCode};
use http_body_util::BodyExt;
use joaju::create_app;
use serde_json::json;
use tower::ServiceExt;

#[tokio::test]
async fn test_spec_compile_markdown_to_pdf() {
    let app = create_app();

    let input_markdown = r#"---
titulo: Relatório Clínico de Avaliação
autor: Dra. Lumen Pink
---

# Introdução

Este documento foi gerado pelo compilador in-process do Joaju.

```table
%% caption=Tabela de Frequências
Marcador | Frequência
D1S80 | 0.45
D2S1338 | 0.82
```

Fim do relatório."#;

    let payload = json!({
        "markdown": input_markdown
    });

    let response = app
        .oneshot(
            Request::builder()
                .method("POST")
                .uri("/compile")
                .header(header::CONTENT_TYPE, "application/json")
                .body(Body::from(serde_json::to_vec(&payload).unwrap()))
                .unwrap(),
        )
        .await
        .unwrap();

    let status = response.status();
    let content_type = response.headers().get(header::CONTENT_TYPE).cloned();
    let pdf_bytes = response.into_body().collect().await.unwrap().to_bytes();
    if status != StatusCode::OK {
        eprintln!("Response error: {}", String::from_utf8_lossy(&pdf_bytes));
    }
    assert_eq!(status, StatusCode::OK);
    assert_eq!(
        content_type.as_ref().map(|v| v.to_str().unwrap()),
        Some("application/pdf")
    );

    assert!(pdf_bytes.len() > 100);
    // PDF Magic Bytes: %PDF-
    assert_eq!(&pdf_bytes[0..5], b"%PDF-");
}

#[tokio::test]
async fn test_spec_compile_empty_markdown_returns_bad_request() {
    let app = create_app();

    let payload = json!({
        "markdown": "   "
    });

    let response = app
        .oneshot(
            Request::builder()
                .method("POST")
                .uri("/compile")
                .header(header::CONTENT_TYPE, "application/json")
                .body(Body::from(serde_json::to_vec(&payload).unwrap()))
                .unwrap(),
        )
        .await
        .unwrap();

    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}

#[tokio::test]
async fn test_spec_compile_markdown_with_pedigree_and_chem_to_pdf() {
    let app = create_app();

    let input_markdown = r#"---
titulo: Estudo Genético e Farmacológico
autor: Laboratório Joaju
---

# Heredograma

```pedtools
1 0 0 1 0
2 0 0 2 0
3 1 2 1 1
```

# Molécula

```openchemlib
CCO
```
"#;

    let payload = json!({
        "markdown": input_markdown
    });

    let response = app
        .oneshot(
            Request::builder()
                .method("POST")
                .uri("/compile")
                .header(header::CONTENT_TYPE, "application/json")
                .body(Body::from(serde_json::to_vec(&payload).unwrap()))
                .unwrap(),
        )
        .await
        .unwrap();

    let status = response.status();
    let pdf_bytes = response.into_body().collect().await.unwrap().to_bytes();
    if status != StatusCode::OK {
        eprintln!("Response error: {}", String::from_utf8_lossy(&pdf_bytes));
    }
    assert_eq!(status, StatusCode::OK);
    assert!(pdf_bytes.len() > 100);
    assert_eq!(&pdf_bytes[0..5], b"%PDF-");
}