asched-core 0.2.0

Reusable local project routine scheduler, daemon, persistence, and typed client
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

use super::*;
use crate::routine::RoutineFire;
use std::io::Cursor;

fn preserve_io(error: std::io::Error) -> RoutineError {
    error.into()
}

#[test]
fn given_newline_terminated_frame_at_maximum_when_read_then_payload_is_accepted() {
    let result = read_response_frame(Cursor::new(b"abc\n"), 3, preserve_io);

    assert_eq!(result.unwrap(), b"abc");
}

#[test]
fn given_frame_without_newline_when_read_then_corrupt_is_reported() {
    let result = read_response_frame(Cursor::new(b"abc"), 3, preserve_io);

    assert!(matches!(result, Err(RoutineError::Corrupt(_))));
}

#[test]
fn given_newline_terminated_frame_over_maximum_when_read_then_corrupt_is_reported() {
    let result = read_response_frame(Cursor::new(b"abcd\n"), 3, preserve_io);

    assert!(matches!(result, Err(RoutineError::Corrupt(_))));
}

#[test]
fn given_fire_request_and_response_when_serialized_then_contract_round_trips() {
    let request = Request::new(
        "/project".into(),
        Action::Fire {
            kind: "filesystem.changed".into(),
            payload: serde_json::json!({"path": "src/main.rs"}),
            event_id: "delivery-1".into(),
        },
    );
    let response = Response::Fire {
        outcome: FireOutcome::Handled {
            routines: vec![RoutineFire::Started {
                name: "check".into(),
            }],
        },
    };

    let decoded_request: Request =
        serde_json::from_slice(&serde_json::to_vec(&request).unwrap()).unwrap();
    let decoded_response: Response =
        serde_json::from_slice(&serde_json::to_vec(&response).unwrap()).unwrap();

    assert!(matches!(
        decoded_request.action,
        Action::Fire { kind, event_id, .. }
            if kind == "filesystem.changed" && event_id == "delivery-1"
    ));
    assert!(matches!(
        decoded_response,
        Response::Fire {
            outcome: FireOutcome::Handled { routines }
        } if routines == vec![RoutineFire::Started { name: "check".into() }]
    ));
}