use md5::Md5;
use sha1::Sha1;
use sha2::{Digest, Sha256, Sha512};
use sha3::{Shake256, digest::{ExtendableOutput, XofReader}};
use std::sync::{Mutex, OnceLock};
pub const BLAKE3_HASH_PREFIX: &str = "blake3:";
pub const SHA256_HASH_PREFIX: &str = "sha256:";
pub const DEFAULT_HASH_PREFIX: &str = BLAKE3_HASH_PREFIX;
pub const DEFAULT_COLLISION_THRESHOLD: u32 = 2;
pub trait HashProvider: Send + Sync {
fn hash(&self, content: &[u8]) -> String;
fn prefix(&self) -> &'static str;
fn hash_bytes(&self, content: &[u8]) -> [u8; 32] {
let hex = self.hash(content);
let mut out = [0u8; 32];
let bytes = hex.as_bytes();
for i in 0..32 {
out[i] = u8::from_str_radix(
std::str::from_utf8(&bytes[i * 2..i * 2 + 2]).unwrap_or("00"),
16,
)
.unwrap_or(0);
}
out
}
}
pub struct Blake3Provider;
impl HashProvider for Blake3Provider {
fn hash(&self, content: &[u8]) -> String {
blake3::hash(content).to_hex().to_string()
}
fn prefix(&self) -> &'static str {
BLAKE3_HASH_PREFIX
}
fn hash_bytes(&self, content: &[u8]) -> [u8; 32] {
*blake3::hash(content).as_bytes()
}
}
pub struct Sha256Provider;
impl HashProvider for Sha256Provider {
fn hash(&self, content: &[u8]) -> String {
let mut hasher = Sha256::new();
hasher.update(content);
format!("{:x}", hasher.finalize())
}
fn prefix(&self) -> &'static str {
SHA256_HASH_PREFIX
}
fn hash_bytes(&self, content: &[u8]) -> [u8; 32] {
let mut hasher = Sha256::new();
hasher.update(content);
hasher.finalize().into()
}
}
pub struct Md5Provider;
impl HashProvider for Md5Provider {
fn hash(&self, content: &[u8]) -> String {
let mut hasher = Md5::new();
hasher.update(content);
format!("{:x}", hasher.finalize())
}
fn prefix(&self) -> &'static str {
"md5:"
}
}
pub struct Sha1Provider;
impl HashProvider for Sha1Provider {
fn hash(&self, content: &[u8]) -> String {
let mut hasher = Sha1::new();
hasher.update(content);
format!("{:x}", hasher.finalize())
}
fn prefix(&self) -> &'static str {
"sha1:"
}
}
pub struct Sha512Provider;
impl HashProvider for Sha512Provider {
fn hash(&self, content: &[u8]) -> String {
let mut hasher = Sha512::new();
hasher.update(content);
format!("{:x}", hasher.finalize())
}
fn prefix(&self) -> &'static str {
"sha512:"
}
}
pub struct Shake256Provider {
bits: usize,
prefix_str: &'static str,
}
impl Shake256Provider {
pub fn new(bits: usize) -> Self {
let prefix_str: &'static str = Box::leak(
format!("custom-{}:", bits).into_boxed_str(),
);
Self { bits, prefix_str }
}
fn byte_len(&self) -> usize {
(self.bits + 7) / 8
}
}
impl HashProvider for Shake256Provider {
fn hash(&self, content: &[u8]) -> String {
let mut hasher = Shake256::default();
sha3::digest::Update::update(&mut hasher, content);
let mut reader = hasher.finalize_xof();
let byte_len = self.byte_len();
let mut buf = vec![0u8; byte_len];
reader.read(&mut buf);
hex::encode(&buf)
}
fn prefix(&self) -> &'static str {
self.prefix_str
}
}
pub struct ProviderRegistry {
providers: Vec<(&'static str, Box<dyn HashProvider>)>,
}
impl ProviderRegistry {
fn new() -> Self {
Self {
providers: Vec::new(),
}
}
pub fn register(&mut self, provider: Box<dyn HashProvider>) {
let prefix = provider.prefix();
self.providers.push((prefix, provider));
}
pub fn get(&self, prefix: &str) -> Option<&dyn HashProvider> {
self.providers
.iter()
.find(|(p, _)| *p == prefix)
.map(|(_, provider)| provider.as_ref())
}
pub fn active(&self, active_prefix: &str) -> &dyn HashProvider {
self.get(active_prefix)
.unwrap_or_else(|| self.get(DEFAULT_HASH_PREFIX).expect("default provider must be registered"))
}
pub fn algorithms(&self) -> Vec<&'static str> {
self.providers.iter().map(|(p, _)| *p).collect()
}
}
pub fn global_registry() -> &'static Mutex<ProviderRegistry> {
static REGISTRY: OnceLock<Mutex<ProviderRegistry>> = OnceLock::new();
REGISTRY.get_or_init(|| {
let mut reg = ProviderRegistry::new();
reg.register(Box::new(Blake3Provider));
reg.register(Box::new(Sha256Provider));
reg.register(Box::new(Md5Provider));
reg.register(Box::new(Sha1Provider));
reg.register(Box::new(Sha512Provider));
Mutex::new(reg)
})
}
pub fn register_provider(provider: Box<dyn HashProvider>) {
let mut reg = global_registry().lock().unwrap();
reg.register(provider);
}
pub fn register_custom_provider(bits: usize) {
register_provider(Box::new(Shake256Provider::new(bits)));
}
pub const STRENGTH_HIERARCHY: &[&str] = &[
"md5:",
"sha1:",
"sha256:",
"blake3:",
"sha512:",
"custom-1024:",
];
pub fn next_stronger_algorithm(current: &str) -> &'static str {
if let Some(rest) = current.strip_prefix("custom-") {
if let Some(num_str) = rest.strip_suffix(':') {
if let Ok(n) = num_str.parse::<usize>() {
let doubled = n * 2;
return Box::leak(format!("custom-{}:", doubled).into_boxed_str());
}
}
}
let pos = STRENGTH_HIERARCHY.iter().position(|&algo| algo == current);
match pos {
Some(i) if i + 1 < STRENGTH_HIERARCHY.len() => STRENGTH_HIERARCHY[i + 1],
_ => DEFAULT_HASH_PREFIX,
}
}
pub fn list_algorithms() -> Vec<&'static str> {
let reg = global_registry().lock().unwrap();
reg.algorithms()
}
#[derive(Debug, Clone)]
pub struct HashConfig {
pub active_algorithm: &'static str,
pub collision_threshold: u32,
pub fallback_order: Vec<&'static str>,
}
impl Default for HashConfig {
fn default() -> Self {
Self {
active_algorithm: DEFAULT_HASH_PREFIX,
collision_threshold: DEFAULT_COLLISION_THRESHOLD,
fallback_order: vec![DEFAULT_HASH_PREFIX, SHA256_HASH_PREFIX],
}
}
}
impl HashConfig {
pub fn from_env() -> Self {
if let Ok(raw) = std::env::var("CLM_HASH_CONFIG") {
Self::parse_config(&raw)
} else if let Ok(algo) = std::env::var("CLM_HASH_ALGO")
.or_else(|_| std::env::var("MCARD_HASH_ALGORITHM"))
{
let trimmed = algo.trim();
let prefix = if trimmed.ends_with(':') {
trimmed.to_string()
} else {
format!("{}:", trimmed)
};
let leaked_prefix: &'static str = Box::leak(prefix.into_boxed_str());
Self {
active_algorithm: leaked_prefix,
collision_threshold: DEFAULT_COLLISION_THRESHOLD,
fallback_order: vec![leaked_prefix, SHA256_HASH_PREFIX],
}
} else {
Self::default()
}
}
fn parse_config(raw: &str) -> Self {
let parts: Vec<&str> = raw.splitn(3, '|').collect();
if parts.len() < 2 {
return Self::default();
}
let active = if parts[0].is_empty() {
DEFAULT_HASH_PREFIX
} else {
Box::leak(parts[0].to_string().into_boxed_str())
};
let threshold = parts[1].parse::<u32>().unwrap_or(DEFAULT_COLLISION_THRESHOLD);
let fallbacks: Vec<&'static str> = if parts.len() == 3 && !parts[2].is_empty() {
parts[2]
.split(',')
.map(|s| {
if s.is_empty() {
DEFAULT_HASH_PREFIX
} else {
Box::leak(s.to_string().into_boxed_str())
}
})
.collect()
} else {
vec![active]
};
Self {
active_algorithm: active,
collision_threshold: threshold,
fallback_order: fallbacks,
}
}
}
fn global_config() -> &'static HashConfig {
static CONFIG: OnceLock<HashConfig> = OnceLock::new();
CONFIG.get_or_init(HashConfig::from_env)
}
pub fn config() -> &'static HashConfig {
global_config()
}
pub fn extract_prefix(prefixed: &str) -> Option<&str> {
prefixed.find(':').map(|pos| &prefixed[..=pos])
}
pub fn verify_hash(stored_hash: &str, content: &[u8]) -> Result<(), String> {
let prefix = extract_prefix(stored_hash).unwrap_or(DEFAULT_HASH_PREFIX);
let reg = global_registry().lock().unwrap();
let provider = reg.get(prefix).ok_or_else(|| {
format!("Unknown hash algorithm prefix: {} (registered: {:?})", prefix, reg.algorithms())
})?;
let computed = provider.hash(content);
let stored_raw = strip_prefix(stored_hash);
if computed == stored_raw {
Ok(())
} else {
Err(format!(
"Hash mismatch: expected {}..., got {}...",
&stored_raw[..stored_raw.len().min(16)],
&computed[..computed.len().min(16)]
))
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CollisionCheckResult {
NoCollision,
Collision { hash: String, collision_count: u32 },
ThresholdExceeded {
hash: String,
collision_count: u32,
recommended_algorithm: &'static str,
},
}
pub fn check_collision(
hash: &str,
new_content: &[u8],
existing_content: Option<&[u8]>,
collision_count: u32,
) -> CollisionCheckResult {
match existing_content {
None => CollisionCheckResult::NoCollision,
Some(existing) if existing == new_content => CollisionCheckResult::NoCollision,
Some(_) => {
let count = collision_count + 1;
let cfg = config();
if count >= cfg.collision_threshold {
let recommended = cfg
.fallback_order
.iter()
.find(|&&algo| algo != cfg.active_algorithm)
.copied()
.unwrap_or(cfg.active_algorithm);
CollisionCheckResult::ThresholdExceeded {
hash: hash.to_string(),
collision_count: count,
recommended_algorithm: recommended,
}
} else {
CollisionCheckResult::Collision {
hash: hash.to_string(),
collision_count: count,
}
}
}
}
}
pub fn raw_hash_bytes(content: &[u8]) -> String {
let reg = global_registry().lock().unwrap();
reg.active(config().active_algorithm).hash(content)
}
pub fn raw_hash_string(s: &str) -> String {
raw_hash_bytes(s.as_bytes())
}
pub fn raw_hash_bytes_32(content: &[u8]) -> [u8; 32] {
let reg = global_registry().lock().unwrap();
reg.active(config().active_algorithm).hash_bytes(content)
}
pub fn prefixed_hash_bytes(content: &[u8]) -> String {
let reg = global_registry().lock().unwrap();
let provider = reg.active(config().active_algorithm);
format!("{}{}", provider.prefix(), provider.hash(content))
}
pub fn prefixed_hash_string(s: &str) -> String {
prefixed_hash_bytes(s.as_bytes())
}
pub fn prefixed(raw_hex: &str) -> String {
format!("{}{}", config().active_algorithm, raw_hex)
}
pub fn strip_prefix(prefixed: &str) -> &str {
let active = config().active_algorithm;
if let Some(rest) = prefixed.strip_prefix(active) {
return rest;
}
if let Some(rest) = prefixed.strip_prefix(DEFAULT_HASH_PREFIX) {
return rest;
}
if let Some(pos) = prefixed.find(':') {
if pos + 1 < prefixed.len() {
return &prefixed[pos + 1..];
}
}
prefixed
}
pub fn default_provider() -> impl HashProvider {
Blake3Provider
}
#[cfg(feature = "native")]
pub fn content_equivalent(
conn: &rusqlite::Connection,
hash_a: &str,
hash_b: &str,
) -> Result<bool, String> {
if hash_a == hash_b {
return Ok(true);
}
let content_a: Option<Vec<u8>> = conn
.query_row(
"SELECT content FROM card WHERE hash = ?",
rusqlite::params![hash_a],
|row| row.get(0),
)
.ok();
let content_b: Option<Vec<u8>> = conn
.query_row(
"SELECT content FROM card WHERE hash = ?",
rusqlite::params![hash_b],
|row| row.get(0),
)
.ok();
match (content_a, content_b) {
(Some(a), Some(b)) => Ok(a == b),
_ => Ok(false),
}
}
#[cfg(feature = "native")]
pub fn migrate_handle_hash(
conn: &mut rusqlite::Connection,
handle: &str,
target_algo: &str,
) -> Result<String, String> {
{
let reg = global_registry().lock().unwrap();
if reg.get(target_algo).is_none() {
return Err(format!(
"Unsupported target algorithm: '{}' (registered: {:?})",
target_algo,
reg.algorithms()
));
}
}
let current_hash: String = conn
.query_row(
"SELECT current_hash FROM handle_registry WHERE handle = ?",
rusqlite::params![handle],
|row| row.get(0),
)
.map_err(|_| format!("Handle '{}' not found in handle_registry", handle))?;
let content: Vec<u8> = conn
.query_row(
"SELECT content FROM card WHERE hash = ?",
rusqlite::params![current_hash],
|row| row.get(0),
)
.map_err(|_| {
format!(
"Content not found in CAS for hash '{}'",
current_hash
)
})?;
let reg = global_registry().lock().unwrap();
let provider = reg.get(target_algo).ok_or_else(|| {
format!("Provider not found for algorithm '{}'", target_algo)
})?;
let new_raw_hash = provider.hash(&content);
let new_hash = format!("{}{}", provider.prefix(), new_raw_hash);
drop(reg);
let now_utc = chrono::Utc::now().to_rfc3339();
let algo_name = target_algo.trim_end_matches(':');
let g_time = format!("{}|{}|UTC", algo_name, now_utc);
let max_attempts = 3;
let mut last_err = String::new();
for attempt in 0..max_attempts {
let tx = match conn.transaction() {
Ok(tx) => tx,
Err(e) => {
last_err = e.to_string();
std::thread::sleep(std::time::Duration::from_millis(200));
continue;
}
};
let result = (|| {
tx.execute(
"INSERT OR IGNORE INTO card (hash, content, g_time) VALUES (?, ?, ?)",
rusqlite::params![new_hash, &content, &g_time],
)
.map_err(|e| e.to_string())?;
tx.execute(
"INSERT INTO handle_history (handle, previous_hash, changed_at) VALUES (?, ?, ?)",
rusqlite::params![handle, ¤t_hash, &now_utc],
)
.map_err(|e| e.to_string())?;
tx.execute(
"UPDATE handle_registry SET current_hash = ?, updated_at = ? WHERE handle = ?",
rusqlite::params![&new_hash, &now_utc, handle],
)
.map_err(|e| e.to_string())?;
tx.commit().map_err(|e| e.to_string())
})();
match result {
Ok(()) => return Ok(new_hash),
Err(e) => {
last_err = e;
if attempt + 1 < max_attempts {
std::thread::sleep(std::time::Duration::from_millis(200));
}
}
}
}
Err(format!("Transaction failed after {} attempts: {}", max_attempts, last_err))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_raw_hash_bytes() {
assert_eq!(
raw_hash_bytes(b"hello"),
"ea8f163db38682925e4491c5e58d4bb3506ef8c14eb78a86e908c5624a67200f"
);
}
#[test]
fn test_sha256_provider() {
let provider = Sha256Provider;
assert_eq!(
provider.hash(b"hello"),
"2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
);
}
#[test]
fn test_raw_hash_string() {
assert_eq!(
raw_hash_string("hello"),
"ea8f163db38682925e4491c5e58d4bb3506ef8c14eb78a86e908c5624a67200f"
);
}
#[test]
fn test_raw_hash_bytes_32() {
let expected = [
0xea, 0x8f, 0x16, 0x3d, 0xb3, 0x86, 0x82, 0x92, 0x5e, 0x44, 0x91, 0xc5, 0xe5, 0x8d,
0x4b, 0xb3, 0x50, 0x6e, 0xf8, 0xc1, 0x4e, 0xb7, 0x8a, 0x86, 0xe9, 0x08, 0xc5, 0x62,
0x4a, 0x67, 0x20, 0x0f,
];
assert_eq!(raw_hash_bytes_32(b"hello"), expected);
}
#[test]
fn test_prefixed_hash_string() {
let h = prefixed_hash_string("hello");
assert!(h.starts_with("blake3:"));
assert_eq!(
h,
"blake3:ea8f163db38682925e4491c5e58d4bb3506ef8c14eb78a86e908c5624a67200f"
);
}
#[test]
fn test_strip_prefix() {
assert_eq!(strip_prefix("sha256:abcdef"), "abcdef");
assert_eq!(strip_prefix("sha3-256:abcdef"), "abcdef");
assert_eq!(strip_prefix("noprefix"), "noprefix");
}
#[test]
fn test_extract_prefix() {
assert_eq!(extract_prefix("sha256:abc"), Some("sha256:"));
assert_eq!(extract_prefix("sha3-256:abc"), Some("sha3-256:"));
assert_eq!(extract_prefix("noprefix"), None);
}
#[test]
fn test_verify_hash_match() {
let content = b"hello";
let stored = prefixed_hash_bytes(content);
assert!(verify_hash(&stored, content).is_ok());
}
#[test]
fn test_verify_hash_mismatch() {
let stored = prefixed_hash_bytes(b"hello");
assert!(verify_hash(&stored, b"world").is_err());
}
#[test]
fn test_verify_hash_unknown_prefix() {
assert!(verify_hash("unknown:abc", b"hello").is_err());
}
#[test]
fn test_provider_registry() {
let algorithms = list_algorithms();
assert!(algorithms.contains(&"sha256:"));
}
#[test]
fn test_collision_no_collision() {
let result = check_collision("abc", b"hello", None, 0);
assert_eq!(result, CollisionCheckResult::NoCollision);
}
#[test]
fn test_collision_same_content() {
let result = check_collision("abc", b"hello", Some(b"hello"), 0);
assert_eq!(result, CollisionCheckResult::NoCollision);
}
#[test]
fn test_collision_detected() {
let result = check_collision("abc", b"hello", Some(b"world"), 0);
assert_eq!(
result,
CollisionCheckResult::Collision {
hash: "abc".to_string(),
collision_count: 1
}
);
}
#[test]
fn test_collision_threshold_exceeded() {
let result = check_collision("abc", b"hello", Some(b"world"), 1);
match result {
CollisionCheckResult::ThresholdExceeded {
recommended_algorithm,
..
} => {
assert_eq!(recommended_algorithm, "sha256:");
}
other => panic!("Expected ThresholdExceeded, got {:?}", other),
}
}
#[test]
fn test_hash_config_default() {
let cfg = HashConfig::default();
assert_eq!(cfg.active_algorithm, DEFAULT_HASH_PREFIX);
assert_eq!(cfg.collision_threshold, DEFAULT_COLLISION_THRESHOLD);
}
#[test]
fn test_hash_config_parse() {
let cfg = HashConfig::parse_config("sha256:|3|sha256:,sha3-256:");
assert_eq!(cfg.active_algorithm, "sha256:");
assert_eq!(cfg.collision_threshold, 3);
assert_eq!(cfg.fallback_order, vec!["sha256:", "sha3-256:"]);
}
#[test]
fn test_shake256_provider() {
let provider = Shake256Provider::new(256);
let h = provider.hash(b"hello");
assert_eq!(h.len(), 64);
assert_eq!(provider.prefix(), "custom-256:");
}
#[test]
fn test_shake256_provider_1024() {
let provider = Shake256Provider::new(1024);
let h = provider.hash(b"hello");
assert_eq!(h.len(), 256);
assert_eq!(provider.prefix(), "custom-1024:");
}
#[test]
fn test_register_custom_provider() {
register_custom_provider(512);
let algorithms = list_algorithms();
assert!(algorithms.contains(&"custom-512:"));
}
#[test]
fn test_next_stronger_algorithm() {
assert_eq!(next_stronger_algorithm("md5:"), "sha1:");
assert_eq!(next_stronger_algorithm("sha1:"), "sha256:");
assert_eq!(next_stronger_algorithm("sha256:"), "blake3:");
assert_eq!(next_stronger_algorithm("blake3:"), "sha512:");
assert_eq!(next_stronger_algorithm("sha512:"), "custom-1024:");
}
#[test]
fn test_next_stronger_custom_doubling() {
assert_eq!(next_stronger_algorithm("custom-1024:"), "custom-2048:");
assert_eq!(next_stronger_algorithm("custom-2048:"), "custom-4096:");
}
#[test]
fn test_verify_hash_custom_n() {
register_custom_provider(256);
let provider = Shake256Provider::new(256);
let content = b"hello";
let raw = provider.hash(content);
let prefixed = format!("custom-256:{}", raw);
assert!(verify_hash(&prefixed, content).is_ok());
assert!(verify_hash(&prefixed, b"world").is_err());
}
#[test]
fn test_md5_provider() {
let provider = Md5Provider;
let h = provider.hash(b"hello");
assert_eq!(h.len(), 32); assert_eq!(h, "5d41402abc4b2a76b9719d911017c592");
assert_eq!(provider.prefix(), "md5:");
}
#[test]
fn test_sha1_provider() {
let provider = Sha1Provider;
let h = provider.hash(b"hello");
assert_eq!(h.len(), 40); assert_eq!(h, "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d");
assert_eq!(provider.prefix(), "sha1:");
}
#[test]
fn test_sha512_provider() {
let provider = Sha512Provider;
let h = provider.hash(b"hello");
assert_eq!(h.len(), 128); assert_eq!(
h,
"9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043"
);
assert_eq!(provider.prefix(), "sha512:");
}
#[test]
fn test_blake3_provider() {
let provider = Blake3Provider;
let h = provider.hash(b"hello");
assert_eq!(h.len(), 64);
assert_eq!(
h,
"ea8f163db38682925e4491c5e58d4bb3506ef8c14eb78a86e908c5624a67200f"
);
assert_eq!(provider.prefix(), "blake3:");
}
#[test]
fn test_all_providers_registered() {
let algorithms = list_algorithms();
assert!(algorithms.contains(&"blake3:"));
assert!(algorithms.contains(&"sha256:"));
assert!(algorithms.contains(&"md5:"));
assert!(algorithms.contains(&"sha1:"));
assert!(algorithms.contains(&"sha512:"));
}
#[test]
fn test_verify_hash_blake3() {
let provider = Blake3Provider;
let content = b"hello";
let prefixed = format!("blake3:{}", provider.hash(content));
assert!(verify_hash(&prefixed, content).is_ok());
assert!(verify_hash(&prefixed, b"world").is_err());
}
#[test]
fn test_verify_hash_md5() {
let provider = Md5Provider;
let content = b"hello";
let prefixed = format!("md5:{}", provider.hash(content));
assert!(verify_hash(&prefixed, content).is_ok());
assert!(verify_hash(&prefixed, b"world").is_err());
}
#[test]
fn test_verify_hash_sha512() {
let provider = Sha512Provider;
let content = b"hello";
let prefixed = format!("sha512:{}", provider.hash(content));
assert!(verify_hash(&prefixed, content).is_ok());
assert!(verify_hash(&prefixed, b"world").is_err());
}
#[test]
#[cfg(feature = "native")]
fn test_migrate_through_hierarchy() {
use rusqlite::Connection;
register_custom_provider(1024);
let mut conn = Connection::open_in_memory().unwrap();
conn.execute_batch(
"CREATE TABLE card (hash TEXT PRIMARY KEY, content BLOB NOT NULL, g_time TEXT NOT NULL);
CREATE TABLE handle_registry (handle TEXT PRIMARY KEY, current_hash TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
CREATE TABLE handle_history (handle TEXT NOT NULL, previous_hash TEXT NOT NULL, changed_at TEXT NOT NULL);",
).unwrap();
let content = b"hierarchy_test_payload";
let h = prefixed_hash_bytes(content);
conn.execute("INSERT INTO card (hash, content, g_time) VALUES (?, ?, '2025-01-01')", rusqlite::params![h, content]).unwrap();
conn.execute("INSERT INTO handle_registry (handle, current_hash, created_at, updated_at) VALUES (?, ?, '2025-01-01', '2025-01-01')", rusqlite::params!["test:hier_handle", h]).unwrap();
let h512 = migrate_handle_hash(&mut conn, "test:hier_handle", "sha512:").unwrap();
assert!(h512.starts_with("sha512:"));
assert!(content_equivalent(&conn, &h, &h512).unwrap());
let h_custom = migrate_handle_hash(&mut conn, "test:hier_handle", "custom-1024:").unwrap();
assert!(h_custom.starts_with("custom-1024:"));
assert!(content_equivalent(&conn, &h, &h_custom).unwrap());
let count: i64 = conn.query_row("SELECT count(*) FROM card WHERE hash IN (?, ?, ?)", rusqlite::params![h, h512, h_custom], |r| r.get(0)).unwrap();
assert_eq!(count, 3);
let hist: i64 = conn.query_row("SELECT count(*) FROM handle_history WHERE handle = 'test:hier_handle'", [], |r| r.get(0)).unwrap();
assert_eq!(hist, 2);
}
#[test]
#[cfg(feature = "native")]
fn test_content_equivalent() {
use rusqlite::Connection;
let conn = Connection::open_in_memory().unwrap();
conn.execute(
"CREATE TABLE card (hash TEXT PRIMARY KEY, content BLOB NOT NULL, g_time TEXT NOT NULL)",
[],
)
.unwrap();
let content = b"hello world";
let hash_a = "sha256:aaa";
let hash_b = "sha512:bbb";
let hash_c = "sha256:ccc";
conn.execute(
"INSERT INTO card (hash, content, g_time) VALUES (?, ?, '2025-01-01')",
rusqlite::params![hash_a, content],
)
.unwrap();
conn.execute(
"INSERT INTO card (hash, content, g_time) VALUES (?, ?, '2025-01-01')",
rusqlite::params![hash_b, content],
)
.unwrap();
conn.execute(
"INSERT INTO card (hash, content, g_time) VALUES (?, ?, '2025-01-01')",
rusqlite::params![hash_c, b"different"],
)
.unwrap();
assert_eq!(content_equivalent(&conn, hash_a, hash_b).unwrap(), true);
assert_eq!(content_equivalent(&conn, hash_a, hash_a).unwrap(), true);
assert_eq!(content_equivalent(&conn, hash_a, hash_c).unwrap(), false);
assert_eq!(content_equivalent(&conn, hash_a, "missing").unwrap(), false);
}
#[test]
#[cfg(feature = "native")]
fn test_migrate_handle_hash() {
use rusqlite::Connection;
register_custom_provider(256);
let mut conn = Connection::open_in_memory().unwrap();
conn.execute_batch(
"CREATE TABLE card (hash TEXT PRIMARY KEY, content BLOB NOT NULL, g_time TEXT NOT NULL);
CREATE TABLE handle_registry (handle TEXT PRIMARY KEY, current_hash TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
CREATE TABLE handle_history (handle TEXT NOT NULL, previous_hash TEXT NOT NULL, changed_at TEXT NOT NULL);",
).unwrap();
let content = b"migration_test_payload";
let h = prefixed_hash_bytes(content);
conn.execute("INSERT INTO card (hash, content, g_time) VALUES (?, ?, '2025-01-01')", rusqlite::params![h, content]).unwrap();
conn.execute("INSERT INTO handle_registry (handle, current_hash, created_at, updated_at) VALUES (?, ?, '2025-01-01', '2025-01-01')", rusqlite::params!["test:handle", h]).unwrap();
let new_h = migrate_handle_hash(&mut conn, "test:handle", "custom-256:").unwrap();
assert!(new_h.starts_with("custom-256:"));
let updated: String = conn.query_row("SELECT current_hash FROM handle_registry WHERE handle = 'test:handle'", [], |r| r.get(0)).unwrap();
assert_eq!(updated, new_h);
let hist: i64 = conn.query_row("SELECT count(*) FROM handle_history WHERE handle = 'test:handle'", [], |r| r.get(0)).unwrap();
assert_eq!(hist, 1);
assert!(content_equivalent(&conn, &h, &new_h).unwrap());
}
}