#[macro_use]
extern crate jsonrpc_client_core;
use serde::{Serialize, Deserialize};
#[cfg(test)]
use autorand::Random;
#[cfg(test)]
mod test_harness;
pub type JwTtoken = String;
pub type UserName = String;
pub type Password = String;
pub type UserRole = String;
pub type UserId = String;
pub type NodeName = String;
pub type NodeNetwork = String;
pub type SyncType = String;
pub type RpcApi = bool;
pub type WsApi = bool;
pub type ContainerId = String;
pub type RemoveNodeData = bool;
pub type SolVersion = String;
pub type SolCode = String;
pub type Web3CallMethod = String;
pub type Web3CallParams = Vec<Option<serde_json::Value>>;
pub type RpcId = f64;
pub type ServiceName = String;
pub type Version = String;
pub type Name = String;
pub type Environment = String;
pub type InstallSuccess = bool;
pub type ListedServices = Vec<ObjectT9Jrtxk4>;
pub type InstalledServices = Vec<ObjectVZsrKceH>;
pub type RunningServices = Vec<ObjectDlZvXzsu>;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
#[serde(untagged)]
pub enum Filter {
#[serde(rename = "all")]
All,
#[serde(rename = "available")]
Available,
#[serde(rename = "installed")]
Installed,
#[serde(rename = "running")]
Running,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
#[serde(untagged)]
pub enum RemoveNode {
AnythingArray(Vec<Option<serde_json::Value>>),
Bool(bool),
Double(f64),
Integer(i64),
RemoveNodeClass(RemoveNodeClass),
String(String),
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
#[serde(untagged)]
pub enum GetNodeContainer {
AnythingArray(Vec<Option<serde_json::Value>>),
Bool(bool),
Double(f64),
GetNodeContainerClass(GetNodeContainerClass),
Integer(i64),
String(String),
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
#[serde(untagged)]
pub enum StringTLqBBstC {
#[serde(rename = "active")]
Active,
#[serde(rename = "available")]
Available,
#[serde(rename = "installed")]
Installed,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct GetSysInfo {
#[serde(rename = "message")]
message: Option<String>,
#[serde(rename = "status")]
status: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct CreateUser {
#[serde(rename = "message")]
message: Option<String>,
#[serde(rename = "status")]
status: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct DeleteUser {
#[serde(rename = "message")]
message: Option<String>,
#[serde(rename = "status")]
status: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct Login {
#[serde(rename = "message")]
message: Option<String>,
#[serde(rename = "status")]
status: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct GetUser {
#[serde(rename = "message")]
message: Option<String>,
#[serde(rename = "status")]
status: Option<String>,
#[serde(rename = "response")]
response: Option<serde_json::Value>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct AddNode {
#[serde(rename = "message")]
message: Option<String>,
#[serde(rename = "status")]
status: Option<String>,
#[serde(rename = "response")]
response: Option<serde_json::Value>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct RemoveNodeClass {
#[serde(rename = "message")]
message: Option<String>,
#[serde(rename = "status")]
status: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct GetNodeContainerClass {
#[serde(rename = "message")]
message: Option<String>,
#[serde(rename = "status")]
status: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct SolCompile {
#[serde(rename = "message")]
message: Option<String>,
#[serde(rename = "status")]
status: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct Web3CallResult {
#[serde(rename = "message")]
message: Option<String>,
#[serde(rename = "status")]
status: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct ObjectT9Jrtxk4 {
#[serde(rename = "enviornments")]
enviornments: Option<Vec<String>>,
#[serde(rename = "name")]
name: Option<String>,
#[serde(rename = "state")]
state: Option<StringTLqBBstC>,
#[serde(rename = "version")]
version: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct ObjectVZsrKceH {
#[serde(rename = "name")]
name: Option<String>,
#[serde(rename = "version")]
version: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct ObjectDlZvXzsu {
#[serde(rename = "args")]
args: ObjectHqcFus7M,
#[serde(rename = "commands")]
commands: ObjectHuetvW0J,
#[serde(rename = "env")]
env: String,
#[serde(rename = "name")]
name: String,
#[serde(rename = "path")]
path: String,
#[serde(rename = "rpcPort")]
rpc_port: String,
#[serde(rename = "state")]
state: Option<String>,
#[serde(rename = "version")]
version: String,
#[serde(rename = "running")]
running: Option<serde_json::Value>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct ObjectHqcFus7M {
#[serde(rename = "start")]
start: Vec<String>,
#[serde(rename = "stop")]
stop: Vec<String>,
#[serde(rename = "teardown")]
teardown: Vec<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct ObjectHuetvW0J {
#[serde(rename = "setup")]
setup: Vec<ObjectD8RkBgzg>,
#[serde(rename = "start")]
start: String,
#[serde(rename = "stop")]
stop: String,
#[serde(rename = "teardown")]
teardown: String,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct ObjectD8RkBgzg {
#[serde(rename = "args")]
args: Vec<String>,
#[serde(rename = "cmd")]
cmd: String,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[cfg_attr(test, derive(Random))]
pub struct ServiceConfig {
#[serde(rename = "args")]
args: ObjectHqcFus7M,
#[serde(rename = "commands")]
commands: ObjectHuetvW0J,
#[serde(rename = "env")]
env: String,
#[serde(rename = "name")]
name: String,
#[serde(rename = "path")]
path: String,
#[serde(rename = "rpcPort")]
rpc_port: String,
#[serde(rename = "state")]
state: Option<String>,
#[serde(rename = "version")]
version: String,
#[serde(rename = "running")]
running: Option<serde_json::Value>,
}
jsonrpc_client!(pub struct EnAPIOpenRPCJsonRpcAPI {
pub fn getSysInfo(&mut self, JWTtoken: JwTtoken) -> RpcRequest<GetSysInfo>;
pub fn createUser(&mut self, userName: UserName, password: Password, userRole: UserRole) -> RpcRequest<CreateUser>;
pub fn deleteUser(&mut self, JWTtoken: JwTtoken, userId: UserId) -> RpcRequest<DeleteUser>;
pub fn login(&mut self, userName: UserName, password: Password) -> RpcRequest<Login>;
pub fn getUser(&mut self, JWTtoken: JwTtoken, userName: UserName) -> RpcRequest<GetUser>;
pub fn addNode(&mut self, JWTtoken: JwTtoken, userName: UserName, nodeName: NodeName, nodeNetwork: NodeNetwork, syncType: SyncType, rpcApi: RpcApi, wsApi: WsApi) -> RpcRequest<AddNode>;
pub fn removeNode(&mut self, JWTtoken: JwTtoken, userName: UserName, containerId: ContainerId, nodeName: NodeName, removeNodeData: RemoveNodeData) -> RpcRequest<RemoveNode>;
pub fn getNodeContainerInfo(&mut self, JWTtoken: JwTtoken, containerId: ContainerId) -> RpcRequest<GetNodeContainer>;
pub fn sol_compile(&mut self, solVersion: SolVersion, solCode: SolCode) -> RpcRequest<SolCompile>;
pub fn ethRpcCall(&mut self, userName: UserName, nodeName: NodeName, nodeNetwork: NodeNetwork, web3callMethod: Web3CallMethod, web3callParams: Web3CallParams, rpcId: RpcId) -> RpcRequest<Web3CallResult>;
pub fn installService(&mut self, serviceName: ServiceName, version: Version) -> RpcRequest<InstallSuccess>;
pub fn listServices(&mut self, filter: Filter) -> RpcRequest<ListedServices>;
pub fn listInstalledServices(&mut self) -> RpcRequest<InstalledServices>;
pub fn listRunningServices(&mut self) -> RpcRequest<RunningServices>;
pub fn startService(&mut self, name: Name, version: Version, environment: Environment) -> RpcRequest<ServiceConfig>;
});
#[cfg(test)]
mod tests {
use super::*;
use test_harness::*;
use autorand::Random;
use futures::Future;
#[test]
#[allow(non_snake_case)]
fn getSysInfo_test () {
let method = "getSysInfo".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let result = GetSysInfo::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: GetSysInfo = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.getSysInfo(
JwTtoken_value
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn createUser_test () {
let method = "createUser".into();
let mut params = Vec::new();
let UserName_value = UserName::random();
let serialized = serde_json::to_value(&UserName_value).unwrap();
params.push(serialized);
let Password_value = Password::random();
let serialized = serde_json::to_value(&Password_value).unwrap();
params.push(serialized);
let UserRole_value = UserRole::random();
let serialized = serde_json::to_value(&UserRole_value).unwrap();
params.push(serialized);
let result = CreateUser::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: CreateUser = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.createUser(
UserName_value, Password_value, UserRole_value
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn deleteUser_test () {
let method = "deleteUser".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let UserId_value = UserId::random();
let serialized = serde_json::to_value(&UserId_value).unwrap();
params.push(serialized);
let result = DeleteUser::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: DeleteUser = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.deleteUser(
JwTtoken_value, UserId_value
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn login_test () {
let method = "login".into();
let mut params = Vec::new();
let UserName_value = UserName::random();
let serialized = serde_json::to_value(&UserName_value).unwrap();
params.push(serialized);
let Password_value = Password::random();
let serialized = serde_json::to_value(&Password_value).unwrap();
params.push(serialized);
let result = Login::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: Login = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.login(
UserName_value, Password_value
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn getUser_test () {
let method = "getUser".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let UserName_value = UserName::random();
let serialized = serde_json::to_value(&UserName_value).unwrap();
params.push(serialized);
let result = GetUser::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: GetUser = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.getUser(
JwTtoken_value, UserName_value
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn addNode_test () {
let method = "addNode".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let UserName_value = UserName::random();
let serialized = serde_json::to_value(&UserName_value).unwrap();
params.push(serialized);
let NodeName_value = NodeName::random();
let serialized = serde_json::to_value(&NodeName_value).unwrap();
params.push(serialized);
let NodeNetwork_value = NodeNetwork::random();
let serialized = serde_json::to_value(&NodeNetwork_value).unwrap();
params.push(serialized);
let SyncType_value = SyncType::random();
let serialized = serde_json::to_value(&SyncType_value).unwrap();
params.push(serialized);
let RpcApi_value = RpcApi::random();
let serialized = serde_json::to_value(&RpcApi_value).unwrap();
params.push(serialized);
let WsApi_value = WsApi::random();
let serialized = serde_json::to_value(&WsApi_value).unwrap();
params.push(serialized);
let result = AddNode::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: AddNode = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.addNode(
JwTtoken_value, UserName_value, NodeName_value, NodeNetwork_value, SyncType_value, RpcApi_value, WsApi_value
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn removeNode_test () {
let method = "removeNode".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let UserName_value = UserName::random();
let serialized = serde_json::to_value(&UserName_value).unwrap();
params.push(serialized);
let ContainerId_value = ContainerId::random();
let serialized = serde_json::to_value(&ContainerId_value).unwrap();
params.push(serialized);
let NodeName_value = NodeName::random();
let serialized = serde_json::to_value(&NodeName_value).unwrap();
params.push(serialized);
let RemoveNodeData_value = RemoveNodeData::random();
let serialized = serde_json::to_value(&RemoveNodeData_value).unwrap();
params.push(serialized);
let result = RemoveNode::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: RemoveNode = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.removeNode(
JwTtoken_value, UserName_value, ContainerId_value, NodeName_value, RemoveNodeData_value
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn getNodeContainerInfo_test () {
let method = "getNodeContainerInfo".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let ContainerId_value = ContainerId::random();
let serialized = serde_json::to_value(&ContainerId_value).unwrap();
params.push(serialized);
let result = GetNodeContainer::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: GetNodeContainer = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.getNodeContainerInfo(
JwTtoken_value, ContainerId_value
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn sol_compile_test () {
let method = "sol_compile".into();
let mut params = Vec::new();
let SolVersion_value = SolVersion::random();
let serialized = serde_json::to_value(&SolVersion_value).unwrap();
params.push(serialized);
let SolCode_value = SolCode::random();
let serialized = serde_json::to_value(&SolCode_value).unwrap();
params.push(serialized);
let result = SolCompile::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: SolCompile = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.sol_compile(
SolVersion_value, SolCode_value
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn ethRpcCall_test () {
let method = "ethRpcCall".into();
let mut params = Vec::new();
let UserName_value = UserName::random();
let serialized = serde_json::to_value(&UserName_value).unwrap();
params.push(serialized);
let NodeName_value = NodeName::random();
let serialized = serde_json::to_value(&NodeName_value).unwrap();
params.push(serialized);
let NodeNetwork_value = NodeNetwork::random();
let serialized = serde_json::to_value(&NodeNetwork_value).unwrap();
params.push(serialized);
let Web3CallMethod_value = Web3CallMethod::random();
let serialized = serde_json::to_value(&Web3CallMethod_value).unwrap();
params.push(serialized);
let Web3CallParams_value = Web3CallParams::random();
let serialized = serde_json::to_value(&Web3CallParams_value).unwrap();
params.push(serialized);
let RpcId_value = RpcId::random();
let serialized = serde_json::to_value(&RpcId_value).unwrap();
params.push(serialized);
let result = Web3CallResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: Web3CallResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.ethRpcCall(
UserName_value, NodeName_value, NodeNetwork_value, Web3CallMethod_value, Web3CallParams_value, RpcId_value
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn installService_test () {
let method = "installService".into();
let mut params = Vec::new();
let ServiceName_value = ServiceName::random();
let serialized = serde_json::to_value(&ServiceName_value).unwrap();
params.push(serialized);
let Version_value = Version::random();
let serialized = serde_json::to_value(&Version_value).unwrap();
params.push(serialized);
let result = InstallSuccess::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: InstallSuccess = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.installService(
ServiceName_value, Version_value
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn listServices_test () {
let method = "listServices".into();
let mut params = Vec::new();
let Filter_value = Filter::random();
let serialized = serde_json::to_value(&Filter_value).unwrap();
params.push(serialized);
let result = ListedServices::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: ListedServices = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.listServices(
Filter_value
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn listInstalledServices_test () {
let method = "listInstalledServices".into();
let mut params = Vec::new();
let result = InstalledServices::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: InstalledServices = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.listInstalledServices(
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn listRunningServices_test () {
let method = "listRunningServices".into();
let mut params = Vec::new();
let result = RunningServices::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: RunningServices = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.listRunningServices(
).wait().unwrap();
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn startService_test () {
let method = "startService".into();
let mut params = Vec::new();
let Name_value = Name::random();
let serialized = serde_json::to_value(&Name_value).unwrap();
params.push(serialized);
let Version_value = Version::random();
let serialized = serde_json::to_value(&Version_value).unwrap();
params.push(serialized);
let Environment_value = Environment::random();
let serialized = serde_json::to_value(&Environment_value).unwrap();
params.push(serialized);
let result = ServiceConfig::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: ServiceConfig = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = EnAPIOpenRPCJsonRpcAPI::new(transport);
let received_result = client.startService(
Name_value, Version_value, Environment_value
).wait().unwrap();
assert_eq!(result, received_result);
}
}