oxcache 0.1.4

A high-performance multi-level cache library for Rust with L1 (memory) and L2 (Redis) caching.
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

#![allow(deprecated)]
// Copyright (c) 2025-2026, Kirky.X
//
// MIT License
//
// SeaORM SQLite测试

use sea_orm::{ConnectOptions, ConnectionTrait, Database};
use std::fs::File;

fn create_test_connect_options(db_path: &str) -> ConnectOptions {
    let mut opt = ConnectOptions::new(db_path.to_string());
    opt.max_connections(1)
        .min_connections(0)
        .connect_timeout(std::time::Duration::from_secs(10))
        .sqlx_logging(true);
    opt
}

async fn test_basic_connection(db_path: &str) -> bool {
    let opt = create_test_connect_options(db_path);

    match Database::connect(opt).await {
        Ok(db) => {
            println!("✓ Connection succeeded: {}", db_path);

            let result = db
                .execute(sea_orm::Statement::from_string(
                    sea_orm::DatabaseBackend::Sqlite,
                    "SELECT 1 as test".to_string(),
                ))
                .await;

            match result {
                Ok(_) => {
                    println!("✓ Query test succeeded");
                    true
                }
                Err(e) => {
                    println!("✗ Query test failed: {}", e);
                    false
                }
            }
        }
        Err(e) => {
            println!("✗ Connection failed: {} - {}", db_path, e);
            false
        }
    }
}

mod minimal_config_tests {
    use super::*;

    #[tokio::test]
    async fn test_sea_orm_sqlite_minimal() {
        let db_name = "test_sea_orm_minimal.db";
        let _ = std::fs::remove_file(db_name);

        println!(
            "Testing sea-orm SQLite with minimal configuration: {}",
            db_name
        );
        test_basic_connection(&format!("sqlite:{}", db_name)).await;

        let _ = std::fs::remove_file(db_name);
    }

    #[tokio::test]
    async fn test_sea_orm_sqlite_with_logging() {
        let db_name = "test_sea_orm_logging.db";
        let _ = std::fs::remove_file(db_name);

        println!("Testing sea-orm SQLite with detailed logging: {}", db_name);
        test_basic_connection(&format!("sqlite:{}", db_name)).await;

        let _ = std::fs::remove_file(db_name);
    }
}

mod file_creation_tests {
    use super::*;

    #[tokio::test]
    async fn test_sea_orm_sqlite_create_file_first() {
        let db_path = "/tmp/test_sea_orm_created.db";
        let _ = std::fs::remove_file(db_path);

        match File::create(db_path) {
            Ok(_) => println!("✓ Database file created successfully: {}", db_path),
            Err(e) => println!("✗ Failed to create database file: {}", e),
        }

        println!("Testing sea-orm SQLite with pre-created file: {}", db_path);
        test_basic_connection(&format!("sqlite:{}", db_path)).await;

        let _ = std::fs::remove_file(db_path);
    }

    #[tokio::test]
    async fn test_sea_orm_sqlite_memory() {
        println!("Testing sea-orm SQLite with in-memory database");
        test_basic_connection("sqlite::memory:").await;

        println!("Testing sea-orm SQLite with shared in-memory database");
        test_basic_connection("sqlite::memory:?cache=shared").await;
    }
}

mod path_tests {
    use super::*;

    #[tokio::test]
    async fn test_sea_orm_sqlite_absolute_path() {
        let db_path = "/home/project/aybss/crates/infra/oxcache/test_sea_orm_absolute.db";
        let _ = std::fs::remove_file(db_path);

        println!("Testing sea-orm SQLite with absolute path: {}", db_path);
        test_basic_connection(&format!("sqlite:{}", db_path)).await;

        let _ = std::fs::remove_file(db_path);
    }

    #[tokio::test]
    async fn test_sea_orm_sqlite_with_uri_format() {
        let db_path = "/home/project/aybss/crates/infra/oxcache/test_sea_orm_uri.db";
        let _ = std::fs::remove_file(db_path);

        println!("Testing sea-orm SQLite with URI format: {}", db_path);

        let connection_string = format!("sqlite://{}", db_path);
        println!("Connection string: {}", connection_string);

        test_basic_connection(&connection_string).await;

        let _ = std::fs::remove_file(db_path);
    }
}