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::MockServer;

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

    let client = mock_client(&server);
    let builds = client
        .builds()
        .list("Veles", &crate::builds::ListBuildsOptions::default()).await
        .unwrap();
    assert_eq!(builds.len(), 1);
    assert_eq!(builds[0].build_number.as_deref(), Some("20240115.1"));
}

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

    let client = mock_client(&server);
    let build = client.builds().get("Veles", 456).await.unwrap();
    assert_eq!(build.id, Some(456));
}

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

    let client = mock_client(&server);
    let tl = client.builds().get_timeline("Veles", 456).await.unwrap();
    assert_eq!(tl.records.unwrap().len(), 3);
}

#[tokio::test]
async fn list_build_definitions() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/build/definitions");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!([{
                "id": 10, "name": "CI Pipeline", "path": "\\",
                "revision": 5, "type": "build",
                "project": { "id": "p1", "name": "Veles" }
            }])
            );
    });

    let client = mock_client(&server);
    let defs = client.builds().list_definitions("Veles", None, None).await.unwrap();
    assert_eq!(defs.len(), 1);
    assert_eq!(defs[0].name.as_deref(), Some("CI Pipeline"));
}

#[tokio::test]
async fn list_build_artifacts() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/build/builds/456/artifacts");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!([{
                "id": 1, "name": "drop",
                "resource": { "type": "Container", "data": "...", "downloadUrl": "https://..." }
            }])
            );
    });

    let client = mock_client(&server);
    let artifacts = client.builds().list_artifacts("Veles", 456).await.unwrap();
    assert_eq!(artifacts.len(), 1);
    assert_eq!(artifacts[0].name.as_deref(), Some("drop"));
}

#[tokio::test]
async fn status_badge_url() {
    let server = MockServer::start();
    let client = mock_client(&server);
    let url = client.builds().status_badge_url(10);
    assert!(url.contains("_apis/public/build/definitions/10/badge"));
}

#[tokio::test]
async fn get_build_artifact() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/build/builds/456/artifacts/drop");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!({
                "id": 1, "name": "drop",
                "resource": { "type": "Container", "data": "...", "downloadUrl": "https://..." }
            })
            );
    });

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

#[tokio::test]
async fn add_build_tag() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(httpmock::Method::PUT).path("/Veles/_apis/build/builds/456/tags/release");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!(["release", "v1.0"]));
    });

    let client = mock_client(&server);
    let tags = client.builds().add_tag("Veles", 456, "release").await.unwrap();
    assert_eq!(tags.len(), 2);
    assert!(tags.contains(&"release".to_string()));
}

#[tokio::test]
async fn get_build_latest() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/build/latest/10").query_param("branchName", "main");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(seed::builds_list().as_array().unwrap()[0].clone());
    });

    let client = mock_client(&server);
    let build = client.builds().get_latest("Veles", 10, Some("main")).await.unwrap();
    assert_eq!(build.id, Some(456));
}

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

    let client = mock_client(&server);
    let build = crate::builds::models::Build::default();
    let result = client.builds().queue("Veles", &build).await.unwrap();
    assert_eq!(result.id, Some(456));
}

#[tokio::test]
async fn get_build_definition() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/build/definitions/10");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!({
                "id": 10, "name": "CI Pipeline", "path": "\\",
                "revision": 5, "type": "build",
                "project": { "id": "p1", "name": "Veles" }
            })
            );
    });

    let client = mock_client(&server);
    let def = client.builds().get_definition("Veles", 10).await.unwrap();
    assert_eq!(def.name.as_deref(), Some("CI Pipeline"));
}

#[tokio::test]
async fn get_build_definition_metrics() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/build/definitions/10/metrics");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!([{
                "name": "SucceededBuilds", "intValue": 42
            }])
            );
    });

    let client = mock_client(&server);
    let metrics = client.builds().get_definition_metrics("Veles", 10).await.unwrap();
    assert_eq!(metrics.len(), 1);
}

#[tokio::test]
async fn get_build_definition_revisions() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/build/definitions/10/revisions");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!([{
                "revision": 1, "name": "Initial",
                "changedBy": { "displayName": "Ruslan", "id": "a1" },
                "changeType": "add"
            }])
            );
    });

    let client = mock_client(&server);
    let revs = client.builds().get_definition_revisions("Veles", 10).await.unwrap();
    assert_eq!(revs.len(), 1);
}

#[tokio::test]
async fn get_build_project_metrics() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/build/metrics/definitions");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!([{
                "name": "TotalBuilds", "intValue": 100
            }])
            );
    });

    let client = mock_client(&server);
    let metrics = client.builds().get_project_metrics("Veles").await.unwrap();
    assert_eq!(metrics.len(), 1);
}

#[tokio::test]
async fn get_build_tags() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/build/builds/456/tags");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!(["release", "v1.0"]));
    });

    let client = mock_client(&server);
    let tags = client.builds().get_tags("Veles", 456).await.unwrap();
    assert_eq!(tags.len(), 2);
}

#[tokio::test]
async fn list_build_changes() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/build/builds/456/changes");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!([{
                "id": "abc123", "message": "Fix bug",
                "type": "commit",
                "author": { "displayName": "Ruslan", "id": "a1" }
            }])
            );
    });

    let client = mock_client(&server);
    let changes = client.builds().list_changes("Veles", 456).await.unwrap();
    assert_eq!(changes.len(), 1);
}

#[tokio::test]
async fn list_build_logs() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/build/builds/456/logs");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!([{
                "id": 1, "type": "Container",
                "url": "https://dev.azure.com/ruslan/logs/1"
            }])
            );
    });

    let client = mock_client(&server);
    let logs = client.builds().list_logs("Veles", 456).await.unwrap();
    assert_eq!(logs.len(), 1);
}