mod wire;
use std::collections::{BTreeMap, HashMap};
use std::sync::atomic::{AtomicI32, AtomicI64, Ordering};
use std::sync::{Arc, Mutex, PoisonError};
use std::time::{Duration, SystemTime};
use hatchet_proto::prost_types::Timestamp;
use hatchet_proto::root::{
AssignedAction, PutLogRequest, PutStreamEventRequest, RefreshTimeoutRequest,
ReleaseSlotRequest, UpsertWorkerLabelsRequest,
};
use serde::Deserialize;
use serde::de::DeserializeOwned;
use serde_json::{Map, Value};
use tokio::sync::OwnedSemaphorePermit;
use tokio_util::sync::CancellationToken;
use tonic::{Request, Response, Status};
use tracing::{Instrument, Span};
use crate::durable::DurableInvocation;
use crate::trigger::{ParentRef, RunOpts};
use crate::{Client, Error, LabelValue, Task, Workflow, otel, retry, trigger};
const LOG_LEVEL: &str = "INFO";
#[derive(Clone)]
pub struct Context {
inner: Arc<Inner>,
}
impl std::fmt::Debug for Context {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Context")
.field("workflow_run_id", &self.workflow_run_id())
.field("task_run_id", &self.task_run_id())
.field("action_id", &self.action_id())
.field("retry_count", &self.retry_count())
.field("cancelled", &self.is_cancelled())
.finish()
}
}
struct Inner {
action: AssignedAction,
payload: ActionPayload,
metadata: Map<String, Value>,
worker_id: String,
client: Option<Client>,
cancel: CancellationToken,
slot: Slot,
durable: Option<Arc<DurableInvocation>>,
next_event_index: AtomicI64,
next_child_index: AtomicI32,
}
#[derive(Debug, Default, Deserialize)]
#[serde(default)]
pub(crate) struct ActionPayload {
pub(crate) input: Value,
#[serde(deserialize_with = "null_as_default")]
pub(crate) parents: HashMap<String, Value>,
#[serde(deserialize_with = "decode_step_run_errors")]
pub(crate) step_run_errors: BTreeMap<String, String>,
}
fn null_as_default<'de, D, T>(deserializer: D) -> Result<T, D::Error>
where
D: serde::Deserializer<'de>,
T: Default + Deserialize<'de>,
{
Ok(Option::<T>::deserialize(deserializer)?.unwrap_or_default())
}
fn decode_step_run_errors<'de, D>(deserializer: D) -> Result<BTreeMap<String, String>, D::Error>
where
D: serde::Deserializer<'de>,
{
let raw: BTreeMap<String, String> = null_as_default(deserializer)?;
Ok(raw
.into_iter()
.map(|(task, value)| {
let decoded = serde_json::from_str::<String>(&value).unwrap_or(value);
(task, decoded)
})
.collect())
}
#[derive(Clone, Default)]
pub(crate) struct Slot {
permit: Arc<Mutex<Option<OwnedSemaphorePermit>>>,
}
impl Slot {
pub(crate) fn holding(permit: OwnedSemaphorePermit) -> Self {
Self {
permit: Arc::new(Mutex::new(Some(permit))),
}
}
pub(crate) fn release(&self) {
let permit = self
.permit
.lock()
.unwrap_or_else(PoisonError::into_inner)
.take();
drop(permit);
}
}
impl Context {
pub fn is_cancelled(&self) -> bool {
self.inner.cancel.is_cancelled()
}
pub async fn cancelled(&self) {
self.inner.cancel.cancelled().await;
}
}
impl Context {
pub fn input_raw(&self) -> &Value {
self.input()
}
pub fn parent_output<PI, O>(&self, parent: &Task<PI, O>) -> crate::Result<O>
where
O: DeserializeOwned,
{
self.parent_output_by_name(parent.name())
}
pub fn parent_output_by_name<T>(&self, task_name: &str) -> crate::Result<T>
where
T: DeserializeOwned,
{
let output = self
.parents()
.get(task_name)
.ok_or_else(|| Error::ParentOutput {
task: task_name.to_string(),
reason: "no output is recorded for this task; check that it is declared as a \
parent and has run"
.to_string(),
})?;
if is_skipped(output) {
return Err(Error::ParentOutput {
task: task_name.to_string(),
reason: "the task was skipped, so it produced no output; check \
`Context::was_skipped` before reading it"
.to_string(),
});
}
serde_json::from_value(output.clone()).map_err(|error| Error::ParentOutput {
task: task_name.to_string(),
reason: error.to_string(),
})
}
pub fn step_run_errors(&self) -> &BTreeMap<String, String> {
&self.inner.payload.step_run_errors
}
pub fn was_skipped<PI, O>(&self, parent: &Task<PI, O>) -> bool {
self.was_skipped_by_name(parent.name())
}
pub fn was_skipped_by_name(&self, task_name: &str) -> bool {
self.parents().get(task_name).is_some_and(is_skipped)
}
pub fn additional_metadata(&self) -> &Map<String, Value> {
&self.inner.metadata
}
pub fn retry_count(&self) -> u32 {
u32::try_from(self.retry_count_wire()).unwrap_or(0)
}
pub fn workflow_run_id(&self) -> &str {
&self.action().workflow_run_id
}
pub fn task_run_id(&self) -> &str {
&self.action().task_run_external_id
}
pub fn task_name(&self) -> &str {
&self.action().task_name
}
pub fn action_id(&self) -> &str {
&self.action().action_id
}
pub fn worker_id(&self) -> &str {
&self.inner.worker_id
}
}
impl Context {
pub async fn refresh_timeout(&self, increment: Duration) -> crate::Result<()> {
let client = self.engine("refresh_timeout")?;
let request = RefreshTimeoutRequest {
task_run_external_id: self.task_run_id().to_string(),
increment_timeout_by: wire::timeout_increment(increment)?,
};
send(request, |request| {
let mut dispatcher = client.dispatcher_grpc();
async move { dispatcher.refresh_timeout(request).await }
})
.await?;
Ok(())
}
pub async fn release_slot(&self) -> crate::Result<()> {
let client = self.engine("release_slot")?;
let request = ReleaseSlotRequest {
task_run_external_id: self.task_run_id().to_string(),
};
send(request, |request| {
let mut dispatcher = client.dispatcher_grpc();
async move { dispatcher.release_slot(request).await }
})
.await?;
self.release_local_slot();
Ok(())
}
pub async fn log(&self, message: impl AsRef<str>) -> crate::Result<()> {
let client = self.engine("log")?;
let message = message.as_ref();
let kept = wire::truncate_log(message);
if kept.len() < message.len() {
tracing::warn!(
task_run_external_id = %self.task_run_id(),
original_chars = message.chars().count(),
kept_chars = kept.chars().count(),
"a log message was longer than the engine accepts and was truncated",
);
}
let request = PutLogRequest {
task_run_external_id: self.task_run_id().to_string(),
created_at: Some(Timestamp::from(SystemTime::now())),
message: kept.to_string(),
level: Some(LOG_LEVEL.to_string()),
metadata: String::new(),
task_retry_count: Some(self.retry_count_wire()),
};
send(request, |request| {
let mut events = client.events_grpc();
async move { events.put_log(request).await }
})
.await?;
Ok(())
}
pub async fn put_stream(&self, data: impl Into<Vec<u8>>) -> crate::Result<()> {
let client = self.engine("put_stream")?;
let request = PutStreamEventRequest {
task_run_external_id: self.task_run_id().to_string(),
created_at: Some(Timestamp::from(SystemTime::now())),
message: data.into(),
metadata: String::new(),
event_index: Some(self.inner.next_event_index.fetch_add(1, Ordering::Relaxed)),
};
send(request, |request| {
let mut events = client.events_grpc();
async move { events.put_stream_event(request).await }
})
.await?;
Ok(())
}
pub async fn upsert_labels<K, V>(
&self,
labels: impl IntoIterator<Item = (K, V)>,
) -> crate::Result<()>
where
K: Into<String>,
V: Into<LabelValue>,
{
let client = self.engine("upsert_labels")?;
let request = UpsertWorkerLabelsRequest {
worker_id: self.worker_id().to_string(),
labels: labels
.into_iter()
.map(|(key, value)| (key.into(), value.into().to_proto()))
.collect(),
};
send(request, |request| {
let mut dispatcher = client.dispatcher_grpc();
async move { dispatcher.upsert_worker_labels(request).await }
})
.await?;
Ok(())
}
pub async fn spawn<I, O>(
&self,
task: &Task<I, O>,
input: &I,
opts: RunOpts,
) -> crate::Result<String>
where
I: serde::Serialize,
{
let span = otel::run_workflow(task.name());
let run_id = self
.trigger_child("spawn", task.name(), input, &opts, &span)
.instrument(span.clone())
.await;
otel::record_result(&span, &run_id);
run_id
}
pub async fn spawn_workflow<I>(
&self,
workflow: &Workflow,
input: &I,
opts: RunOpts,
) -> crate::Result<String>
where
I: serde::Serialize,
{
let span = otel::run_workflow(workflow.name());
let run_id = self
.trigger_child("spawn_workflow", workflow.name(), input, &opts, &span)
.instrument(span.clone())
.await;
otel::record_result(&span, &run_id);
run_id
}
pub async fn run<I, O>(&self, task: &Task<I, O>, input: &I, opts: RunOpts) -> crate::Result<O>
where
I: serde::Serialize,
O: serde::de::DeserializeOwned,
{
let span = otel::run_workflow(task.name());
let output = async {
let run_id = self
.trigger_child("run", task.name(), input, &opts, &span)
.await?;
let event = self.engine("run")?.run_listener().wait(run_id).await?;
crate::runs::output_of(&event, task.name())
}
.instrument(span.clone())
.await;
otel::record_result(&span, &output);
output
}
async fn trigger_child<I: serde::Serialize>(
&self,
method: &str,
name: &str,
input: &I,
opts: &RunOpts,
span: &Span,
) -> crate::Result<String> {
let client = self.engine(method)?;
let mut request = trigger::request(
client.config().namespace(),
name,
input,
opts,
Some(ParentRef {
workflow_run_id: self.workflow_run_id(),
task_run_external_id: self.task_run_id(),
child_index: self.claim_child_index(),
worker_id: self.worker_id(),
}),
)?;
otel::inject(span, &mut request.additional_metadata);
let response = send(request, |request| {
let mut workflows = client.workflows_grpc();
async move { workflows.trigger_workflow(request).await }
})
.await
.map_err(crate::collision::from_trigger)?;
span.record(
"hatchet.child_workflow_run_id",
response.workflow_run_id.as_str(),
);
Ok(response.workflow_run_id)
}
}
async fn send<T, C, Fut, R>(request: T, mut call: C) -> crate::Result<R>
where
T: Clone,
C: FnMut(Request<T>) -> Fut,
Fut: Future<Output = std::result::Result<Response<R>, Status>>,
{
let response = retry::unary(|| call(retry::timed(request.clone()))).await?;
Ok(response.into_inner())
}
impl Context {
pub(crate) fn new(
action: AssignedAction,
worker_id: String,
client: Option<Client>,
cancel: CancellationToken,
slot: Slot,
durable: Option<Arc<DurableInvocation>>,
) -> Result<Self, String> {
let payload = parse_payload(&action.action_payload)?;
let metadata = wire::parse_metadata(action.additional_metadata.as_deref());
Ok(Self {
inner: Arc::new(Inner {
action,
payload,
metadata,
worker_id,
client,
cancel,
slot,
durable,
next_event_index: AtomicI64::new(0),
next_child_index: AtomicI32::new(0),
}),
})
}
pub(crate) fn release_local_slot(&self) {
self.inner.slot.release();
}
fn retry_count_wire(&self) -> i32 {
self.action().retry_count.max(0)
}
pub(crate) fn input(&self) -> &Value {
&self.inner.payload.input
}
pub(crate) fn parents(&self) -> &HashMap<String, Value> {
&self.inner.payload.parents
}
pub(crate) fn action(&self) -> &AssignedAction {
&self.inner.action
}
pub(crate) fn client(&self) -> Option<&Client> {
self.inner.client.as_ref()
}
pub(crate) fn durable(&self) -> Option<&Arc<DurableInvocation>> {
self.inner.durable.as_ref()
}
pub(crate) fn claim_child_index(&self) -> i32 {
self.inner.next_child_index.fetch_add(1, Ordering::Relaxed)
}
fn engine(&self, method: &str) -> crate::Result<&Client> {
self.client().ok_or_else(|| {
Error::Detached(format!(
"`{method}` talks to the engine, and this context was built without a connection \
to one"
))
})
}
#[cfg(test)]
pub(crate) fn placeholder() -> Self {
Self::new(
AssignedAction::default(),
String::new(),
None,
CancellationToken::new(),
Slot::default(),
None,
)
.expect("an empty payload parses")
}
}
fn is_skipped(value: &Value) -> bool {
value.get("skipped") == Some(&Value::Bool(true))
}
fn parse_payload(raw: &str) -> Result<ActionPayload, String> {
if raw.is_empty() {
return Ok(ActionPayload::default());
}
serde_json::from_str(raw).map_err(|error| format!("could not read the action payload: {error}"))
}
#[cfg(test)]
mod tests {
use super::*;
use hatchet_proto::root::AssignedAction;
use serde_json::json;
use tokio_util::sync::CancellationToken;
fn action_with_payload(payload: &str) -> AssignedAction {
AssignedAction {
action_payload: payload.to_string(),
action_id: "pipeline:step".to_string(),
..AssignedAction::default()
}
}
fn context_for(payload: &str, cancel: CancellationToken) -> Result<Context, String> {
Context::new(
action_with_payload(payload),
"worker-1".to_string(),
None,
cancel,
Slot::default(),
None,
)
}
#[test]
fn parses_input_and_parents_from_the_payload() {
let payload = json!({
"input": {"repo": "hatchet-rs"},
"parents": {"fetch": {"count": 3}},
})
.to_string();
let ctx = context_for(&payload, CancellationToken::new()).unwrap();
assert_eq!(ctx.input(), &json!({"repo": "hatchet-rs"}));
assert_eq!(ctx.parents().get("fetch"), Some(&json!({"count": 3})));
assert_eq!(ctx.worker_id(), "worker-1");
assert_eq!(ctx.action().action_id, "pipeline:step");
assert!(ctx.client().is_none());
}
#[test]
fn an_empty_payload_is_an_empty_object() {
let ctx = context_for("", CancellationToken::new()).unwrap();
assert_eq!(ctx.input(), &serde_json::Value::Null);
assert!(ctx.parents().is_empty());
}
#[test]
fn step_run_errors_are_read_from_the_payload() {
let payload = json!({
"input": {},
"step_run_errors": {"fetch": "boom", "build": "nope"}
})
.to_string();
let ctx = context_for(&payload, CancellationToken::new()).unwrap();
let errors = ctx.step_run_errors();
assert_eq!(errors.len(), 2);
assert_eq!(errors.get("fetch").map(String::as_str), Some("boom"));
assert_eq!(errors.get("build").map(String::as_str), Some("nope"));
}
#[test]
fn null_parents_and_step_run_errors_read_as_empty() {
let payload = json!({"input": {}, "parents": null, "step_run_errors": null}).to_string();
let ctx = context_for(&payload, CancellationToken::new()).unwrap();
assert!(ctx.parents().is_empty());
assert!(ctx.step_run_errors().is_empty());
}
#[test]
fn a_payload_without_step_run_errors_reports_none() {
let ctx = context_for(r#"{"input":{}}"#, CancellationToken::new()).unwrap();
assert!(ctx.step_run_errors().is_empty());
let ctx = context_for("", CancellationToken::new()).unwrap();
assert!(ctx.step_run_errors().is_empty());
}
#[test]
fn a_json_string_encoded_step_run_error_is_decoded() {
let payload = json!({
"input": {},
"step_run_errors": {"boom": "\"boom went the task\""}
})
.to_string();
let ctx = context_for(&payload, CancellationToken::new()).unwrap();
assert_eq!(
ctx.step_run_errors().get("boom").map(String::as_str),
Some("boom went the task")
);
}
#[test]
fn a_step_run_error_that_is_not_a_json_string_is_kept_verbatim() {
let payload = json!({
"input": {},
"step_run_errors": {"plain": "boom", "structured": "{\"a\":1}"}
})
.to_string();
let ctx = context_for(&payload, CancellationToken::new()).unwrap();
assert_eq!(
ctx.step_run_errors().get("plain").map(String::as_str),
Some("boom")
);
assert_eq!(
ctx.step_run_errors().get("structured").map(String::as_str),
Some(r#"{"a":1}"#)
);
}
#[test]
fn a_payload_that_is_not_json_is_an_error() {
let error = context_for("not json at all", CancellationToken::new()).unwrap_err();
assert!(error.contains("payload"), "{error}");
}
#[test]
fn unknown_payload_fields_are_ignored() {
let payload = json!({
"input": 7,
"triggers": ["cron"],
"user_data": {"anything": true},
})
.to_string();
let ctx = context_for(&payload, CancellationToken::new()).unwrap();
assert_eq!(ctx.input(), &json!(7));
assert!(ctx.parents().is_empty());
}
#[tokio::test]
async fn cancellation_is_observable() {
let cancel = CancellationToken::new();
let ctx = context_for("", cancel.clone()).unwrap();
assert!(!ctx.is_cancelled());
let clone = ctx.clone();
let waiting = tokio::spawn(async move {
clone.cancelled().await;
clone.is_cancelled()
});
cancel.cancel();
assert!(waiting.await.unwrap());
assert!(ctx.is_cancelled());
ctx.cancelled().await;
}
fn full_action(payload: &str, metadata: Option<&str>) -> AssignedAction {
AssignedAction {
action_payload: payload.to_string(),
action_id: "pipeline:step".to_string(),
task_name: "step".to_string(),
workflow_run_id: "run-1".to_string(),
task_run_external_id: "task-run-1".to_string(),
retry_count: 2,
additional_metadata: metadata.map(str::to_string),
..AssignedAction::default()
}
}
fn context_with(action: AssignedAction) -> Context {
Context::new(
action,
"worker-1".to_string(),
None,
CancellationToken::new(),
Slot::default(),
None,
)
.expect("a valid payload parses")
}
#[test]
fn ids_and_retry_count_come_from_the_action() {
let ctx = context_with(full_action("", None));
assert_eq!(ctx.workflow_run_id(), "run-1");
assert_eq!(ctx.task_run_id(), "task-run-1");
assert_eq!(ctx.task_name(), "step");
assert_eq!(ctx.action_id(), "pipeline:step");
assert_eq!(ctx.worker_id(), "worker-1");
assert_eq!(ctx.retry_count(), 2);
}
#[test]
fn input_raw_is_the_unparsed_input() {
let payload = json!({"input": {"repo": "hatchet-rs"}}).to_string();
let ctx = context_with(full_action(&payload, None));
assert_eq!(ctx.input_raw(), &json!({"repo": "hatchet-rs"}));
}
#[test]
fn additional_metadata_parses_the_actions_json_object() {
let ctx = context_with(full_action("", Some(r#"{"a":"b","n":1}"#)));
let metadata = ctx.additional_metadata();
assert_eq!(metadata.len(), 2);
assert_eq!(metadata.get("a"), Some(&json!("b")));
assert_eq!(metadata.get("n"), Some(&json!(1)));
}
#[test]
fn additional_metadata_is_empty_when_the_action_has_none() {
let ctx = context_with(full_action("", None));
assert!(ctx.additional_metadata().is_empty());
}
#[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
struct FetchOutput {
n: i32,
}
fn fetch_task() -> Task<(), FetchOutput> {
crate::TaskBuilder::new("fetch")
.handler(|_ctx, _input: ()| async { Ok(FetchOutput { n: 0 }) })
}
#[test]
fn parent_output_deserializes_a_recorded_parent() {
let payload = json!({"parents": {"fetch": {"n": 3}}}).to_string();
let ctx = context_with(full_action(&payload, None));
let output: FetchOutput = ctx.parent_output(&fetch_task()).unwrap();
assert_eq!(output, FetchOutput { n: 3 });
}
#[test]
fn parent_output_of_a_missing_parent_names_the_task() {
let ctx = context_with(full_action("", None));
let error = ctx.parent_output(&fetch_task()).unwrap_err();
let Error::ParentOutput { task, .. } = &error else {
panic!("{error:?}")
};
assert_eq!(task, "fetch");
}
#[test]
fn parent_output_of_the_wrong_type_names_the_task_and_the_serde_error() {
let payload = json!({"parents": {"fetch": "not an object"}}).to_string();
let ctx = context_with(full_action(&payload, None));
let error = ctx.parent_output(&fetch_task()).unwrap_err();
let Error::ParentOutput { task, reason } = &error else {
panic!("{error:?}")
};
assert_eq!(task, "fetch");
assert!(!reason.is_empty(), "{error:?}");
}
#[test]
fn parent_output_by_name_looks_up_by_string_rather_than_a_task_handle() {
let payload = json!({"parents": {"fetch": {"n": 5}}}).to_string();
let ctx = context_with(full_action(&payload, None));
let output: FetchOutput = ctx.parent_output_by_name("fetch").unwrap();
assert_eq!(output, FetchOutput { n: 5 });
}
#[test]
fn a_skipped_parent_is_reported_as_skipped() {
let payload = json!({
"input": {},
"parents": {
"maybe": {"skipped": true},
"fetch": {"count": 3},
},
})
.to_string();
let ctx = context_for(&payload, CancellationToken::new()).unwrap();
assert!(ctx.was_skipped_by_name("maybe"));
assert!(!ctx.was_skipped_by_name("fetch"));
assert!(
!ctx.was_skipped_by_name("never-heard-of-it"),
"a task that is not a parent at all was not skipped either"
);
}
#[test]
fn was_skipped_matches_by_task_handle() {
let maybe: Task<(), ()> =
crate::TaskBuilder::new("maybe").handler(|_ctx, _input: ()| async { Ok(()) });
let payload = json!({"input": {}, "parents": {"maybe": {"skipped": true}}}).to_string();
let ctx = context_for(&payload, CancellationToken::new()).unwrap();
assert!(ctx.was_skipped(&maybe));
}
#[test]
fn reading_a_skipped_parents_output_says_it_was_skipped() {
#[derive(Debug, serde::Deserialize)]
struct Count {
#[allow(dead_code)]
count: u32,
}
let payload = json!({"input": {}, "parents": {"maybe": {"skipped": true}}}).to_string();
let ctx = context_for(&payload, CancellationToken::new()).unwrap();
let error = ctx.parent_output_by_name::<Count>("maybe").unwrap_err();
let Error::ParentOutput { task, reason } = &error else {
panic!("expected ParentOutput: {error:?}");
};
assert_eq!(task, "maybe");
assert!(reason.contains("skipped"), "{reason}");
assert!(
!reason.contains("missing field"),
"the serde message must not be what the caller sees: {reason}"
);
}
#[test]
fn only_a_skipped_true_marker_counts_as_skipped() {
let payload = json!({
"input": {},
"parents": {"a": {"skipped": false}, "b": {"skipped": "yes"}, "c": null},
})
.to_string();
let ctx = context_for(&payload, CancellationToken::new()).unwrap();
assert!(!ctx.was_skipped_by_name("a"));
assert!(!ctx.was_skipped_by_name("b"));
assert!(!ctx.was_skipped_by_name("c"));
}
#[tokio::test]
async fn rpcs_on_a_context_without_an_engine_are_detached_errors() {
let ctx = Context::placeholder();
let child = fetch_task();
let pipeline = Workflow::new("pipeline");
let calls: [(&str, crate::Result<()>); 5] = [
(
"refresh_timeout",
ctx.refresh_timeout(Duration::from_secs(60)).await,
),
("release_slot", ctx.release_slot().await),
("log", ctx.log("anything").await),
(
"spawn",
ctx.spawn(&child, &(), RunOpts::default()).await.map(drop),
),
(
"spawn_workflow",
ctx.spawn_workflow(&pipeline, &(), RunOpts::default())
.await
.map(drop),
),
];
for (method, result) in calls {
let error = result.expect_err("a placeholder context reaches no engine");
let Error::Detached(reason) = &error else {
panic!("{method}: {error:?}")
};
assert!(reason.contains(method), "{method}: {reason}");
}
}
#[test]
fn a_slot_gives_its_permit_back_once_however_often_it_is_released() {
let semaphore = Arc::new(tokio::sync::Semaphore::new(1));
let permit = Arc::clone(&semaphore)
.try_acquire_owned()
.expect("the semaphore has a permit");
let slot = Slot::holding(permit);
assert_eq!(semaphore.available_permits(), 0);
let clone = slot.clone();
slot.release();
assert_eq!(semaphore.available_permits(), 1);
clone.release();
slot.release();
assert_eq!(semaphore.available_permits(), 1);
Slot::default().release();
}
#[test]
fn a_negative_retry_count_reads_as_zero_everywhere() {
let ctx = context_with(AssignedAction {
retry_count: -1,
..AssignedAction::default()
});
assert_eq!(ctx.retry_count(), 0);
assert_eq!(ctx.retry_count_wire(), 0);
}
#[test]
fn debug_hides_input_and_metadata_but_shows_the_task_run_id() {
let payload = json!({"input": {"token": "s3cr3t"}}).to_string();
let ctx = context_with(full_action(&payload, Some(r#"{"key": "s3cr3t"}"#)));
let debug = format!("{ctx:?}");
assert!(!debug.contains("s3cr3t"), "{debug}");
assert!(debug.contains("task-run-1"), "{debug}");
}
}