opsview 0.1.12

mod api_responses;
extern crate opsview;
use crate::api_responses::*;
use mockito::{Server, ServerGuard};
use opsview::client::OpsviewClient;
use opsview::config::*;
use opsview::prelude::*;
use pretty_assertions::assert_eq;

/// Returns a ServerGuard that can be used to mock Opsview API responses.
/// Common responses are already mocked, in this case the login response.
async fn setup_mock_server() -> ServerGuard {
    let mut server = Server::new_async().await;

    server
        .mock("POST", "/rest/login")
        .with_status(200)
        .with_body(r#"{"token": "some_auth_token"}"#)
        .create_async()
        .await;

    server
}

#[tokio::test]
async fn test_get_all_bsmcomponent_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/bsmcomponent")
        .with_status(200)
        .with_body(ALL_BSMCOMPONENT_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let components = ov.get_all_bsmcomponent_configs(None).await;

    assert!(components.is_ok());

    Ok(())
}

#[tokio::test]
async fn test_get_bsmservice_config_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/bsmservice?s.name=BSM%201")
        .with_status(200)
        .with_body(BSMSERVICE_CONFIG)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let bsmservice = ov.get_bsmservice_config("BSM 1", None).await?;
    let component_1 = bsmservice
        .components
        .as_ref()
        .unwrap()
        .get("/rest/config/businesscomponent/1")
        .unwrap();
    let component_2 = bsmservice
        .components
        .unwrap()
        .get("/rest/config/businesscomponent/2")
        .unwrap();

    assert_eq!(bsmservice.name, "BSM 1");
    assert_eq!(component_1.name(), "Component 1");
    assert_eq!(component_2.name(), "Component 2");

    Ok(())
}

#[tokio::test]
async fn test_get_all_bsmservice_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/bsmservice")
        .with_status(200)
        .with_body(ALL_BSMSERVICE_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let services = ov.get_all_bsmservice_configs(None).await?;
    let service_1 = services.get("BSM 1-1").unwrap();
    let component_1 = service_1
        .components
        .as_ref()
        .unwrap()
        .get("/rest/config/businesscomponent/1")
        .unwrap();
    let component_2 = service_1
        .components
        .as_ref()
        .unwrap()
        .get("/rest/config/businesscomponent/2")
        .unwrap();

    assert!(!services.is_empty());
    assert_eq!(services.len(), 1);
    assert_eq!(service_1.name, "BSM 1");
    assert_eq!(service_1.components.as_ref().unwrap().len(), 2);
    assert_eq!(component_1.name(), "Component 1");
    assert_eq!(component_2.name(), "Component 2");

    Ok(())
}

#[tokio::test]
async fn test_get_contact_config_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/contact?s.name=admin")
        .with_status(200)
        .with_body(CONTACT_CONFIG)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let contact = ov.get_contact_config("admin", None).await?;

    assert_eq!(contact.name, "admin");
    assert_eq!(contact.id, Some(1));
    assert_eq!(contact.ref_.as_ref().unwrap(), "/rest/config/contact/1");
    assert_eq!(contact.uncommitted, Some(false));
    assert_eq!(
        contact
            .notificationprofiles
            .as_ref()
            .expect("notificationprofiles is None")
            .len(),
        1
    );
    assert_eq!(
        contact
            .notificationprofiles
            .expect("notificationprofiles is None")
            .get("Default")
            .unwrap()
            .ref_
            .as_ref()
            .unwrap(),
        "/rest/config/notificationprofile/1",
    );

    Ok(())
}

#[tokio::test]
async fn test_get_all_contact_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/contact")
        .with_status(200)
        .with_body(ALL_CONTACT_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let contacts = ov.get_all_contact_configs(None).await?;
    let anonymous_guest = contacts
        .get("anonymous-guest")
        .expect("No contact named 'anonymous-guest'");

    assert!(!contacts.is_empty());
    assert_eq!(contacts.len(), 3);
    assert_eq!(anonymous_guest.name, "anonymous-guest");
    assert_eq!(
        anonymous_guest.description,
        Some("Anonymous guest".to_string())
    );
    assert_eq!(anonymous_guest.fullname, Some("Guest".to_string()));

    Ok(())
}

