Skip to content

test(core): remove inline tests and obsolete integration tests #338

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
mroczect merged 12 commits into from
Aug 21, 2026
Merged

test(core): remove inline tests and obsolete integration tests #338

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
12 commits
Select commit Hold shift + click to select a range
4a7ef64
test(core): remove inline tests from binary_decoder
mroczect Aug 21, 2026
b098e03
test(core): remove inline tests from binary_encoder
mroczect Aug 21, 2026
3cc0491
test(core): remove inline tests from sha512
mroczect Aug 21, 2026
15ce08f
test(core): remove inline tests from blob
mroczect Aug 21, 2026
762dfd2
test(core): remove inline tests from commit
mroczect Aug 21, 2026
6f1df9b
test(core): remove inline tests from tag
mroczect Aug 21, 2026
8cd3b42
test(core): remove inline tests from tree
mroczect Aug 21, 2026
6feb8e3
test(core): remove inline tests from memory store
mroczect Aug 21, 2026
94c6f37
test(core): remove inline tests from ref_store
mroczect Aug 21, 2026
ea7b058
test(core): remove builder_api integration tests
mroczect Aug 21, 2026
c407156
test(core): remove codec_roundtrip integration tests
mroczect Aug 21, 2026
34231f4
test(core): remove common test utilities
mroczect Aug 21, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
528 changes: 0 additions & 528 deletions libvctrl_core/src/codec/binary_decoder.rs
View file
Open in desktop

Large diffs are not rendered by default.

305 changes: 0 additions & 305 deletions libvctrl_core/src/codec/binary_encoder.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -237,308 +237,3 @@ impl Encoder for BinaryEncoder {
Ok(())
}
}

