🏡 index : ~doyle/sonos.rs.git

ece84f2e7d30e2af9a1e33ea3da44ac8fcd3d3a6 [patch]

ac1ef5989f9bdbada51b262e6a659b50376634c8

9c77ab0467ea039d482e909880fe9e9b44a83635

ece84f2e7d30e2af9a1e33ea3da44ac8fcd3d3a6.tar.gz

Update deps and fix tests

Diff

 Cargo.toml                |  7 +++++--
 tests/integration_test.rs | 95 ++++++++++++++++++++++++++++++++++++++++++++++++--------------------------------
 2 files changed, 59 insertions(+), 43 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 118c0c3..24fe06e 100644
--- a/Cargo.toml
+++ a/Cargo.toml
@@ -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 }
diff --git a/tests/integration_test.rs b/tests/integration_test.rs
index f072e4d..64b3ac5 100644
--- a/tests/integration_test.rs
+++ a/tests/integration_test.rs
@@ -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();
    // eprintln!("{:#?}", state);
    // This returns PausedPlayback on my speaker - is stop no longer supported?
    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");
}