From bf7f4d5381203d5c27b2811d62c5b1781533aa2b Mon Sep 17 00:00:00 2001 From: DanConwayDev Date: Wed, 19 Nov 2025 17:01:36 +0000 Subject: fix some clippy fmt warnings --- grasp-audit/src/fixtures.rs | 162 ++++++++++++++++++++++++++------------------ 1 file changed, 95 insertions(+), 67 deletions(-) (limited to 'grasp-audit/src/fixtures.rs') diff --git a/grasp-audit/src/fixtures.rs b/grasp-audit/src/fixtures.rs index 71d64d3..8eee81f 100644 --- a/grasp-audit/src/fixtures.rs +++ b/grasp-audit/src/fixtures.rs @@ -33,13 +33,13 @@ use std::sync::{Arc, Mutex}; pub enum FixtureKind { /// Basic repository announcement (kind 30617) ValidRepo, - + /// Repository with one issue (kind 1621) RepoWithIssue, - + /// Repository with issue and comment (kind 1111) RepoWithComment, - + /// Repository state announcement (kind 30618) RepoState, } @@ -49,7 +49,7 @@ pub enum FixtureKind { pub enum ContextMode { /// Create fresh fixtures for each request (test isolation) Isolated, - + /// Reuse shared fixtures across requests (minimal events) Shared, } @@ -104,7 +104,7 @@ impl<'a> TestContext<'a> { cache: Arc::new(Mutex::new(HashMap::new())), } } - + /// Create a test context with explicit mode override /// /// This is useful for testing the context itself or for advanced use cases @@ -116,7 +116,7 @@ impl<'a> TestContext<'a> { cache: Arc::new(Mutex::new(HashMap::new())), } } - + /// Get a fixture, creating it if needed based on mode /// /// # Behavior @@ -139,7 +139,7 @@ impl<'a> TestContext<'a> { ContextMode::Shared => self.get_or_create_shared(kind).await, } } - + /// Get the underlying client for direct access /// /// This allows tests to use the client directly when needed while still @@ -147,23 +147,27 @@ impl<'a> TestContext<'a> { pub fn client(&self) -> &'a AuditClient { self.client } - + /// Get the current context mode pub fn mode(&self) -> ContextMode { self.mode } - + /// Create a fresh fixture (always creates new) async fn create_fresh(&self, kind: FixtureKind) -> Result { - let event = self.build_fixture(kind).await + let event = self + .build_fixture(kind) + .await .with_context(|| format!("Failed to build {:?} fixture", kind))?; - - self.client.send_event(event.clone()).await + + self.client + .send_event(event.clone()) + .await .with_context(|| format!("Failed to send {:?} fixture event to relay", kind))?; - + Ok(event) } - + /// Get or create a shared fixture (caches for reuse) async fn get_or_create_shared(&self, kind: FixtureKind) -> Result { // Check cache first @@ -173,39 +177,54 @@ impl<'a> TestContext<'a> { return Ok(event.clone()); } } - + // Not in cache, create it - let event = self.build_fixture(kind).await + let event = self + .build_fixture(kind) + .await .with_context(|| format!("Failed to build {:?} fixture for shared cache", kind))?; - - self.client.send_event(event.clone()).await - .with_context(|| format!("Failed to send {:?} fixture event to relay (shared cache)", kind))?; - + + self.client + .send_event(event.clone()) + .await + .with_context(|| { + format!( + "Failed to send {:?} fixture event to relay (shared cache)", + kind + ) + })?; + // Store in cache { let mut cache = self.cache.lock().unwrap(); cache.insert(kind, event.clone()); } - + Ok(event) } - + /// Build a fixture event (doesn't send it) async fn build_fixture(&self, kind: FixtureKind) -> Result { match kind { FixtureKind::ValidRepo => { - let test_name = format!("fixture-{:?}-{}", kind, &uuid::Uuid::new_v4().to_string()[..8]); + let test_name = format!( + "fixture-{:?}-{}", + kind, + &uuid::Uuid::new_v4().to_string()[..8] + ); self.client.create_repo_announcement(&test_name).await } - + FixtureKind::RepoWithIssue => { - use nostr_sdk::prelude::*; - // First create and send repo - let test_name = format!("fixture-{:?}-{}", FixtureKind::ValidRepo, &uuid::Uuid::new_v4().to_string()[..8]); + let test_name = format!( + "fixture-{:?}-{}", + FixtureKind::ValidRepo, + &uuid::Uuid::new_v4().to_string()[..8] + ); let repo = self.client.create_repo_announcement(&test_name).await?; self.client.send_event(repo.clone()).await?; - + // Then create issue referencing it - this will have 'a' tag to repo // Note: We build the issue but DON'T send it here - the caller will send it let issue = self.client.create_issue( @@ -214,64 +233,70 @@ impl<'a> TestContext<'a> { "Issue content for testing", vec![], )?; - + // Return the issue - tests can extract repo reference from its 'a' tag // The caller (create_fresh/get_or_create_shared) will send this event Ok(issue) } - + FixtureKind::RepoWithComment => { // First create repo with issue - let test_name = format!("fixture-{:?}-{}", FixtureKind::ValidRepo, &uuid::Uuid::new_v4().to_string()[..8]); + let test_name = format!( + "fixture-{:?}-{}", + FixtureKind::ValidRepo, + &uuid::Uuid::new_v4().to_string()[..8] + ); let repo = self.client.create_repo_announcement(&test_name).await?; self.client.send_event(repo.clone()).await?; - - let issue = self.client.create_issue( - &repo, - "Test Issue", - "Issue content", - vec![], - )?; + + let issue = + self.client + .create_issue(&repo, "Test Issue", "Issue content", vec![])?; self.client.send_event(issue.clone()).await?; - + // Then create comment on issue - self.client.create_comment( - &issue, - "Test comment", - vec![], - ) + self.client.create_comment(&issue, "Test comment", vec![]) } - + FixtureKind::RepoState => { use nostr_sdk::prelude::*; - + // First create repo announcement - let test_name = format!("fixture-{:?}-{}", FixtureKind::ValidRepo, &uuid::Uuid::new_v4().to_string()[..8]); + let test_name = format!( + "fixture-{:?}-{}", + FixtureKind::ValidRepo, + &uuid::Uuid::new_v4().to_string()[..8] + ); let repo = self.client.create_repo_announcement(&test_name).await?; self.client.send_event(repo.clone()).await?; - + // Extract repo_id from repo announcement - let repo_id = repo.tags.iter() + let repo_id = repo + .tags + .iter() .find(|t| t.kind() == TagKind::d()) .and_then(|t| t.content()) .ok_or_else(|| anyhow::anyhow!("Missing d tag in repo announcement"))? .to_string(); - + // Create state announcement - self.client.event_builder(Kind::Custom(30618), "") + self.client + .event_builder(Kind::Custom(30618), "") .tag(Tag::identifier(&repo_id)) - .tag(Tag::custom(TagKind::custom("refs/heads/main"), vec![ - "abc123def456789012345678901234567890abcd" - ])) - .tag(Tag::custom(TagKind::custom("HEAD"), vec![ - "ref: refs/heads/main" - ])) + .tag(Tag::custom( + TagKind::custom("refs/heads/main"), + vec!["abc123def456789012345678901234567890abcd"], + )) + .tag(Tag::custom( + TagKind::custom("HEAD"), + vec!["ref: refs/heads/main"], + )) .build(self.client.keys()) .map_err(|e| anyhow::anyhow!("Failed to build state announcement: {}", e)) } } } - + /// Clear the fixture cache /// /// This is useful for tests that want to ensure fresh fixtures @@ -286,34 +311,37 @@ impl<'a> TestContext<'a> { mod tests { use super::*; use crate::AuditConfig; - + #[test] fn test_context_mode_from_audit_mode() { assert_eq!(ContextMode::from(AuditMode::CI), ContextMode::Isolated); - assert_eq!(ContextMode::from(AuditMode::Production), ContextMode::Shared); + assert_eq!( + ContextMode::from(AuditMode::Production), + ContextMode::Shared + ); } - + #[test] fn test_fixture_kind_hash() { use std::collections::HashSet; - + let mut set = HashSet::new(); set.insert(FixtureKind::ValidRepo); set.insert(FixtureKind::RepoWithIssue); - + assert!(set.contains(&FixtureKind::ValidRepo)); assert!(!set.contains(&FixtureKind::RepoWithComment)); } - + #[tokio::test] async fn test_context_creation() { let config = AuditConfig::ci(); let client = crate::AuditClient::new_test(config); - + let ctx = TestContext::new(&client); assert_eq!(ctx.mode(), ContextMode::Isolated); - + let ctx = TestContext::with_mode(&client, ContextMode::Shared); assert_eq!(ctx.mode(), ContextMode::Shared); } -} \ No newline at end of file +} -- cgit v1.2.3