feat(login) fetch user relays and metadata

get user relay list and metadata events from relays when keys are
used and last fetch attempt was more than an hour ago

uses user's write relays if known, otherwise uses fallback relays

to achieve this a method for intergration testing event fetching
from relays was added

1 files changed, 667 insertions, 16 deletions

diff --git a/src/key_handling/users.rs b/src/key_handling/users.rs
index 1d2cc34..91519bc 100644
--- a/src/key_handling/users.rs
+++ b/src/key_handling/users.rs
@@ -1,11 +1,21 @@
+use std::time::SystemTime;
+
 use anyhow::{Context, Result};
+use async_trait::async_trait;
 use nostr::prelude::*;
 use zeroize::Zeroize;
 
 use super::encryption::{EncryptDecrypt, Encryptor};
+#[cfg(not(test))]
+use crate::client::Client;
+#[cfg(test)]
+use crate::client::MockConnect;
 use crate::{
     cli_interactor::{Interactor, InteractorPrompt, PromptInputParms, PromptPasswordParms},
-    config::{self, ConfigManagement, ConfigManager},
+    client::Connect,
+    config::{
+        self, ConfigManagement, ConfigManager, UserMetadata, UserRef, UserRelayRef, UserRelays,
+    },
 };
 
 #[derive(Default)]
@@ -15,13 +25,29 @@ pub struct UserManager {
     encryptor: Encryptor,
 }
 
+#[async_trait]
 pub trait UserManagement {
     fn add(&self, nsec: &Option<String>, password: &Option<String>) -> Result<nostr::Keys>;
+    async fn get_user(
+        &self,
+        #[cfg(test)] client: &MockConnect,
+        #[cfg(not(test))] client: &Client,
+        public_key: &XOnlyPublicKey,
+        after: u64,
+    ) -> Result<UserRef>;
+    fn get_user_from_cache(&self, public_key: &XOnlyPublicKey) -> Result<UserRef>;
+    fn add_user_to_config(
+        &self,
+        public_key: XOnlyPublicKey,
+        encrypted_secret_key: Option<String>,
+        overwrite: bool,
+    ) -> Result<()>;
 }
 
 #[cfg(test)]
 use duplicate::duplicate_item;
 #[cfg_attr(test, duplicate_item(UserManager; [UserManager]; [self::tests::MockUserManager]))]
