Update nitrokey crate to 0.4.0-alpha.0

This is patch marks the first step in the process of updating the
nitrokey dependency to version 0.4. In particular, it integrates with
the first alpha version.
The main change on the nitrocli side accompanying the version bump is
that the nitrokey::CommandError got replaced by a more general
nitrokey::Error which includes the former variant.

Import subrepo nitrokey/:nitrokey at d433189caefe6bd6c88da7fbb1d6e9304353eb83

1 files changed, 55 insertions, 61 deletions

diff --git a/nitrokey/tests/pws.rs b/nitrokey/tests/pws.rs
index fbcc0c1..df99e1c 100644
--- a/nitrokey/tests/pws.rs
+++ b/nitrokey/tests/pws.rs
@@ -1,18 +1,23 @@
+// Copyright (C) 2018-2019 Robin Krahl <robin.krahl@ireas.org>
+// SPDX-License-Identifier: MIT
+
 mod util;
 
 use std::ffi::CStr;
 
 use libc::{c_int, c_void, free};
-use nitrokey::{CommandError, Device, GetPasswordSafe, PasswordSafe, SLOT_COUNT};
+use nitrokey::{
+    CommandError, Device, Error, GetPasswordSafe, LibraryError, PasswordSafe, SLOT_COUNT,
+};
 use nitrokey_sys;
 use nitrokey_test::test as test_device;
 
 use crate::util::{ADMIN_PASSWORD, USER_PASSWORD};
 