#[tokio::test]
async fn test_get_all_hashtag_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/keyword")
        .with_status(200)
        .with_body(ALL_HASHTAG_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let hashtags = ov.get_all_hashtag_configs(None).await?;

    assert!(!hashtags.is_empty());

    Ok(())
}

#[tokio::test]
async fn test_get_host_config_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/host?s.name=opsview")
        .with_status(200)
        .with_body(HOST_CONFIG)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let host = ov.get_host_config("opsview", None).await?;

    assert_eq!(host.name, "opsview");
    assert_eq!(
        host.check_command
            .as_ref()
            .expect("check_command is None")
            .name(),
        "ping"
    );
    assert_eq!(
        host.check_command.expect("check_Command is None").ref_(),
        Some("/rest/config/hostcheckcommand/15".to_string())
    );
    assert_eq!(host.check_interval, Some(300));
    assert_eq!(host.retry_check_interval, Some(60));
    assert_eq!(host.check_attempts, Some(2));

    Ok(())
}

#[tokio::test]
async fn test_get_all_host_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/host")
        .with_status(200)
        .with_body(ALL_HOST_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let hosts = ov.get_all_host_configs(None).await?;
    let host_0 = hosts.get("Amer-Finance-Environment").unwrap();
    let host_48 = hosts.get("opsview").unwrap();

    assert!(!hosts.is_empty());
    assert_eq!(hosts.len(), 48);
    assert_eq!(host_0.name, "Amer-Finance-Environment");
    assert_eq!(
        host_0
            .check_command
            .as_ref()
            .expect("check_command is None")
            .name(),
        "ping"
    );
    assert_eq!(
        host_0
            .check_command
            .as_ref()
            .expect("check_command is None")
            .ref_(),
        Some("/rest/config/hostcheckcommand/15".to_string())
    );
    assert_eq!(host_0.check_interval, Some(300));
    assert_eq!(host_0.retry_check_interval, Some(60));
    assert_eq!(host_0.check_attempts, Some(2));
    assert_eq!(
        host_0
            .hostgroup
            .as_ref()
            .expect("hostgroup is None")
            .name()
            .as_str(),
        "192.168.2.88 - VMs"
    );
    assert_eq!(
        host_48
            .hostgroup
            .as_ref()
            .expect("hostgroup is None")
            .ref_(),
        Some("/rest/config/hostgroup/2".to_string())
    );
    assert_eq!(host_48.name, "opsview");
    assert_eq!(
        host_48
            .check_command
            .as_ref()
            .expect("check_command is None")
            .name(),
        "ping"
    );

    Ok(())
}

#[tokio::test]
async fn test_get_all_host_configs_with_empty_snmpinterfaces_mock() -> Result<(), OpsviewClientError>
{
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/host?cols=%2Bsnmpinterfaces")
        .with_status(200)
        .with_body(ALL_HOST_CONFIGS_WITH_EMPTY_SNMPINTERFACES)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let params = Some(vec![("cols".to_string(), "+snmpinterfaces".to_string())]);
    let hosts = ov.get_all_host_configs(params).await?;
    let host_0 = hosts.get("Amer-Finance-Environment").unwrap();
    let host_48 = hosts.get("opsview").unwrap();

    assert!(!hosts.is_empty());
    assert_eq!(hosts.len(), 48);
    assert_eq!(host_0.name, "Amer-Finance-Environment");
    assert_eq!(
        host_0
            .snmpinterfaces
            .clone()
            .expect("snmpinterfaces is None"),
        SNMPInterfaces::default()
    );
    assert_eq!(host_48.name, "opsview");
    assert_eq!(
        host_48
            .snmpinterfaces
            .clone()
            .expect("snmpinterfaces is None"),
        SNMPInterfaces::default()
    );

    Ok(())
}

