From 845fbe13bc80bd55d3f586ab4aa88a3383c9d37d Mon Sep 17 00:00:00 2001 From: Ishan Jain Date: Thu, 11 Aug 2022 16:33:40 +0530 Subject: [PATCH] bugfixes and refactored the project a bit 1. Fixed bugs in `.execute_post`. 2. Functions that take a single input string were updated to take a string and then create the request body from it instead of asking user to enter the request body. 3. Moved tests from `tests/` to their specific modules 4. Added few more methods --- src/client.rs | 43 ++++++--- src/interface/types.rs | 2 + src/ip/address.rs | 110 ++++++++++++++++++++- src/ip/dhcp_client.rs | 113 +++++++++++++++++++--- src/ip/dhcp_server.rs | 87 +++++++++++++++++ src/ip/route.rs | 34 +++++++ src/ip/types.rs | 20 ++++ tests/ip_test.rs | 212 ----------------------------------------- tests/routing_test.rs | 212 ----------------------------------------- 9 files changed, 386 insertions(+), 447 deletions(-) delete mode 100644 tests/ip_test.rs delete mode 100644 tests/routing_test.rs diff --git a/src/client.rs b/src/client.rs index 348431b..cc2aff8 100644 --- a/src/client.rs +++ b/src/client.rs @@ -3,7 +3,7 @@ use reqwest::{ Method, Request, Url, }; use serde::{de::DeserializeOwned, ser::Serialize}; -use std::num::ParseFloatError; +use std::{fmt::Display, num::ParseFloatError}; use thiserror::Error; pub struct Client { @@ -76,13 +76,14 @@ impl Client { *req.body_mut() = Some(body); // Add Content-Type Header - let mut headers = HeaderMap::new(); - headers.insert("Content-Type", HeaderValue::from_static("application/json")); - *req.headers_mut() = headers; + req.headers_mut() + .insert("Content-Type", HeaderValue::from_static("application/json")); - let response = self.client.execute(req).await?.json::().await?; - - Ok(response) + match self.client.execute(req).await { + Ok(v) if v.status().is_success() => Ok(v.json::().await?), + Ok(v) => Err(ClientError::MikrotikError(v.json::().await?)), + Err(e) => Err(e.into()), + } } pub async fn execute_post_with_no_response( @@ -104,10 +105,11 @@ impl Client { req.headers_mut() .insert("Content-Type", HeaderValue::from_static("application/json")); - self.client.execute(req).await?; - // TODO(ishan): Check status code!! - - Ok(()) + match self.client.execute(req).await { + Ok(v) if v.status().is_success() => Ok(()), + Ok(v) => Err(ClientError::MikrotikError(v.json::().await?)), + Err(e) => Err(e.into()), + } } } @@ -124,4 +126,23 @@ pub enum ClientError { #[error(transparent)] SerdeJsonError(#[from] serde_json::Error), + + #[error(transparent)] + MikrotikError(#[from] MikrotikError), +} + +use serde::{Deserialize as DeserializeDerive, Serialize as SerializeDerive}; + +#[derive(Default, Error, Debug, Clone, PartialEq, SerializeDerive, DeserializeDerive)] +#[serde(rename_all = "camelCase")] +pub struct MikrotikError { + pub error: u16, + pub message: String, + pub detail: String, +} + +impl Display for MikrotikError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(&self.message) + } } diff --git a/src/interface/types.rs b/src/interface/types.rs index fd6c15b..ded3413 100644 --- a/src/interface/types.rs +++ b/src/interface/types.rs @@ -19,6 +19,8 @@ pub enum InterfaceType { Wireguard, #[serde(rename = "pppoe-out")] PPPoE, + #[serde(rename = "6to4-tunnel")] + Tunnel6to4, } impl Default for InterfaceType { diff --git a/src/ip/address.rs b/src/ip/address.rs index 23424de..2d0b14a 100644 --- a/src/ip/address.rs +++ b/src/ip/address.rs @@ -1,5 +1,6 @@ -pub use crate::ip::types::Address; +pub use crate::ip::types::{AddAddressInput, AddAddressOutput, Address}; use crate::{Client, ClientError}; +use serde::{Deserialize, Serialize}; /// list all configurd ipv4 addresses pub async fn list(client: &mut Client) -> Result, ClientError> { @@ -14,3 +15,110 @@ pub async fn get(client: &mut Client, aid: &str) -> Result client.execute_get::
(&url).await } + +pub async fn add( + client: &mut Client, + input: AddAddressInput, +) -> Result { + let url = format!("{}/address/add", super::BASE); + + client + .execute_post::(&url, input) + .await +} + +#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)] +struct RemoveAddressInput { + pub numbers: String, +} + +pub async fn remove(client: &mut Client, id: &str) -> Result<(), ClientError> { + let url = format!("{}/address/remove", super::BASE); + + client + .execute_post_with_no_response::( + &url, + RemoveAddressInput { + numbers: id.to_string(), + }, + ) + .await +} + +#[cfg(test)] +mod test { + use super::*; + use reqwest::Url; + + #[tokio::test] + async fn remove_address() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "pia".to_string(), "qwertyuiop".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::address::add( + &mut client, + AddAddressInput { + address: "10.20.0.1/24".to_string(), + disabled: false, + interface: "pia".to_string(), + ..Default::default() + }, + ) + .await?; + + crate::ip::address::remove(&mut client, &response.ret).await?; + + Ok(()) + } + + #[tokio::test] + async fn add_address() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "pia".to_string(), "qwertyuiop".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::address::add( + &mut client, + AddAddressInput { + address: "10.20.0.1/24".to_string(), + disabled: false, + interface: "pia".to_string(), + ..Default::default() + }, + ) + .await?; + + println!("{:?}", response); + + Ok(()) + } + + #[tokio::test] + async fn list_address() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::address::list(&mut client).await?; + + println!("{:?}", response); + + Ok(()) + } + + #[tokio::test] + async fn get_address() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::address::list(&mut client).await?; + + let response = crate::ip::address::get(&mut client, &response[0].id).await?; + + println!("{:?}", response); + + Ok(()) + } +} diff --git a/src/ip/dhcp_client.rs b/src/ip/dhcp_client.rs index 77b6dee..11f7845 100644 --- a/src/ip/dhcp_client.rs +++ b/src/ip/dhcp_client.rs @@ -17,55 +17,146 @@ pub async fn get(client: &mut Client, id: &str) -> Result Result<(), ClientError> { +pub async fn release(client: &mut Client, input: &str) -> Result<(), ClientError> { let url = format!("{}/dhcp-client/release", super::BASE); client - .execute_post_with_no_response::(&url, input) + .execute_post_with_no_response::( + &url, + DhcpClientInput { + numbers: input.to_string(), + }, + ) .await?; Ok(()) } /// Renew a DHCP Lease -pub async fn renew(client: &mut Client, input: DhcpClientInput) -> Result<(), ClientError> { +pub async fn renew(client: &mut Client, input: &str) -> Result<(), ClientError> { let url = format!("{}/dhcp-client/renew", super::BASE); client - .execute_post_with_no_response::(&url, input) + .execute_post_with_no_response::( + &url, + DhcpClientInput { + numbers: input.to_string(), + }, + ) .await } /// Remove a DHCP client -pub async fn remove(client: &mut Client, input: DhcpClientInput) -> Result<(), ClientError> { +pub async fn remove(client: &mut Client, input: &str) -> Result<(), ClientError> { let url = format!("{}/dhcp-client/remove", super::BASE); client - .execute_post_with_no_response::(&url, input) + .execute_post_with_no_response::( + &url, + DhcpClientInput { + numbers: input.to_string(), + }, + ) .await } /// Disable a DHCP client -pub async fn disable(client: &mut Client, input: DhcpClientInput) -> Result<(), ClientError> { +pub async fn disable(client: &mut Client, input: &str) -> Result<(), ClientError> { let url = format!("{}/dhcp-client/disable", super::BASE); client - .execute_post_with_no_response::(&url, input) + .execute_post_with_no_response::( + &url, + DhcpClientInput { + numbers: input.to_string(), + }, + ) .await } /// Enable a DHCP client -pub async fn enable(client: &mut Client, input: DhcpClientInput) -> Result<(), ClientError> { +pub async fn enable(client: &mut Client, input: &str) -> Result<(), ClientError> { let url = format!("{}/dhcp-client/enable", super::BASE); client - .execute_post_with_no_response::(&url, input) + .execute_post_with_no_response::( + &url, + DhcpClientInput { + numbers: input.to_string(), + }, + ) .await } // TODO(ishan): Add reset/set/unset methods + +#[cfg(test)] +mod test { + use super::*; + use reqwest::Url; + + #[tokio::test] + async fn list_dhcp_client() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::dhcp_client::list(&mut client).await?; + + println!("{:?}", response); + + Ok(()) + } + + #[tokio::test] + async fn get_dhcp_client() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::dhcp_client::list(&mut client).await?; + + let response = crate::ip::dhcp_client::get(&mut client, &response[0].id).await?; + + println!("{:?}", response); + + Ok(()) + } + + #[tokio::test] + async fn renew_dhcp_lease() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::dhcp_client::list(&mut client).await?; + + let response = crate::ip::dhcp_client::renew(&mut client, &response[0].id).await?; + + println!("{:?}", response); + + Ok(()) + } + + #[tokio::test] + async fn release_dhcp_lease() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::dhcp_client::list(&mut client).await?; + + println!("{:?}", response); + + let response = crate::ip::dhcp_client::release(&mut client, &response[0].id).await?; + + println!("{:?}", response); + + Ok(()) + } +} diff --git a/src/ip/dhcp_server.rs b/src/ip/dhcp_server.rs index d92ee71..d6ffa39 100644 --- a/src/ip/dhcp_server.rs +++ b/src/ip/dhcp_server.rs @@ -42,3 +42,90 @@ pub async fn get_lease(client: &mut Client, lease_id: &str) -> Result(&url).await } + +#[cfg(test)] +mod test { + use super::*; + use reqwest::Url; + + #[tokio::test] + async fn list_dhcp_servers() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::dhcp_server::list(&mut client).await?; + + println!("{:?}", response); + + Ok(()) + } + + #[tokio::test] + async fn get_dhcp_server() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + let response = crate::ip::dhcp_server::get(&mut client, "vlan-150").await?; + + println!("{:?}", response); + + Ok(()) + } + + #[tokio::test] + async fn list_network() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::dhcp_server::list_network(&mut client).await?; + + println!("{:?}", response); + + Ok(()) + } + + #[tokio::test] + async fn get_network() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::dhcp_server::list_network(&mut client).await?; + + let response = crate::ip::dhcp_server::get_network(&mut client, &response[0].id).await?; + + println!("{:?}", response); + + Ok(()) + } + + #[tokio::test] + async fn list_leases() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::dhcp_server::list_leases(&mut client).await?; + + println!("{:?}", response); + + Ok(()) + } + + #[tokio::test] + async fn get_lease() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::dhcp_server::list_leases(&mut client).await?; + + let response = crate::ip::dhcp_server::get_lease(&mut client, &response[0].id).await?; + + println!("{:?}", response); + + Ok(()) + } +} diff --git a/src/ip/route.rs b/src/ip/route.rs index c896a4c..6b52342 100644 --- a/src/ip/route.rs +++ b/src/ip/route.rs @@ -49,3 +49,37 @@ pub async fn remove(client: &mut Client, input: RouteInput) -> Result<(), Client } //TODO(ishan): add set/unset/reset + +#[cfg(test)] +mod test { + use super::*; + use reqwest::Url; + + #[tokio::test] + async fn list_routes() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::route::list(&mut client).await?; + + println!("{:?}", response); + + Ok(()) + } + + #[tokio::test] + async fn get_route() -> Result<(), ClientError> { + let base = Url::parse("https://10.0.10.1")?; + let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) + .expect("error in creating client"); + + let response = crate::ip::route::list(&mut client).await?; + + let response = crate::ip::route::get(&mut client, &response[0].id).await?; + + println!("{:?}", response); + + Ok(()) + } +} diff --git a/src/ip/types.rs b/src/ip/types.rs index e1e3a6a..7eb61ad 100644 --- a/src/ip/types.rs +++ b/src/ip/types.rs @@ -185,3 +185,23 @@ pub struct Route { #[serde(rename = "local-address")] pub local_address: Option, } + +#[derive(Default, Hash, Eq, Debug, Clone, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct AddAddressInput { + pub address: String, + pub comment: Option, + #[serde(deserialize_with = "deserialize_bool")] + pub disabled: bool, + pub interface: String, + + // TODO(ishan): Do not serialize this if this was none + #[serde(skip_serializing_if = "Option::is_none")] + pub network: Option, +} + +#[derive(Default, Hash, Eq, Debug, Clone, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct AddAddressOutput { + pub ret: String, +} diff --git a/tests/ip_test.rs b/tests/ip_test.rs deleted file mode 100644 index 82a28e9..0000000 --- a/tests/ip_test.rs +++ /dev/null @@ -1,212 +0,0 @@ -use mikrotik::{ip::dhcp_client::DhcpClientInput, Client, ClientError}; -use reqwest::Url; - -#[tokio::test] -async fn list_dhcp_servers() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_server::list(&mut client).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn get_dhcp_server() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_server::get(&mut client, "vlan-150").await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn list_network() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_server::list_network(&mut client).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn get_network() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_server::list_network(&mut client).await?; - - let response = mikrotik::ip::dhcp_server::get_network(&mut client, &response[0].id).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn list_leases() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_server::list_leases(&mut client).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn get_lease() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_server::list_leases(&mut client).await?; - - let response = mikrotik::ip::dhcp_server::get_lease(&mut client, &response[0].id).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn list_address() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::address::list(&mut client).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn get_address() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::address::list(&mut client).await?; - - let response = mikrotik::ip::address::get(&mut client, &response[0].id).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn list_dhcp_client() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_client::list(&mut client).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn get_dhcp_client() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_client::list(&mut client).await?; - - let response = mikrotik::ip::dhcp_client::get(&mut client, &response[0].id).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn renew_dhcp_lease() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_client::list(&mut client).await?; - - let response = mikrotik::ip::dhcp_client::renew( - &mut client, - DhcpClientInput { - numbers: response[0].id.clone(), - }, - ) - .await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn release_dhcp_lease() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_client::list(&mut client).await?; - - println!("{:?}", response); - - let response = mikrotik::ip::dhcp_client::release( - &mut client, - DhcpClientInput { - numbers: response[0].id.clone(), - }, - ) - .await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn list_routes() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::route::list(&mut client).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn get_route() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::route::list(&mut client).await?; - - let response = mikrotik::ip::route::get(&mut client, &response[0].id).await?; - - println!("{:?}", response); - - Ok(()) -} diff --git a/tests/routing_test.rs b/tests/routing_test.rs deleted file mode 100644 index 82a28e9..0000000 --- a/tests/routing_test.rs +++ /dev/null @@ -1,212 +0,0 @@ -use mikrotik::{ip::dhcp_client::DhcpClientInput, Client, ClientError}; -use reqwest::Url; - -#[tokio::test] -async fn list_dhcp_servers() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_server::list(&mut client).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn get_dhcp_server() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_server::get(&mut client, "vlan-150").await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn list_network() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_server::list_network(&mut client).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn get_network() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_server::list_network(&mut client).await?; - - let response = mikrotik::ip::dhcp_server::get_network(&mut client, &response[0].id).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn list_leases() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_server::list_leases(&mut client).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn get_lease() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_server::list_leases(&mut client).await?; - - let response = mikrotik::ip::dhcp_server::get_lease(&mut client, &response[0].id).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn list_address() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::address::list(&mut client).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn get_address() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::address::list(&mut client).await?; - - let response = mikrotik::ip::address::get(&mut client, &response[0].id).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn list_dhcp_client() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_client::list(&mut client).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn get_dhcp_client() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_client::list(&mut client).await?; - - let response = mikrotik::ip::dhcp_client::get(&mut client, &response[0].id).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn renew_dhcp_lease() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_client::list(&mut client).await?; - - let response = mikrotik::ip::dhcp_client::renew( - &mut client, - DhcpClientInput { - numbers: response[0].id.clone(), - }, - ) - .await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn release_dhcp_lease() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::dhcp_client::list(&mut client).await?; - - println!("{:?}", response); - - let response = mikrotik::ip::dhcp_client::release( - &mut client, - DhcpClientInput { - numbers: response[0].id.clone(), - }, - ) - .await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn list_routes() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::route::list(&mut client).await?; - - println!("{:?}", response); - - Ok(()) -} - -#[tokio::test] -async fn get_route() -> Result<(), ClientError> { - let base = Url::parse("https://10.0.10.1")?; - let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true) - .expect("error in creating client"); - - let response = mikrotik::ip::route::list(&mut client).await?; - - let response = mikrotik::ip::route::get(&mut client, &response[0].id).await?; - - println!("{:?}", response); - - Ok(()) -}