solid-pod-rs 0.4.0-alpha.15

Rust-native Solid Pod server library — LDP, WAC, WebID, Solid-OIDC, Solid Notifications, NIP-98. Framework-agnostic.
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
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
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276

//! Container `index.html` content negotiation tests (khive ef97a6d1).
//!
//! When a GET request hits a container path and the `Accept` header
//! includes `text/html`, the server checks if an `index.html` resource
//! exists in the container. If yes, it serves that content with
//! `Content-Type: text/html`. If no, it falls through to the standard
//! LDP container listing (JSON-LD / Turtle).
//!
//! Solid clients requesting `text/turtle` or `application/ld+json`
//! always get the RDF container listing, regardless of whether
//! `index.html` exists.

use std::sync::Arc;

use actix_web::http::StatusCode;
use actix_web::test;
use bytes::Bytes;
use solid_pod_rs::security::DotfileAllowlist;
use solid_pod_rs::storage::memory::MemoryBackend;
use solid_pod_rs::storage::Storage;
use solid_pod_rs_server::{build_app, AppState, NodeInfoMeta, PodCreateLimiter};

// ---------------------------------------------------------------------------
// Test harness
// ---------------------------------------------------------------------------

async fn make_state() -> AppState {
    let backend = Arc::new(MemoryBackend::new());

    // Root ACL granting public access.
    let ttl = r#"
        @prefix acl: <http://www.w3.org/ns/auth/acl#> .
        @prefix foaf: <http://xmlns.com/foaf/0.1/> .
        <#public> a acl:Authorization ;
            acl:agentClass foaf:Agent ;
            acl:accessTo </> ;
            acl:default </> ;
            acl:mode acl:Read, acl:Write, acl:Append, acl:Control .
    "#;
    backend
        .put(
            "/.acl",
            Bytes::copy_from_slice(ttl.as_bytes()),
            "text/turtle",
        )
        .await
        .unwrap();

    // Seed a container with a .meta marker.
    backend
        .put(
            "/site/.meta",
            Bytes::from_static(b"# container marker"),
            "text/plain",
        )
        .await
        .unwrap();

    AppState {
        storage: backend,
        dotfiles: Arc::new(DotfileAllowlist::with_defaults()),
        body_cap: 10_000_000,
        nodeinfo: NodeInfoMeta {
            software_name: "solid-pod-rs-server".into(),
            software_version: "0.4.0".into(),
            open_registrations: false,
            total_users: 0,
            base_url: "https://pod.example".into(),
        },
        mashlib: solid_pod_rs::MashlibConfig::default(),
        mashlib_cdn: None,
        pay_config: solid_pod_rs::payments::PayConfig::default(),
        data_root: None,
        pod_create_limiter: Arc::new(PodCreateLimiter::default()),
    }
}

// ---------------------------------------------------------------------------
// Test: Accept text/html + index.html exists => serve index.html
// ---------------------------------------------------------------------------

#[actix_web::test]
async fn container_get_html_with_index_serves_index_html() {
    let state = make_state().await;
    let storage = state.storage.clone();

    // Seed an index.html in the container.
    let html_content = b"<html><body>Hello from index</body></html>";
    storage
        .put(
            "/site/index.html",
            Bytes::copy_from_slice(html_content),
            "text/html",
        )
        .await
        .unwrap();

    let app = test::init_service(build_app(state)).await;

    let req = test::TestRequest::get()
        .uri("/site/")
        .insert_header(("accept", "text/html"))
        .to_request();
    let resp = test::call_service(&app, req).await;

    assert_eq!(resp.status(), StatusCode::OK);
    let ct = resp
        .headers()
        .get("content-type")
        .unwrap()
        .to_str()
        .unwrap();
    assert!(
        ct.contains("text/html"),
        "content-type should be text/html, got: {ct}"
    );

    let body = test::read_body(resp).await;
    assert_eq!(&body[..], html_content);
}