#[tokio::test]
async fn test_get_all_host_configs_with_snmpinterfaces_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/host?cols=%2Bsnmpinterfaces")
        .with_status(200)
        .with_body(ALL_HOST_CONFIGS_WITH_SNMPINTERFACES)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let params = Some(vec![("cols".to_string(), "+snmpinterfaces".to_string())]);
    let hosts = ov.get_all_host_configs(params).await?;
    let host_0 = hosts.get("Amer-Finance-Environment").unwrap();
    let host_48 = hosts.get("opsview").unwrap();

    assert!(!hosts.is_empty());
    assert_eq!(hosts.len(), 48);
    assert_eq!(host_0.name, "Amer-Finance-Environment");
    assert_eq!(
        host_0
            .snmpinterfaces
            .clone()
            .expect("snmpinterfaces is None"),
        SNMPInterfaces::default()
    );
    assert_eq!(host_48.name, "opsview");
    assert!(host_48.snmpinterfaces.is_some());

    let interfaces = host_48
        .snmpinterfaces
        .clone()
        .expect("snmpinterfaces is None");

    let i0 = interfaces[0].clone();
    let i1 = interfaces[1].clone();

    assert_eq!(i0.active, Some(false));
    assert_eq!(i0.discards_critical, Some("15".to_string()));
    assert_eq!(i0.discards_warning, None);
    assert_eq!(i0.duplicatename, Some(false));
    assert_eq!(i0.errors_critical, Some("10".to_string()));
    assert_eq!(i0.errors_warning, None);
    assert_eq!(i0.indexid, Some(0));
    assert_eq!(i0.interfacename, Some("".to_string()));
    assert_eq!(i0.throughput_critical, Some("50%".to_string()));
    assert_eq!(i0.throughput_warning, None);

    assert_eq!(i1.active, Some(false));
    assert_eq!(i1.discards_critical, Some("".to_string()));
    assert_eq!(i1.discards_warning, Some("".to_string()));
    assert_eq!(i1.duplicatename, Some(false));
    assert_eq!(i1.errors_critical, Some("".to_string()));
    assert_eq!(i1.errors_warning, Some("".to_string()));
    assert_eq!(i1.indexid, Some(0));
    assert_eq!(i1.interfacename, Some("eth0".to_string()));
    assert_eq!(i1.throughput_critical, Some("".to_string()));
    assert_eq!(i1.throughput_warning, Some("".to_string()));

    Ok(())
}

#[tokio::test]
async fn test_get_all_hostcheckcommand_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/hostcheckcommand")
        .with_status(200)
        .with_body(ALL_HOSTCHECKCOMMAND_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let commands = ov.get_all_hostcheckcommand_configs(None).await?;

    assert!(!commands.is_empty());

    Ok(())
}

// #[tokio::test]
// async fn test_get_hostgroup_config_mock() -> Result<(), OpsviewClientError> {
//     let mut s = setup_mock_server().await;

//     s.await.mock("GET", "/rest/config/hostgroup?s.name=Opsview")
//         .with_status(200)
//         .with_body(HOSTGROUP_CONFIG)
//         .create_async().await;

//     let ov = OpsviewClient::new(&s.url(), "username", "password").await?;
//     let hostgroup = ov.get_hostgroup_config("Opsview").await?;

//     assert_eq!(hostgroup.name, "Opsview");

//     Ok(())
// }

#[tokio::test]
async fn test_get_all_hostgroup_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/hostgroup")
        .with_status(200)
        .with_body(ALL_HOSTGROUP_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let hostgroups = ov.get_all_hostgroup_configs(None).await?;

    let hostgroup_1 = hostgroups.get("Opsview,").unwrap();

    assert!(!hostgroups.is_empty());
    assert_eq!(hostgroups.len(), 14);
    assert_eq!(hostgroup_1.name, "Opsview");
    assert_eq!(hostgroup_1.id, Some(1));
    assert_eq!(
        hostgroup_1.ref_.as_ref().unwrap(),
        "/rest/config/hostgroup/1"
    );

    Ok(())
}

#[tokio::test]
async fn test_get_all_hosticon_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/hosticons")
        .with_status(200)
        .with_body(ALL_HOSTICON_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let hosticons = ov.get_all_hosticon_configs(None).await?;

    assert!(!hosticons.is_empty());

    Ok(())
}

