dactor-mock 0.2.0

Mock multi-node cluster for testing dactor actor systems
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

use dactor::node::NodeId;
use dactor::system_actors::{CancelManager, NodeDirectory, PeerStatus, SpawnManager, WatchManager};
use dactor::test_support::test_runtime::TestRuntime;
use dactor::type_registry::TypeRegistry;

/// A simulated node in a MockCluster.
///
/// Each node has its own runtime, identity, and system actors for
/// simulated remote operations (spawn, watch, cancel).
pub struct MockNode {
    pub node_id: NodeId,
    pub runtime: TestRuntime,
    /// Manages remote actor spawn requests for this node.
    pub spawn_manager: SpawnManager,
    /// Manages remote watch/unwatch subscriptions for this node.
    pub watch_manager: WatchManager,
    /// Manages remote cancellation requests for this node.
    pub cancel_manager: CancelManager,
    /// Tracks peer node connection state.
    pub node_directory: NodeDirectory,
}

impl MockNode {
    pub fn new(node_id: NodeId) -> Self {
        let runtime = TestRuntime::with_node_id(node_id.clone());
        Self {
            node_id,
            runtime,
            spawn_manager: SpawnManager::new(TypeRegistry::new()),
            watch_manager: WatchManager::new(),
            cancel_manager: CancelManager::new(),
            node_directory: NodeDirectory::new(),
        }
    }

    /// Register an actor type for remote spawning on this node.
    pub fn register_factory(
        &mut self,
        type_name: impl Into<String>,
        factory: impl Fn(&[u8]) -> Result<Box<dyn std::any::Any + Send>, dactor::remote::SerializationError>
            + Send
            + Sync
            + 'static,
    ) {
        self.spawn_manager
            .type_registry_mut()
            .register_factory(type_name, factory);
    }

    /// Connect this node to a peer (marks as Connected in directory).
    pub fn connect_peer(&mut self, peer: &NodeId) {
        self.node_directory.add_peer(peer.clone(), None);
        self.node_directory.set_status(peer, PeerStatus::Connected);
    }

    /// Disconnect a peer node.
    pub fn disconnect_peer(&mut self, peer: &NodeId) {
        self.node_directory
            .set_status(peer, PeerStatus::Disconnected);
    }
}