David Culbreth
13749409cd
Some checks failed
CI / Rust Blocking Checks (push) Failing after 22s
CI / Web Blocking Checks (push) Failing after 26s
CI / Security Blocking Checks (push) Successful in 9s
CI / Web Advisory Checks (push) Successful in 32s
CI / Security Advisory Checks (push) Has been cancelled
1297 lines
48 KiB
Rust
1297 lines
48 KiB
Rust
//! Workflow Context Manager
|
|
//!
|
|
//! This module manages workflow execution context, including variables,
|
|
//! template rendering, and data flow between tasks.
|
|
//!
|
|
//! ## Canonical Namespaces
|
|
//!
|
|
//! All data accessible inside `{{ }}` template expressions is organised into
|
|
//! well-defined, non-overlapping namespaces:
|
|
//!
|
|
//! | Namespace | Example | Description |
|
|
//! |-----------|---------|-------------|
|
|
//! | `parameters` | `{{ parameters.url }}` | Immutable workflow input parameters |
|
|
//! | `workflow` | `{{ workflow.counter }}` | Mutable workflow-scoped variables (set via `publish`) |
|
|
//! | `task` | `{{ task.fetch.result.data }}` | Completed task results keyed by task name |
|
|
//! | `config` | `{{ config.api_token }}` | Pack configuration values (read-only) |
|
|
//! | `keystore` | `{{ keystore.secret_key }}` | Encrypted secrets from the key store (read-only) |
|
|
//! | `item` | `{{ item }}` or `{{ item.name }}` | Current element in a `with_items` loop |
|
|
//! | `index` | `{{ index }}` | Zero-based iteration index in a `with_items` loop |
|
|
//! | `system` | `{{ system.workflow_start }}` | System-provided variables |
|
|
//!
|
|
//! ### Backward-compatible aliases
|
|
//!
|
|
//! The following aliases resolve to the same data as their canonical form and
|
|
//! are kept for backward compatibility with existing workflow definitions:
|
|
//!
|
|
//! - `vars` / `variables` → same as `workflow`
|
|
//! - `tasks` → same as `task`
|
|
//!
|
|
//! Bare variable names (e.g. `{{ my_var }}`) also resolve against the
|
|
//! `workflow` variable store as a last-resort fallback.
|
|
//!
|
|
//! ## Function-call expressions
|
|
//!
|
|
//! Templates support Orquesta-style function calls:
|
|
//! - `{{ result() }}` — the last completed task's result
|
|
//! - `{{ result().field }}` — nested access into the result
|
|
//! - `{{ succeeded() }}` — `true` if the last task succeeded
|
|
//! - `{{ failed() }}` — `true` if the last task failed
|
|
//! - `{{ timed_out() }}` — `true` if the last task timed out
|
|
//!
|
|
//! ## Type-preserving rendering
|
|
//!
|
|
//! When a JSON string value is a *pure* template expression (the entire value
|
|
//! is `{{ expr }}`), `render_json` returns the raw `JsonValue` from the
|
|
//! expression instead of stringifying it. This means `"{{ item }}"` resolving
|
|
//! to integer `5` stays as `5`, not the string `"5"`.
|
|
|
|
use attune_common::workflow::expression::{
|
|
self, is_truthy, EvalContext, EvalError, EvalResult as ExprResult,
|
|
};
|
|
use dashmap::DashMap;
|
|
use serde_json::{json, Value as JsonValue};
|
|
use std::collections::HashMap;
|
|
use std::sync::Arc;
|
|
use thiserror::Error;
|
|
|
|
/// Result type for context operations
|
|
pub type ContextResult<T> = Result<T, ContextError>;
|
|
|
|
/// Errors that can occur during context operations
|
|
#[derive(Debug, Error)]
|
|
pub enum ContextError {
|
|
#[error("Variable not found: {0}")]
|
|
VariableNotFound(String),
|
|
|
|
#[error("Invalid expression: {0}")]
|
|
InvalidExpression(String),
|
|
|
|
#[error("Type conversion error: {0}")]
|
|
TypeConversion(String),
|
|
|
|
#[error("JSON error: {0}")]
|
|
JsonError(#[from] serde_json::Error),
|
|
}
|
|
|
|
/// The status of the last completed task, used by `succeeded()` / `failed()` /
|
|
/// `timed_out()` function expressions.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum TaskOutcome {
|
|
Succeeded,
|
|
Failed,
|
|
TimedOut,
|
|
}
|
|
|
|
/// Workflow execution context
|
|
///
|
|
/// Uses Arc for shared immutable data to enable efficient cloning.
|
|
/// When cloning for with-items iterations, only Arc pointers are copied,
|
|
/// not the underlying data, making it O(1) instead of O(context_size).
|
|
#[derive(Debug, Clone)]
|
|
pub struct WorkflowContext {
|
|
/// Mutable workflow-scoped variables. Canonical namespace: `workflow`.
|
|
/// Also accessible as `vars`, `variables`, or bare names (fallback).
|
|
variables: Arc<DashMap<String, JsonValue>>,
|
|
|
|
/// Immutable workflow input parameters. Canonical namespace: `parameters`.
|
|
parameters: Arc<JsonValue>,
|
|
|
|
/// Completed task results keyed by task name. Canonical namespace: `task`.
|
|
task_results: Arc<DashMap<String, JsonValue>>,
|
|
|
|
/// System-provided variables. Canonical namespace: `system`.
|
|
system: Arc<DashMap<String, JsonValue>>,
|
|
|
|
/// Pack configuration values (read-only). Canonical namespace: `config`.
|
|
pack_config: Arc<JsonValue>,
|
|
|
|
/// Encrypted keystore values (read-only). Canonical namespace: `keystore`.
|
|
keystore: Arc<JsonValue>,
|
|
|
|
/// Current item (for with-items iteration) - per-item data
|
|
current_item: Option<JsonValue>,
|
|
|
|
/// Current item index (for with-items iteration) - per-item data
|
|
current_index: Option<usize>,
|
|
|
|
/// The result of the last completed task (for `result()` expressions)
|
|
last_task_result: Option<JsonValue>,
|
|
|
|
/// The outcome of the last completed task (for `succeeded()` / `failed()`)
|
|
last_task_outcome: Option<TaskOutcome>,
|
|
}
|
|
|
|
impl WorkflowContext {
|
|
/// Create a new workflow context.
|
|
///
|
|
/// `parameters` — the immutable input parameters for this workflow run.
|
|
/// `initial_vars` — initial workflow-scoped variables (from the workflow
|
|
/// definition's `vars` section).
|
|
pub fn new(parameters: JsonValue, initial_vars: HashMap<String, JsonValue>) -> Self {
|
|
let system = DashMap::new();
|
|
system.insert("workflow_start".to_string(), json!(chrono::Utc::now()));
|
|
|
|
let variables = DashMap::new();
|
|
for (k, v) in initial_vars {
|
|
variables.insert(k, v);
|
|
}
|
|
|
|
Self {
|
|
variables: Arc::new(variables),
|
|
parameters: Arc::new(parameters),
|
|
task_results: Arc::new(DashMap::new()),
|
|
system: Arc::new(system),
|
|
pack_config: Arc::new(JsonValue::Null),
|
|
keystore: Arc::new(JsonValue::Null),
|
|
current_item: None,
|
|
current_index: None,
|
|
last_task_result: None,
|
|
last_task_outcome: None,
|
|
}
|
|
}
|
|
|
|
/// Rebuild a workflow context from persisted workflow execution state.
|
|
///
|
|
/// This is used when advancing a workflow after a child task completes —
|
|
/// the scheduler reconstructs the context from the `workflow_execution`
|
|
/// record's stored `variables` plus the results of all completed child
|
|
/// executions.
|
|
pub fn rebuild(
|
|
parameters: JsonValue,
|
|
stored_variables: &JsonValue,
|
|
task_results: HashMap<String, JsonValue>,
|
|
) -> Self {
|
|
let variables = DashMap::new();
|
|
if let Some(obj) = stored_variables.as_object() {
|
|
for (k, v) in obj {
|
|
variables.insert(k.clone(), v.clone());
|
|
}
|
|
}
|
|
|
|
let results = DashMap::new();
|
|
for (k, v) in task_results {
|
|
results.insert(k, v);
|
|
}
|
|
|
|
let system = DashMap::new();
|
|
system.insert("workflow_start".to_string(), json!(chrono::Utc::now()));
|
|
|
|
Self {
|
|
variables: Arc::new(variables),
|
|
parameters: Arc::new(parameters),
|
|
task_results: Arc::new(results),
|
|
system: Arc::new(system),
|
|
pack_config: Arc::new(JsonValue::Null),
|
|
keystore: Arc::new(JsonValue::Null),
|
|
current_item: None,
|
|
current_index: None,
|
|
last_task_result: None,
|
|
last_task_outcome: None,
|
|
}
|
|
}
|
|
|
|
/// Set a workflow-scoped variable (accessible as `workflow.<name>`).
|
|
pub fn set_var(&mut self, name: &str, value: JsonValue) {
|
|
self.variables.insert(name.to_string(), value);
|
|
}
|
|
|
|
/// Get a workflow-scoped variable by name.
|
|
#[allow(dead_code)] // Part of complete context API; used in tests
|
|
pub fn get_var(&self, name: &str) -> Option<JsonValue> {
|
|
self.variables.get(name).map(|entry| entry.value().clone())
|
|
}
|
|
|
|
/// Store a completed task's result (accessible as `task.<name>.*`).
|
|
#[allow(dead_code)] // Part of complete context API; used in tests
|
|
pub fn set_task_result(&mut self, task_name: &str, result: JsonValue) {
|
|
self.task_results.insert(task_name.to_string(), result);
|
|
}
|
|
|
|
/// Get a task result by task name.
|
|
#[allow(dead_code)] // Part of complete context API; used in tests
|
|
pub fn get_task_result(&self, task_name: &str) -> Option<JsonValue> {
|
|
self.task_results
|
|
.get(task_name)
|
|
.map(|entry| entry.value().clone())
|
|
}
|
|
|
|
/// Set the pack configuration (accessible as `config.<key>`).
|
|
#[allow(dead_code)] // Part of complete context API; used in tests
|
|
pub fn set_pack_config(&mut self, config: JsonValue) {
|
|
self.pack_config = Arc::new(config);
|
|
}
|
|
|
|
/// Set the keystore secrets (accessible as `keystore.<key>`).
|
|
#[allow(dead_code)] // Part of complete context API; used in tests
|
|
pub fn set_keystore(&mut self, secrets: JsonValue) {
|
|
self.keystore = Arc::new(secrets);
|
|
}
|
|
|
|
/// Set current item for iteration
|
|
pub fn set_current_item(&mut self, item: JsonValue, index: usize) {
|
|
self.current_item = Some(item);
|
|
self.current_index = Some(index);
|
|
}
|
|
|
|
/// Clear current item
|
|
#[allow(dead_code)] // Part of complete context API; symmetric with set_current_item
|
|
pub fn clear_current_item(&mut self) {
|
|
self.current_item = None;
|
|
self.current_index = None;
|
|
}
|
|
|
|
/// Record the outcome of the last completed task so that `result()`,
|
|
/// `succeeded()`, `failed()`, and `timed_out()` expressions resolve
|
|
/// correctly.
|
|
pub fn set_last_task_outcome(&mut self, result: JsonValue, outcome: TaskOutcome) {
|
|
self.last_task_result = Some(result);
|
|
self.last_task_outcome = Some(outcome);
|
|
}
|
|
|
|
/// Export workflow variables as a JSON object suitable for persisting
|
|
/// back to the `workflow_execution.variables` column.
|
|
pub fn export_variables(&self) -> JsonValue {
|
|
let map: HashMap<String, JsonValue> = self
|
|
.variables
|
|
.iter()
|
|
.map(|entry| (entry.key().clone(), entry.value().clone()))
|
|
.collect();
|
|
json!(map)
|
|
}
|
|
|
|
/// Render a template string, always returning a `String`.
|
|
///
|
|
/// For type-preserving rendering of JSON values use [`render_json`].
|
|
pub fn render_template(&self, template: &str) -> ContextResult<String> {
|
|
// Simple template rendering (Jinja2-like syntax)
|
|
// Supports: {{ variable }}, {{ task.result }}, {{ parameters.key }}
|
|
|
|
let mut result = template.to_string();
|
|
|
|
// Find all template expressions
|
|
let mut start = 0;
|
|
while let Some(open_pos) = result[start..].find("{{") {
|
|
let open_pos = start + open_pos;
|
|
if let Some(close_pos) = result[open_pos..].find("}}") {
|
|
let close_pos = open_pos + close_pos;
|
|
let expr = &result[open_pos + 2..close_pos].trim();
|
|
|
|
// Evaluate expression
|
|
let value = self.evaluate_expression(expr)?;
|
|
|
|
// Replace template with value
|
|
let value_str = value_to_string(&value);
|
|
result.replace_range(open_pos..close_pos + 2, &value_str);
|
|
|
|
start = open_pos + value_str.len();
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
Ok(result)
|
|
}
|
|
|
|
/// Try to evaluate a string as a single pure template expression.
|
|
///
|
|
/// Returns `Some(JsonValue)` when the **entire** string is exactly
|
|
/// `{{ expr }}` (with optional whitespace), preserving the original
|
|
/// JSON type of the evaluated expression. Returns `None` if the
|
|
/// string contains literal text around the template or multiple
|
|
/// template expressions — in that case the caller should fall back
|
|
/// to `render_template` which always stringifies.
|
|
fn try_evaluate_pure_expression(&self, s: &str) -> Option<ContextResult<JsonValue>> {
|
|
let trimmed = s.trim();
|
|
if !trimmed.starts_with("{{") || !trimmed.ends_with("}}") {
|
|
return None;
|
|
}
|
|
|
|
// Make sure there is only ONE template expression in the string.
|
|
// Count `{{` occurrences — if more than one, it's not a pure expr.
|
|
if trimmed.matches("{{").count() != 1 {
|
|
return None;
|
|
}
|
|
|
|
let expr = trimmed[2..trimmed.len() - 2].trim();
|
|
if expr.is_empty() {
|
|
return None;
|
|
}
|
|
|
|
Some(self.evaluate_expression(expr))
|
|
}
|
|
|
|
/// Render a JSON value, recursively resolving `{{ }}` templates in
|
|
/// strings.
|
|
///
|
|
/// **Type-preserving**: when a string value is a *pure* template
|
|
/// expression (the entire string is `{{ expr }}`), the raw `JsonValue`
|
|
/// from the expression is returned. For example, if `item` is `5`
|
|
/// (a JSON number), then `"{{ item }}"` resolves to `5` not `"5"`.
|
|
pub fn render_json(&self, value: &JsonValue) -> ContextResult<JsonValue> {
|
|
match value {
|
|
JsonValue::String(s) => {
|
|
// Fast path: try as a pure expression to preserve type
|
|
if let Some(result) = self.try_evaluate_pure_expression(s) {
|
|
return result;
|
|
}
|
|
// Fallback: render as string (interpolation with surrounding text)
|
|
let rendered = self.render_template(s)?;
|
|
Ok(JsonValue::String(rendered))
|
|
}
|
|
JsonValue::Array(arr) => {
|
|
let mut result = Vec::new();
|
|
for item in arr {
|
|
result.push(self.render_json(item)?);
|
|
}
|
|
Ok(JsonValue::Array(result))
|
|
}
|
|
JsonValue::Object(obj) => {
|
|
let mut result = serde_json::Map::new();
|
|
for (key, val) in obj {
|
|
result.insert(key.clone(), self.render_json(val)?);
|
|
}
|
|
Ok(JsonValue::Object(result))
|
|
}
|
|
other => Ok(other.clone()),
|
|
}
|
|
}
|
|
|
|
/// Evaluate a template expression using the expression engine.
|
|
///
|
|
/// Supports the full expression language including arithmetic, comparison,
|
|
/// boolean logic, member access, and built-in functions. Falls back to
|
|
/// legacy dot-path resolution for simple variable references when the
|
|
/// expression engine cannot parse the input.
|
|
fn evaluate_expression(&self, expr: &str) -> ContextResult<JsonValue> {
|
|
// Use the expression engine for all expressions. It handles:
|
|
// - Dot-path access: parameters.config.port
|
|
// - Bracket access: arr[0], obj["key"]
|
|
// - Arithmetic: 2 + 3, length(items) * 2
|
|
// - Comparison: x > 5, status == "ok"
|
|
// - Boolean logic: x > 0 and x < 10
|
|
// - Function calls: length(arr), result(), succeeded()
|
|
// - Membership: "key" in obj, 5 in arr
|
|
expression::eval_expression(expr, self).map_err(|e| match e {
|
|
EvalError::VariableNotFound(name) => ContextError::VariableNotFound(name),
|
|
EvalError::TypeError(msg) => ContextError::TypeConversion(msg),
|
|
EvalError::ParseError(msg) => ContextError::InvalidExpression(msg),
|
|
other => ContextError::InvalidExpression(format!("{}", other)),
|
|
})
|
|
}
|
|
|
|
/// Evaluate a conditional expression (for 'when' clauses).
|
|
///
|
|
/// Uses the full expression engine so conditions can contain comparisons,
|
|
/// boolean operators, function calls, and arithmetic. For example:
|
|
///
|
|
/// ```text
|
|
/// succeeded()
|
|
/// result().status == "ok"
|
|
/// length(items) > 3 and "admin" in roles
|
|
/// not failed()
|
|
/// ```
|
|
pub fn evaluate_condition(&self, condition: &str) -> ContextResult<bool> {
|
|
// Try the expression engine first — it handles complex conditions
|
|
// like `result().code == 200 and succeeded()`.
|
|
match expression::eval_expression(condition, self) {
|
|
Ok(val) => Ok(is_truthy(&val)),
|
|
Err(_) => {
|
|
// Fall back to template rendering for backward compat with
|
|
// simple template conditions like `{{ succeeded() }}` (though
|
|
// bare expressions are preferred going forward).
|
|
let rendered = self.render_template(condition)?;
|
|
match rendered.trim().to_lowercase().as_str() {
|
|
"true" | "1" | "yes" => Ok(true),
|
|
"false" | "0" | "no" | "" => Ok(false),
|
|
_ => Ok(!rendered.trim().is_empty()),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Publish variables from a task result.
|
|
///
|
|
/// Each publish directive is a `(name, value)` pair where the value is
|
|
/// any JSON-compatible type. String values are treated as template
|
|
/// expressions (e.g. `"{{ result().data.items }}"`) and rendered with
|
|
/// type preservation. Non-string values (booleans, numbers, arrays,
|
|
/// objects, null) pass through `render_json` unchanged, preserving
|
|
/// their original type.
|
|
pub fn publish_from_result(
|
|
&mut self,
|
|
result: &JsonValue,
|
|
publish_vars: &[String],
|
|
publish_map: Option<&HashMap<String, JsonValue>>,
|
|
) -> ContextResult<()> {
|
|
// If publish map is provided, use it
|
|
if let Some(map) = publish_map {
|
|
for (var_name, json_value) in map {
|
|
// render_json handles all types: strings are template-rendered
|
|
// (with type preservation for pure `{{ }}` expressions), while
|
|
// booleans, numbers, arrays, objects, and null pass through
|
|
// unchanged.
|
|
let value = self.render_json(json_value)?;
|
|
self.set_var(var_name, value);
|
|
}
|
|
} else {
|
|
// Simple variable publishing - store entire result
|
|
for var_name in publish_vars {
|
|
self.set_var(var_name, result.clone());
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Export context for storage
|
|
#[allow(dead_code)] // Part of complete context API; used in tests
|
|
pub fn export(&self) -> JsonValue {
|
|
let variables: HashMap<String, JsonValue> = self
|
|
.variables
|
|
.iter()
|
|
.map(|entry| (entry.key().clone(), entry.value().clone()))
|
|
.collect();
|
|
|
|
let task_results: HashMap<String, JsonValue> = self
|
|
.task_results
|
|
.iter()
|
|
.map(|entry| (entry.key().clone(), entry.value().clone()))
|
|
.collect();
|
|
|
|
let system: HashMap<String, JsonValue> = self
|
|
.system
|
|
.iter()
|
|
.map(|entry| (entry.key().clone(), entry.value().clone()))
|
|
.collect();
|
|
|
|
json!({
|
|
"variables": variables,
|
|
"parameters": self.parameters.as_ref(),
|
|
"task_results": task_results,
|
|
"system": system,
|
|
"pack_config": self.pack_config.as_ref(),
|
|
"keystore": self.keystore.as_ref(),
|
|
})
|
|
}
|
|
|
|
/// Import context from stored data
|
|
#[allow(dead_code)] // Part of complete context API; used in tests
|
|
pub fn import(data: JsonValue) -> ContextResult<Self> {
|
|
let variables = DashMap::new();
|
|
if let Some(obj) = data["variables"].as_object() {
|
|
for (k, v) in obj {
|
|
variables.insert(k.clone(), v.clone());
|
|
}
|
|
}
|
|
|
|
let parameters = data["parameters"].clone();
|
|
|
|
let task_results = DashMap::new();
|
|
if let Some(obj) = data["task_results"].as_object() {
|
|
for (k, v) in obj {
|
|
task_results.insert(k.clone(), v.clone());
|
|
}
|
|
}
|
|
|
|
let system = DashMap::new();
|
|
if let Some(obj) = data["system"].as_object() {
|
|
for (k, v) in obj {
|
|
system.insert(k.clone(), v.clone());
|
|
}
|
|
}
|
|
|
|
let pack_config = data["pack_config"].clone();
|
|
let keystore = data["keystore"].clone();
|
|
|
|
Ok(Self {
|
|
variables: Arc::new(variables),
|
|
parameters: Arc::new(parameters),
|
|
task_results: Arc::new(task_results),
|
|
system: Arc::new(system),
|
|
pack_config: Arc::new(pack_config),
|
|
keystore: Arc::new(keystore),
|
|
current_item: None,
|
|
current_index: None,
|
|
last_task_result: None,
|
|
last_task_outcome: None,
|
|
})
|
|
}
|
|
}
|
|
|
|
/// Convert a JSON value to a string for template rendering
|
|
fn value_to_string(value: &JsonValue) -> String {
|
|
match value {
|
|
JsonValue::String(s) => s.clone(),
|
|
JsonValue::Number(n) => n.to_string(),
|
|
JsonValue::Bool(b) => b.to_string(),
|
|
JsonValue::Null => String::new(),
|
|
other => serde_json::to_string(other).unwrap_or_default(),
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// EvalContext implementation — bridges the expression engine into
|
|
// the WorkflowContext's variable resolution and workflow functions.
|
|
// ---------------------------------------------------------------
|
|
|
|
impl EvalContext for WorkflowContext {
|
|
fn resolve_variable(&self, name: &str) -> ExprResult<JsonValue> {
|
|
match name {
|
|
// ── Canonical namespaces ──────────────────────────────
|
|
"parameters" => Ok(self.parameters.as_ref().clone()),
|
|
|
|
// `workflow` is the canonical name for mutable vars.
|
|
// `vars` and `variables` are backward-compatible aliases.
|
|
"workflow" | "vars" | "variables" => {
|
|
let map: serde_json::Map<String, JsonValue> = self
|
|
.variables
|
|
.iter()
|
|
.map(|entry| (entry.key().clone(), entry.value().clone()))
|
|
.collect();
|
|
Ok(JsonValue::Object(map))
|
|
}
|
|
|
|
// `task` (alias: `tasks`) — completed task results.
|
|
"task" | "tasks" => {
|
|
let map: serde_json::Map<String, JsonValue> = self
|
|
.task_results
|
|
.iter()
|
|
.map(|entry| (entry.key().clone(), entry.value().clone()))
|
|
.collect();
|
|
Ok(JsonValue::Object(map))
|
|
}
|
|
|
|
// `config` — pack configuration (read-only).
|
|
"config" => Ok(self.pack_config.as_ref().clone()),
|
|
|
|
// `keystore` — encrypted secrets (read-only).
|
|
"keystore" => Ok(self.keystore.as_ref().clone()),
|
|
|
|
// ── Iteration context ────────────────────────────────
|
|
"item" => self
|
|
.current_item
|
|
.clone()
|
|
.ok_or_else(|| EvalError::VariableNotFound("item".to_string())),
|
|
"index" => self
|
|
.current_index
|
|
.map(|i| json!(i))
|
|
.ok_or_else(|| EvalError::VariableNotFound("index".to_string())),
|
|
|
|
// ── System variables ──────────────────────────────────
|
|
"system" => {
|
|
let map: serde_json::Map<String, JsonValue> = self
|
|
.system
|
|
.iter()
|
|
.map(|entry| (entry.key().clone(), entry.value().clone()))
|
|
.collect();
|
|
Ok(JsonValue::Object(map))
|
|
}
|
|
|
|
// ── Bare-name fallback ───────────────────────────────
|
|
// Resolve against workflow variables last so that
|
|
// `{{ my_var }}` still works as shorthand for
|
|
// `{{ workflow.my_var }}`.
|
|
_ => {
|
|
if let Some(entry) = self.variables.get(name) {
|
|
Ok(entry.value().clone())
|
|
} else {
|
|
Err(EvalError::VariableNotFound(name.to_string()))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn call_workflow_function(
|
|
&self,
|
|
name: &str,
|
|
_args: &[JsonValue],
|
|
) -> ExprResult<Option<JsonValue>> {
|
|
match name {
|
|
"succeeded" => {
|
|
let val = self
|
|
.last_task_outcome
|
|
.map(|o| o == TaskOutcome::Succeeded)
|
|
.unwrap_or(false);
|
|
Ok(Some(json!(val)))
|
|
}
|
|
"failed" => {
|
|
let val = self
|
|
.last_task_outcome
|
|
.map(|o| o == TaskOutcome::Failed)
|
|
.unwrap_or(false);
|
|
Ok(Some(json!(val)))
|
|
}
|
|
"timed_out" => {
|
|
let val = self
|
|
.last_task_outcome
|
|
.map(|o| o == TaskOutcome::TimedOut)
|
|
.unwrap_or(false);
|
|
Ok(Some(json!(val)))
|
|
}
|
|
"result" => {
|
|
let base = self.last_task_result.clone().unwrap_or(JsonValue::Null);
|
|
Ok(Some(base))
|
|
}
|
|
_ => Ok(None),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
// ---------------------------------------------------------------
|
|
// parameters namespace
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_basic_template_rendering() {
|
|
let params = json!({
|
|
"name": "World"
|
|
});
|
|
let ctx = WorkflowContext::new(params, HashMap::new());
|
|
|
|
let result = ctx.render_template("Hello {{ parameters.name }}!").unwrap();
|
|
assert_eq!(result, "Hello World!");
|
|
}
|
|
|
|
#[test]
|
|
fn test_nested_value_access() {
|
|
let params = json!({
|
|
"config": {
|
|
"server": {
|
|
"port": 8080
|
|
}
|
|
}
|
|
});
|
|
let ctx = WorkflowContext::new(params, HashMap::new());
|
|
|
|
let result = ctx
|
|
.render_template("Port: {{ parameters.config.server.port }}")
|
|
.unwrap();
|
|
assert_eq!(result, "Port: 8080");
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// workflow namespace (canonical) + vars/variables aliases
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_workflow_namespace_canonical() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_var("greeting", json!("Hello"));
|
|
|
|
// Canonical: workflow.<name>
|
|
let result = ctx
|
|
.render_template("{{ workflow.greeting }} World")
|
|
.unwrap();
|
|
assert_eq!(result, "Hello World");
|
|
}
|
|
|
|
#[test]
|
|
fn test_workflow_namespace_vars_alias() {
|
|
let mut vars = HashMap::new();
|
|
vars.insert("greeting".to_string(), json!("Hello"));
|
|
let ctx = WorkflowContext::new(json!({}), vars);
|
|
|
|
// Backward-compat alias: vars.<name>
|
|
let result = ctx.render_template("{{ vars.greeting }} World").unwrap();
|
|
assert_eq!(result, "Hello World");
|
|
}
|
|
|
|
#[test]
|
|
fn test_workflow_namespace_variables_alias() {
|
|
let mut vars = HashMap::new();
|
|
vars.insert("greeting".to_string(), json!("Hello"));
|
|
let ctx = WorkflowContext::new(json!({}), vars);
|
|
|
|
// Backward-compat alias: variables.<name>
|
|
let result = ctx
|
|
.render_template("{{ variables.greeting }} World")
|
|
.unwrap();
|
|
assert_eq!(result, "Hello World");
|
|
}
|
|
|
|
#[test]
|
|
fn test_variable_access_bare_name_fallback() {
|
|
let mut vars = HashMap::new();
|
|
vars.insert("greeting".to_string(), json!("Hello"));
|
|
|
|
let ctx = WorkflowContext::new(json!({}), vars);
|
|
|
|
// Bare name falls back to workflow variables
|
|
let result = ctx.render_template("{{ greeting }} World").unwrap();
|
|
assert_eq!(result, "Hello World");
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// task namespace
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_task_result_access() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_task_result("task1", json!({"status": "success"}));
|
|
|
|
let result = ctx
|
|
.render_template("Status: {{ task.task1.status }}")
|
|
.unwrap();
|
|
assert_eq!(result, "Status: success");
|
|
}
|
|
|
|
#[test]
|
|
fn test_task_result_deep_access() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_task_result("fetch", json!({"result": {"data": {"id": 42}}}));
|
|
|
|
let val = ctx
|
|
.evaluate_expression("task.fetch.result.data.id")
|
|
.unwrap();
|
|
assert_eq!(val, json!(42));
|
|
}
|
|
|
|
#[test]
|
|
fn test_task_result_stdout() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_task_result("run_cmd", json!({"result": {"stdout": "hello world"}}));
|
|
|
|
let val = ctx
|
|
.evaluate_expression("task.run_cmd.result.stdout")
|
|
.unwrap();
|
|
assert_eq!(val, json!("hello world"));
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// config namespace (pack configuration)
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_config_namespace() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_pack_config(
|
|
json!({"api_token": "tok_abc123", "base_url": "https://api.example.com"}),
|
|
);
|
|
|
|
let val = ctx.evaluate_expression("config.api_token").unwrap();
|
|
assert_eq!(val, json!("tok_abc123"));
|
|
|
|
let result = ctx.render_template("URL: {{ config.base_url }}").unwrap();
|
|
assert_eq!(result, "URL: https://api.example.com");
|
|
}
|
|
|
|
#[test]
|
|
fn test_config_namespace_nested() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_pack_config(json!({"slack": {"webhook_url": "https://hooks.slack.com/xxx"}}));
|
|
|
|
let val = ctx.evaluate_expression("config.slack.webhook_url").unwrap();
|
|
assert_eq!(val, json!("https://hooks.slack.com/xxx"));
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// keystore namespace (encrypted secrets)
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_keystore_namespace() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_keystore(json!({"secret_key": "s3cr3t", "db_password": "hunter2"}));
|
|
|
|
let val = ctx.evaluate_expression("keystore.secret_key").unwrap();
|
|
assert_eq!(val, json!("s3cr3t"));
|
|
|
|
let val = ctx.evaluate_expression("keystore.db_password").unwrap();
|
|
assert_eq!(val, json!("hunter2"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_keystore_bracket_access() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_keystore(json!({"My Secret Key": "value123"}));
|
|
|
|
let val = ctx
|
|
.evaluate_expression("keystore[\"My Secret Key\"]")
|
|
.unwrap();
|
|
assert_eq!(val, json!("value123"));
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// item / index (with_items iteration)
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_item_context() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_current_item(json!({"name": "item1"}), 0);
|
|
|
|
let result = ctx
|
|
.render_template("Item: {{ item.name }}, Index: {{ index }}")
|
|
.unwrap();
|
|
assert_eq!(result, "Item: item1, Index: 0");
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// Condition evaluation
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_condition_evaluation() {
|
|
let params = json!({"enabled": true});
|
|
let ctx = WorkflowContext::new(params, HashMap::new());
|
|
|
|
assert!(ctx.evaluate_condition("true").unwrap());
|
|
assert!(!ctx.evaluate_condition("false").unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_condition_with_comparison() {
|
|
let ctx = WorkflowContext::new(json!({"count": 10}), HashMap::new());
|
|
assert!(ctx.evaluate_condition("parameters.count > 5").unwrap());
|
|
assert!(!ctx.evaluate_condition("parameters.count < 5").unwrap());
|
|
assert!(ctx.evaluate_condition("parameters.count == 10").unwrap());
|
|
assert!(ctx.evaluate_condition("parameters.count >= 10").unwrap());
|
|
assert!(ctx.evaluate_condition("parameters.count != 99").unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_condition_with_boolean_operators() {
|
|
let ctx = WorkflowContext::new(json!({"x": 10, "y": 20}), HashMap::new());
|
|
assert!(ctx
|
|
.evaluate_condition("parameters.x > 5 and parameters.y > 15")
|
|
.unwrap());
|
|
assert!(!ctx
|
|
.evaluate_condition("parameters.x > 5 and parameters.y > 25")
|
|
.unwrap());
|
|
assert!(ctx
|
|
.evaluate_condition("parameters.x > 50 or parameters.y > 15")
|
|
.unwrap());
|
|
assert!(ctx.evaluate_condition("not parameters.x > 50").unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_condition_with_in_operator() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_var("roles", json!(["admin", "user"]));
|
|
// Via bare-name fallback
|
|
assert!(ctx.evaluate_condition("\"admin\" in roles").unwrap());
|
|
assert!(!ctx.evaluate_condition("\"root\" in roles").unwrap());
|
|
// Via canonical workflow namespace
|
|
assert!(ctx
|
|
.evaluate_condition("\"admin\" in workflow.roles")
|
|
.unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_condition_with_function_calls() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_last_task_outcome(json!({"status": "ok", "code": 200}), TaskOutcome::Succeeded);
|
|
assert!(ctx.evaluate_condition("succeeded()").unwrap());
|
|
assert!(!ctx.evaluate_condition("failed()").unwrap());
|
|
assert!(ctx
|
|
.evaluate_condition("succeeded() and result().code == 200")
|
|
.unwrap());
|
|
assert!(!ctx
|
|
.evaluate_condition("succeeded() and result().code == 404")
|
|
.unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_condition_with_length() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_var("items", json!([1, 2, 3, 4, 5]));
|
|
assert!(ctx.evaluate_condition("length(items) > 3").unwrap());
|
|
assert!(!ctx.evaluate_condition("length(items) > 10").unwrap());
|
|
assert!(ctx.evaluate_condition("length(items) == 5").unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_condition_with_config() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_pack_config(json!({"retries": 3}));
|
|
assert!(ctx.evaluate_condition("config.retries > 0").unwrap());
|
|
assert!(ctx.evaluate_condition("config.retries == 3").unwrap());
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// Expression engine in templates
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_expression_arithmetic() {
|
|
let ctx = WorkflowContext::new(json!({"x": 10}), HashMap::new());
|
|
let input = json!({"result": "{{ parameters.x + 5 }}"});
|
|
let result = ctx.render_json(&input).unwrap();
|
|
assert_eq!(result["result"], json!(15));
|
|
}
|
|
|
|
#[test]
|
|
fn test_expression_string_concat() {
|
|
let ctx =
|
|
WorkflowContext::new(json!({"first": "Hello", "second": "World"}), HashMap::new());
|
|
let input = json!({"msg": "{{ parameters.first + \" \" + parameters.second }}"});
|
|
let result = ctx.render_json(&input).unwrap();
|
|
assert_eq!(result["msg"], json!("Hello World"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_expression_nested_functions() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_var("data", json!("a,b,c"));
|
|
let input = json!({"count": "{{ length(split(data, \",\")) }}"});
|
|
let result = ctx.render_json(&input).unwrap();
|
|
assert_eq!(result["count"], json!(3));
|
|
}
|
|
|
|
#[test]
|
|
fn test_expression_bracket_access() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_var("arr", json!([10, 20, 30]));
|
|
let input = json!({"second": "{{ arr[1] }}"});
|
|
let result = ctx.render_json(&input).unwrap();
|
|
assert_eq!(result["second"], json!(20));
|
|
}
|
|
|
|
#[test]
|
|
fn test_expression_type_conversion() {
|
|
let ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
let input = json!({"val": "{{ int(3.9) }}"});
|
|
let result = ctx.render_json(&input).unwrap();
|
|
assert_eq!(result["val"], json!(3));
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// render_json type-preserving behaviour
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_render_json() {
|
|
let params = json!({"name": "test"});
|
|
let ctx = WorkflowContext::new(params, HashMap::new());
|
|
|
|
let input = json!({
|
|
"message": "Hello {{ parameters.name }}",
|
|
"count": 42,
|
|
"nested": {
|
|
"value": "Name is {{ parameters.name }}"
|
|
}
|
|
});
|
|
|
|
let result = ctx.render_json(&input).unwrap();
|
|
assert_eq!(result["message"], "Hello test");
|
|
assert_eq!(result["count"], 42);
|
|
assert_eq!(result["nested"]["value"], "Name is test");
|
|
}
|
|
|
|
#[test]
|
|
fn test_render_json_type_preserving_number() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_current_item(json!(5), 0);
|
|
|
|
// Pure expression — should preserve the integer type
|
|
let input = json!({"seconds": "{{ item }}"});
|
|
let result = ctx.render_json(&input).unwrap();
|
|
assert_eq!(result["seconds"], json!(5));
|
|
assert!(result["seconds"].is_number());
|
|
}
|
|
|
|
#[test]
|
|
fn test_render_json_type_preserving_array() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_last_task_outcome(
|
|
json!({"data": {"items": [0, 1, 2, 3, 4]}}),
|
|
TaskOutcome::Succeeded,
|
|
);
|
|
|
|
// Pure expression into result() — should preserve the array type
|
|
let input = json!({"list": "{{ result().data.items }}"});
|
|
let result = ctx.render_json(&input).unwrap();
|
|
assert_eq!(result["list"], json!([0, 1, 2, 3, 4]));
|
|
assert!(result["list"].is_array());
|
|
}
|
|
|
|
#[test]
|
|
fn test_render_json_mixed_template_stays_string() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_current_item(json!(5), 0);
|
|
|
|
// Mixed text + template — must remain a string
|
|
let input = json!({"msg": "Sleeping for {{ item }} seconds"});
|
|
let result = ctx.render_json(&input).unwrap();
|
|
assert_eq!(result["msg"], json!("Sleeping for 5 seconds"));
|
|
assert!(result["msg"].is_string());
|
|
}
|
|
|
|
#[test]
|
|
fn test_render_json_type_preserving_bool() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_last_task_outcome(json!({}), TaskOutcome::Succeeded);
|
|
|
|
let input = json!({"ok": "{{ succeeded() }}"});
|
|
let result = ctx.render_json(&input).unwrap();
|
|
assert_eq!(result["ok"], json!(true));
|
|
assert!(result["ok"].is_boolean());
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// result() / succeeded() / failed() / timed_out()
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_result_function() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_last_task_outcome(
|
|
json!({"data": {"items": [10, 20]}, "stdout": "hello"}),
|
|
TaskOutcome::Succeeded,
|
|
);
|
|
|
|
// result() returns the full last task result
|
|
let val = ctx.evaluate_expression("result()").unwrap();
|
|
assert_eq!(val["data"]["items"], json!([10, 20]));
|
|
|
|
// result().stdout returns nested field
|
|
let val = ctx.evaluate_expression("result().stdout").unwrap();
|
|
assert_eq!(val, json!("hello"));
|
|
|
|
// result().data.items returns deeper nested field
|
|
let val = ctx.evaluate_expression("result().data.items").unwrap();
|
|
assert_eq!(val, json!([10, 20]));
|
|
}
|
|
|
|
#[test]
|
|
fn test_succeeded_failed_functions() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_last_task_outcome(json!({}), TaskOutcome::Succeeded);
|
|
|
|
assert_eq!(ctx.evaluate_expression("succeeded()").unwrap(), json!(true));
|
|
assert_eq!(ctx.evaluate_expression("failed()").unwrap(), json!(false));
|
|
assert_eq!(
|
|
ctx.evaluate_expression("timed_out()").unwrap(),
|
|
json!(false)
|
|
);
|
|
|
|
ctx.set_last_task_outcome(json!({}), TaskOutcome::Failed);
|
|
assert_eq!(
|
|
ctx.evaluate_expression("succeeded()").unwrap(),
|
|
json!(false)
|
|
);
|
|
assert_eq!(ctx.evaluate_expression("failed()").unwrap(), json!(true));
|
|
|
|
ctx.set_last_task_outcome(json!({}), TaskOutcome::TimedOut);
|
|
assert_eq!(ctx.evaluate_expression("timed_out()").unwrap(), json!(true));
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// Publish
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_publish_with_result_function() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_last_task_outcome(
|
|
json!({"data": {"items": [0, 1, 2]}}),
|
|
TaskOutcome::Succeeded,
|
|
);
|
|
|
|
let mut publish_map = HashMap::new();
|
|
publish_map.insert(
|
|
"number_list".to_string(),
|
|
JsonValue::String("{{ result().data.items }}".to_string()),
|
|
);
|
|
|
|
ctx.publish_from_result(&json!({}), &[], Some(&publish_map))
|
|
.unwrap();
|
|
|
|
let val = ctx.get_var("number_list").unwrap();
|
|
assert_eq!(val, json!([0, 1, 2]));
|
|
assert!(val.is_array());
|
|
}
|
|
|
|
#[test]
|
|
fn test_publish_variables() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
let result = json!({"output": "success"});
|
|
|
|
ctx.publish_from_result(&result, &["my_var".to_string()], None)
|
|
.unwrap();
|
|
|
|
assert_eq!(ctx.get_var("my_var").unwrap(), result);
|
|
}
|
|
|
|
#[test]
|
|
fn test_publish_typed_values() {
|
|
// Non-string publish values (booleans, numbers, null) should pass
|
|
// through render_json unchanged and be stored with their original type.
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_last_task_outcome(json!({"status": "ok"}), TaskOutcome::Succeeded);
|
|
|
|
let mut publish_map = HashMap::new();
|
|
publish_map.insert("flag".to_string(), JsonValue::Bool(true));
|
|
publish_map.insert("count".to_string(), json!(42));
|
|
publish_map.insert("ratio".to_string(), json!(3.15));
|
|
publish_map.insert("nothing".to_string(), JsonValue::Null);
|
|
publish_map.insert(
|
|
"template".to_string(),
|
|
JsonValue::String("{{ result().status }}".to_string()),
|
|
);
|
|
publish_map.insert(
|
|
"plain_str".to_string(),
|
|
JsonValue::String("hello".to_string()),
|
|
);
|
|
|
|
ctx.publish_from_result(&json!({}), &[], Some(&publish_map))
|
|
.unwrap();
|
|
|
|
// Boolean preserved as boolean (not string "true")
|
|
assert_eq!(ctx.get_var("flag").unwrap(), json!(true));
|
|
assert!(ctx.get_var("flag").unwrap().is_boolean());
|
|
|
|
// Integer preserved
|
|
assert_eq!(ctx.get_var("count").unwrap(), json!(42));
|
|
assert!(ctx.get_var("count").unwrap().is_number());
|
|
|
|
// Float preserved
|
|
assert_eq!(ctx.get_var("ratio").unwrap(), json!(3.15));
|
|
|
|
// Null preserved
|
|
assert_eq!(ctx.get_var("nothing").unwrap(), json!(null));
|
|
assert!(ctx.get_var("nothing").unwrap().is_null());
|
|
|
|
// Template expression rendered with type preservation
|
|
assert_eq!(ctx.get_var("template").unwrap(), json!("ok"));
|
|
|
|
// Plain string stays as string
|
|
assert_eq!(ctx.get_var("plain_str").unwrap(), json!("hello"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_published_var_accessible_via_workflow_namespace() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_var("counter", json!(42));
|
|
|
|
// Via canonical namespace
|
|
let val = ctx.evaluate_expression("workflow.counter").unwrap();
|
|
assert_eq!(val, json!(42));
|
|
|
|
// Via backward-compat alias
|
|
let val = ctx.evaluate_expression("vars.counter").unwrap();
|
|
assert_eq!(val, json!(42));
|
|
|
|
// Via bare-name fallback
|
|
let val = ctx.evaluate_expression("counter").unwrap();
|
|
assert_eq!(val, json!(42));
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// Rebuild / Export / Import round-trip
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_rebuild_context() {
|
|
let stored_vars = json!({"number_list": [0, 1, 2]});
|
|
let mut task_results = HashMap::new();
|
|
task_results.insert("task1".to_string(), json!({"data": {"items": [0, 1, 2]}}));
|
|
|
|
let ctx = WorkflowContext::rebuild(json!({"count": 5}), &stored_vars, task_results);
|
|
|
|
assert_eq!(ctx.get_var("number_list").unwrap(), json!([0, 1, 2]));
|
|
assert_eq!(
|
|
ctx.get_task_result("task1").unwrap(),
|
|
json!({"data": {"items": [0, 1, 2]}})
|
|
);
|
|
let rendered = ctx.render_template("{{ parameters.count }}").unwrap();
|
|
assert_eq!(rendered, "5");
|
|
}
|
|
|
|
#[test]
|
|
fn test_export_import() {
|
|
let mut ctx = WorkflowContext::new(json!({"key": "value"}), HashMap::new());
|
|
ctx.set_var("test", json!("data"));
|
|
ctx.set_task_result("task1", json!({"result": "ok"}));
|
|
ctx.set_pack_config(json!({"setting": "val"}));
|
|
ctx.set_keystore(json!({"secret": "hidden"}));
|
|
|
|
let exported = ctx.export();
|
|
let imported = WorkflowContext::import(exported).unwrap();
|
|
|
|
assert_eq!(imported.get_var("test").unwrap(), json!("data"));
|
|
assert_eq!(
|
|
imported.get_task_result("task1").unwrap(),
|
|
json!({"result": "ok"})
|
|
);
|
|
assert_eq!(
|
|
imported.evaluate_expression("config.setting").unwrap(),
|
|
json!("val")
|
|
);
|
|
assert_eq!(
|
|
imported.evaluate_expression("keystore.secret").unwrap(),
|
|
json!("hidden")
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// with_items type preservation
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_with_items_integer_type_preservation() {
|
|
// Simulates the sleep_2 task from the hello_workflow:
|
|
// input: { seconds: "{{ item }}" }
|
|
// with_items: [0, 1, 2, 3, 4]
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_current_item(json!(3), 3);
|
|
|
|
let input = json!({
|
|
"message": "Sleeping for {{ item }} seconds ",
|
|
"seconds": "{{item}}"
|
|
});
|
|
|
|
let rendered = ctx.render_json(&input).unwrap();
|
|
|
|
// seconds should be integer 3, not string "3"
|
|
assert_eq!(rendered["seconds"], json!(3));
|
|
assert!(rendered["seconds"].is_number());
|
|
|
|
// message should be a string with the value interpolated
|
|
assert_eq!(rendered["message"], json!("Sleeping for 3 seconds "));
|
|
assert!(rendered["message"].is_string());
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// Cross-namespace expressions
|
|
// ---------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn test_cross_namespace_expression() {
|
|
let mut ctx = WorkflowContext::new(json!({"limit": 5}), HashMap::new());
|
|
ctx.set_var("items", json!([1, 2, 3]));
|
|
ctx.set_pack_config(json!({"multiplier": 2}));
|
|
|
|
assert!(ctx
|
|
.evaluate_condition("length(workflow.items) < parameters.limit")
|
|
.unwrap());
|
|
let val = ctx
|
|
.evaluate_expression("parameters.limit * config.multiplier")
|
|
.unwrap();
|
|
assert_eq!(val, json!(10));
|
|
}
|
|
|
|
#[test]
|
|
fn test_keystore_in_template() {
|
|
let mut ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
ctx.set_keystore(json!({"api_key": "abc-123"}));
|
|
|
|
let input = json!({"auth": "Bearer {{ keystore.api_key }}"});
|
|
let result = ctx.render_json(&input).unwrap();
|
|
assert_eq!(result["auth"], json!("Bearer abc-123"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_config_null_when_not_set() {
|
|
let ctx = WorkflowContext::new(json!({}), HashMap::new());
|
|
let val = ctx.evaluate_expression("config").unwrap();
|
|
assert_eq!(val, json!(null));
|
|
}
|
|
}
|