azure-devops 0.1.0

Idiomatic Rust client for Azure DevOps REST APIs
Documentation
#[cfg(test)]
use crate::builds::models::*;
use crate::common::*;
use crate::pipelines::models::*;
use crate::projects::models::*;
use crate::pull_requests::models::*;
use crate::repositories::models::*;
use crate::work_items::models::*;

/// Helper: serialize a value to JSON, then deserialize it back and compare.
fn roundtrip<T: serde::Serialize + serde::de::DeserializeOwned + std::fmt::Debug + PartialEq>(
    val: &T,
) {
    let json = serde_json::to_string(val).expect("serialize");
    let back: T = serde_json::from_str(&json).expect("deserialize");
    assert_eq!(&back, val, "roundtrip mismatch for JSON: {json}");
}

// ─────────────────────────────────────────────────────────────────────────
// Projects
// ─────────────────────────────────────────────────────────────────────────

#[test]
fn deserialize_project_list() {
    let json = crate::test_utils::seed::project_list();
    let list: ProjectList = serde_json::from_value(json).unwrap();
    assert_eq!(list.count, 2);
    assert_eq!(list.value.len(), 2);
    assert_eq!(list.value[0].name, "Veles");
    assert_eq!(list.value[0].visibility.as_deref(), Some("private"));
}

#[test]
fn deserialize_single_project() {
    let list: Project = serde_json::from_value(crate::test_utils::seed::single_project()).unwrap();
    assert_eq!(list.name, "Veles");
    assert_eq!(list.revision, 42);
}

#[test]
fn deserialize_project_missing_optional_fields() {
    let json = serde_json::json!({
        "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
        "name": "Minimal"
    });
    let project: Project = serde_json::from_value(json).unwrap();
    assert_eq!(project.name, "Minimal");
    assert_eq!(project.description, None);
    assert_eq!(project.revision, 0);
}

#[test]
fn project_state_filter_values() {
    // Verify enum variants exist and compile
    let _filters = [
        ProjectStateFilter::WellFormed,
        ProjectStateFilter::All,
        ProjectStateFilter::CreatePending,
        ProjectStateFilter::Deleting,
        ProjectStateFilter::New,
    ];
    assert_eq!(
        ProjectStateFilter::WellFormed,
        ProjectStateFilter::WellFormed
    );
}

// ─────────────────────────────────────────────────────────────────────────
// Work Items
// ─────────────────────────────────────────────────────────────────────────

#[test]
fn deserialize_work_item() {
    let wi: WorkItem = serde_json::from_value(crate::test_utils::seed::work_item()).unwrap();
    assert_eq!(wi.id, Some(123));
    assert_eq!(wi.rev, Some(3));
    assert!(wi.fields.is_some());
    assert_eq!(wi.field_str("System.Title"), Some("Test Bug"));
    assert_eq!(wi.field_str("System.State"), Some("Active"));
    assert_eq!(wi.relations.as_ref().unwrap().len(), 1);
}

#[test]
fn deserialize_work_items_list() {
    let items: Vec<WorkItem> =
        serde_json::from_value(crate::test_utils::seed::work_items_list()).unwrap();
    assert_eq!(items.len(), 2);
    assert_eq!(items[1].id, Some(124));
}

#[test]
fn deserialize_wiql_result() {
    let result: WorkItemQueryResult =
        serde_json::from_value(crate::test_utils::seed::wiql_result()).unwrap();
    assert_eq!(result.query_type, Some(QueryType::Flat));
    let work_items = result.work_items.unwrap();
    assert_eq!(work_items.len(), 2);
    assert_eq!(work_items[0].id, Some(123));
}

#[test]
fn json_patch_operation_serialization() {
    let op = JsonPatchOperation::add("/fields/System.Title", "My Bug");
    let json = serde_json::to_value(&op).unwrap();
    assert_eq!(json["op"], "add");
    assert_eq!(json["path"], "/fields/System.Title");
    assert_eq!(json["value"], "My Bug");
    assert!(json.get("from").is_none());

    let remove_op = JsonPatchOperation::remove("/fields/System.Tags");
    let json = serde_json::to_value(&remove_op).unwrap();
    assert_eq!(json["op"], "remove");
    assert!(json.get("value").is_none());
}

#[test]
fn work_item_expand_serde() {
    roundtrip(&WorkItemExpand::All);
    roundtrip(&WorkItemExpand::None);
    roundtrip(&WorkItemExpand::Relations);

    let json = serde_json::to_string(&WorkItemExpand::All).unwrap();
    assert_eq!(json, "\"all\"");
}

#[test]
fn wiql_new() {
    let q = Wiql::new("SELECT [System.Id] FROM WorkItems");
    assert_eq!(
        q.query.as_deref(),
        Some("SELECT [System.Id] FROM WorkItems")
    );
}

// ─────────────────────────────────────────────────────────────────────────
// Repositories
// ─────────────────────────────────────────────────────────────────────────

