moadim 1.3.0

Loop engine for AI agents — routines over REST, MCP, and a built-in web UI
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180

//! Tests for `/client` (the React client, served alongside `ui/` — see `CLIENT_HTML`'s doc
//! comment in `http.rs`). Split out of `http_tests.rs` to keep that file under the line-count
//! gate, mirroring the existing `http_settings_routes_tests.rs` split.

use axum::{
    body::Body,
    http::{header::CONTENT_TYPE, Request, StatusCode},
};
use tower::ServiceExt;

use super::build_app;

#[tokio::test]
async fn build_app_serves_client() {
    let app = build_app(crate::routines::new_store());
    let resp = app
        .oneshot(
            Request::builder()
                .uri("/client")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::OK);
    let ctype = resp.headers().get(CONTENT_TYPE).unwrap();
    assert!(ctype.to_str().unwrap().starts_with("text/html"));
}

#[tokio::test]
async fn build_app_serves_client_with_etag() {
    let app = build_app(crate::routines::new_store());
    let resp = app
        .oneshot(
            Request::builder()
                .uri("/client")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::OK);
    let etag = resp
        .headers()
        .get(axum::http::header::ETAG)
        .expect("ETag header present")
        .to_str()
        .unwrap()
        .to_owned();
    assert!(etag.starts_with('"') && etag.ends_with('"'));
    assert_eq!(
        resp.headers()
            .get(axum::http::header::CACHE_CONTROL)
            .unwrap(),
        "no-cache"
    );
}

#[tokio::test]
async fn build_app_returns_304_for_client_when_if_none_match_matches() {
    let app = build_app(crate::routines::new_store());
    let first = app
        .clone()
        .oneshot(
            Request::builder()
                .uri("/client")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    let etag = first
        .headers()
        .get(axum::http::header::ETAG)
        .unwrap()
        .to_str()
        .unwrap()
        .to_owned();

    let resp = app
        .oneshot(
            Request::builder()
                .uri("/client")
                .header(axum::http::header::IF_NONE_MATCH, &etag)
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::NOT_MODIFIED);
    let body = axum::body::to_bytes(resp.into_body(), usize::MAX)
        .await
        .unwrap();
    assert!(body.is_empty(), "304 response must not carry a body");
}

#[tokio::test]
async fn build_app_client_fallback_serves_client_on_nested_routes() {
    // `/client/routines` (and other React-Router-owned paths) aren't real server routes — the
    // nested `/client` router's own fallback returns the same HTML so React Router resolves the
    // path client-side on a hard refresh or deep link, mirroring `/routines` for `ui/` at `/`.
    let app = build_app(crate::routines::new_store());
    let resp = app
        .oneshot(
            Request::builder()
                .uri("/client/routines")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::OK);
    let ctype = resp.headers().get(CONTENT_TYPE).unwrap();
    assert!(ctype.to_str().unwrap().starts_with("text/html"));
}

#[tokio::test]
async fn build_app_client_and_root_serve_distinct_bundles() {
    // `/client` and `/` embed two independent SPAs (`CLIENT_HTML` vs `INDEX_HTML`) — confirm the
    // nested router isn't accidentally aliased to the outer `index` handler.
    let app = build_app(crate::routines::new_store());
    let root = app
        .clone()
        .oneshot(Request::builder().uri("/").body(Body::empty()).unwrap())
        .await
        .unwrap();
    let client = app
        .oneshot(
            Request::builder()
                .uri("/client")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    let root_etag = root
        .headers()
        .get(axum::http::header::ETAG)
        .unwrap()
        .clone();
    let client_etag = client
        .headers()
        .get(axum::http::header::ETAG)
        .unwrap()
        .clone();
    assert_ne!(root_etag, client_etag);
}

/// Every unmatched path outside `/client` (and `/api/v1`) must keep falling through to `ui/`'s
/// `INDEX_HTML`, not the React client — the outer `.fallback(get(index))` is untouched by the
/// new `/client` nest.
#[tokio::test]
async fn build_app_root_fallback_unaffected_by_client_route() {
    let app = build_app(crate::routines::new_store());
    let root = app
        .clone()
        .oneshot(Request::builder().uri("/").body(Body::empty()).unwrap())
        .await
        .unwrap();
    let root_etag = root
        .headers()
        .get(axum::http::header::ETAG)
        .unwrap()
        .clone();

    let unmatched = app
        .oneshot(
            Request::builder()
                .uri("/some/unmatched/path")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(unmatched.status(), StatusCode::OK);
    assert_eq!(
        unmatched.headers().get(axum::http::header::ETAG).unwrap(),
        &root_etag
    );
}