framesmith 0.1.0

A Rust library for controlling Samsung Frame TVs over the local network
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use crate::frame_tv_api::FrameTvApi;
use crate::frame_tv_impl::FrameTvImpl;
use crate::protocol::art_response::ArtResponse;
use crate::transport::mock_transport::MockTransport;
use crate::transport::rest_client::RestClient;
use crate::types::{DisplayBrightness, RemoteControlButton};
use std::net::{IpAddr, Ipv4Addr};

fn make_test_tv(mock: MockTransport) -> FrameTvImpl<MockTransport> {
    let rest_client = RestClient::new(
        IpAddr::V4(Ipv4Addr::new(192, 168, 1, 100)),
        reqwest::Client::new(),
    );
    FrameTvImpl {
        transport: mock,
        rest_client,
    }
}

fn art_response_with_content_list(json_list: &str) -> ArtResponse {
    serde_json::from_str(&format!(
        r#"{{"content_list": {}}}"#,
        serde_json::to_string(json_list).unwrap()
    ))
    .unwrap()
}

fn art_response_with_value(value: &str) -> ArtResponse {
    serde_json::from_str(&format!(r#"{{"value": "{value}"}}"#)).unwrap()
}

fn art_response_empty() -> ArtResponse {
    serde_json::from_str("{}").unwrap()
}

#[tokio::test]
async fn test_get_uploaded_art_images() {
    let mock = MockTransport::new();
    let content_list =
        r#"[{"content_id":"MY-F0001","category_id":"MY-C0002","width":3840,"height":2160}]"#;
    mock.enqueue_art_response(art_response_with_content_list(content_list));

    let tv = make_test_tv(mock);
    let images = tv.get_uploaded_art_images().await.unwrap();
    assert_eq!(images.len(), 1);
    assert_eq!(images[0].id(), "MY-F0001");
    assert_eq!(images[0].width(), 3840);
}

#[tokio::test]
async fn test_is_artmode_enabled() {
    let mock = MockTransport::new();
    mock.enqueue_art_response(art_response_with_value("on"));
    let tv = make_test_tv(mock);
    assert!(tv.is_artmode_enabled().await.unwrap());
}

#[tokio::test]
async fn test_is_artmode_disabled() {
    let mock = MockTransport::new();
    mock.enqueue_art_response(art_response_with_value("off"));
    let tv = make_test_tv(mock);
    assert!(!tv.is_artmode_enabled().await.unwrap());
}

#[tokio::test]
async fn test_get_display_brightness() {
    let mock = MockTransport::new();
    mock.enqueue_art_response(art_response_with_value("7"));
    let tv = make_test_tv(mock);
    let brightness = tv.get_display_brightness().await.unwrap();
    assert_eq!(brightness, DisplayBrightness::L7);
}

#[tokio::test]
async fn test_set_display_brightness() {
    let mock = MockTransport::new();
    mock.enqueue_art_response(art_response_empty());
    let tv = make_test_tv(mock);
    tv.set_display_brightness(DisplayBrightness::L5)
        .await
        .unwrap();
}

#[tokio::test]
async fn test_press_remote_control_button() {
    let mock = MockTransport::new();
    let tv = make_test_tv(mock);
    tv.press_remote_control_button(RemoteControlButton::Power)
        .await
        .unwrap();
    let log = tv.transport.get_remote_key_log();
    assert_eq!(log, vec!["KEY_POWER"]);
}

#[tokio::test]
async fn test_enable_artmode() {
    let mock = MockTransport::new();
    mock.enqueue_art_response(art_response_empty());
    let tv = make_test_tv(mock);
    tv.enable_artmode().await.unwrap();
}

#[tokio::test]
async fn test_disable_artmode() {
    let mock = MockTransport::new();
    mock.enqueue_art_response(art_response_empty());
    let tv = make_test_tv(mock);
    tv.disable_artmode().await.unwrap();
}

#[tokio::test]
async fn test_get_available_mattes() {
    let mock = MockTransport::new();
    let resp: ArtResponse = serde_json::from_str(
        r#"{"matte_type_list": "[{\"matte_id\":\"shadowbox_polar\",\"matte_type\":\"shadowbox\"}]"}"#,
    )
    .unwrap();
    mock.enqueue_art_response(resp);
    let tv = make_test_tv(mock);
    let mattes = tv.get_available_mattes().await.unwrap();
    assert_eq!(mattes.len(), 1);
    assert_eq!(mattes[0].id(), "shadowbox_polar");
}

#[tokio::test]
async fn test_get_available_photo_filters() {
    let mock = MockTransport::new();
    let resp: ArtResponse = serde_json::from_str(
        r#"{"filter_list": "[{\"filter_id\":\"ink\",\"filter_name\":\"Ink Wash\"}]"}"#,
    )
    .unwrap();
    mock.enqueue_art_response(resp);
    let tv = make_test_tv(mock);
    let filters = tv.get_available_photo_filters().await.unwrap();
    assert_eq!(filters.len(), 1);
    assert_eq!(filters[0].id(), "ink");
    assert_eq!(filters[0].name(), "Ink Wash");
}