mpdclient 0.2.0

Rust interface to MPD using libmpdclient
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
119
120

use mpdclient::{Error, Message};

use crate::common::setup_mpd;

mod common;

#[test]
fn roundtrip() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            let channel = conn.channel();
            channel.subscribe("test_roundtrip")?;
            channel.channel_write("test_roundtrip", "a message")?;
            let messages = channel
                .read_subscriptions()?
                .collect::<Result<Vec<Message>, Error>>()?;

            assert_eq!(messages.len(), 1);
            assert_eq!(
                messages[0],
                Message {
                    channel: "test_roundtrip".to_string(),
                    text: "a message".to_string()
                }
            );
            Ok(())
        },
    )
}

#[test]
fn multiple_messages() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            let channel = conn.channel();
            channel.subscribe("test_multiple_msg")?;
            channel.channel_write("test_multiple_msg", "a message")?;
            channel.channel_write("test_multiple_msg", "second message")?;
            channel.channel_write("test_multiple_msg", "the third")?;
            let messages = channel
                .read_subscriptions()?
                .collect::<Result<Vec<Message>, Error>>()?;

            assert_eq!(
                messages,
                vec![
                    Message {
                        channel: "test_multiple_msg".to_string(),
                        text: "a message".to_string()
                    },
                    Message {
                        channel: "test_multiple_msg".to_string(),
                        text: "second message".to_string()
                    },
                    Message {
                        channel: "test_multiple_msg".to_string(),
                        text: "the third".to_string()
                    }
                ]
            );
            Ok(())
        },
    )
}

#[test]
fn multiple_channel() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            let channel = conn.channel();
            channel.subscribe("test_multiple_ch1")?;
            channel.subscribe("test_multiple_ch2")?;
            channel.subscribe("test_multiple_ch3")?;
            channel.channel_write("test_multiple_ch1", "a message")?;
            channel.channel_write("test_multiple_ch2", "second message")?;
            channel.channel_write("test_multiple_ch3", "the third")?;
            let messages = channel
                .read_subscriptions()?
                .collect::<Result<Vec<Message>, Error>>()?;

            assert_eq!(
                messages,
                vec![
                    Message {
                        channel: "test_multiple_ch1".to_string(),
                        text: "a message".to_string()
                    },
                    Message {
                        channel: "test_multiple_ch2".to_string(),
                        text: "second message".to_string()
                    },
                    Message {
                        channel: "test_multiple_ch3".to_string(),
                        text: "the third".to_string()
                    }
                ]
            );
            Ok(())
        },
    )
}

#[test]
fn list() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            let channel = conn.channel();
            channel.subscribe("test_list1")?;
            channel.subscribe("test_list2")?;
            let list = channel.list()?;
            assert!(list.contains(&"test_list1".to_string()));
            assert!(list.contains(&"test_list2".to_string()));
            Ok(())
        },
    )
}