#[test]
fn deserialize_repositories_list() {
    let repos: Vec<GitRepository> =
        serde_json::from_value(crate::test_utils::seed::repositories_list()).unwrap();
    assert_eq!(repos.len(), 1);
    assert_eq!(repos[0].name.as_deref(), Some("Veles"));
    assert_eq!(repos[0].default_branch.as_deref(), Some("refs/heads/main"));
    assert!(!repos[0].is_disabled);
}

#[test]
fn git_version_descriptor() {
    let branch = GitVersionDescriptor::branch("main");
    assert_eq!(branch.version.as_deref(), Some("main"));
    assert_eq!(branch.version_type, Some(GitVersionType::Branch));

    let commit = GitVersionDescriptor::commit("abc123");
    assert_eq!(commit.version_type, Some(GitVersionType::Commit));

    let tag = GitVersionDescriptor::tag("v1.0");
    assert_eq!(tag.version_type, Some(GitVersionType::Tag));
}

#[test]
fn git_ref_defaults() {
    let json = serde_json::json!({ "name": "refs/heads/main", "objectId": "abc123" });
    let r: GitRef = serde_json::from_value(json).unwrap();
    assert_eq!(r.name.as_deref(), Some("refs/heads/main"));
    assert!(!r.is_locked);
    assert!(r.creator.is_none());
}

// ─────────────────────────────────────────────────────────────────────────
// Pull Requests
// ─────────────────────────────────────────────────────────────────────────

#[test]
fn deserialize_pull_requests_list() {
    let prs: Vec<GitPullRequest> =
        serde_json::from_value(crate::test_utils::seed::pull_requests_list()).unwrap();
    assert_eq!(prs.len(), 1);
    assert_eq!(prs[0].title.as_deref(), Some("Add feature X"));
    assert_eq!(prs[0].status, Some(PullRequestStatus::Active));
    let reviewers = prs[0].reviewers.as_ref().unwrap();
    assert_eq!(reviewers[0].vote, 10);
}

#[test]
fn pull_request_status_serde() {
    roundtrip(&PullRequestStatus::Active);
    roundtrip(&PullRequestStatus::Completed);
    roundtrip(&PullRequestStatus::Abandoned);

    let json = serde_json::to_string(&PullRequestStatus::Active).unwrap();
    assert_eq!(json, "\"active\"");
}

// ─────────────────────────────────────────────────────────────────────────
// Builds
// ─────────────────────────────────────────────────────────────────────────

#[test]
fn deserialize_builds_list() {
    let builds: Vec<Build> =
        serde_json::from_value(crate::test_utils::seed::builds_list()).unwrap();
    assert_eq!(builds.len(), 1);
    assert_eq!(builds[0].status, Some(BuildStatus::Completed));
    assert_eq!(builds[0].result, Some(BuildResult::Succeeded));
    assert_eq!(builds[0].tags.as_ref().unwrap().len(), 1);
}

#[test]
fn deserialize_build_timeline() {
    let tl: Timeline = serde_json::from_value(crate::test_utils::seed::build_timeline()).unwrap();
    let records = tl.records.unwrap();
    assert_eq!(records.len(), 3);
    assert_eq!(records[0].name.as_deref(), Some("Build"));
}

#[test]
fn build_status_serde() {
    // camelCase enum values
    let json = serde_json::to_string(&BuildStatus::InProgress).unwrap();
    assert_eq!(json, "\"inProgress\"");
    let json = serde_json::to_string(&BuildStatus::NotStarted).unwrap();
    assert_eq!(json, "\"notStarted\"");
}

// ─────────────────────────────────────────────────────────────────────────
// Pipelines
// ─────────────────────────────────────────────────────────────────────────

#[test]
fn deserialize_pipelines_list() {
    let pipes: Vec<Pipeline> =
        serde_json::from_value(crate::test_utils::seed::pipelines_list()).unwrap();
    assert_eq!(pipes.len(), 1);
    assert_eq!(pipes[0].name.as_deref(), Some("Main CI"));
}

#[test]
fn deserialize_pipeline_runs() {
    let runs: Vec<Run> =
        serde_json::from_value(crate::test_utils::seed::pipeline_runs_list()).unwrap();
    assert_eq!(runs.len(), 1);
    assert_eq!(runs[0].result, Some(RunResult::Succeeded));
    assert_eq!(runs[0].state, Some(RunState::Completed));
}

// ─────────────────────────────────────────────────────────────────────────
// Common types
// ─────────────────────────────────────────────────────────────────────────

#[test]
fn identity_ref_defaults() {
    let json = serde_json::json!({ "displayName": "Test User", "id": "abc" });
    let id: IdentityRef = serde_json::from_value(json).unwrap();
    assert_eq!(id.display_name.as_deref(), Some("Test User"));
    assert!(!id.is_container);
    assert!(id.unique_name.is_none());
}

#[test]
fn team_project_reference_defaults() {
    let json = serde_json::json!({ "name": "Veles" });
    let p: TeamProjectReference = serde_json::from_value(json).unwrap();
    assert_eq!(p.name.as_deref(), Some("Veles"));
    assert_eq!(p.revision, 0);
    assert!(p.visibility.is_none());
}