icydb-core 0.157.12

//! Module: db::identity::tests
//! Covers identity helper behavior for generated and typed entity identifiers.
//! Does not own: cross-module orchestration outside this module.
//! Boundary: exposes this module API while keeping implementation details internal.

use super::*;

const ENTITY_64_B: &str = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
const FIELD_64_B: &str = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";

fn accepted_ascii_identity_bytes() -> impl Iterator<Item = u8> {
    (0..=MAX_ASCII_BYTE).filter(|byte| *byte != INDEX_NAME_SEGMENT_DELIMITER)
}

#[test]
fn index_name_max_len_matches_limits() {
    let expanding = "aA".repeat(MAX_ENTITY_NAME_LEN / 2);
    let entity = EntityName::try_from_str(expanding.as_str()).unwrap();
    let fields = [
        expanding.as_str(),
        expanding.as_str(),
        expanding.as_str(),
        expanding.as_str(),
    ];

    assert_eq!(entity.as_str().len(), MAX_ENTITY_NAME_LEN);
    for field in &fields {
        assert_eq!(field.len(), MAX_INDEX_FIELD_NAME_LEN);
    }
    assert_eq!(fields.len(), MAX_INDEX_FIELDS);

    let name = IndexName::try_unique_from_parts(&entity, &fields).unwrap();
    assert_eq!(name.as_bytes().len(), MAX_INDEX_NAME_LEN);
}

#[test]
fn index_name_max_size_roundtrip_and_ordering() {
    let entity_64 = "a".repeat(MAX_ENTITY_NAME_LEN);
    let entity_a = EntityName::try_from_str(entity_64.as_str()).unwrap();
    let entity_b = EntityName::try_from_str(ENTITY_64_B).unwrap();

    let fields_a = [
        entity_64.as_str(),
        entity_64.as_str(),
        entity_64.as_str(),
        entity_64.as_str(),
    ];
    let fields_b = [FIELD_64_B, FIELD_64_B, FIELD_64_B, FIELD_64_B];

    let idx_a = IndexName::try_from_parts(&entity_a, &fields_a).unwrap();
    let idx_b = IndexName::try_from_parts(&entity_b, &fields_b).unwrap();

    let decoded = IndexName::from_bytes(&idx_a.to_bytes()).unwrap();
    assert_eq!(idx_a, decoded);

    assert_eq!(idx_a.cmp(&idx_b), idx_a.to_bytes().cmp(&idx_b.to_bytes()));
}

#[test]
fn rejects_too_many_index_fields() {
    let entity = EntityName::try_from_str("entity").unwrap();
    let fields = ["a", "b", "c", "d", "e"];

    let err = IndexName::try_from_parts(&entity, &fields).unwrap_err();
    assert!(matches!(err, IndexNameError::TooManyFields { .. }));
}

#[test]
fn rejects_index_with_no_fields() {
    let entity = EntityName::try_from_str("entity").unwrap();

    let err = IndexName::try_from_parts(&entity, &[]).unwrap_err();
    assert!(matches!(err, IndexNameError::NoFields));
}

#[test]
fn rejects_empty_index_field_segment() {
    let entity = EntityName::try_from_str("entity").unwrap();

    let err = IndexName::try_from_parts(&entity, &[""]).unwrap_err();
    assert!(matches!(err, IndexNameError::FieldEmpty));
}

#[test]
fn rejects_index_field_over_len() {
    let entity = EntityName::try_from_str("entity").unwrap();
    let long_field = "a".repeat(MAX_INDEX_FIELD_NAME_LEN + 1);

    let err = IndexName::try_from_parts(&entity, &[long_field.as_str()]).unwrap_err();
    assert!(matches!(err, IndexNameError::FieldTooLong { .. }));
}

#[test]
fn rejects_index_field_delimiter_that_would_alias_segments() {
    fn legacy_join(entity: &str, fields: &[&str]) -> String {
        let mut out = entity.to_string();
        for field in fields {
            out.push('|');
            out.push_str(field);
        }

        out
    }

    assert_eq!(legacy_join("E", &["a|b"]), legacy_join("E", &["a", "b"]));

    let entity = EntityName::try_from_str("E").unwrap();
    let err = IndexName::try_from_parts(&entity, &["a|b"]).unwrap_err();
    assert!(matches!(err, IndexNameError::FieldDelimiter { .. }));
}

#[test]
fn entity_try_from_str_roundtrip() {
    let e = EntityName::try_from_str("user").unwrap();
    assert_eq!(e.len(), 4);
    assert_eq!(e.as_str(), "user");
}

#[test]
fn entity_rejects_empty() {
    let err = EntityName::try_from_str("").unwrap_err();
    assert!(matches!(err, EntityNameError::Empty));
}

#[test]
fn entity_rejects_len_over_max() {
    let s = "a".repeat(MAX_ENTITY_NAME_LEN + 1);
    let err = EntityName::try_from_str(&s).unwrap_err();
    assert!(matches!(err, EntityNameError::TooLong { .. }));
}

