pushover-rs 0.3.23

use crate::tests::setup::{TestData, read_test_data};
use crate::{send_pushover_request, send_pushover_request_with_attachment, send_pushover_request_with_attachment_async};
use crate::{
    pushover::data::{Message, MessageBuilder, AttachmentMessage, AttachmentMessageBuilder, PushoverResponse}
};

#[test]
pub fn test_testdata_readability() {
    let testdata: Result<TestData, Box<dyn std::error::Error>> = read_test_data();
    assert_eq!(testdata.is_ok(), true);
}

#[tokio::test]
async fn test_send_minimal_message_specific_device() {
    // Device name is set on the Pushover dashboard.
    // You can join multiple singular devices by separating them with a comma (eg: "MyPhone,MyOtherPhone")
    let device_name: &str = "MyPhone";
    if let Ok(credentials) = read_test_data() {
        let message: Message = MessageBuilder::new(
            credentials.user_key.as_str(),
            credentials.app_token.as_str(),
            "Test from pushover-rs to specific device.",
        )
            .set_device(device_name)
            .build();
        let response = send_pushover_request(message).await;
        assert!(response.is_ok());
    } else {
        panic!("Could not read test data.");
    }
}

#[tokio::test]
async fn test_send_request_minimal_message() {
    if let Ok(credentials) = read_test_data() {
        let message: Message = MessageBuilder::new(
            credentials.user_key.as_str(),
            credentials.app_token.as_str(),
            "Test from pushover-rs.",
        )
        .build();
        let response = send_pushover_request(message).await;
        assert!(response.is_ok());
    } else {
        panic!("Could not read test data.");
    }
}

#[tokio::test]
async fn test_send_request_min_message_with_ttl() {
    if let Ok(credentials) = read_test_data() {
        let ttl: u32 = 5;
        let message: Message = MessageBuilder::new(
            credentials.user_key.as_str(),
            credentials.app_token.as_str(),
            format!("Test from pushover-rs with {ttl} seconds TTL").as_str(),
        )
            .set_ttl(ttl)
            .build();
        let response = send_pushover_request(message).await;
        assert!(response.is_ok());
    } else {
        panic!("Could not read test data.");
    }
}

#[tokio::test]
async fn test_send_request_emergency_priority() {
    if let Ok(credentials) = read_test_data() {
        let message: Message = MessageBuilder::new(
            credentials.user_key.as_str(),
            credentials.app_token.as_str(),
            "Server down wake up!!!",
        )
            .set_priority(2)
            .set_retry(30)
            .set_expire(60)
            .build();
        let response = send_pushover_request(message).await;
        assert!(response.is_ok());
    } else {
        panic!("Could not read test data.");
    }
}

#[tokio::test]
async fn test_send_bad_request() {
    // Message should not be used "manually", messagebuilder should be used.
    // Default message doesn't contain the minimal info for a request.
    let message = Message {
        ..Default::default()
    };
    let response = send_pushover_request(message).await;

    assert!(response.is_ok()); // Bad request doesn't mean the request didn't go through

    if response.is_ok() {
        // !Shadowing previous var
        let response: PushoverResponse = response.ok().unwrap();
        assert_eq!(response.status, 0);
    }
}

#[test]
fn test_send_with_good_attachment() {
    if let Ok(credentials) = read_test_data() {
        let attachment_path: String = "./testdata/attachment_test.jpg".to_owned();
        let message: AttachmentMessage = AttachmentMessageBuilder::new(
            credentials.user_key.as_str(),
            credentials.app_token.as_str(),
            "Test from pushover-rs, with attachment and ttl",
        )
        .set_attachment(attachment_path)
        .set_ttl(10)
        .build()
        .unwrap();

        let response = send_pushover_request_with_attachment(message);

        assert!(response.is_ok());
    } else {
        panic!("Could not read test data.");
    }
}
#[test]
fn test_send_with_good_attachment_and_emergency_priority() {
    if let Ok(credentials) = read_test_data() {
        let attachment_path: String = "./testdata/attachment_test.jpg".to_owned();
        let message: AttachmentMessage = AttachmentMessageBuilder::new(
            credentials.user_key.as_str(),
            credentials.app_token.as_str(),
            "Test from pushover-rs, with attachment and ttl",
        )
            .set_attachment(attachment_path)
            .set_priority(2)
            .set_retry(30)
            .set_expire(120)
            .build()
            .unwrap();

        let response = send_pushover_request_with_attachment(message);

        assert!(response.is_ok());
    } else {
        panic!("Could not read test data.");
    }
}

#[tokio::test]
async fn test_send_with_good_attachment_async() {
    if let Ok(credentials) = read_test_data() {
        let attachment_path: String = "./testdata/attachment_test.jpg".to_owned();
        let message: AttachmentMessage = AttachmentMessageBuilder::new(
            credentials.user_key.as_str(),
            credentials.app_token.as_str(),
            "<b>Test from pushover-rs</b>, with <font color='#FF0000'>attachment</font>, <font color='#00FF00'>ttl</font> and <font color='#0000FF'>async</font>",
        )
            .set_attachment(attachment_path)
            .set_ttl(60)
            .build()
            .unwrap();

        let response = send_pushover_request_with_attachment_async(message).await;

        assert!(response.is_ok());
    } else {
        panic!("Could not read test data.");
    }
}