rustsf 0.0.3

Rust Salesforce API Client
Documentation
use super::*;
use mockito::Server;
use serde_json::json;

fn create_test_bulk_api_v2(server_url: &str) -> BulkApiV2 {
    let mut client = Client::new();
    client.set_instance_url(server_url);
    client.set_access_token(
        "test_token".to_string(),
        "9999999999000".to_string(),
        "Bearer".to_string(),
    );
    client.set_version("v60.0");
    BulkApiV2::new(client)
}

#[test]
fn test_new() {
    let client = Client::new();
    let api = BulkApiV2::new(client);
    assert!(api.client.instance_url.is_none());
}

#[test]
fn test_base_version_path() {
    let mut client = Client::new();
    client.set_instance_url("https://na1.salesforce.com");
    client.set_version("v60.0");
    let api = BulkApiV2::new(client);
    assert_eq!(
        api.client.base_version_path().unwrap(),
        "https://na1.salesforce.com/services/data/v60.0"
    );
}

#[test]
fn test_base_path_not_logged_in() {
    let client = Client::new();
    let api = BulkApiV2::new(client);
    let result = api.client.base_version_path();
    assert!(result.is_err());
    match result.unwrap_err() {
        Error::NotLoggedIn => {}
        e => panic!("Expected NotLoggedIn, got {:?}", e),
    }
}

#[tokio::test]
async fn test_create_job() {
    let mut server = Server::new_async().await;
    let mock = server
        .mock("POST", "/services/data/v60.0/jobs/ingest")
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body(
            json!({
            "id": "750xx",
            "operation": "insert",
            "object": "Account",
            "createdById": "005xx",
            "createdDate": "2024-01-01",
            "systemModstamp": "2024-01-01",
            "state": "Open",
            "concurrencyMode": "Parallel",
            "contentType": "CSV",
            "apiVersion": 60.0,
            "contentUrl": "services/data/v60.0/jobs/ingest/750xx/batches",
            "lineEnding": "LF"
            })
            .to_string(),
        )
        .create_async()
        .await;

    let mut api = create_test_bulk_api_v2(&server.url());
    let mut params = HashMap::new();
    params.insert("operation", "insert");
    params.insert("object", "Account");
    let res = api.create_job(params).await;
    assert!(res.is_ok());
    mock.assert_async().await;
}

#[tokio::test]
async fn test_upload_job_data_success() {
    let mut server = Server::new_async().await;
    let mock = server
        .mock("PUT", "/services/data/v60.0/jobs/ingest/750xx/batches")
        .with_status(201)
        .create_async()
        .await;

    let mut api = create_test_bulk_api_v2(&server.url());
    let csv = b"Name\nTest Account".to_vec();
    let res = api.upload_job_data("750xx", csv).await;
    assert!(res.is_ok());
    assert_eq!(res.unwrap(), "Created");
    mock.assert_async().await;
}

#[tokio::test]
async fn test_upload_job_data_failure() {
    let mut server = Server::new_async().await;
    let mock = server
        .mock("PUT", "/services/data/v60.0/jobs/ingest/750xx/batches")
        .with_status(400)
        .with_header("content-type", "application/json")
        .with_body(
            json!({
            "message": "Invalid CSV",
            "errorCode": "INVALID_CONTENT"
            })
            .to_string(),
        )
        .create_async()
        .await;

    let mut api = create_test_bulk_api_v2(&server.url());
    let csv = b"bad data".to_vec();
    let res = api.upload_job_data("750xx", csv).await;
    assert!(res.is_err());
    mock.assert_async().await;
}

#[tokio::test]
async fn test_get_all_jobs() {
    let mut server = Server::new_async().await;
    let mock = server
        .mock("GET", "/services/data/v60.0/jobs/ingest/")
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body(json!({"records": [], "done": true}).to_string())
        .create_async()
        .await;

    let mut api = create_test_bulk_api_v2(&server.url());
    let res = api.get_all_jobs().await;
    assert!(res.is_ok());
    mock.assert_async().await;
}

#[tokio::test]
async fn test_get_job_info() {
    let mut server = Server::new_async().await;
    let mock = server
        .mock("GET", "/services/data/v60.0/jobs/ingest/750xx")
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body(json!({"id": "750xx", "state": "Open"}).to_string())
        .create_async()
        .await;

    let mut api = create_test_bulk_api_v2(&server.url());
    let res = api.get_job_info("750xx").await;
    assert!(res.is_ok());
    mock.assert_async().await;
}

#[tokio::test]
async fn test_get_job_records() {
    let mut server = Server::new_async().await;
    let mock = server
        .mock(
            "GET",
            "/services/data/v60.0/jobs/ingest/750xx/successfulResults",
        )
        .with_status(200)
        .with_body("sf__Id,Name\n001xx,Test")
        .create_async()
        .await;

    let mut api = create_test_bulk_api_v2(&server.url());
    let res = api.get_job_records("750xx", "successfulResults").await;
    assert!(res.is_ok());
    mock.assert_async().await;
}

#[tokio::test]
async fn test_abort_job() {
    let mut server = Server::new_async().await;
    let mock = server
        .mock("PATCH", "/services/data/v60.0/jobs/ingest/750xx")
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body(json!({"state": "Aborted"}).to_string())
        .create_async()
        .await;

    let mut api = create_test_bulk_api_v2(&server.url());
    let res = api.abort_job("750xx").await;
    assert!(res.is_ok());
    mock.assert_async().await;
}

#[tokio::test]
async fn test_set_upload_state() {
    let mut server = Server::new_async().await;
    let mock = server
        .mock("PATCH", "/services/data/v60.0/jobs/ingest/750xx")
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body(json!({"state": "UploadComplete"}).to_string())
        .create_async()
        .await;

    let mut api = create_test_bulk_api_v2(&server.url());
    let mut params = HashMap::new();
    params.insert("state", "UploadComplete");
    let res = api.set_upload_state("750xx", params).await;
    assert!(res.is_ok());
    mock.assert_async().await;
}

#[tokio::test]
async fn test_check_job_status() {
    let mut server = Server::new_async().await;
    let mock = server
        .mock("GET", "/services/data/v60.0/jobs/ingest/750xx/")
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body(json!({"id": "750xx", "state": "JobComplete"}).to_string())
        .create_async()
        .await;

    let mut api = create_test_bulk_api_v2(&server.url());
    let res = api.check_job_status("750xx").await;
    assert!(res.is_ok());
    mock.assert_async().await;
}