azure-devops 0.1.0

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

#[tokio::test]
async fn get_work_item() {
    let server = MockServer::start();
    let _mock = mock_get(&server, "/_apis/wit/workitems/123", 200, seed::work_item());

    let client = mock_client(&server);
    let wi = client.work_items().get(123).await.unwrap();
    assert_eq!(wi.id, Some(123));
    assert_eq!(wi.field_str("System.Title"), Some("Test Bug"));
}

#[tokio::test]
async fn get_work_items_batch() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/_apis/wit/workitems").query_param("ids", "123,124");
        then.status(200).header(hdr::CONTENT_TYPE, ct::JSON).json_body(seed::work_items_list());
    });

    let client = mock_client(&server);
    let items = client.work_items().get_many(&[123, 124]).await.unwrap();
    assert_eq!(items.len(), 2);
}

#[tokio::test]
async fn query_by_wiql() {
    let server = MockServer::start();
    let _mock = mock_post(&server, "/Veles/_apis/wit/wiql", 200, seed::wiql_result());

    let client = mock_client(&server);
    let query = Wiql::new("SELECT [System.Id] FROM WorkItems");
    let result = client.work_items().query_by_wiql("Veles", &query).await.unwrap();
    assert_eq!(result.work_items.unwrap().len(), 2);
}

#[tokio::test]
async fn create_work_item() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(POST)
            .path("/Veles/_apis/wit/workitems/$Bug")
            .header(hdr::CONTENT_TYPE, ct::JSON_PATCH);
        then.status(200).header(hdr::CONTENT_TYPE, ct::JSON).json_body(seed::work_item());
    });

    let client = mock_client(&server);
    let patch = vec![JsonPatchOperation::add("/fields/System.Title", "Test Bug")];
    let wi = client.work_items().create("Veles", "Bug", &patch).await.unwrap();
    assert_eq!(wi.id, Some(123));
}

#[tokio::test]
async fn update_work_item() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(PATCH)
            .path("/_apis/wit/workitems/123")
            .header(hdr::CONTENT_TYPE, ct::JSON_PATCH);
        then.status(200).header(hdr::CONTENT_TYPE, ct::JSON).json_body(seed::work_item());
    });

    let client = mock_client(&server);
    let patch = vec![JsonPatchOperation::replace("/fields/System.State", "Resolved")];
    let wi = client.work_items().update(123, &patch).await.unwrap();
    assert_eq!(wi.id, Some(123));
}

#[tokio::test]
async fn get_work_item_types() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/wit/workitemtypes");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!([
                { "name": "Bug", "referenceName": "Microsoft.VSTS.WorkItemTypes.Bug", "color": "CC293D" },
                { "name": "User Story", "referenceName": "Microsoft.VSTS.WorkItemTypes.UserStory", "color": "007ACC" }
            ])
            );
    });

    let client = mock_client(&server);
    let types = client.work_items().get_work_item_types("Veles").await.unwrap();
    assert_eq!(types.len(), 2);
    assert_eq!(types[0].name.as_deref(), Some("Bug"));
}

#[tokio::test]
async fn get_fields() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/_apis/wit/fields");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!([
                { "name": "Title", "referenceName": "System.Title", "type": "string", "readOnly": false, "canSortBy": true, "isQueryable": true }
            ])
            );
    });

    let client = mock_client(&server);
    let fields = client.work_items().get_fields().await.unwrap();
    assert_eq!(fields.len(), 1);
    assert_eq!(fields[0].reference_name.as_deref(), Some("System.Title"));
}

#[tokio::test]
async fn get_work_item_with_options() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/_apis/wit/workitems/123").query_param("fields", "System.Title");
        then.status(200).header(hdr::CONTENT_TYPE, ct::JSON).json_body(seed::work_item());
    });

    let client = mock_client(&server);
    let opts = crate::work_items::options::GetWorkItemOptions {
        fields: Some(vec!["System.Title".into()]),
        ..Default::default()
    };
    let wi = client.work_items().get_with_options(123, &opts).await.unwrap();
    assert_eq!(wi.id, Some(123));
}

#[tokio::test]
async fn get_many_work_items_with_options() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET)
            .path("/_apis/wit/workitems")
            .query_param("ids", "123,124")
            .query_param("fields", "System.Title");
        then.status(200).header(hdr::CONTENT_TYPE, ct::JSON).json_body(seed::work_items_list());
    });

    let client = mock_client(&server);
    let opts = crate::work_items::options::GetWorkItemOptions {
        fields: Some(vec!["System.Title".into()]),
        ..Default::default()
    };
    let items = client.work_items().get_many_with_options(&[123, 124], &opts).await.unwrap();
    assert_eq!(items.len(), 2);
}

