cqlite-core 0.11.0

Core engine for CQLite — read Apache Cassandra 5.0 SSTables locally without a cluster
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! Platform abstraction layer for cross-platform compatibility

use crate::{Config, Result};

pub mod fs;
pub mod threading;
pub mod time;

/// Platform abstraction layer
#[derive(Debug)]
pub struct Platform {
    /// File system abstraction
    fs: fs::FileSystem,

    /// Time utilities
    time: time::TimeProvider,

    /// Threading utilities
    threading: threading::ThreadingProvider,

    /// Configuration
    config: Config,
}

impl Platform {
    /// Create a new platform abstraction
    pub async fn new(config: &Config) -> Result<Self> {
        Ok(Self {
            fs: fs::FileSystem::new().await?,
            time: time::TimeProvider::new(),
            threading: threading::ThreadingProvider::new(),
            config: config.clone(),
        })
    }

    /// Get file system abstraction
    pub fn fs(&self) -> &fs::FileSystem {
        &self.fs
    }

    /// Get time provider
    pub fn time(&self) -> &time::TimeProvider {
        &self.time
    }

    /// Get threading provider
    pub fn threading(&self) -> &threading::ThreadingProvider {
        &self.threading
    }

    /// Get configuration
    pub fn config(&self) -> &Config {
        &self.config
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::Path;
    use tempfile::TempDir;

    #[tokio::test]
    async fn test_platform_creation() {
        let config = Config::default();
        let platform = Platform::new(&config).await.unwrap();

        assert!(platform.fs().exists(Path::new(".")).await.unwrap());
    }

    #[tokio::test]
    async fn test_file_system() {
        let config = Config::default();
        let platform = Platform::new(&config).await.unwrap();
        let fs = platform.fs();

        let temp_dir = TempDir::new().unwrap();
        let test_file = temp_dir.path().join("test.txt");
        let content = b"Hello, World!";

        // Write file
        fs.write_file(&test_file, content).await.unwrap();

        // Check exists
        assert!(fs.exists(&test_file).await.unwrap());

        // Read file
        let read_content = fs.read_file(&test_file).await.unwrap();
        assert_eq!(read_content, content);

        // Get file size
        let size = fs.file_size(&test_file).await.unwrap();
        assert_eq!(size, content.len() as u64);

        // Remove file
        fs.remove_file(&test_file).await.unwrap();
        assert!(!fs.exists(&test_file).await.unwrap());
    }

    #[test]
    fn test_time_provider() {
        let time = time::TimeProvider::new();

        let now_micros = time.now_micros();
        let now_millis = time.now_millis();
        let now_secs = time.now_secs();

        assert!(now_micros > 0);
        assert!(now_millis > 0);
        assert!(now_secs > 0);

        // Check relationships with tolerance for timing differences
        // Allow for small variations due to multiple system calls
        let micros_to_millis = now_micros / 1000;
        let millis_to_secs = now_millis / 1000;

        // Allow small tolerance for timing variations between system calls
        let tolerance_ms: u64 = 5;
        let tolerance_sec: u64 = 1;

        assert!(
            micros_to_millis >= now_millis.saturating_sub(tolerance_ms),
            "micros_to_millis ({}) should be within {}ms of now_millis ({})",
            micros_to_millis,
            tolerance_ms,
            now_millis
        );
        assert!(
            millis_to_secs >= now_secs.saturating_sub(tolerance_sec),
            "millis_to_secs ({}) should be within {}s of now_secs ({})",
            millis_to_secs,
            tolerance_sec,
            now_secs
        );
    }

    #[tokio::test]
    async fn test_threading_provider() {
        let threading = threading::ThreadingProvider::new();

        let result = threading.execute_cpu_task(|| 42).await.unwrap();

        assert_eq!(result, 42);

        let result = threading
            .execute_io_task(|| "hello".to_string())
            .await
            .unwrap();

        assert_eq!(result, "hello");
    }
}