#[tokio::test]
async fn test_get_all_hosttemplate_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/hosttemplate")
        .with_status(200)
        .with_body(ALL_HOSTTEMPLATE_CONFIGS_PAGE_1)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/hosttemplate?page=2")
        .with_status(200)
        .with_body(ALL_HOSTTEMPLATE_CONFIGS_PAGE_2)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/hosttemplate?page=3")
        .with_status(200)
        .with_body(ALL_HOSTTEMPLATE_CONFIGS_PAGE_3)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/hosttemplate?page=4")
        .with_status(200)
        .with_body(ALL_HOSTTEMPLATE_CONFIGS_PAGE_4)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/hosttemplate?page=5")
        .with_status(200)
        .with_body(ALL_HOSTTEMPLATE_CONFIGS_PAGE_5)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/hosttemplate?page=6")
        .with_status(200)
        .with_body(ALL_HOSTTEMPLATE_CONFIGS_PAGE_6)
        .create_async()
        .await;

    let ov = OpsviewClient::new(&s.url(), "username", "password", false).await?;
    let hosttemplates = ov.get_all_hosttemplate_configs(None).await?;

    assert!(!hosttemplates.is_empty());

    Ok(())
}

#[tokio::test]
async fn test_get_monitoringcluster_config_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/monitoringcluster?s.name=collectors-ny")
        .with_status(200)
        .with_body(MONITORINGCLUSTER_CONFIG)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let cluster = ov
        .get_monitoringcluster_config("collectors-ny", None)
        .await?;

    assert_eq!(cluster.name, "collectors-ny");
    assert_eq!(cluster.id, Some(2));
    assert_eq!(
        cluster.ref_.as_ref().unwrap(),
        "/rest/config/monitoringcluster/2"
    );

    Ok(())
}

#[tokio::test]
async fn test_get_all_monitoringcluster_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/monitoringcluster")
        .with_status(200)
        .with_body(ALL_MONITORINGCLUSTER_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let clusters = ov.get_all_monitoringcluster_configs(None).await?;
    let cluster_1 = clusters.get("Master Monitoring Server").unwrap();
    let cluster_2 = clusters.get("collectors-ny").unwrap();

    assert!(!clusters.is_empty());
    assert_eq!(clusters.len(), 2);
    assert_eq!(cluster_1.name, "Master Monitoring Server");
    assert_eq!(cluster_1.id, Some(1));
    assert_eq!(
        cluster_1.ref_.as_ref().unwrap(),
        "/rest/config/monitoringcluster/1"
    );
    assert_eq!(
        cluster_1.monitors.as_ref().expect("monitors is None").len(),
        1
    );
    assert_eq!(cluster_2.name, "collectors-ny");
    assert_eq!(cluster_2.id, Some(2));
    assert_eq!(
        cluster_2.ref_.as_ref().unwrap(),
        "/rest/config/monitoringcluster/2"
    );
    assert_eq!(
        cluster_1.cloudops_owned.expect("cloudops_owned is None"),
        false
    );
    assert_eq!(
        cluster_2.monitors.as_ref().expect("monitors is None").len(),
        47
    );

    Ok(())
}

#[tokio::test]
async fn test_get_notificationmethod_config_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/notificationmethod?s.name=Email")
        .with_status(200)
        .with_body(NOTIFICATIONMETHOD_CONFIG)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let method = ov.get_notificationmethod_config("Email", None).await?;

    assert_eq!(method.name, "Email");
    assert_eq!(method.id, Some(3));
    assert_eq!(
        method.ref_.as_ref().unwrap(),
        "/rest/config/notificationmethod/3"
    );
    assert_eq!(method.uncommitted, Some(false));
    assert_eq!(
        method
            .notificationprofiles
            .as_ref()
            .expect("notificationprofiles is None")
            .len(),
        0
    );

    Ok(())
}

#[tokio::test]
async fn test_get_all_notificationmethod_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/notificationmethod")
        .with_status(200)
        .with_body(ALL_NOTIFICATIONMETHOD_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let methods = ov.get_all_notificationmethod_configs(None).await?;
    let method_1 = methods.get("Email").unwrap();
    let method_2 = methods.get("SMS Notification Module").unwrap();

    assert!(!methods.is_empty());
    assert_eq!(methods.len(), 20);
    assert_eq!(method_1.name, "Email");
    assert_eq!(method_1.id, Some(3));
    assert_eq!(
        method_1.ref_.as_ref().unwrap(),
        "/rest/config/notificationmethod/3"
    );
    assert_eq!(method_2.name, "SMS Notification Module");
    assert_eq!(method_2.id, Some(2));
    assert_eq!(
        method_2.ref_.as_ref().unwrap(),
        "/rest/config/notificationmethod/2"
    );

    Ok(())
}

