rustensor 0.1.0

Small Rust-native checkpoint format for model metadata and tensor weights.
Documentation
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);
}