Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

32.5 KB
Raw Blame
use crate::domain::models::{
    AggregateId, FrecencyAction, FrecencyData, FrecencyEntity, FrecencyEvent,
};

use super::*;
use chrono::Utc;
use item_filters::ChatFilters;
use macro_db_migrator::MACRO_DB_MIGRATIONS;
use macro_user_id::{cowlike::CowLike, user_id::MacroUserIdStr};
use model_entity::EntityType;
use std::collections::VecDeque;

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_set_event(pool: PgPool) {
    let storage = FrecencyPgStorage::new(pool.clone());
    let test_user_id = "test_user_set_event";

    // Create a test event record
    let event = EventRecord {
        event: FrecencyEvent {
            entity: FrecencyEntity {
                user_id: Cow::Borrowed(test_user_id),
                entity: EntityType::Document.with_entity_str("doc123"),
            },
            action: FrecencyAction::Open,
        },
        timestamp: Utc::now(),
    };

    // Insert the event
    let result = storage.set_event(event).await;
    assert!(result.is_ok(), "Failed to set event: {:?}", result);

    // Verify the event was inserted
    let row = sqlx::query!(
        r#"
        SELECT user_id, entity_type, event_type, entity_id, was_processed
        FROM frecency_events
        WHERE user_id = $1 AND entity_id = $2
        "#,
        test_user_id,
        "doc123"
    )
    .fetch_one(&pool)
    .await
    .unwrap();

    assert_eq!(row.user_id, test_user_id);
    assert_eq!(row.entity_type, "document");
    assert_eq!(row.event_type, "open");
    assert_eq!(row.entity_id, "doc123");
    assert!(!row.was_processed);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_set_and_get_aggregate(pool: PgPool) {
    let storage = FrecencyPgStorage::new(pool.clone());
    let test_user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();

    // Create a test aggregate
    let mut recent_events = VecDeque::new();
    recent_events.push_back(TimestampWeight {
        timestamp: Utc::now(),
        weight: 1.0,
    });

    let aggregate = AggregateFrecency {
        id: AggregateId {
            entity: EntityType::Document.with_entity_str("doc456"),
            user_id: test_user_id.clone(),
        },
        data: FrecencyData {
            event_count: 5,
            frecency_score: 75.5,
            first_event: Utc::now(),
            recent_events,
        },
    };

    // Insert the aggregate
    let result = storage.set_aggregate(aggregate.clone()).await;
    assert!(result.is_ok(), "Failed to set aggregate: {:?}", result);

    // Retrieve the aggregate
    let retrieved = storage
        .get_top_entities(FrecencyPageRequest {
            user_id: test_user_id.copied(),
            from_score: None,
            limit: 1,
            filters: None,
        })
        .await
        .unwrap();

    let retrieved = retrieved.into_iter().next().unwrap();
    assert_eq!(retrieved.id.user_id.as_ref(), test_user_id.as_ref());
    assert_eq!(retrieved.id.entity.entity_id, "doc456");
    assert_eq!(retrieved.id.entity.entity_type, EntityType::Document);
    assert_eq!(retrieved.data.event_count, 5);
    assert_eq!(retrieved.data.frecency_score, 75.5);
    assert_eq!(retrieved.data.recent_events.len(), 1);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_update_aggregate(pool: PgPool) {
    let storage = FrecencyPgStorage::new(pool.clone());
    let test_user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();

    // Create initial aggregate
    let aggregate1 = AggregateFrecency {
        id: AggregateId {
            entity: EntityType::Chat.with_entity_str("chat789"),
            user_id: test_user_id.clone(),
        },
        data: FrecencyData {
            event_count: 3,
            frecency_score: 50.0,
            first_event: Utc::now(),
            recent_events: VecDeque::new(),
        },
    };

    storage.set_aggregate(aggregate1).await.unwrap();

    // Update with new values
    let mut updated_events = VecDeque::new();
    updated_events.push_back(TimestampWeight {
        timestamp: Utc::now(),
        weight: 2.0,
    });

    let aggregate2 = AggregateFrecency {
        id: AggregateId {
            entity: EntityType::Chat.with_entity_str("chat789"),
            user_id: test_user_id.clone(),
        },
        data: FrecencyData {
            event_count: 10,
            frecency_score: 95.0,
            first_event: Utc::now(),
            recent_events: updated_events,
        },
    };

    storage.set_aggregate(aggregate2).await.unwrap();

    // Verify the update
    let retrieved = storage
        .get_top_entities(FrecencyPageRequest {
            user_id: test_user_id.copied(),
            from_score: None,
            limit: 1,
            filters: None,
        })
        .await
        .unwrap()
        .into_iter()
        .next()
        .unwrap();

    assert_eq!(retrieved.data.event_count, 10);
    assert_eq!(retrieved.data.frecency_score, 95.0);
    assert_eq!(retrieved.data.recent_events.len(), 1);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_get_top_entities(pool: PgPool) {
    let storage = FrecencyPgStorage::new(pool.clone());
    let test_user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();

    // Create multiple aggregates with different scores
    let entities = vec![
        ("doc1", EntityType::Document, 90.0),
        ("doc2", EntityType::Document, 70.0),
        ("chat1", EntityType::Chat, 85.0),
        ("project1", EntityType::Project, 60.0),
        ("doc3", EntityType::Document, 95.0),
    ];

    for (id, entity_type, score) in entities {
        let aggregate = AggregateFrecency {
            id: AggregateId {
                entity: entity_type.with_entity_string(id.to_string()),
                user_id: test_user_id.clone(),
            },
            data: FrecencyData {
                event_count: 1,
                frecency_score: score,
                first_event: Utc::now(),
                recent_events: VecDeque::new(),
            },
        };
        storage.set_aggregate(aggregate).await.unwrap();
    }

    // Get top 3 entities
    let top_entities = storage
        .get_top_entities(FrecencyPageRequest {
            user_id: test_user_id.copied(),
            from_score: None,
            limit: 3,
            filters: None,
        })
        .await
        .unwrap();

    assert_eq!(top_entities.len(), 3);
    assert_eq!(top_entities[0].id.entity.entity_id, "doc3");
    assert_eq!(top_entities[0].data.frecency_score, 95.0);
    assert_eq!(top_entities[1].id.entity.entity_id, "doc1");
    assert_eq!(top_entities[1].data.frecency_score, 90.0);
    assert_eq!(top_entities[2].id.entity.entity_id, "chat1");
    assert_eq!(top_entities[2].data.frecency_score, 85.0);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_get_aggregate_for_user_entities(pool: PgPool) {
    let storage = FrecencyPgStorage::new(pool.clone());
    let test_user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();

    // Create multiple aggregates
    let aggregates = vec![
        ("doc1", EntityType::Document, 80.0),
        ("doc2", EntityType::Document, 70.0),
        ("chat1", EntityType::Chat, 85.0),
        ("project1", EntityType::Project, 60.0),
    ];

    for (id, entity_type, score) in &aggregates {
        let aggregate = AggregateFrecency {
            id: AggregateId {
                entity: (*entity_type).with_entity_string(id.to_string()),
                user_id: test_user_id.clone(),
            },
            data: FrecencyData {
                event_count: 1,
                frecency_score: *score,
                first_event: Utc::now(),
                recent_events: VecDeque::new(),
            },
        };
        storage.set_aggregate(aggregate).await.unwrap();
    }

    // Query for specific entities
    let entities_to_query = vec![
        EntityType::Document.with_entity_str("doc1"),
        EntityType::Chat.with_entity_str("chat1"),
        EntityType::Document.with_entity_str("doc_nonexistent"),
    ];

    let results = storage
        .get_aggregate_for_user_entities(test_user_id.into_owned(), entities_to_query.as_slice())
        .await
        .unwrap();

    // Should return 2 results (doc1 and chat1), ordered by score
    assert_eq!(results.len(), 2);
    assert_eq!(results[0].id.entity.entity_id, "chat1");
    assert_eq!(results[0].data.frecency_score, 85.0);
    assert_eq!(results[1].id.entity.entity_id, "doc1");
    assert_eq!(results[1].data.frecency_score, 80.0);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_get_top_entities_empty(pool: PgPool) {
    let storage = FrecencyPgStorage::new(pool.clone());
    let test_user_id =
        MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();

    // Get top entities for user with no data
    let top_entities = storage
        .get_top_entities(FrecencyPageRequest {
            user_id: test_user_id.copied(),
            from_score: None,
            limit: 10,
            filters: None,
        })
        .await
        .unwrap();

    assert_eq!(top_entities.len(), 0);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_get_aggregate_for_empty_entities_list(pool: PgPool) {
    let storage = FrecencyPgStorage::new(pool.clone());
    let test_user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();

    // Query with empty entities list
    let results = storage
        .get_aggregate_for_user_entities(test_user_id, &[])
        .await
        .unwrap();

    assert_eq!(results.len(), 0);
}

// Tests for FrecencyPgProcessor

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_get_top_entities_with_from_score(pool: PgPool) {
    let storage = FrecencyPgStorage::new(pool.clone());
    let test_user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();

    // Create multiple aggregates with different scores
    let entities = vec![
        ("doc1", EntityType::Document, 100.0),
        ("doc2", EntityType::Document, 80.0),
        ("chat1", EntityType::Chat, 60.0),
        ("project1", EntityType::Project, 40.0),
        ("doc3", EntityType::Document, 20.0),
    ];

    for (id, entity_type, score) in entities {
        let aggregate = AggregateFrecency {
            id: AggregateId {
                entity: entity_type.with_entity_string(id.to_string()),
                user_id: test_user_id.clone(),
            },
            data: FrecencyData {
                event_count: 1,
                frecency_score: score,
                first_event: Utc::now(),
                recent_events: VecDeque::new(),
            },
        };
        storage.set_aggregate(aggregate).await.unwrap();
    }

    // Test 1: Get all top entities without from_score
    let all_entities = storage
        .get_top_entities(FrecencyPageRequest {
            user_id: test_user_id.copied(),
            from_score: None,
            limit: 10,
            filters: None,
        })
        .await
        .unwrap();

    assert_eq!(all_entities.len(), 5);
    assert_eq!(all_entities[0].id.entity.entity_id, "doc1");
    assert_eq!(all_entities[0].data.frecency_score, 100.0);

    // Test 2: Get entities with score < 80.0 (should get 60, 40, 20)
    let filtered_entities = storage
        .get_top_entities(FrecencyPageRequest {
            user_id: test_user_id.copied(),
            from_score: Some(80.0),
            limit: 10,
            filters: None,
        })
        .await
        .unwrap();

    assert_eq!(filtered_entities.len(), 3);
    assert_eq!(filtered_entities[0].id.entity.entity_id, "chat1");
    assert_eq!(filtered_entities[0].data.frecency_score, 60.0);
    assert_eq!(filtered_entities[1].id.entity.entity_id, "project1");
    assert_eq!(filtered_entities[1].data.frecency_score, 40.0);
    assert_eq!(filtered_entities[2].id.entity.entity_id, "doc3");
    assert_eq!(filtered_entities[2].data.frecency_score, 20.0);

    // Test 3: Pagination - get top 2, then next 2
    let page1 = storage
        .get_top_entities(FrecencyPageRequest {
            user_id: test_user_id.copied(),
            from_score: None,
            limit: 2,
            filters: None,
        })
        .await
        .unwrap();

    assert_eq!(page1.len(), 2);
    assert_eq!(page1[0].data.frecency_score, 100.0);
    assert_eq!(page1[1].data.frecency_score, 80.0);

    // Use the last score from page1 to get the next page
    let last_score = page1.last().unwrap().data.frecency_score;
    let page2 = storage
        .get_top_entities(FrecencyPageRequest {
            user_id: test_user_id.copied(),
            from_score: Some(last_score),
            limit: 2,
            filters: None,
        })
        .await
        .unwrap();

    assert_eq!(page2.len(), 2);
    assert_eq!(page2[0].data.frecency_score, 60.0);
    assert_eq!(page2[1].data.frecency_score, 40.0);

    // Test 4: from_score lower than all scores (should return empty)
    let no_entities = storage
        .get_top_entities(FrecencyPageRequest {
            user_id: test_user_id.copied(),
            from_score: Some(10.0),
            limit: 10,
            filters: None,
        })
        .await
        .unwrap();

    assert_eq!(no_entities.len(), 0);

    // Test 5: from_score higher than all scores (should return all)
    let all_with_high_score = storage
        .get_top_entities(FrecencyPageRequest {
            user_id: test_user_id.copied(),
            from_score: Some(150.0),
            limit: 10,
            filters: None,
        })
        .await
        .unwrap();

    assert_eq!(all_with_high_score.len(), 5);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_processor_get_unprocessed_events(pool: PgPool) {
    let processor = FrecencyPgProcessor::new(pool.clone());
    let test_user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();

    // Insert some unprocessed events directly
    for i in 0..3 {
        sqlx::query!(
            r#"
            INSERT INTO frecency_events (
                user_id, entity_type, event_type, timestamp,
                connection_id, entity_id, was_processed
            )
            VALUES ($1, $2, $3, $4, $5, $6, false)
            "#,
            test_user_id.as_ref(),
            "document",
            "open",
            Utc::now(),
            format!("conn_{}", i),
            format!("doc_{}", i)
        )
        .execute(&pool)
        .await
        .unwrap();
    }

    // Insert a processed event (should not be returned)
    sqlx::query!(
        r#"
        INSERT INTO frecency_events (
            user_id, entity_type, event_type, timestamp,
            connection_id, entity_id, was_processed
        )
        VALUES ($1, $2, $3, $4, $5, $6, true)
        "#,
        test_user_id.as_ref(),
        "document",
        "open",
        Utc::now(),
        "conn_processed",
        "doc_processed"
    )
    .execute(&pool)
    .await
    .unwrap();

    // Get unprocessed events
    let unprocessed = processor.get_unprocessed_events().await.unwrap();

    // Should have at least our 3 unprocessed events
    assert!(unprocessed.len() >= 3);

    // Verify none are marked as processed
    let unprocessed_for_user: Vec<_> = unprocessed
        .into_iter()
        .filter(|e| e.event_record.event.entity.user_id == test_user_id.as_ref())
        .collect();

    assert_eq!(unprocessed_for_user.len(), 3);
    for event in unprocessed_for_user {
        assert!(
            event
                .event_record
                .event
                .entity
                .entity
                .entity_id
                .starts_with("doc_")
        );
    }
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_processor_mark_processed(pool: PgPool) {
    let processor = FrecencyPgProcessor::new(pool.clone());
    let test_user_id = "test_processor_mark";

    // Insert unprocessed events
    let mut event_ids = Vec::new();
    for i in 0..2 {
        let id = sqlx::query_scalar!(
            r#"
            INSERT INTO frecency_events (
                user_id, entity_type, event_type, timestamp,
                connection_id, entity_id, was_processed
            )
            VALUES ($1, $2, $3, $4, $5, $6, false)
            RETURNING id
            "#,
            test_user_id,
            "document",
            "open",
            Utc::now(),
            format!("conn_{}", i),
            format!("doc_mark_{}", i)
        )
        .fetch_one(&pool)
        .await
        .unwrap();
        event_ids.push(id);
    }

    // Claims the batch and commits; the rows are already marked processed.
    let unprocessed = processor.get_unprocessed_events().await.unwrap();

    // Filter to just our test events
    let to_mark: Vec<_> = unprocessed
        .into_iter()
        .filter(|e| event_ids.contains(&e.id))
        .collect();

    assert_eq!(to_mark.len(), 2);

    // Releases the aggregation lock; the rows were marked by the claim.
    processor.mark_processed(to_mark).await.unwrap();

    // Verify they are marked as processed in the database
    for id in event_ids {
        let was_processed = sqlx::query_scalar!(
            "SELECT was_processed FROM frecency_events WHERE id = $1",
            id
        )
        .fetch_one(&pool)
        .await
        .unwrap();

        assert!(was_processed, "Event {} should be marked as processed", id);
    }
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_processor_get_aggregates_for_users_entities(pool: PgPool) {
    let processor = FrecencyPgProcessor::new(pool.clone());
    let test_user_id: MacroUserIdStr<'static> =
        MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();

    // Insert some aggregates directly
    let aggregates_data = vec![
        ("doc_agg_1", EntityType::Document, 90.0),
        ("chat_agg_1", EntityType::Chat, 80.0),
        ("project_agg_1", EntityType::Project, 70.0),
    ];

    for (entity_id, entity_type, score) in &aggregates_data {
        sqlx::query!(
            r#"
            INSERT INTO frecency_aggregates (
                entity_id, entity_type, user_id, event_count,
                frecency_score, first_event, recent_events
            )
            VALUES ($1, $2, $3, $4, $5, $6, $7)
            "#,
            entity_id,
            entity_type.to_string(),
            test_user_id.0.as_ref(),
            5,
            score,
            Utc::now(),
            serde_json::json!([])
        )
        .execute(&pool)
        .await
        .unwrap();
    }

    // Start a transaction by getting unprocessed events
    let _ = processor.get_unprocessed_events().await.unwrap();

    // Create aggregate IDs to query
    let aggregate_ids = vec![
        AggregateId {
            entity: EntityType::Document.with_entity_str("doc_agg_1"),
            user_id: test_user_id.clone(),
        },
        AggregateId {
            entity: EntityType::Chat.with_entity_str("chat_agg_1"),
            user_id: test_user_id.clone(),
        },
        AggregateId {
            entity: EntityType::Document.with_entity_str("nonexistent"),
            user_id: test_user_id.clone(),
        },
    ];

    let retrieved = processor
        .get_aggregates_for_users_entities(aggregate_ids)
        .await
        .unwrap();

    // Should get 2 results (doc_agg_1 and chat_agg_1)
    assert_eq!(retrieved.len(), 2);

    let doc_agg = retrieved
        .iter()
        .find(|a| a.id.entity.entity_id == "doc_agg_1");
    assert!(doc_agg.is_some());
    assert_eq!(doc_agg.unwrap().data.frecency_score, 90.0);

    let chat_agg = retrieved
        .iter()
        .find(|a| a.id.entity.entity_id == "chat_agg_1");
    assert!(chat_agg.is_some());
    assert_eq!(chat_agg.unwrap().data.frecency_score, 80.0);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_processor_set_aggregates(pool: PgPool) {
    let processor = FrecencyPgProcessor::new(pool.clone());
    let test_user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();

    // Start a transaction
    let _ = processor.get_unprocessed_events().await.unwrap();

    // Create new aggregates to insert
    let mut recent_events = VecDeque::new();
    recent_events.push_back(TimestampWeight {
        timestamp: Utc::now(),
        weight: 1.5,
    });

    let aggregates = vec![
        AggregateFrecency {
            id: AggregateId {
                entity: EntityType::Document.with_entity_str("doc_set_1"),
                user_id: test_user_id.clone(),
            },
            data: FrecencyData {
                event_count: 10,
                frecency_score: 85.0,
                first_event: Utc::now(),
                recent_events: recent_events.clone(),
            },
        },
        AggregateFrecency {
            id: AggregateId {
                entity: EntityType::Chat.with_entity_str("chat_set_1"),
                user_id: test_user_id.clone(),
            },
            data: FrecencyData {
                event_count: 5,
                frecency_score: 65.0,
                first_event: Utc::now(),
                recent_events: recent_events.clone(),
            },
        },
    ];

    // Set the aggregates
    processor.set_aggregates(aggregates.clone()).await.unwrap();

    // Commit the transaction by calling mark_processed with empty list
    processor.mark_processed(vec![]).await.unwrap();

    // Verify they were inserted
    let doc_result = sqlx::query!(
        r#"
        SELECT event_count, frecency_score
        FROM frecency_aggregates
        WHERE user_id = $1 AND entity_id = $2
        "#,
        test_user_id.as_ref(),
        "doc_set_1"
    )
    .fetch_one(&pool)
    .await
    .unwrap();

    assert_eq!(doc_result.event_count, 10);
    assert_eq!(doc_result.frecency_score, 85.0);

    let chat_result = sqlx::query!(
        r#"
        SELECT event_count, frecency_score
        FROM frecency_aggregates
        WHERE user_id = $1 AND entity_id = $2
        "#,
        test_user_id.as_ref(),
        "chat_set_1"
    )
    .fetch_one(&pool)
    .await
    .unwrap();

    assert_eq!(chat_result.event_count, 5);
    assert_eq!(chat_result.frecency_score, 65.0);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_processor_set_aggregates_update_existing(pool: PgPool) {
    let processor = FrecencyPgProcessor::new(pool.clone());
    let test_user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();

    // Insert initial aggregate
    sqlx::query!(
        r#"
        INSERT INTO frecency_aggregates (
            entity_id, entity_type, user_id, event_count,
            frecency_score, first_event, recent_events
        )
        VALUES ($1, $2, $3, $4, $5, $6, $7)
        "#,
        "doc_update_1",
        "document",
        test_user_id.as_ref(),
        3,
        50.0,
        Utc::now(),
        serde_json::json!([])
    )
    .execute(&pool)
    .await
    .unwrap();

    // Start a transaction
    let _ = processor.get_unprocessed_events().await.unwrap();

    // Create updated aggregate
    let mut recent_events = VecDeque::new();
    recent_events.push_back(TimestampWeight {
        timestamp: Utc::now(),
        weight: 2.0,
    });

    let updated_aggregate = vec![AggregateFrecency {
        id: AggregateId {
            entity: EntityType::Document.with_entity_str("doc_update_1"),
            user_id: test_user_id.clone(),
        },
        data: FrecencyData {
            event_count: 15,
            frecency_score: 95.0,
            first_event: Utc::now(),
            recent_events,
        },
    }];

    // Update the aggregate
    processor.set_aggregates(updated_aggregate).await.unwrap();

    // Commit the transaction by calling mark_processed with empty list
    processor.mark_processed(vec![]).await.unwrap();

    // Verify it was updated
    let result = sqlx::query!(
        r#"
        SELECT event_count, frecency_score
        FROM frecency_aggregates
        WHERE user_id = $1 AND entity_id = $2
        "#,
        test_user_id.as_ref(),
        "doc_update_1"
    )
    .fetch_one(&pool)
    .await
    .unwrap();

    assert_eq!(result.event_count, 15);
    assert_eq!(result.frecency_score, 95.0);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_processor_set_aggregates_empty_list(pool: PgPool) {
    let processor = FrecencyPgProcessor::new(pool.clone());

    // Start a transaction
    let _ = processor.get_unprocessed_events().await.unwrap();

    // Set empty list of aggregates (should handle gracefully)
    let result = processor.set_aggregates(Vec::new()).await;
    assert!(result.is_ok());
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_processor_claim_aggregate_lifecycle(pool: PgPool) {
    let processor = FrecencyPgProcessor::new(pool.clone());
    let test_user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();

    // Insert an unprocessed event
    let event_id = sqlx::query_scalar!(
        r#"
        INSERT INTO frecency_events (
            user_id, entity_type, event_type, timestamp,
            connection_id, entity_id, was_processed
        )
        VALUES ($1, $2, $3, $4, $5, $6, false)
        RETURNING id
        "#,
        test_user_id.as_ref(),
        "document",
        "open",
        Utc::now(),
        "conn_tx",
        "doc_tx"
    )
    .fetch_one(&pool)
    .await
    .unwrap();

    // Claims the batch and commits.
    let events = processor.get_unprocessed_events().await.unwrap();
    let test_event = events.into_iter().find(|e| e.id == event_id);
    assert!(test_event.is_some());

    // Create an aggregate for the event
    let aggregate = AggregateFrecency {
        id: AggregateId {
            entity: EntityType::Document.with_entity_str("doc_tx"),
            user_id: test_user_id.clone(),
        },
        data: FrecencyData {
            event_count: 1,
            frecency_score: 100.0,
            first_event: Utc::now(),
            recent_events: VecDeque::new(),
        },
    };

    // Written on its own statement, after the claim committed.
    processor.set_aggregates(vec![aggregate]).await.unwrap();

    // Releases the aggregation lock taken by the claim.
    processor
        .mark_processed(vec![test_event.unwrap()])
        .await
        .unwrap();

    // Verify the aggregate was saved
    let saved_aggregate = sqlx::query!(
        r#"
        SELECT frecency_score
        FROM frecency_aggregates
        WHERE user_id = $1 AND entity_id = $2
        "#,
        test_user_id.as_ref(),
        "doc_tx"
    )
    .fetch_one(&pool)
    .await
    .unwrap();

    assert_eq!(saved_aggregate.frecency_score, 100.0);

    // Verify event is marked as processed
    let was_processed = sqlx::query_scalar!(
        "SELECT was_processed FROM frecency_events WHERE id = $1",
        event_id
    )
    .fetch_one(&pool)
    .await
    .unwrap();

    assert!(was_processed);
}

/// An idle queue must not strand the aggregation lock.
///
/// The pass still takes the lock before discovering there is nothing to claim,
/// so it has to be closed out by mark_processed like any other. Otherwise the
/// lock would sit held until the next tick cleaned it up -- once per poll, on
/// every replica, for as long as the queue stays empty.
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn an_empty_batch_still_releases_the_aggregation_lock(pool: PgPool) {
    let first = FrecencyPgProcessor::new(pool.clone());
    let second = FrecencyPgProcessor::new(pool);

    // No events inserted: the claim finds nothing.
    let events = first.get_unprocessed_events().await.unwrap();
    assert!(events.is_empty());

    // The lock was taken regardless, so the second poller is still shut out.
    let err = second.get_unprocessed_events().await.unwrap_err();
    assert!(matches!(err, PollerErr::DbLockErr), "got {err:?}");

    // Closing out the empty pass releases it.
    first.mark_processed(Vec::new()).await.unwrap();
    let res = second.get_unprocessed_events().await.unwrap();
    assert!(res.is_empty());
}

/// The aggregate lookup renders its filter with `push_tuples`, which emits a
/// bare `IN ()` for an empty batch. Callers should short-circuit before here,
/// but the method must not turn "nothing to look up" into a syntax error.
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn empty_aggregate_lookup_returns_empty_rather_than_failing(pool: PgPool) {
    let processor = FrecencyPgProcessor::new(pool);
    let res = processor
        .get_aggregates_for_users_entities(Vec::new())
        .await
        .expect("an empty lookup must not be a syntax error");
    assert!(res.is_empty());
}

/// Only one poller may aggregate at a time.
///
/// Disjoint event batches can still merge into the same aggregate key, and
/// set_aggregates blind-overwrites that row, so two concurrent passes would
/// lose one of their contributions. The second poller must be turned away
/// while the first holds the lock, and admitted once it releases.
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn a_second_poller_is_locked_out_until_the_first_finishes(pool: PgPool) {
    let test_user_id = "test_processor_claim_is_exclusive";
    // Insert an unprocessed event
    let event_id = sqlx::query_scalar!(
        r#"
        INSERT INTO frecency_events (
            user_id, entity_type, event_type, timestamp,
            connection_id, entity_id, was_processed
        )
        VALUES ($1, $2, $3, $4, $5, $6, false)
        RETURNING id
        "#,
        test_user_id,
        "document",
        "open",
        Utc::now(),
        "conn_tx",
        "doc_tx"
    )
    .fetch_one(&pool)
    .await
    .unwrap();

    let pool_handle = pool.clone();
    let first = FrecencyPgProcessor::new(pool.clone());
    let second = FrecencyPgProcessor::new(pool);

    let events = first.get_unprocessed_events().await.unwrap();
    assert_eq!(events.len(), 1);
    assert_eq!(events.first().unwrap().id, event_id);

    // The first poller holds the aggregation lock across its whole pass, so
    // the second must not be allowed to read-modify-write concurrently.
    let err = second.get_unprocessed_events().await.unwrap_err();
    assert!(
        matches!(err, PollerErr::DbLockErr),
        "second poller should be locked out, got {err:?}"
    );

    // The claim itself already marked the row, independent of the lock.
    let was_processed = sqlx::query_scalar!(
        r#"SELECT was_processed AS "was_processed!" FROM frecency_events WHERE id = $1"#,
        event_id
    )
    .fetch_one(&pool_handle)
    .await
    .unwrap();
    assert!(was_processed);

    // Ending the first pass releases the lock and lets the second in; there
    // is simply nothing left for it to claim.
    first.mark_processed(Vec::new()).await.unwrap();
    let res = second.get_unprocessed_events().await.unwrap();
    assert!(res.is_empty());
}

/// Tests that mixing supported (chat_id) and unsupported (role) filters
/// does not produce malformed SQL. Role filters don't apply to frecency
/// aggregates and should be ignored without breaking the query.
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn test_get_top_entities_mixed_supported_and_unsupported_chat_filters(pool: PgPool) {
    use item_filters::{EntityFilters, ast::EntityFilterAst};

    let storage = FrecencyPgStorage::new(pool.clone());
    let test_user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();

    // Create a chat aggregate
    let chat_id = "11111111-1111-1111-1111-111111111111";
    let aggregate = AggregateFrecency {
        id: AggregateId {
            entity: EntityType::Chat.with_entity_string(chat_id.to_string()),
            user_id: test_user_id.clone(),
        },
        data: FrecencyData {
            event_count: 5,
            frecency_score: 75.0,
            first_event: Utc::now(),
            recent_events: VecDeque::new(),
        },
    };
    storage.set_aggregate(aggregate).await.unwrap();

    // Create filter with both chat_id (supported) and role (unsupported at frecency level)
    // This combination previously produced malformed SQL like "( AND entity_id = '...')"
    let entity_filters = EntityFilters {
        chat_filters: ChatFilters {
            chat_ids: vec![chat_id.to_string()],
            role: vec!["user".to_string()],
            ..Default::default()
        },
        ..Default::default()
    };

    let filter = EntityFilterAst::new_from_filters(entity_filters)
        .unwrap()
        .unwrap();

    // This should not fail with a SQL syntax error
    let results = storage
        .get_top_entities(FrecencyPageRequest {
            user_id: test_user_id.copied(),
            from_score: None,
            limit: 10,
            filters: Some(filter),
        })
        .await
        .unwrap();

    // Should still filter by the supported chat_id filter
    assert_eq!(results.len(), 1, "Should return exactly one chat");
    assert_eq!(
        results[0].id.entity.entity_id, chat_id,
        "Should return the correct chat"
    );
}