#![allow(missing_docs)]
#![cfg(feature = "sqlite-tests")]
#[path = "support/backend_cases.rs"]
mod backend_cases;
use keepsake::ExpiryPolicy;
use keepsake_sqlx::{RepositoryError, SqliteKeepsakeRepository};
use sqlx::sqlite::SqlitePoolOptions;
use uuid::Uuid;
use backend_cases::{BackendHarness, TestResult, upsert_relation};
struct SqliteHarness;
#[async_trait::async_trait]
impl BackendHarness for SqliteHarness {
const BACKEND: &'static str = "sqlite";
type Pool = sqlx::SqlitePool;
type Repo = SqliteKeepsakeRepository;
async fn repo() -> TestResult<(Self::Repo, Self::Pool)> {
let pool = SqlitePoolOptions::new()
.max_connections(1)
.connect("sqlite::memory:")
.await?;
let repo = SqliteKeepsakeRepository::new(pool.clone());
repo.migrate().await?;
Ok((repo, pool))
}
async fn backend_marker(pool: &Self::Pool) -> Result<String, sqlx::Error> {
sqlx::query_scalar("select value from keepsake_schema_metadata where key = 'backend'")
.fetch_one(pool)
.await
}
async fn upsert_relation(
repo: &Self::Repo,
relation: &keepsake::RelationDefinition,
at: chrono::DateTime<chrono::Utc>,
) -> Result<keepsake::RelationDefinition, RepositoryError> {
repo.upsert_relation(relation, at).await
}
async fn apply(
repo: &Self::Repo,
command: &keepsake::ApplyKeepsake,
) -> Result<keepsake_sqlx::AppliedKeepsake, RepositoryError> {
repo.apply(command).await
}
async fn active_relations_for_subject(
repo: &Self::Repo,
subject: &keepsake::SubjectRef,
) -> Result<Vec<keepsake_sqlx::ActiveRelation>, RepositoryError> {
repo.active_relations_for_subject(subject).await
}
async fn active_for_subject(
repo: &Self::Repo,
subject: &keepsake::SubjectRef,
) -> Result<Vec<keepsake::Keepsake>, RepositoryError> {
repo.active_for_subject(subject).await
}
async fn expire_due_timed(
repo: &Self::Repo,
now: chrono::DateTime<chrono::Utc>,
limit: i64,
) -> Result<u64, RepositoryError> {
repo.expire_due_timed(now, limit).await
}
async fn upsert_counter_projection(
repo: &Self::Repo,
keepsake_id: Uuid,
key: &str,
value: i64,
observed_at: chrono::DateTime<chrono::Utc>,
) -> Result<(), RepositoryError> {
repo.upsert_counter_projection(keepsake_id, key, value, observed_at)
.await
}
async fn expire_due_fulfilled(
repo: &Self::Repo,
now: chrono::DateTime<chrono::Utc>,
limit: i64,
) -> Result<u64, RepositoryError> {
repo.expire_due_fulfilled(now, limit).await
}
}
#[tokio::test]
async fn sqlite_migration_initializes_backend_marker() -> TestResult<()> {
backend_cases::migration_initializes_backend_marker::<SqliteHarness>().await
}
#[tokio::test]
async fn sqlite_apply_duplicate_and_active_read() -> TestResult<()> {
backend_cases::apply_duplicate_and_active_read::<SqliteHarness>().await
}
#[tokio::test]
async fn sqlite_timed_expiry_expires_due_keepsake() -> TestResult<()> {
backend_cases::timed_expiry_expires_due_keepsake::<SqliteHarness>().await
}
#[tokio::test]
async fn sqlite_lifecycle_invariants_reject_invalid_rows() -> TestResult<()> {
let (repo, pool) = SqliteHarness::repo().await?;
let relation = upsert_relation::<SqliteHarness>(&repo, ExpiryPolicy::ManualOnly).await?;
let result = sqlx::query(
r"
insert into keepsakes
(id, subject_kind, subject_id, relation_id, state, expiry_policy, applied_at,
expires_at, fulfilled_at, revoked_at, metadata, created_at, updated_at)
values (?1, 'account', 'invalid', ?2, 'applied', ?3, ?4, null, null, ?4, '{}', ?4, ?4)
",
)
.bind(Uuid::now_v7().to_string())
.bind(relation.id.to_string())
.bind(serde_json::to_string(&ExpiryPolicy::ManualOnly)?)
.bind("2026-01-01T00:00:00.000000Z")
.execute(&pool)
.await;
assert!(matches!(result, Err(sqlx::Error::Database(_))));
Ok(())
}
#[tokio::test]
async fn sqlite_lifecycle_invariants_reject_malformed_policy_rows() -> TestResult<()> {
let (repo, pool) = SqliteHarness::repo().await?;
let relation = upsert_relation::<SqliteHarness>(&repo, ExpiryPolicy::ManualOnly).await?;
let result = sqlx::query(
r"
insert into keepsakes
(id, subject_kind, subject_id, relation_id, state, expiry_policy, applied_at,
expires_at, fulfilled_at, revoked_at, metadata, created_at, updated_at)
values (?1, 'account', 'malformed', ?2, 'applied', '{}', ?3, null, null, null, '{}', ?3, ?3)
",
)
.bind(Uuid::now_v7().to_string())
.bind(relation.id.to_string())
.bind("2026-01-01T00:00:00.000000Z")
.execute(&pool)
.await;
assert!(matches!(result, Err(sqlx::Error::Database(_))));
Ok(())
}
#[tokio::test]
async fn sqlite_projection_invariant_rejects_fractional_expiry_mismatch() -> TestResult<()> {
let (repo, pool) = SqliteHarness::repo().await?;
let relation = upsert_relation::<SqliteHarness>(&repo, ExpiryPolicy::ManualOnly).await?;
let policy = serde_json::json!({
"type": "at",
"timestamp": "2026-01-01T00:00:00.123456Z"
});
let result = sqlx::query(
r"
insert into keepsakes
(id, subject_kind, subject_id, relation_id, state, expiry_policy, applied_at,
expires_at, fulfilled_at, revoked_at, metadata, created_at, updated_at)
values (?1, 'account', 'fractional', ?2, 'applied', ?3, ?4, ?5, null, null, '{}', ?4, ?4)
",
)
.bind(Uuid::now_v7().to_string())
.bind(relation.id.to_string())
.bind(policy.to_string())
.bind("2026-01-01T00:00:00.000000Z")
.bind("2026-01-01T00:00:00.654321Z")
.execute(&pool)
.await;
assert!(matches!(result, Err(sqlx::Error::Database(_))));
Ok(())
}
#[tokio::test]
async fn sqlite_fulfilled_expiry_uses_counter_snapshot() -> TestResult<()> {
backend_cases::fulfilled_expiry_uses_counter_snapshot::<SqliteHarness>().await
}
#[tokio::test]
async fn sqlite_migration_rejects_wrong_backend_marker() -> TestResult<()> {
let pool = SqlitePoolOptions::new()
.max_connections(1)
.connect("sqlite::memory:")
.await?;
sqlx::query(
"create table keepsake_schema_metadata (key text primary key, value text not null)",
)
.execute(&pool)
.await?;
sqlx::query("insert into keepsake_schema_metadata (key, value) values ('backend', 'postgres')")
.execute(&pool)
.await?;
let repo = SqliteKeepsakeRepository::new(pool);
let result = repo.migrate().await;
assert!(matches!(
result,
Err(RepositoryError::BackendMismatch {
expected: "sqlite",
actual
}) if actual == "postgres"
));
Ok(())
}