thespis_impl 0.3.0

Reference implementation for the thespis actor model
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

// Tested:
//
// ✔ let thread of mailbox crash and verify mailbox closed error
// ✔ let thread of mailbox crash and verify mailbox closed before response error
//
#![ cfg(not( target_arch = "wasm32" )) ]


mod common;

use
{
	common :: { actors::*, import::*    } ,
	std    :: { panic::AssertUnwindSafe } ,
};



// What we need to achieve here is that the mailbox is spawned, then closed while we
// keep the addr to try and Send. We should then get a MailboxClosed error.
//
#[async_std::test]
//
async fn mb_closed() -> Result<(), DynError >
{
	let (mut addr, mb) = Addr::builder( "mb_closed" ).build();

	let (trigger_tx, trigger_rx) = oneshot::channel();


	let mb_task = async move
	{
		mb.start( Sum(5) ).await;

		trigger_tx.send(()).expect( "send trigger" );
	};

	let mb_handle = AsyncStd.spawn_handle( mb_task )?;


	// Make sure the mailbox is actually up and running before moving on.
	//
	addr.call( Add(10) ).await?;

	drop( mb_handle );

	// since we drop the handle, it's gonna fire not because of the send, but
	// because it get's dropped, so we don't care for success here.
	//
	assert!( trigger_rx.await.is_err() );


	match addr.send( Add(10) ).await
	{
		Ok (_) => panic!( "Addr::send should fail" ),

		Err(e) => match e
		{
			ThesErr::MailboxClosed{..} => {}
			_                          => panic!( "Wrong error returned: {:?}", e ),
		}
	}

	Ok(())
}




#[ derive( Actor ) ] struct Panic;

struct Void;

impl Message for Void { type Return = (); }

impl Handler<Void> for Panic
{
	fn handle( &mut self, _: Void ) -> Return<'_, ()>
	{
		panic!();
	}
}


#[async_std::test]
//
async fn mb_closed_before_response() -> Result<(), DynError >
{
	// flexi_logger::Logger::with_str( "warn, thespis_impl=trace" ).start().expect( "flexi_logger");

	let (mut addr, mb) = Addr::builder( "mb_closed_before_response" ).build();


	let mb_task = async move
	{
		let _ = AssertUnwindSafe( mb.start( Panic ) ).catch_unwind().await;
	};

	AsyncStd.spawn( mb_task )?;


	match addr.call( Void ).await
	{
		Ok (_) => panic!( "Call should fail" ),

		Err(e) => match e
		{
			ThesErr::ActorStoppedBeforeResponse{..} => {}
			_ => panic!( "Wrong error returned: {:?}", e ),
		}
	}

	Ok(())
}