use std::collections::{HashMap, HashSet, VecDeque};
use std::fmt;
use hatchet_proto::v1;
use serde_json::Value;
use super::task::Task;
use super::{
Concurrency, ConditionAction, Gates, Idempotency, Priority, RegisteredAction, StickyStrategy,
TaskDef, TaskOptions, WorkflowOptions, action_id, timeout_string, wire_name,
};
use crate::config::namespace;
use crate::{Error, Result};
mod sealed {
pub trait Sealed {}
}
pub trait Register: sealed::Sealed {
#[doc(hidden)]
fn definition(&self) -> WorkflowDef;
}
#[derive(Clone)]
#[must_use = "a declared workflow runs nothing until it is registered on a worker"]
pub struct Workflow {
name: String,
options: WorkflowOptions,
tasks: Vec<TaskDef>,
on_failure: Vec<TaskDef>,
on_success: Vec<TaskDef>,
tasks_with_standalone_options: Vec<String>,
}
impl fmt::Debug for Workflow {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Workflow")
.field("name", &self.name)
.field("tasks", &task_names(&self.tasks))
.finish_non_exhaustive()
}
}
impl fmt::Debug for WorkflowDef {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("WorkflowDef")
.field("name", &self.name)
.field("tasks", &task_names(&self.tasks))
.field("is_standalone", &self.is_standalone)
.finish_non_exhaustive()
}
}
fn task_names(tasks: &[TaskDef]) -> Vec<&str> {
tasks.iter().map(|task| task.name.as_str()).collect()
}
impl Workflow {
pub fn new(name: impl Into<String>) -> Self {
Self {
name: name.into(),
options: WorkflowOptions::default(),
tasks: Vec::new(),
on_failure: Vec::new(),
on_success: Vec::new(),
tasks_with_standalone_options: Vec::new(),
}
}
pub fn name(&self) -> &str {
&self.name
}
pub fn description(mut self, description: impl Into<String>) -> Self {
self.options.description = Some(description.into());
self
}
pub fn version(mut self, version: impl Into<String>) -> Self {
self.options.version = Some(version.into());
self
}
pub fn on_events(mut self, keys: impl IntoIterator<Item = impl Into<String>>) -> Self {
self.options
.on_events
.extend(keys.into_iter().map(Into::into));
self
}
pub fn cron(mut self, expression: impl Into<String>) -> Self {
self.options.on_crons.push(expression.into());
self
}
pub fn cron_input(mut self, input: Value) -> Self {
self.options.cron_input = Some(input);
self
}
pub fn default_priority(mut self, priority: Priority) -> Self {
self.options.default_priority = Some(priority);
self
}
pub fn concurrency(mut self, concurrency: Concurrency) -> Self {
self.options.concurrency.push(concurrency);
self
}
pub fn sticky(mut self, strategy: StickyStrategy) -> Self {
self.options.sticky = Some(strategy);
self
}
pub fn idempotency(mut self, idempotency: Idempotency) -> Self {
self.options.idempotency = Some(idempotency);
self
}
pub fn task<I, O>(mut self, task: &Task<I, O>) -> Self {
if !task.standalone.is_empty() {
self.tasks_with_standalone_options
.push(task.def.name.clone());
}
self.tasks.push(task.def.clone());
self
}
pub fn on_failure<I, O>(mut self, task: &Task<I, O>) -> Self {
if !task.standalone.is_empty() {
self.tasks_with_standalone_options
.push(task.def.name.clone());
}
self.on_failure.push(task.def.clone());
self
}
pub fn on_success<I, O>(mut self, task: &Task<I, O>) -> Self {
if !task.standalone.is_empty() {
self.tasks_with_standalone_options
.push(task.def.name.clone());
}
self.on_success.push(task.def.clone());
self
}
}
impl sealed::Sealed for Workflow {}
impl Register for Workflow {
fn definition(&self) -> WorkflowDef {
WorkflowDef {
name: self.name.clone(),
options: self.options.clone(),
tasks: self.tasks.clone(),
on_failure: self.on_failure.clone(),
on_success: self.on_success.clone(),
tasks_with_standalone_options: self.tasks_with_standalone_options.clone(),
is_standalone: false,
}
}
}
impl<I, O> sealed::Sealed for Task<I, O> {}
impl<I, O> Register for Task<I, O> {
fn definition(&self) -> WorkflowDef {
WorkflowDef {
name: self.def.name.clone(),
options: self.standalone.clone(),
tasks: vec![self.def.clone()],
on_failure: Vec::new(),
on_success: Vec::new(),
tasks_with_standalone_options: Vec::new(),
is_standalone: true,
}
}
}
#[derive(Clone)]
pub struct WorkflowDef {
name: String,
options: WorkflowOptions,
tasks: Vec<TaskDef>,
on_failure: Vec<TaskDef>,
on_success: Vec<TaskDef>,
tasks_with_standalone_options: Vec<String>,
is_standalone: bool,
}
impl WorkflowDef {
pub(crate) fn wire_name(&self, namespace: &str) -> String {
wire_name(namespace, &self.name)
}
pub(crate) fn actions(&self, namespace: &str) -> Result<Vec<(String, RegisteredAction)>> {
self.validate()?;
let workflow = self.wire_name(namespace);
Ok(self
.declared_tasks()
.map(|task| {
(
action_id(&workflow, &task.name),
RegisteredAction {
handler: task.handler.clone(),
durable: task.durable,
eviction_policy: task.options.eviction_policy.clone(),
batch: task.batch.as_ref().map(|batch| batch.handler.clone()),
},
)
})
.collect())
}
fn declared_tasks(&self) -> impl Iterator<Item = &TaskDef> {
self.tasks
.iter()
.chain(self.on_failure.iter())
.chain(self.on_success.iter())
}
pub(crate) fn has_default(&self) -> bool {
self.declared_tasks().any(|task| !task.durable)
}
pub(crate) fn has_durable(&self) -> bool {
self.declared_tasks().any(|task| task.durable)
}
pub(crate) fn to_request(&self, namespace: &str) -> Result<v1::CreateWorkflowVersionRequest> {
self.validate()?;
let workflow = self.wire_name(namespace);
let options = &self.options;
let mut tasks: Vec<v1::CreateTaskOpts> = self
.tasks
.iter()
.map(|task| task_opts(namespace, &workflow, task))
.collect();
if let Some(hook) = self.on_success.first() {
let mut opts = task_opts(namespace, &workflow, hook);
opts.parents = leaf_names(&self.tasks);
tasks.push(opts);
}
Ok(v1::CreateWorkflowVersionRequest {
tasks,
description: options.description.clone().unwrap_or_default(),
version: options.version.clone().unwrap_or_default(),
event_triggers: options
.on_events
.iter()
.map(|key| namespace::apply(namespace, key))
.collect(),
cron_triggers: options.on_crons.clone(),
cron_input: options.cron_input.as_ref().map(Value::to_string),
default_priority: options.default_priority.map(Priority::to_proto),
concurrency_arr: options
.concurrency
.iter()
.map(Concurrency::to_proto)
.collect(),
on_failure_task: self
.on_failure
.first()
.map(|task| task_opts(namespace, &workflow, task)),
sticky: options.sticky.map(StickyStrategy::to_proto),
idempotency: options.idempotency.as_ref().map(Idempotency::to_proto),
name: workflow,
..Default::default()
})
}
pub(crate) fn check_engine_features(&self, engine_version: &str) -> Result<()> {
if self.options.idempotency.is_some() {
crate::version::ensure_feature(
"idempotency",
crate::version::IDEMPOTENCY_MIN_ENGINE_VERSION,
engine_version,
)?;
}
if self.declared_tasks().any(|task| task.batch.is_some()) {
crate::version::ensure_feature(
"batch tasks",
crate::version::BATCH_MIN_ENGINE_VERSION,
engine_version,
)?;
}
Ok(())
}
fn validate(&self) -> Result<()> {
let name = &self.name;
if let Some(reason) = invalid_name_reason(name) {
return Err(Error::InvalidDeclaration(format!(
"a workflow or standalone task name `{name}` is invalid: {reason}"
)));
}
if self.tasks.is_empty() {
return Err(Error::InvalidDeclaration(format!(
"workflow `{name}` has no tasks"
)));
}
if let Some(task) = self.tasks_with_standalone_options.first() {
return Err(Error::InvalidDeclaration(format!(
"task `{task}` in workflow `{name}` sets standalone-only options \
(description, version, event or cron triggers, cron input, default \
priority, workflow concurrency, sticky, idempotency); set them on the \
workflow instead"
)));
}
let mut seen = HashSet::new();
for task in &self.tasks {
if let Some(reason) = invalid_name_reason(&task.name) {
return Err(Error::InvalidDeclaration(format!(
"task `{}` in workflow `{name}` has an invalid name: {reason}",
task.name
)));
}
if !seen.insert(task.name.to_lowercase()) {
return Err(Error::InvalidDeclaration(format!(
"workflow `{name}` has more than one task named `{}` (names are compared case-insensitively)",
task.name
)));
}
}
for (label, hooks) in [
("on_failure", &self.on_failure),
("on_success", &self.on_success),
] {
if hooks.len() > 1 {
return Err(Error::InvalidDeclaration(format!(
"workflow `{name}` declares {label} more than once; there can be only one"
)));
}
for hook in hooks {
if let Some(reason) = invalid_name_reason(&hook.name) {
return Err(Error::InvalidDeclaration(format!(
"the {label} task `{}` of workflow `{name}` has an invalid name: {reason}",
hook.name
)));
}
if !hook.parents.is_empty() {
return Err(Error::InvalidDeclaration(format!(
"the {label} task `{}` of workflow `{name}` has parents; they are set \
automatically, so it cannot declare its own",
hook.name
)));
}
if !seen.insert(hook.name.to_lowercase()) {
return Err(Error::InvalidDeclaration(format!(
"task `{}` of workflow `{name}` is used more than once (as a task, an \
on-failure task or an on-success task); names are compared \
case-insensitively",
hook.name
)));
}
for concurrency in &hook.options.concurrency {
concurrency.validate().map_err(|reason| {
Error::InvalidDeclaration(format!(
"the {label} task `{}` of workflow `{name}`: {reason}",
hook.name
))
})?;
}
for limit in &hook.options.rate_limits {
limit.validate().map_err(|reason| {
Error::InvalidDeclaration(format!(
"the {label} task `{}` of workflow `{name}`: {reason}",
hook.name
))
})?;
}
if label == "on_failure" && !conditions_are_empty(&hook.options) {
return Err(Error::InvalidDeclaration(format!(
"the on_failure task `{}` of workflow `{name}` sets wait_for, \
skip_if or cancel_if; an on-failure task runs because the \
workflow failed, and the engine is not sent conditions for it",
hook.name
)));
}
if label == "on_success" {
check_conditions(name, &hook.name, &hook.options, &leaf_names(&self.tasks))?;
}
}
}
if self.is_standalone && self.tasks.iter().any(|task| !task.parents.is_empty()) {
return Err(Error::InvalidDeclaration(
"a standalone task cannot have parents".to_string(),
));
}
let known: HashSet<&str> = self.tasks.iter().map(|task| task.name.as_str()).collect();
for task in &self.tasks {
if let Some(parent) = task
.parents
.iter()
.find(|parent| !known.contains(parent.as_str()))
{
return Err(Error::InvalidDeclaration(format!(
"task `{}` has parent `{parent}`, which is not part of workflow `{name}`",
task.name
)));
}
}
for task in &self.tasks {
if task.parents.iter().any(|parent| parent == &task.name) {
return Err(Error::InvalidDeclaration(format!(
"task `{}` in workflow `{name}` lists itself as a parent",
task.name
)));
}
}
self.check_no_cycles(name)?;
for task in self.declared_tasks() {
let Some(policy) = &task.options.eviction_policy else {
continue;
};
if !task.durable {
return Err(Error::InvalidDeclaration(format!(
"task `{}` in workflow `{name}` has an eviction policy but an ordinary \
handler; only a durable task is ever parked on the engine, so only a \
`durable_handler` can be evicted",
task.name
)));
}
if !policy.has_ttl() {
return Err(Error::InvalidDeclaration(format!(
"task `{}` in workflow `{name}` has an eviction policy with a TTL of zero, \
which never evicts on time at all; give it the time a wait may last, or \
leave the policy off",
task.name
)));
}
}
for task in self.declared_tasks() {
let Some(batch) = &task.batch else {
continue;
};
if let Some(reason) = batch.config.invalid_reason() {
return Err(Error::InvalidDeclaration(format!(
"task `{}` in workflow `{name}`: {reason}",
task.name
)));
}
if task.options.retries != 0 {
return Err(Error::InvalidDeclaration(format!(
"task `{}` in workflow `{name}` is a batch task with retries ({}); a batch \
handler runs once for a whole group of runs, so there is no single run for \
the task's retries to be about. Engines do honour the field, but both \
official SDKs force it to zero and this one refuses the declaration rather \
than quietly changing it — fail a member with a retryable `TaskError` \
instead, and the engine re-batches that member on its own",
task.name, task.options.retries
)));
}
}
for (label, hooks) in [
("on_failure", &self.on_failure),
("on_success", &self.on_success),
] {
if let Some(hook) = hooks.iter().find(|hook| hook.batch.is_some()) {
return Err(Error::InvalidDeclaration(format!(
"the {label} task `{}` of workflow `{name}` is a batch task; a hook runs \
because one particular run ended, so there is nothing to batch it with",
hook.name
)));
}
}
for concurrency in &self.options.concurrency {
concurrency.validate().map_err(|reason| {
Error::InvalidDeclaration(format!("workflow `{name}`: {reason}"))
})?;
}
if let Some(idempotency) = &self.options.idempotency {
idempotency.validate().map_err(|reason| {
Error::InvalidDeclaration(format!("workflow `{name}`: {reason}"))
})?;
}
for task in &self.tasks {
for concurrency in &task.options.concurrency {
concurrency.validate().map_err(|reason| {
Error::InvalidDeclaration(format!(
"task `{}` in workflow `{name}`: {reason}",
task.name
))
})?;
}
for limit in &task.options.rate_limits {
limit.validate().map_err(|reason| {
Error::InvalidDeclaration(format!(
"task `{}` in workflow `{name}`: {reason}",
task.name
))
})?;
}
}
for task in &self.tasks {
check_conditions(name, &task.name, &task.options, &task.parents)?;
}
Ok(())
}
fn check_no_cycles(&self, name: &str) -> Result<()> {
let mut in_degree: HashMap<&str, usize> = self
.tasks
.iter()
.map(|task| (task.name.as_str(), task.parents.len()))
.collect();
let mut children: HashMap<&str, Vec<&str>> = HashMap::new();
for task in &self.tasks {
for parent in &task.parents {
children
.entry(parent.as_str())
.or_default()
.push(task.name.as_str());
}
}
let mut queue: VecDeque<&str> = in_degree
.iter()
.filter(|&(_, °ree)| degree == 0)
.map(|(&task, _)| task)
.collect();
let mut processed = 0usize;
while let Some(task) = queue.pop_front() {
processed += 1;
if let Some(kids) = children.get(task) {
for &kid in kids {
if let Some(degree) = in_degree.get_mut(kid) {
*degree -= 1;
if *degree == 0 {
queue.push_back(kid);
}
}
}
}
}
if processed < self.tasks.len() {
let cyclic = in_degree
.iter()
.find(|&(_, °ree)| degree > 0)
.map(|(&task, _)| task)
.unwrap_or_default();
return Err(Error::InvalidDeclaration(format!(
"workflow `{name}` has a cycle among task parents, involving task `{cyclic}`"
)));
}
Ok(())
}
}
fn invalid_name_reason(name: &str) -> Option<&'static str> {
if name.trim().is_empty() {
Some("names must not be empty or whitespace-only")
} else if name.contains(':') {
Some("names must not contain `:`")
} else {
None
}
}
fn leaf_names(tasks: &[TaskDef]) -> Vec<String> {
let has_a_child: HashSet<&str> = tasks
.iter()
.flat_map(|task| task.parents.iter().map(String::as_str))
.collect();
tasks
.iter()
.filter(|task| !has_a_child.contains(task.name.as_str()))
.map(|task| task.name.clone())
.collect()
}
fn gates(options: &TaskOptions) -> Gates<'_> {
[
(ConditionAction::Queue, &options.wait_for),
(ConditionAction::Skip, &options.skip_if),
(ConditionAction::Cancel, &options.cancel_if),
]
}
fn conditions_are_empty(options: &TaskOptions) -> bool {
options.wait_for.is_empty() && options.skip_if.is_empty() && options.cancel_if.is_empty()
}
fn check_conditions(
workflow: &str,
task: &str,
options: &TaskOptions,
parents: &[String],
) -> Result<()> {
super::condition::validate(gates(options)).map_err(|reason| {
Error::InvalidDeclaration(format!("task `{task}` in workflow `{workflow}`: {reason}"))
})?;
for (_, set) in gates(options) {
for parent in set.parent_names() {
if !parents.iter().any(|declared| declared == parent) {
return Err(Error::InvalidDeclaration(format!(
"task `{task}` in workflow `{workflow}` has a condition on parent \
`{parent}`, which is not one of its parents; a parent condition reads \
that parent's output, so the task must run after it"
)));
}
}
}
Ok(())
}
fn task_opts(namespace: &str, workflow_wire_name: &str, task: &TaskDef) -> v1::CreateTaskOpts {
let options = &task.options;
v1::CreateTaskOpts {
readable_id: task.name.clone(),
action: action_id(workflow_wire_name, &task.name),
timeout: options
.execution_timeout
.map(timeout_string)
.unwrap_or_default(),
schedule_timeout: options.schedule_timeout.map(timeout_string),
inputs: "{}".to_string(),
parents: task.parents.clone(),
retries: super::options::saturating_i32(options.retries),
backoff_factor: options.backoff.map(|(factor, _)| factor),
backoff_max_seconds: options
.backoff
.map(|(_, max)| super::options::saturating_i32(max)),
rate_limits: options
.rate_limits
.iter()
.map(|limit| limit.to_proto())
.collect(),
concurrency: options
.concurrency
.iter()
.map(Concurrency::to_proto)
.collect(),
worker_labels: options
.worker_labels
.iter()
.map(|(key, label)| (key.clone(), label.to_proto()))
.collect(),
is_durable: task.durable,
slot_requests: HashMap::from([(
if task.durable { "durable" } else { "default" }.to_string(),
1,
)]),
conditions: super::condition::to_proto(namespace, gates(options)),
batch: task
.batch
.as_ref()
.map(|batch| batch.config.to_proto(batch.broadcast)),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{
Concurrency, ConcurrencyLimitStrategy, Condition, DesiredLabel, Error, Idempotency,
Priority, RateLimit, StickyStrategy, TaskBuilder,
};
use hatchet_proto::v1;
use serde_json::json;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
fn task(name: &str) -> crate::Task<serde_json::Value, serde_json::Value> {
TaskBuilder::new(name).handler(|_ctx, input| async move { Ok(input) })
}
fn default_slots() -> HashMap<String, i32> {
HashMap::from([("default".to_string(), 1)])
}
#[test]
fn debug_names_the_workflow_and_its_tasks_and_says_it_is_not_all_of_it() {
let workflow = Workflow::new("pipeline")
.task(&task("fetch"))
.task(&task("build"));
let debug = format!("{workflow:?}");
assert!(debug.starts_with("Workflow"), "{debug}");
assert!(debug.contains("pipeline"), "{debug}");
assert!(
debug.contains("fetch") && debug.contains("build"),
"{debug}"
);
assert!(debug.contains(".."), "{debug}");
let debug = format!("{:?}", workflow.definition());
assert!(debug.starts_with("WorkflowDef"), "{debug}");
assert!(debug.contains("pipeline"), "{debug}");
}
#[test]
fn standalone_task_maps_to_a_one_task_workflow() {
let agent_run = TaskBuilder::<serde_json::Value, serde_json::Value>::new("Agent-Run")
.retries(1)
.execution_timeout(Duration::from_secs(2 * 3600))
.handler(|_ctx, input| async move { Ok(input) });
let request = agent_run.definition().to_request("dev_").unwrap();
assert_eq!(
request,
v1::CreateWorkflowVersionRequest {
name: "dev_agent-run".to_string(),
tasks: vec![v1::CreateTaskOpts {
readable_id: "Agent-Run".to_string(),
action: "dev_agent-run:agent-run".to_string(),
timeout: "7200s".to_string(),
inputs: "{}".to_string(),
retries: 1,
slot_requests: default_slots(),
..Default::default()
}],
..Default::default()
}
);
}
#[test]
fn a_durable_task_registers_as_durable_and_asks_for_a_durable_slot() {
let durable = TaskBuilder::<Value, Value>::new("approve")
.durable_handler(|_ctx, input| async move { Ok(input) });
let request = durable.definition().to_request("dev_").unwrap();
let task = &request.tasks[0];
assert!(task.is_durable);
assert_eq!(
task.slot_requests,
HashMap::from([("durable".to_string(), 1)])
);
let plain = self::task("fetch").definition().to_request("dev_").unwrap();
assert!(!plain.tasks[0].is_durable);
assert_eq!(plain.tasks[0].slot_requests, default_slots());
}
#[test]
fn a_declaration_reports_which_slot_kinds_it_needs() {
let durable = TaskBuilder::<Value, Value>::new("approve")
.durable_handler(|_ctx, input| async move { Ok(input) });
let plain = task("fetch");
let only_durable = durable.definition();
assert!(only_durable.has_durable());
assert!(!only_durable.has_default());
let only_default = plain.definition();
assert!(!only_default.has_durable());
assert!(only_default.has_default());
let mixed = Workflow::new("pipeline")
.task(&plain)
.task(&durable)
.definition();
assert!(mixed.has_durable());
assert!(mixed.has_default());
let hooked = Workflow::new("hooked")
.task(&plain)
.on_failure(&durable)
.definition();
assert!(hooked.has_durable());
}
#[test]
fn without_a_namespace_names_are_only_lowercased() {
let request = task("Agent-Run").definition().to_request("").unwrap();
assert_eq!(request.name, "agent-run");
assert_eq!(request.tasks[0].action, "agent-run:agent-run");
}
#[test]
fn a_name_that_already_carries_the_namespace_is_not_prefixed_again() {
let request = task("dev_agent-run")
.definition()
.to_request("dev_")
.unwrap();
assert_eq!(request.name, "dev_agent-run");
}
#[test]
fn dag_parents_are_readable_ids() {
let fetch = task("Fetch");
let build = task("build").parent(&fetch);
let workflow = Workflow::new("Pipeline").task(&fetch).task(&build);
let request = workflow.definition().to_request("dev_").unwrap();
assert_eq!(request.name, "dev_pipeline");
assert_eq!(request.tasks.len(), 2);
assert_eq!(request.tasks[0].readable_id, "Fetch");
assert_eq!(request.tasks[0].action, "dev_pipeline:fetch");
assert!(request.tasks[0].parents.is_empty());
assert_eq!(request.tasks[1].readable_id, "build");
assert_eq!(request.tasks[1].action, "dev_pipeline:build");
assert_eq!(request.tasks[1].parents, ["Fetch"]);
}
#[test]
fn task_level_options_map_onto_create_task_opts() {
let task = TaskBuilder::<serde_json::Value, serde_json::Value>::new("agent-run")
.retries(2)
.retry_backoff(1.5, 120)
.execution_timeout(Duration::from_secs(90))
.schedule_timeout(Duration::from_secs(30))
.concurrency(
Concurrency::expr("input.device_id")
.max_runs(1)
.strategy(ConcurrencyLimitStrategy::GroupRoundRobin),
)
.rate_limit(RateLimit::new("github-api", 2))
.worker_label("os", DesiredLabel::eq("macos").required())
.worker_label("mem", DesiredLabel::gte(8).weight(50))
.handler(|_ctx, input| async move { Ok(input) });
let request = task.definition().to_request("").unwrap();
assert_eq!(
request.tasks[0],
v1::CreateTaskOpts {
readable_id: "agent-run".to_string(),
action: "agent-run:agent-run".to_string(),
timeout: "90s".to_string(),
schedule_timeout: Some("30s".to_string()),
inputs: "{}".to_string(),
retries: 2,
backoff_factor: Some(1.5),
backoff_max_seconds: Some(120),
concurrency: vec![v1::Concurrency {
expression: "input.device_id".to_string(),
max_runs: Some(1),
limit_strategy: Some(v1::ConcurrencyLimitStrategy::GroupRoundRobin as i32),
..Default::default()
}],
rate_limits: vec![v1::CreateTaskRateLimit {
key: "github-api".to_string(),
units: Some(2),
..Default::default()
}],
worker_labels: HashMap::from([
(
"os".to_string(),
v1::DesiredWorkerLabels {
str_value: Some("macos".to_string()),
required: Some(true),
comparator: Some(v1::WorkerLabelComparator::Equal as i32),
..Default::default()
},
),
(
"mem".to_string(),
v1::DesiredWorkerLabels {
int_value: Some(8),
required: Some(false),
comparator: Some(v1::WorkerLabelComparator::GreaterThanOrEqual as i32),
weight: Some(50),
..Default::default()
},
),
]),
slot_requests: default_slots(),
..Default::default()
}
);
assert!(
request.concurrency_arr.is_empty(),
"task concurrency stays on the task"
);
assert!(request.concurrency.is_none());
}
#[test]
fn workflow_options_map_onto_the_request() {
let workflow = Workflow::new("pipeline")
.description("Build and ship")
.version("v3")
.on_events(["approval.granted"])
.cron("0 * * * *")
.cron_input(json!({"repo": "hatchet-rs"}))
.default_priority(Priority::High)
.concurrency(Concurrency::expr("input.repo").max_runs(2))
.task(&task("build"));
let request = workflow.definition().to_request("dev_").unwrap();
assert_eq!(request.description, "Build and ship");
assert_eq!(request.version, "v3");
assert_eq!(
request.event_triggers,
["dev_approval.granted"],
"event keys are namespaced"
);
assert_eq!(
request.cron_triggers,
["0 * * * *"],
"cron expressions are not"
);
assert_eq!(
request.cron_input.as_deref(),
Some(r#"{"repo":"hatchet-rs"}"#)
);
assert_eq!(request.default_priority, Some(3));
assert_eq!(
request.concurrency_arr,
[v1::Concurrency {
expression: "input.repo".to_string(),
max_runs: Some(2),
..Default::default()
}]
);
assert!(
request.concurrency.is_none(),
"the singular field is never used"
);
}
#[test]
fn standalone_trigger_options_map_onto_the_request() {
let task = TaskBuilder::<serde_json::Value, serde_json::Value>::new("on-approval")
.on_events(["approval.granted"])
.cron("*/5 * * * *")
.default_priority(Priority::Low)
.handler(|_ctx, input| async move { Ok(input) });
let request = task.definition().to_request("dev_").unwrap();
assert_eq!(request.event_triggers, ["dev_approval.granted"]);
assert_eq!(request.cron_triggers, ["*/5 * * * *"]);
assert_eq!(request.default_priority, Some(1));
}
#[test]
fn duplicate_task_names_are_an_error_not_a_panic() {
let workflow = Workflow::new("pipeline")
.task(&task("build"))
.task(&task("build"));
let err = workflow.definition().to_request("").unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("build"), "{err}");
}
#[test]
fn task_names_that_collide_after_lowercasing_are_an_error() {
let workflow = Workflow::new("pipeline")
.task(&task("Build"))
.task(&task("build"));
let err = workflow.definition().to_request("").unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
}
#[test]
fn a_parent_outside_the_workflow_is_an_error_naming_it() {
let fetch = task("fetch");
let workflow = Workflow::new("pipeline").task(&task("build").parent(&fetch));
let err = workflow.definition().to_request("").unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("fetch"), "{err}");
}
#[test]
fn a_hook_task_cannot_be_a_parent_of_an_ordinary_task() {
for hook_is_on_failure in [true, false] {
let hook = task("cleanup");
let build = task("build").parent(&hook);
let workflow = Workflow::new("pipeline").task(&task("fetch")).task(&build);
let workflow = if hook_is_on_failure {
workflow.on_failure(&hook)
} else {
workflow.on_success(&hook)
};
let err = workflow.definition().to_request("").unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("cleanup"), "{err}");
}
}
#[test]
fn a_workflow_without_tasks_is_an_error() {
let err = Workflow::new("empty")
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
}
#[test]
fn empty_names_are_errors() {
assert!(task("").definition().to_request("").is_err());
assert!(
Workflow::new("")
.task(&task("a"))
.definition()
.to_request("")
.is_err()
);
}
#[test]
fn trigger_options_on_a_task_inside_a_workflow_are_an_error() {
let triggered = TaskBuilder::<serde_json::Value, serde_json::Value>::new("build")
.on_events(["push"])
.handler(|_ctx, input| async move { Ok(input) });
let err = Workflow::new("pipeline")
.task(&triggered)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("build"), "{err}");
}
#[test]
fn standalone_parents_are_an_error() {
let fetch = task("fetch");
let err = task("build")
.parent(&fetch)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
}
#[test]
fn actions_pair_each_action_id_with_its_handler() {
let fetch = task("Fetch");
let build = task("build").parent(&fetch);
let fetch_handler = fetch.def.handler.clone();
let build_handler = build.def.handler.clone();
let definition = Workflow::new("Pipeline")
.task(&fetch)
.task(&build)
.definition();
let actions = definition.actions("dev_").unwrap();
let ids: Vec<&str> = actions.iter().map(|(id, _)| id.as_str()).collect();
assert_eq!(ids, ["dev_pipeline:fetch", "dev_pipeline:build"]);
assert_eq!(definition.wire_name("dev_"), "dev_pipeline");
let fetch_action = actions
.iter()
.find(|(id, _)| id == "dev_pipeline:fetch")
.unwrap();
let build_action = actions
.iter()
.find(|(id, _)| id == "dev_pipeline:build")
.unwrap();
assert!(
Arc::ptr_eq(&fetch_action.1.handler, &fetch_handler),
"dev_pipeline:fetch should be paired with fetch's own handler"
);
assert!(
Arc::ptr_eq(&build_action.1.handler, &build_handler),
"dev_pipeline:build should be paired with build's own handler"
);
assert!(
!Arc::ptr_eq(&fetch_action.1.handler, &build_handler),
"fetch's action must not be paired with build's handler"
);
}
#[test]
fn an_eviction_policy_reaches_the_worker_and_never_the_wire() {
let plain = TaskBuilder::<serde_json::Value, serde_json::Value>::new("approve")
.durable_handler(|_ctx, input| async move { Ok(input) });
let policy = crate::EvictionPolicy::ttl(Duration::from_secs(30)).priority(-3);
let evictable = TaskBuilder::<serde_json::Value, serde_json::Value>::new("approve")
.eviction_policy(policy.clone())
.durable_handler(|_ctx, input| async move { Ok(input) });
assert_eq!(
evictable.definition().to_request("dev_").unwrap(),
plain.definition().to_request("dev_").unwrap(),
);
let actions = evictable.definition().actions("dev_").unwrap();
assert_eq!(actions[0].1.eviction_policy.as_ref(), Some(&policy));
assert!(actions[0].1.durable);
assert_eq!(
plain.definition().actions("dev_").unwrap()[0]
.1
.eviction_policy,
None,
);
}
#[test]
fn an_eviction_policy_on_an_ordinary_task_is_refused() {
let wrong = TaskBuilder::<serde_json::Value, serde_json::Value>::new("approve")
.eviction_policy(crate::EvictionPolicy::default())
.handler(|_ctx, input| async move { Ok(input) });
let err = wrong.definition().to_request("dev_").unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("durable_handler"), "{err}");
let inside = Workflow::new("pipeline").task(&wrong).definition();
assert!(
matches!(inside.actions("dev_"), Err(Error::InvalidDeclaration(_))),
"a policy on an ordinary task in a workflow is refused too",
);
let err = Workflow::new("pipeline")
.task(&task("build"))
.on_failure(&wrong)
.definition()
.to_request("dev_")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
}
#[test]
fn an_eviction_policy_with_no_ttl_at_all_is_refused() {
let never = TaskBuilder::<serde_json::Value, serde_json::Value>::new("approve")
.eviction_policy(crate::EvictionPolicy::ttl(Duration::ZERO))
.durable_handler(|_ctx, input| async move { Ok(input) });
let err = never.definition().to_request("dev_").unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("TTL"), "{err}");
TaskBuilder::<serde_json::Value, serde_json::Value>::new("approve")
.eviction_policy(crate::EvictionPolicy::ttl(Duration::from_millis(1)))
.durable_handler(|_ctx, input| async move { Ok(input) })
.definition()
.to_request("dev_")
.unwrap();
}
#[test]
fn actions_reject_what_to_request_rejects() {
let definition = Workflow::new("pipeline")
.task(&task("build"))
.task(&task("build"))
.definition();
assert!(
matches!(definition.actions(""), Err(Error::InvalidDeclaration(_))),
"actions should reject what to_request rejects"
);
assert!(matches!(
definition.to_request(""),
Err(Error::InvalidDeclaration(_))
));
}
#[test]
fn whitespace_only_names_are_invalid() {
let err = task(" ").definition().to_request("").unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
let err = Workflow::new("pipeline")
.task(&task(" "))
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("pipeline"), "{err}");
}
#[test]
fn a_colon_in_a_name_is_invalid() {
let err = Workflow::new("dev:pipeline")
.task(&task("build"))
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("dev:pipeline"), "{err}");
let err = Workflow::new("pipeline")
.task(&task("build:step"))
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("build:step"), "{err}");
}
#[test]
fn a_task_that_lists_itself_as_a_parent_is_invalid_inside_a_workflow() {
let a = task("s");
let err = Workflow::new("w")
.task(&a.clone().parent(&a))
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains('s'), "{err}");
}
#[test]
fn a_standalone_task_that_lists_itself_as_a_parent_says_standalone_tasks_cannot_have_parents() {
let a = task("s");
let err = a
.clone()
.parent(&a)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(
err.to_string()
.contains("standalone task cannot have parents"),
"{err}"
);
}
#[test]
fn a_cycle_among_task_parents_is_invalid_and_names_a_task_on_it() {
let a0 = task("a");
let b = task("b").parent(&a0);
let a = task("a").parent(&b);
let err = Workflow::new("w")
.task(&a)
.task(&b)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
let message = err.to_string();
assert!(message.contains('a') || message.contains('b'), "{message}");
}
#[test]
fn concurrency_max_runs_zero_is_invalid_at_workflow_level() {
let err = Workflow::new("pipeline")
.concurrency(Concurrency::expr("input.repo").max_runs(0))
.task(&task("build"))
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("max_runs"), "{err}");
}
#[test]
fn concurrency_max_runs_zero_is_invalid_at_task_level() {
let bad_task = TaskBuilder::<serde_json::Value, serde_json::Value>::new("build")
.concurrency(Concurrency::expr("input.repo").max_runs(0))
.handler(|_ctx, input| async move { Ok(input) });
let err = Workflow::new("pipeline")
.task(&bad_task)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("max_runs"), "{err}");
}
#[test]
fn a_dynamic_rate_limit_without_a_limit_is_an_invalid_declaration() {
let bad_task = TaskBuilder::<serde_json::Value, serde_json::Value>::new("build")
.rate_limit(RateLimit::dynamic("input.tenant"))
.handler(|_ctx, input| async move { Ok(input) });
let err = Workflow::new("pipeline")
.task(&bad_task)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("limit_expr"), "{err}");
}
#[test]
fn a_task_without_timeouts_maps_to_the_engine_defaults() {
let request = task("build").definition().to_request("").unwrap();
assert_eq!(request.tasks[0].timeout, "");
assert_eq!(request.tasks[0].schedule_timeout, None);
}
#[test]
fn task_level_concurrency_inside_a_workflow_stays_on_the_task() {
let concurrent_task = TaskBuilder::<serde_json::Value, serde_json::Value>::new("build")
.concurrency(Concurrency::expr("input.repo").max_runs(1))
.handler(|_ctx, input| async move { Ok(input) });
let request = Workflow::new("pipeline")
.task(&concurrent_task)
.definition()
.to_request("")
.unwrap();
assert_eq!(
request.tasks[0].concurrency,
[v1::Concurrency {
expression: "input.repo".to_string(),
max_runs: Some(1),
..Default::default()
}]
);
assert!(
request.concurrency_arr.is_empty(),
"task-level concurrency must not leak into the workflow-level field"
);
}
#[test]
fn an_on_failure_task_maps_to_its_own_field_and_not_to_tasks() {
let build = task("build");
let cleanup = task("cleanup");
let definition = Workflow::new("pipeline")
.task(&build)
.on_failure(&cleanup)
.definition();
let request = definition.to_request("dev_").unwrap();
assert_eq!(
task_names(&definition.tasks),
["build"],
"the on-failure task is not one of the workflow's tasks"
);
assert_eq!(request.tasks.len(), 1);
assert_eq!(request.tasks[0].readable_id, "build");
let on_failure = request
.on_failure_task
.expect("the on-failure task is sent in its own field");
assert_eq!(
on_failure,
v1::CreateTaskOpts {
readable_id: "cleanup".to_string(),
action: "dev_pipeline:cleanup".to_string(),
inputs: "{}".to_string(),
slot_requests: default_slots(),
..Default::default()
}
);
let ids: Vec<String> = definition
.actions("dev_")
.unwrap()
.into_iter()
.map(|(id, _)| id)
.collect();
assert_eq!(
ids,
["dev_pipeline:build", "dev_pipeline:cleanup"],
"the worker must register the on-failure action too"
);
}
#[test]
fn the_same_task_in_task_and_on_failure_is_an_error_not_a_panic() {
let build = task("build");
let err = Workflow::new("pipeline")
.task(&build)
.on_failure(&build)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("build"), "{err}");
}
#[test]
fn declaring_two_on_failure_tasks_is_an_error() {
let err = Workflow::new("pipeline")
.task(&task("build"))
.on_failure(&task("a"))
.on_failure(&task("b"))
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("on_failure"), "{err}");
}
#[test]
fn an_on_failure_task_with_a_parent_is_an_error() {
let build = task("build");
let err = Workflow::new("pipeline")
.task(&build)
.on_failure(&task("cleanup").parent(&build))
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("cleanup"), "{err}");
}
#[test]
fn standalone_only_options_on_an_on_failure_task_are_an_error() {
let triggered = TaskBuilder::<serde_json::Value, serde_json::Value>::new("cleanup")
.on_events(["push"])
.handler(|_ctx, input| async move { Ok(input) });
let err = Workflow::new("pipeline")
.task(&task("build"))
.on_failure(&triggered)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("cleanup"), "{err}");
}
#[test]
fn an_on_success_task_is_an_ordinary_task_parented_on_every_leaf() {
let fetch = task("fetch");
let build = task("build").parent(&fetch);
let package = task("package").parent(&build);
let lint = task("lint").parent(&fetch);
let announce = task("announce");
let request = Workflow::new("pipeline")
.task(&fetch)
.task(&build)
.task(&package)
.task(&lint)
.on_success(&announce)
.definition()
.to_request("dev_")
.unwrap();
assert_eq!(
request
.tasks
.iter()
.map(|task| task.readable_id.as_str())
.collect::<Vec<_>>(),
["fetch", "build", "package", "lint", "announce"],
"the on-success task is the last of the workflow's tasks"
);
let announce_opts = request.tasks.last().unwrap();
assert_eq!(announce_opts.action, "dev_pipeline:announce");
assert_eq!(
announce_opts.parents,
["package", "lint"],
"its parents are exactly the leaves, in declaration order"
);
assert!(request.on_failure_task.is_none());
}
#[test]
fn a_single_task_workflow_parents_its_on_success_task_on_that_task() {
let build = task("build");
let request = Workflow::new("pipeline")
.task(&build)
.on_success(&task("announce"))
.definition()
.to_request("")
.unwrap();
assert_eq!(request.tasks.last().unwrap().parents, ["build"]);
}
#[test]
fn an_on_success_task_may_not_collide_with_a_task_or_be_declared_twice() {
let build = task("build");
let err = Workflow::new("pipeline")
.task(&build)
.on_success(&build)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
let err = Workflow::new("pipeline")
.task(&task("build"))
.on_success(&task("a"))
.on_success(&task("b"))
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("on_success"), "{err}");
}
#[test]
fn on_success_and_on_failure_may_not_share_a_name() {
let err = Workflow::new("pipeline")
.task(&task("build"))
.on_failure(&task("after"))
.on_success(&task("After"))
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
}
#[test]
fn an_on_success_task_is_registered_as_an_action() {
let definition = Workflow::new("pipeline")
.task(&task("build"))
.on_failure(&task("cleanup"))
.on_success(&task("announce"))
.definition();
let ids: Vec<String> = definition
.actions("")
.unwrap()
.into_iter()
.map(|(id, _)| id)
.collect();
assert_eq!(
ids,
["pipeline:build", "pipeline:cleanup", "pipeline:announce"]
);
}
#[test]
fn workflow_concurrency_on_a_standalone_task_goes_to_the_workflow_field() {
let agent_run = TaskBuilder::<serde_json::Value, serde_json::Value>::new("agent-run")
.workflow_concurrency(Concurrency::expr("input.key").max_runs(1))
.handler(|_ctx, input| async move { Ok(input) });
let request = agent_run.definition().to_request("").unwrap();
assert_eq!(
request.concurrency_arr,
[v1::Concurrency {
expression: "input.key".to_string(),
max_runs: Some(1),
..Default::default()
}]
);
assert!(
request.tasks[0].concurrency.is_empty(),
"workflow-level concurrency must not land on the task"
);
assert!(
request.concurrency.is_none(),
"the singular field is never used"
);
}
#[test]
fn task_concurrency_on_a_standalone_task_stays_on_the_task() {
let agent_run = TaskBuilder::<serde_json::Value, serde_json::Value>::new("agent-run")
.concurrency(Concurrency::expr("input.key").max_runs(1))
.handler(|_ctx, input| async move { Ok(input) });
let request = agent_run.definition().to_request("").unwrap();
assert_eq!(request.tasks[0].concurrency.len(), 1);
assert!(request.concurrency_arr.is_empty());
}
#[test]
fn workflow_concurrency_on_a_task_inside_a_workflow_is_an_error() {
let bad = TaskBuilder::<serde_json::Value, serde_json::Value>::new("build")
.workflow_concurrency(Concurrency::expr("input.key").max_runs(1))
.handler(|_ctx, input| async move { Ok(input) });
let err = Workflow::new("pipeline")
.task(&bad)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("workflow concurrency"), "{err}");
}
#[test]
fn a_tenant_scoped_entry_without_a_name_is_rejected_at_registration() {
let err = Workflow::new("pipeline")
.concurrency(Concurrency::expr("input.tenant").tenant_scoped())
.task(&task("build"))
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("name"), "{err}");
}
#[test]
fn a_wait_for_sleep_maps_to_a_queue_sleep_condition() {
let gated = TaskBuilder::<serde_json::Value, serde_json::Value>::new("gated")
.wait_for(Condition::sleep(Duration::from_secs(30)))
.handler(|_ctx, input| async move { Ok(input) });
let request = Workflow::new("pipeline")
.task(&gated)
.definition()
.to_request("dev_")
.unwrap();
let conditions = request.tasks[0]
.conditions
.as_ref()
.expect("the task carries conditions");
assert!(conditions.user_event_conditions.is_empty());
assert!(conditions.parent_override_conditions.is_empty());
let [sleep] = conditions.sleep_conditions.as_slice() else {
panic!("one sleep condition: {conditions:?}");
};
assert_eq!(sleep.sleep_for, "30000ms");
let base = sleep.base.as_ref().unwrap();
assert_eq!(base.action, v1::Action::Queue as i32);
assert_eq!(base.readable_data_key, "sleep:30000ms");
assert_eq!(base.or_group_id.len(), 36);
}
#[test]
fn a_skip_if_parent_maps_to_a_skip_parent_override_condition() {
let a = task("a");
let b = TaskBuilder::<serde_json::Value, serde_json::Value>::new("b")
.skip_if(Condition::parent(&a).expression("output.ok == false"))
.handler(|_ctx, input| async move { Ok(input) })
.parent(&a);
let request = Workflow::new("pipeline")
.task(&a)
.task(&b)
.definition()
.to_request("dev_")
.unwrap();
let conditions = request.tasks[1].conditions.as_ref().expect("conditions");
let [parent] = conditions.parent_override_conditions.as_slice() else {
panic!("one parent condition: {conditions:?}");
};
assert_eq!(parent.parent_readable_id, "a");
let base = parent.base.as_ref().unwrap();
assert_eq!(base.action, v1::Action::Skip as i32);
assert_eq!(base.expression, "output.ok == false");
assert!(
request.tasks[0].conditions.is_none(),
"`a` has no conditions"
);
}
#[test]
fn a_cancel_if_event_is_namespaced() {
let gated = TaskBuilder::<serde_json::Value, serde_json::Value>::new("gated")
.wait_for(Condition::sleep(Duration::from_secs(60)))
.cancel_if(Condition::on_event("kill"))
.handler(|_ctx, input| async move { Ok(input) });
let request = Workflow::new("pipeline")
.task(&gated)
.definition()
.to_request("dev_")
.unwrap();
let conditions = request.tasks[0].conditions.as_ref().expect("conditions");
let [event] = conditions.user_event_conditions.as_slice() else {
panic!("one event condition: {conditions:?}");
};
assert_eq!(event.user_event_key, "dev_kill");
let base = event.base.as_ref().unwrap();
assert_eq!(base.action, v1::Action::Cancel as i32);
assert_eq!(base.readable_data_key, "kill");
}
#[test]
fn two_conditions_sharing_a_readable_key_are_an_error() {
let gated = TaskBuilder::<serde_json::Value, serde_json::Value>::new("gated")
.wait_for(Condition::on_event("go"))
.skip_if(Condition::on_event("go"))
.handler(|_ctx, input| async move { Ok(input) });
let err = Workflow::new("pipeline")
.task(&gated)
.definition()
.to_request("dev_")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("gated"), "{err}");
assert!(err.to_string().contains("readable_key"), "{err}");
}
#[test]
fn a_parent_condition_naming_a_task_that_is_not_a_parent_is_an_error() {
let a = task("a");
let b = TaskBuilder::<serde_json::Value, serde_json::Value>::new("b")
.skip_if(Condition::parent(&a).expression("output.ok"))
.handler(|_ctx, input| async move { Ok(input) });
let err = Workflow::new("pipeline")
.task(&a)
.task(&b)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("`a`"), "{err}");
assert!(err.to_string().contains("parent"), "{err}");
}
#[test]
fn a_parent_condition_whose_case_differs_from_the_parent_is_an_error() {
let a = task("a");
let b = TaskBuilder::<serde_json::Value, serde_json::Value>::new("b")
.skip_if(Condition::parent_by_name("A").expression("output.ok"))
.handler(|_ctx, input| async move { Ok(input) })
.parent(&a);
let err = Workflow::new("pipeline")
.task(&a)
.task(&b)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("`A`"), "{err}");
assert!(err.to_string().contains("parent"), "{err}");
}
#[test]
fn a_parent_condition_on_a_standalone_task_is_an_error() {
let lonely = TaskBuilder::<serde_json::Value, serde_json::Value>::new("lonely")
.wait_for(Condition::parent_by_name("nobody"))
.handler(|_ctx, input| async move { Ok(input) });
let err = lonely.definition().to_request("").unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("nobody"), "{err}");
}
#[test]
fn a_standalone_task_may_still_wait_for_a_sleep_or_an_event() {
let lonely = TaskBuilder::<serde_json::Value, serde_json::Value>::new("lonely")
.wait_for(Condition::sleep(Duration::from_secs(5)))
.cancel_if(Condition::on_event("stop"))
.handler(|_ctx, input| async move { Ok(input) });
let request = lonely.definition().to_request("dev_").unwrap();
let conditions = request.tasks[0].conditions.as_ref().expect("conditions");
assert_eq!(conditions.sleep_conditions.len(), 1);
assert_eq!(conditions.user_event_conditions.len(), 1);
}
#[test]
fn a_skip_if_event_without_a_wait_for_is_an_error() {
let gated = TaskBuilder::<serde_json::Value, serde_json::Value>::new("gated")
.skip_if(Condition::on_event("skip"))
.handler(|_ctx, input| async move { Ok(input) });
let err = Workflow::new("pipeline")
.task(&task("build"))
.task(&gated)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("gated"), "{err}");
assert!(err.to_string().contains("wait_for"), "{err}");
}
#[test]
fn conditions_on_the_on_failure_hook_are_an_error() {
let cleanup = TaskBuilder::<serde_json::Value, serde_json::Value>::new("cleanup")
.wait_for(Condition::sleep(Duration::from_secs(5)))
.handler(|_ctx, input| async move { Ok(input) });
let err = Workflow::new("pipeline")
.task(&task("build"))
.on_failure(&cleanup)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("cleanup"), "{err}");
assert!(err.to_string().contains("on_failure"), "{err}");
}
#[test]
fn the_on_success_hook_may_carry_conditions_but_only_on_a_leaf() {
let build = task("build");
let announce = TaskBuilder::<serde_json::Value, serde_json::Value>::new("announce")
.skip_if(Condition::parent(&build).expression("output.quiet == true"))
.handler(|_ctx, input| async move { Ok(input) });
let request = Workflow::new("pipeline")
.task(&build)
.on_success(&announce)
.definition()
.to_request("")
.unwrap();
let hook = request.tasks.last().expect("the on-success task is last");
assert_eq!(hook.readable_id, "announce");
assert_eq!(hook.parents, ["build"]);
assert_eq!(
hook.conditions
.as_ref()
.expect("conditions")
.parent_override_conditions[0]
.parent_readable_id,
"build"
);
let stray = TaskBuilder::<serde_json::Value, serde_json::Value>::new("announce")
.skip_if(Condition::parent_by_name("root").expression("output.x"))
.handler(|_ctx, input| async move { Ok(input) });
let root = task("root");
let leaf = task("leaf").parent(&root);
let err = Workflow::new("pipeline")
.task(&root)
.task(&leaf)
.on_success(&stray)
.definition()
.to_request("")
.unwrap_err();
assert!(matches!(err, Error::InvalidDeclaration(_)), "{err:?}");
assert!(err.to_string().contains("root"), "{err}");
}
#[test]
fn a_sticky_workflow_carries_its_strategy() {
let request = Workflow::new("pipeline")
.sticky(StickyStrategy::Hard)
.task(&task("work"))
.definition()
.to_request("dev_")
.unwrap();
assert_eq!(request.sticky, Some(v1::StickyStrategy::Hard as i32));
}
#[test]
fn a_workflow_without_sticky_leaves_the_field_unset() {
let request = Workflow::new("pipeline")
.task(&task("work"))
.definition()
.to_request("dev_")
.unwrap();
assert_eq!(request.sticky, None);
}
#[test]
fn a_standalone_task_carries_its_own_sticky_strategy() {
let solo = TaskBuilder::<(), ()>::new("solo")
.sticky(StickyStrategy::Soft)
.handler(|_ctx, _input| async { Ok(()) });
let request = solo.definition().to_request("dev_").unwrap();
assert_eq!(request.sticky, Some(v1::StickyStrategy::Soft as i32));
}
#[test]
fn sticky_on_a_task_inside_a_workflow_is_a_standalone_only_option() {
let work = TaskBuilder::<(), ()>::new("work")
.sticky(StickyStrategy::Hard)
.handler(|_ctx, _input| async { Ok(()) });
let error = Workflow::new("pipeline")
.task(&work)
.definition()
.to_request("dev_")
.unwrap_err();
assert!(matches!(error, Error::InvalidDeclaration(_)), "{error:?}");
assert!(error.to_string().contains("standalone-only"), "{error}");
}
#[test]
fn an_idempotent_workflow_carries_its_config() {
let request = Workflow::new("checkout")
.idempotency(Idempotency::until_run_ends(
"input.order_id",
Duration::from_secs(600),
))
.task(&task("charge"))
.definition()
.to_request("dev_")
.unwrap();
assert_eq!(
request.idempotency,
Some(v1::IdempotencyConfig {
expression: "input.order_id".to_string(),
ttl_ms: 600_000,
method: Some(v1::IdempotencyMethod::Status as i32),
})
);
}
#[test]
fn an_empty_idempotency_expression_is_an_invalid_declaration_not_a_panic() {
let error = Workflow::new("checkout")
.idempotency(Idempotency::ttl("", Duration::from_secs(60)))
.task(&task("charge"))
.definition()
.to_request("dev_")
.unwrap_err();
assert!(matches!(error, Error::InvalidDeclaration(_)), "{error:?}");
assert!(error.to_string().contains("checkout"), "{error}");
}
#[test]
fn a_task_added_to_a_workflow_is_still_usable_afterwards() {
let fetch = task("fetch");
let build = task("build").parent(&fetch);
let workflow = Workflow::new("pipeline").task(&fetch).task(&build);
assert_eq!(fetch.name(), "fetch");
assert_eq!(build.name(), "build");
assert_eq!(task_names(&workflow.definition().tasks), ["fetch", "build"]);
}
}