snowid 2.1.0

A Rust library for generating SnowID - a Snowflake-like timestamp-based distributed unique identifier
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

//! Configuration tests

#[cfg(test)]
mod tests {
    use crate::SnowID;
    use crate::config::{SnowIDConfig, SnowIDConfigError};

    #[test]
    fn test_valid_node_bits() {
        for bits in 6..=16 {
            let config = SnowIDConfig::builder().node_bits(bits).unwrap().build();
            assert_eq!(config.node_bits(), bits);
            assert_eq!(config.sequence_bits(), SnowID::TOTAL_NODE_AND_SEQUENCE_BITS - bits);
        }
    }

    #[test]
    fn test_node_bits_ok() {
        let cfg = SnowIDConfig::builder().node_bits(12).unwrap().build();
        assert_eq!(cfg.node_bits(), 12);
    }

    #[test]
    fn test_node_bits_err() {
        let err = SnowIDConfig::builder().node_bits(5).unwrap_err();
        assert_eq!(err, SnowIDConfigError::InvalidNodeBits { bits: 5 });
    }

    #[test]
    fn test_custom_config() {
        let config = SnowIDConfig::builder().node_bits(12).unwrap().epoch(1640995200000).build();

        assert_eq!(config.node_bits(), 12);
        assert_eq!(config.sequence_bits(), 10);
        assert_eq!(config.epoch(), 1640995200000);
    }

    #[test]
    fn test_default_config() {
        let config = SnowIDConfig::default();
        assert_eq!(config.node_bits(), 10);
        assert_eq!(config.sequence_bits(), 12);
        assert!(config.spin_enabled());
    }

    #[test]
    fn test_bit_config() {
        let config = SnowIDConfig::default();
        assert_eq!(config.max_sequence_id(), 0xFFF);
        assert_eq!(config.max_node_id(), 0x3FF);
    }

    #[test]
    fn test_spin_tuning_builder() {
        let cfg = SnowIDConfig::builder().enable_spin(false).spin_loops(0).spin_yield_every(0).build();
        assert!(!cfg.spin_enabled());
        assert_eq!(cfg.spin_loops(), 0);
        assert_eq!(cfg.spin_yield_every(), 0);

        let cfg2 = SnowIDConfig::builder().enable_spin(true).spin_loops(128).spin_yield_every(8).build();
        assert!(cfg2.spin_enabled());
        assert_eq!(cfg2.spin_loops(), 128);
        assert_eq!(cfg2.spin_yield_every(), 8);
    }
}