#[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::*;
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}");
}
#[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() {
let _filters = [
ProjectStateFilter::WellFormed,
ProjectStateFilter::All,
ProjectStateFilter::CreatePending,
ProjectStateFilter::Deleting,
ProjectStateFilter::New,
];
assert_eq!(
ProjectStateFilter::WellFormed,
ProjectStateFilter::WellFormed
);
}
#[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")
);
}
#[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());
}
#[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\"");
}
#[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() {
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\"");
}
#[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));
}
#[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());
}