From ddeef961ca5f4c2f91f8c76e645f1b62ca4a47ca Mon Sep 17 00:00:00 2001 From: Timothy Quilling Date: Thu, 20 Nov 2025 17:35:18 -0500 Subject: [PATCH] fix: warnings, lints, tests --- consumer/src/db/gates/queries.rs | 2 +- consumer/src/workers/backfill/mod.rs | 1 + consumer/tests/bulk_copy_queries_test.rs | 2 ++ consumer/tests/bulk_resolve_queries_test.rs | 2 ++ lexica/src/app_bsky/mod.rs | 14 +-------- parakeet/src/loaders/feed.rs | 2 +- parakeet/src/loaders/post.rs | 2 +- .../src/xrpc/app_bsky/feed/get_timeline.rs | 5 ++- parakeet/tests/author_feed_optimization.rs | 6 ++++ parakeet/tests/db_states_test.rs | 11 +++++-- parakeet/tests/db_uri_reconstruction_test.rs | 31 ++----------------- parakeet/tests/force_generic_plan_test.rs | 2 ++ parakeet/tests/manual_prepare_test.rs | 2 ++ parakeet/tests/performance_benchmark.rs | 1 + parakeet/tests/performance_bottlenecks.rs | 1 + parakeet/tests/pinned_post_optimization.rs | 21 +++++++------ parakeet/tests/post_state_optimizations.rs | 2 ++ parakeet/tests/prepare_connection_pool.rs | 1 + parakeet/tests/production_simulation.rs | 2 ++ parakeet/tests/query_caching_investigation.rs | 2 ++ parakeet/tests/session_level_plan_mode.rs | 2 ++ parakeet/tests/sql/db_module_test.rs | 11 ++++--- parakeet/tests/test_author_feed_prod.rs | 2 ++ parakeet/tests/viewer_states_performance.rs | 7 +++-- 24 files changed, 67 insertions(+), 67 deletions(-) diff --git a/consumer/src/db/gates/queries.rs b/consumer/src/db/gates/queries.rs index e6447fd8..03a86ffe 100644 --- a/consumer/src/db/gates/queries.rs +++ b/consumer/src/db/gates/queries.rs @@ -173,7 +173,7 @@ pub async fn maintain_postgates_cached( .await? .get(0); if !exists { - return Err(eyre::eyre!("Post not found: {}", post_uri).into()); + return Err(eyre::eyre!("Post not found: {}", post_uri)); } (actor_id, rkey_i64) diff --git a/consumer/src/workers/backfill/mod.rs b/consumer/src/workers/backfill/mod.rs index 9153fca6..3d019845 100644 --- a/consumer/src/workers/backfill/mod.rs +++ b/consumer/src/workers/backfill/mod.rs @@ -30,6 +30,7 @@ const PDS_SERVICE_ID: &str = "#atproto_pds"; #[derive(Clone)] pub struct BackfillManagerInner { + #[expect(dead_code, reason = "Stored for potential future stats aggregation integration")] index_client: Option, tmp_dir: PathBuf, resolver: Arc, diff --git a/consumer/tests/bulk_copy_queries_test.rs b/consumer/tests/bulk_copy_queries_test.rs index 77cb9069..e38633c1 100644 --- a/consumer/tests/bulk_copy_queries_test.rs +++ b/consumer/tests/bulk_copy_queries_test.rs @@ -3,6 +3,8 @@ //! These tests validate that the SQL queries used by bulk_copy functions //! are syntactically correct against the current database schema. //! + +#![allow(clippy::unseparated_literal_suffix)] //! IMPORTANT: These tests run against the parakeet_test database and verify //! that all SQL operations compile and execute without schema errors. diff --git a/consumer/tests/bulk_resolve_queries_test.rs b/consumer/tests/bulk_resolve_queries_test.rs index af188f38..3e378c23 100644 --- a/consumer/tests/bulk_resolve_queries_test.rs +++ b/consumer/tests/bulk_resolve_queries_test.rs @@ -3,6 +3,8 @@ //! These tests validate that the SQL queries used by bulk_resolve functions //! are syntactically correct against the current database schema. +#![allow(clippy::unseparated_literal_suffix)] + mod common; use chrono::Utc; use common::*; diff --git a/lexica/src/app_bsky/mod.rs b/lexica/src/app_bsky/mod.rs index ed086c79..d4dbba27 100644 --- a/lexica/src/app_bsky/mod.rs +++ b/lexica/src/app_bsky/mod.rs @@ -9,7 +9,7 @@ pub mod labeler; pub mod richtext; pub mod unspecced; -#[derive(Clone, Debug, Serialize, Deserialize)] +#[derive(Clone, Debug, Default, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct RecordStats { pub reply_count: i64, @@ -18,15 +18,3 @@ pub struct RecordStats { pub quote_count: i64, pub bookmark_count: i64, } - -impl Default for RecordStats { - fn default() -> Self { - Self { - reply_count: 0, - repost_count: 0, - like_count: 0, - quote_count: 0, - bookmark_count: 0, - } - } -} diff --git a/parakeet/src/loaders/feed.rs b/parakeet/src/loaders/feed.rs index 9ac3bdd4..d310960c 100644 --- a/parakeet/src/loaders/feed.rs +++ b/parakeet/src/loaders/feed.rs @@ -181,7 +181,7 @@ impl BatchFn for LikeLoader { .iter() .map(|(uri, post_key)| { post_key_to_uri.insert((post_key.actor_id, post_key.rkey), uri.clone()); - post_key.clone() + *post_key }) .collect(); diff --git a/parakeet/src/loaders/post.rs b/parakeet/src/loaders/post.rs index c67d6622..f9b0ea86 100644 --- a/parakeet/src/loaders/post.rs +++ b/parakeet/src/loaders/post.rs @@ -1275,7 +1275,7 @@ impl BatchFn for PostStatsLoader { .iter() .map(|(uri, post_key)| { post_key_to_uri.insert((post_key.actor_id, post_key.rkey), uri.clone()); - post_key.clone() + *post_key }) .collect(); diff --git a/parakeet/src/xrpc/app_bsky/feed/get_timeline.rs b/parakeet/src/xrpc/app_bsky/feed/get_timeline.rs index 2281bcab..a9add6d7 100644 --- a/parakeet/src/xrpc/app_bsky/feed/get_timeline.rs +++ b/parakeet/src/xrpc/app_bsky/feed/get_timeline.rs @@ -31,7 +31,6 @@ pub async fn get_timeline( Query(query): Query, ) -> XrpcResult> { let start = std::time::Instant::now(); - let mut step_timer = std::time::Instant::now(); // Get the user's DID from auth let user_did = auth.0.clone(); @@ -45,7 +44,7 @@ pub async fn get_timeline( let cached_actor = state.id_cache.get_actor_id(&user_did).await; // Try cache first (if we have actor_id) - step_timer = std::time::Instant::now(); + let mut step_timer = std::time::Instant::now(); if let Some(cached_actor) = &cached_actor { if let Some(cached) = state.timeline_cache.get(cached_actor.actor_id, query.cursor.as_deref()).await { // Cache hit - hydrate the cached URIs @@ -275,7 +274,7 @@ pub async fn get_timeline( } // Debug: Log first few post URIs to verify response content - if feed.len() > 0 { + if !feed.is_empty() { let sample_uris: Vec<&str> = feed.iter().take(3).map(|f| f.post.uri.as_str()).collect(); tracing::debug!(" → Sample post URIs: {:?}", sample_uris); } diff --git a/parakeet/tests/author_feed_optimization.rs b/parakeet/tests/author_feed_optimization.rs index 98ebdbf4..a21d71d7 100644 --- a/parakeet/tests/author_feed_optimization.rs +++ b/parakeet/tests/author_feed_optimization.rs @@ -5,6 +5,8 @@ //! //! Run with: cargo test --package parakeet --test author_feed_optimization -- --nocapture +#![allow(clippy::print_stdout, clippy::unseparated_literal_suffix)] + use diesel::prelude::*; use diesel_async::pooled_connection::deadpool::Pool; use diesel_async::pooled_connection::AsyncDieselConnectionManager; @@ -72,6 +74,7 @@ async fn test_author_feed_optimization() { println!("────────────────────────────────────────────────────────────────\n"); #[derive(QueryableByName)] + #[allow(dead_code)] struct PostRow { #[diesel(sql_type = diesel::sql_types::Integer)] actor_id: i32, @@ -80,6 +83,7 @@ async fn test_author_feed_optimization() { } #[derive(QueryableByName)] + #[allow(dead_code)] struct RepostRow { #[diesel(sql_type = diesel::sql_types::Integer)] actor_id: i32, @@ -153,6 +157,7 @@ async fn test_author_feed_optimization() { println!("────────────────────────────────────────────────────────────────\n"); #[derive(QueryableByName)] + #[allow(dead_code)] struct RepostSimple { #[diesel(sql_type = diesel::sql_types::Integer)] actor_id: i32, @@ -165,6 +170,7 @@ async fn test_author_feed_optimization() { } #[derive(QueryableByName)] + #[allow(dead_code)] struct PostData { #[diesel(sql_type = diesel::sql_types::Integer)] actor_id: i32, diff --git a/parakeet/tests/db_states_test.rs b/parakeet/tests/db_states_test.rs index f612a765..028c0e8c 100644 --- a/parakeet/tests/db_states_test.rs +++ b/parakeet/tests/db_states_test.rs @@ -50,10 +50,12 @@ async fn test_get_post_state() -> eyre::Result<()> { let pool = common::test_diesel_pool(); let mut conn = pool.get().await.wrap_err("Failed to get connection")?; + // Use dummy IDs for SQL syntax validation (doesn't need to exist) let _result = parakeet::db::get_post_state( &mut conn, - "did:plc:viewer", - "at://did:plc:test/app.bsky.feed.post/3ktpjpifdsr2d", + 999, // viewer_id + 888, // subject_actor_id + 1234567890, // subject_rkey ) .await .wrap_err("SQL syntax error in get_post_state")?; @@ -67,7 +69,10 @@ async fn test_get_post_states() -> eyre::Result<()> { let pool = common::test_diesel_pool(); let mut conn = pool.get().await.wrap_err("Failed to get connection")?; - let subjects = vec!["at://did:plc:test/app.bsky.feed.post/3ktpjpifdsr2d".to_string()]; + // get_post_states expects (uri, actor_id, rkey) tuples + let subjects = vec![ + ("at://did:plc:test/app.bsky.feed.post/3ktpjpifdsr2d".to_string(), 888, 1234567890), + ]; // Use dummy viewer_id for SQL syntax validation (doesn't need to exist) let _result = parakeet::db::get_post_states(&mut conn, 999, &subjects) diff --git a/parakeet/tests/db_uri_reconstruction_test.rs b/parakeet/tests/db_uri_reconstruction_test.rs index 9875b428..d9210e50 100644 --- a/parakeet/tests/db_uri_reconstruction_test.rs +++ b/parakeet/tests/db_uri_reconstruction_test.rs @@ -12,35 +12,8 @@ use eyre::WrapErr; // URI RECONSTRUCTION QUERY TESTS // ============================================================================ -#[tokio::test] -async fn test_get_post_uris_by_ids() -> eyre::Result<()> { - common::ensure_test_db_ready().await; - let pool = common::test_diesel_pool(); - let mut conn = pool.get().await.wrap_err("Failed to get connection")?; - - let post_ids = vec![1, 2, 3]; - - let _result = parakeet::db::get_post_uris_by_ids(&mut conn, &post_ids) - .await - .wrap_err("SQL syntax error in get_post_uris_by_ids")?; - - Ok(()) -} - -#[tokio::test] -async fn test_get_post_uris_by_ids_empty() -> eyre::Result<()> { - common::ensure_test_db_ready().await; - let pool = common::test_diesel_pool(); - let mut conn = pool.get().await.wrap_err("Failed to get connection")?; - - let post_ids: Vec = vec![]; - - let _result = parakeet::db::get_post_uris_by_ids(&mut conn, &post_ids) - .await - .wrap_err("SQL syntax error in get_post_uris_by_ids (empty)")?; - - Ok(()) -} +// NOTE: get_post_uris_by_ids tests removed - function no longer exists after natural key migration +// Posts now use natural keys (actor_id, rkey) instead of synthetic IDs #[tokio::test] async fn test_get_feedgen_uris_by_ids() -> eyre::Result<()> { diff --git a/parakeet/tests/force_generic_plan_test.rs b/parakeet/tests/force_generic_plan_test.rs index c8386fc8..20789a26 100644 --- a/parakeet/tests/force_generic_plan_test.rs +++ b/parakeet/tests/force_generic_plan_test.rs @@ -4,6 +4,8 @@ //! //! Run with: cargo test --package parakeet --test force_generic_plan_test -- --nocapture +#![allow(clippy::print_stdout, clippy::unseparated_literal_suffix)] + use diesel::prelude::*; use diesel_async::pooled_connection::deadpool::Pool; use diesel_async::pooled_connection::AsyncDieselConnectionManager; diff --git a/parakeet/tests/manual_prepare_test.rs b/parakeet/tests/manual_prepare_test.rs index fd10f792..be49c5f5 100644 --- a/parakeet/tests/manual_prepare_test.rs +++ b/parakeet/tests/manual_prepare_test.rs @@ -4,6 +4,8 @@ //! //! Run with: cargo test --package parakeet --test manual_prepare_test -- --nocapture +#![allow(clippy::print_stdout)] + use diesel::prelude::*; use diesel_async::pooled_connection::deadpool::Pool; use diesel_async::pooled_connection::AsyncDieselConnectionManager; diff --git a/parakeet/tests/performance_benchmark.rs b/parakeet/tests/performance_benchmark.rs index 13e85391..885bc8e4 100644 --- a/parakeet/tests/performance_benchmark.rs +++ b/parakeet/tests/performance_benchmark.rs @@ -7,6 +7,7 @@ //! //! Run with: cargo test --package parakeet --test performance_benchmark -- --nocapture +#![allow(clippy::print_stdout, clippy::println_empty_string)] use diesel::prelude::*; use diesel::sql_types::Text; use diesel_async::pooled_connection::deadpool::Pool; diff --git a/parakeet/tests/performance_bottlenecks.rs b/parakeet/tests/performance_bottlenecks.rs index 05a78677..97403b97 100644 --- a/parakeet/tests/performance_bottlenecks.rs +++ b/parakeet/tests/performance_bottlenecks.rs @@ -7,6 +7,7 @@ //! //! Run with: cargo test --package parakeet --test performance_bottlenecks -- --nocapture +#![allow(clippy::print_stdout, clippy::println_empty_string)] use diesel::prelude::*; use diesel_async::pooled_connection::deadpool::Pool; use diesel_async::pooled_connection::AsyncDieselConnectionManager; diff --git a/parakeet/tests/pinned_post_optimization.rs b/parakeet/tests/pinned_post_optimization.rs index 795d09dc..dcdd5d25 100644 --- a/parakeet/tests/pinned_post_optimization.rs +++ b/parakeet/tests/pinned_post_optimization.rs @@ -1,12 +1,15 @@ -/// Test comparing pinned post query optimization approaches -/// -/// This test demonstrates the performance difference between: -/// 1. Old approach: Single query with JOIN to posts hypertable (expensive query planning) -/// 2. New approach: Two-step process avoiding hypertable planning overhead -/// -/// The old approach triggers PostgreSQL to plan for 305+ TimescaleDB chunks even when -/// pinned_post_id is NULL, causing 64-140ms planning overhead. The new approach -/// short-circuits when pinned_post_id is NULL, avoiding this overhead entirely. +// Test comparing pinned post query optimization approaches +// +// This test demonstrates the performance difference between: +// 1. Old approach: Single query with JOIN to posts hypertable (expensive query planning) +// 2. New approach: Two-step process avoiding hypertable planning overhead +// +// The old approach triggers PostgreSQL to plan for 305+ TimescaleDB chunks even when +// pinned_post_id is NULL, causing 64-140ms planning overhead. The new approach +// short-circuits when pinned_post_id is NULL, avoiding this overhead entirely. + +#![allow(clippy::print_stdout, clippy::unseparated_literal_suffix)] + use diesel::prelude::*; use diesel::sql_types::{BigInt, Nullable, Text}; use diesel_async::RunQueryDsl; diff --git a/parakeet/tests/post_state_optimizations.rs b/parakeet/tests/post_state_optimizations.rs index 8cc99893..8c8cd3f6 100644 --- a/parakeet/tests/post_state_optimizations.rs +++ b/parakeet/tests/post_state_optimizations.rs @@ -10,6 +10,8 @@ //! //! Run with: cargo test --package parakeet --test post_state_optimizations -- --nocapture +#![allow(clippy::print_stdout, clippy::unseparated_literal_suffix)] + use diesel::prelude::*; use diesel_async::pooled_connection::deadpool::Pool; use diesel_async::pooled_connection::AsyncDieselConnectionManager; diff --git a/parakeet/tests/prepare_connection_pool.rs b/parakeet/tests/prepare_connection_pool.rs index 73c5b856..3fff3826 100644 --- a/parakeet/tests/prepare_connection_pool.rs +++ b/parakeet/tests/prepare_connection_pool.rs @@ -5,6 +5,7 @@ //! //! Run with: cargo test --package parakeet --test prepare_connection_pool -- --nocapture +#![allow(clippy::print_stdout, clippy::println_empty_string)] use diesel::prelude::*; use diesel_async::pooled_connection::deadpool::Pool; use diesel_async::pooled_connection::AsyncDieselConnectionManager; diff --git a/parakeet/tests/production_simulation.rs b/parakeet/tests/production_simulation.rs index 29b5c4ef..12fd220c 100644 --- a/parakeet/tests/production_simulation.rs +++ b/parakeet/tests/production_simulation.rs @@ -7,6 +7,8 @@ //! //! Run with: cargo test --package parakeet --test production_simulation -- --nocapture +#![allow(clippy::print_stdout)] + use diesel::prelude::*; use diesel_async::pooled_connection::deadpool::Pool; use diesel_async::pooled_connection::AsyncDieselConnectionManager; diff --git a/parakeet/tests/query_caching_investigation.rs b/parakeet/tests/query_caching_investigation.rs index 5bfb0907..7053139e 100644 --- a/parakeet/tests/query_caching_investigation.rs +++ b/parakeet/tests/query_caching_investigation.rs @@ -8,6 +8,8 @@ //! //! Run with: cargo test --package parakeet --test query_caching_investigation -- --nocapture +#![allow(clippy::print_stdout, clippy::unseparated_literal_suffix)] + use diesel::prelude::*; use diesel_async::pooled_connection::deadpool::Pool; use diesel_async::pooled_connection::AsyncDieselConnectionManager; diff --git a/parakeet/tests/session_level_plan_mode.rs b/parakeet/tests/session_level_plan_mode.rs index e1dd84dd..9dc2968a 100644 --- a/parakeet/tests/session_level_plan_mode.rs +++ b/parakeet/tests/session_level_plan_mode.rs @@ -4,6 +4,8 @@ //! //! Run with: cargo test --package parakeet --test session_level_plan_mode -- --nocapture +#![allow(clippy::print_stdout)] + use diesel::prelude::*; use diesel_async::pooled_connection::deadpool::Pool; use diesel_async::pooled_connection::AsyncDieselConnectionManager; diff --git a/parakeet/tests/sql/db_module_test.rs b/parakeet/tests/sql/db_module_test.rs index 1e464f2b..bbdf3d8d 100644 --- a/parakeet/tests/sql/db_module_test.rs +++ b/parakeet/tests/sql/db_module_test.rs @@ -94,10 +94,12 @@ async fn test_get_post_state_empty() -> eyre::Result<()> { let mut conn = pool.get().await .wrap_err("Failed to get connection")?; + // Use dummy IDs for SQL syntax validation (doesn't need to exist) let result = db::get_post_state( &mut conn, - "did:plc:viewer", - "at://did:plc:author/app.bsky.feed.post/3ktpjpifdsr2d" + 999, // viewer_id + 888, // subject_actor_id + 1234567890 // subject_rkey ).await; let result = result.wrap_err("SQL query failed")?; @@ -112,9 +114,10 @@ async fn test_get_post_states_empty() -> eyre::Result<()> { let mut conn = pool.get().await .wrap_err("Failed to get connection")?; + // get_post_states expects (uri, actor_id, rkey) tuples let subjects = vec![ - "at://did:plc:author/app.bsky.feed.post/3ktpjpifdsr2d".to_string(), - "at://did:plc:author/app.bsky.feed.post/3kvqomklhtx2d".to_string(), + ("at://did:plc:author/app.bsky.feed.post/3ktpjpifdsr2d".to_string(), 888, 1234567890), + ("at://did:plc:author/app.bsky.feed.post/3kvqomklhtx2d".to_string(), 888, 1234567891), ]; // Use dummy viewer_id for SQL syntax validation (doesn't need to exist) diff --git a/parakeet/tests/test_author_feed_prod.rs b/parakeet/tests/test_author_feed_prod.rs index 91de0422..aefce3cc 100644 --- a/parakeet/tests/test_author_feed_prod.rs +++ b/parakeet/tests/test_author_feed_prod.rs @@ -1,5 +1,7 @@ //! Quick test to verify the production getAuthorFeed implementation works +#![allow(clippy::print_stdout, clippy::unseparated_literal_suffix)] + use diesel_async::pooled_connection::deadpool::Pool; use diesel_async::pooled_connection::AsyncDieselConnectionManager; use diesel_async::AsyncPgConnection; diff --git a/parakeet/tests/viewer_states_performance.rs b/parakeet/tests/viewer_states_performance.rs index dd4aaed0..97412ff1 100644 --- a/parakeet/tests/viewer_states_performance.rs +++ b/parakeet/tests/viewer_states_performance.rs @@ -4,12 +4,13 @@ // This test uses the EXACT production SQL file via include_str!() to ensure // we're testing the actual code that runs in production. +#![allow(clippy::unseparated_literal_suffix, clippy::print_stdout)] + use diesel::prelude::*; use diesel_async::{AsyncPgConnection, RunQueryDsl}; use diesel_async::pooled_connection::AsyncDieselConnectionManager; use diesel_async::pooled_connection::deadpool::Pool; use std::time::Instant; -use tracing_subscriber; // Import the actual production SQL query const POST_STATE_SQL: &str = include_str!("../src/sql/post_state.sql"); @@ -181,7 +182,7 @@ async fn test_viewer_states_production_breakdown() { println!("\n=== Complete Timing Breakdown ===\n"); // Initialize tracing to capture detailed logs - let _ = tracing_subscriber::fmt() + let _unused = tracing_subscriber::fmt() .with_max_level(tracing::Level::INFO) .with_test_writer() .try_init(); @@ -364,7 +365,7 @@ async fn test_viewer_states_explain_analyze() { .load(&mut conn) .await .unwrap(); - let explain_total = explain_start.elapsed(); + let _explain_total = explain_start.elapsed(); // Now run actual query to measure Rust overhead let query_start = Instant::now(); -- 2.51.2