-fn get_slot_name_direct(slot: u8) -> Result<String, CommandError> {
+fn get_slot_name_direct(slot: u8) -> Result<String, Error> {
     let ptr = unsafe { nitrokey_sys::NK_get_password_safe_slot_name(slot) };
     if ptr.is_null() {
-        return Err(CommandError::Undefined);
+        return Err(Error::UnexpectedError);
     }
     let s = unsafe { CStr::from_ptr(ptr).to_string_lossy().into_owned() };
     unsafe { free(ptr as *mut c_void) };
@@ -21,7 +26,7 @@ fn get_slot_name_direct(slot: u8) -> Result<String, CommandError> {
             let error = unsafe { nitrokey_sys::NK_get_last_command_status() } as c_int;
             match error {
                 0 => Ok(s),
-                other => Err(CommandError::from(other)),
+                other => Err(Error::from(other)),
             }
         }
         false => Ok(s),
@@ -37,11 +42,15 @@ where
 
 #[test_device]
 fn enable(device: DeviceWrapper) {
-    assert!(device
-        .get_password_safe(&(USER_PASSWORD.to_owned() + "123"))
-        .is_err());
+    assert_cmd_err!(
+        CommandError::WrongPassword,
+        device.get_password_safe(&(USER_PASSWORD.to_owned() + "123"))
+    );
     assert!(device.get_password_safe(USER_PASSWORD).is_ok());
-    assert!(device.get_password_safe(ADMIN_PASSWORD).is_err());
+    assert_cmd_err!(
+        CommandError::WrongPassword,
+        device.get_password_safe(ADMIN_PASSWORD)
+    );
     assert!(device.get_password_safe(USER_PASSWORD).is_ok());
 }
 
@@ -49,35 +58,35 @@ fn enable(device: DeviceWrapper) {
 fn drop(device: DeviceWrapper) {
     {
         let pws = get_pws(&device);
-        assert_eq!(Ok(()), pws.write_slot(1, "name", "login", "password"));
+        assert_ok!((), pws.write_slot(1, "name", "login", "password"));
         assert_eq!("name", pws.get_slot_name(1).unwrap());
         let result = get_slot_name_direct(1);
-        assert_eq!(Ok(String::from("name")), result);
+        assert_ok!(String::from("name"), result);
     }
     let result = get_slot_name_direct(1);
-    assert_eq!(Ok(String::from("name")), result);
-    assert_eq!(Ok(()), device.lock());
+    assert_ok!(String::from("name"), result);
+    assert_ok!((), device.lock());
     let result = get_slot_name_direct(1);
-    assert_eq!(Err(CommandError::NotAuthorized), result);
+    assert_cmd_err!(CommandError::NotAuthorized, result);
 }
 
 #[test_device]
 fn get_status(device: DeviceWrapper) {
     let pws = get_pws(&device);
     for i in 0..SLOT_COUNT {
-        assert_eq!(Ok(()), pws.erase_slot(i), "Could not erase slot {}", i);
+        assert_ok!((), pws.erase_slot(i));
     }
     let status = pws.get_slot_status().unwrap();
     assert_eq!(status, [false; SLOT_COUNT as usize]);
 
-    assert_eq!(Ok(()), pws.write_slot(1, "name", "login", "password"));
+    assert_ok!((), pws.write_slot(1, "name", "login", "password"));
     let status = pws.get_slot_status().unwrap();
     for i in 0..SLOT_COUNT {
         assert_eq!(i == 1, status[i as usize]);
     }
 
     for i in 0..SLOT_COUNT {
-        assert_eq!(Ok(()), pws.write_slot(i, "name", "login", "password"));
+        assert_ok!((), pws.write_slot(i, "name", "login", "password"));
     }
     let status = pws.get_slot_status().unwrap();
     assert_eq!(status, [true; SLOT_COUNT as usize]);
@@ -86,76 +95,61 @@ fn get_status(device: DeviceWrapper) {
 #[test_device]
 fn get_data(device: DeviceWrapper) {
     let pws = get_pws(&device);
-    assert_eq!(Ok(()), pws.write_slot(1, "name", "login", "password"));
+    assert_ok!((), pws.write_slot(1, "name", "login", "password"));
     assert_eq!("name", pws.get_slot_name(1).unwrap());
     assert_eq!("login", pws.get_slot_login(1).unwrap());
     assert_eq!("password", pws.get_slot_password(1).unwrap());
 
-    assert_eq!(Ok(()), pws.erase_slot(1));
-    assert_eq!(Err(CommandError::SlotNotProgrammed), pws.get_slot_name(1));
-    assert_eq!(Err(CommandError::SlotNotProgrammed), pws.get_slot_login(1));
-    assert_eq!(
-        Err(CommandError::SlotNotProgrammed),
-        pws.get_slot_password(1)
-    );
+    assert_ok!((), pws.erase_slot(1));
+    assert_cmd_err!(CommandError::SlotNotProgrammed, pws.get_slot_name(1));
+    assert_cmd_err!(CommandError::SlotNotProgrammed, pws.get_slot_login(1));
+    assert_cmd_err!(CommandError::SlotNotProgrammed, pws.get_slot_password(1));
 
     let name = "with å";
     let login = "pär@test.com";
     let password = "'i3lJc[09?I:,[u7dWz9";
-    assert_eq!(Ok(()), pws.write_slot(1, name, login, password));
+    assert_ok!((), pws.write_slot(1, name, login, password));
     assert_eq!(name, pws.get_slot_name(1).unwrap());
     assert_eq!(login, pws.get_slot_login(1).unwrap());
     assert_eq!(password, pws.get_slot_password(1).unwrap());
 
-    assert_eq!(
-        Err(CommandError::InvalidSlot),
-        pws.get_slot_name(SLOT_COUNT)
-    );
-    assert_eq!(
-        Err(CommandError::InvalidSlot),
-        pws.get_slot_login(SLOT_COUNT)
-    );
-    assert_eq!(
-        Err(CommandError::InvalidSlot),
-        pws.get_slot_password(SLOT_COUNT)
-    );
+    assert_lib_err!(LibraryError::InvalidSlot, pws.get_slot_name(SLOT_COUNT));
+    assert_lib_err!(LibraryError::InvalidSlot, pws.get_slot_login(SLOT_COUNT));
+    assert_lib_err!(LibraryError::InvalidSlot, pws.get_slot_password(SLOT_COUNT));
 }
 
 #[test_device]
 fn write(device: DeviceWrapper) {
     let pws = get_pws(&device);
 
-    assert_eq!(
-        Err(CommandError::InvalidSlot),
+    assert_lib_err!(
+        LibraryError::InvalidSlot,
         pws.write_slot(SLOT_COUNT, "name", "login", "password")
     );
 
-    assert_eq!(Ok(()), pws.write_slot(0, "", "login", "password"));
-    assert_eq!(Err(CommandError::SlotNotProgrammed), pws.get_slot_name(0));
-    assert_eq!(Ok(String::from("login")), pws.get_slot_login(0));
-    assert_eq!(Ok(String::from("password")), pws.get_slot_password(0));
-
-    assert_eq!(Ok(()), pws.write_slot(0, "name", "", "password"));
-    assert_eq!(Ok(String::from("name")), pws.get_slot_name(0));
-    assert_eq!(Err(CommandError::SlotNotProgrammed), pws.get_slot_login(0));
-    assert_eq!(Ok(String::from("password")), pws.get_slot_password(0));
-
-    assert_eq!(Ok(()), pws.write_slot(0, "name", "login", ""));
-    assert_eq!(Ok(String::from("name")), pws.get_slot_name(0));
-    assert_eq!(Ok(String::from("login")), pws.get_slot_login(0));
-    assert_eq!(
-        Err(CommandError::SlotNotProgrammed),
-        pws.get_slot_password(0)
-    );
+    assert_ok!((), pws.write_slot(0, "", "login", "password"));
+    assert_cmd_err!(CommandError::SlotNotProgrammed, pws.get_slot_name(0));
+    assert_ok!(String::from("login"), pws.get_slot_login(0));
+    assert_ok!(String::from("password"), pws.get_slot_password(0));
+
+    assert_ok!((), pws.write_slot(0, "name", "", "password"));
+    assert_ok!(String::from("name"), pws.get_slot_name(0));
+    assert_cmd_err!(CommandError::SlotNotProgrammed, pws.get_slot_login(0));
+    assert_ok!(String::from("password"), pws.get_slot_password(0));
+
+    assert_ok!((), pws.write_slot(0, "name", "login", ""));
+    assert_ok!(String::from("name"), pws.get_slot_name(0));
+    assert_ok!(String::from("login"), pws.get_slot_login(0));
+    assert_cmd_err!(CommandError::SlotNotProgrammed, pws.get_slot_password(0));
 }
 
 #[test_device]
 fn erase(device: DeviceWrapper) {
     let pws = get_pws(&device);
-    assert_eq!(Err(CommandError::InvalidSlot), pws.erase_slot(SLOT_COUNT));
+    assert_lib_err!(LibraryError::InvalidSlot, pws.erase_slot(SLOT_COUNT));
 
-    assert_eq!(Ok(()), pws.write_slot(0, "name", "login", "password"));
-    assert_eq!(Ok(()), pws.erase_slot(0));
-    assert_eq!(Ok(()), pws.erase_slot(0));
-    assert_eq!(Err(CommandError::SlotNotProgrammed), pws.get_slot_name(0));
+    assert_ok!((), pws.write_slot(0, "name", "login", "password"));
+    assert_ok!((), pws.erase_slot(0));
+    assert_ok!((), pws.erase_slot(0));
+    assert_cmd_err!(CommandError::SlotNotProgrammed, pws.get_slot_name(0));
 }