Refactor/remove background sync

src/integration_tests/core/test_clients.rs

@@ -64,3 +64,18 @@ pub async fn publish_relay_lists(
 
     Ok(())
 }
+
+pub async fn publish_follow_list(
+    client: &Client,
+    contacts: &[PublicKey],
+) -> Result<(), WhitenoiseError> {
+    let tags: Vec<Tag> = contacts
+        .iter()
+        .map(|pk| Tag::custom(TagKind::p(), [pk.to_hex()]))
+        .collect();
+
+    client
+        .send_event_builder(EventBuilder::new(Kind::ContactList, "").tags(tags))
+        .await?;
+    Ok(())
+}

src/integration_tests/scenarios/subscription_processing.rs

@@ -60,11 +60,25 @@ impl Scenario for SubscriptionProcessingScenario {
 
         // Test 4: External user relay list update
         let alice_relay_url = "wss://alice-relay.example.com".to_string();
-        PublishSubscriptionUpdateTestCase::for_external_user(alice_keys)
+        PublishSubscriptionUpdateTestCase::for_external_user(alice_keys.clone())
             .with_relay_update(alice_relay_url)
             .execute(&mut self.context)
             .await?;
 
+        // Test 5: Publish a follow list (as a TestCase with assertion)
+        PublishSubscriptionUpdateTestCase::for_account("subscription_test_account")
+            .with_follow_list(vec![alice_keys.public_key()])
+            .execute(&mut self.context)
+            .await?;
+
+        // Test 6: Verify timestamp policy using a single builder-style test case
+        VerifyLastSyncedTimestampTestCase::for_account_follow_event()
+            .execute(&mut self.context)
+            .await?;
+        VerifyLastSyncedTimestampTestCase::for_global_metadata_event()
+            .execute(&mut self.context)
+            .await?;
+
         Ok(())
     }
 }

src/integration_tests/test_cases/subscription_processing/mod.rs

@@ -1,3 +1,5 @@
 pub mod publish_subscription_update;
+pub mod verify_last_synced_timestamp;
 
 pub use publish_subscription_update::*;
+pub use verify_last_synced_timestamp::*;

src/integration_tests/test_cases/subscription_processing/publish_subscription_update.rs

@@ -2,13 +2,15 @@ use crate::integration_tests::core::*;
 use crate::{RelayType, WhitenoiseError};
 use async_trait::async_trait;
 use nostr_sdk::prelude::*;
+use std::collections::HashSet;
 
 /// Test case for subscription-driven updates using builder pattern
 pub struct PublishSubscriptionUpdateTestCase {
     keys: Keys,
     account_name: Option<String>,
     metadata: Option<Metadata>,
     new_relay_url: Option<String>,
+    follow_pubkeys: Option<Vec<PublicKey>>,
 }
 
 impl PublishSubscriptionUpdateTestCase {
@@ -19,6 +21,7 @@ impl PublishSubscriptionUpdateTestCase {
             account_name: Some(account_name.to_string()),
             metadata: None,
             new_relay_url: None,
+            follow_pubkeys: None,
         }
     }
 
@@ -29,6 +32,7 @@ impl PublishSubscriptionUpdateTestCase {
             account_name: None,
             metadata: None,
             new_relay_url: None,
+            follow_pubkeys: None,
         }
     }
 
@@ -44,6 +48,12 @@ impl PublishSubscriptionUpdateTestCase {
         self
     }
 
+    /// Add follow list update to the test (account-based only)
+    pub fn with_follow_list(mut self, follows: Vec<PublicKey>) -> Self {
+        self.follow_pubkeys = Some(follows);
+        self
+    }
+
     /// Setup test client with relay lists published
     async fn setup_test_client(
         context: &ScenarioContext,
@@ -149,6 +159,18 @@ impl PublishSubscriptionUpdateTestCase {
         Ok(())
     }
 
+    /// Publish follow list update (account-based)
+    async fn publish_follow_list_update(
+        &self,
+        test_client: &Client,
+        follows: &[PublicKey],
+    ) -> Result<(), WhitenoiseError> {
+        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+        publish_follow_list(test_client, follows).await?;
+        tracing::info!("✓ Follow list published via test client");
+        Ok(())
+    }
+
     /// Verify metadata update
     async fn verify_metadata(
         &self,
@@ -238,24 +260,62 @@ impl PublishSubscriptionUpdateTestCase {
         );
         Ok(())
     }
+
+    /// Verify follow list processed into follows (account-based)
+    async fn verify_follow_list(
+        &self,
+        context: &mut ScenarioContext,
+        expected_follows: &[PublicKey],
+    ) -> Result<(), WhitenoiseError> {
+        let Some(account_name) = &self.account_name else {
+            return Err(WhitenoiseError::InvalidInput(
+                "Contact list verification only supported for accounts".to_string(),
+            ));
+        };
+
+        let account = context.get_account(account_name)?;
+        let follows = context.whitenoise.follows(account).await?;
+
+        let expected: HashSet<PublicKey> = expected_follows.iter().copied().collect();
+        let actual: HashSet<PublicKey> = follows.iter().map(|u| u.pubkey).collect();
+
+        assert!(
+            actual == expected,
+            "Account follows do not match expected follows. Missing: {:?}, Extra: {:?}",
+            expected.difference(&actual).collect::<Vec<_>>(),
+            actual.difference(&expected).collect::<Vec<_>>()
+        );
+
+        tracing::info!("✓ Account follow list exactly matches expected set");
+        Ok(())
+    }
 }
 
 #[async_trait]
 impl TestCase for PublishSubscriptionUpdateTestCase {
     async fn run(&self, context: &mut ScenarioContext) -> Result<(), WhitenoiseError> {
         let has_metadata = self.metadata.is_some();
         let has_relay = self.new_relay_url.is_some();
+        let has_follows = self.follow_pubkeys.is_some();
 
-        let updates = match (has_metadata, has_relay) {
-            (true, true) => "metadata and relay list",
-            (true, false) => "metadata",
-            (false, true) => "relay list",
-            (false, false) => {
-                return Err(WhitenoiseError::InvalidInput(
-                    "No updates specified".to_string(),
-                ))
-            }
-        };
+        let mut updates_parts = Vec::new();
+        if has_metadata {
+            updates_parts.push("metadata");
+        }
+        if has_relay {
+            updates_parts.push("relay list");
+        }
+        if has_follows {
+            updates_parts.push("follows");
+        }
+
+        if updates_parts.is_empty() {
+            return Err(WhitenoiseError::InvalidInput(
+                "No updates specified".to_string(),
+            ));
+        }
+
+        let updates = updates_parts.join(", ");
 
         // Get appropriate keys first
         let test_keys = self.get_keys(context).await?;
@@ -289,6 +349,11 @@ impl TestCase for PublishSubscriptionUpdateTestCase {
                 .await?;
         }
 
+        if let Some(follows) = &self.follow_pubkeys {
+            self.publish_follow_list_update(&test_client, follows)
+                .await?;
+        }
+
         // Wait for processing and disconnect
         tokio::time::sleep(tokio::time::Duration::from_millis(600)).await;
         test_client.disconnect().await;
@@ -303,6 +368,10 @@ impl TestCase for PublishSubscriptionUpdateTestCase {
                 .await?;
         }
 
+        if let Some(follows) = &self.follow_pubkeys {
+            self.verify_follow_list(context, follows).await?;
+        }
+
         Ok(())
     }
 }