#[tokio::test]
async fn create_work_item_with_options() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(POST)
            .path("/Veles/_apis/wit/workitems/$Bug")
            .header(hdr::CONTENT_TYPE, ct::JSON_PATCH);
        then.status(200).header(hdr::CONTENT_TYPE, ct::JSON).json_body(seed::work_item());
    });

    let client = mock_client(&server);
    let patch = vec![JsonPatchOperation::add("/fields/System.Title", "Test")];
    let opts = crate::work_items::options::CreateWorkItemOptions::default();
    let wi = client.work_items().create_with_options("Veles", "Bug", &patch, &opts).await.unwrap();
    assert_eq!(wi.id, Some(123));
}

#[tokio::test]
async fn update_work_item_with_options() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(PATCH)
            .path("/_apis/wit/workitems/123")
            .header(hdr::CONTENT_TYPE, ct::JSON_PATCH);
        then.status(200).header(hdr::CONTENT_TYPE, ct::JSON).json_body(seed::work_item());
    });

    let client = mock_client(&server);
    let patch = vec![JsonPatchOperation::replace("/fields/System.State", "Closed")];
    let opts = crate::work_items::options::UpdateWorkItemOptions::default();
    let wi = client.work_items().update_with_options(123, &patch, &opts).await.unwrap();
    assert_eq!(wi.id, Some(123));
}

#[tokio::test]
async fn delete_work_item() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(httpmock::Method::DELETE).path("/_apis/wit/workitems/123");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!({
                "id": 123, "code": 200, "deletedBy": "Ruslan",
                "deletedDate": "2024-01-15T10:30:00Z",
                "resource": { "id": 123, "rev": 4, "url": "..." }
            })
            );
    });

    let client = mock_client(&server);
    let result = client.work_items().delete(123).await.unwrap();
    assert_eq!(result.id, Some(123));
}

#[tokio::test]
async fn destroy_work_item() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(httpmock::Method::DELETE)
            .path("/_apis/wit/workitems/123")
            .query_param("destroy", "true");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!({
                "id": 123, "code": 200, "deletedBy": "Ruslan",
                "deletedDate": "2024-01-15T10:30:00Z",
                "resource": { "id": 123, "rev": 4, "url": "..." }
            })
            );
    });

    let client = mock_client(&server);
    let result = client.work_items().destroy(123).await.unwrap();
    assert_eq!(result.id, Some(123));
}

#[tokio::test]
async fn get_work_item_batch() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(POST).path("/_apis/wit/workitemsbatch");
        then.status(200).header(hdr::CONTENT_TYPE, ct::JSON).json_body(seed::work_items_list());
    });

    let client = mock_client(&server);
    let req = crate::work_items::models::WorkItemBatchGetRequest {
        ids: Some(vec![123, 124]),
        ..Default::default()
    };
    let items = client.work_items().get_batch(&req).await.unwrap();
    assert_eq!(items.len(), 2);
}

#[tokio::test]
async fn get_fields_for_project() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/_apis/wit/fields").query_param("project", "Veles");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!([{
                "name": "Title", "referenceName": "System.Title",
                "type": "string", "readOnly": false, "canSortBy": true, "isQueryable": true
            }])
            );
    });

    let client = mock_client(&server);
    let fields = client.work_items().get_fields_for_project("Veles").await.unwrap();
    assert_eq!(fields.len(), 1);
}

#[tokio::test]
async fn get_state_colors() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(POST).path("/_apis/wit/workitemstatescolors");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!([{
                "projectName": "Veles",
                "workItemTypeStateColors": [{
                    "workItemTypeName": "Bug",
                    "stateColors": [{ "name": "Active", "color": "007ACC" }]
                }]
            }])
            );
    });

    let client = mock_client(&server);
    let colors = client.work_items().get_state_colors(&["Veles".to_string()]).await.unwrap();
    assert_eq!(colors.len(), 1);
}

#[tokio::test]
async fn get_work_item_type() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/_apis/wit/workitemtypes/Bug");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(
                serde_json::json!({
                "name": "Bug", "referenceName": "Microsoft.VSTS.WorkItemTypes.Bug",
                "color": "CC293D"
            })
            );
    });

    let client = mock_client(&server);
    let wit = client.work_items().get_work_item_type("Veles", "Bug").await.unwrap();
    assert_eq!(wit.name.as_deref(), Some("Bug"));
}

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

    let client = mock_client(&server);
    let result = client.work_items().query_by_id("Veles", "abc-123").await.unwrap();
    assert!(result.work_items.is_some());
}

#[tokio::test]
async fn query_by_id_for_team() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/Veles/TeamA/_apis/wit/wiql/abc-123");
        then.status(200).header(hdr::CONTENT_TYPE, ct::JSON).json_body(seed::wiql_result());
    });

    let client = mock_client(&server);
    let result = client
        .work_items()
        .query_by_id_for_team("Veles", "TeamA", "abc-123").await
        .unwrap();
    assert!(result.work_items.is_some());
}

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

    let client = mock_client(&server);
    let query = Wiql::new("SELECT [System.Id] FROM WorkItems");
    let result = client
        .work_items()
        .query_by_wiql_for_team("Veles", "TeamA", &query).await
        .unwrap();
    assert!(result.work_items.is_some());
}