dex-sdk 1.38.0

Strongly typed Rust SDK for Dex
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// Portions of this file are derived from indeedeng/iwf-java-sdk.
// Those portions are licensed under the Apache License, Version 2.0.
// See LICENSES/Apache-2.0.txt and LEGACY_NOTICES.md.
//
// Modifications Copyright (c) 2026 Super Durable, Inc.
//
// Modifications are licensed under the Sustainable Use License 1.0.
// Third-Party Materials remain under the Apache License, Version 2.0.
// See LICENSE and LEGACY_NOTICES.md.

use std::time::Duration;

use dex_sdk::{Client, Registry, SdkResult};

use crate::conditional_complete_workflow::ConditionalCompleteWorkflow;
use crate::support::{DexDevTestEnvironment, flow_id};

#[test]
#[ignore = "requires dexcli dev"]
fn test_signal_channel() {
    let environment =
        DexDevTestEnvironment::start(Registry::new().register(ConditionalCompleteWorkflow::new()));
    let workflow = ConditionalCompleteWorkflow::new();
    let flow_id = flow_id("conditional-signal");
    environment
        .client
        .start_flow(&workflow, &flow_id, true)
        .expect("start conditional signal Flow");
    environment
        .client
        .invoke_rpc(&flow_id, ConditionalCompleteWorkflow::PUBLISH_SIGNAL, 3)
        .expect("publish signal messages");
    assert_eq!(
        3,
        environment
            .client
            .wait_for_flow_with_timeout(&flow_id, Duration::from_secs(30))
            .and_then(|result| result.single_output::<i32>())
            .expect("drain signal channel")
    );
}

#[test]
#[ignore = "requires dexcli dev"]
fn test_internal_channel() {
    let environment =
        DexDevTestEnvironment::start(Registry::new().register(ConditionalCompleteWorkflow::new()));
    let workflow = ConditionalCompleteWorkflow::new();
    let flow_id = flow_id("conditional-internal");
    environment
        .client
        .start_flow(&workflow, &flow_id, false)
        .expect("start conditional internal Flow");
    environment
        .client
        .invoke_rpc(
            &flow_id,
            ConditionalCompleteWorkflow::PUBLISH_TO_INTERNAL,
            3,
        )
        .expect("publish internal messages through RPC");
    assert_eq!(
        3,
        environment
            .client
            .wait_for_flow_with_timeout(&flow_id, Duration::from_secs(30))
            .and_then(|result| result.single_output::<i32>())
            .expect("drain internal channel")
    );
}

#[expect(
    dead_code,
    reason = "Integration fixtures implement schema variants exercised by selected test targets."
)]
fn compile_conditional_complete(client: &Client) -> SdkResult<()> {
    let workflow = ConditionalCompleteWorkflow::new();
    client.start_flow(&workflow, "conditional-signal", true)?;
    client.invoke_rpc(
        "conditional-signal",
        ConditionalCompleteWorkflow::PUBLISH_SIGNAL,
        3,
    )?;
    let _: i32 = client
        .wait_for_flow("conditional-signal")?
        .single_output()?;
    client.start_flow(&workflow, "conditional-internal", false)?;
    client.invoke_rpc(
        "conditional-internal",
        ConditionalCompleteWorkflow::PUBLISH_TO_INTERNAL,
        3,
    )
}