unki/integration-tests/tests/integration_tests/endpoints.rs

// get_personal_jobs(&self, url_param: Id)
// report(&self, payload: impl OneOrVec<messaging::Reportable>)
// dl(&self, file: String)
// get_job(&self, job: Id)
// get_jobs(&self)
// get_agents(&self, agent: Option<Id>)
// update_agent(&self, agent: Agent)
// update_job(&self, job: FatJob)
// update_result(&self, result: AssignedJob)
// upload_jobs(&self, payload: impl OneOrVec<FatJob>)
// del(&self, item: Id)
// set_jobs(&self, agent: Id, job_idents: impl OneOrVec<String>)
// get_agent_jobs(&self, agent: Option<Id>)
// ping(&self)

use crate::fixtures::connections::*;
use std::iter::repeat;
use u_lib::models::{BriefMode, RawJob, RawPayload, MAX_READABLE_PAYLOAD_SIZE};

#[rstest]
#[tokio::test]
async fn jobs_upload_update_get_del(client_panel: &HttpClient) {
    let job_alias = "henlo";
    let mut job = RawJob::default()
        .with_shell("/bin/bash {}")
        .with_raw_payload("echo henlo")
        .with_alias(job_alias)
        .try_into_job()
        .unwrap();

    let job_id = job.meta.id;

    client_panel.upload_jobs([&job]).await.unwrap();

    let fetched_job = client_panel.get_full_job(job_id).await.unwrap();
    assert_eq!(job, fetched_job);

    let new_alias = "henlo2".to_string();
    job.meta.alias = Some(new_alias.clone());
    client_panel.update_job(&job.meta).await.unwrap();

    let fetched_job = client_panel.get_full_job(job_id).await.unwrap();
    assert_eq!(
        fetched_job.payload.as_ref().unwrap().data.as_ref().unwrap(),
        b"echo henlo"
    );
    assert_eq!(fetched_job.meta.alias, Some(new_alias));

    client_panel.del(job_id).await.unwrap();

    let not_found_err = client_panel.get_brief_job(job_id).await.unwrap_err();
    assert!(not_found_err.to_string().contains("404 Not Found"))
}

#[rstest]
#[tokio::test]
async fn payloads_upload_update_get_del(client_panel: &HttpClient) {
    let name = "test1".to_string();
    let data = b"qweasdzxc".to_vec();
    let payload = RawPayload {
        name: Some(name.clone()),
        data: data.clone(),
    };

    client_panel.upload_payloads([&payload]).await.unwrap();

    let mut fetched_payload = client_panel
        .get_payload(&name, BriefMode::No)
        .await
        .unwrap();
    let fetched_payload_auto = client_panel
        .get_payload(&name, BriefMode::Auto)
        .await
        .unwrap();

    assert_eq!(fetched_payload, fetched_payload_auto);
    assert_eq!(fetched_payload.data.unwrap(), data);

    let new_size = MAX_READABLE_PAYLOAD_SIZE + 1;
    let big_data = repeat(1u8).take(new_size as usize).collect::<Vec<_>>();

    fetched_payload.data = Some(big_data.clone());
    client_panel.update_payload(&fetched_payload).await.unwrap();

    let fetched_big_payload = client_panel
        .get_payload(&name, BriefMode::Yes)
        .await
        .unwrap();
    let fetched_big_payload_auto = client_panel
        .get_payload(&name, BriefMode::Auto)
        .await
        .unwrap();

    assert_eq!(fetched_big_payload, fetched_big_payload_auto);
    assert_eq!(fetched_big_payload.size, new_size);
    assert!(fetched_big_payload.data.is_none());

    let fetched_big_payload_full = client_panel
        .get_payload(&name, BriefMode::No)
        .await
        .unwrap();

    assert_eq!(fetched_big_payload_full.data.unwrap(), big_data);

    client_panel.del(fetched_big_payload_full.id).await.unwrap();

    let not_found_err = client_panel
        .get_payload(&name, BriefMode::Yes)
        .await
        .unwrap_err();
    assert!(not_found_err.to_string().contains("404 Not Found"))
}