mod common;
use common::*;
use conductor::{
client::ConductorClient,
models::{
StartWorkflowRequest, TaskDef, TaskResult, TaskResultStatus, WorkflowDef, WorkflowTask,
},
};
use std::collections::HashMap;
use std::time::Duration;
#[tokio::test]
async fn test_update_task() {
let config = test_config();
let client = ConductorClient::new(config.clone()).unwrap();
let metadata = client.metadata_client();
let workflow_client = client.workflow_client();
let task_client = client.task_client();
let task_name = generate_unique_task_name("update_task");
let workflow_name = generate_unique_workflow_name("update_task_wf");
metadata
.register_task_def(&TaskDef::new(&task_name))
.await
.unwrap();
let workflow_def = WorkflowDef::new(&workflow_name)
.with_version(1)
.with_task(WorkflowTask::simple(&task_name, "task_ref"));
metadata.register_workflow_def(&workflow_def).await.unwrap();
let request = StartWorkflowRequest::new(&workflow_name).with_version(1);
let workflow_id = workflow_client.start_workflow(&request).await.unwrap();
tokio::time::sleep(Duration::from_secs(1)).await;
let workflow = workflow_client
.get_workflow(&workflow_id, true)
.await
.unwrap();
if let Some(task) = workflow.tasks.first() {
let mut output = HashMap::new();
output.insert("result".to_owned(), serde_json::json!("completed"));
let result = TaskResult::completed(&task.task_id, &workflow_id).with_output(output);
task_client.update_task(&result).await.unwrap();
tokio::time::sleep(Duration::from_secs(1)).await;
let updated_wf = workflow_client
.get_workflow(&workflow_id, false)
.await
.unwrap();
assert!(
updated_wf.is_successful()
|| updated_wf.status == conductor::models::WorkflowStatus::Running,
"Workflow should complete or be running after task update"
);
}
cleanup_workflow(&client, &workflow_id).await;
cleanup_workflow_def(&client, &workflow_name, 1).await;
cleanup_task_def(&client, &task_name).await;
}
#[tokio::test]
async fn test_update_task_by_ref_name() {
let config = test_config();
let client = ConductorClient::new(config.clone()).unwrap();
let metadata = client.metadata_client();
let workflow_client = client.workflow_client();
let task_client = client.task_client();
let task_name = generate_unique_task_name("update_ref");
let workflow_name = generate_unique_workflow_name("update_ref_wf");
metadata
.register_task_def(&TaskDef::new(&task_name))
.await
.unwrap();
let workflow_def = WorkflowDef::new(&workflow_name)
.with_version(1)
.with_task(WorkflowTask::simple(&task_name, "my_task_ref"));
metadata.register_workflow_def(&workflow_def).await.unwrap();
let request = StartWorkflowRequest::new(&workflow_name).with_version(1);
let workflow_id = workflow_client.start_workflow(&request).await.unwrap();
tokio::time::sleep(Duration::from_secs(1)).await;
let mut output = HashMap::new();
output.insert("result".to_owned(), serde_json::json!("done"));
task_client
.update_task_by_ref_name(
&workflow_id,
"my_task_ref",
TaskResultStatus::Completed,
serde_json::to_value(output).unwrap(),
None,
)
.await
.unwrap();
tokio::time::sleep(Duration::from_secs(1)).await;
let wf = workflow_client
.get_workflow(&workflow_id, false)
.await
.unwrap();
assert!(wf.is_successful() || wf.status == conductor::models::WorkflowStatus::Running);
cleanup_workflow(&client, &workflow_id).await;
cleanup_workflow_def(&client, &workflow_name, 1).await;
cleanup_task_def(&client, &task_name).await;
}
#[tokio::test]
async fn test_task_log() {
let config = test_config();
let client = ConductorClient::new(config.clone()).unwrap();
let metadata = client.metadata_client();
let workflow_client = client.workflow_client();
let task_client = client.task_client();
let task_name = generate_unique_task_name("log_task");
let workflow_name = generate_unique_workflow_name("log_task_wf");
metadata
.register_task_def(&TaskDef::new(&task_name))
.await
.unwrap();
let workflow_def = WorkflowDef::new(&workflow_name)
.with_version(1)
.with_task(WorkflowTask::simple(&task_name, "task_ref"));
metadata.register_workflow_def(&workflow_def).await.unwrap();
let request = StartWorkflowRequest::new(&workflow_name).with_version(1);
let workflow_id = workflow_client.start_workflow(&request).await.unwrap();
tokio::time::sleep(Duration::from_secs(1)).await;
let workflow = workflow_client
.get_workflow(&workflow_id, true)
.await
.unwrap();
if let Some(task) = workflow.tasks.first() {
task_client
.add_task_log(&task.task_id, "Test log message")
.await
.unwrap();
let logs = task_client.get_task_logs(&task.task_id).await.unwrap();
assert!(!logs.is_empty(), "Should have at least one log entry");
let has_message = logs.iter().any(|log| log.log.contains("Test log message"));
assert!(has_message, "Log should contain test message");
}
cleanup_workflow(&client, &workflow_id).await;
cleanup_workflow_def(&client, &workflow_name, 1).await;
cleanup_task_def(&client, &task_name).await;
}
#[tokio::test]
async fn test_get_queue_size_for_task() {
let config = test_config();
let client = ConductorClient::new(config).unwrap();
let task_client = client.task_client();
let size = task_client.get_queue_size_for_task("some_task_name").await;
size.unwrap();
}
#[tokio::test]
async fn test_get_poll_data() {
let config = test_config();
let client = ConductorClient::new(config).unwrap();
let task_client = client.task_client();
let task_name = generate_unique_task_name("poll_data");
let poll_data = task_client.get_poll_data(&task_name).await;
match poll_data {
Ok(_) => {}
Err(e) => {
eprintln!("Warning: get_poll_data returned error (may be expected for non-existent tasks): {e:?}");
}
}
}
#[tokio::test]
async fn test_get_all_poll_data() {
let config = test_config();
let client = ConductorClient::new(config).unwrap();
let task_client = client.task_client();
let all_poll_data = task_client.get_all_poll_data().await;
match all_poll_data {
Ok(_) => {}
Err(e) => {
eprintln!("Warning: get_all_poll_data returned error: {e:?}");
}
}
}
#[tokio::test]
async fn test_search_tasks() {
let config = test_config();
let client = ConductorClient::new(config).unwrap();
let task_client = client.task_client();
let result = task_client.search_tasks(None, None, 0, 10).await.unwrap();
assert!(result.total_hits >= 0);
}
#[tokio::test]
async fn test_search_v2_tasks() {
let config = test_config();
let client = ConductorClient::new(config).unwrap();
let task_client = client.task_client();
let result = task_client.search_tasks_v2(None, None, 0, 10).await;
match result {
Ok(r) => assert!(r.total_hits >= 0),
Err(e) => {
eprintln!("Warning: search_v2 returned error (may not be available): {e:?}");
}
}
}
#[tokio::test]
async fn test_batch_poll() {
let config = test_config();
let client = ConductorClient::new(config).unwrap();
let metadata = client.metadata_client();
let task_client = client.task_client();
let task_name = generate_unique_task_name("batch_poll");
metadata
.register_task_def(&TaskDef::new(&task_name))
.await
.unwrap();
let tasks = task_client
.batch_poll(
&task_name,
Some("test-worker"),
None,
5,
Duration::from_secs(1),
)
.await
.unwrap();
assert!(tasks.len() <= 5);
cleanup_task_def(&client, &task_name).await;
}
#[tokio::test]
async fn test_get_task_details() {
let config = test_config();
let client = ConductorClient::new(config.clone()).unwrap();
let metadata = client.metadata_client();
let workflow_client = client.workflow_client();
let task_client = client.task_client();
let task_name = generate_unique_task_name("task_details");
let workflow_name = generate_unique_workflow_name("task_details_wf");
metadata
.register_task_def(&TaskDef::new(&task_name))
.await
.unwrap();
let workflow_def = WorkflowDef::new(&workflow_name)
.with_version(1)
.with_task(WorkflowTask::simple(&task_name, "task_ref"));
metadata.register_workflow_def(&workflow_def).await.unwrap();
let request = StartWorkflowRequest::new(&workflow_name).with_version(1);
let workflow_id = workflow_client.start_workflow(&request).await.unwrap();
tokio::time::sleep(Duration::from_secs(1)).await;
let workflow = workflow_client
.get_workflow(&workflow_id, true)
.await
.unwrap();
if let Some(task) = workflow.tasks.first() {
let details = task_client.get_task(&task.task_id).await.unwrap();
assert_eq!(details.task_id, task.task_id);
assert_eq!(details.task_def_name, task_name);
}
cleanup_workflow(&client, &workflow_id).await;
cleanup_workflow_def(&client, &workflow_name, 1).await;
cleanup_task_def(&client, &task_name).await;
}
#[tokio::test]
async fn test_requeue_pending_tasks() {
let config = test_config();
let client = ConductorClient::new(config).unwrap();
let metadata = client.metadata_client();
let task_client = client.task_client();
let task_name = generate_unique_task_name("requeue");
metadata
.register_task_def(&TaskDef::new(&task_name))
.await
.unwrap();
let result = task_client.requeue_pending_tasks(&task_name).await;
result.unwrap();
cleanup_task_def(&client, &task_name).await;
}
#[tokio::test]
#[ignore = "Requires specific workflow setup with state updates"]
async fn test_update_task_sync() {
let config = test_config();
let client = ConductorClient::new(config).unwrap();
let _task_client = client.task_client();
}