#[test]
fn entity_rejects_non_ascii() {
    let err = EntityName::try_from_str("usér").unwrap_err();
    assert!(matches!(err, EntityNameError::NonAscii));
}

#[test]
fn entity_rejects_index_name_delimiter() {
    let err = EntityName::try_from_str("user|account").unwrap_err();
    assert!(matches!(err, EntityNameError::Delimiter));
}

#[test]
fn entity_storage_roundtrip() {
    let e = EntityName::try_from_str("entity_name").unwrap();
    let bytes = e.to_bytes();
    let decoded = EntityName::from_bytes(&bytes).unwrap();
    assert_eq!(e, decoded);
}

#[test]
fn entity_max_storable_is_ascii_utf8() {
    let max = EntityName::max_storable();
    assert_eq!(max.len(), MAX_ENTITY_NAME_LEN);
    assert!(max.as_str().is_ascii());
}

#[test]
fn entity_max_storable_covers_every_accepted_ascii_byte() {
    let max = EntityName::max_storable();

    for byte in accepted_ascii_identity_bytes() {
        let name = String::from_utf8(vec![byte; MAX_ENTITY_NAME_LEN]).unwrap();
        let entity = EntityName::try_from_str(name.as_str()).unwrap();

        assert!(
            entity <= max,
            "max entity sentinel must cover accepted byte 0x{byte:02X}",
        );
    }
}

#[test]
fn entity_rejects_invalid_size() {
    let buf = vec![0u8; EntityName::STORED_SIZE_USIZE - 1];
    assert!(matches!(
        EntityName::from_bytes(&buf),
        Err(IdentityDecodeError::InvalidSize)
    ));
}

#[test]
fn entity_rejects_len_over_max_from_bytes() {
    let mut buf = [0u8; EntityName::STORED_SIZE_USIZE];
    buf[0] = (MAX_ENTITY_NAME_LEN as u8).saturating_add(1);
    assert!(matches!(
        EntityName::from_bytes(&buf),
        Err(IdentityDecodeError::InvalidLength)
    ));
}

#[test]
fn entity_rejects_non_ascii_from_bytes() {
    let mut buf = [0u8; EntityName::STORED_SIZE_USIZE];
    buf[0] = 1;
    buf[1] = 0xFF;
    assert!(matches!(
        EntityName::from_bytes(&buf),
        Err(IdentityDecodeError::NonAscii)
    ));
}

#[test]
fn entity_rejects_delimiter_from_bytes() {
    let mut buf = [0u8; EntityName::STORED_SIZE_USIZE];
    buf[0] = 1;
    buf[1] = b'|';

    assert!(matches!(
        EntityName::from_bytes(&buf),
        Err(IdentityDecodeError::Delimiter)
    ));
}

#[test]
fn entity_rejects_non_zero_padding() {
    let e = EntityName::try_from_str("user").unwrap();
    let mut bytes = e.to_bytes();
    bytes[1 + e.len()] = b'x';

    assert!(matches!(
        EntityName::from_bytes(&bytes),
        Err(IdentityDecodeError::NonZeroPadding)
    ));
}

#[test]
fn entity_ordering_matches_bytes() {
    let a = EntityName::try_from_str("abc").unwrap();
    let b = EntityName::try_from_str("abd").unwrap();
    let c = EntityName::try_from_str("abcx").unwrap();

    assert_eq!(a.cmp(&b), a.to_bytes().cmp(&b.to_bytes()));
    assert_eq!(a.cmp(&c), a.to_bytes().cmp(&c.to_bytes()));
}

#[test]
fn entity_ordering_is_not_lexicographic() {
    let z = EntityName::try_from_str("z").unwrap();
    let aa = EntityName::try_from_str("aa").unwrap();

    assert_eq!(z.cmp(&aa), Ordering::Less);
    assert_eq!(z.to_bytes().cmp(&aa.to_bytes()), Ordering::Less);
    assert_eq!(z.as_str().cmp(aa.as_str()), Ordering::Greater);
}

#[test]
fn index_single_field_format() {
    let entity = EntityName::try_from_str("user").unwrap();
    let idx = IndexName::try_from_parts(&entity, &["email"]).unwrap();

    assert_eq!(idx.as_str(), "idx_user__email");
}

#[test]
fn unique_index_single_field_format() {
    let entity = EntityName::try_from_str("user").unwrap();
    let idx = IndexName::try_unique_from_parts(&entity, &["email"]).unwrap();

    assert_eq!(idx.as_str(), "uniq_user__email");
}

#[test]
fn index_field_order_is_preserved() {
    let entity = EntityName::try_from_str("user").unwrap();
    let idx = IndexName::try_from_parts(&entity, &["a", "b", "c"]).unwrap();

    assert_eq!(idx.as_str(), "idx_user__a_b_c");
}

