From 333d17fb7b7a0eb43b7907fe7282c36ded2bd22e Mon Sep 17 00:00:00 2001 From: Daniel Mueller Date: Wed, 9 Jan 2019 09:43:09 -0800 Subject: Update nitrokey crate to 0.3.1 This change updates the nitrokey crate to version 0.3.1. Import subrepo nitrokey/:nitrokey at bad12ad3c57c67d42243338af7d65c3591fed327 --- nitrokey/tests/device.rs | 219 +++++++++++++++++++++------------------------ nitrokey/tests/otp.rs | 155 +++++++++++++++----------------- nitrokey/tests/pws.rs | 72 +++++++-------- nitrokey/tests/util/mod.rs | 6 -- 4 files changed, 209 insertions(+), 243 deletions(-) (limited to 'nitrokey/tests') diff --git a/nitrokey/tests/device.rs b/nitrokey/tests/device.rs index 0ad4987..db8194c 100644 --- a/nitrokey/tests/device.rs +++ b/nitrokey/tests/device.rs @@ -6,10 +6,11 @@ use std::{thread, time}; use nitrokey::{ Authenticate, CommandError, Config, ConfigureOtp, Device, GenerateOtp, GetPasswordSafe, - OtpMode, OtpSlotData, Storage, + OtpMode, OtpSlotData, }; +use nitrokey_test::test as test_device; -use crate::util::{Target, ADMIN_PASSWORD, UPDATE_PIN, USER_PASSWORD}; +use crate::util::{ADMIN_PASSWORD, UPDATE_PIN, USER_PASSWORD}; static ADMIN_NEW_PASSWORD: &str = "1234567890"; static UPDATE_NEW_PIN: &str = "87654321"; @@ -27,36 +28,39 @@ fn count_nitrokey_block_devices() -> usize { .count() } -#[test] -#[cfg_attr(any(feature = "test-pro", feature = "test-storage"), ignore)] +#[test_device] fn connect_no_device() { assert!(nitrokey::connect().is_err()); + assert!(nitrokey::connect_model(nitrokey::Model::Pro).is_err()); + assert!(nitrokey::connect_model(nitrokey::Model::Storage).is_err()); assert!(nitrokey::Pro::connect().is_err()); assert!(nitrokey::Storage::connect().is_err()); } -#[test] -#[cfg_attr(not(feature = "test-pro"), ignore)] -fn connect_pro() { +#[test_device] +fn connect_pro(device: Pro) { + assert_eq!(device.get_model(), nitrokey::Model::Pro); + drop(device); + assert!(nitrokey::connect().is_ok()); + assert!(nitrokey::connect_model(nitrokey::Model::Pro).is_ok()); assert!(nitrokey::Pro::connect().is_ok()); + + assert!(nitrokey::connect_model(nitrokey::Model::Storage).is_err()); assert!(nitrokey::Storage::connect().is_err()); - match nitrokey::connect().unwrap() { - nitrokey::DeviceWrapper::Pro(_) => assert!(true), - nitrokey::DeviceWrapper::Storage(_) => assert!(false), - }; } -#[test] -#[cfg_attr(not(feature = "test-storage"), ignore)] -fn connect_storage() { +#[test_device] +fn connect_storage(device: Storage) { + assert_eq!(device.get_model(), nitrokey::Model::Storage); + drop(device); + assert!(nitrokey::connect().is_ok()); - assert!(nitrokey::Pro::connect().is_err()); + assert!(nitrokey::connect_model(nitrokey::Model::Storage).is_ok()); assert!(nitrokey::Storage::connect().is_ok()); - match nitrokey::connect().unwrap() { - nitrokey::DeviceWrapper::Pro(_) => assert!(false), - nitrokey::DeviceWrapper::Storage(_) => assert!(true), - }; + + assert!(nitrokey::connect_model(nitrokey::Model::Pro).is_err()); + assert!(nitrokey::Pro::connect().is_err()); } fn assert_empty_serial_number() { @@ -68,54 +72,22 @@ fn assert_empty_serial_number() { } } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn disconnect() { - Target::connect().unwrap(); - assert_empty_serial_number(); - Target::connect() - .unwrap() - .authenticate_admin(ADMIN_PASSWORD) - .unwrap(); - assert_empty_serial_number(); - Target::connect() - .unwrap() - .authenticate_user(USER_PASSWORD) - .unwrap(); +#[test_device] +fn disconnect(device: DeviceWrapper) { + drop(device); assert_empty_serial_number(); } -fn require_model(model: nitrokey::Model) { - assert_eq!(model, nitrokey::connect().unwrap().get_model()); - assert_eq!(model, Target::connect().unwrap().get_model()); -} - -#[test] -#[cfg_attr(not(feature = "test-pro"), ignore)] -fn get_model_pro() { - require_model(nitrokey::Model::Pro); -} - -#[test] -#[cfg_attr(not(feature = "test-storage"), ignore)] -fn get_model_storage() { - require_model(nitrokey::Model::Storage); -} - -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn get_serial_number() { - let device = Target::connect().unwrap(); +#[test_device] +fn get_serial_number(device: DeviceWrapper) { let result = device.get_serial_number(); assert!(result.is_ok()); let serial_number = result.unwrap(); assert!(serial_number.is_ascii()); assert!(serial_number.chars().all(|c| c.is_ascii_hexdigit())); } -#[test] -#[cfg_attr(not(feature = "test-pro"), ignore)] -fn get_firmware_version() { - let device = Target::connect().unwrap(); +#[test_device] +fn get_firmware_version(device: Pro) { assert_eq!(0, device.get_major_firmware_version()); let minor = device.get_minor_firmware_version(); assert!(minor > 0); @@ -141,11 +113,8 @@ fn user_retry(device: T, suffix: &str, count: u8) -> T return device; } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn get_retry_count() { - let device = Target::connect().unwrap(); - +#[test_device] +fn get_retry_count(device: DeviceWrapper) { let device = admin_retry(device, "", 3); let device = admin_retry(device, "123", 2); let device = admin_retry(device, "456", 1); @@ -157,13 +126,11 @@ fn get_retry_count() { user_retry(device, "", 3); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn config() { - let device = Target::connect().unwrap(); +#[test_device] +fn config(device: DeviceWrapper) { let admin = device.authenticate_admin(ADMIN_PASSWORD).unwrap(); let config = Config::new(None, None, None, true); - assert!(admin.write_config(config).is_ok()); + assert_eq!(Ok(()), admin.write_config(config)); let get_config = admin.get_config().unwrap(); assert_eq!(config, get_config); @@ -171,20 +138,18 @@ fn config() { assert_eq!(Err(CommandError::InvalidSlot), admin.write_config(config)); let config = Config::new(Some(1), None, Some(0), false); - assert!(admin.write_config(config).is_ok()); + assert_eq!(Ok(()), admin.write_config(config)); let get_config = admin.get_config().unwrap(); assert_eq!(config, get_config); let config = Config::new(None, None, None, false); - assert!(admin.write_config(config).is_ok()); + assert_eq!(Ok(()), admin.write_config(config)); let get_config = admin.get_config().unwrap(); assert_eq!(config, get_config); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn change_user_pin() { - let device = Target::connect().unwrap(); +#[test_device] +fn change_user_pin(device: DeviceWrapper) { let device = device.authenticate_user(USER_PASSWORD).unwrap().device(); let device = device.authenticate_user(USER_NEW_PASSWORD).unwrap_err().0; @@ -209,10 +174,8 @@ fn change_user_pin() { assert!(device.authenticate_user(USER_NEW_PASSWORD).is_err()); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn change_admin_pin() { - let device = Target::connect().unwrap(); +#[test_device] +fn change_admin_pin(device: DeviceWrapper) { let device = device.authenticate_admin(ADMIN_PASSWORD).unwrap().device(); let device = device.authenticate_admin(ADMIN_NEW_PASSWORD).unwrap_err().0; @@ -239,7 +202,11 @@ fn change_admin_pin() { device.authenticate_admin(ADMIN_NEW_PASSWORD).unwrap_err(); } -fn require_failed_user_login(device: Target, password: &str, error: CommandError) -> Target { +fn require_failed_user_login(device: D, password: &str, error: CommandError) -> D +where + D: Device + Authenticate, + nitrokey::User: std::fmt::Debug, +{ let result = device.authenticate_user(password); assert!(result.is_err()); let err = result.unwrap_err(); @@ -247,10 +214,8 @@ fn require_failed_user_login(device: Target, password: &str, error: CommandError err.0 } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn unlock_user_pin() { - let device = Target::connect().unwrap(); +#[test_device] +fn unlock_user_pin(device: DeviceWrapper) { let device = device.authenticate_user(USER_PASSWORD).unwrap().device(); assert!(device .unlock_user_pin(ADMIN_PASSWORD, USER_PASSWORD) @@ -298,11 +263,8 @@ fn unlock_user_pin() { .is_ok()); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn factory_reset() { - let device = Target::connect().unwrap(); - +#[test_device] +fn factory_reset(device: DeviceWrapper) { assert_eq!( Ok(()), device.change_user_pin(USER_PASSWORD, USER_NEW_PASSWORD) @@ -348,11 +310,8 @@ fn factory_reset() { assert_eq!(Ok(()), device.build_aes_key(ADMIN_PASSWORD)); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn build_aes_key() { - let device = Target::connect().unwrap(); - +#[test_device] +fn build_aes_key(device: DeviceWrapper) { let pws = device.get_password_safe(USER_PASSWORD).unwrap(); assert_eq!(Ok(()), pws.write_slot(0, "test", "testlogin", "testpw")); drop(pws); @@ -371,11 +330,8 @@ fn build_aes_key() { assert_ne!("testpw".to_string(), pws.get_slot_password(0).unwrap()); } -#[test] -#[cfg_attr(not(feature = "test-storage"), ignore)] -fn change_update_pin() { - let device = Storage::connect().unwrap(); - +#[test_device] +fn change_update_pin(device: Storage) { assert_eq!( Err(CommandError::WrongPassword), device.change_update_pin(UPDATE_NEW_PIN, UPDATE_PIN) @@ -384,40 +340,71 @@ fn change_update_pin() { assert_eq!(Ok(()), device.change_update_pin(UPDATE_NEW_PIN, UPDATE_PIN)); } -#[test] -#[cfg_attr(not(feature = "test-storage"), ignore)] -fn encrypted_volume() { - let device = Storage::connect().unwrap(); - assert!(device.lock().is_ok()); +#[test_device] +fn encrypted_volume(device: Storage) { + assert_eq!(Ok(()), device.lock()); assert_eq!(1, count_nitrokey_block_devices()); - assert!(device.disable_encrypted_volume().is_ok()); + assert_eq!(Ok(()), device.disable_encrypted_volume()); assert_eq!(1, count_nitrokey_block_devices()); assert_eq!( Err(CommandError::WrongPassword), device.enable_encrypted_volume("123") ); assert_eq!(1, count_nitrokey_block_devices()); - assert!(device.enable_encrypted_volume(USER_PASSWORD).is_ok()); + assert_eq!(Ok(()), device.enable_encrypted_volume(USER_PASSWORD)); assert_eq!(2, count_nitrokey_block_devices()); - assert!(device.disable_encrypted_volume().is_ok()); + assert_eq!(Ok(()), device.disable_encrypted_volume()); assert_eq!(1, count_nitrokey_block_devices()); } -#[test] -#[cfg_attr(not(feature = "test-storage"), ignore)] -fn lock() { - let device = Storage::connect().unwrap(); +#[test_device] +fn hidden_volume(device: Storage) { + assert_eq!(Ok(()), device.lock()); + + assert_eq!(1, count_nitrokey_block_devices()); + assert_eq!(Ok(()), device.disable_hidden_volume()); + assert_eq!(1, count_nitrokey_block_devices()); + + assert_eq!(Ok(()), device.enable_encrypted_volume(USER_PASSWORD)); + assert_eq!(2, count_nitrokey_block_devices()); + + // TODO: why this error code? + assert_eq!( + Err(CommandError::WrongPassword), + device.create_hidden_volume(5, 0, 100, "hiddenpw") + ); + assert_eq!(Ok(()), device.create_hidden_volume(0, 20, 21, "hidden-pw")); + assert_eq!( + Ok(()), + device.create_hidden_volume(0, 20, 21, "hiddenpassword") + ); + assert_eq!(Ok(()), device.create_hidden_volume(1, 0, 1, "otherpw")); + // TODO: test invalid range (not handled by libnitrokey) + assert_eq!(2, count_nitrokey_block_devices()); + + assert_eq!( + Err(CommandError::WrongPassword), + device.enable_hidden_volume("blubb") + ); + assert_eq!(Ok(()), device.enable_hidden_volume("hiddenpassword")); + assert_eq!(2, count_nitrokey_block_devices()); + assert_eq!(Ok(()), device.enable_hidden_volume("otherpw")); + assert_eq!(2, count_nitrokey_block_devices()); + + assert_eq!(Ok(()), device.disable_hidden_volume()); + assert_eq!(1, count_nitrokey_block_devices()); +} - assert!(device.enable_encrypted_volume(USER_PASSWORD).is_ok()); - assert!(device.lock().is_ok()); +#[test_device] +fn lock(device: Storage) { + assert_eq!(Ok(()), device.enable_encrypted_volume(USER_PASSWORD)); + assert_eq!(Ok(()), device.lock()); assert_eq!(1, count_nitrokey_block_devices()); } -#[test] -#[cfg_attr(not(feature = "test-storage"), ignore)] -fn get_storage_status() { - let device = Storage::connect().unwrap(); +#[test_device] +fn get_storage_status(device: Storage) { let status = device.get_status().unwrap(); assert!(status.serial_number_sd_card > 0); diff --git a/nitrokey/tests/otp.rs b/nitrokey/tests/otp.rs index c7d6e68..2b46088 100644 --- a/nitrokey/tests/otp.rs +++ b/nitrokey/tests/otp.rs @@ -1,12 +1,15 @@ mod util; +use std::fmt::Debug; use std::ops::Deref; use nitrokey::{ - Admin, Authenticate, CommandError, Config, ConfigureOtp, GenerateOtp, OtpMode, OtpSlotData, + Admin, Authenticate, CommandError, Config, ConfigureOtp, Device, GenerateOtp, OtpMode, + OtpSlotData, }; +use nitrokey_test::test as test_device; -use crate::util::{Target, ADMIN_PASSWORD, USER_PASSWORD}; +use crate::util::{ADMIN_PASSWORD, USER_PASSWORD}; // test suite according to RFC 4226, Appendix D static HOTP_SECRET: &str = "3132333435363738393031323334353637383930"; @@ -32,16 +35,19 @@ enum TotpTimestampSize { U64, } -fn get_admin_test_device() -> Admin { - Target::connect() - .expect("Could not connect to the Nitrokey.") +fn make_admin_test_device(device: T) -> Admin +where + T: Device, + (T, nitrokey::CommandError): Debug, +{ + device .authenticate_admin(ADMIN_PASSWORD) .expect("Could not login as admin.") } fn configure_hotp(admin: &ConfigureOtp, counter: u8) { let slot_data = OtpSlotData::new(1, "test-hotp", HOTP_SECRET, OtpMode::SixDigits); - assert!(admin.write_hotp_slot(slot_data, counter.into()).is_ok()); + assert_eq!(Ok(()), admin.write_hotp_slot(slot_data, counter.into())); } fn check_hotp_codes(device: &GenerateOtp, offset: u8) { @@ -53,22 +59,22 @@ fn check_hotp_codes(device: &GenerateOtp, offset: u8) { }); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn set_time() { - let device = Target::connect().expect("Could not connect to the Nitrokey."); +#[test_device] +fn set_time(device: DeviceWrapper) { assert_eq!(Ok(()), device.set_time(1546385382, true)); assert_eq!(Ok(()), device.set_time(1546385392, false)); - assert_eq!(Err(CommandError::Timestamp), device.set_time(1546385292, false)); + assert_eq!( + Err(CommandError::Timestamp), + device.set_time(1546385292, false) + ); assert_eq!(Ok(()), device.set_time(1546385382, true)); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn hotp_no_pin() { - let admin = get_admin_test_device(); +#[test_device] +fn hotp_no_pin(device: DeviceWrapper) { + let admin = make_admin_test_device(device); let config = Config::new(None, None, None, false); - assert!(admin.write_config(config).is_ok()); + assert_eq!(Ok(()), admin.write_config(config)); configure_hotp(&admin, 0); check_hotp_codes(admin.deref(), 0); @@ -80,12 +86,11 @@ fn hotp_no_pin() { check_hotp_codes(&admin.device(), 0); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn hotp_pin() { - let admin = get_admin_test_device(); +#[test_device] +fn hotp_pin(device: DeviceWrapper) { + let admin = make_admin_test_device(device); let config = Config::new(None, None, None, true); - assert!(admin.write_config(config).is_ok()); + assert_eq!(Ok(()), admin.write_config(config)); configure_hotp(&admin, 0); let user = admin.device().authenticate_user(USER_PASSWORD).unwrap(); @@ -94,12 +99,11 @@ fn hotp_pin() { assert!(user.device().get_hotp_code(1).is_err()); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn hotp_slot_name() { - let admin = get_admin_test_device(); +#[test_device] +fn hotp_slot_name(device: DeviceWrapper) { + let admin = make_admin_test_device(device); let slot_data = OtpSlotData::new(1, "test-hotp", HOTP_SECRET, OtpMode::SixDigits); - assert!(admin.write_hotp_slot(slot_data, 0).is_ok()); + assert_eq!(Ok(()), admin.write_hotp_slot(slot_data, 0)); let device = admin.device(); let result = device.get_hotp_slot_name(1); @@ -108,10 +112,9 @@ fn hotp_slot_name() { assert_eq!(CommandError::InvalidSlot, result.unwrap_err()); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn hotp_error() { - let admin = get_admin_test_device(); +#[test_device] +fn hotp_error(device: DeviceWrapper) { + let admin = make_admin_test_device(device); let slot_data = OtpSlotData::new(1, "", HOTP_SECRET, OtpMode::SixDigits); assert_eq!( Err(CommandError::NoName), @@ -126,18 +129,17 @@ fn hotp_error() { assert_eq!(CommandError::InvalidSlot, code.unwrap_err()); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn hotp_erase() { - let admin = get_admin_test_device(); +#[test_device] +fn hotp_erase(device: DeviceWrapper) { + let admin = make_admin_test_device(device); let config = Config::new(None, None, None, false); - assert!(admin.write_config(config).is_ok()); + assert_eq!(Ok(()), admin.write_config(config)); let slot_data = OtpSlotData::new(1, "test1", HOTP_SECRET, OtpMode::SixDigits); - assert!(admin.write_hotp_slot(slot_data, 0).is_ok()); + assert_eq!(Ok(()), admin.write_hotp_slot(slot_data, 0)); let slot_data = OtpSlotData::new(2, "test2", HOTP_SECRET, OtpMode::SixDigits); - assert!(admin.write_hotp_slot(slot_data, 0).is_ok()); + assert_eq!(Ok(()), admin.write_hotp_slot(slot_data, 0)); - assert!(admin.erase_hotp_slot(1).is_ok()); + assert_eq!(Ok(()), admin.erase_hotp_slot(1)); let device = admin.device(); let result = device.get_hotp_slot_name(1); @@ -151,7 +153,7 @@ fn hotp_erase() { fn configure_totp(admin: &ConfigureOtp, factor: u64) { let slot_data = OtpSlotData::new(1, "test-totp", TOTP_SECRET, OtpMode::EightDigits); let time_window = 30u64.checked_mul(factor).unwrap(); - assert!(admin.write_totp_slot(slot_data, time_window as u16).is_ok()); + assert_eq!(Ok(()), admin.write_totp_slot(slot_data, time_window as u16)); } fn check_totp_codes(device: &GenerateOtp, factor: u64, timestamp_size: TotpTimestampSize) { @@ -162,7 +164,7 @@ fn check_totp_codes(device: &GenerateOtp, factor: u64, timestamp_size: TotpTimes continue; } - assert!(device.set_time(time, true).is_ok()); + assert_eq!(Ok(()), device.set_time(time, true)); let result = device.get_totp_code(1); assert!(result.is_ok()); let result_code = result.unwrap(); @@ -174,13 +176,12 @@ fn check_totp_codes(device: &GenerateOtp, factor: u64, timestamp_size: TotpTimes } } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn totp_no_pin() { +#[test_device] +fn totp_no_pin(device: DeviceWrapper) { // TODO: this test may fail due to bad timing --> find solution - let admin = get_admin_test_device(); + let admin = make_admin_test_device(device); let config = Config::new(None, None, None, false); - assert!(admin.write_config(config).is_ok()); + assert_eq!(Ok(()), admin.write_config(config)); configure_totp(&admin, 1); check_totp_codes(admin.deref(), 1, TotpTimestampSize::U32); @@ -192,15 +193,13 @@ fn totp_no_pin() { check_totp_codes(&admin.device(), 1, TotpTimestampSize::U32); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -#[cfg_attr(feature = "test-storage", should_panic(expected = "assertion failed"))] -// Nitrokey Storage does only support timestamps that fit in a 32-bit unsigned integer. Therefore -// the last RFC test case is expected to fail. -fn totp_no_pin_64() { - let admin = get_admin_test_device(); +#[test_device] +// Nitrokey Storage does only support timestamps that fit in a 32-bit +// unsigned integer, so don't test with it. +fn totp_no_pin_64(device: Pro) { + let admin = make_admin_test_device(device); let config = Config::new(None, None, None, false); - assert!(admin.write_config(config).is_ok()); + assert_eq!(Ok(()), admin.write_config(config)); configure_totp(&admin, 1); check_totp_codes(admin.deref(), 1, TotpTimestampSize::U64); @@ -212,13 +211,12 @@ fn totp_no_pin_64() { check_totp_codes(&admin.device(), 1, TotpTimestampSize::U64); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn totp_pin() { +#[test_device] +fn totp_pin(device: DeviceWrapper) { // TODO: this test may fail due to bad timing --> find solution - let admin = get_admin_test_device(); + let admin = make_admin_test_device(device); let config = Config::new(None, None, None, true); - assert!(admin.write_config(config).is_ok()); + assert_eq!(Ok(()), admin.write_config(config)); configure_totp(&admin, 1); let user = admin.device().authenticate_user(USER_PASSWORD).unwrap(); @@ -227,14 +225,12 @@ fn totp_pin() { assert!(user.device().get_totp_code(1).is_err()); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -#[cfg_attr(feature = "test-storage", should_panic(expected = "assertion failed"))] +#[test_device] // See comment for totp_no_pin_64. -fn totp_pin_64() { - let admin = get_admin_test_device(); +fn totp_pin_64(device: Pro) { + let admin = make_admin_test_device(device); let config = Config::new(None, None, None, true); - assert!(admin.write_config(config).is_ok()); + assert_eq!(Ok(()), admin.write_config(config)); configure_totp(&admin, 1); let user = admin.device().authenticate_user(USER_PASSWORD).unwrap(); @@ -243,12 +239,11 @@ fn totp_pin_64() { assert!(user.device().get_totp_code(1).is_err()); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn totp_slot_name() { - let admin = get_admin_test_device(); +#[test_device] +fn totp_slot_name(device: DeviceWrapper) { + let admin = make_admin_test_device(device); let slot_data = OtpSlotData::new(1, "test-totp", TOTP_SECRET, OtpMode::EightDigits); - assert!(admin.write_totp_slot(slot_data, 0).is_ok()); + assert_eq!(Ok(()), admin.write_totp_slot(slot_data, 0)); let device = admin.device(); let result = device.get_totp_slot_name(1); @@ -258,10 +253,9 @@ fn totp_slot_name() { assert_eq!(CommandError::InvalidSlot, result.unwrap_err()); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn totp_error() { - let admin = get_admin_test_device(); +#[test_device] +fn totp_error(device: DeviceWrapper) { + let admin = make_admin_test_device(device); let slot_data = OtpSlotData::new(1, "", HOTP_SECRET, OtpMode::SixDigits); assert_eq!( Err(CommandError::NoName), @@ -276,18 +270,17 @@ fn totp_error() { assert_eq!(CommandError::InvalidSlot, code.unwrap_err()); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn totp_erase() { - let admin = get_admin_test_device(); +#[test_device] +fn totp_erase(device: DeviceWrapper) { + let admin = make_admin_test_device(device); let config = Config::new(None, None, None, false); - assert!(admin.write_config(config).is_ok()); + assert_eq!(Ok(()), admin.write_config(config)); let slot_data = OtpSlotData::new(1, "test1", TOTP_SECRET, OtpMode::SixDigits); - assert!(admin.write_totp_slot(slot_data, 0).is_ok()); + assert_eq!(Ok(()), admin.write_totp_slot(slot_data, 0)); let slot_data = OtpSlotData::new(2, "test2", TOTP_SECRET, OtpMode::SixDigits); - assert!(admin.write_totp_slot(slot_data, 0).is_ok()); + assert_eq!(Ok(()), admin.write_totp_slot(slot_data, 0)); - assert!(admin.erase_totp_slot(1).is_ok()); + assert_eq!(Ok(()), admin.erase_totp_slot(1)); let device = admin.device(); let result = device.get_totp_slot_name(1); diff --git a/nitrokey/tests/pws.rs b/nitrokey/tests/pws.rs index 5061298..b349558 100644 --- a/nitrokey/tests/pws.rs +++ b/nitrokey/tests/pws.rs @@ -5,8 +5,9 @@ use std::ffi::CStr; use libc::{c_int, c_void, free}; use nitrokey::{CommandError, Device, GetPasswordSafe, PasswordSafe, SLOT_COUNT}; use nitrokey_sys; +use nitrokey_test::test as test_device; -use crate::util::{Target, ADMIN_PASSWORD, USER_PASSWORD}; +use crate::util::{ADMIN_PASSWORD, USER_PASSWORD}; fn get_slot_name_direct(slot: u8) -> Result { let ptr = unsafe { nitrokey_sys::NK_get_password_safe_slot_name(slot) }; @@ -27,14 +28,15 @@ fn get_slot_name_direct(slot: u8) -> Result { } } -fn get_pws(device: &Target) -> PasswordSafe { +fn get_pws(device: &T) -> PasswordSafe +where + T: Device, +{ device.get_password_safe(USER_PASSWORD).unwrap() } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn enable() { - let device = Target::connect().unwrap(); +#[test_device] +fn enable(device: DeviceWrapper) { assert!(device .get_password_safe(&(USER_PASSWORD.to_owned() + "123")) .is_err()); @@ -43,59 +45,53 @@ fn enable() { assert!(device.get_password_safe(USER_PASSWORD).is_ok()); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn drop() { - let device = Target::connect().unwrap(); +#[test_device] +fn drop(device: DeviceWrapper) { { let pws = get_pws(&device); - assert!(pws.write_slot(1, "name", "login", "password").is_ok()); + assert_eq!(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); } let result = get_slot_name_direct(1); assert_eq!(Ok(String::from("name")), result); - assert!(device.lock().is_ok()); + assert_eq!(Ok(()), device.lock()); let result = get_slot_name_direct(1); assert_eq!(Err(CommandError::NotAuthorized), result); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn get_status() { - let device = Target::connect().unwrap(); +#[test_device] +fn get_status(device: DeviceWrapper) { let pws = get_pws(&device); for i in 0..SLOT_COUNT { - assert!(pws.erase_slot(i).is_ok(), "Could not erase slot {}", i); + assert_eq!(Ok(()), pws.erase_slot(i), "Could not erase slot {}", i); } let status = pws.get_slot_status().unwrap(); assert_eq!(status, [false; SLOT_COUNT as usize]); - assert!(pws.write_slot(1, "name", "login", "password").is_ok()); + assert_eq!(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!(pws.write_slot(i, "name", "login", "password").is_ok()); + assert_eq!(Ok(()), pws.write_slot(i, "name", "login", "password")); } let status = pws.get_slot_status().unwrap(); assert_eq!(status, [true; SLOT_COUNT as usize]); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn get_data() { - let device = Target::connect().unwrap(); +#[test_device] +fn get_data(device: DeviceWrapper) { let pws = get_pws(&device); - assert!(pws.write_slot(1, "name", "login", "password").is_ok()); + assert_eq!(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!(pws.erase_slot(1).is_ok()); + assert_eq!(Ok(()), pws.erase_slot(1)); // TODO: check error codes assert_eq!(Err(CommandError::Undefined), pws.get_slot_name(1)); assert_eq!(Err(CommandError::Undefined), pws.get_slot_login(1)); @@ -104,7 +100,7 @@ fn get_data() { let name = "with å"; let login = "pär@test.com"; let password = "'i3lJc[09?I:,[u7dWz9"; - assert!(pws.write_slot(1, name, login, password).is_ok()); + assert_eq!(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()); @@ -123,10 +119,8 @@ fn get_data() { ); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn write() { - let device = Target::connect().unwrap(); +#[test_device] +fn write(device: DeviceWrapper) { let pws = get_pws(&device); assert_eq!( @@ -134,31 +128,29 @@ fn write() { pws.write_slot(SLOT_COUNT, "name", "login", "password") ); - assert!(pws.write_slot(0, "", "login", "password").is_ok()); + assert_eq!(Ok(()), pws.write_slot(0, "", "login", "password")); assert_eq!(Err(CommandError::Undefined), 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!(pws.write_slot(0, "name", "", "password").is_ok()); + assert_eq!(Ok(()), pws.write_slot(0, "name", "", "password")); assert_eq!(Ok(String::from("name")), pws.get_slot_name(0)); assert_eq!(Err(CommandError::Undefined), pws.get_slot_login(0)); assert_eq!(Ok(String::from("password")), pws.get_slot_password(0)); - assert!(pws.write_slot(0, "name", "login", "").is_ok()); + 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::Undefined), pws.get_slot_password(0)); } -#[test] -#[cfg_attr(not(any(feature = "test-pro", feature = "test-storage")), ignore)] -fn erase() { - let device = Target::connect().unwrap(); +#[test_device] +fn erase(device: DeviceWrapper) { let pws = get_pws(&device); assert_eq!(Err(CommandError::InvalidSlot), pws.erase_slot(SLOT_COUNT)); - assert!(pws.write_slot(0, "name", "login", "password").is_ok()); - assert!(pws.erase_slot(0).is_ok()); - assert!(pws.erase_slot(0).is_ok()); + 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::Undefined), pws.get_slot_name(0)); } diff --git a/nitrokey/tests/util/mod.rs b/nitrokey/tests/util/mod.rs index 5e495d8..1e522fd 100644 --- a/nitrokey/tests/util/mod.rs +++ b/nitrokey/tests/util/mod.rs @@ -1,9 +1,3 @@ pub static ADMIN_PASSWORD: &str = "12345678"; pub static UPDATE_PIN: &str = "12345678"; pub static USER_PASSWORD: &str = "123456"; - -#[cfg(not(feature = "test-storage"))] -pub type Target = nitrokey::Pro; - -#[cfg(feature = "test-storage")] -pub type Target = nitrokey::Storage; -- cgit v1.2.1