Skip to main content

yew_e2e/test_driver/
drag.rs

1//! Carrying one element onto another, with the pointer or through the HTML
2//! drag handlers.
3
4use anyhow::Result;
5
6use crate::{TestDriver, TestElement};
7
8impl TestDriver {
9    /// **Carry one element over another with the pointer, the way a hand
10    /// does, and keep hold**: press on it, move off in small steps so the
11    /// browser starts its own drag, and come to rest over the target. Unlike
12    /// [`Self::drag_over`] nothing is dispatched, so whatever stops the browser
13    /// starting a drag, or a target taking one, stops this too. Let go with
14    /// [`Self::native_release`].
15    pub async fn native_drag_over(&self, from: &TestElement, to: &TestElement) -> Result<()> {
16        tracing::trace!("Carrying one element over another with the pointer");
17
18        from.inner.scroll_into_view().await?;
19
20        self.inner
21            .action_chain()
22            .move_to_element_center(&from.inner)
23            .click_and_hold()
24            .move_by_offset(4, 0)
25            .move_by_offset(8, 2)
26            .move_by_offset(16, 4)
27            .move_to_element_center(&to.inner)
28            .move_by_offset(2, 0)
29            .perform()
30            .await?;
31        self.holding.set(true);
32
33        Ok(())
34    }
35
36    /// Let go of what [`Self::native_drag_over`] is holding, where it is.
37    pub async fn native_release(&self) -> Result<()> {
38        self.inner
39            .action_chain()
40            .move_by_offset(1, 0)
41            .release()
42            .perform()
43            .await?;
44        self.holding.set(false);
45        Ok(())
46    }
47
48    /// Load real local files into a browser FileList without starting an import.
49    pub async fn external_files(&self, paths: &str) -> Result<TestElement> {
50        self.inner.execute("const input = document.createElement('input'); input.type = 'file'; input.multiple = true; input.hidden = true; input.dataset.test = 'external-files'; document.body.appendChild(input);", Vec::new()).await?;
51        let input = self.find_one_by("[data-test='external-files']").await?;
52        input.send_keys(paths).await?;
53        Ok(input)
54    }
55
56    /// Dispatch the browser file payload onto a drop target; report cancellation.
57    pub async fn drag_external_files(
58        &self,
59        files: &TestElement,
60        to: &TestElement,
61        kind: &str,
62    ) -> Result<bool> {
63        let result = self.inner.execute("const data = new DataTransfer(); for (const file of arguments[0].files) data.items.add(file); const event = new DragEvent(arguments[2], {dataTransfer: data, bubbles: true, cancelable: true}); arguments[1].dispatchEvent(event); return event.defaultPrevented;", vec![files.inner.to_json()?, to.inner.to_json()?, kind.into()]).await?;
64        Ok(serde_json::from_value(result.json().clone())?)
65    }
66
67    /// Carry one element onto another through its HTML drag handlers.
68    pub async fn drag_onto(&self, from: &TestElement, to: &TestElement) -> Result<()> {
69        tracing::trace!("Carrying one element onto another");
70
71        let script = "const data = new DataTransfer(); \
72             const fire = (node, kind) => node.dispatchEvent( \
73                 new DragEvent(kind, \
74                     { dataTransfer: data, bubbles: true, cancelable: true })); \
75             fire(arguments[0], 'dragstart'); \
76             fire(arguments[1], 'dragover'); \
77             fire(arguments[1], 'drop'); \
78             fire(arguments[0], 'dragend');";
79
80        self.inner
81            .execute(script, vec![from.inner.to_json()?, to.inner.to_json()?])
82            .await?;
83
84        Ok(())
85    }
86
87    /// Carry one element over another without letting go, so that what the
88    /// controller says about the offer can be read.
89    pub async fn drag_over(&self, from: &TestElement, to: &TestElement) -> Result<()> {
90        tracing::trace!("Carrying one element over another");
91
92        let script = "const data = new DataTransfer(); \
93             const fire = (node, kind) => node.dispatchEvent( \
94                 new DragEvent(kind, \
95                     { dataTransfer: data, bubbles: true, cancelable: true })); \
96             fire(arguments[0], 'dragstart'); \
97             fire(arguments[1], 'dragover');";
98
99        self.inner
100            .execute(script, vec![from.inner.to_json()?, to.inner.to_json()?])
101            .await?;
102
103        Ok(())
104    }
105
106    /// Carry a drag in progress back off the element it was over, which is the
107    /// `dragleave` a browser sends and neither [`Self::drag_over`] nor
108    /// [`Self::drag_onto`] does: both begin their own drag, so this is handed
109    /// the element the carry is leaving and nothing else.
110    pub async fn drag_off(&self, left: &TestElement) -> Result<()> {
111        tracing::trace!("Carrying a drag back off an element");
112
113        let script = "const data = new DataTransfer(); \
114             arguments[0].dispatchEvent( \
115                 new DragEvent('dragleave', \
116                     { dataTransfer: data, bubbles: true, cancelable: true }));";
117
118        self.inner
119            .execute(script, vec![left.inner.to_json()?])
120            .await?;
121
122        Ok(())
123    }
124}