polywrap_tests_utils 0.1.11

Utilities for testing Polywrap Client
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

use std::{
    collections::HashMap,
    sync::{Arc, Mutex},
};

use polywrap_core::{
    invoker::Invoker, macros::uri, resolution::uri_resolution_context::UriResolutionContext,
    uri::Uri,
};
use polywrap_msgpack_serde::to_vec;
use serde::{Deserialize, Serialize};
use wrap_manifest_schemas::versions::WrapManifest;

pub struct MockInvoker;

impl MockInvoker {
    // Manifest returned from invoke_raw when the tryResolveUri method is called
    pub fn manifest_from_try_resolve_uri_result() -> WrapManifest {
        wrap_manifest_schemas::versions::WrapManifest01 {
            abi: wrap_manifest_schemas::versions::WrapManifest01Abi {
                version: Some("1".to_string()),
                enum_types: None,
                env_type: None,
                imported_enum_types: None,
                imported_env_types: None,
                imported_module_types: None,
                imported_object_types: None,
                interface_types: None,
                module_type: None,
                object_types: None,
            },
            name: "mock".to_string(),
            version: "0.1".to_string(),
            type_: "wasm".to_string(),
        }
    }

    // URI returned from invoke_raw when the tryResolveUri method is called
    pub fn uri_from_try_resolve_uri() -> Uri {
        uri!("wrap://mock/resolved-uri")
    }
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct MaybeUriOrManifest {
    pub uri: Option<String>,
    #[serde(with = "serde_bytes")]
    pub manifest: Option<Vec<u8>>,
}

impl Invoker for MockInvoker {
    fn invoke_raw(
        &self,
        _: &polywrap_core::uri::Uri,
        method: &str,
        _: Option<&[u8]>,
        _: Option<&[u8]>,
        _: Option<Arc<Mutex<UriResolutionContext>>>,
    ) -> Result<Vec<u8>, polywrap_core::error::Error> {
        if method == "tryResolveUri" {
            let result: Vec<u8> = to_vec(&MaybeUriOrManifest {
                uri: Some(MockInvoker::uri_from_try_resolve_uri().to_string()),
                manifest: Some(to_vec(&MockInvoker::manifest_from_try_resolve_uri_result()).unwrap()),
            })
            .unwrap();

            Ok(result)
        } else {
            Ok(vec![3])
        }
    }

    fn get_implementations(
        &self,
        _: &polywrap_core::uri::Uri,
    ) -> Result<Vec<polywrap_core::uri::Uri>, polywrap_core::error::Error> {
        Ok(vec![uri!("mock/a")])
    }

    fn get_interfaces(
        &self,
    ) -> Option<polywrap_core::interface_implementation::InterfaceImplementations> {
        Some(HashMap::from([(
            uri!("mock/a"),
            vec![uri!("mock/b")],
        )]))
    }

    fn get_env_by_uri(&self, _: &polywrap_core::uri::Uri) -> Option<Vec<u8>> {
        Some([0, 4].to_vec())
    }
}

pub fn get_mock_invoker() -> Arc<dyn Invoker> {
    Arc::new(MockInvoker {})
}