backgroundassets 0.3.0

Safe Rust bindings for Apple's BackgroundAssets framework — on-demand asset packs delivered via App Store on macOS
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

#![cfg(feature = "async")]

use backgroundassets::{
    install_global_managed_downloader_extension, AppExtensionInfo, AssetPackSnapshot,
    AuthenticationChallenge, ChallengeDisposition, ContentRequest, Download,
    DownloadManagerDelegate, DownloadManagerEvent, DownloadPriority, DownloadSnapshot,
    DownloadStatus, DownloadWriteProgress, DownloaderExtensionHandler, ExtensionEvent,
    ManagedDownloaderExtensionConfiguration,
};

struct ExampleExtension;

impl DownloaderExtensionHandler for ExampleExtension {
    fn should_download_asset_pack(&mut self, _asset_pack: &AssetPackSnapshot) -> bool {
        true
    }

    fn downloads(
        &mut self,
        _request: ContentRequest,
        _manifest_url: &str,
        _extension_info: &AppExtensionInfo,
    ) -> Result<Vec<Download>, backgroundassets::BackgroundAssetsError> {
        Ok(Vec::new())
    }

    fn did_receive_challenge(
        &mut self,
        _download: &Download,
        _challenge: &AuthenticationChallenge,
    ) -> ChallengeDisposition {
        ChallengeDisposition::PerformDefaultHandling
    }
}

struct ExampleDownloadManagerDelegate;

impl DownloadManagerDelegate for ExampleDownloadManagerDelegate {}

#[test]
fn managed_extension_registration_exposes_streams() {
    let registration = install_global_managed_downloader_extension(
        ExampleExtension,
        ManagedDownloaderExtensionConfiguration::new(ExampleDownloadManagerDelegate)
            .extension_event_capacity(0)
            .download_manager_event_capacity(0),
    );

    assert_eq!(registration.extension_events().buffered_count(), 0);
    assert_eq!(registration.download_manager_events().buffered_count(), 0);
    assert!(!registration.extension_events().is_closed());
    assert!(!registration.download_manager_events().is_closed());
}

#[test]
fn new_event_variants_serialize_as_expected() {
    let download = DownloadSnapshot {
        identifier: "download.one".into(),
        unique_identifier: "unique.one".into(),
        status: DownloadStatus::Downloading,
        priority: DownloadPriority::new(7),
        is_essential: true,
        is_url_download: true,
    };
    let progress = DownloadWriteProgress {
        bytes_written: 128,
        total_bytes_written: 512,
        total_bytes_expected_to_write: 1024,
    };
    let manager_event = DownloadManagerEvent::Progress {
        download,
        progress,
    };
    let manager_json = serde_json::to_value(&manager_event).unwrap();
    assert_eq!(manager_json["kind"], "progress");
    assert_eq!(manager_json["download"]["identifier"], "download.one");

    let extension_event = ExtensionEvent::ShouldDownloadAssetPack {
        asset_pack: AssetPackSnapshot {
            id: "pack.one".into(),
            download_size: 1024,
            version: 2,
            description: "Pack One".into(),
        },
        should_download: false,
    };
    let extension_json = serde_json::to_value(&extension_event).unwrap();
    assert_eq!(extension_json["kind"], "should_download_asset_pack");
    assert_eq!(extension_json["should_download"], false);
}