Skip to main content

jellyflow_runtime/runtime/conformance/scenario/action/
connection.rs

1use serde::{Deserialize, Serialize};
2
3use crate::runtime::connection::{
4    ConnectEdgeRequest, ConnectionEndIntent, ConnectionLifecycleResult, ConnectionTargetCandidate,
5    ConnectionTargetFromHandlesInput, ConnectionTargetInput, ReconnectEdgeRequest,
6    ResolvedConnectionTarget,
7};
8use crate::runtime::events::ConnectStart;
9use jellyflow_core::core::CanvasPoint;
10use jellyflow_core::interaction::NodeGraphConnectionMode;
11
12use super::ConformanceAction;
13
14pub(super) fn kind(action: &ConformanceAction) -> Option<&'static str> {
15    Some(match action {
16        ConformanceAction::AssertConnectionTarget { .. } => "assert_connection_target",
17        ConformanceAction::AssertConnectionTargetFromHandles { .. } => {
18            "assert_connection_target_from_handles"
19        }
20        ConformanceAction::AssertConnectionLifecycle { .. } => "assert_connection_lifecycle",
21        ConformanceAction::ApplyConnectEdge { .. } => "apply_connect_edge",
22        ConformanceAction::ApplyConnectEdgeSession { .. } => "apply_connect_edge_session",
23        ConformanceAction::ApplyReconnectEdge { .. } => "apply_reconnect_edge",
24        _ => return None,
25    })
26}
27
28#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
29pub struct ConformanceConnectionTargetFromHandlesInput {
30    pub pointer: CanvasPoint,
31    pub radius: f32,
32    pub from: crate::runtime::connection::ConnectionHandleRef,
33    pub candidates: Vec<ConnectionTargetCandidate>,
34    pub mode: NodeGraphConnectionMode,
35    #[serde(default = "default_connection_validity")]
36    pub is_valid_connection: bool,
37}
38
39impl ConformanceConnectionTargetFromHandlesInput {
40    pub(crate) fn as_runtime(&self) -> ConnectionTargetFromHandlesInput<'_> {
41        ConnectionTargetFromHandlesInput::new(
42            self.pointer,
43            self.radius,
44            self.from,
45            &self.candidates,
46            self.mode,
47        )
48        .with_connection_validity(self.is_valid_connection)
49    }
50
51    fn from_runtime(input: ConnectionTargetFromHandlesInput<'_>) -> Self {
52        Self {
53            pointer: input.pointer,
54            radius: input.radius,
55            from: input.from,
56            candidates: input.candidates.to_vec(),
57            mode: input.mode,
58            is_valid_connection: input.is_valid_connection,
59        }
60    }
61}
62
63fn default_connection_validity() -> bool {
64    true
65}
66
67impl ConformanceAction {
68    pub fn assert_connection_target(
69        input: ConnectionTargetInput,
70        expected: ResolvedConnectionTarget,
71    ) -> Self {
72        Self::AssertConnectionTarget { input, expected }
73    }
74
75    pub fn assert_connection_target_from_handles(
76        input: ConnectionTargetFromHandlesInput<'_>,
77        expected: ResolvedConnectionTarget,
78    ) -> Self {
79        Self::AssertConnectionTargetFromHandles {
80            input: ConformanceConnectionTargetFromHandlesInput::from_runtime(input),
81            expected,
82        }
83    }
84
85    pub fn assert_connection_lifecycle(
86        start: ConnectStart,
87        hover: Option<ResolvedConnectionTarget>,
88        intent: ConnectionEndIntent,
89        expected: ConnectionLifecycleResult,
90    ) -> Self {
91        Self::AssertConnectionLifecycle {
92            start,
93            hover,
94            intent,
95            expected,
96        }
97    }
98
99    pub fn apply_connect_edge(request: ConnectEdgeRequest) -> Self {
100        Self::ApplyConnectEdge { request }
101    }
102
103    pub fn apply_connect_edge_session(start: ConnectStart, request: ConnectEdgeRequest) -> Self {
104        Self::ApplyConnectEdgeSession { start, request }
105    }
106
107    pub fn apply_reconnect_edge(request: ReconnectEdgeRequest) -> Self {
108        Self::ApplyReconnectEdge { request }
109    }
110}