fraiseql-storage 2.3.2

Object storage backends and HTTP handlers for FraiseQL
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

#![allow(clippy::unwrap_used)] // Reason: test code, panics acceptable
#![allow(missing_docs)] // Reason: test functions are self-describing

use fraiseql_error::FileError;
use tempfile::TempDir;

use super::*;
use crate::{backend::LocalBackend, config::BucketAccess};

fn temp_service(
    max_size: Option<u64>,
    allowed_types: Option<Vec<String>>,
) -> (BucketService, TempDir) {
    let tmpdir = TempDir::new().expect("create tempdir");
    let backend = StorageBackend::Local(LocalBackend::new(tmpdir.path().to_str().unwrap()));
    let config = BucketConfig {
        name:               "test".to_string(),
        max_object_bytes:   max_size,
        allowed_mime_types: allowed_types,
        access:             BucketAccess::Private,
        transform_presets:  None,
    };
    (BucketService::new(backend, config), tmpdir)
}

#[tokio::test]
async fn test_size_limit_rejected() {
    let (service, _tmpdir) = temp_service(Some(100), None);

    let result = service.upload("test.bin", &[0u8; 150], "application/octet-stream").await;

    let err = result.expect_err("should reject oversized upload");
    assert!(
        matches!(
            err,
            FraiseQLError::File(FileError::SizeLimitExceeded {
                limit: Some(100),
                actual: Some(150),
                ..
            })
        ),
        "should be FileError::SizeLimitExceeded with the configured limit / actual size; got {err:?}"
    );
}

#[tokio::test]
async fn test_size_limit_accepted() {
    let (service, _tmpdir) = temp_service(Some(100), None);

    let result = service.upload("test.bin", &[0u8; 50], "application/octet-stream").await;

    result.expect("should accept upload within limit");
}

#[tokio::test]
async fn test_mime_type_rejected() {
    let (service, _tmpdir) = temp_service(None, Some(vec!["image/jpeg".to_string()]));

    let result = service.upload("test.txt", b"text", "text/plain").await;

    let err = result.expect_err("should reject disallowed MIME type");
    assert!(
        matches!(
            err,
            FraiseQLError::File(FileError::MimeTypeNotAllowed {
                ref mime,
                ..
            }) if mime.as_deref() == Some("text/plain")
        ),
        "should be FileError::MimeTypeNotAllowed with the rejected MIME; got {err:?}"
    );
}

#[tokio::test]
async fn test_mime_type_wildcard() {
    let (service, _tmpdir) = temp_service(None, Some(vec!["*/*".to_string()]));

    let result = service.upload("test.anything", b"data", "application/anything").await;

    result.expect("wildcard should accept any MIME type");
}

#[tokio::test]
async fn test_no_policy_passes_through() {
    let (service, _tmpdir) = temp_service(None, None);

    let result = service
        .upload("test.bin", &vec![0u8; 1_000_000], "application/octet-stream")
        .await;

    result.expect("no limits should allow any upload");
}

#[tokio::test]
async fn test_list_delegates_to_backend() {
    let (service, _tmpdir) = temp_service(None, None);

    service.upload("file1.txt", b"data", "text/plain").await.expect("upload");
    service.upload("file2.txt", b"data", "text/plain").await.expect("upload");

    let result = service.list("", None, 100).await.expect("list");

    assert_eq!(result.objects.len(), 2, "should list both files");
}