fix: tests

consumer/src/database_writer/operations/executor.rs

···
 //! This makes stats idempotent - duplicate events won't double-count.
 
 use super::{cache, ActorStatsDeltas, DatabaseOperation, PostStatsDeltas};
+use eyre::WrapErr as _;
 use ipld_core::cid::Cid;
 
 /// Helper to create a single post stats delta
···
             cid,
             record,
         } => {
+            // Lists use arbitrary string rkeys (not TID-based like posts)
             let inserted = db::list_upsert(conn, actor_id, &rkey, cid, record).await?;
             if inserted {
                 let actor_deltas = actor_list_delta(actor_id, 1);
···
                     // Lists use arbitrary string rkeys - extract from at_uri
                     let rkey_str = parakeet_db::at_uri_util::extract_rkey(&at_uri)
                         .ok_or_else(|| eyre::eyre!("Invalid at_uri: missing rkey"))?;
+
                     let rows = db::list_delete(conn, actor_id, rkey_str).await?;
                     if rows > 0 {
                         actor_deltas.extend(actor_list_delta(actor_id, -1));

consumer/src/db/operations/actor_update.rs

···
             }
             ActorUpdateTarget::ByDid(did) => {
                 // Resolve DID to ID first
-                let actor_id = super::super::actor_id_from_did(conn, did)
-                    .await?
-                    .ok_or_else(|| eyre::eyre!("Actor not found for DID: {}", did))?;
+                let actor_id_opt = super::super::actor_id_from_did(conn, did).await?;
 
-                let clause = "id = $1".to_string();
-                let params: Vec<Box<dyn tokio_postgres::types::ToSql + Sync + Send>> =
-                    vec![Box::new(actor_id)];
-                Ok((clause, params))
+                if let Some(actor_id) = actor_id_opt {
+                    let clause = "id = $1".to_string();
+                    let params: Vec<Box<dyn tokio_postgres::types::ToSql + Sync + Send>> =
+                        vec![Box::new(actor_id)];
+                    Ok((clause, params))
+                } else {
+                    // Actor doesn't exist - return WHERE FALSE so UPDATE returns 0 rows
+                    // This allows the caller to handle the not-found case (e.g., actor_upsert does INSERT)
+                    Ok(("FALSE".to_string(), vec![]))
+                }
             }
             ActorUpdateTarget::Batch { ids } => {
                 if ids.is_empty() {
···
                     params.push(Box::new(*embed_post_rkey));
                     param_idx += 1;
 
-                    clauses.push(format!("status_thumb_mime_type = ${}", param_idx));
+                    clauses.push(format!("status_thumb_mime_type = ${}::text::image_mime_type", param_idx));
                     params.push(Box::new(thumb_mime_type.clone()));
                     param_idx += 1;
 

consumer/src/db/operations/graph.rs

···
 pub async fn list_upsert<C: GenericClient>(
     conn: &C,
     actor_id: i32,
-    rkey: &str,
+    rkey: &str,  // Lists use arbitrary string rkeys (not TID-based like posts)
     cid: Cid,
     rec: AppBskyGraphList,
 ) -> Result<bool> {

consumer/tests/community_starterpack_operations_test.rs

···
     graph::list_upsert(
         &tx,
         list_owner_id,
-        parakeet_db::models::tid_to_i64(&extract_rkey(list_uri)).unwrap(),
+        &extract_rkey(list_uri),
         test_cid(),
         list,
     )
···
     graph::list_upsert(
         &tx,
         list_owner_id,
-        parakeet_db::models::tid_to_i64(&extract_rkey(list_uri)).unwrap(),
+        &extract_rkey(list_uri),
         test_cid(),
         list,
     )
···
     graph::list_upsert(
         &tx,
         list_owner_id,
-        parakeet_db::models::tid_to_i64(&extract_rkey(list_uri)).unwrap(),
+        &extract_rkey(list_uri),
         test_cid(),
         list,
     )
···
     graph::list_upsert(
         &tx,
         list_owner_id,
-        parakeet_db::models::tid_to_i64(&extract_rkey(list_uri)).unwrap(),
+        &extract_rkey(list_uri),
         test_cid(),
         list,
     )

consumer/tests/graph_operations_test.rs

···
     let (actor_id, _, _) = consumer::db::operations::feed::get_actor_id(&tx, "did:plc:listowner").await?;
     let rkey = "3l7mkz4lmk24a";
     let rkey_i64 = parakeet_db::models::tid_to_i64(rkey).unwrap();
-    let result = graph::list_upsert(&tx, actor_id, rkey_i64, test_cid(), list).await;
+    let result = graph::list_upsert(&tx, actor_id, rkey, test_cid(), list).await;
 
     assert!(
         result.is_ok(),
···
             "SELECT EXISTS(
                 SELECT 1 FROM lists l
                 INNER JOIN actors a ON l.actor_id = a.id
-                WHERE a.did = $1 AND l.rkey = tid_to_i64($2)
+                WHERE a.did = $1 AND l.rkey = $2
             )",
             &[&"did:plc:listowner", &"3l7mkz4lmk24a"],
         )
···
     let (actor_id, _, _) = consumer::db::operations::feed::get_actor_id(&tx, "did:plc:listowner2").await?;
     let rkey = "3l7mkz4lmk24b";
     let rkey_i64 = parakeet_db::models::tid_to_i64(rkey).unwrap();
-    let result1 = graph::list_upsert(&tx, actor_id, rkey_i64, test_cid(), list1).await;
+    let result1 = graph::list_upsert(&tx, actor_id, rkey, test_cid(), list1).await;
 
     assert!(result1.unwrap(), "First insert should return true");
 
···
         created_at: Utc::now(),
     };
 
-    let result2 = graph::list_upsert(&tx, actor_id, rkey_i64, test_cid(), list2).await;
+    let result2 = graph::list_upsert(&tx, actor_id, rkey, test_cid(), list2).await;
 
     assert!(!result2.unwrap(), "Update should return false");
 
···
         .query_one(
             "SELECT l.name FROM lists l
              INNER JOIN actors a ON l.actor_id = a.id
-             WHERE a.did = $1 AND l.rkey = tid_to_i64($2)",
+             WHERE a.did = $1 AND l.rkey = $2",
             &[&"did:plc:listowner2", &"3l7mkz4lmk24b"],
         )
         .await
···
     let (actor_id, _, _) = consumer::db::operations::feed::get_actor_id(&tx, "did:plc:listowner3").await?;
     let rkey = "3l7mkz4lmk24c";
     let rkey_i64 = parakeet_db::models::tid_to_i64(rkey).unwrap();
-    graph::list_upsert(&tx, actor_id, rkey_i64, test_cid(), list)
+    graph::list_upsert(&tx, actor_id, rkey, test_cid(), list)
         .await
         .wrap_err("Failed to insert list")?;
 
     // Delete the list
-    let result = graph::list_delete(&tx, actor_id, rkey_i64).await;
+    let result = graph::list_delete(&tx, actor_id,rkey).await;
 
     assert!(
         result.is_ok(),
···
             "SELECT EXISTS(
                 SELECT 1 FROM lists l
                 INNER JOIN actors a ON l.actor_id = a.id
-                WHERE a.did = $1 AND l.rkey = tid_to_i64($2)
+                WHERE a.did = $1 AND l.rkey = $2
             )",
             &[&"did:plc:listowner3", &"3l7mkz4lmk24c"],
         )
···
     let list_uri = "at://did:plc:listowner4/app.bsky.graph.list/3l7mkz4lmk24d";
     let list_rkey = "3l7mkz4lmk24d";
     let list_rkey_i64 = parakeet_db::models::tid_to_i64(list_rkey).unwrap();
-    graph::list_upsert(&tx, list_owner_actor_id, list_rkey_i64, test_cid(), list)
+    graph::list_upsert(&tx, list_owner_actor_id, list_rkey, test_cid(), list)
         .await
         .wrap_err("Failed to create list")?;
 
···
             "SELECT l.status::text, l.list_type IS NULL, l.name IS NULL
              FROM lists l
              INNER JOIN actors a ON l.actor_id = a.id
-             WHERE a.did = $1 AND l.rkey = tid_to_i64($2)",
+             WHERE a.did = $1 AND l.rkey = $2",
             &[&"did:plc:listowner5", &"3l7mkz4lmk24h"],
         )
         .await
···
     let list_uri = "at://did:plc:listowner6/app.bsky.graph.list/3l7mkz4lmk24j";
     let list_rkey = "3l7mkz4lmk24j";
     let list_rkey_i64 = parakeet_db::models::tid_to_i64(list_rkey).unwrap();
-    graph::list_upsert(&tx, list_owner_actor_id, list_rkey_i64, test_cid(), list)
+    graph::list_upsert(&tx, list_owner_actor_id, list_rkey, test_cid(), list)
         .await
         .wrap_err("Failed to create list")?;
 
···
     let list_uri = "at://did:plc:listowner7/app.bsky.graph.list/3l7mkz4lmk24l";
     let list_rkey = "3l7mkz4lmk24l";
     let list_rkey_i64 = parakeet_db::models::tid_to_i64(list_rkey).unwrap();
-    graph::list_upsert(&tx, list_owner_actor_id, list_rkey_i64, test_cid(), list)
+    graph::list_upsert(&tx, list_owner_actor_id, list_rkey, test_cid(), list)
         .await
         .wrap_err("Failed to create list")?;
 
···
     let list_uri = "at://did:plc:listowner8/app.bsky.graph.list/3l7mkz4lmk24n";
     let list_rkey = "3l7mkz4lmk24n";
     let list_rkey_i64 = parakeet_db::models::tid_to_i64(list_rkey).unwrap();
-    graph::list_upsert(&tx, list_owner_actor_id, list_rkey_i64, test_cid(), list)
+    graph::list_upsert(&tx, list_owner_actor_id, list_rkey, test_cid(), list)
         .await
         .wrap_err("Failed to create list")?;
 

consumer/tests/record_exists_queries_test.rs

···
     let pool = test_pool();
     let conn = pool.get().await.wrap_err("Failed to get connection")?;
 
-    let rkey_i64 = decode_tid(TEST_TID).unwrap();
-
-    let result = queries::list_exists(&**conn, "did:plc:test", rkey_i64).await;
+    let result = queries::list_exists(&**conn, "did:plc:test", TEST_TID).await;
 
     assert!(
         result.is_ok(),

consumer/tests/threadgate_enforcement_test.rs

···
     graph::list_upsert(
         &tx,
         listowner_id,
-        parakeet_db::models::tid_to_i64(&extract_rkey(list_uri)).unwrap(),
+        &extract_rkey(list_uri),
         test_cid(),
         list,
     )
···
     graph::list_upsert(
         &tx,
         listowner2_id,
-        parakeet_db::models::tid_to_i64(&extract_rkey(list_uri)).unwrap(),
+        &extract_rkey(list_uri),
         test_cid(),
         list,
     )

consumer/tests/workers_test.rs

···
     let mut conn = pool.get().await.wrap_err("Failed to get connection")?;
     let tx = conn.transaction().await.wrap_err("Failed to start transaction")?;
 
-    let dids = vec!["did:plc:alice", "did:plc:bob", "did:plc:charlie"];
+    // Use unique DIDs to avoid cache pollution from other tests
+    let dids = vec!["did:plc:alice_new1", "did:plc:bob_new1", "did:plc:charlie_new1"];
     let rows_inserted = workers::bulk_ensure_actors(&tx, &dids)
         .await
         .wrap_err("Failed to bulk ensure actors")?;
···
     let mut conn = pool.get().await.wrap_err("Failed to get connection")?;
     let tx = conn.transaction().await.wrap_err("Failed to start transaction")?;
 
-    // First insert
-    let dids = vec!["did:plc:alice", "did:plc:bob"];
+    // First insert - use unique DIDs to avoid cache pollution
+    let dids = vec!["did:plc:alice_existing", "did:plc:bob_existing"];
     workers::bulk_ensure_actors(&tx, &dids)
         .await
         .wrap_err("Failed to bulk ensure actors (first insert)")?;
···
     let mut conn = pool.get().await.wrap_err("Failed to get connection")?;
     let tx = conn.transaction().await.wrap_err("Failed to start transaction")?;
 
-    // First insert
-    let dids1 = vec!["did:plc:alice", "did:plc:bob"];
+    // First insert - use unique DIDs to avoid cache pollution
+    let dids1 = vec!["did:plc:alice_mixed", "did:plc:bob_mixed"];
     workers::bulk_ensure_actors(&tx, &dids1).await.wrap_err("Failed to bulk ensure actors")?;
 
     // Second insert with overlap
-    let dids2 = vec!["did:plc:bob", "did:plc:charlie"]; // bob exists, charlie is new
+    let dids2 = vec!["did:plc:bob_mixed", "did:plc:charlie_mixed"]; // bob exists, charlie is new
     let result = workers::bulk_ensure_actors(&tx, &dids2).await;
 
     assert!(