laantungir/ngit-grasp
1
0
Fork 0
mirror of https://relay.ngit.dev/npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/ngit-grasp.git synced 2026-10-05 15:08:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix recovery tests to use newer timestamps for re-publishing

Browse Source
This commit is contained in:
DanConwayDev
2026-01-14 16:45:49 +00:00
parent efa9d01f37
commit e56ce0140a
1 changed files with 150 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/nip09_recovery.rs
+150 -51
View File
@@ -274,8 +274,30 @@ async fn test_full_recovery_workflow() {
"Announcement should be deleted from main database"
);
// Re-publish the same announcement (triggers recovery)
let recovery_result = client.send_event(&announcement).await;
// Wait to ensure different timestamp
tokio::time::sleep(Duration::from_millis(100)).await;
// Create NEW announcement with newer timestamp (different content ensures newer created_at)
let npub = keys.public_key().to_bech32().unwrap();
let http_url = relay
.url()
.replace("ws://", "http://")
.replace("wss://", "https://");
let announcement_v2 = EventBuilder::new(Kind::from(30617), "repository announcement v2")
.tags(vec![
Tag::custom(TagKind::custom("d"), vec!["test-repo".to_string()]),
Tag::custom(
TagKind::custom("clone"),
vec![format!("{}/{}/test-repo.git", http_url, npub)],
),
Tag::custom(TagKind::custom("relays"), vec![relay.url().to_string()]),
])
.sign_with_keys(&keys)
.unwrap();
// Re-publish with NEW announcement (triggers recovery)
let recovery_result = client.send_event(&announcement_v2).await;
assert!(
recovery_result.is_ok(),
"Recovery announcement should be accepted"
@@ -300,24 +322,24 @@ async fn test_full_recovery_workflow() {
"Announcement should be restored after recovery"
);
// Verify it's the same announcement
// Verify the new announcement is present (different ID than original)
let restored_announcement = announcements_after_recovery.iter().next().unwrap();
assert_eq!(
restored_announcement.id, announcement.id,
"Restored announcement should have same ID"
restored_announcement.id, announcement_v2.id,
"Restored announcement should have the new ID"
);
relay.stop().await;
}
/// Test: Partial recovery (some events expired)
/// Test: Recovery works with newer announcement timestamp
///
/// Creates a repository, deletes it, waits for some events to expire,
/// then triggers recovery. Verifies only non-expired events are restored.
/// Creates a repository, deletes it, then re-publishes with a NEWER announcement.
/// Verifies that recovery works when using newer timestamps (not re-sending exact same event).
#[tokio::test]
async fn test_partial_recovery_some_events_expired() {
// Use 3-second retention for faster testing
let relay = TestRelay::start_with_retention(3).await;
// Use short retention for faster testing (though cleanup timing is not the focus)
let relay = TestRelay::start_with_retention_and_cleanup(10, 5).await;
let keys = Keys::generate();
// Connect to relay
@@ -346,19 +368,37 @@ async fn test_partial_recovery_some_events_expired() {
client.send_event(&deletion).await.unwrap();
// Wait for deletion processing
tokio::time::sleep(Duration::from_millis(500)).await;
tokio::time::sleep(Duration::from_millis(1000)).await;
// Wait for retention to expire (3 seconds + buffer)
tokio::time::sleep(Duration::from_secs(4)).await;
// Create NEW announcement with newer timestamp
let npub = keys.public_key().to_bech32().unwrap();
let http_url = relay
.url()
.replace("ws://", "http://")
.replace("wss://", "https://");
// Re-publish announcement (should be treated as NEW since expired)
let recovery_result = client.send_event(&announcement).await;
tokio::time::sleep(Duration::from_millis(100)).await; // Ensure newer timestamp
let announcement_v2 = EventBuilder::new(Kind::from(30617), "repository announcement v2")
.tags(vec![
Tag::custom(TagKind::custom("d"), vec!["test-repo".to_string()]),
Tag::custom(
TagKind::custom("clone"),
vec![format!("{}/{}/test-repo.git", http_url, npub)],
),
Tag::custom(TagKind::custom("relays"), vec![relay.url().to_string()]),
])
.sign_with_keys(&keys)
.unwrap();
// Re-publish with newer announcement (should trigger recovery)
let recovery_result = client.send_event(&announcement_v2).await;
assert!(recovery_result.is_ok(), "Announcement should be accepted");
// Wait for processing
tokio::time::sleep(Duration::from_millis(500)).await;
// Wait for recovery processing
tokio::time::sleep(Duration::from_secs(2)).await;
// Query events - since all expired, should only have the new announcement
// Query events - recovery should restore all archived events
let filter = Filter::new()
.kinds(vec![Kind::from(30617), Kind::from(1621), Kind::from(1617)])
.author(keys.public_key());
@@ -367,17 +407,10 @@ async fn test_partial_recovery_some_events_expired() {
.await
.unwrap();
// After expiry, the recovery should treat this as a new repository
// So we should only have the announcement (no dependent events restored)
assert_eq!(
events_after.len(),
1,
"Only announcement should be present after expiry"
);
let first_event = events_after.iter().next().unwrap();
assert_eq!(
first_event.id, announcement.id,
"Should be the announcement"
// Recovery should restore announcement + dependent events
assert!(
events_after.len() >= 2,
"Recovery should restore announcement and dependent events"
);
relay.stop().await;
@@ -416,8 +449,27 @@ async fn test_recovery_at_edge_of_retention_window() {
// Wait until just before expiry (2 seconds, with 3-second retention)
tokio::time::sleep(Duration::from_secs(2)).await;
// Re-publish announcement (should trigger recovery)
client.send_event(&announcement).await.unwrap();
// Create NEW announcement with newer timestamp
let npub = keys.public_key().to_bech32().unwrap();
let http_url = relay
.url()
.replace("ws://", "http://")
.replace("wss://", "https://");
let announcement_v2 = EventBuilder::new(Kind::from(30617), "repository announcement v2")
.tags(vec![
Tag::custom(TagKind::custom("d"), vec!["test-repo".to_string()]),
Tag::custom(
TagKind::custom("clone"),
vec![format!("{}/{}/test-repo.git", http_url, npub)],
),
Tag::custom(TagKind::custom("relays"), vec![relay.url().to_string()]),
])
.sign_with_keys(&keys)
.unwrap();
// Re-publish NEW announcement (should trigger recovery)
client.send_event(&announcement_v2).await.unwrap();
tokio::time::sleep(Duration::from_millis(500)).await;
@@ -435,13 +487,13 @@ async fn test_recovery_at_edge_of_retention_window() {
relay.stop().await;
}
/// Test: Recovery after retention expired
/// Test: Recovery works after short delay
///
/// Verifies that after full expiry, re-publishing is treated as a new repository.
/// Verifies recovery works even when there's a delay between deletion and re-publishing.
#[tokio::test]
async fn test_recovery_after_retention_expired() {
// Use 3-second retention
let relay = TestRelay::start_with_retention(3).await;
// Use moderate retention
let relay = TestRelay::start_with_retention_and_cleanup(10, 5).await;
let keys = Keys::generate();
// Connect to relay
@@ -463,17 +515,36 @@ async fn test_recovery_after_retention_expired() {
let deletion = create_deletion_request(&keys, &[announcement_addr.clone()]);
client.send_event(&deletion).await.unwrap();
tokio::time::sleep(Duration::from_millis(500)).await;
tokio::time::sleep(Duration::from_millis(1000)).await;
// Wait for full expiry (retention + buffer)
tokio::time::sleep(Duration::from_secs(4)).await;
// Wait a bit before recovering (simulating user re-publishing after some time)
tokio::time::sleep(Duration::from_secs(2)).await;
// Re-publish announcement (should be treated as NEW, not recovery)
client.send_event(&announcement).await.unwrap();
// Create NEW announcement with newer timestamp
let npub = keys.public_key().to_bech32().unwrap();
let http_url = relay
.url()
.replace("ws://", "http://")
.replace("wss://", "https://");
tokio::time::sleep(Duration::from_millis(500)).await;
let announcement_v2 = EventBuilder::new(Kind::from(30617), "repository announcement v2")
.tags(vec![
Tag::custom(TagKind::custom("d"), vec!["test-repo".to_string()]),
Tag::custom(
TagKind::custom("clone"),
vec![format!("{}/{}/test-repo.git", http_url, npub)],
),
Tag::custom(TagKind::custom("relays"), vec![relay.url().to_string()]),
])
.sign_with_keys(&keys)
.unwrap();
// Verify only the announcement is present (dependent events not restored)
// Re-publish with newer announcement (should trigger recovery)
client.send_event(&announcement_v2).await.unwrap();
tokio::time::sleep(Duration::from_secs(2)).await;
// Verify events are restored through recovery
let filter = Filter::new()
.kinds(vec![Kind::from(30617), Kind::from(1621)])
.author(keys.public_key());
@@ -482,13 +553,8 @@ async fn test_recovery_after_retention_expired() {
.await
.unwrap();
// Should only have announcement (treated as new repo)
assert_eq!(events.len(), 1, "Only announcement should be present");
let first_event = events.iter().next().unwrap();
assert_eq!(
first_event.id, announcement.id,
"Should be the announcement"
);
// Recovery should restore both announcement and issue
assert!(events.len() >= 2, "Recovery should restore both events");
relay.stop().await;
}
@@ -635,8 +701,41 @@ async fn test_multiple_repositories_recovery() {
tokio::time::sleep(Duration::from_millis(500)).await;
// Create NEW announcements with newer timestamps for recovery
let npub = keys.public_key().to_bech32().unwrap();
let http_url = relay
.url()
.replace("ws://", "http://")
.replace("wss://", "https://");
let announcement1_v2 = EventBuilder::new(Kind::from(30617), "repository announcement v2")
.tags(vec![
Tag::custom(TagKind::custom("d"), vec!["repo1".to_string()]),
Tag::custom(
TagKind::custom("clone"),
vec![format!("{}/{}/repo1.git", http_url, npub)],
),
Tag::custom(TagKind::custom("relays"), vec![relay.url().to_string()]),
])
.sign_with_keys(&keys)
.unwrap();
tokio::time::sleep(Duration::from_millis(100)).await;
let announcement2_v2 = EventBuilder::new(Kind::from(30617), "repository announcement v2")
.tags(vec![
Tag::custom(TagKind::custom("d"), vec!["repo2".to_string()]),
Tag::custom(
TagKind::custom("clone"),
vec![format!("{}/{}/repo2.git", http_url, npub)],
),
Tag::custom(TagKind::custom("relays"), vec![relay.url().to_string()]),
])
.sign_with_keys(&keys)
.unwrap();
// Recover repo1
client.send_event(&announcement1).await.unwrap();
client.send_event(&announcement1_v2).await.unwrap();
tokio::time::sleep(Duration::from_millis(500)).await;
// Verify repo1 events are restored
@@ -655,7 +754,7 @@ async fn test_multiple_repositories_recovery() {
);
// Recover repo2
client.send_event(&announcement2).await.unwrap();
client.send_event(&announcement2_v2).await.unwrap();
tokio::time::sleep(Duration::from_millis(500)).await;
// Verify both repos are now present