acyclic-fs 0.1.5

Rust SDK for versioned workspaces and embedded native mounts
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

use super::*;

#[derive(Debug, Error, PartialEq)]
enum OuterError {
    #[error("inner")]
    Inner,
    #[error(transparent)]
    Work(#[from] WorkError),
}

#[test]
fn budgets_fail_on_the_exact_counter() {
    let observed = WorkCounters {
        page_reads: 2,
        ..WorkCounters::default()
    };
    let budget = WorkBudget {
        page_reads: 1,
        ..WorkBudget::default()
    };
    assert_eq!(
        observed.verify(budget),
        Err(WorkError::BudgetExceeded {
            counter: "page_reads",
            observed: 2,
            maximum: 1,
        })
    );
    let observed = WorkCounters {
        source_entries_visited: 3,
        ..WorkCounters::default()
    };
    let budget = WorkBudget {
        source_entries_visited: 2,
        ..WorkBudget::default()
    };
    assert_eq!(
        observed.verify(budget),
        Err(WorkError::BudgetExceeded {
            counter: "source_entries_visited",
            observed: 3,
            maximum: 2,
        })
    );
}

#[test]
fn nested_failure_accounting_never_substitutes_a_sentinel_receipt() {
    let failure = OperationFailure::new(
        (),
        WorkCounters {
            page_reads: 1,
            ..WorkCounters::default()
        },
    );
    let mapped = failure.map_with_prior_work(
        WorkCounters {
            page_reads: u64::MAX,
            ..WorkCounters::default()
        },
        |()| OuterError::Inner,
    );
    assert_eq!(mapped.error, OuterError::Work(WorkError::Overflow));
    assert_eq!(mapped.work.page_reads, u64::MAX);
    assert_ne!(*mapped.work, WorkCounters::UNBOUNDED);
}

#[test]
fn every_multiline_counter_addition_fails_closed_on_overflow() {
    for (left, right) in [
        (
            WorkCounters {
                authority_records_appended: u64::MAX,
                ..WorkCounters::default()
            },
            WorkCounters {
                authority_records_appended: 1,
                ..WorkCounters::default()
            },
        ),
        (
            WorkCounters {
                authority_bytes_written: u64::MAX,
                ..WorkCounters::default()
            },
            WorkCounters {
                authority_bytes_written: 1,
                ..WorkCounters::default()
            },
        ),
        (
            WorkCounters {
                backend_read_operations: u64::MAX,
                ..WorkCounters::default()
            },
            WorkCounters {
                backend_read_operations: 1,
                ..WorkCounters::default()
            },
        ),
        (
            WorkCounters {
                backend_write_operations: u64::MAX,
                ..WorkCounters::default()
            },
            WorkCounters {
                backend_write_operations: 1,
                ..WorkCounters::default()
            },
        ),
    ] {
        assert_eq!(left.checked_add(right), Err(WorkError::Overflow));
    }
}