plex-api 0.0.12

Library for communication with Plex server. Work in progress, not ready for any use. See github for details.
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

mod fixtures;

mod offline {
    use super::fixtures::offline::{server::*, Mocked};
    use httpmock::Method::{GET, PUT};
    use plex_api::{url::SERVER_PREFS, Server};

    #[plex_api_test_helper::offline_test]
    async fn load_prefs(#[future] server_anonymous: Mocked<Server>) {
        let (server, mock_server) = server_anonymous.split();

        let mut m = mock_server.mock(|when, then| {
            when.method(GET).path(SERVER_PREFS);
            then.status(200)
                .header("content-type", "text/json")
                .body_from_file("tests/mocks/server/prefs.json");
        });

        let mut prefs = server
            .preferences()
            .await
            .expect("failed to load preferences");

        m.assert();
        m.delete();

        prefs
            .set(
                "CinemaTrailersType",
                plex_api::media_container::preferences::Value::Int(0),
            )
            .expect("failed to update value");

        let m = mock_server.mock(|when, then| {
            when.method(PUT)
                .path(SERVER_PREFS)
                .query_param("CinemaTrailersType", "0");
            then.status(200).header("content-type", "text/json");
        });

        prefs
            .commit()
            .await
            .expect("failed to commit updated preferences");

        m.assert();
    }
}

mod online {
    use std::time::Duration;

    use super::fixtures::online::server::*;
    use plex_api::Server;

    #[plex_api_test_helper::online_test_non_shared_server]
    async fn load_prefs(#[future] server: Server) {
        let mut prefs = server
            .preferences()
            .await
            .expect("failed to load preferences");

        let current = {
            let s = prefs
                .get("ButlerTaskDeepMediaAnalysis")
                .expect("failed to get value");

            match s.value {
                plex_api::media_container::preferences::Value::Bool(b) => b,
                _ => panic!("expected bool value"),
            }
        };

        prefs
            .set(
                "ButlerTaskDeepMediaAnalysis",
                plex_api::media_container::preferences::Value::Bool(!current),
            )
            .expect("failed to update value");

        prefs
            .commit()
            .await
            .expect("failed to commit updated preferences");

        // Server responds with 400 Bad Request if the next request is
        // sent too soon after the PUT, so let's add some retries
        tokio::time::sleep(Duration::from_millis(500)).await;
        let mut prefs = server.preferences().await;

        for _ in 0..10 {
            tokio::time::sleep(Duration::from_millis(500)).await;
            prefs = server.preferences().await;

            if prefs.is_ok() {
                break;
            }
        }

        let prefs = prefs.expect("failed to load preferences 2nd time");

        let new_value = {
            let s = prefs
                .get("ButlerTaskDeepMediaAnalysis")
                .expect("failed to get value");

            match s.value {
                plex_api::media_container::preferences::Value::Bool(b) => b,
                _ => panic!("expected bool value"),
            }
        };

        assert_eq!(!current, new_value, "Value did not change");
    }
}