From fa065ad128882755f2a988d6203b59a2ab5e38ff Mon Sep 17 00:00:00 2001 From: DanConwayDev Date: Wed, 19 Nov 2025 11:55:32 +0000 Subject: add landing page and nostr-relay-builder relay on same port --- tests/nip01_compliance.rs | 50 +++++++++---------- tests/nip34_announcements.rs | 111 +++++++++++++++++++------------------------ 2 files changed, 74 insertions(+), 87 deletions(-) (limited to 'tests') diff --git a/tests/nip01_compliance.rs b/tests/nip01_compliance.rs index 3e2fdd3..05957fd 100644 --- a/tests/nip01_compliance.rs +++ b/tests/nip01_compliance.rs @@ -39,22 +39,22 @@ use grasp_audit::*; async fn test_nip01_smoke() { // Start test relay let relay = TestRelay::start().await; - + // Create audit client in CI mode (isolated, no cleanup needed) let config = AuditConfig::ci(); let client = AuditClient::new(relay.url(), config) .await .expect("Failed to create audit client"); - + // Run all NIP-01 smoke tests let results = specs::Nip01SmokeTests::run_all(&client).await; - + // Print detailed report results.print_report(); - + // Stop relay relay.stop().await; - + // Assert all tests passed assert!( results.all_passed(), @@ -70,20 +70,20 @@ async fn test_nip01_smoke() { /// for more granular testing or debugging. #[tokio::test] async fn test_nip01_individual_tests() { - use grasp_audit::specs::nip01_smoke::Nip01SmokeTests; - + use grasp_audit::specs::grasp01::Nip01SmokeTests; + let relay = TestRelay::start().await; let config = AuditConfig::ci(); let client = AuditClient::new(relay.url(), config) .await .expect("Failed to create audit client"); - + // We can't call private methods, so we'll run the full suite // This test is mainly to show the pattern let all_results = Nip01SmokeTests::run_all(&client).await; - + relay.stop().await; - + // Verify assert!(all_results.all_passed()); } @@ -99,25 +99,25 @@ async fn test_relay_validates_events() { let client = AuditClient::new(relay.url(), config) .await .expect("Failed to create audit client"); - + // The validation tests are part of the smoke tests let results = specs::Nip01SmokeTests::run_all(&client).await; - + // Check that validation tests exist and pass let validation_tests: Vec<_> = results .results .iter() .filter(|t| t.spec_ref.contains("validation")) .collect(); - + relay.stop().await; - + // Should have validation tests assert!( !validation_tests.is_empty(), "No validation tests found in NIP-01 smoke tests" ); - + // All validation tests should pass for test in validation_tests { assert!( @@ -137,18 +137,18 @@ async fn test_relay_lifecycle() { // Start relay let relay = TestRelay::start().await; let url = relay.url().to_string(); - + // Verify we can connect let config = AuditConfig::ci(); let client = AuditClient::new(&url, config) .await .expect("Failed to connect to relay"); - + assert!(client.is_connected().await, "Client should be connected"); - + // Stop relay relay.stop().await; - + // Note: We can't easily verify disconnection without modifying grasp-audit // to expose connection state after relay shutdown. That's okay - the // important part is that the relay starts and stops cleanly. @@ -162,28 +162,28 @@ async fn test_parallel_relays() { // Start two relays simultaneously let relay1 = TestRelay::start().await; let relay2 = TestRelay::start().await; - + // Should have different URLs (different ports) assert_ne!( relay1.url(), relay2.url(), "Relays should use different ports" ); - + // Both should be connectable let config = AuditConfig::ci(); - + let client1 = AuditClient::new(relay1.url(), config.clone()) .await .expect("Failed to connect to relay 1"); - + let client2 = AuditClient::new(relay2.url(), config) .await .expect("Failed to connect to relay 2"); - + assert!(client1.is_connected().await); assert!(client2.is_connected().await); - + // Clean up relay1.stop().await; relay2.stop().await; diff --git a/tests/nip34_announcements.rs b/tests/nip34_announcements.rs index 6e83bb6..535425d 100644 --- a/tests/nip34_announcements.rs +++ b/tests/nip34_announcements.rs @@ -36,7 +36,9 @@ const KIND_REPOSITORY_ANNOUNCEMENT: u16 = 30617; const KIND_REPOSITORY_STATE: u16 = 30618; /// Helper to connect to a test relay -async fn connect_to_relay(url: &str) -> tokio_tungstenite::WebSocketStream> { +async fn connect_to_relay( + url: &str, +) -> tokio_tungstenite::WebSocketStream> { let (ws, _) = connect_async(url) .await .expect("Failed to connect to relay"); @@ -54,10 +56,7 @@ fn create_announcement( let mut tags = vec![Tag::custom(TagKind::d(), vec![identifier.to_string()])]; for url in clone_urls { - tags.push(Tag::custom( - TagKind::Clone, - vec![url], - )); + tags.push(Tag::custom(TagKind::Clone, vec![url])); } for relay in relays { @@ -94,10 +93,10 @@ fn create_state(keys: &Keys, identifier: &str, branches: Vec<(&str, &str)>) -> n #[tokio::test] async fn test_relay_accepts_connection() { let relay = TestRelay::start().await; - + // Try to connect let ws = connect_to_relay(relay.url()).await; - + drop(ws); // Clean disconnect } @@ -119,14 +118,14 @@ async fn test_accepts_valid_announcement() { // Send event let event_msg = json!(["EVENT", event]); - ws.send(Message::Text(event_msg.to_string())) + ws.send(Message::Text(event_msg.to_string().into())) .await .expect("Failed to send event"); // Read response if let Some(Ok(Message::Text(text))) = ws.next().await { let response: Value = serde_json::from_str(&text).expect("Failed to parse response"); - + // Should be ["OK", event_id, true, ""] assert_eq!(response[0], "OK"); assert_eq!(response[1], event.id.to_hex()); @@ -146,9 +145,7 @@ async fn test_rejects_announcement_without_clone() { let relay = TestRelay::start().await; let keys = Keys::generate(); - let (mut ws, _) = connect_async(relay.url()) - .await - .expect("Failed to connect"); + let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect"); // Missing clone tag let event = create_announcement( @@ -160,18 +157,18 @@ async fn test_rejects_announcement_without_clone() { ); let event_msg = json!(["EVENT", event]); - ws.send(Message::Text(event_msg.to_string())) + ws.send(Message::Text(event_msg.to_string().into())) .await .expect("Failed to send event"); if let Some(Ok(Message::Text(text))) = ws.next().await { let response: Value = serde_json::from_str(&text).expect("Failed to parse"); - + // Should be rejected assert_eq!(response[0], "OK"); assert_eq!(response[1], event.id.to_hex()); assert_eq!(response[2], false, "Event should be rejected"); - + let message = response[3].as_str().unwrap(); assert!( message.contains("clone") || message.contains("invalid"), @@ -190,9 +187,7 @@ async fn test_rejects_announcement_without_relay() { let relay = TestRelay::start().await; let keys = Keys::generate(); - let (mut ws, _) = connect_async(relay.url()) - .await - .expect("Failed to connect"); + let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect"); // Missing relay tag let event = create_announcement( @@ -204,18 +199,18 @@ async fn test_rejects_announcement_without_relay() { ); let event_msg = json!(["EVENT", event]); - ws.send(Message::Text(event_msg.to_string())) + ws.send(Message::Text(event_msg.to_string().into())) .await .expect("Failed to send event"); if let Some(Ok(Message::Text(text))) = ws.next().await { let response: Value = serde_json::from_str(&text).expect("Failed to parse"); - + // Should be rejected assert_eq!(response[0], "OK"); assert_eq!(response[1], event.id.to_hex()); assert_eq!(response[2], false, "Event should be rejected"); - + let message = response[3].as_str().unwrap(); assert!( message.contains("relays") || message.contains("invalid"), @@ -233,9 +228,7 @@ async fn test_rejects_announcement_for_other_service() { let relay = TestRelay::start().await; let keys = Keys::generate(); - let (mut ws, _) = connect_async(relay.url()) - .await - .expect("Failed to connect"); + let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect"); // Lists different service let event = create_announcement( @@ -247,13 +240,13 @@ async fn test_rejects_announcement_for_other_service() { ); let event_msg = json!(["EVENT", event]); - ws.send(Message::Text(event_msg.to_string())) + ws.send(Message::Text(event_msg.to_string().into())) .await .expect("Failed to send event"); if let Some(Ok(Message::Text(text))) = ws.next().await { let response: Value = serde_json::from_str(&text).expect("Failed to parse"); - + // Should be rejected assert_eq!(response[0], "OK"); assert_eq!(response[1], event.id.to_hex()); @@ -269,9 +262,7 @@ async fn test_accepts_valid_state() { let relay = TestRelay::start().await; let keys = Keys::generate(); - let (mut ws, _) = connect_async(relay.url()) - .await - .expect("Failed to connect"); + let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect"); let event = create_state( &keys, @@ -280,13 +271,13 @@ async fn test_accepts_valid_state() { ); let event_msg = json!(["EVENT", event]); - ws.send(Message::Text(event_msg.to_string())) + ws.send(Message::Text(event_msg.to_string().into())) .await .expect("Failed to send event"); if let Some(Ok(Message::Text(text))) = ws.next().await { let response: Value = serde_json::from_str(&text).expect("Failed to parse"); - + // Should be accepted assert_eq!(response[0], "OK"); assert_eq!(response[1], event.id.to_hex()); @@ -302,9 +293,7 @@ async fn test_accepts_state_with_multiple_branches() { let relay = TestRelay::start().await; let keys = Keys::generate(); - let (mut ws, _) = connect_async(relay.url()) - .await - .expect("Failed to connect"); + let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect"); let event = create_state( &keys, @@ -317,13 +306,13 @@ async fn test_accepts_state_with_multiple_branches() { ); let event_msg = json!(["EVENT", event]); - ws.send(Message::Text(event_msg.to_string())) + ws.send(Message::Text(event_msg.to_string().into())) .await .expect("Failed to send event"); if let Some(Ok(Message::Text(text))) = ws.next().await { let response: Value = serde_json::from_str(&text).expect("Failed to parse"); - + assert_eq!(response[0], "OK"); assert_eq!(response[2], true, "State event should be accepted"); } else { @@ -337,9 +326,7 @@ async fn test_rejects_state_without_identifier() { let relay = TestRelay::start().await; let keys = Keys::generate(); - let (mut ws, _) = connect_async(relay.url()) - .await - .expect("Failed to connect"); + let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect"); // Create state without identifier let event = EventBuilder::new(Kind::from(KIND_REPOSITORY_STATE), "") @@ -347,18 +334,18 @@ async fn test_rejects_state_without_identifier() { .expect("Failed to sign event"); let event_msg = json!(["EVENT", event]); - ws.send(Message::Text(event_msg.to_string())) + ws.send(Message::Text(event_msg.to_string().into())) .await .expect("Failed to send event"); if let Some(Ok(Message::Text(text))) = ws.next().await { let response: Value = serde_json::from_str(&text).expect("Failed to parse"); - + // Should be rejected assert_eq!(response[0], "OK"); assert_eq!(response[1], event.id.to_hex()); assert_eq!(response[2], false, "Event should be rejected"); - + let message = response[3].as_str().unwrap(); assert!( message.contains("identifier") || message.contains("invalid"), @@ -376,21 +363,22 @@ async fn test_query_announcements() { let relay = TestRelay::start().await; let keys = Keys::generate(); - let (mut ws, _) = connect_async(relay.url()) - .await - .expect("Failed to connect"); + let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect"); // Send an announcement let event = create_announcement( &keys, &relay.domain(), "query-test-repo", - vec![format!("https://{}/alice/query-test-repo.git", relay.domain())], + vec![format!( + "https://{}/alice/query-test-repo.git", + relay.domain() + )], vec![format!("wss://{}", relay.domain())], ); let event_msg = json!(["EVENT", event]); - ws.send(Message::Text(event_msg.to_string())) + ws.send(Message::Text(event_msg.to_string().into())) .await .expect("Failed to send event"); @@ -409,7 +397,7 @@ async fn test_query_announcements() { } ]); - ws.send(Message::Text(req.to_string())) + ws.send(Message::Text(req.to_string().into())) .await .expect("Failed to send REQ"); @@ -420,7 +408,7 @@ async fn test_query_announcements() { for _ in 0..10 { if let Some(Ok(Message::Text(text))) = ws.next().await { let response: Value = serde_json::from_str(&text).expect("Failed to parse"); - + if response[0] == "EVENT" { assert_eq!(response[1], "test-sub"); found_event = true; @@ -442,9 +430,7 @@ async fn test_query_states() { let relay = TestRelay::start().await; let keys = Keys::generate(); - let (mut ws, _) = connect_async(relay.url()) - .await - .expect("Failed to connect"); + let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect"); // Send a state event let event = create_state( @@ -454,7 +440,7 @@ async fn test_query_states() { ); let event_msg = json!(["EVENT", event]); - ws.send(Message::Text(event_msg.to_string())) + ws.send(Message::Text(event_msg.to_string().into())) .await .expect("Failed to send event"); @@ -473,7 +459,7 @@ async fn test_query_states() { } ]); - ws.send(Message::Text(req.to_string())) + ws.send(Message::Text(req.to_string().into())) .await .expect("Failed to send REQ"); @@ -484,7 +470,7 @@ async fn test_query_states() { for _ in 0..10 { if let Some(Ok(Message::Text(text))) = ws.next().await { let response: Value = serde_json::from_str(&text).expect("Failed to parse"); - + if response[0] == "EVENT" { assert_eq!(response[1], "test-sub"); found_event = true; @@ -506,21 +492,22 @@ async fn test_duplicate_announcement() { let relay = TestRelay::start().await; let keys = Keys::generate(); - let (mut ws, _) = connect_async(relay.url()) - .await - .expect("Failed to connect"); + let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect"); let event = create_announcement( &keys, &relay.domain(), "duplicate-test", - vec![format!("https://{}/alice/duplicate-test.git", relay.domain())], + vec![format!( + "https://{}/alice/duplicate-test.git", + relay.domain() + )], vec![format!("wss://{}", relay.domain())], ); // Send first time let event_msg = json!(["EVENT", event]); - ws.send(Message::Text(event_msg.to_string())) + ws.send(Message::Text(event_msg.to_string().into())) .await .expect("Failed to send event"); @@ -531,14 +518,14 @@ async fn test_duplicate_announcement() { // Send second time (duplicate) let event_msg = json!(["EVENT", event]); - ws.send(Message::Text(event_msg.to_string())) + ws.send(Message::Text(event_msg.to_string().into())) .await .expect("Failed to send event"); if let Some(Ok(Message::Text(text))) = ws.next().await { let response2: Value = serde_json::from_str(&text).expect("Failed to parse"); assert_eq!(response2[2], true, "Duplicate should be acknowledged"); - + let message = response2[3].as_str().unwrap(); assert!( message.contains("duplicate") || message.is_empty(), -- cgit v1.2.3