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.

27.1 KB
Raw Blame
use super::*;
use ai_usage::outbound::PgUsageRepo;
use ai_usage::{
    AiFeature, CompletionUsage, ModelPricing, Price, Usage, UsageAmount, UsageApiParams, UsageRepo,
};
use chrono::{Duration, Utc};
use macro_db_migrator::MACRO_DB_MIGRATIONS;

fn completion(
    user: MacroUserIdStr<'static>,
    feature: AiFeature,
    provider_cost_usd: f32,
) -> CompletionUsage {
    CompletionUsage {
        feature,
        user,
        entity: None,
        agent_api_key_id: None,
        cost: Usage {
            amount: UsageAmount::Tokens {
                input: 1_000_000,
                output: 0,
                cache_read: 0,
                cache_write: 0,
            },
            model: "test-model".to_string(),
            price: Some(Price {
                pricing: ModelPricing::Tokens {
                    input: provider_cost_usd,
                    output: 0.0,
                    cache_read: None,
                    cache_write: None,
                },
                total: provider_cost_usd,
            }),
            created_at: Utc::now(),
        },
    }
}

fn free_completions(user: MacroUserIdStr<'static>) -> [CompletionUsage; 4] {
    let mut dictation = completion(user.clone(), AiFeature::Dictation, 8.0);
    dictation.cost.model = "test-audio-model".to_string();
    dictation.cost.amount = UsageAmount::Audio {
        duration: std::time::Duration::from_secs(60),
    };
    dictation.cost.price = Some(Price {
        pricing: ModelPricing::Audio { per_minute: 8.0 },
        total: 8.0,
    });
    [
        completion(user.clone(), AiFeature::Memory, 8.0),
        completion(user.clone(), AiFeature::AiProjection, 8.0),
        completion(user, AiFeature::CallSummary, 8.0),
        dictation,
    ]
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn aggregates_only_persisted_counted_rows_for_requested_seats(pool: PgPool) {
    let first = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    let second = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    let outside = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    let empty = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    let repo = PgUsageRepo::new(pool.clone());
    for (user, total, counted) in [
        (&first, 1.0, true),
        (&first, 3.0, true),
        (&first, 100.0, false),
        (&second, 2.0, true),
        (&second, 200.0, false),
        (&outside, 300.0, true),
        (&empty, 400.0, false),
    ] {
        repo.insert_usage(&completion(user.clone(), AiFeature::Chat, total), counted)
            .await
            .unwrap();
    }
    // The stored decision, not today's feature classification, is authoritative.
    repo.insert_usage(&completion(second.clone(), AiFeature::Memory, 1.0), true)
        .await
        .unwrap();
    let mut unpriced = completion(second.clone(), AiFeature::Chat, 0.0);
    unpriced.cost.price = None;
    unpriced.cost.amount = UsageAmount::Tokens {
        input: 1_000_000,
        output: 1_000_000,
        cache_read: 0,
        cache_write: 0,
    };
    repo.insert_usage(&unpriced, true).await.unwrap(); // $5 input + $25 output
    repo.insert_usage(&unpriced, false).await.unwrap();

    // A default-false legacy write must never acquire debt via fallback pricing.
    sqlx::query!(
        r#"INSERT INTO ai_usage (id, feature, user_id, model, input_tokens, output_tokens)
           VALUES ($1, 'chat', $2, 'legacy-model', 1000000, 1000000)"#,
        macro_uuid::generate_uuid_v7(),
        first.as_ref(),
    )
    .execute(&pool)
    .await
    .unwrap();

    let reader = PgUsageReader::new(pool);
    let mut usage = reader
        .usage_cost_cents_by_user(&[first.clone(), second.clone(), empty], current_period())
        .await
        .unwrap();
    usage.sort_by(|a, b| a.user.as_ref().cmp(b.user.as_ref()));
    assert_eq!(
        usage,
        vec![
            SeatUsage {
                user: first.clone(),
                used_cents: 400,
                chargeable_cost_cents: None,
            },
            SeatUsage {
                user: second,
                used_cents: 3_300,
                chargeable_cost_cents: None,
            },
        ]
    );
    assert!(
        reader
            .usage_cost_cents_by_user(&[], current_period())
            .await
            .unwrap()
            .is_empty()
    );
    assert_eq!(
        reader
            .usage_cost_cents_by_user(std::slice::from_ref(&first), current_period())
            .await
            .unwrap(),
        vec![SeatUsage {
            user: first,
            used_cents: 400,
            chargeable_cost_cents: None,
        }]
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn billing_period_includes_start_and_excludes_end(pool: PgPool) {
    let user = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    let start = chrono::DateTime::from_timestamp(1_800_000_000, 0).unwrap();
    let end = start + Duration::days(30);
    for (created_at, count_usage) in [
        (start - Duration::microseconds(1), true),
        (start, true),
        (end - Duration::microseconds(1), true),
        (end, true),
        (end + Duration::microseconds(1), true),
        (start, false),
    ] {
        sqlx::query!(
            r#"INSERT INTO ai_usage (id, feature, user_id, model, input_tokens, output_tokens,
                                    total, created_at, count_usage)
               VALUES ($1, 'chat', $2, 'test-model', 0, 0, 1.0, $3, $4)"#,
            macro_uuid::generate_uuid_v7(),
            user.as_ref(),
            created_at,
            count_usage,
        )
        .execute(&pool)
        .await
        .unwrap();
    }
    let usage = PgUsageReader::new(pool)
        .usage_cost_cents_by_user(std::slice::from_ref(&user), BillingPeriod { start, end })
        .await
        .unwrap();
    assert_eq!(
        usage,
        vec![SeatUsage {
            user,
            used_cents: 200,
            chargeable_cost_cents: None,
        }]
    );
}

fn current_period() -> BillingPeriod {
    let now = Utc::now();
    BillingPeriod {
        start: now - Duration::minutes(1),
        end: now + Duration::minutes(1),
    }
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn free_features_are_recorded_but_only_chat_and_editing_are_metered(pool: PgPool) {
    let user = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    let usage_repo = PgUsageRepo::new(pool.clone());
    for (usage, count_usage) in free_completions(user.clone())
        .into_iter()
        .map(|usage| (usage, false))
        .chain([
            (completion(user.clone(), AiFeature::Chat, 4.0), true),
            (completion(user.clone(), AiFeature::AiEditing, 2.0), true),
        ])
    {
        usage_repo.insert_usage(&usage, count_usage).await.unwrap();
    }

    let stored_usage = usage_repo
        .query_usage(&UsageApiParams {
            include_users: vec![user.clone()],
            ..Default::default()
        })
        .await
        .unwrap();
    assert_eq!(stored_usage.len(), 6);
    assert!(
        stored_usage
            .iter()
            .all(|usage| { usage.cost.price.is_some_and(|price| price.total > 0.0) })
    );
    let mut stored_features: Vec<_> = stored_usage.iter().map(|usage| usage.feature).collect();
    stored_features.sort();
    let mut expected_features = vec![
        AiFeature::Chat,
        AiFeature::Memory,
        AiFeature::CallSummary,
        AiFeature::AiProjection,
        AiFeature::AiEditing,
        AiFeature::Dictation,
    ];
    expected_features.sort();
    assert_eq!(stored_features, expected_features);

    let usage = PgUsageReader::new(pool)
        .usage_cost_cents_by_user(std::slice::from_ref(&user), current_period())
        .await
        .unwrap();

    assert_eq!(
        usage,
        vec![SeatUsage {
            user,
            used_cents: 600,
            chargeable_cost_cents: None,
        }]
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn free_features_alone_do_not_produce_billable_usage(pool: PgPool) {
    let user = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    let usage_repo = PgUsageRepo::new(pool.clone());
    for usage in free_completions(user.clone()) {
        usage_repo.insert_usage(&usage, false).await.unwrap();
    }

    let usage = PgUsageReader::new(pool)
        .usage_cost_cents_by_user(&[user], current_period())
        .await
        .unwrap();
    assert!(usage.is_empty());
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn unpriced_free_features_are_excluded_from_fallback_billing(pool: PgPool) {
    let user = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    let usage_repo = PgUsageRepo::new(pool.clone());
    for (mut usage, count_usage) in free_completions(user.clone())
        .into_iter()
        .map(|usage| (usage, false))
        .chain([
            (completion(user.clone(), AiFeature::Chat, 4.0), true),
            (completion(user.clone(), AiFeature::AiEditing, 2.0), true),
        ])
    {
        usage.cost.price = None;
        usage_repo.insert_usage(&usage, count_usage).await.unwrap();
    }

    let usage = PgUsageReader::new(pool)
        .usage_cost_cents_by_user(std::slice::from_ref(&user), current_period())
        .await
        .unwrap();

    // Chat and editing each fall back to $5 per million input tokens, counted
    // at cost. Unpriced free features add nothing.
    assert_eq!(
        usage,
        vec![SeatUsage {
            user,
            used_cents: 1_000,
            chargeable_cost_cents: None,
        }]
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn priced_cache_tokens_count_through_the_stored_total(pool: PgPool) {
    let user = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    let amount = UsageAmount::Tokens {
        input: 1_000_000,
        output: 0,
        cache_read: 1_000_000,
        cache_write: 1_000_000,
    };
    PgUsageRepo::new(pool.clone())
        .insert_usage(
            &CompletionUsage {
                feature: AiFeature::Chat,
                user: user.clone(),
                entity: None,
                agent_api_key_id: None,
                cost: Usage {
                    amount,
                    model: "claude-opus-5".to_string(),
                    price: Price::compute(
                        ModelPricing::Tokens {
                            input: 5.0,
                            output: 25.0,
                            cache_read: Some(0.5),
                            cache_write: Some(6.25),
                        },
                        amount,
                    ),
                    created_at: Utc::now(),
                },
            },
            true,
        )
        .await
        .unwrap();

    let usage = PgUsageReader::new(pool)
        .usage_cost_cents_by_user(std::slice::from_ref(&user), current_period())
        .await
        .unwrap();

    // $5 input + $0.50 cache read + $6.25 cache write.
    assert_eq!(
        usage,
        vec![SeatUsage {
            user,
            used_cents: 1_175,
            chargeable_cost_cents: None,
        }]
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn unpriced_cache_tokens_fall_back_to_the_opus_5_cache_rates(pool: PgPool) {
    let user = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    PgUsageRepo::new(pool.clone())
        .insert_usage(
            &CompletionUsage {
                feature: AiFeature::Chat,
                user: user.clone(),
                entity: None,
                agent_api_key_id: None,
                cost: Usage {
                    amount: UsageAmount::Tokens {
                        input: 1_000_000,
                        output: 0,
                        cache_read: 1_000_000,
                        cache_write: 1_000_000,
                    },
                    model: "unpriced-cache-model".to_string(),
                    price: None,
                    created_at: Utc::now(),
                },
            },
            true,
        )
        .await
        .unwrap();

    let usage = PgUsageReader::new(pool)
        .usage_cost_cents_by_user(std::slice::from_ref(&user), current_period())
        .await
        .unwrap();

    // $5 input + $0.50 cache read + $6.25 cache write at the Opus 5 rates.
    assert_eq!(
        usage,
        vec![SeatUsage {
            user,
            used_cents: 1_175,
            chargeable_cost_cents: None,
        }]
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn upgrade_resets_only_the_seat_and_replays_preserve_new_usage(pool: PgPool) {
    use crate::domain::AiPricing;
    use crate::outbound::PgBillingRepo;
    let first = MacroUserIdStr::try_from("macro|[email protected]").unwrap();
    let second = MacroUserIdStr::try_from("macro|[email protected]").unwrap();
    let period = current_period();
    let at = Utc::now();
    for user in [&first, &second] {
        let mut usage = completion(user.clone(), AiFeature::Chat, 15.0);
        usage.cost.created_at = at - Duration::seconds(1);
        insert_upgrade_usage(&pool, &usage).await;
    }
    let billing = PgBillingRepo::new(pool.clone(), AiPricing::testing());
    billing
        .reset_usage(
            &first,
            period.start,
            at,
            Some(2_000),
            crate::domain::PlanTier::Max,
        )
        .await
        .unwrap();
    let reader = PgUsageReader::new(pool.clone());
    assert!(
        reader
            .usage_cost_cents_by_user(std::slice::from_ref(&first), period)
            .await
            .unwrap()
            .is_empty()
    );
    assert_eq!(
        reader
            .usage_cost_cents_by_user(std::slice::from_ref(&second), period)
            .await
            .unwrap()[0]
            .used_cents,
        1_500
    );
    let mut new_usage = completion(first.clone(), AiFeature::Chat, 2.0);
    new_usage.cost.created_at = at; // Reset includes the boundary instant.
    insert_upgrade_usage(&pool, &new_usage).await;
    for _ in 0..2 {
        billing
            .reset_usage(
                &first,
                period.start,
                at,
                Some(2_000),
                crate::domain::PlanTier::Max,
            )
            .await
            .unwrap();
        assert_eq!(
            reader
                .usage_cost_cents_by_user(std::slice::from_ref(&first), period)
                .await
                .unwrap()[0]
                .used_cents,
            200
        );
    }
    // Audit history and stored counting decisions are untouched.
    assert_eq!(
        PgUsageRepo::new(pool.clone())
            .query_usage(&UsageApiParams {
                include_users: vec![first.clone()],
                ..Default::default()
            })
            .await
            .unwrap()
            .len(),
        2
    );
    let next = BillingPeriod {
        start: period.end,
        end: period.end + Duration::days(30),
    };
    new_usage.cost.created_at = next.start;
    insert_upgrade_usage(&pool, &new_usage).await;
    assert_eq!(
        reader
            .usage_cost_cents_by_user(std::slice::from_ref(&first), next)
            .await
            .unwrap()[0]
            .used_cents,
        200
    );
    // A replay with a newer timestamp cannot replenish an already held Max plan.
    billing
        .reset_usage(
            &first,
            period.start,
            at + Duration::seconds(1),
            Some(2_000),
            crate::domain::PlanTier::Max,
        )
        .await
        .unwrap();
    assert_eq!(
        reader
            .usage_cost_cents_by_user(std::slice::from_ref(&first), period)
            .await
            .unwrap()
            .first()
            .unwrap()
            .used_cents,
        200
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn reset_preserves_prior_overage_without_reusing_spent_credits(pool: PgPool) {
    use crate::domain::AiPricing;
    use crate::outbound::PgBillingRepo;
    let user = MacroUserIdStr::try_from("macro|[email protected]").unwrap();
    let period = current_period();
    let at = Utc::now();
    let mut usage = completion(user.clone(), AiFeature::Chat, 22.0);
    usage.cost.created_at = at - Duration::seconds(1);
    insert_upgrade_usage(&pool, &usage).await;
    let billing = PgBillingRepo::new(pool.clone(), AiPricing::testing());
    billing
        .reset_usage(
            &user,
            period.start,
            at,
            Some(2_000),
            crate::domain::PlanTier::Max,
        )
        .await
        .unwrap();
    let reader = PgUsageReader::new(pool.clone());
    let position = reader
        .usage_cost_cents_by_user(std::slice::from_ref(&user), period)
        .await
        .unwrap();
    assert_eq!(position[0].used_cents, 0);
    assert_eq!(position[0].chargeable_cost_cents, Some(200));
    usage.cost.created_at = at;
    usage.cost.price.as_mut().unwrap().total = 105.0;
    insert_upgrade_usage(&pool, &usage).await;
    let position = reader
        .usage_cost_cents_by_user(std::slice::from_ref(&user), period)
        .await
        .unwrap();
    assert_eq!(position[0].used_cents, 10_500);
    assert_eq!(position[0].chargeable_cost_cents, Some(700));
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn free_upgrade_discards_usage_without_creating_billable_overage(pool: PgPool) {
    use crate::domain::AiPricing;
    use crate::outbound::PgBillingRepo;
    let user = MacroUserIdStr::try_from("macro|[email protected]").unwrap();
    let period = current_period();
    let at = Utc::now();
    let mut usage = completion(user.clone(), AiFeature::Chat, 22.0);
    usage.cost.created_at = at - Duration::seconds(1);
    insert_upgrade_usage(&pool, &usage).await;
    PgBillingRepo::new(pool.clone(), AiPricing::testing())
        .reset_usage(
            &user,
            period.start,
            at,
            None,
            crate::domain::PlanTier::Premium,
        )
        .await
        .unwrap();
    let reader = PgUsageReader::new(pool.clone());
    assert!(
        reader
            .usage_cost_cents_by_user(std::slice::from_ref(&user), period)
            .await
            .unwrap()
            .is_empty()
    );
    usage.cost.created_at = at;
    usage.cost.price.as_mut().unwrap().total = 2.0;
    insert_upgrade_usage(&pool, &usage).await;
    let position = reader
        .usage_cost_cents_by_user(std::slice::from_ref(&user), period)
        .await
        .unwrap();
    assert_eq!(position[0].used_cents, 200);
    assert_eq!(position[0].chargeable_cost_cents, Some(0));
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn sequential_free_pro_max_upgrades_do_not_double_bill_public_funded_usage(pool: PgPool) {
    use crate::domain::{AiPricing, PlanTier};
    use crate::outbound::PgBillingRepo;
    let user = MacroUserIdStr::try_from("macro|[email protected]").unwrap();
    let period = current_period();
    let at = Utc::now();
    let billing = PgBillingRepo::new(pool.clone(), AiPricing::testing());
    sqlx::query!(
        "INSERT INTO ai_billing_account (user_id) VALUES ($1)",
        user.as_ref()
    )
    .execute(&pool)
    .await
    .unwrap();
    sqlx::query!("INSERT INTO ai_billing_usage_period (user_id, payer_id, subscription_id, period_start, period_end, policy) VALUES ($1, $1, 'sub_test', $2, $3, 'public_allowance_v1')", user.as_ref(), period.start, period.end).execute(&pool).await.unwrap();
    billing
        .reset_usage(
            &user,
            period.start,
            at - Duration::seconds(2),
            None,
            PlanTier::Premium,
        )
        .await
        .unwrap();
    let mut usage = completion(user.clone(), AiFeature::Chat, 22.0);
    usage.cost.created_at = at - Duration::seconds(1);
    insert_upgrade_usage(&pool, &usage).await;
    billing
        .reset_usage(&user, period.start, at, Some(2_000), PlanTier::Max)
        .await
        .unwrap();
    let reader = PgUsageReader::new(pool.clone());
    assert!(
        reader
            .usage_cost_cents_by_user(std::slice::from_ref(&user), period)
            .await
            .unwrap()
            .is_empty()
    );
    usage.cost.created_at = at;
    usage.cost.price.as_mut().unwrap().total = 2.0;
    insert_upgrade_usage(&pool, &usage).await;
    let position = reader
        .usage_cost_cents_by_user(std::slice::from_ref(&user), period)
        .await
        .unwrap();
    assert_eq!(position[0].used_cents, 200);
    assert_eq!(position[0].chargeable_cost_cents, Some(0));
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn batched_usage_preserves_each_change_at_a_shared_boundary(pool: PgPool) {
    use crate::domain::{AiPricing, BillingRepo, PlanTier};
    use crate::outbound::PgBillingRepo;

    let upgraded = MacroUserIdStr::try_from("macro|[email protected]").unwrap();
    let unchanged = MacroUserIdStr::try_from("macro|[email protected]").unwrap();
    let empty = MacroUserIdStr::try_from("macro|[email protected]").unwrap();
    let outside = MacroUserIdStr::try_from("macro|[email protected]").unwrap();
    let period = current_period();
    let at = period.start + Duration::seconds(10);
    let billing = PgBillingRepo::new(pool.clone(), AiPricing::testing());

    // Insert in reverse order: both transitions must survive the shared boundary,
    // and neither may turn the earlier Free usage into paid overage.
    for (from, to, old, new) in [
        (PlanTier::Premium, PlanTier::Max, Some(2_000), 10_000),
        (PlanTier::Free, PlanTier::Premium, None, 2_000),
    ] {
        billing
            .record_plan_change(
                &upgraded,
                RecordedPlanChange {
                    change: PlanChange {
                        from,
                        to,
                        at,
                        period,
                    },
                    previous_included_cents: old,
                    new_included_cents: Some(new),
                },
            )
            .await
            .unwrap();
    }
    billing
        .reset_usage(&empty, period.start, at, None, PlanTier::Premium)
        .await
        .unwrap();
    for (user, total, created_at) in [
        (&upgraded, 22.0, at - Duration::seconds(1)),
        (&upgraded, 25.0, at),
        (&unchanged, 1.0, at),
        (&outside, 100.0, at),
    ] {
        let mut usage = completion(user.clone(), AiFeature::Chat, total);
        usage.cost.created_at = created_at;
        insert_upgrade_usage(&pool, &usage).await;
    }

    let mut usage = PgUsageReader::new(pool)
        .usage_cost_cents_by_user(&[unchanged.clone(), empty, upgraded.clone()], period)
        .await
        .unwrap();
    usage.sort_by(|a, b| a.user.as_ref().cmp(b.user.as_ref()));
    assert_eq!(
        usage,
        vec![
            SeatUsage {
                user: unchanged,
                used_cents: 100,
                chargeable_cost_cents: None,
            },
            SeatUsage {
                user: upgraded,
                used_cents: 2_500,
                chargeable_cost_cents: Some(0),
            },
        ]
    );
}

// PgUsageRepo timestamps writes with the database clock. Explicitly locate this
// fixture's newest row on either side of the upgrade instead of relying on sleeps.
async fn insert_upgrade_usage(pool: &PgPool, usage: &CompletionUsage) {
    PgUsageRepo::new(pool.clone())
        .insert_usage(usage, true)
        .await
        .unwrap();
    sqlx::query!("UPDATE ai_usage SET created_at = $2 WHERE id = (SELECT id FROM ai_usage WHERE user_id = $1 ORDER BY created_at DESC, id DESC LIMIT 1)", usage.user.as_ref(), usage.cost.created_at).execute(pool).await.unwrap();
}

trait UpgradeFixture {
    async fn reset_usage(
        &self,
        user: &MacroUserIdStr<'_>,
        start: chrono::DateTime<Utc>,
        at: chrono::DateTime<Utc>,
        previous: Option<i64>,
        to: crate::domain::PlanTier,
    ) -> crate::domain::Result<()>;
}
impl UpgradeFixture for crate::outbound::PgBillingRepo {
    async fn reset_usage(
        &self,
        user: &MacroUserIdStr<'_>,
        start: chrono::DateTime<Utc>,
        at: chrono::DateTime<Utc>,
        previous: Option<i64>,
        to: crate::domain::PlanTier,
    ) -> crate::domain::Result<()> {
        use crate::domain::{BillingRepo, PlanTier};
        self.record_plan_change(
            user,
            crate::domain::plan_change::RecordedPlanChange {
                change: crate::domain::plan_change::PlanChange {
                    from: if previous.is_some() {
                        PlanTier::Premium
                    } else {
                        PlanTier::Free
                    },
                    to,
                    at,
                    period: crate::domain::BillingPeriod {
                        start,
                        end: start + chrono::Duration::days(30),
                    },
                },
                previous_included_cents: previous,
                new_included_cents: Some(if to == PlanTier::Max { 10_000 } else { 2_000 }),
            },
        )
        .await
    }
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn delayed_plan_cycle_retains_max_consumption_without_creating_downgrade_debt(pool: PgPool) {
    use crate::domain::plan_change::{PlanChange, RecordedPlanChange};
    use crate::domain::{AiPricing, BillingRepo, PlanTier};
    let user = MacroUserIdStr::try_from("macro|[email protected]").unwrap();
    let period = current_period();
    let at = Utc::now();
    let mut usage = completion(user.clone(), AiFeature::Chat, 80.0);
    usage.cost.created_at = at - Duration::seconds(1);
    insert_upgrade_usage(&pool, &usage).await;
    let billing = crate::outbound::PgBillingRepo::new(pool.clone(), AiPricing::testing());
    // The later event arrives first; readers use occurrence order, not insertion order.
    for (from, to, stamp, old, new) in [
        (
            PlanTier::Premium,
            PlanTier::Max,
            at + Duration::seconds(1),
            2_000,
            10_000,
        ),
        (PlanTier::Max, PlanTier::Premium, at, 10_000, 2_000),
    ] {
        let change = RecordedPlanChange {
            change: PlanChange {
                from,
                to,
                at: stamp,
                period,
            },
            previous_included_cents: Some(old),
            new_included_cents: Some(new),
        };
        billing.record_plan_change(&user, change).await.unwrap();
        billing.record_plan_change(&user, change).await.unwrap();
    }
    let reader = PgUsageReader::new(pool.clone());
    let position = reader
        .usage_cost_cents_by_user(std::slice::from_ref(&user), period)
        .await
        .unwrap();
    assert_eq!(position[0].used_cents, 8_000);
    assert_eq!(position[0].chargeable_cost_cents, Some(0));
    usage.cost.created_at = at + Duration::seconds(2);
    usage.cost.price.as_mut().unwrap().total = 25.0;
    insert_upgrade_usage(&pool, &usage).await;
    let position = reader
        .usage_cost_cents_by_user(std::slice::from_ref(&user), period)
        .await
        .unwrap();
    assert_eq!(position[0].used_cents, 10_500);
    assert_eq!(position[0].chargeable_cost_cents, Some(500));
}