khive-db 0.21.0

SQLite storage backend: entities, edges, notes, events, FTS5, sqlite-vec vectors.
Documentation
use super::*;

const NAME: &str = "node_confirmed_pins";
const TABLE: &str = "comm_node_confirmed_pin";

fn insert(
    conn: &Connection,
    epoch: i64,
    kem: u32,
    signing: u32,
    fingerprint: u32,
) -> rusqlite::Result<usize> {
    conn.execute(
        &format!(
            "INSERT INTO comm_node_confirmed_pin(namespace, slug, realm, agent_id, device_id, \
             key_epoch, kem_public_key, signing_public_key, fingerprint) VALUES ('local', 'peer', \
             'example', '00000000-0000-0000-0000-000000000007', \
             '00000000-0000-0000-0000-000000000001', {epoch}, zeroblob({kem}), \
             zeroblob({signing}), zeroblob({fingerprint}))"
        ),
        [],
    )
}

fn is_constraint(error: &rusqlite::Error) -> bool {
    matches!(
        error,
        rusqlite::Error::SqliteFailure(failure, _)
            if failure.code == rusqlite::ErrorCode::ConstraintViolation
    )
}

fn pin_count(conn: &Connection) -> i64 {
    conn.query_row("SELECT COUNT(*) FROM comm_node_confirmed_pin", [], |row| {
        row.get(0)
    })
    .unwrap()
}

#[test]
fn confirmed_pin_migration_installs_on_fresh_and_v63_databases() {
    let migration = MIGRATIONS
        .iter()
        .find(|migration| migration.name == NAME)
        .unwrap();
    assert_eq!(migration.version, 64);
    let mut fresh = open_memory();
    run_migrations(&mut fresh).unwrap();
    assert!(table_exists(&fresh, TABLE));

    let mut existing = open_memory();
    let admission = WriteAdmission::for_migration_policy(None, &migration_test_policy()).unwrap();
    {
        let mut writes = RawMigrationTransactions::new(&mut existing, &admission);
        writes
            .admitted(|conn| bootstrap_migration_ledger(conn, &admission))
            .unwrap();
        for prior in MIGRATIONS
            .iter()
            .take_while(|migration| migration.name != NAME)
        {
            writes
                .admitted(|conn| {
                    apply_versioned_migration(conn, prior, &admission, latest_schema_version())
                })
                .unwrap();
        }
    }
    assert!(!table_exists(&existing, TABLE));
    run_migrations(&mut existing).unwrap();
    assert!(table_exists(&existing, TABLE));
    insert(&existing, 1, 32, 32, 32).unwrap();
    run_migrations(&mut existing).unwrap();
    assert_eq!(pin_count(&existing), 1);
}

#[test]
fn confirmed_pin_checks_refuse_short_keys_and_out_of_range_epochs() {
    let mut conn = open_memory();
    run_migrations(&mut conn).unwrap();
    insert(&conn, 1, 32, 32, 32).unwrap();
    insert(&conn, 4_294_967_295, 32, 32, 32).unwrap();
    for (epoch, kem, signing, fingerprint) in [
        (2, 31, 32, 32),
        (2, 33, 32, 32),
        (2, 32, 31, 32),
        (2, 32, 32, 31),
        (0, 32, 32, 32),
        (-1, 32, 32, 32),
        (4_294_967_296, 32, 32, 32),
    ] {
        let error = insert(&conn, epoch, kem, signing, fingerprint).unwrap_err();
        assert!(
            is_constraint(&error),
            "epoch {epoch} lengths {kem}/{signing}/{fingerprint}: {error:?}"
        );
    }
    assert_eq!(pin_count(&conn), 2);
}

#[test]
fn confirmed_pin_identity_cannot_be_inserted_twice() {
    let mut conn = open_memory();
    run_migrations(&mut conn).unwrap();
    insert(&conn, 1, 32, 32, 32).unwrap();
    let error = insert(&conn, 1, 32, 32, 32).unwrap_err();
    assert!(is_constraint(&error), "{error:?}");
    assert_eq!(pin_count(&conn), 1);
}