mirror of
https://github.com/chatmail/core.git
synced 2026-04-17 13:36:30 +03:00
9d7b756ddb
This tidies up our testing tools a little bit. We had several functions which through various changes ended up doing the same and some more which did very similar stuff, so I merged them to have things simpler. Also moved towards methods on the TestContext struct while cleaning this up anyway, seems like this structure is going to stay around for a bit anyway. The intersting change is in `test_utils.rs`, everything else is just updating callers. A few tests used example.org which I moved to example.com to be able to re-use more configuration of the test context.
93 lines
2.4 KiB
Rust
93 lines
2.4 KiB
Rust
//! Keyring to perform rpgp operations with.
|
|
|
|
use anyhow::Result;
|
|
|
|
use crate::context::Context;
|
|
use crate::key::{self, DcKey};
|
|
|
|
/// An in-memory keyring.
|
|
///
|
|
/// Instances are usually constructed just for the rpgp operation and
|
|
/// short-lived.
|
|
#[derive(Clone, Debug, Default)]
|
|
pub struct Keyring<T>
|
|
where
|
|
T: DcKey,
|
|
{
|
|
keys: Vec<T>,
|
|
}
|
|
|
|
impl<T> Keyring<T>
|
|
where
|
|
T: DcKey<KeyType = T>,
|
|
{
|
|
/// New empty keyring.
|
|
pub fn new() -> Keyring<T> {
|
|
Keyring { keys: Vec::new() }
|
|
}
|
|
|
|
/// Create a new keyring with the the user's secret key loaded.
|
|
pub async fn new_self(context: &Context) -> Result<Keyring<T>, key::Error> {
|
|
let mut keyring: Keyring<T> = Keyring::new();
|
|
keyring.load_self(context).await?;
|
|
Ok(keyring)
|
|
}
|
|
|
|
/// Load the user's key into the keyring.
|
|
pub async fn load_self(&mut self, context: &Context) -> Result<(), key::Error> {
|
|
self.add(T::load_self(context).await?);
|
|
Ok(())
|
|
}
|
|
|
|
/// Add a key to the keyring.
|
|
pub fn add(&mut self, key: T) {
|
|
self.keys.push(key);
|
|
}
|
|
|
|
pub fn len(&self) -> usize {
|
|
self.keys.len()
|
|
}
|
|
|
|
pub fn is_empty(&self) -> bool {
|
|
self.keys.is_empty()
|
|
}
|
|
|
|
/// A vector with reference to all the keys in the keyring.
|
|
pub fn keys(&self) -> &[T] {
|
|
&self.keys
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::key::{SignedPublicKey, SignedSecretKey};
|
|
use crate::test_utils::*;
|
|
|
|
#[test]
|
|
fn test_keyring_add_keys() {
|
|
let alice = alice_keypair();
|
|
let mut pub_ring: Keyring<SignedPublicKey> = Keyring::new();
|
|
pub_ring.add(alice.public.clone());
|
|
assert_eq!(pub_ring.keys(), [alice.public]);
|
|
|
|
let mut sec_ring: Keyring<SignedSecretKey> = Keyring::new();
|
|
sec_ring.add(alice.secret.clone());
|
|
assert_eq!(sec_ring.keys(), [alice.secret]);
|
|
}
|
|
|
|
#[async_std::test]
|
|
async fn test_keyring_load_self() {
|
|
// new_self() implies load_self()
|
|
let t = TestContext::new().await;
|
|
t.configure_alice().await;
|
|
let alice = alice_keypair();
|
|
|
|
let pub_ring: Keyring<SignedPublicKey> = Keyring::new_self(&t.ctx).await.unwrap();
|
|
assert_eq!(pub_ring.keys(), [alice.public]);
|
|
|
|
let sec_ring: Keyring<SignedSecretKey> = Keyring::new_self(&t.ctx).await.unwrap();
|
|
assert_eq!(sec_ring.keys(), [alice.secret]);
|
|
}
|
|
}
|