2022-03-10 08:21:57 +03:00
|
|
|
// === Non-Standard Linter Configuration ===
|
2022-03-10 07:57:59 +03:00
|
|
|
#![deny(non_ascii_idents)]
|
|
|
|
#![warn(unsafe_code)]
|
|
|
|
|
2022-02-22 19:43:37 +03:00
|
|
|
use enso_integration_test::prelude::*;
|
|
|
|
|
|
|
|
use approx::assert_abs_diff_eq;
|
2022-03-31 17:16:28 +03:00
|
|
|
use enso_frp::future::FutureEvent;
|
|
|
|
use enso_frp::io::mouse::PrimaryButton;
|
|
|
|
use enso_gui::view::graph_editor;
|
|
|
|
use enso_gui::view::graph_editor::component::node as node_view;
|
2022-03-30 15:49:07 +03:00
|
|
|
use enso_gui::view::graph_editor::component::node::test_utils::NodeModelExt;
|
2022-03-16 21:02:47 +03:00
|
|
|
use enso_gui::view::graph_editor::component::node::Expression;
|
|
|
|
use enso_gui::view::graph_editor::GraphEditor;
|
2022-03-21 18:08:17 +03:00
|
|
|
use enso_gui::view::graph_editor::Node;
|
2022-03-16 21:02:47 +03:00
|
|
|
use enso_gui::view::graph_editor::NodeId;
|
|
|
|
use enso_gui::view::graph_editor::NodeSource;
|
2022-02-22 19:43:37 +03:00
|
|
|
use enso_web::sleep;
|
|
|
|
use ensogl::display::navigation::navigator::ZoomEvent;
|
2022-03-31 17:16:28 +03:00
|
|
|
use ensogl::display::scene::test_utils::MouseExt;
|
|
|
|
use ensogl::display::Scene;
|
2022-03-16 21:02:47 +03:00
|
|
|
use ordered_float::OrderedFloat;
|
2022-02-22 19:43:37 +03:00
|
|
|
use std::time::Duration;
|
2022-02-11 15:19:02 +03:00
|
|
|
|
|
|
|
|
2022-03-10 07:32:33 +03:00
|
|
|
|
2022-02-11 15:19:02 +03:00
|
|
|
wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
|
|
|
|
|
|
|
|
#[wasm_bindgen_test]
|
|
|
|
async fn create_new_project_and_add_nodes() {
|
2022-02-22 19:43:37 +03:00
|
|
|
let test = IntegrationTestOnNewProject::setup().await;
|
|
|
|
let graph_editor = test.graph_editor();
|
2022-02-11 15:19:02 +03:00
|
|
|
|
2022-03-30 15:49:07 +03:00
|
|
|
assert_eq!(graph_editor.nodes().all.len(), 2);
|
2022-02-11 15:19:02 +03:00
|
|
|
let expect_node_added = graph_editor.node_added.next_event();
|
|
|
|
graph_editor.add_node();
|
2022-03-16 21:02:47 +03:00
|
|
|
let (added_node_id, source_node, _) = expect_node_added.expect();
|
|
|
|
assert_eq!(source_node, None);
|
2022-03-30 15:49:07 +03:00
|
|
|
assert_eq!(graph_editor.nodes().all.len(), 3);
|
2022-02-11 15:19:02 +03:00
|
|
|
|
|
|
|
let added_node =
|
2022-03-30 15:49:07 +03:00
|
|
|
graph_editor.nodes().get_cloned_ref(&added_node_id).expect("Added node is not added");
|
2022-02-11 15:19:02 +03:00
|
|
|
assert_eq!(added_node.view.expression.value().to_string(), "");
|
|
|
|
}
|
2022-02-22 19:43:37 +03:00
|
|
|
|
|
|
|
#[wasm_bindgen_test]
|
|
|
|
async fn debug_mode() {
|
|
|
|
let test = IntegrationTestOnNewProject::setup().await;
|
|
|
|
let project = test.project_view();
|
|
|
|
let graph_editor = test.graph_editor();
|
|
|
|
|
|
|
|
assert!(!graph_editor.debug_mode.value());
|
|
|
|
|
|
|
|
// Turning On
|
|
|
|
let expect_mode = project.debug_mode.next_event();
|
|
|
|
let expect_popup_message = project.debug_mode_popup().label().show.next_event();
|
|
|
|
project.enable_debug_mode();
|
|
|
|
assert!(expect_mode.expect());
|
|
|
|
let message = expect_popup_message.expect();
|
|
|
|
assert!(
|
|
|
|
message.contains("Debug Mode enabled"),
|
|
|
|
"Message \"{}\" does not mention enabling Debug mode",
|
|
|
|
message
|
|
|
|
);
|
|
|
|
assert!(
|
|
|
|
message.contains(enso_gui::view::debug_mode_popup::DEBUG_MODE_SHORTCUT),
|
|
|
|
"Message \"{}\" does not inform about shortcut to turn mode off",
|
|
|
|
message
|
|
|
|
);
|
|
|
|
assert!(graph_editor.debug_mode.value());
|
|
|
|
|
|
|
|
// Turning Off
|
|
|
|
let expect_mode = project.debug_mode.next_event();
|
|
|
|
let expect_popup_message = project.debug_mode_popup().label().show.next_event();
|
|
|
|
project.disable_debug_mode();
|
|
|
|
assert!(!expect_mode.expect());
|
|
|
|
let message = expect_popup_message.expect();
|
|
|
|
assert!(
|
|
|
|
message.contains("Debug Mode disabled"),
|
|
|
|
"Message \"{}\" does not mention disabling of debug mode",
|
|
|
|
message
|
|
|
|
);
|
|
|
|
assert!(!graph_editor.debug_mode.value());
|
|
|
|
}
|
|
|
|
|
|
|
|
#[wasm_bindgen_test]
|
|
|
|
async fn zooming() {
|
|
|
|
let test = IntegrationTestOnNewProject::setup().await;
|
|
|
|
let project = test.project_view();
|
|
|
|
let graph_editor = test.graph_editor();
|
2022-03-04 17:13:23 +03:00
|
|
|
let camera = test.ide.ensogl_app.display.default_scene.layers.main.camera();
|
2022-02-22 19:43:37 +03:00
|
|
|
let navigator = &graph_editor.model.navigator;
|
|
|
|
|
|
|
|
let zoom_on_center = |amount: f32| ZoomEvent { focus: Vector2(0.0, 0.0), amount };
|
|
|
|
let zoom_duration_ms = Duration::from_millis(1000);
|
|
|
|
|
|
|
|
// Without debug mode
|
|
|
|
navigator.emit_zoom_event(zoom_on_center(-1.0));
|
|
|
|
sleep(zoom_duration_ms).await;
|
|
|
|
assert_abs_diff_eq!(camera.zoom(), 1.0, epsilon = 0.001);
|
|
|
|
navigator.emit_zoom_event(zoom_on_center(1.0));
|
|
|
|
sleep(zoom_duration_ms).await;
|
|
|
|
assert!(camera.zoom() < 1.0, "Camera zoom {} must be less than 1.0", camera.zoom());
|
|
|
|
navigator.emit_zoom_event(zoom_on_center(-2.0));
|
|
|
|
sleep(zoom_duration_ms).await;
|
|
|
|
assert_abs_diff_eq!(camera.zoom(), 1.0, epsilon = 0.001);
|
|
|
|
|
|
|
|
// With debug mode
|
|
|
|
project.enable_debug_mode();
|
|
|
|
navigator.emit_zoom_event(zoom_on_center(-1.0));
|
|
|
|
sleep(zoom_duration_ms).await;
|
|
|
|
assert!(camera.zoom() > 1.0, "Camera zoom {} must be greater than 1.0", camera.zoom());
|
|
|
|
navigator.emit_zoom_event(zoom_on_center(5.0));
|
|
|
|
sleep(zoom_duration_ms).await;
|
|
|
|
assert!(camera.zoom() < 1.0, "Camera zoom {} must be less than 1.0", camera.zoom());
|
|
|
|
navigator.emit_zoom_event(zoom_on_center(-5.0));
|
|
|
|
sleep(zoom_duration_ms).await;
|
|
|
|
assert!(camera.zoom() > 1.0, "Camera zoom {} must be greater than 1.0", camera.zoom());
|
|
|
|
}
|
2022-03-16 21:02:47 +03:00
|
|
|
|
|
|
|
#[wasm_bindgen_test]
|
|
|
|
async fn adding_node_with_add_node_button() {
|
|
|
|
const INITIAL_NODE_COUNT: usize = 2;
|
|
|
|
let test = IntegrationTestOnNewProject::setup().await;
|
|
|
|
let graph_editor = test.graph_editor();
|
|
|
|
let scene = &test.ide.ensogl_app.display.default_scene;
|
|
|
|
|
2022-03-30 15:49:07 +03:00
|
|
|
let nodes = graph_editor.nodes().all.keys();
|
2022-03-16 21:02:47 +03:00
|
|
|
let nodes_positions = nodes.into_iter().flat_map(|id| graph_editor.model.get_node_position(id));
|
|
|
|
let mut sorted_positions = nodes_positions.sorted_by_key(|pos| OrderedFloat(pos.y));
|
|
|
|
let bottom_most_pos =
|
|
|
|
sorted_positions.next().expect("Default project does not contain any nodes");
|
|
|
|
|
|
|
|
// Node is created below the bottom-most one.
|
2022-03-21 18:08:17 +03:00
|
|
|
let (first_node_id, node_source, _) = add_node_with_add_node_button(&graph_editor, "1 + 1");
|
2022-03-16 21:02:47 +03:00
|
|
|
assert!(node_source.is_none());
|
2022-03-30 15:49:07 +03:00
|
|
|
assert_eq!(graph_editor.nodes().all.len(), INITIAL_NODE_COUNT + 1);
|
2022-03-16 21:02:47 +03:00
|
|
|
let node_position =
|
|
|
|
graph_editor.model.get_node_position(first_node_id).expect("Node was not added");
|
|
|
|
assert!(
|
|
|
|
node_position.y < bottom_most_pos.y,
|
|
|
|
"Expected that {node_position}.y < {bottom_most_pos}.y"
|
|
|
|
);
|
|
|
|
|
|
|
|
// Selected node is used as a `source` node.
|
2022-03-30 15:49:07 +03:00
|
|
|
graph_editor.nodes().deselect_all();
|
|
|
|
graph_editor.nodes().select(first_node_id);
|
2022-03-21 18:08:17 +03:00
|
|
|
let (_, node_source, _) = add_node_with_add_node_button(&graph_editor, "+ 1");
|
2022-03-16 21:02:47 +03:00
|
|
|
assert_eq!(node_source, Some(NodeSource { node: first_node_id }));
|
2022-03-30 15:49:07 +03:00
|
|
|
assert_eq!(graph_editor.nodes().all.len(), INITIAL_NODE_COUNT + 2);
|
2022-03-16 21:02:47 +03:00
|
|
|
|
|
|
|
// If there is a free space, the new node is created in the center of screen.
|
|
|
|
let camera = scene.layers.main.camera();
|
|
|
|
camera.mod_position_xy(|pos| pos + Vector2(1000.0, 1000.0));
|
|
|
|
let wait_for_update = Duration::from_millis(500);
|
|
|
|
sleep(wait_for_update).await;
|
2022-03-30 15:49:07 +03:00
|
|
|
graph_editor.nodes().deselect_all();
|
2022-03-21 18:08:17 +03:00
|
|
|
let (node_id, node_source, _) = add_node_with_add_node_button(&graph_editor, "1");
|
2022-03-16 21:02:47 +03:00
|
|
|
assert!(node_source.is_none());
|
2022-03-30 15:49:07 +03:00
|
|
|
assert_eq!(graph_editor.nodes().all.len(), INITIAL_NODE_COUNT + 3);
|
2022-03-31 17:16:28 +03:00
|
|
|
let node_position = graph_editor.model.get_node_position(node_id).expect(
|
|
|
|
"Node was not
|
|
|
|
added",
|
|
|
|
);
|
2022-03-16 21:02:47 +03:00
|
|
|
let center_of_screen = scene.screen_to_scene_coordinates(Vector3::zeros());
|
|
|
|
assert_abs_diff_eq!(node_position.x, center_of_screen.x, epsilon = 10.0);
|
|
|
|
assert_abs_diff_eq!(node_position.y, center_of_screen.y, epsilon = 10.0);
|
|
|
|
}
|
|
|
|
|
2022-03-21 18:08:17 +03:00
|
|
|
#[wasm_bindgen_test]
|
|
|
|
async fn adding_node_by_clicking_on_the_output_port() {
|
|
|
|
let test = IntegrationTestOnNewProject::setup().await;
|
|
|
|
let graph_editor = test.graph_editor();
|
|
|
|
let (node_1_id, _, node_1) = add_node_with_internal_api(&graph_editor, "1 + 1");
|
|
|
|
|
|
|
|
let method = |editor: &GraphEditor| {
|
2022-03-30 15:49:07 +03:00
|
|
|
let port = node_1.model.output_port_shape().expect("No output port");
|
|
|
|
port.events.mouse_over.emit(());
|
2022-03-21 18:08:17 +03:00
|
|
|
editor.start_node_creation_from_port();
|
|
|
|
};
|
|
|
|
let (_, source, node_2) = add_node(&graph_editor, "+ 1", method);
|
|
|
|
|
|
|
|
assert_eq!(source.unwrap(), NodeSource { node: node_1_id });
|
|
|
|
assert!(node_2.position().y < node_1.position().y);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn add_node(
|
2022-03-16 21:02:47 +03:00
|
|
|
graph_editor: &GraphEditor,
|
|
|
|
expression: &str,
|
2022-03-21 18:08:17 +03:00
|
|
|
method: impl Fn(&GraphEditor),
|
|
|
|
) -> (NodeId, Option<NodeSource>, Node) {
|
2022-03-16 21:02:47 +03:00
|
|
|
let node_added = graph_editor.node_added.next_event();
|
2022-03-21 18:08:17 +03:00
|
|
|
method(graph_editor);
|
2022-03-16 21:02:47 +03:00
|
|
|
let (node_id, source_node, _) = node_added.expect();
|
2022-03-30 15:49:07 +03:00
|
|
|
let node = graph_editor.nodes().get_cloned_ref(&node_id).expect("Node was not added");
|
2022-03-16 21:02:47 +03:00
|
|
|
node.set_expression(Expression::new_plain(expression));
|
|
|
|
graph_editor.stop_editing();
|
2022-03-21 18:08:17 +03:00
|
|
|
(node_id, source_node, node)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn add_node_with_internal_api(
|
|
|
|
graph_editor: &GraphEditor,
|
|
|
|
expression: &str,
|
|
|
|
) -> (NodeId, Option<NodeSource>, Node) {
|
|
|
|
let method = |editor: &GraphEditor| editor.add_node();
|
|
|
|
add_node(graph_editor, expression, method)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn add_node_with_add_node_button(
|
|
|
|
graph_editor: &GraphEditor,
|
|
|
|
expression: &str,
|
|
|
|
) -> (NodeId, Option<NodeSource>, Node) {
|
|
|
|
let add_node_button = &graph_editor.model.add_node_button;
|
|
|
|
let method = |_: &GraphEditor| add_node_button.click();
|
|
|
|
add_node(graph_editor, expression, method)
|
2022-03-16 21:02:47 +03:00
|
|
|
}
|
2022-03-31 17:16:28 +03:00
|
|
|
|
|
|
|
#[wasm_bindgen_test]
|
|
|
|
async fn mouse_oriented_node_placement() {
|
|
|
|
struct Case {
|
|
|
|
scene: Scene,
|
|
|
|
graph_editor: GraphEditor,
|
|
|
|
source_node: Node,
|
|
|
|
mouse_position: Vector2,
|
|
|
|
expected_position: Vector2,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Case {
|
|
|
|
fn run(&self) {
|
|
|
|
self.check_tab_key();
|
|
|
|
self.check_edge_drop();
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check_searcher_opening_place(
|
|
|
|
&self,
|
|
|
|
added_node: FutureEvent<(NodeId, Option<NodeSource>, bool)>,
|
|
|
|
) {
|
|
|
|
let (new_node_id, _, _) = added_node.expect();
|
|
|
|
let new_node_pos =
|
|
|
|
self.graph_editor.model.get_node_position(new_node_id).map(|v| v.xy());
|
|
|
|
assert_eq!(new_node_pos, Some(self.expected_position));
|
|
|
|
self.graph_editor.stop_editing();
|
|
|
|
assert_eq!(self.graph_editor.model.nodes.all.len(), 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check_tab_key(&self) {
|
|
|
|
self.scene.mouse.frp.position.emit(self.mouse_position);
|
|
|
|
let added_node = self.graph_editor.node_added.next_event();
|
|
|
|
self.graph_editor.start_node_creation();
|
|
|
|
self.check_searcher_opening_place(added_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check_edge_drop(&self) {
|
|
|
|
let port = self.source_node.view.model.output_port_shape().unwrap();
|
|
|
|
port.events.mouse_down.emit(PrimaryButton);
|
|
|
|
port.events.mouse_up.emit(PrimaryButton);
|
|
|
|
self.scene.mouse.frp.position.emit(self.mouse_position);
|
|
|
|
assert!(
|
|
|
|
self.graph_editor.has_detached_edge.value(),
|
|
|
|
"No detached edge after clicking port"
|
|
|
|
);
|
|
|
|
let added_node = self.graph_editor.node_added.next_event();
|
|
|
|
self.scene.mouse.click_on_background();
|
|
|
|
self.check_searcher_opening_place(added_node);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let test = IntegrationTestOnNewProject::setup().await;
|
|
|
|
let scene = &test.ide.ensogl_app.display.default_scene;
|
|
|
|
let graph_editor = test.graph_editor();
|
|
|
|
let gap_x = graph_editor.default_x_gap_between_nodes.value();
|
|
|
|
let gap_y = graph_editor.default_y_gap_between_nodes.value();
|
|
|
|
let min_spacing = graph_editor.min_x_spacing_for_new_nodes.value();
|
|
|
|
|
|
|
|
let InitialNodes { above, below } = InitialNodes::obtain_from_graph_editor(&graph_editor);
|
|
|
|
|
|
|
|
let create_case =
|
|
|
|
|source_node: &Node, mouse_position: Vector2, expected_position: Vector2| Case {
|
|
|
|
scene: scene.clone_ref(),
|
|
|
|
graph_editor: graph_editor.clone_ref(),
|
|
|
|
source_node: source_node.clone_ref(),
|
|
|
|
mouse_position,
|
|
|
|
expected_position,
|
|
|
|
};
|
|
|
|
|
|
|
|
let far_away = below.position().xy() + Vector2(500.0, 500.0);
|
|
|
|
let far_away_expect = far_away;
|
|
|
|
create_case(&below, far_away, far_away_expect).run();
|
|
|
|
|
|
|
|
let under_below = below.position().xy() + Vector2(30.0, -15.0);
|
|
|
|
let under_below_expect = below.position().xy() + Vector2(0.0, -gap_y - node_view::HEIGHT);
|
|
|
|
create_case(&below, under_below, under_below_expect).run();
|
|
|
|
|
|
|
|
let under_above = above.position().xy() + Vector2(30.0, 15.0);
|
|
|
|
let under_above_expect = Vector2(
|
|
|
|
below.position().x - gap_x - min_spacing,
|
|
|
|
above.position().y - gap_y - node_view::HEIGHT,
|
|
|
|
);
|
|
|
|
create_case(&above, under_above, under_above_expect).run();
|
|
|
|
}
|
|
|
|
|
|
|
|
struct InitialNodes {
|
|
|
|
above: graph_editor::Node,
|
|
|
|
below: graph_editor::Node,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl InitialNodes {
|
|
|
|
fn obtain_from_graph_editor(graph_editor: &GraphEditor) -> Self {
|
|
|
|
let nodes = graph_editor.model.nodes.all.values();
|
|
|
|
let mut sorted = nodes.into_iter().sorted_by_key(|node| OrderedFloat(node.position().y));
|
|
|
|
match (sorted.next(), sorted.next()) {
|
|
|
|
(Some(below), Some(above)) => Self { above, below },
|
|
|
|
_ => panic!("Expected two nodes in initial Graph Editor"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|