azure-devops 0.1.0

Idiomatic Rust client for Azure DevOps REST APIs
Documentation
#[cfg(test)]
use crate::constants::{ ct, hdr };
use crate::test_utils::{ mock_client, seed };
use httpmock::Method::GET;
use httpmock::Method::POST;
use httpmock::MockServer;

#[tokio::test]
async fn list_pipelines() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/pipelines");
        then.status(200).header(hdr::CONTENT_TYPE, ct::JSON).json_body(seed::pipelines_list());
    });

    let client = mock_client(&server);
    let pipes = client.pipelines().list("Veles", None).await.unwrap();
    assert_eq!(pipes.len(), 1);
    assert_eq!(pipes[0].name.as_deref(), Some("Main CI"));
}

#[tokio::test]
async fn get_pipeline() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/pipelines/1");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(seed::pipelines_list().as_array().unwrap()[0].clone());
    });

    let client = mock_client(&server);
    let pipe = client.pipelines().get("Veles", 1).await.unwrap();
    assert_eq!(pipe.id, Some(1));
}

#[tokio::test]
async fn list_pipeline_runs() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/pipelines/1/runs");
        then.status(200).header(hdr::CONTENT_TYPE, ct::JSON).json_body(seed::pipeline_runs_list());
    });

    let client = mock_client(&server);
    let runs = client.pipelines().list_runs("Veles", 1).await.unwrap();
    assert_eq!(runs.len(), 1);
    assert_eq!(runs[0].result, Some(crate::pipelines::models::RunResult::Succeeded));
}

#[tokio::test]
async fn run_pipeline() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(POST).path("/Veles/_apis/pipelines/1/runs");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(seed::pipeline_runs_list().as_array().unwrap()[0].clone());
    });

    let client = mock_client(&server);
    let params = crate::pipelines::models::RunPipelineParameters::default();
    let run = client.pipelines().run("Veles", 1, &params).await.unwrap();
    assert_eq!(run.id, Some(100));
}

#[tokio::test]
async fn get_pipeline_run() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/pipelines/1/runs/100");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(seed::pipeline_runs_list().as_array().unwrap()[0].clone());
    });

    let client = mock_client(&server);
    let run = client.pipelines().get_run("Veles", 1, 100).await.unwrap();
    assert_eq!(run.name.as_deref(), Some("20240115.1"));
}

#[tokio::test]
async fn create_pipeline() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(POST).path("/Veles/_apis/pipelines");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(seed::pipelines_list().as_array().unwrap()[0].clone());
    });

    let client = mock_client(&server);
    let params = crate::pipelines::models::CreatePipelineParameters::default();
    let pipe = client.pipelines().create("Veles", &params).await.unwrap();
    assert_eq!(pipe.id, Some(1));
}

#[tokio::test]
async fn get_pipeline_artifact() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/pipelines/1/runs/100/artifacts/drop");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!({
                "name": "drop", "url": "https://...",
                "signedContent": { "signature": "sha256" }
            })
            );
    });

    let client = mock_client(&server);
    let artifact = client.pipelines().get_artifact("Veles", 1, 100, "drop").await.unwrap();
    assert_eq!(artifact.name.as_deref(), Some("drop"));
}

#[tokio::test]
async fn get_pipeline_log() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/pipelines/1/runs/100/logs/1");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!({
                "id": 1, "url": "https://..."
            })
            );
    });

    let client = mock_client(&server);
    let log = client.pipelines().get_log("Veles", 1, 100, 1).await.unwrap();
    assert_eq!(log.id, Some(1));
}

#[tokio::test]
async fn list_pipeline_logs() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/pipelines/1/runs/100/logs");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!({
                "logs": [{ "id": 1, "url": "https://..." }]
            })
            );
    });

    let client = mock_client(&server);
    let logs = client.pipelines().list_logs("Veles", 1, 100).await.unwrap();
    assert!(logs.logs.is_some());
}

#[tokio::test]
async fn preview_pipeline() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(POST).path("/Veles/_apis/pipelines/1/preview");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!({
                "finalYaml": "stages:\n- stage: Build"
            })
            );
    });

    let client = mock_client(&server);
    let params = crate::pipelines::models::RunPipelineParameters::default();
    let preview = client.pipelines().preview("Veles", 1, &params).await.unwrap();
    assert!(preview.final_yaml.is_some());
}