#[cfg(test)]
mod tests {
use super::*;
use libvctrl_handler::{CommitMeta, HASH_LENGTH, Hash, UserID};
use std::io::Cursor;

fn make_hash(fill: u8) -> Hash {
Hash::from_bytes(&vec![fill; HASH_LENGTH]).unwrap()
}

fn hash_bytes(fill: u8) -> Vec<u8> {
vec![fill; HASH_LENGTH]
}

fn make_user_id(name: &str, email: &str) -> UserID {
UserID::new(name.into(), email.into()).unwrap()
}

fn make_meta(ts: i64, tz: i16, enc: Option<&str>) -> CommitMeta {
CommitMeta::new(ts, tz, enc.map(|s| s.into())).unwrap()
}

#[test]
fn test_encode_blob() {
let blob = Blob::new(vec![0x01, 0x02, 0x03]).unwrap();
let mut buf = Cursor::new(Vec::new());
BinaryEncoder.encode_blob(&blob, &mut buf).unwrap();
let encoded = buf.into_inner();

let mut expected = Vec::new();
expected.push(VERSION);
expected.extend_from_slice(&3u64.to_le_bytes());
expected.extend_from_slice(&[0x01, 0x02, 0x03]);
assert_eq!(encoded, expected);
}

#[test]
fn test_encode_blob_empty_data() {
let blob = Blob::new(vec![]).unwrap();
let mut buf = Cursor::new(Vec::new());
BinaryEncoder.encode_blob(&blob, &mut buf).unwrap();
let encoded = buf.into_inner();

let mut expected = Vec::new();
expected.push(VERSION);
expected.extend_from_slice(&0u64.to_le_bytes());
assert_eq!(encoded, expected);
}

#[test]
fn test_encode_tree_single_entry() {
let hash = make_hash(0xAB);
let entry = TreeEntry::new("README".into(), EntryKind::Blob, hash).unwrap();
let tree = Tree::new(vec![entry]).unwrap();
let mut buf = Cursor::new(Vec::new());
BinaryEncoder.encode_tree(&tree, &mut buf).unwrap();
let encoded = buf.into_inner();

let mut expected = Vec::new();
expected.push(VERSION);
expected.extend_from_slice(&1u32.to_le_bytes());
expected.push(6); // "README" length
expected.extend_from_slice(b"README");
expected.push(0); // Blob
expected.extend_from_slice(&hash_bytes(0xAB));
assert_eq!(encoded, expected);
}

#[test]
fn test_encode_tree_empty() {
let tree = Tree::new(vec![]).unwrap();
let mut buf = Cursor::new(Vec::new());
BinaryEncoder.encode_tree(&tree, &mut buf).unwrap();
let encoded = buf.into_inner();

let mut expected = Vec::new();
expected.push(VERSION);
expected.extend_from_slice(&0u32.to_le_bytes());
assert_eq!(encoded, expected);
}

#[test]
fn test_encode_tree_multiple_entries() {
let e1 = TreeEntry::new("src".into(), EntryKind::Tree, make_hash(0x01)).unwrap();
let e2 = TreeEntry::new("run".into(), EntryKind::Executable, make_hash(0x02)).unwrap();
let tree = Tree::new(vec![e1, e2]).unwrap();
let mut buf = Cursor::new(Vec::new());
BinaryEncoder.encode_tree(&tree, &mut buf).unwrap();
let encoded = buf.into_inner();

let mut expected = Vec::new();
expected.push(VERSION);
expected.extend_from_slice(&2u32.to_le_bytes());
expected.push(3);
expected.extend_from_slice(b"src");
expected.push(3); // Tree
expected.extend_from_slice(&hash_bytes(0x01));
expected.push(3);
expected.extend_from_slice(b"run");
expected.push(1); // Executable
expected.extend_from_slice(&hash_bytes(0x02));
assert_eq!(encoded, expected);
}

#[test]
fn test_encode_commit() {
let commit = Commit::with_meta(
make_hash(0x01),
vec![],
make_user_id("Alice", "a@b.c"),
make_user_id("Bob", "b@c.d"),
"init".into(),
make_meta(1700000000, 0, None),
)
.unwrap();
let mut buf = Cursor::new(Vec::new());
BinaryEncoder.encode_commit(&commit, &mut buf).unwrap();
let encoded = buf.into_inner();

let mut expected = Vec::new();
expected.push(VERSION);
expected.extend_from_slice(&hash_bytes(0x01));
expected.extend_from_slice(&0u16.to_le_bytes());
expected.push(5);
expected.extend_from_slice(b"Alice");
expected.push(5);
expected.extend_from_slice(b"a@b.c");
expected.push(3);
expected.extend_from_slice(b"Bob");
expected.push(5);
expected.extend_from_slice(b"b@c.d");
expected.extend_from_slice(&4u32.to_le_bytes());
expected.extend_from_slice(b"init");
expected.extend_from_slice(&1700000000i64.to_le_bytes());
expected.extend_from_slice(&0i16.to_le_bytes());
expected.push(0);
assert_eq!(encoded, expected);
}

#[test]
fn test_encode_commit_with_encoding() {
let commit = Commit::with_meta(
make_hash(0x01),
vec![],
make_user_id("A", "a@b.c"),
make_user_id("B", "b@c.d"),
"msg".into(),
make_meta(1700000000, 3600, Some("UTF-8")),
)
.unwrap();
let mut buf = Cursor::new(Vec::new());
BinaryEncoder.encode_commit(&commit, &mut buf).unwrap();
let encoded = buf.into_inner();

let mut expected = Vec::new();
expected.push(VERSION);
expected.extend_from_slice(&hash_bytes(0x01));
expected.extend_from_slice(&0u16.to_le_bytes());
expected.push(1);
expected.extend_from_slice(b"A");
expected.push(5);
expected.extend_from_slice(b"a@b.c");
expected.push(1);
expected.extend_from_slice(b"B");
expected.push(5);
expected.extend_from_slice(b"b@c.d");
expected.extend_from_slice(&3u32.to_le_bytes());
expected.extend_from_slice(b"msg");
expected.extend_from_slice(&1700000000i64.to_le_bytes());
expected.extend_from_slice(&3600i16.to_le_bytes());
expected.push(5);
expected.extend_from_slice(b"UTF-8");
assert_eq!(encoded, expected);
}

#[test]
fn test_encode_commit_with_parents() {
let commit = Commit::with_meta(
make_hash(0x01),
vec![make_hash(0x02), make_hash(0x03)],
make_user_id("A", "a@b.c"),
make_user_id("B", "b@c.d"),
"merge".into(),
make_meta(0, 0, None),
)
.unwrap();
let mut buf = Cursor::new(Vec::new());
BinaryEncoder.encode_commit(&commit, &mut buf).unwrap();
let encoded = buf.into_inner();

let mut expected = Vec::new();
expected.push(VERSION);
expected.extend_from_slice(&hash_bytes(0x01));
expected.extend_from_slice(&2u16.to_le_bytes());
expected.extend_from_slice(&hash_bytes(0x02));
expected.extend_from_slice(&hash_bytes(0x03));
expected.push(1);
expected.extend_from_slice(b"A");
expected.push(5);
expected.extend_from_slice(b"a@b.c");
expected.push(1);
expected.extend_from_slice(b"B");
expected.push(5);
expected.extend_from_slice(b"b@c.d");
expected.extend_from_slice(&5u32.to_le_bytes());
expected.extend_from_slice(b"merge");
expected.extend_from_slice(&0i64.to_le_bytes());
expected.extend_from_slice(&0i16.to_le_bytes());
expected.push(0);
assert_eq!(encoded, expected);
}

#[test]
fn test_encode_tag_with_tagger() {
let tag = Tag::with_meta(
"v1.0".into(),
make_hash(0x10),
Some(make_user_id("Alice", "alice@ex.com")),
"release".into(),
make_meta(1700000000, 0, None),
)
.unwrap();
let mut buf = Cursor::new(Vec::new());
BinaryEncoder.encode_tag(&tag, &mut buf).unwrap();
let encoded = buf.into_inner();

let mut expected = Vec::new();
expected.push(VERSION);
expected.push(4); // "v1.0" length
expected.extend_from_slice(b"v1.0");
expected.extend_from_slice(&hash_bytes(0x10));
expected.push(1); // has tagger
expected.push(5);
expected.extend_from_slice(b"Alice");
expected.push(11);
expected.extend_from_slice(b"alice@ex.com");
expected.extend_from_slice(&7u32.to_le_bytes());
expected.extend_from_slice(b"release");
expected.extend_from_slice(&1700000000i64.to_le_bytes());
expected.extend_from_slice(&0i16.to_le_bytes());
expected.push(0);
assert_eq!(encoded, expected);
}

#[test]
fn test_encode_tag_no_tagger() {
let tag = Tag::with_meta(
"v2.0".into(),
make_hash(0x20),
None,
"".into(),
make_meta(1700000000, 0, None),
)
.unwrap();
let mut buf = Cursor::new(Vec::new());
BinaryEncoder.encode_tag(&tag, &mut buf).unwrap();
let encoded = buf.into_inner();

let mut expected = Vec::new();
expected.push(VERSION);
expected.push(4);
expected.extend_from_slice(b"v2.0");
expected.extend_from_slice(&hash_bytes(0x20));
expected.push(0); // no tagger
expected.extend_from_slice(&0u32.to_le_bytes());
expected.extend_from_slice(&1700000000i64.to_le_bytes());
expected.extend_from_slice(&0i16.to_le_bytes());
expected.push(0);
assert_eq!(encoded, expected);
}

#[test]
fn test_encode_tag_with_encoding() {
let tag = Tag::with_meta(
"v3".into(),
make_hash(0x30),
Some(make_user_id("B", "b@c.d")),
"tag".into(),
make_meta(1700000000, -3600, Some("UTF-8")),
)
.unwrap();
let mut buf = Cursor::new(Vec::new());
BinaryEncoder.encode_tag(&tag, &mut buf).unwrap();
let encoded = buf.into_inner();

let mut expected = Vec::new();
expected.push(VERSION);
expected.push(2); // "v3" length
expected.extend_from_slice(b"v3");
expected.extend_from_slice(&hash_bytes(0x30));
expected.push(1);
expected.push(1);
expected.extend_from_slice(b"B");
expected.push(5);
expected.extend_from_slice(b"b@c.d");
expected.extend_from_slice(&3u32.to_le_bytes());
expected.extend_from_slice(b"tag");
expected.extend_from_slice(&1700000000i64.to_le_bytes());
expected.extend_from_slice(&(-3600i16).to_le_bytes());
expected.push(5);
expected.extend_from_slice(b"UTF-8");
assert_eq!(encoded, expected);
}
}
74 changes: 0 additions & 74 deletions libvctrl_core/src/hash/sha512.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28,77 +28,3 @@ impl Hasher for Sha512Hasher {
Hash::from_bytes(&digest)
}
}

