korrosync 0.4.0

A KOReader Sync Server
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

mod common;

use axum::body::{Body, HttpBody};
use axum::http::{Method, Request, StatusCode};
use common::{AuthenticatedRequestBuilder, UnauthenticatedRequestBuilder, spawn_app};
use tower::ServiceExt;

#[tokio::test]
async fn fallback_returns_404_for_invalid_routes() {
    let app = spawn_app();

    let invalid_routes = [
        "/invalid",
        "/does/not/exist",
        "/api/v1/users",
        "/healthcheck-invalid",
        "/users/create/extra",
        "/syncs/progress/doc/extra",
    ];

    for route in invalid_routes {
        let response = app
            .clone()
            .oneshot(AuthenticatedRequestBuilder::get(route).build())
            .await
            .expect("Failed to send request");

        assert_eq!(
            StatusCode::NOT_FOUND,
            response.status(),
            "Route {route} should return 404"
        );

        let body_size = response.into_body().size_hint().exact();
        assert_eq!(Some(0), body_size, "Route {route} should have empty body");
    }
}

#[tokio::test]
async fn fallback_returns_404_for_various_http_methods() {
    let app = spawn_app();

    let methods = [
        Method::GET,
        Method::POST,
        Method::PUT,
        Method::DELETE,
        Method::PATCH,
        Method::OPTIONS,
        Method::HEAD,
        Method::TRACE,
    ];

    for method in methods {
        let req = Request::builder()
            .uri("/nonexistent")
            .method(method.clone())
            .header("x-auth-user", "test")
            .header("x-auth-key", "test")
            .body(Body::empty())
            .unwrap();

        let response = app
            .clone()
            .oneshot(req)
            .await
            .expect("Failed to send request");

        assert_eq!(
            StatusCode::NOT_FOUND,
            response.status(),
            "Method {method:?} on invalid route should return 404"
        );

        let body_size = response.into_body().size_hint().exact();
        assert_eq!(
            Some(0),
            body_size,
            "Method {method:?} should have empty body"
        );
    }
}

#[tokio::test]
async fn fallback_works_without_authentication() {
    let app = spawn_app();

    let response = app
        .oneshot(UnauthenticatedRequestBuilder::get("/nonexistent/route").build())
        .await
        .expect("Failed to send request");

    assert_eq!(StatusCode::NOT_FOUND, response.status());

    let body_size = response.into_body().size_hint().exact();
    assert_eq!(Some(0), body_size);
}

#[tokio::test]
async fn fallback_handles_deeply_nested_paths() {
    let app = spawn_app();

    let response = app
        .oneshot(AuthenticatedRequestBuilder::get("/a/b/c/d/e/f/g/h/i/j/k").build())
        .await
        .expect("Failed to send request");

    assert_eq!(StatusCode::NOT_FOUND, response.status());

    let body_size = response.into_body().size_hint().exact();
    assert_eq!(Some(0), body_size);
}