fslite-server 0.1.0

HTTP adapter exposing fslite-core's FileSystem trait as a resource-oriented REST API, gated by a pluggable AuthProvider.
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
115
116
117
118

use fslite_server::range::{RangeError, resolve_range};

#[test]
fn fully_specified_range_is_inclusive_end_converted_to_exclusive() {
    let range = resolve_range("bytes=0-9", 100).unwrap();
    assert_eq!(range.start, 0);
    assert_eq!(range.end, 10);
}

#[test]
fn open_ended_range_extends_to_the_logical_size() {
    let range = resolve_range("bytes=90-", 100).unwrap();
    assert_eq!(range.start, 90);
    assert_eq!(range.end, 100);
}

#[test]
fn suffix_range_takes_the_last_n_bytes() {
    let range = resolve_range("bytes=-10", 100).unwrap();
    assert_eq!(range.start, 90);
    assert_eq!(range.end, 100);
}

#[test]
fn suffix_longer_than_the_file_clamps_to_the_whole_file() {
    let range = resolve_range("bytes=-1000", 100).unwrap();
    assert_eq!(range.start, 0);
    assert_eq!(range.end, 100);
}

#[test]
fn start_beyond_the_file_is_unsatisfiable() {
    assert!(matches!(
        resolve_range("bytes=200-300", 100),
        Err(RangeError::Unsatisfiable)
    ));
}

#[test]
fn multiple_ranges_are_rejected() {
    assert!(matches!(
        resolve_range("bytes=0-9,20-29", 100),
        Err(RangeError::MultiRangeUnsupported)
    ));
}

#[test]
fn malformed_unit_is_rejected() {
    assert!(matches!(
        resolve_range("items=0-9", 100),
        Err(RangeError::Malformed)
    ));
}

#[test]
fn end_beyond_the_file_is_clamped_to_the_logical_size() {
    let range = resolve_range("bytes=50-1000", 100).unwrap();
    assert_eq!(range.start, 50);
    assert_eq!(range.end, 100);
}

#[test]
fn range_against_an_empty_file_is_unsatisfiable() {
    assert!(matches!(
        resolve_range("bytes=0-9", 0),
        Err(RangeError::Unsatisfiable)
    ));
}

#[test]
fn zero_length_suffix_is_malformed() {
    assert!(matches!(
        resolve_range("bytes=-0", 100),
        Err(RangeError::Malformed)
    ));
}

#[test]
fn non_numeric_start_is_malformed() {
    assert!(matches!(
        resolve_range("bytes=abc-9", 100),
        Err(RangeError::Malformed)
    ));
}

#[test]
fn missing_dash_is_malformed() {
    assert!(matches!(
        resolve_range("bytes=100", 100),
        Err(RangeError::Malformed)
    ));
}

#[test]
fn single_byte_range_is_satisfiable_at_the_last_offset() {
    let range = resolve_range("bytes=99-99", 100).unwrap();
    assert_eq!(range.start, 99);
    assert_eq!(range.end, 100);
}

#[test]
fn end_near_u64_max_clamps_instead_of_overflowing() {
    let range = resolve_range("bytes=0-18446744073709551615", 100).unwrap();
    assert_eq!(range.start, 0);
    assert_eq!(range.end, 100);
}

#[test]
fn reversed_range_is_malformed() {
    assert!(matches!(
        resolve_range("bytes=5-1", 11),
        Err(RangeError::Malformed)
    ));
    assert!(matches!(
        resolve_range("bytes=5-1", 100),
        Err(RangeError::Malformed)
    ));
}