#[cfg(test)]
mod tests {
use super::*;
use libvctrl_handler::HASH_LENGTH;
use std::io::Cursor;

#[test]
fn test_hash_empty_input() {
let cursor = Cursor::new(Vec::<u8>::new());
let result = Sha512Hasher.hash(cursor);
assert!(result.is_ok(), "hashing empty input should succeed");
let hash = result.unwrap();
assert_eq!(
hash.as_bytes().len(),
HASH_LENGTH,
"hash should be HASH_LENGTH bytes"
);
}

#[test]
fn test_hash_non_empty_input() {
let cursor = Cursor::new(b"hello world");
let result = Sha512Hasher.hash(cursor);
assert!(result.is_ok());
let hash = result.unwrap();
assert_eq!(hash.as_bytes().len(), HASH_LENGTH);
}

#[test]
fn test_hash_deterministic() {
let data = b"test data for determinism check";
let h1 = Sha512Hasher.hash(Cursor::new(data.as_slice())).unwrap();
let h2 = Sha512Hasher.hash(Cursor::new(data.as_slice())).unwrap();
assert_eq!(
h1.as_bytes(),
h2.as_bytes(),
"same input must produce identical hash"
);
}

#[test]
fn test_hash_different_inputs_produce_different_hashes() {
let h1 = Sha512Hasher.hash(Cursor::new(b"input one")).unwrap();
let h2 = Sha512Hasher.hash(Cursor::new(b"input two")).unwrap();
assert_ne!(
h1.as_bytes(),
h2.as_bytes(),
"different inputs should produce different hashes"
);
}

#[test]
fn test_hash_large_input() {
let data = vec![0xABu8; 100_000];
let result = Sha512Hasher.hash(Cursor::new(data));
assert!(result.is_ok(), "hashing large input should succeed");
let hash = result.unwrap();
assert_eq!(hash.as_bytes().len(), HASH_LENGTH);
}

#[test]
fn test_hash_single_byte() {
let result = Sha512Hasher.hash(Cursor::new(b"\x00"));
assert!(result.is_ok());
let result2 = Sha512Hasher.hash(Cursor::new(b"\xFF"));
assert!(result2.is_ok());
assert_ne!(
result.unwrap().as_bytes(),
result2.unwrap().as_bytes(),
"different single bytes should produce different hashes"
);
}
}
Loading