easerx 0.1.1

A reactive MVI (Model-View-Intent) framework for Rust.
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
153
154
155

use crate::unit_tests::TestState;
use crate::{Async, StateStore};
use std::time::Duration;
use crate::StreamExt;
use tokio::time::sleep;
use crate::async_error::AsyncError;

// Test state store initialization
#[tokio::test]
async fn test_state_store_initialization() {
    let initial_state = TestState {
        count: 10,
        data: Async::success("initial".to_string()),
    };

    let store = StateStore::new(initial_state.clone());
    let state = store.get_state();

    assert_eq!(state.count, 10);
    assert!(matches!(
        state.data,
        Async::Success { value } if value == "initial"
    ));
}

// Test synchronous state updates
#[tokio::test]
async fn test_set_state() -> Result<(), AsyncError> {
    let store = StateStore::new(TestState::default());

    // Update state synchronously
    store.set_state(|state| state.add_count(10))?;

    let state = store.await_state().await;
    assert_eq!(
        state,
        Ok(TestState {
            count: 10,
            data: Async::Uninitialized
        })
    );
    Ok(())
}

/*#[tokio::test]
async fn test_set_state_panic() -> Result<(), AsyncError> {
    let store = StateStore::new(TestState::default());

    // Update state synchronously
    store.set_state(|_state| {
        panic!("set_state panic");
        _state.add_count(10)
    })?;

    let state = store.await_state().await;
    assert_eq!(state, Err(AsyncError::error("channel closed")));
    Ok(())
}*/

// Test with_state functionality
#[tokio::test]
async fn test_with_state() -> Result<(), AsyncError> {
    let store = StateStore::new(TestState::default());
    store.set_state(|state| state.add_count(100))?;

    let (tx, rx) = tokio::sync::oneshot::channel();
    store.with_state(move |state| {
        let _ = tx.send(state.count);
    })?;

    let counter = rx.await.unwrap();
    assert_eq!(counter, 100);
    Ok(())
}

#[tokio::test]
async fn test_with_state_panic() -> Result<(), AsyncError> {
    let store = StateStore::new(TestState::default());
    store.set_state(|state| state.add_count(100))?;

    let (tx, rx) = tokio::sync::oneshot::channel();
    store.with_state(move |state| {
        let _ = tx.send(state.count);
        panic!("with_state panic");
    })?;

    let counter = rx.await.unwrap();
    assert_eq!(counter, 100);
    Ok(())
}

#[tokio::test]
async fn test_get_state() -> Result<(), AsyncError> {
    let store = StateStore::new(TestState::default());

    // Update state
    store.set_state(|state| TestState { count: 18, ..state })?;
    sleep(Duration::from_millis(100)).await;
    // Await state and verify
    let state = store.get_state();
    assert_eq!(state.count, 18);
    Ok(())
}

// Test await_state functionality
#[tokio::test]
async fn test_await_state() -> Result<(), AsyncError> {
    let store = StateStore::new(TestState::default());

    // Update state
    store.set_state(|state| TestState { count: 38, ..state })?;

    // Await state and verify
    let state = store.await_state().await.unwrap();
    assert_eq!(state.count, 38);
    Ok(())
}

// Test state stream
#[tokio::test]
async fn test_state_stream() -> Result<(), AsyncError> {
    let store = StateStore::new(TestState::default());
    let mut updates = Vec::new();

    // Create a stream to collect state updates
    let mut stream = store.to_stream();
    let handle = tokio::spawn(async move {
        while let Some(state) = stream.next().await {
            updates.push(state.count);
            if updates.len() >= 3 {
                break;
            }
        }
        updates
    });

    // Make several state updates
    store.set_state(|state| state.set_count(1))?;

    sleep(Duration::from_millis(10)).await;

    store.set_state(|state| state.set_count(2))?;

    sleep(Duration::from_millis(10)).await;

    store.set_state(|state| state.set_count(3))?;

    // Wait for the stream to collect all updates
    let collected_updates = handle.await.unwrap();

    // We should have at least the initial state and our 3 updates
    assert_eq!(collected_updates.len(), 3);
    assert_eq!(collected_updates, [1, 2, 3]);
    Ok(())
}