Addressed comments

Signed-off-by: Hugues de Valon <[email protected]>

Author: hug-dev

src/auth.rs

@@ -60,15 +60,15 @@ impl TryFrom<&Authentication> for RequestAuth {
                             "Can not read the SPIFFE_ENDPOINT_SOCKET environment variable ({}).",
                             e
                         );
-                        Error::Client(ClientErrorKind::Spiffe)
+                        Error::Client(ClientErrorKind::NoAuthenticator)
                     })?,
                     None,
                 );
                 let audience = String::from("parsec");
 
                 let result = client.fetch(audience, None).map_err(|e| {
                     error!("Error while fetching the JWT-SVID ({}).", e);
-                    Error::Client(ClientErrorKind::Spiffe)
+                    Error::Client(ClientErrorKind::Spiffe(e))
                 })?;
                 Ok(RequestAuth::new(result.svid().as_bytes().into()))
             }
@@ -84,6 +84,7 @@ impl PartialEq for Authentication {
             (Authentication::Direct(app_name), Authentication::Direct(other_app_name)) => {
                 app_name == other_app_name
             }
+            (Authentication::JwtSvid, Authentication::JwtSvid) => true,
             _ => false,
         }
     }

src/core/testing/core_tests.rs

@@ -179,7 +179,10 @@ fn core_provider_for_crypto_test() {
         .psa_destroy_key(String::from("random key"))
         .expect_err("Expected a failure!!");
 
-    assert_eq!(res, Error::Client(ClientErrorKind::InvalidProvider));
+    assert!(matches!(
+        res,
+        Error::Client(ClientErrorKind::InvalidProvider)
+    ));
 }
 
 #[test]
@@ -694,10 +697,10 @@ fn different_response_type_test() {
         .psa_destroy_key(key_name)
         .expect_err("Error was expected");
 
-    assert_eq!(
+    assert!(matches!(
         err,
         Error::Client(ClientErrorKind::InvalidServiceResponseType)
-    );
+    ));
 }
 
 #[test]
@@ -711,7 +714,10 @@ fn response_status_test() {
     client.set_mock_read(&stream.pop_bytes_written());
     let err = client.ping().expect_err("Error was expected");
 
-    assert_eq!(err, Error::Service(status));
+    assert!(matches!(
+        err,
+        Error::Service(ResponseStatus::PsaErrorDataCorrupt)
+    ));
 }
 
 #[test]
@@ -720,10 +726,10 @@ fn malformed_response_test() {
     client.set_mock_read(&[0xcb_u8; 130]);
     let err = client.ping().expect_err("Error was expected");
 
-    assert_eq!(
+    assert!(matches!(
         err,
         Error::Client(ClientErrorKind::Interface(ResponseStatus::InvalidHeader))
-    );
+    ));
 }
 
 #[test]
@@ -788,10 +794,10 @@ fn failing_ipc_test() {
     ))));
 
     let err = client.ping().expect_err("Expected to fail");
-    assert_eq!(
+    assert!(matches!(
         err,
         Error::Client(ClientErrorKind::Interface(ResponseStatus::ConnectionError))
-    );
+    ));
 }
 
 #[test]
@@ -866,10 +872,10 @@ fn set_default_auth_direct() {
         }),
     ));
 
-    assert_eq!(
+    assert!(matches!(
         client.set_default_auth(None).unwrap_err(),
         Error::Client(ClientErrorKind::MissingParam)
-    );
+    ));
 
     client.set_mock_read(&get_response_bytes_from_result(
         NativeResult::ListAuthenticators(operations::list_authenticators::Result {

src/error.rs

@@ -6,7 +6,7 @@ use std::error;
 use std::fmt;
 
 /// Enum used to denote errors returned to the library user
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub enum Error {
     /// Errors originating in the service
     Service(ResponseStatus),
@@ -43,7 +43,7 @@ pub enum ClientErrorKind {
     /// Required parameter was not provided
     MissingParam,
     /// Error while using the SPIFFE Workload API
-    Spiffe,
+    Spiffe(spiffe::workload::Error),
 }
 
 impl From<ClientErrorKind> for Error {
@@ -52,35 +52,6 @@ impl From<ClientErrorKind> for Error {
     }
 }
 
-impl PartialEq for ClientErrorKind {
-    fn eq(&self, other: &Self) -> bool {
-        match self {
-            ClientErrorKind::Interface(status) => {
-                if let ClientErrorKind::Interface(other_status) = other {
-                    other_status == status
-                } else {
-                    false
-                }
-            }
-            ClientErrorKind::Ipc(error) => {
-                if let ClientErrorKind::Ipc(other_error) = other {
-                    other_error.kind() == error.kind()
-                } else {
-                    false
-                }
-            }
-            ClientErrorKind::InvalidServiceResponseType => {
-                matches!(other, ClientErrorKind::InvalidServiceResponseType)
-            }
-            ClientErrorKind::InvalidProvider => matches!(other, ClientErrorKind::InvalidProvider),
-            ClientErrorKind::NoProvider => matches!(other, ClientErrorKind::NoProvider),
-            ClientErrorKind::NoAuthenticator => matches!(other, ClientErrorKind::NoAuthenticator),
-            ClientErrorKind::MissingParam => matches!(other, ClientErrorKind::MissingParam),
-            ClientErrorKind::Spiffe => matches!(other, ClientErrorKind::Spiffe),
-        }
-    }
-}
-
 impl fmt::Display for ClientErrorKind {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
@@ -96,7 +67,7 @@ impl fmt::Display for ClientErrorKind {
             ClientErrorKind::NoProvider => write!(f, "client is missing an implicit provider"),
             ClientErrorKind::NoAuthenticator => write!(f, "service is not reporting any authenticators or none of the reported ones are supported by the client"),
             ClientErrorKind::MissingParam => write!(f, "one of the `Option` parameters was required but was not provided"),
-            ClientErrorKind::Spiffe => write!(f, "error using the SPIFFE Workload API"),
+            ClientErrorKind::Spiffe(error) => error.fmt(f),
         }
     }
 }