#[tokio::test]
async fn test_get_all_plugin_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/plugin")
        .with_status(200)
        .with_body(ALL_PLUGIN_CONFIGS_PAGE_1)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/plugin?page=2")
        .with_status(200)
        .with_body(ALL_PLUGIN_CONFIGS_PAGE_2)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/plugin?page=3")
        .with_status(200)
        .with_body(ALL_PLUGIN_CONFIGS_PAGE_3)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/plugin?page=4")
        .with_status(200)
        .with_body(ALL_PLUGIN_CONFIGS_PAGE_4)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/plugin?page=5")
        .with_status(200)
        .with_body(ALL_PLUGIN_CONFIGS_PAGE_5)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/plugin?page=6")
        .with_status(200)
        .with_body(ALL_PLUGIN_CONFIGS_PAGE_6)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let plugins = ov.get_all_plugin_configs(None).await?;

    assert!(!plugins.is_empty());

    Ok(())
}

#[tokio::test]
async fn test_get_role_config_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/role?s.name=Administrator")
        .with_status(200)
        .with_body(ROLE_CONFIG)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let role = ov.get_role_config("Administrator", None).await?;

    assert_eq!(role.name, "Administrator");
    assert_eq!(role.id, Some(10));
    assert_eq!(role.ref_.as_ref().unwrap(), "/rest/config/role/10");
    assert_eq!(role.uncommitted, Some(false));

    Ok(())
}

#[tokio::test]
async fn test_get_all_role_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/role")
        .with_status(200)
        .with_body(ALL_ROLE_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let roles = ov.get_all_role_configs(None).await?;

    println!("{:#?}", roles);

    let role_1 = roles.get("Administrator").unwrap();
    let role_2 = roles.get("Anonymous Guest").unwrap();

    assert!(!roles.is_empty());
    assert_eq!(roles.len(), 9);
    assert_eq!(role_1.name, "Administrator");
    assert_eq!(role_1.description, Some("Administrator access".to_string()));
    assert_eq!(role_1.id, Some(10));
    assert!(role_1
        .accesses
        .as_ref()
        .expect("accesses is None")
        .contains(&Access::ActionAll(Some(
            "/rest/config/access/3".to_string()
        ))));
    assert_eq!(role_1.ref_.as_ref().unwrap(), "/rest/config/role/10");
    assert_eq!(role_2.name, "Anonymous Guest");
    assert_eq!(role_2.id, Some(16));
    assert_eq!(role_2.ref_.as_ref().unwrap(), "/rest/config/role/16");

    Ok(())
}

#[tokio::test]
async fn test_get_all_servicegroup_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/servicegroup")
        .with_status(200)
        .with_body(ALL_SERVICEGROUP_CONFIGS_PAGE_1)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicegroup?page=2")
        .with_status(200)
        .with_body(ALL_SERVICEGROUP_CONFIGS_PAGE_2)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicegroup?page=3")
        .with_status(200)
        .with_body(ALL_SERVICEGROUP_CONFIGS_PAGE_3)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicegroup?page=4")
        .with_status(200)
        .with_body(ALL_SERVICEGROUP_CONFIGS_PAGE_4)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicegroup?page=5")
        .with_status(200)
        .with_body(ALL_SERVICEGROUP_CONFIGS_PAGE_5)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let servicegroups = ov.get_all_servicegroup_configs(None).await?;

    let servicegroup_1 = servicegroups
        .get("Application - Active Directory - Address Book")
        .unwrap();

    assert!(!servicegroups.is_empty());
    assert_eq!(servicegroups.len(), 215);
    assert_eq!(
        servicegroup_1.name,
        "Application - Active Directory - Address Book"
    );
    assert_eq!(servicegroup_1.id, Some(136));
    assert_eq!(
        servicegroup_1.ref_.as_ref().unwrap(),
        "/rest/config/servicegroup/136"
    );

    Ok(())
}

