blazingly 0.2.2

Facade crate re-exporting the Blazingly framework: routing, extraction, validation, dependency injection, OpenAPI, and MCP
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

use blazingly::prelude::*;
use futures_lite::future;
use std::cell::RefCell;
use std::rc::Rc;

#[derive(Clone)]
struct Events(Rc<RefCell<Vec<&'static str>>>);

#[get("/work", id = "work.create")]
#[allow(clippy::unused_async)]
async fn work(events: Events) -> Background<Json<&'static str>> {
    Json("accepted").background(BackgroundTask::infallible(move || async move {
        events.0.borrow_mut().push("background");
    }))
}

#[test]
fn lifespan_orders_scopes_and_background_waits_for_response_completion() {
    let entries = Rc::new(RefCell::new(Vec::new()));
    let parent_start = Rc::clone(&entries);
    let parent_stop = Rc::clone(&entries);
    let child_start = Rc::clone(&entries);
    let child_stop = Rc::clone(&entries);
    let executable = ExecutableApp::from_plugin(
        Plugin::new("app")
            .on_startup(move || {
                let entries = Rc::clone(&parent_start);
                async move {
                    entries.borrow_mut().push("parent_start");
                    Ok(())
                }
            })
            .on_shutdown(move || {
                let entries = Rc::clone(&parent_stop);
                async move {
                    entries.borrow_mut().push("parent_stop");
                    Ok(())
                }
            })
            .plugin(
                Plugin::new("worker")
                    .provide(Provider::value(Events(Rc::clone(&entries))))
                    .on_startup(move || {
                        let entries = Rc::clone(&child_start);
                        async move {
                            entries.borrow_mut().push("child_start");
                            Ok(())
                        }
                    })
                    .on_shutdown(move || {
                        let entries = Rc::clone(&child_stop);
                        async move {
                            entries.borrow_mut().push("child_stop");
                            Ok(())
                        }
                    })
                    .routes(routes![work]),
            ),
    )
    .expect("lifespan app");
    let app = TestApp::new(&executable);

    future::block_on(app.startup()).expect("startup");
    let mut response = future::block_on(app.call(Request::get("/work")));
    assert_eq!(entries.borrow().as_slice(), ["parent_start", "child_start"]);
    future::block_on(response.run_background()).expect("background task");
    assert_eq!(
        entries.borrow().as_slice(),
        ["parent_start", "child_start", "background"]
    );
    future::block_on(app.shutdown()).expect("shutdown");
    assert_eq!(
        entries.borrow().as_slice(),
        [
            "parent_start",
            "child_start",
            "background",
            "child_stop",
            "parent_stop",
        ]
    );
}