admixture-harness 0.1.0

Test harness with context lifecycle management and grouped execution
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

//! Test demonstrating multiple context types and context reuse
//!
//! This file shows how the harness groups tests by context type and reuses contexts.

use admixture::context;
use admixture::service;
use admixture::service::ServiceRunning;
use admixture_harness::prelude::*;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;

// First service type using service! macro
#[derive(Debug, thiserror::Error)]
#[error("Database service error")]
pub struct DatabaseServiceError;

service! {
    DatabaseService {
        error: DatabaseServiceError,

        running {
            stopped: Arc<AtomicBool>,
        }

        async fn start(self) -> Result<DatabaseServiceRunning, DatabaseServiceError> {
            println!("      🔧 Starting Database service");
            Ok(DatabaseServiceRunning {
                stopped: Arc::new(AtomicBool::new(false)),
            })
        }

        async fn stop(&mut self) -> Result<(), DatabaseServiceError> {
            println!("      🛑 Stopping Database service");
            self.stopped.store(true, Ordering::SeqCst);
            Ok(())
        }
    }
}

// Second service type using service! macro
#[derive(Debug, thiserror::Error)]
#[error("Cache service error")]
pub struct CacheServiceError;

service! {
    CacheService {
        error: CacheServiceError,

        running {
            stopped: Arc<AtomicBool>,
        }

        async fn start(self) -> Result<CacheServiceRunning, CacheServiceError> {
            println!("      🔧 Starting Cache service");
            Ok(CacheServiceRunning {
                stopped: Arc::new(AtomicBool::new(false)),
            })
        }

        async fn stop(&mut self) -> Result<(), CacheServiceError> {
            println!("      🛑 Stopping Cache service");
            self.stopped.store(true, Ordering::SeqCst);
            Ok(())
        }
    }
}

// Define first context with just database
context! {
    DatabaseContext {
        database: DatabaseServiceSetup = DatabaseServiceConfig {},
    }
}

// Define second context with just cache
context! {
    CacheContext {
        cache: CacheServiceSetup = CacheServiceConfig {},
    }
}

// Define third context with both services
context! {
    FullContext {
        database: DatabaseServiceSetup = DatabaseServiceConfig {},
        cache: CacheServiceSetup = CacheServiceConfig {},
    }
}

// Tests using DatabaseContext (will share context)
#[admixture_test(context = DatabaseContext)]
async fn test_database_query_1(ctx: &DatabaseContext) -> Result<(), TestError> {
    ctx.database().healthy().await.unwrap();
    Ok(())
}

#[admixture_test(context = DatabaseContext)]
async fn test_database_query_2(ctx: &DatabaseContext) -> Result<(), TestError> {
    ctx.database().healthy().await.unwrap();
    Ok(())
}

// Tests using CacheContext (will share context)
#[admixture_test(context = CacheContext)]
async fn test_cache_get_1(ctx: &CacheContext) -> Result<(), TestError> {
    ctx.cache().healthy().await.unwrap();
    Ok(())
}

#[admixture_test(context = CacheContext)]
async fn test_cache_get_2(ctx: &CacheContext) -> Result<(), TestError> {
    ctx.cache().healthy().await.unwrap();
    Ok(())
}

// Tests using FullContext (will share context)
#[admixture_test(context = FullContext)]
async fn test_full_integration_1(ctx: &FullContext) -> Result<(), TestError> {
    ctx.database().healthy().await.unwrap();
    ctx.cache().healthy().await.unwrap();
    Ok(())
}

#[admixture_test(context = FullContext)]
async fn test_full_integration_2(ctx: &FullContext) -> Result<(), TestError> {
    ctx.database().healthy().await.unwrap();
    ctx.cache().healthy().await.unwrap();
    Ok(())
}

#[admixture_test(context = FullContext)]
async fn test_full_integration_3(ctx: &FullContext) -> Result<(), TestError> {
    ctx.database().healthy().await.unwrap();
    ctx.cache().healthy().await.unwrap();
    Ok(())
}

// Generate the test runner
admixture_harness::test_runner!();