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_repositories() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET).path("/_apis/git/repositories");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(seed::repositories_list());
    });

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

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

    let client = mock_client(&server);
    let repo = client.repositories().get("repo-guid-1").await.unwrap();
    assert_eq!(repo.name.as_deref(), Some("Veles"));
}

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

    let client = mock_client(&server);
    let repo = crate::repositories::models::GitRepository {
        name: Some("NewRepo".into()),
        ..Default::default()
    };
    let result = client
        .repositories()
        .create(&repo, Some("Veles"))
        .await
        .unwrap();
    assert_eq!(result.name.as_deref(), Some("Veles"));
}

#[tokio::test]
async fn delete_repository() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(httpmock::Method::DELETE)
            .path("/_apis/git/repositories/repo-guid-1");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!({}));
    });

    let client = mock_client(&server);
    let result = client.repositories().delete("repo-guid-1").await;
    assert!(result.is_ok());
}

#[tokio::test]
async fn get_commit() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET)
            .path("/_apis/git/repositories/repo-guid-1/commits/abc123");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!({
                "commitId": "abc123", "comment": "Initial commit",
                "author": { "name": "Ruslan", "email": "ruslan@example.com", "date": "2024-01-15T10:00:00Z" }
            }));
    });

    let client = mock_client(&server);
    let commit = client
        .repositories()
        .get_commit("repo-guid-1", "abc123")
        .await
        .unwrap();
    assert_eq!(commit.commit_id.as_deref(), Some("abc123"));
}

#[tokio::test]
async fn get_blob() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET)
            .path("/_apis/git/repositories/repo-guid-1/blobs/abc123");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!({
                "objectId": "abc123", "size": 1024, "url": "https://..."
            }));
    });

    let client = mock_client(&server);
    let blob = client
        .repositories()
        .get_blob("repo-guid-1", "abc123")
        .await
        .unwrap();
    assert_eq!(blob.object_id.as_deref(), Some("abc123"));
}

#[tokio::test]
async fn get_branch() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET)
            .path("/_apis/git/repositories/repo-guid-1/stats/branches")
            .query_param("name", "main");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!({
                "name": "main",
                "commit": { "commitId": "abc123", "comment": "Latest" }
            }));
    });

    let client = mock_client(&server);
    let branch = client
        .repositories()
        .get_branch("repo-guid-1", "main")
        .await
        .unwrap();
    assert_eq!(branch.name.as_deref(), Some("main"));
}

#[tokio::test]
async fn get_item() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET)
            .path("/_apis/git/repositories/repo-guid-1/items")
            .query_param("path", "/src/main.rs");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!({
                "objectId": "abc123", "gitObjectType": "blob",
                "path": "/src/main.rs", "url": "https://..."
            }));
    });

    let client = mock_client(&server);
    let opts = crate::repositories::options::ListItemsOptions::default();
    let item = client
        .repositories()
        .get_item("repo-guid-1", "/src/main.rs", &opts)
        .await
        .unwrap();
    assert_eq!(item.path.as_deref(), Some("/src/main.rs"));
}

#[tokio::test]
async fn get_push() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET)
            .path("/_apis/git/repositories/repo-guid-1/pushes/1");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!({
                "pushId": 1, "date": "2024-01-15T10:30:00Z",
                "pushCorrelationId": "corr-1"
            }));
    });

    let client = mock_client(&server);
    let push = client
        .repositories()
        .get_push("repo-guid-1", 1)
        .await
        .unwrap();
    assert_eq!(push.push_id, Some(1));
}

#[tokio::test]
async fn list_branches() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET)
            .path("/_apis/git/repositories/repo-guid-1/stats/branches");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!([{
                "name": "main",
                "commit": { "commitId": "abc123", "comment": "Latest" }
            }]));
    });

    let client = mock_client(&server);
    let branches = client
        .repositories()
        .list_branches("repo-guid-1")
        .await
        .unwrap();
    assert_eq!(branches.len(), 1);
}

#[tokio::test]
async fn list_commits() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET)
            .path("/_apis/git/repositories/repo-guid-1/commits");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!([{
                "commitId": "abc123", "comment": "Initial commit",
                "author": { "name": "Ruslan", "email": "ruslan@example.com", "date": "2024-01-15T10:00:00Z" }
            }]));
    });

    let client = mock_client(&server);
    let criteria = crate::repositories::options::CommitSearchCriteria::default();
    let commits = client
        .repositories()
        .list_commits("repo-guid-1", &criteria)
        .await
        .unwrap();
    assert_eq!(commits.len(), 1);
}

#[tokio::test]
async fn list_items() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET)
            .path("/_apis/git/repositories/repo-guid-1/items");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!([{
                "objectId": "abc123", "gitObjectType": "blob",
                "path": "/src/main.rs", "url": "https://..."
            }]));
    });

    let client = mock_client(&server);
    let opts = crate::repositories::options::ListItemsOptions::default();
    let items = client
        .repositories()
        .list_items("repo-guid-1", &opts)
        .await
        .unwrap();
    assert_eq!(items.len(), 1);
}

#[tokio::test]
async fn list_pushes() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET)
            .path("/_apis/git/repositories/repo-guid-1/pushes");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!([{
                "pushId": 1, "date": "2024-01-15T10:30:00Z",
                "pushCorrelationId": "corr-1"
            }]));
    });

    let client = mock_client(&server);
    let pushes = client
        .repositories()
        .list_pushes("repo-guid-1")
        .await
        .unwrap();
    assert_eq!(pushes.len(), 1);
}

#[tokio::test]
async fn list_refs() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET)
            .path("/_apis/git/repositories/repo-guid-1/refs");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!([{
                "name": "refs/heads/main", "objectId": "abc123"
            }]));
    });

    let client = mock_client(&server);
    let refs = client.repositories().list_refs("repo-guid-1", None).await.unwrap();
    assert_eq!(refs.len(), 1);
}

#[tokio::test]
async fn list_statuses() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(GET)
            .path("/_apis/git/repositories/repo-guid-1/commits/abc123/statuses");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!([{
                "id": 1, "state": "succeeded", "description": "Build passed",
                "context": { "name": "ci/build", "genre": "continuous-integration" }
            }]));
    });

    let client = mock_client(&server);
    let statuses = client
        .repositories()
        .list_statuses("repo-guid-1", "abc123")
        .await
        .unwrap();
    assert_eq!(statuses.len(), 1);
}

#[tokio::test]
async fn create_status() {
    let server = MockServer::start();
    let _mock = server.mock(|when, then| {
        when.method(POST)
            .path("/_apis/git/repositories/repo-guid-1/commits/abc123/statuses");
        then.status(200)
            .header(hdr::CONTENT_TYPE, ct::JSON)
            .json_body(serde_json::json!({
                "id": 1, "state": "succeeded", "description": "Build passed",
                "context": { "name": "ci/build", "genre": "continuous-integration" }
            }));
    });

    let client = mock_client(&server);
    let status = crate::repositories::models::GitStatus {
        state: Some(crate::repositories::models::GitStatusState::Succeeded),
        description: Some("Build passed".into()),
        ..Default::default()
    };
    let result = client
        .repositories()
        .create_status("repo-guid-1", "abc123", &status)
        .await
        .unwrap();
    assert_eq!(result.id, Some(1));
}