everruns-host 0.17.26

Shared host orchestration for Everruns execution adapters
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

//! Dependency-direction guard for the neutral host implementation boundary.

use std::path::Path;

#[test]
fn host_manifest_has_no_edge_to_facades_or_adapters() {
    let manifest_path = Path::new(env!("CARGO_MANIFEST_DIR")).join("Cargo.toml");
    let manifest = std::fs::read_to_string(&manifest_path)
        .unwrap_or_else(|error| panic!("read {}: {error}", manifest_path.display()));

    for forbidden in [
        "everruns-runtime",
        "everruns-local",
        "everruns-worker",
        "everruns-server",
        "everruns-durable",
    ] {
        assert!(
            !manifest.contains(forbidden),
            "everruns-host must not depend on {forbidden}; adapters and facades depend on host"
        );
    }

    let engine_manifest = manifest_path
        .parent()
        .expect("host crate directory")
        .parent()
        .expect("crates directory")
        .join("engine/Cargo.toml");
    let engine = std::fs::read_to_string(&engine_manifest)
        .unwrap_or_else(|error| panic!("read {}: {error}", engine_manifest.display()));
    assert!(
        !engine.contains("everruns-host"),
        "the sans-I/O engine must not depend on the effectful host"
    );
}

#[test]
fn host_exposes_no_writable_message_store_contract() {
    let source = Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
    for forbidden in ["RuntimeMessageStore", "PersistingEventEmitter"] {
        for entry in std::fs::read_dir(&source).expect("read host source") {
            let path = entry.expect("host source entry").path();
            if path.extension().is_some_and(|extension| extension == "rs") {
                let contents = std::fs::read_to_string(&path).expect("read host source file");
                assert!(
                    !contents.contains(forbidden),
                    "{} must not define legacy writable history marker {forbidden}",
                    path.display()
                );
            }
        }
    }

    let backends =
        std::fs::read_to_string(source.join("backends.rs")).expect("read canonical backend bundle");
    assert!(
        !backends.contains("message_store"),
        "HostBackends must use EventLog, never a writable message store"
    );
}