#[macro_use]
extern crate jsonrpc_client_core;
use serde::{Serialize, Deserialize};
#[cfg(test)]
use autorand::Random;
#[cfg(test)]
mod test_harness;
pub type UserRole = String;
pub type Email = String;
pub type UserFirst = String;
pub type UserLast = String;
pub type UserStreet = String;
pub type UserCity = String;
pub type UserState = String;
pub type UserZipcode = f64;
pub type UserCountry = String;
pub type UserPhone = String;
pub type UserCompany = String;
pub type Password = String;
pub type JwTtoken = String;
pub type SubType = String;
pub type SubCost = String;
pub type SubFreq = String;
pub type SubStart = String;
pub type SubRenew = String;
pub type SellerId = String;
pub type EmployeeId = String;
pub type DeviceEsn = String;
pub type Columns = Vec<Option<serde_json::Value>>;
pub type Columndata = Vec<Option<serde_json::Value>>;
pub type DeviceType = String;
pub type Simiccid = String;
pub type AnetProfileId = String;
pub type CreateUserResult = String;
pub type AdminLoginResult = String;
pub type GetUsersResult = String;
pub type GetSubscriptionsResult = String;
pub type AddSubscriptionResult = String;
pub type UpdateSubscriptionResult = String;
pub type AddDeviceResult = String;
pub type GetDevicesResult = String;
pub type UpdateDeviceInfoResult = String;
pub type PodGetUsersResult = String;
pub type PodGetSimInfoResult = String;
pub type PodTurnOnSimResult = String;
pub type PodSuspendSimResult = String;
pub type PodUnsuspendSimResult = String;
pub type PulsGetDeviceResult = String;
pub type PulsChangeDeviceGroupResult = String;
pub type AuthGetCustomerProfileResult = String;
jsonrpc_client!(pub struct GSAAPI {
pub fn createUser(&mut self, userRole: UserRole, email: Email, userFirst: UserFirst, userLast: UserLast, userStreet: UserStreet, userCity: UserCity, userState: UserState, userZipcode: UserZipcode, userCountry: UserCountry, userPhone: UserPhone, userCompany: UserCompany) -> RpcRequest<CreateUserResult>;
pub fn adminLogin(&mut self, email: Email, password: Password) -> RpcRequest<AdminLoginResult>;
pub fn getUsers(&mut self, JWTtoken: JwTtoken, email: Email) -> RpcRequest<GetUsersResult>;
pub fn getSubscriptions(&mut self, JWTtoken: JwTtoken, email: Email) -> RpcRequest<GetSubscriptionsResult>;
pub fn addSubscription(&mut self, JWTtoken: JwTtoken, email: Email, subType: SubType, subCost: SubCost, subFreq: SubFreq, subStart: SubStart, subRenew: SubRenew, sellerID: SellerId, employeeID: EmployeeId, deviceESN: DeviceEsn) -> RpcRequest<AddSubscriptionResult>;
pub fn updateSubscriptionInfo(&mut self, JWTtoken: JwTtoken, email: Email, deviceESN: DeviceEsn, columns: Columns, columndata: Columndata) -> RpcRequest<UpdateSubscriptionResult>;
pub fn addDevice(&mut self, JWTtoken: JwTtoken, email: Email, deviceESN: DeviceEsn, deviceType: DeviceType, simiccid: Simiccid) -> RpcRequest<AddDeviceResult>;
pub fn getDevices(&mut self, JWTtoken: JwTtoken, email: Email) -> RpcRequest<GetDevicesResult>;
pub fn updateDeviceInfo(&mut self, JWTtoken: JwTtoken, email: Email, deviceESN: DeviceEsn, columns: Columns, columndata: Columndata) -> RpcRequest<UpdateDeviceInfoResult>;
pub fn podGetUsers(&mut self, JWTtoken: JwTtoken, email: Email) -> RpcRequest<PodGetUsersResult>;
pub fn podGetSimInfo(&mut self, JWTtoken: JwTtoken, email: Email, simiccid: Simiccid) -> RpcRequest<PodGetSimInfoResult>;
pub fn podTurnOnSim(&mut self, JWTtoken: JwTtoken, email: Email, simiccid: Simiccid) -> RpcRequest<PodTurnOnSimResult>;
pub fn podSuspendSim(&mut self, JWTtoken: JwTtoken, email: Email, simiccid: Simiccid) -> RpcRequest<PodSuspendSimResult>;
pub fn podUnsuspendSim(&mut self, JWTtoken: JwTtoken, email: Email, simiccid: Simiccid) -> RpcRequest<PodUnsuspendSimResult>;
pub fn pulsGetDevice(&mut self, JWTtoken: JwTtoken, email: Email, deviceESN: DeviceEsn) -> RpcRequest<PulsGetDeviceResult>;
pub fn pulsChangeDeviceGroup(&mut self, JWTtoken: JwTtoken, email: Email, deviceESN: DeviceEsn) -> RpcRequest<PulsChangeDeviceGroupResult>;
pub fn authGetCustomerProfile(&mut self, JWTtoken: JwTtoken, email: Email, anetProfileId: AnetProfileId) -> RpcRequest<AuthGetCustomerProfileResult>;
});
#[cfg(test)]
mod tests {
use super::*;
use test_harness::*;
use autorand::Random;
use futures::Future;
#[test]
#[allow(non_snake_case)]
fn createUser_test () {
let method = "createUser".into();
let mut params = Vec::new();
let UserRole_value = UserRole::random();
let serialized = serde_json::to_value(&UserRole_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let UserFirst_value = UserFirst::random();
let serialized = serde_json::to_value(&UserFirst_value).unwrap();
params.push(serialized);
let UserLast_value = UserLast::random();
let serialized = serde_json::to_value(&UserLast_value).unwrap();
params.push(serialized);
let UserStreet_value = UserStreet::random();
let serialized = serde_json::to_value(&UserStreet_value).unwrap();
params.push(serialized);
let UserCity_value = UserCity::random();
let serialized = serde_json::to_value(&UserCity_value).unwrap();
params.push(serialized);
let UserState_value = UserState::random();
let serialized = serde_json::to_value(&UserState_value).unwrap();
params.push(serialized);
let UserZipcode_value = UserZipcode::random();
let serialized = serde_json::to_value(&UserZipcode_value).unwrap();
params.push(serialized);
let UserCountry_value = UserCountry::random();
let serialized = serde_json::to_value(&UserCountry_value).unwrap();
params.push(serialized);
let UserPhone_value = UserPhone::random();
let serialized = serde_json::to_value(&UserPhone_value).unwrap();
params.push(serialized);
let UserCompany_value = UserCompany::random();
let serialized = serde_json::to_value(&UserCompany_value).unwrap();
params.push(serialized);
let result = CreateUserResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: CreateUserResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.createUser(
UserRole_value, Email_value, UserFirst_value, UserLast_value, UserStreet_value, UserCity_value, UserState_value, UserZipcode_value, UserCountry_value, UserPhone_value, UserCompany_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn adminLogin_test () {
let method = "adminLogin".into();
let mut params = Vec::new();
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let Password_value = Password::random();
let serialized = serde_json::to_value(&Password_value).unwrap();
params.push(serialized);
let result = AdminLoginResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: AdminLoginResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.adminLogin(
Email_value, Password_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn getUsers_test () {
let method = "getUsers".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let result = GetUsersResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: GetUsersResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.getUsers(
JwTtoken_value, Email_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn getSubscriptions_test () {
let method = "getSubscriptions".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let result = GetSubscriptionsResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: GetSubscriptionsResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.getSubscriptions(
JwTtoken_value, Email_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn addSubscription_test () {
let method = "addSubscription".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let SubType_value = SubType::random();
let serialized = serde_json::to_value(&SubType_value).unwrap();
params.push(serialized);
let SubCost_value = SubCost::random();
let serialized = serde_json::to_value(&SubCost_value).unwrap();
params.push(serialized);
let SubFreq_value = SubFreq::random();
let serialized = serde_json::to_value(&SubFreq_value).unwrap();
params.push(serialized);
let SubStart_value = SubStart::random();
let serialized = serde_json::to_value(&SubStart_value).unwrap();
params.push(serialized);
let SubRenew_value = SubRenew::random();
let serialized = serde_json::to_value(&SubRenew_value).unwrap();
params.push(serialized);
let SellerId_value = SellerId::random();
let serialized = serde_json::to_value(&SellerId_value).unwrap();
params.push(serialized);
let EmployeeId_value = EmployeeId::random();
let serialized = serde_json::to_value(&EmployeeId_value).unwrap();
params.push(serialized);
let DeviceEsn_value = DeviceEsn::random();
let serialized = serde_json::to_value(&DeviceEsn_value).unwrap();
params.push(serialized);
let result = AddSubscriptionResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: AddSubscriptionResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.addSubscription(
JwTtoken_value, Email_value, SubType_value, SubCost_value, SubFreq_value, SubStart_value, SubRenew_value, SellerId_value, EmployeeId_value, DeviceEsn_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn updateSubscriptionInfo_test () {
let method = "updateSubscriptionInfo".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let DeviceEsn_value = DeviceEsn::random();
let serialized = serde_json::to_value(&DeviceEsn_value).unwrap();
params.push(serialized);
let Columns_value = Columns::random();
let serialized = serde_json::to_value(&Columns_value).unwrap();
params.push(serialized);
let Columndata_value = Columndata::random();
let serialized = serde_json::to_value(&Columndata_value).unwrap();
params.push(serialized);
let result = UpdateSubscriptionResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: UpdateSubscriptionResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.updateSubscriptionInfo(
JwTtoken_value, Email_value, DeviceEsn_value, Columns_value, Columndata_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn addDevice_test () {
let method = "addDevice".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let DeviceEsn_value = DeviceEsn::random();
let serialized = serde_json::to_value(&DeviceEsn_value).unwrap();
params.push(serialized);
let DeviceType_value = DeviceType::random();
let serialized = serde_json::to_value(&DeviceType_value).unwrap();
params.push(serialized);
let Simiccid_value = Simiccid::random();
let serialized = serde_json::to_value(&Simiccid_value).unwrap();
params.push(serialized);
let result = AddDeviceResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: AddDeviceResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.addDevice(
JwTtoken_value, Email_value, DeviceEsn_value, DeviceType_value, Simiccid_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn getDevices_test () {
let method = "getDevices".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let result = GetDevicesResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: GetDevicesResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.getDevices(
JwTtoken_value, Email_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn updateDeviceInfo_test () {
let method = "updateDeviceInfo".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let DeviceEsn_value = DeviceEsn::random();
let serialized = serde_json::to_value(&DeviceEsn_value).unwrap();
params.push(serialized);
let Columns_value = Columns::random();
let serialized = serde_json::to_value(&Columns_value).unwrap();
params.push(serialized);
let Columndata_value = Columndata::random();
let serialized = serde_json::to_value(&Columndata_value).unwrap();
params.push(serialized);
let result = UpdateDeviceInfoResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: UpdateDeviceInfoResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.updateDeviceInfo(
JwTtoken_value, Email_value, DeviceEsn_value, Columns_value, Columndata_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn podGetUsers_test () {
let method = "podGetUsers".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let result = PodGetUsersResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: PodGetUsersResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.podGetUsers(
JwTtoken_value, Email_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn podGetSimInfo_test () {
let method = "podGetSimInfo".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let Simiccid_value = Simiccid::random();
let serialized = serde_json::to_value(&Simiccid_value).unwrap();
params.push(serialized);
let result = PodGetSimInfoResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: PodGetSimInfoResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.podGetSimInfo(
JwTtoken_value, Email_value, Simiccid_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn podTurnOnSim_test () {
let method = "podTurnOnSim".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let Simiccid_value = Simiccid::random();
let serialized = serde_json::to_value(&Simiccid_value).unwrap();
params.push(serialized);
let result = PodTurnOnSimResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: PodTurnOnSimResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.podTurnOnSim(
JwTtoken_value, Email_value, Simiccid_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn podSuspendSim_test () {
let method = "podSuspendSim".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let Simiccid_value = Simiccid::random();
let serialized = serde_json::to_value(&Simiccid_value).unwrap();
params.push(serialized);
let result = PodSuspendSimResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: PodSuspendSimResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.podSuspendSim(
JwTtoken_value, Email_value, Simiccid_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn podUnsuspendSim_test () {
let method = "podUnsuspendSim".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let Simiccid_value = Simiccid::random();
let serialized = serde_json::to_value(&Simiccid_value).unwrap();
params.push(serialized);
let result = PodUnsuspendSimResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: PodUnsuspendSimResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.podUnsuspendSim(
JwTtoken_value, Email_value, Simiccid_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn pulsGetDevice_test () {
let method = "pulsGetDevice".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let DeviceEsn_value = DeviceEsn::random();
let serialized = serde_json::to_value(&DeviceEsn_value).unwrap();
params.push(serialized);
let result = PulsGetDeviceResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: PulsGetDeviceResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.pulsGetDevice(
JwTtoken_value, Email_value, DeviceEsn_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn pulsChangeDeviceGroup_test () {
let method = "pulsChangeDeviceGroup".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let DeviceEsn_value = DeviceEsn::random();
let serialized = serde_json::to_value(&DeviceEsn_value).unwrap();
params.push(serialized);
let result = PulsChangeDeviceGroupResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: PulsChangeDeviceGroupResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.pulsChangeDeviceGroup(
JwTtoken_value, Email_value, DeviceEsn_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
#[test]
#[allow(non_snake_case)]
fn authGetCustomerProfile_test () {
let method = "authGetCustomerProfile".into();
let mut params = Vec::new();
let JwTtoken_value = JwTtoken::random();
let serialized = serde_json::to_value(&JwTtoken_value).unwrap();
params.push(serialized);
let Email_value = Email::random();
let serialized = serde_json::to_value(&Email_value).unwrap();
params.push(serialized);
let AnetProfileId_value = AnetProfileId::random();
let serialized = serde_json::to_value(&AnetProfileId_value).unwrap();
params.push(serialized);
let result = AuthGetCustomerProfileResult::random();
let result_serialized = serde_json::to_vec(&result).unwrap();
let result: AuthGetCustomerProfileResult = serde_json::from_slice(&result_serialized).unwrap();
let transport = MockTransport {
method,
params,
result: serde_json::to_value(&result).unwrap(),
};
let mut client = GSAAPI::new(transport);
let received_result = client.authGetCustomerProfile(
JwTtoken_value, Email_value, AnetProfileId_value
).wait().unwrap();
let result_s =
assert_eq!(result, received_result);
}
}