Fix failing tests

Author: Johannesd3

core/src/config.rs

@@ -15,7 +15,7 @@ pub struct SessionConfig {
 
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(into = "&str")]
-#[serde(try_from = "&str")]
+#[serde(try_from = "String")]
 pub enum DeviceType {
     Unknown = 0,
     Computer = 1,
@@ -64,14 +64,22 @@ impl FromStr for DeviceType {
     }
 }
 
-impl TryFrom<&str> for DeviceType {
+impl<'a> TryFrom<&'a str> for DeviceType {
     type Error = &'static str;
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
         value.parse().map_err(|_| "Invalid device type")
     }
 }
 
+impl TryFrom<String> for DeviceType {
+    type Error = &'static str;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        Self::try_from(value.as_str())
+    }
+}
+
 impl From<&DeviceType> for &str {
     fn from(d: &DeviceType) -> &'static str {
         use self::DeviceType::*;

discovery/src/response.rs

@@ -33,43 +33,64 @@ impl From<ParseError> for Error {
 mod status {
     use std::convert::TryFrom;
 
-    use serde::{Deserialize, Serialize, Serializer};
+    use serde::de::IgnoredAny;
+    use serde::{Deserialize, Serialize};
 
     use super::{Error, SpotifyError};
 
-    fn serialize_status_code<S: Serializer>(code: &u32, serializer: S) -> Result<S::Ok, S::Error> {
-        #[derive(Serialize)]
-        #[serde(rename_all = "camelCase")]
-        struct Repr {
-            status: u32,
-            status_string: &'static str,
+    #[derive(Serialize)]
+    #[serde(rename_all = "camelCase")]
+    struct StatusSerialize {
+        spotify_error: u32,
+        status: u32,
+        status_string: &'static str,
+    }
+
+    impl From<Status> for StatusSerialize {
+        fn from(st: Status) -> Self {
+            let status_string = match &st.status {
+                101 => "OK",
+                301 => "ERROR-MISSING-ACTION",
+                302 => "ERROR-INVALID-ACTION",
+                303 => "ERROR-INVALID-ARGUMENTS",
+                402 => "ERROR-SPOTIFY-ERROR",
+                _ => "ERROR-UNKNOWN",
+            };
+
+            Self {
+                spotify_error: st.spotify_error,
+                status: st.status,
+                status_string,
+            }
         }
+    }
 
-        let status_string = match code {
-            101 => "OK",
-            301 => "ERROR-MISSING-ACTION",
-            302 => "ERROR-INVALID-ACTION",
-            303 => "ERROR-INVALID-ARGUMENTS",
-            402 => "ERROR-SPOTIFY-ERROR",
-            _ => "ERROR-UNKNOWN",
-        };
+    #[derive(Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    struct StatusDeserialize {
+        spotify_error: u32,
+        status: u32,
+        #[allow(dead_code)]
+        status_string: IgnoredAny,
+    }
 
-        Repr {
-            status: *code,
-            status_string,
+    impl From<StatusDeserialize> for Status {
+        fn from(st: StatusDeserialize) -> Self {
+            Self {
+                spotify_error: st.spotify_error,
+                status: st.status,
+            }
         }
-        .serialize(serializer)
     }
 
     /// Helper type to serialize a status. It must be imagined
     /// isomorphic to `Result<(), super::Error>`, and they are
     /// freely convertible.
     #[derive(Clone, Debug, Serialize, Deserialize)]
-    #[serde(rename_all = "camelCase")]
+    #[serde(into = "StatusSerialize", from = "StatusDeserialize")]
     pub struct Status {
-        spotify_error: SpotifyError,
-        #[serde(flatten, serialize_with = "serialize_status_code")]
         status: u32,
+        spotify_error: SpotifyError,
     }
 
     impl Status {