dex-sdk 0.2.9

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

// 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 Super Durable Source 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, SIGNAL};
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
        .publish_many(&flow_id, &SIGNAL, [(), (), ()])
        .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")
    );
}

#[allow(dead_code)]
fn compile_conditional_complete(client: &Client) -> SdkResult<()> {
    let workflow = ConditionalCompleteWorkflow::new();
    client.start_flow(&workflow, "conditional-signal", true)?;
    client.publish_many("conditional-signal", &SIGNAL, [(), (), ()])?;
    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,
    )
}