tauri-plugin-audioplayer 0.1.2

Tauri Audioplayer Plugin
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

use tauri_plugin_audioplayer::{
    AudioDevice, AudioDeviceList, BufferSizeRange, Error, LoadedAudio, PlaybackProgress,
    StreamConfig, SupportedStreamConfig,
};

#[test]
fn serializes_device_data_with_the_frontend_field_names() {
    let device = AudioDevice {
        id: "output-42".into(),
        name: "Studio output".into(),
        selected_stream_config: Some(StreamConfig {
            channels: 2,
            sample_format: "F32".into(),
            sample_rate: 48_000,
            buffer_size: Some(BufferSizeRange {
                min_frames: 128,
                max_frames: 1_024,
            }),
        }),
        supported_stream_configs: vec![SupportedStreamConfig {
            channels: 2,
            sample_format: "F32".into(),
            min_sample_rate: 44_100,
            max_sample_rate: 48_000,
            buffer_size: None,
        }],
        error: None,
    };

    assert_eq!(
        serde_json::to_value(device).unwrap(),
        serde_json::json!({
            "id": "output-42",
            "name": "Studio output",
            "selectedStreamConfig": {
                "channels": 2,
                "sampleFormat": "F32",
                "sampleRate": 48000,
                "bufferSize": { "minFrames": 128, "maxFrames": 1024 }
            },
            "supportedStreamConfigs": [{
                "channels": 2,
                "sampleFormat": "F32",
                "minSampleRate": 44100,
                "maxSampleRate": 48000,
                "bufferSize": null
            }],
            "error": null
        })
    );
}

#[test]
fn serializes_optional_audio_fields_and_playback_progress() {
    let device = AudioDevice {
        id: "input-7".into(),
        name: "Microphone".into(),
        selected_stream_config: None,
        supported_stream_configs: vec![],
        error: Some("permission denied".into()),
    };
    let loaded = LoadedAudio {
        channels: 1,
        sample_rate: 44_100,
        duration_seconds: 12.5,
    };
    let progress = PlaybackProgress {
        position_seconds: 12.5,
        duration_seconds: 12.5,
        is_playing: false,
    };

    assert_eq!(
        serde_json::to_value(device).unwrap()["selectedStreamConfig"],
        serde_json::Value::Null
    );
    assert_eq!(
        serde_json::to_value(loaded).unwrap()["durationSeconds"],
        12.5
    );
    assert_eq!(serde_json::to_value(progress).unwrap()["isPlaying"], false);
}

#[test]
fn serializes_the_default_device_id_without_renaming_it() {
    let list = AudioDeviceList {
        devices: vec![],
        default_id: "stable-default-output-id".into(),
    };

    assert_eq!(
        serde_json::to_value(list).unwrap(),
        serde_json::json!({
            "devices": [],
            "default_id": "stable-default-output-id"
        })
    );
}
#[test]
fn errors_preserve_and_serialize_their_message() {
    let error = Error::message("selected output is unavailable");

    assert_eq!(error.to_string(), "selected output is unavailable");
    assert_eq!(
        serde_json::to_string(&error).unwrap(),
        "\"selected output is unavailable\""
    );
}