// ---------------------------------------------------------------------------
// Test: Accept text/turtle => always get container listing, even when
//       index.html exists
// ---------------------------------------------------------------------------

#[actix_web::test]
async fn container_get_turtle_ignores_index_html() {
    let state = make_state().await;
    let storage = state.storage.clone();

    // Seed an index.html.
    storage
        .put(
            "/site/index.html",
            Bytes::from_static(b"<html>ignored</html>"),
            "text/html",
        )
        .await
        .unwrap();

    let app = test::init_service(build_app(state)).await;

    let req = test::TestRequest::get()
        .uri("/site/")
        .insert_header(("accept", "text/turtle"))
        .to_request();
    let resp = test::call_service(&app, req).await;

    assert_eq!(resp.status(), StatusCode::OK);
    let ct = resp
        .headers()
        .get("content-type")
        .unwrap()
        .to_str()
        .unwrap();
    // Should be JSON-LD (the default container representation), not text/html.
    assert!(
        ct.contains("application/ld+json"),
        "expected RDF container listing content-type, got: {ct}"
    );
}

// ---------------------------------------------------------------------------
// Test: Accept text/html but no index.html => fall through to RDF listing
// ---------------------------------------------------------------------------

#[actix_web::test]
async fn container_get_html_without_index_falls_through_to_rdf() {
    let state = make_state().await;
    // No index.html seeded in /site/.

    let app = test::init_service(build_app(state)).await;

    let req = test::TestRequest::get()
        .uri("/site/")
        .insert_header(("accept", "text/html"))
        .to_request();
    let resp = test::call_service(&app, req).await;

    assert_eq!(resp.status(), StatusCode::OK);
    let ct = resp
        .headers()
        .get("content-type")
        .unwrap()
        .to_str()
        .unwrap();
    // With mashlib disabled, should fall through to JSON-LD.
    assert!(
        ct.contains("application/ld+json"),
        "expected RDF container listing (mashlib off), got: {ct}"
    );
}

// ---------------------------------------------------------------------------
// Test: Accept application/ld+json => always get RDF, even with index.html
// ---------------------------------------------------------------------------

#[actix_web::test]
async fn container_get_jsonld_ignores_index_html() {
    let state = make_state().await;
    let storage = state.storage.clone();

    storage
        .put(
            "/site/index.html",
            Bytes::from_static(b"<html>nope</html>"),
            "text/html",
        )
        .await
        .unwrap();

    let app = test::init_service(build_app(state)).await;

    let req = test::TestRequest::get()
        .uri("/site/")
        .insert_header(("accept", "application/ld+json"))
        .to_request();
    let resp = test::call_service(&app, req).await;

    assert_eq!(resp.status(), StatusCode::OK);
    let ct = resp
        .headers()
        .get("content-type")
        .unwrap()
        .to_str()
        .unwrap();
    assert!(
        ct.contains("application/ld+json"),
        "Solid client should get JSON-LD, got: {ct}"
    );
}

// ---------------------------------------------------------------------------
// Test: Browser Accept header with multiple types including text/html
// ---------------------------------------------------------------------------

#[actix_web::test]
async fn container_get_browser_accept_with_index_serves_html() {
    let state = make_state().await;
    let storage = state.storage.clone();

    let html = b"<html><body>Browser view</body></html>";
    storage
        .put(
            "/site/index.html",
            Bytes::copy_from_slice(html),
            "text/html",
        )
        .await
        .unwrap();

    let app = test::init_service(build_app(state)).await;

    // Typical browser Accept header.
    let req = test::TestRequest::get()
        .uri("/site/")
        .insert_header((
            "accept",
            "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        ))
        .to_request();
    let resp = test::call_service(&app, req).await;

    assert_eq!(resp.status(), StatusCode::OK);
    let ct = resp
        .headers()
        .get("content-type")
        .unwrap()
        .to_str()
        .unwrap();
    assert!(ct.contains("text/html"));

    let body = test::read_body(resp).await;
    assert_eq!(&body[..], html);
}