From ece84f2e7d30e2af9a1e33ea3da44ac8fcd3d3a6 Mon Sep 17 00:00:00 2001
From: Edwin Svensson <git@olback.net>
Date: Fri, 24 Sep 2021 00:50:15 +0200
Subject: [PATCH] Update deps and fix tests

---
 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");
 }
--
rgit 0.1.3