cqlite-cli 0.11.0

Command-line interface for CQLite — read Apache Cassandra 5.0 SSTables 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

//! Testing infrastructure for CQLite CLI
//!
//! This module provides comprehensive testing utilities including:
//! - TestContainer pattern for dependency injection
//! - CLI test utilities and helpers
//! - Test data fixtures and builders
//! - Integration test framework
//! - Performance testing utilities

pub mod assertions;
pub mod cli_helpers;
pub mod container;
pub mod fixtures;
pub mod integration;
#[cfg(feature = "benchmarks")]
pub mod performance;

// Re-export commonly used types
pub use assertions::{ErrorAssertion, OutputAssertion, ResultAssertion};
pub use cli_helpers::{CliTestBuilder, CliTestRunner, CommandAssertion};
pub use container::{TestContainer, TestDatabase, TestEnvironment};
pub use fixtures::{SSTableFixture, SchemaFixture, TestDataBuilder};
pub use integration::{E2ETestRunner, IntegrationTestSuite};
#[cfg(feature = "benchmarks")]
pub use performance::{BenchmarkSuite, PerformanceTestRunner};

/// Common test result type
pub type TestResult<T = ()> = Result<T, Box<dyn std::error::Error + Send + Sync>>;

/// Test configuration builder
#[derive(Debug, Clone)]
pub struct TestConfig {
    pub timeout: std::time::Duration,
    pub parallel: bool,
    pub verbose: bool,
    pub temp_dir: Option<std::path::PathBuf>,
    pub cleanup: bool,
}

impl Default for TestConfig {
    fn default() -> Self {
        Self {
            timeout: std::time::Duration::from_secs(30),
            parallel: false,
            verbose: false,
            temp_dir: None,
            cleanup: true,
        }
    }
}

impl TestConfig {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_timeout(mut self, timeout: std::time::Duration) -> Self {
        self.timeout = timeout;
        self
    }

    pub fn with_parallel(mut self) -> Self {
        self.parallel = true;
        self
    }

    pub fn with_verbose(mut self) -> Self {
        self.verbose = true;
        self
    }

    pub fn with_temp_dir<P: Into<std::path::PathBuf>>(mut self, dir: P) -> Self {
        self.temp_dir = Some(dir.into());
        self
    }

    pub fn no_cleanup(mut self) -> Self {
        self.cleanup = false;
        self
    }
}

/// Macro for creating test containers with automatic cleanup
#[macro_export]
macro_rules! test_container {
    ($name:ident) => {
        let $name = $crate::test_infrastructure::TestContainer::new()?;
    };
    ($name:ident, $config:expr) => {
        let $name = $crate::test_infrastructure::TestContainer::with_config($config)?;
    };
}

/// Macro for CLI test assertions
#[macro_export]
macro_rules! assert_cli_success {
    ($cmd:expr) => {
        $cmd.assert().success();
    };
    ($cmd:expr, $expected:expr) => {
        $cmd.assert()
            .success()
            .stdout(predicates::str::contains($expected));
    };
}

/// Macro for CLI error assertions
#[macro_export]
macro_rules! assert_cli_error {
    ($cmd:expr) => {
        $cmd.assert().failure();
    };
    ($cmd:expr, $expected:expr) => {
        $cmd.assert()
            .failure()
            .stderr(predicates::str::contains($expected));
    };
}