Update deps and fix tests
Diff
Cargo.toml | 7 +++++--
tests/integration_test.rs | 95 ++++++++++++++++++++++++++++++++++++++++++++++++--------------------------------
2 files changed, 59 insertions(+), 43 deletions(-)
@@ -10,11 +10,14 @@
edition = "2018"
[dependencies]
reqwest = "0.10"
reqwest = "0.11"
log = "0.4"
ssdp-client = "0.5"
ssdp-client = "1"
futures = "0.3"
xmltree = "0.10"
failure = "0.1"
regex = "1"
lazy_static = "1"
[dev-dependencies]
tokio = { version = "1", features = [ "rt", "macros", "test-util" ], default-features = false }
@@ -1,87 +1,98 @@
extern crate sonos;
use sonos::TransportState;
fn get_speaker() -> sonos::Speaker {
let devices = sonos::discover().unwrap();
async fn get_speaker() -> sonos::Speaker {
let devices = sonos::discover().await.unwrap();
devices
.into_iter()
.find(|d| d.name == "Bedroom")
.find(|d| d.name == "Living Room")
.ok_or("Couldn't find bedroom")
.unwrap()
}
#[test]
fn can_discover_devices() {
let devices = sonos::discover().unwrap();
#[tokio::test]
async fn can_discover_devices() {
let devices = sonos::discover().await.unwrap();
assert!(!devices.is_empty(), "No devices discovered");
}
#[test]
fn volume() {
let device = get_speaker();
device.set_volume(2).expect("Failed to get volume");
#[tokio::test]
async fn volume() {
let device = get_speaker().await;
device.set_volume(2).await.expect("Failed to get volume");
assert_eq!(
device.volume().expect("Failed to get volume"),
device.volume().await.expect("Failed to get volume"),
2 as u8,
"Volume was not updated."
);
}
#[test]
fn muted() {
let device = get_speaker();
device.mute().expect("Couldn't mute player");
#[tokio::test]
async fn muted() {
let device = get_speaker().await;
device.mute().await.expect("Couldn't mute player");
assert_eq!(
device.muted().expect("Failed to get current mute status"),
device
.muted()
.await
.expect("Failed to get current mute status"),
true
);
device.unmute().expect("Couldn't unmute player");
device.unmute().await.expect("Couldn't unmute player");
assert_eq!(
device.muted().expect("Failed to get current mute status"),
device
.muted()
.await
.expect("Failed to get current mute status"),
false
);
}
#[test]
fn playback_state() {
let device = get_speaker();
#[tokio::test]
async fn playback_state() {
let device = get_speaker().await;
device.play().expect("Couldn't play track");
assert!(match device.transport_state().unwrap() {
device.play().await.expect("Couldn't play track");
assert!(match device.transport_state().await.unwrap() {
TransportState::Playing | TransportState::Transitioning => true,
_ => false,
});
device.pause().expect("Couldn't pause track");
assert!(match device.transport_state().unwrap() {
device.pause().await.expect("Couldn't pause track");
assert!(match device.transport_state().await.unwrap() {
TransportState::PausedPlayback | TransportState::Transitioning => true,
_ => false,
});
device.stop().expect("Couldn't stop track");
assert!(match device.transport_state().unwrap() {
device.stop().await.expect("Couldn't stop track");
let state = device.transport_state().await.unwrap();
assert!(match state {
TransportState::Stopped | TransportState::Transitioning => true,
_ => false,
});
}
#[test]
fn track_info() {
let device = get_speaker();
device.track().expect("Failed to get track info");
#[tokio::test]
async fn track_info() {
let device = get_speaker().await;
device.track().await.expect("Failed to get track info");
}
#[test]
fn seek() {
let device = get_speaker();
#[tokio::test]
async fn seek() {
let device = get_speaker().await;
device
.seek(&std::time::Duration::from_secs(30))
.await
.expect("Failed to seek to 30 seconds");
assert_eq!(
device
.track()
.await
.expect("Failed to get track info")
.running_time
.as_secs(),
@@ -89,17 +100,19 @@
);
}
#[test]
fn play() {
let device = get_speaker();
device.play().expect("Failed to play");
device.pause().expect("Failed to pause");
#[tokio::test]
async fn play() {
let device = get_speaker().await;
device.play().await.expect("Failed to play");
device.pause().await.expect("Failed to pause");
}
#[test]
#[tokio::test]
#[should_panic]
fn fail_on_set_invalid_volume() {
async fn fail_on_set_invalid_volume() {
get_speaker()
.await
.set_volume(101)
.await
.expect_err("Didn't fail on invalid volume");
}