use rustensor::{
HEADER_SIZE, ModelCheckpoint, ModelMetadata, RustensorError, WeightLayer, load_checkpoint,
save_checkpoint, sha256_hex, sha256_payload, verify_checksum,
};
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH};
fn unique_temp_path(name: &str) -> PathBuf {
let nanos = SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("system time should be valid")
.as_nanos();
std::env::temp_dir().join(format!(
"rustensor_{name}_{}_{}.rten",
std::process::id(),
nanos
))
}
fn sample_checkpoint() -> ModelCheckpoint {
let metadata = ModelMetadata::new(
"demo-model".to_string(),
"linear".to_string(),
"0.1.0".to_string(),
)
.expect("metadata should be valid");
let layer = WeightLayer::f32(
"dense.weight".to_string(),
vec![2, 2],
vec![0.1, 0.2, 0.3, 0.4],
)
.expect("layer should be valid");
let mut checkpoint = ModelCheckpoint::new(metadata);
checkpoint.add_layer(layer).expect("layer should be added");
checkpoint
}
#[test]
fn sha256_payload_is_32_bytes() {
let digest = sha256_payload(b"hello");
assert_eq!(digest.len(), 32);
}
#[test]
fn sha256_payload_is_deterministic() {
let left = sha256_payload(b"payload");
let right = sha256_payload(b"payload");
assert_eq!(left, right);
}
#[test]
fn sha256_payload_changes_when_payload_changes() {
let left = sha256_payload(b"payload-a");
let right = sha256_payload(b"payload-b");
assert_ne!(left, right);
}
#[test]
fn sha256_hex_has_64_characters() {
let hex = sha256_hex(b"payload");
assert_eq!(hex.len(), 64);
assert!(hex.chars().all(|ch| ch.is_ascii_hexdigit()));
}
#[test]
fn verify_checksum_accepts_matching_digest() {
let payload = b"payload";
let digest = sha256_payload(payload);
let result = verify_checksum(payload, &digest);
assert!(result.is_ok());
}
#[test]
fn verify_checksum_rejects_mismatched_digest() {
let payload = b"payload";
let wrong = sha256_payload(b"other-payload");
let result = verify_checksum(payload, &wrong);
assert!(matches!(result, Err(RustensorError::ChecksumMismatch)));
}
#[test]
fn accepts_intact_checkpoint() {
let path = unique_temp_path("intact_checkpoint");
let checkpoint = sample_checkpoint();
save_checkpoint(&path, &checkpoint).expect("checkpoint should save");
let loaded = load_checkpoint(&path).expect("checkpoint should load");
assert_eq!(loaded.metadata.model_name, checkpoint.metadata.model_name);
assert_eq!(loaded.layers.len(), checkpoint.layers.len());
let _ = std::fs::remove_file(path);
}
#[test]
fn rejects_tampered_payload() {
let path = unique_temp_path("tampered_payload");
let checkpoint = sample_checkpoint();
save_checkpoint(&path, &checkpoint).expect("checkpoint should save");
let mut bytes = std::fs::read(&path).expect("file should be readable");
let last = bytes.len() - 1;
bytes[last] ^= 0xFF;
std::fs::write(&path, bytes).expect("tampered file should be written");
let result = load_checkpoint(&path);
assert!(matches!(result, Err(RustensorError::ChecksumMismatch)));
let _ = std::fs::remove_file(path);
}
#[test]
fn rejects_tampered_checksum() {
let path = unique_temp_path("tampered_checksum");
let checkpoint = sample_checkpoint();
save_checkpoint(&path, &checkpoint).expect("checkpoint should save");
let mut bytes = std::fs::read(&path).expect("file should be readable");
bytes[HEADER_SIZE - 1] ^= 0xFF;
std::fs::write(&path, bytes).expect("tampered file should be written");
let result = load_checkpoint(&path);
assert!(matches!(result, Err(RustensorError::ChecksumMismatch)));
let _ = std::fs::remove_file(path);
}
#[test]
fn rejects_file_shorter_than_header() {
let path = unique_temp_path("short_header");
std::fs::write(&path, vec![0u8; 20]).expect("short file should be written");
let result = load_checkpoint(&path);
assert!(matches!(result, Err(RustensorError::InvalidHeader)));
let _ = std::fs::remove_file(path);
}
#[test]
fn rejects_header_complete_but_payload_truncated() {
let path = unique_temp_path("payload_truncated");
let checkpoint = sample_checkpoint();
save_checkpoint(&path, &checkpoint).expect("checkpoint should save");
let mut bytes = std::fs::read(&path).expect("file should be readable");
bytes.truncate(bytes.len() - 1);
std::fs::write(&path, bytes).expect("truncated file should be written");
let result = load_checkpoint(&path);
assert!(matches!(
result,
Err(RustensorError::InvalidPayloadLength { .. })
));
let _ = std::fs::remove_file(path);
}
#[test]
fn rejects_invalid_payload_length_after_append() {
let path = unique_temp_path("payload_extra_bytes");
let checkpoint = sample_checkpoint();
save_checkpoint(&path, &checkpoint).expect("checkpoint should save");
let mut bytes = std::fs::read(&path).expect("file should be readable");
bytes.push(0xAA);
std::fs::write(&path, bytes).expect("modified file should be written");
let result = load_checkpoint(&path);
assert!(matches!(
result,
Err(RustensorError::InvalidPayloadLength { .. })
));
let _ = std::fs::remove_file(path);
}