switchy_upnp 0.3.0

Switchy UPnP package
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! Data models for `UPnP` devices and services.
//!
//! This module provides the core data structures for representing discovered `UPnP` devices
//! and their associated services.

use rupnp::{Device, DeviceSpec, Service};
use serde::{Deserialize, Serialize};

/// Represents a discovered `UPnP` device with its associated services.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
pub struct UpnpDevice {
    /// Friendly name of the `UPnP` device.
    pub name: String,
    /// Unique device name (UDN) identifying the device.
    pub udn: String,
    /// Current volume level of the device, if available.
    pub volume: Option<String>,
    /// List of services provided by this device.
    pub services: Vec<UpnpService>,
}

impl From<&DeviceSpec> for UpnpDevice {
    fn from(value: &DeviceSpec) -> Self {
        Self {
            name: value.friendly_name().to_string(),
            udn: value.udn().to_string(),
            volume: None,
            services: vec![],
        }
    }
}

impl From<&Device> for UpnpDevice {
    fn from(value: &Device) -> Self {
        let spec: &DeviceSpec = value;
        spec.into()
    }
}

impl UpnpDevice {
    /// Sets the volume level for this device.
    #[must_use]
    pub fn with_volume(mut self, volume: Option<String>) -> Self {
        self.volume = volume;
        self
    }

    /// Sets the services for this device.
    #[must_use]
    pub fn with_services(mut self, services: Vec<UpnpService>) -> Self {
        self.services = services;
        self
    }
}

/// Represents a `UPnP` service provided by a device.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
pub struct UpnpService {
    /// Service identifier (e.g., "urn:upnp-org:serviceId:AVTransport").
    pub id: String,
    /// Service type (e.g., "urn:schemas-upnp-org:service:AVTransport:1").
    pub r#type: String,
}

impl From<&Service> for UpnpService {
    fn from(value: &Service) -> Self {
        Self {
            id: value.service_id().to_string(),
            r#type: value.service_type().to_string(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test_log::test]
    fn test_upnp_device_with_volume() {
        let device = UpnpDevice {
            name: "Test Device".to_string(),
            udn: "uuid:test-123".to_string(),
            volume: None,
            services: vec![],
        };

        let updated = device.with_volume(Some("50".to_string()));
        assert_eq!(updated.volume, Some("50".to_string()));
        assert_eq!(updated.name, "Test Device");
        assert_eq!(updated.udn, "uuid:test-123");
    }

    #[test_log::test]
    fn test_upnp_device_with_volume_none() {
        let device = UpnpDevice {
            name: "Test Device".to_string(),
            udn: "uuid:test-123".to_string(),
            volume: Some("30".to_string()),
            services: vec![],
        };

        let updated = device.with_volume(None);
        assert!(updated.volume.is_none());
    }

    #[test_log::test]
    fn test_upnp_device_with_services() {
        let device = UpnpDevice {
            name: "Test Device".to_string(),
            udn: "uuid:test-123".to_string(),
            volume: None,
            services: vec![],
        };

        let services = vec![
            UpnpService {
                id: "urn:upnp-org:serviceId:AVTransport".to_string(),
                r#type: "urn:schemas-upnp-org:service:AVTransport:1".to_string(),
            },
            UpnpService {
                id: "urn:upnp-org:serviceId:RenderingControl".to_string(),
                r#type: "urn:schemas-upnp-org:service:RenderingControl:1".to_string(),
            },
        ];

        let updated = device.with_services(services);
        assert_eq!(updated.services.len(), 2);
        assert_eq!(updated.services[0].id, "urn:upnp-org:serviceId:AVTransport");
        assert_eq!(
            updated.services[1].id,
            "urn:upnp-org:serviceId:RenderingControl"
        );
    }

    #[test_log::test]
    fn test_upnp_device_builder_pattern() {
        let device = UpnpDevice {
            name: "Test Device".to_string(),
            udn: "uuid:test-123".to_string(),
            volume: None,
            services: vec![],
        };

        let service = UpnpService {
            id: "urn:upnp-org:serviceId:AVTransport".to_string(),
            r#type: "urn:schemas-upnp-org:service:AVTransport:1".to_string(),
        };

        let updated = device
            .with_volume(Some("75".to_string()))
            .with_services(vec![service]);

        assert_eq!(updated.volume, Some("75".to_string()));
        assert_eq!(updated.services.len(), 1);
        assert_eq!(updated.services[0].id, "urn:upnp-org:serviceId:AVTransport");
    }
}