lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

adapter_conformance.rs (2446B)

      1 #![cfg(any(feature = "memory", feature = "file", feature = "keyring"))]
      2 
      3 use radroots_secrets::id::BackendKind;
      4 use radroots_secrets::provider::{
      5     AccessPolicy, CapabilitySupport, ResidencySupport, SelectionPolicy,
      6 };
      7 use radroots_secrets::{Error, SecretProvider};
      8 
      9 fn assert_provider_contract(
     10     provider: &dyn SecretProvider,
     11     backend: BackendKind,
     12     residency: ResidencySupport,
     13 ) {
     14     assert_eq!(provider.backend_kind(), backend);
     15     let capabilities = provider.capabilities();
     16     assert!(capabilities.is_available());
     17     assert_eq!(capabilities.residency(), residency);
     18     assert_eq!(capabilities.user_presence(), CapabilitySupport::Unavailable);
     19     assert_eq!(
     20         capabilities.hardware_backed(),
     21         CapabilitySupport::Unavailable
     22     );
     23 
     24     let candidates = [provider];
     25     let selected = SelectionPolicy::new(backend, AccessPolicy::standard())
     26         .select(&candidates)
     27         .expect("exact provider selection");
     28     assert_eq!(selected.backend_kind(), backend);
     29     assert!(matches!(
     30         SelectionPolicy::new(BackendKind::External, AccessPolicy::standard()).select(&candidates),
     31         Err(Error::BackendUnavailable {
     32             backend: BackendKind::External
     33         })
     34     ));
     35 }
     36 
     37 #[cfg(feature = "memory")]
     38 #[test]
     39 fn memory_provider_satisfies_shared_capability_contract() {
     40     let provider = radroots_secrets::memory::MemoryProvider::new();
     41     assert_provider_contract(&provider, BackendKind::Memory, ResidencySupport::Volatile);
     42 }
     43 
     44 #[cfg(feature = "file")]
     45 #[test]
     46 fn file_provider_satisfies_shared_capability_contract() {
     47     use radroots_secrets::file::{FileOpenMode, FileProvider};
     48     use radroots_secrets::wrapping::SecretMaterial;
     49 
     50     let temporary = tempfile::tempdir().expect("temporary directory");
     51     let provider = FileProvider::open(
     52         temporary.path().join("secrets"),
     53         FileOpenMode::CreateNew,
     54         SecretMaterial::from_slice(&[0x5a; 32]).expect("master key"),
     55     )
     56     .expect("file provider");
     57     assert_provider_contract(&provider, BackendKind::File, ResidencySupport::UserProfile);
     58 }
     59 
     60 #[cfg(feature = "keyring")]
     61 #[test]
     62 fn keyring_provider_satisfies_shared_capability_contract_without_access() {
     63     let provider = radroots_secrets::keyring::KeyringProvider::new("org.radroots.conformance")
     64         .expect("keyring provider");
     65     assert_provider_contract(
     66         &provider,
     67         BackendKind::Keyring,
     68         ResidencySupport::UserProfile,
     69     );
     70 }