#[test]
fn index_name_slugs_entity_and_expression_key_items() {
    let entity = EntityName::try_from_str("UserAccount").unwrap();
    let idx = IndexName::try_from_parts(&entity, &["LOWER(email)", "profile.nickname"]).unwrap();

    assert_eq!(
        idx.as_str(),
        "idx_user_account__lower_email_profile_nickname"
    );
}

#[test]
fn index_storage_roundtrip() {
    let entity = EntityName::try_from_str("user").unwrap();
    let idx = IndexName::try_from_parts(&entity, &["a", "b"]).unwrap();

    let bytes = idx.to_bytes();
    let decoded = IndexName::from_bytes(&bytes).unwrap();
    assert_eq!(idx, decoded);
}

#[test]
fn index_from_bytes_decodes_flat_canonical_payload() {
    let mut bytes = [0u8; IndexName::STORED_SIZE_USIZE];
    let payload = b"idx_e__a_b";
    bytes[..2].copy_from_slice(&(payload.len() as u16).to_be_bytes());
    bytes[2..2 + payload.len()].copy_from_slice(payload);

    let decoded = IndexName::from_bytes(&bytes).unwrap();
    assert_eq!(decoded.as_str(), "idx_e__a_b");
}

#[test]
fn index_max_storable_is_ascii_utf8() {
    let max = IndexName::max_storable();
    assert_eq!(max.as_bytes().len(), MAX_INDEX_NAME_LEN);
    assert!(max.as_str().is_ascii());
}

#[test]
fn index_max_storable_covers_every_accepted_ascii_byte() {
    let max = IndexName::max_storable();

    for byte in accepted_ascii_identity_bytes() {
        let mut entity_bytes = vec![b'a'];
        entity_bytes.extend(vec![byte; MAX_ENTITY_NAME_LEN - 1]);
        let entity_name = String::from_utf8(entity_bytes).unwrap();
        let mut field_bytes = vec![b'a'];
        field_bytes.extend(vec![byte; MAX_INDEX_FIELD_NAME_LEN - 1]);
        let field_name = String::from_utf8(field_bytes).unwrap();
        let entity = EntityName::try_from_str(entity_name.as_str()).unwrap();
        let fields = [
            field_name.as_str(),
            field_name.as_str(),
            field_name.as_str(),
            field_name.as_str(),
        ];
        let index = IndexName::try_from_parts(&entity, &fields).unwrap();

        assert!(
            index <= max,
            "max index sentinel must cover accepted byte 0x{byte:02X}",
        );
    }
}

#[test]
fn index_rejects_non_ascii_from_bytes() {
    let mut buf = [0u8; IndexName::STORED_SIZE_USIZE];
    buf[..2].copy_from_slice(&1u16.to_be_bytes());
    buf[2] = 0xFF;

    assert!(matches!(
        IndexName::from_bytes(&buf),
        Err(IdentityDecodeError::NonAscii)
    ));
}

// ------------------------------------------------------------------
// FUZZING (deterministic)
// ------------------------------------------------------------------

fn gen_ascii(seed: u64, max_len: usize) -> String {
    let len = (seed as usize % max_len).max(1);
    let mut out = String::with_capacity(len);

    let mut x = seed;
    for _ in 0..len {
        x = x.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1);
        let c = b'a' + (x % 26) as u8;
        out.push(c as char);
    }

    out
}

#[test]
fn fuzz_entity_name_roundtrip_and_ordering() {
    let mut prev: Option<EntityName> = None;

    for i in 1..=1_000u64 {
        let s = gen_ascii(i, MAX_ENTITY_NAME_LEN);
        let e = EntityName::try_from_str(&s).unwrap();

        let bytes = e.to_bytes();
        let decoded = EntityName::from_bytes(&bytes).unwrap();
        assert_eq!(e, decoded);

        if let Some(p) = prev {
            assert_eq!(p.cmp(&e), p.to_bytes().cmp(&e.to_bytes()));
        }

        prev = Some(e);
    }
}

#[test]
fn fuzz_index_name_roundtrip_and_ordering() {
    let entity = EntityName::try_from_str("entity").unwrap();
    let mut prev: Option<IndexName> = None;

    for i in 1..=1_000u64 {
        let field_count = (i as usize % MAX_INDEX_FIELDS).max(1);

        let mut fields = Vec::with_capacity(field_count);
        for f in 0..field_count {
            let s = gen_ascii(i * 31 + f as u64, MAX_INDEX_FIELD_NAME_LEN);
            fields.push(s);
        }

        let field_refs: Vec<&str> = fields.iter().map(String::as_str).collect();
        let idx = IndexName::try_from_parts(&entity, &field_refs).unwrap();

        let bytes = idx.to_bytes();
        let decoded = IndexName::from_bytes(&bytes).unwrap();
        assert_eq!(idx, decoded);

        if let Some(p) = prev {
            assert_eq!(p.cmp(&idx), p.to_bytes().cmp(&idx.to_bytes()));
        }

        prev = Some(idx);
    }
}