wasm-link 0.4.0

A WebAssembly plugin runtime based around Wasmtime intended for building fully modular applications
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

use std::collections::HashMap ;

use wasm_link::{ Binding, Engine, Linker, Remap, Val };
use wasm_link::cardinality::ExactlyOne ;

fixtures! {
	bindings = { root: "root", dependency: "dependency" };
	plugins  = { startup: "startup", child: "child" };
}

#[test]
fn dependant_dispatch_encodes_child_errors() -> Result<(), Box<dyn std::error::Error>> {
	let engine = Engine::default();
	let linker = Linker::new( &engine );
	let plugins = fixtures::plugins( &engine );
	let bindings = fixtures::bindings();
	let child = plugins.child.plugin
		.remap_interfaces( HashMap::from([(
			"root".to_string(),
			Remap::found_as_with_item_resolution_table(
				"root",
				HashMap::from([( "get-value".to_string(), "missing".to_string() )]),
			),
		)]))
		.instantiate( &engine, &linker )?;
	let dependency = Binding::new(
		bindings.dependency.package,
		HashMap::from([( bindings.dependency.name, bindings.dependency.spec )]),
		ExactlyOne( "child".to_string(), child ),
	);
	let startup = plugins.startup.plugin.link( &engine, linker, vec![ dependency ])?;
	let root = Binding::new(
		bindings.root.package,
		HashMap::from([( bindings.root.name, bindings.root.spec )]),
		ExactlyOne( "startup".to_string(), startup ),
	);

	let result = root.dispatch( "root", "get-value", &[] )?;
	assert!( matches!(
		&result,
		ExactlyOne( _, Ok( Val::Tuple( items ))) if matches!( items.as_slice(),
			[ Val::String( id ), Val::Result( Err( Some( error ))) ] if
			id == "child"
			&& matches!( &**error, Val::Variant( name, Some( message )) if
				name == "invalid-function"
				&& matches!( &**message, Val::String( function ) if function.ends_with( ":missing" ))
			)
		)
	), "unexpected dispatch result: {result:#?}" );
	Ok(())
}

#[test]
fn async_dependant_dispatch_encodes_child_errors() -> Result<(), Box<dyn std::error::Error>> {
	futures::executor::block_on( async {
		let engine = Engine::default();
		let linker = Linker::new( &engine );
		let executor = futures::executor::ThreadPool::new()?;
		let plugins = fixtures::plugins( &engine );
		let bindings = fixtures::bindings();
		let child = plugins.child.plugin
			.remap_interfaces( HashMap::from([(
				"root".to_string(),
				Remap::found_as_with_item_resolution_table(
					"root",
					HashMap::from([( "get-value".to_string(), "missing".to_string() )]),
				),
			)]))
			.instantiate_async( &engine, &linker, executor.clone() ).await?;
		let dependency = Binding::new(
			bindings.dependency.package,
			HashMap::from([( bindings.dependency.name, bindings.dependency.spec )]),
			ExactlyOne( "child".to_string(), child ),
		);
		let startup = plugins.startup.plugin.link_async(
			&engine,
			linker,
			vec![ dependency ],
			executor,
		).await?;
		let root = Binding::new(
			bindings.root.package,
			HashMap::from([( bindings.root.name, bindings.root.spec )]),
			ExactlyOne( "startup".to_string(), startup ),
		);

		let result = root.dispatch_async( "root", "get-value", &[] ).await?;
		assert!( matches!(
			&result,
			ExactlyOne( _, Ok( Val::Tuple( items ))) if matches!( items.as_slice(),
				[ Val::String( id ), Val::Result( Err( Some( error ))) ] if
				id == "child"
				&& matches!( &**error, Val::Variant( name, Some( message )) if
					name == "invalid-function"
					&& matches!( &**message, Val::String( function ) if function.ends_with( ":missing" ))
				)
			)
		), "unexpected dispatch result: {result:#?}" );
		Ok(())
	})
}