+#[async_trait]
 impl UserManagement for UserManager {
     fn add(&self, nsec: &Option<String>, password: &Option<String>) -> Result<nostr::Keys> {
         let mut prompt = "login with nsec (or hex private key)";
@@ -66,9 +92,152 @@ impl UserManagement for UserManager {
             .context("failed to encrypt nsec with password.")?;
         pass.zeroize();
 
-        let user_ref = config::UserRef {
-            public_key: keys.public_key(),
-            encrypted_key: encrypted_secret_key,
+        self.add_user_to_config(keys.public_key(), Some(encrypted_secret_key), true)?;
+
+        Ok(keys)
+    }
+
+    fn add_user_to_config(
+        &self,
+        public_key: XOnlyPublicKey,
+        encrypted_secret_key: Option<String>,
+        overwrite: bool,
+    ) -> Result<()> {
+        let user_ref =
+            config::UserRef::new(public_key, encrypted_secret_key.unwrap_or(String::new()));
+
+        let mut cfg = self.config_manager.load().context("failed to load application config to find and remove any old versions of the user's encrypted key")?;
+        // don't overwrite unless specified
+        if !overwrite
+            && cfg
+                .users
+                .clone()
+                .into_iter()
+                .any(|r| r.public_key.eq(&public_key))
+        {
+            return Ok(());
+        }
+        // if overwrite remove any duplicate entries for key before adding it to config
+        cfg.users = cfg
+            .users
+            .clone()
+            .into_iter()
+            .filter(|r| !r.public_key.eq(&public_key))
+            .collect();
+        cfg.users.push(user_ref);
+        self.config_manager
+            .save(&cfg)
+            .context("failed to save application configuration with new user details in")
+    }
+
+    fn get_user_from_cache(&self, public_key: &XOnlyPublicKey) -> Result<UserRef> {
+        let cfg = self
+            .config_manager
+            .load()
+            .context("failed to load application config")?;
+        Ok(cfg
+            .users
+            .iter()
+            .find(|u| u.public_key.eq(public_key))
+            .context(format!("pubkey isn't a current user: {public_key}"))?
+            .clone())
+    }
+    /// get UserRef fetching most recent user relays and metadata infomation
+    /// from relays
+    async fn get_user(
+        &self,
+        #[cfg(test)] client: &MockConnect,
+        #[cfg(not(test))] client: &Client,
+        public_key: &XOnlyPublicKey,
+        use_cache_unless_checked_more_than_x_secs_ago: u64,
+    ) -> Result<UserRef> {
+        let cfg = self
+            .config_manager
+            .load()
+            .context("failed to load application config")?;
+        let user_ref = cfg
+            .users
+            .iter()
+            .find(|u| u.public_key.eq(public_key))
+            .context(format!("pubkey isn't a current user: {public_key}"))?;
+        // return cache if last fetched was within X minutes
+        if !unix_timestamp_after_now_plus_secs(
+            user_ref.last_checked,
+            use_cache_unless_checked_more_than_x_secs_ago,
+        ) {
+            return Ok(user_ref.clone());
+        }
+        let events: Vec<Event> = match client
+            .get_events(
+                if user_ref.relays.write().is_empty() {
+                    client.get_fallback_relays().clone()
+                } else {
+                    user_ref.relays.write()
+                },
+                vec![
+                    nostr::Filter::default()
+                        .author(public_key.to_string())
+                        .since(nostr::Timestamp::from(user_ref.metadata.created_at + 1))
+                        .kind(Kind::Metadata),
+                    nostr::Filter::default()
+                        .author(public_key.to_string())
+                        .since(nostr::Timestamp::from(user_ref.relays.created_at + 1))
+                        .kind(Kind::RelayList),
+                ],
+            )
+            .await
+        {
+            Ok(events) => events,
+            Err(_) => {
+                // TODO error reporting
+                return Ok(user_ref.clone());
+            }
+        };
+
+        let mut user_ref = user_ref.clone();
+
+        user_ref.last_checked = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .context("system time should be after the year 1970")?
+            .as_secs();
+
+        if let Some(new_metadata_event) = events
+            .iter()
+            .filter(|e| e.kind.eq(&nostr::Kind::Metadata) && e.pubkey.eq(public_key))
+            .max_by_key(|e| e.created_at)
+        {
+            if new_metadata_event.created_at.as_u64() > user_ref.metadata.created_at {
+                let metadata = nostr::Metadata::from_json(new_metadata_event.content.clone())
+                    .context("metadata cannot be found in kind 0 event content")?;
+                user_ref.metadata = UserMetadata {
+                    name: metadata
+                        .name
+                        .context("user metadata should always have name")?,
+                    created_at: new_metadata_event.created_at.as_u64(),
+                };
+            }
+        };
+
+        if let Some(new_relays_event) = events
+            .iter()
+            .filter(|e| e.kind.eq(&nostr::Kind::RelayList) && e.pubkey.eq(public_key))
+            .max_by_key(|e| e.created_at)
+        {
+            if new_relays_event.created_at.as_u64() > user_ref.relays.created_at {
+                user_ref.relays = UserRelays {
+                    relays: new_relays_event
+                        .tags
+                        .iter()
+                        .filter(|t| t.kind().eq(&nostr::TagKind::R))
+                        .map(|t| UserRelayRef {
+                            url: t.as_vec()[1].clone(),
+                            read: t.as_vec().len() == 2 || t.as_vec()[2].eq("read"),
+                            write: t.as_vec().len() == 2 || t.as_vec()[2].eq("write"),
+                        })
+                        .collect(),
+                    created_at: new_relays_event.created_at.as_u64(),
+                };
+            }
         };
 
         // remove any duplicate entries for key before adding it to config
@@ -77,19 +246,27 @@ impl UserManagement for UserManager {
             .users
             .clone()
             .into_iter()
-            .filter(|r| !r.public_key.eq(&keys.public_key()))
+            .filter(|r| !r.public_key.eq(public_key))
             .collect();
-        cfg.users.push(user_ref);
+        cfg.users.push(user_ref.clone());
         self.config_manager
             .save(&cfg)
             .context("failed to save application configuration with new user details in")?;
+        Ok(user_ref)
+    }
+}
 
-        Ok(keys)
+fn unix_timestamp_after_now_plus_secs(timestamp: u64, secs: u64) -> bool {
+    if let Ok(now) = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
+        now.as_secs() > (timestamp + secs)
+    } else {
+        true
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use nostr;
     use test_utils::*;
 
     use super::*;
@@ -278,11 +455,10 @@ mod tests {
                     m.config_manager = MockConfigManagement::default();
                     m.config_manager.expect_load().returning(|| {
                         Ok(MyConfig {
-                            users: vec![UserRef {
-                                public_key: TEST_KEY_1_KEYS.public_key(),
-                                // different key to TEST_KEY_1_ENCYPTED
-                                encrypted_key: TEST_KEY_2_ENCRYPTED.into(),
-                            }],
+                            users: vec![UserRef::new(
+                                TEST_KEY_1_KEYS.public_key(),
+                                TEST_KEY_2_ENCRYPTED.into(),
+                            )],
                             ..MyConfig::default()
                         })
                     });
@@ -308,10 +484,10 @@ mod tests {
                     m.config_manager = MockConfigManagement::default();
                     m.config_manager.expect_load().returning(|| {
                         Ok(MyConfig {
-                            users: vec![UserRef {
-                                public_key: TEST_KEY_2_KEYS.public_key(),
-                                encrypted_key: TEST_KEY_2_ENCRYPTED.into(),
-                            }],
+                            users: vec![UserRef::new(
+                                TEST_KEY_2_KEYS.public_key(),
+                                TEST_KEY_2_ENCRYPTED.into(),
+                            )],
                             ..MyConfig::default()
                         })
                     });
@@ -329,4 +505,479 @@ mod tests {
             }
         }
     }
+
+    fn now_timestamp() -> u64 {
+        SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .unwrap()
+            .as_secs()
+    }
+    fn roughly_now(timestamp: u64) -> bool {
+        let now = now_timestamp();
+        timestamp < now + 100 && timestamp > now - 100
+    }
+
+    mod get_user {
+        use anyhow::anyhow;
+
+        use super::*;
+        use crate::client::MockConnect;
+
+        fn generate_relaylist_event() -> nostr::Event {
+            nostr::event::EventBuilder::new(
+                nostr::Kind::RelayList,
+                "",
+                &[
+                    nostr::Tag::RelayMetadata(
+                        "wss://fredswrite1.relay".into(),
+                        Some(nostr::RelayMetadata::Write),
+                    ),
+                    nostr::Tag::RelayMetadata(
+                        "wss://fredsread1.relay".into(),
+                        Some(nostr::RelayMetadata::Read),
+                    ),
+                    nostr::Tag::RelayMetadata("wss://fredsreadwrite.relay".into(), None),
+                ],
+            )
+            .to_event(&TEST_KEY_1_KEYS)
+            .unwrap()
+        }
+
+        fn generate_relaylist_event_user_2() -> nostr::Event {
+            nostr::event::EventBuilder::new(
+                nostr::Kind::RelayList,
+                "",
+                &[
+                    nostr::Tag::RelayMetadata(
+                        "wss://carolswrite1.relay".into(),
+                        Some(nostr::RelayMetadata::Write),
+                    ),
+                    nostr::Tag::RelayMetadata(
+                        "wss://carolsread1.relay".into(),
+                        Some(nostr::RelayMetadata::Read),
+                    ),
+                    nostr::Tag::RelayMetadata("wss://carolsreadwrite.relay".into(), None),
+                ],
+            )
+            .to_event(&TEST_KEY_2_KEYS)
+            .unwrap()
+        }
+
+        fn fallback_relays() -> Vec<String> {
+            vec!["ws://fallback1".to_string(), "ws://fallback2".to_string()].clone()
+        }
+
+        fn generate_mock_client() -> MockConnect {
+            let mut client = <MockConnect as std::default::Default>::default();
+            client
+                .expect_get_fallback_relays()
+                .return_const(fallback_relays());
+            client
+        }
+
+        fn generate_standard_config() -> MyConfig {
+            MyConfig {
+                users: vec![UserRef {
+                    public_key: TEST_KEY_1_KEYS.public_key(),
+                    encrypted_key: TEST_KEY_1_ENCRYPTED.to_string(),
+                    metadata: UserMetadata {
+                        name: "Fred".to_string(),
+                        created_at: 10,
+                    },
+                    relays: UserRelays {
+                        relays: vec![
+                            UserRelayRef {
+                                url: "ws://existingread".to_string(),
+                                read: true,
+                                write: false,
+                            },
+                            UserRelayRef {
+                                url: "ws://existingreadwrite".to_string(),
+                                read: true,
+                                write: true,
+                            },
+                            UserRelayRef {
+                                url: "ws://existingwrite".to_string(),
+                                read: false,
+                                write: true,
+                            },
+                        ],
+                        created_at: 10,
+                    },
+                    last_checked: now_timestamp() - (60 * 60), // 1h ago
+                }],
+                ..MyConfig::default()
+            }
+            .clone()
+        }
+
+        fn expected_userrelayrefs() -> Vec<UserRelayRef> {
+            vec![
+                UserRelayRef {
+                    url: "wss://fredswrite1.relay".into(),
+                    read: false,
+                    write: true,
+                },
+                UserRelayRef {
+                    url: "wss://fredsread1.relay".into(),
+                    read: true,
+                    write: false,
+                },
+                UserRelayRef {
+                    url: "wss://fredsreadwrite.relay".into(),
+                    read: true,
+                    write: true,
+                },
+            ]
+        }
+
+        mod when_within_caching_time_window {
+            use super::*;
+
+            #[test]
+            fn returns_cached_details_without_checking_relays_or_updaing_config() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                let res = futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    24 * 60 * 60, // within 24 hours
+                ))?;
+                assert_eq!(res.metadata.name, "Fred");
+                assert_eq!(res.relays.relays[0].url, "ws://existingread");
+                Ok(())
+            }
+        }
+
+        mod returns_userref_with_latest_details_from_events_on_relays {
+            use super::*;
+
+            #[test]
+            fn name() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager.expect_save().returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
+
+                let res = futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                assert_eq!(res.metadata.name, "fred");
+                Ok(())
+            }
+
+            #[test]
+            fn name_ignoring_other_users_events() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager.expect_save().returning(|_| Ok(()));
+                client.expect_get_events().returning(|_, _| {
+                    Ok(vec![
+                        generate_test_key_2_metadata_event("carole"),
+                        generate_test_key_1_metadata_event_old("fred"),
+                    ])
+                });
+
+                let res = futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                assert_eq!(res.metadata.name, "fred");
+                Ok(())
+            }
+
+            #[test]
+            fn relays() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager.expect_save().returning(|_| Ok(()));
+                client.expect_get_events().returning(|_, _| {
+                    Ok(vec![
+                        generate_test_key_1_metadata_event("fred"),
+                        generate_relaylist_event(),
+                    ])
+                });
+
+                let res = futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                assert_eq!(res.relays.relays, expected_userrelayrefs(),);
+                Ok(())
+            }
+
+            #[test]
+            fn relays_ignoring_other_users_events() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager.expect_save().returning(|_| Ok(()));
+                client.expect_get_events().returning(|_, _| {
+                    Ok(vec![
+                        make_event_old_or_change_user(
+                            generate_relaylist_event(),
+                            &TEST_KEY_1_KEYS,
+                            10000,
+                        ),
+                        generate_relaylist_event_user_2(),
+                    ])
+                });
+
+                let res = futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                assert_eq!(res.relays.relays, expected_userrelayrefs(),);
+                Ok(())
+            }
+        }
+
+        mod saves_updates_to_config {
+            use super::*;
+
+            #[test]
+            fn saves_name_to_config() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager
+                    .expect_save()
+                    .once()
+                    .withf(|cfg| cfg.users[0].metadata.name.eq("fred"))
+                    .returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+
+            #[test]
+            fn updates_metadata_created_at() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager
+                    .expect_save()
+                    .once()
+                    .withf(|cfg| roughly_now(cfg.users[0].metadata.created_at))
+                    .returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+
+            #[test]
+            fn saves_relays_to_config() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager
+                    .expect_save()
+                    .once()
+                    .withf(|cfg| expected_userrelayrefs().eq(&cfg.users[0].relays.relays))
+                    .returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .returning(|_, _| Ok(vec![generate_relaylist_event()]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+
+            #[test]
+            fn updates_relays_created_at() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager
+                    .expect_save()
+                    .once()
+                    .withf(|cfg| roughly_now(cfg.users[0].relays.created_at))
+                    .returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .returning(|_, _| Ok(vec![generate_relaylist_event()]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+
+            #[test]
+            fn when_no_changes_updates_last_updated() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager
+                    .expect_save()
+                    .once()
+                    .withf(|cfg| roughly_now(cfg.users[0].last_checked))
+                    .returning(|_| Ok(()));
+                client.expect_get_events().returning(|_, _| Ok(vec![]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+
+            #[test]
+            fn when_changes_updates_last_updated() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager
+                    .expect_save()
+                    .once()
+                    .withf(|cfg| roughly_now(cfg.users[0].last_checked))
+                    .returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+        }
+
+        mod fetches_from_correct_relays {
+            use super::*;
+            #[test]
+            fn when_userref_write_relays_present_fetches_only_from_them() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager.expect_save().returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .once()
+                    .withf(move |relays, _filters| {
+                        vec![
+                            "ws://existingreadwrite".to_string(),
+                            "ws://existingwrite".to_string(),
+                        ]
+                        .eq(relays)
+                    })
+                    .returning(|_, _| Ok(vec![]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+            #[test]
+            fn when_userref_write_relays_not_present_fetches_from_fallback_relays() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager.expect_load().returning(|| {
+                    Ok(MyConfig {
+                        users: vec![UserRef {
+                            relays: UserRelays {
+                                relays: vec![],
+                                created_at: 0,
+                            },
+                            ..generate_standard_config().users[0].clone()
+                        }],
+                        ..generate_standard_config()
+                    })
+                });
+                m.config_manager.expect_save().returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .once()
+                    .withf(move |relays, _filters| fallback_relays().eq(relays))
+                    .returning(|_, _| Ok(vec![]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+        }
+
+        #[test]
+        fn when_failed_to_fetch_events_returns_cached_details() -> Result<()> {
+            let mut m = MockUserManager::default();
+            let mut client = generate_mock_client();
+            m.config_manager
+                .expect_load()
+                .returning(|| Ok(generate_standard_config()));
+            client
+                .expect_get_events()
+                .returning(|_, _| Err(anyhow!("test error")));
+
+            let res = futures::executor::block_on(m.get_user(
+                &client,
+                &TEST_KEY_1_KEYS.public_key(),
+                5 * 60, // 10 mins ago
+            ))?;
+            assert_eq!(res.metadata.name, "Fred");
+            Ok(())
+        }
+    }
 }