#[tokio::test]
async fn test_get_all_servicecheck_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/servicecheck")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_1)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=2")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_2)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=3")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_3)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=4")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_4)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=5")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_5)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=6")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_6)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=7")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_7)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=8")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_8)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=9")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_9)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=10")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_10)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=11")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_11)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=12")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_12)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=13")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_13)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=14")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_14)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=15")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_15)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=16")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_16)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=17")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_17)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=18")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_18)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=19")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_19)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=20")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_20)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=21")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_21)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=22")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_22)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=23")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_23)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=24")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_24)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=25")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_25)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=26")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_26)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=27")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_27)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=28")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_28)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=29")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_29)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/servicecheck?page=30")
        .with_status(200)
        .with_body(ALL_SERVICECHECK_CONFIGS_PAGE_30)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let servicechecks = ov.get_all_servicecheck_configs(None).await?;

    assert!(!servicechecks.is_empty());

    let example_service_1 = servicechecks.get("ACI - APIC - CPU Usage").unwrap();

    assert_eq!(example_service_1.name, "ACI - APIC - CPU Usage");
    assert_eq!(
        example_service_1.stale_state,
        Some(ServiceCheckState::Unknown)
    );

    let example_service_2 = servicechecks.get("Uptime Restart").unwrap();

    assert_eq!(example_service_2.name, "Uptime Restart");
    assert_eq!(example_service_2.stale_state, Some(ServiceCheckState::Ok));

    Ok(())
}

#[tokio::test]
async fn test_get_sharednotificationprofile_config_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock(
        "GET",
        "/rest/config/sharednotificationprofile?s.name=Receive%20all%20alerts%20during%20work%20hours",
    )
    .with_status(200)
    .with_body(SHAREDNOTIFICATIONPROFILE_CONFIG)
    .create_async().await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let profile = ov
        .get_sharednotificationprofile_config("Receive all alerts during work hours", None)
        .await?;

    println!("{:#?}", profile);

    assert_eq!(profile.name, "Receive all alerts during work hours");
    assert_eq!(profile.id, Some(2));
    assert_eq!(
        profile.ref_.as_ref().unwrap(),
        "/rest/config/sharednotificationprofile/2"
    );
    assert_eq!(profile.uncommitted, Some(false));
    assert_eq!(
        profile
            .notificationmethods
            .as_ref()
            .expect("notificationmethods is None")
            .len(),
        0
    );

    Ok(())
}

#[tokio::test]
async fn test_get_all_sharednotificationprofile_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/sharednotificationprofile")
        .with_status(200)
        .with_body(ALL_SHAREDNOTIFICATIONPROFILE_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let profiles = ov.get_all_sharednotificationprofile_configs(None).await?;
    let profile_1 = profiles
        .get("Receive all alerts during work hours")
        .unwrap();

    assert!(!profiles.is_empty());
    assert_eq!(profiles.len(), 1);
    assert_eq!(profile_1.name, "Receive all alerts during work hours");
    assert_eq!(profile_1.id, Some(2));
    assert_eq!(
        profile_1.ref_.as_ref().unwrap(),
        "/rest/config/sharednotificationprofile/2"
    );

    Ok(())
}

#[tokio::test]
async fn test_get_all_tenancy_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/tenancy")
        .with_status(200)
        .with_body(ALL_TENANCY_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let tenancies = ov.get_all_tenancy_configs(None).await?;

    assert!(!tenancies.is_empty());

    Ok(())
}

#[tokio::test]
async fn test_get_all_timeperiod_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/timeperiod")
        .with_status(200)
        .with_body(ALL_TIMEPERIOD_CONFIGS)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let timeperiods = ov.get_all_timeperiod_configs(None).await?;

    assert!(!timeperiods.is_empty());

    Ok(())
}

#[tokio::test]
async fn test_get_all_variable_configs_mock() -> Result<(), OpsviewClientError> {
    let mut s = setup_mock_server().await;

    s.mock("GET", "/rest/config/attribute")
        .with_status(200)
        .with_body(ALL_VARIABLE_CONFIGS_PAGE_1)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/attribute?page=2")
        .with_status(200)
        .with_body(ALL_VARIABLE_CONFIGS_PAGE_2)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/attribute?page=3")
        .with_status(200)
        .with_body(ALL_VARIABLE_CONFIGS_PAGE_3)
        .create_async()
        .await;

    s.mock("GET", "/rest/config/attribute?page=4")
        .with_status(200)
        .with_body(ALL_VARIABLE_CONFIGS_PAGE_4)
        .create_async()
        .await;

    let ov = OpsviewClient::builder()
        .url(&s.url())
        .username("username")
        .password("password")
        .ignore_cert(false)
        .build()
        .await?;

    let variables = ov.get_all_variable_configs(None).await?;

    assert!(!variables.is_empty());

    Ok(())
}