iced_test/

instruction.rs

//! A step in an end-to-end test.
use crate::core::keyboard;
use crate::core::mouse;
use crate::core::{Event, Point};
use crate::simulator;

use std::fmt;

/// A step in an end-to-end test.
///
/// An [`Instruction`] can be run by an [`Emulator`](crate::Emulator).
#[derive(Debug, Clone, PartialEq)]
pub enum Instruction {
    /// A user [`Interaction`].
    Interact(Interaction),
    /// A testing [`Expectation`].
    Expect(Expectation),
}

impl Instruction {
    /// Parses an [`Instruction`] from its textual representation.
    pub fn parse(line: &str) -> Result<Self, ParseError> {
        parser::run(line)
    }
}

impl fmt::Display for Instruction {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Instruction::Interact(interaction) => interaction.fmt(f),
            Instruction::Expect(expectation) => expectation.fmt(f),
        }
    }
}

/// A user interaction.
#[derive(Debug, Clone, PartialEq)]
pub enum Interaction {
    /// A mouse interaction.
    Mouse(Mouse),
    /// A keyboard interaction.
    Keyboard(Keyboard),
}

impl Interaction {
    /// Creates an [`Interaction`] from a runtime [`Event`].
    ///
    /// This can be useful for recording tests during real usage.
    pub fn from_event(event: &Event) -> Option<Self> {
        Some(match event {
            Event::Mouse(mouse) => Self::Mouse(match mouse {
                mouse::Event::CursorMoved { position } => Mouse::Move(Target::Point(*position)),
                mouse::Event::ButtonPressed(button) => Mouse::Press {
                    button: *button,
                    target: None,
                },
                mouse::Event::ButtonReleased(button) => Mouse::Release {
                    button: *button,
                    target: None,
                },
                _ => None?,
            }),
            Event::Keyboard(keyboard) => Self::Keyboard(match keyboard {
                keyboard::Event::KeyPressed { key, text, .. } => match key {
                    keyboard::Key::Named(keyboard::key::Named::Enter) => {
                        Keyboard::Press(Key::Enter)
                    }
                    keyboard::Key::Named(keyboard::key::Named::Escape) => {
                        Keyboard::Press(Key::Escape)
                    }
                    keyboard::Key::Named(keyboard::key::Named::Tab) => Keyboard::Press(Key::Tab),
                    keyboard::Key::Named(keyboard::key::Named::Backspace) => {
                        Keyboard::Press(Key::Backspace)
                    }
                    _ => Keyboard::Typewrite(text.as_ref()?.to_string()),
                },
                keyboard::Event::KeyReleased { key, .. } => match key {
                    keyboard::Key::Named(keyboard::key::Named::Enter) => {
                        Keyboard::Release(Key::Enter)
                    }
                    keyboard::Key::Named(keyboard::key::Named::Escape) => {
                        Keyboard::Release(Key::Escape)
                    }
                    keyboard::Key::Named(keyboard::key::Named::Tab) => Keyboard::Release(Key::Tab),
                    keyboard::Key::Named(keyboard::key::Named::Backspace) => {
                        Keyboard::Release(Key::Backspace)
                    }
                    _ => None?,
                },
                keyboard::Event::ModifiersChanged(_) => None?,
            }),
            _ => None?,
        })
    }

    /// Merges two interactions together, if possible.
    ///
    /// This method can turn certain sequences of interactions into a single one.
    /// For instance, a mouse movement, left button press, and left button release
    /// can all be merged into a single click interaction.
    ///
    /// Merging is lossy and, therefore, it is not always desirable if you are recording
    /// a test and want full reproducibility.
    ///
    /// If the interactions cannot be merged, the `next` interaction will be
    /// returned as the second element of the tuple.
    pub fn merge(self, next: Self) -> (Self, Option<Self>) {
        match (self, next) {
            (Self::Mouse(current), Self::Mouse(next)) => match (current, next) {
                (Mouse::Move(_), Mouse::Move(to)) => (Self::Mouse(Mouse::Move(to)), None),
                (
                    Mouse::Move(to),
                    Mouse::Press {
                        button,
                        target: None,
                    },
                ) => (
                    Self::Mouse(Mouse::Press {
                        button,
                        target: Some(to),
                    }),
                    None,
                ),
                (
                    Mouse::Move(to),
                    Mouse::Release {
                        button,
                        target: None,
                    },
                ) => (
                    Self::Mouse(Mouse::Release {
                        button,
                        target: Some(to),
                    }),
                    None,
                ),
                (
                    Mouse::Press {
                        button: press,
                        target: press_at,
                    },
                    Mouse::Release {
                        button: release,
                        target: release_at,
                    },
                ) if press == release
                    && release_at
                        .as_ref()
                        .is_none_or(|release_at| Some(release_at) == press_at.as_ref()) =>
                {
                    (
                        Self::Mouse(Mouse::Click {
                            button: press,
                            target: press_at,
                        }),
                        None,
                    )
                }
                (
                    Mouse::Press {
                        button,
                        target: Some(press_at),
                    },
                    Mouse::Move(move_at),
                ) if press_at == move_at => (
                    Self::Mouse(Mouse::Press {
                        button,
                        target: Some(press_at),
                    }),
                    None,
                ),
                (
                    Mouse::Click {
                        button,
                        target: Some(click_at),
                    },
                    Mouse::Move(move_at),
                ) if click_at == move_at => (
                    Self::Mouse(Mouse::Click {
                        button,
                        target: Some(click_at),
                    }),
                    None,
                ),
                (current, next) => (Self::Mouse(current), Some(Self::Mouse(next))),
            },
            (Self::Keyboard(current), Self::Keyboard(next)) => match (current, next) {
                (Keyboard::Typewrite(current), Keyboard::Typewrite(next)) => (
                    Self::Keyboard(Keyboard::Typewrite(format!("{current}{next}"))),
                    None,
                ),
                (Keyboard::Press(current), Keyboard::Release(next)) if current == next => {
                    (Self::Keyboard(Keyboard::Type(current)), None)
                }
                (current, next) => (Self::Keyboard(current), Some(Self::Keyboard(next))),
            },
            (current, next) => (current, Some(next)),
        }
    }

    /// Returns a list of runtime events representing the [`Interaction`].
    ///
    /// The `find_target` closure must convert a [`Target`] into its screen
    /// coordinates.
    pub fn events(&self, find_target: impl FnOnce(&Target) -> Option<Point>) -> Option<Vec<Event>> {
        let mouse_move_ = |to| Event::Mouse(mouse::Event::CursorMoved { position: to });

        let mouse_press = |button| Event::Mouse(mouse::Event::ButtonPressed(button));

        let mouse_release = |button| Event::Mouse(mouse::Event::ButtonReleased(button));

        let key_press = |key| simulator::press_key(key, None);

        let key_release = |key| simulator::release_key(key);

        Some(match self {
            Interaction::Mouse(mouse) => match mouse {
                Mouse::Move(to) => vec![mouse_move_(find_target(to)?)],
                Mouse::Press {
                    button,
                    target: Some(at),
                } => vec![mouse_move_(find_target(at)?), mouse_press(*button)],
                Mouse::Press {
                    button,
                    target: None,
                } => {
                    vec![mouse_press(*button)]
                }
                Mouse::Release {
                    button,
                    target: Some(at),
                } => {
                    vec![mouse_move_(find_target(at)?), mouse_release(*button)]
                }
                Mouse::Release {
                    button,
                    target: None,
                } => {
                    vec![mouse_release(*button)]
                }
                Mouse::Click {
                    button,
                    target: Some(at),
                } => {
                    vec![
                        mouse_move_(find_target(at)?),
                        mouse_press(*button),
                        mouse_release(*button),
                    ]
                }
                Mouse::Click {
                    button,
                    target: None,
                } => {
                    vec![mouse_press(*button), mouse_release(*button)]
                }
            },
            Interaction::Keyboard(keyboard) => match keyboard {
                Keyboard::Press(key) => vec![key_press(*key)],
                Keyboard::Release(key) => vec![key_release(*key)],
                Keyboard::Type(key) => vec![key_press(*key), key_release(*key)],
                Keyboard::Typewrite(text) => simulator::typewrite(text).collect(),
            },
        })
    }
}

impl fmt::Display for Interaction {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Interaction::Mouse(mouse) => mouse.fmt(f),
            Interaction::Keyboard(keyboard) => keyboard.fmt(f),
        }
    }
}

/// A mouse interaction.
#[derive(Debug, Clone, PartialEq)]
pub enum Mouse {
    /// The mouse was moved.
    Move(Target),
    /// A button was pressed.
    Press {
        /// The button.
        button: mouse::Button,
        /// The location of the press.
        target: Option<Target>,
    },
    /// A button was released.
    Release {
        /// The button.
        button: mouse::Button,
        /// The location of the release.
        target: Option<Target>,
    },
    /// A button was clicked.
    Click {
        /// The button.
        button: mouse::Button,
        /// The location of the click.
        target: Option<Target>,
    },
}

impl fmt::Display for Mouse {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Mouse::Move(target) => {
                write!(f, "move {}", target)
            }
            Mouse::Press { button, target } => {
                write!(f, "press {}", format::button_at(*button, target.as_ref()))
            }
            Mouse::Release { button, target } => {
                write!(f, "release {}", format::button_at(*button, target.as_ref()))
            }
            Mouse::Click { button, target } => {
                write!(f, "click {}", format::button_at(*button, target.as_ref()))
            }
        }
    }
}

/// The target of an interaction.
#[derive(Debug, Clone, PartialEq)]
pub enum Target {
    /// A specific point of the viewport.
    Point(Point),
    /// A UI element containing the given text.
    Text(String),
}

impl fmt::Display for Target {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Point(point) => f.write_str(&format::point(*point)),
            Self::Text(text) => f.write_str(&format::string(text)),
        }
    }
}

/// A keyboard interaction.
#[derive(Debug, Clone, PartialEq)]
pub enum Keyboard {
    /// A key was pressed.
    Press(Key),
    /// A key was released.
    Release(Key),
    /// A key was "typed" (press and released).
    Type(Key),
    /// A bunch of text was typed.
    Typewrite(String),
}

impl fmt::Display for Keyboard {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Keyboard::Press(key) => {
                write!(f, "press {}", format::key(*key))
            }
            Keyboard::Release(key) => {
                write!(f, "release {}", format::key(*key))
            }
            Keyboard::Type(key) => {
                write!(f, "type {}", format::key(*key))
            }
            Keyboard::Typewrite(text) => {
                write!(f, "type \"{text}\"")
            }
        }
    }
}

/// A keyboard key.
///
/// Only a small subset of keys is supported currently!
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[allow(missing_docs)]
pub enum Key {
    Enter,
    Escape,
    Tab,
    Backspace,
}

impl From<Key> for keyboard::Key {
    fn from(key: Key) -> Self {
        match key {
            Key::Enter => Self::Named(keyboard::key::Named::Enter),
            Key::Escape => Self::Named(keyboard::key::Named::Escape),
            Key::Tab => Self::Named(keyboard::key::Named::Tab),
            Key::Backspace => Self::Named(keyboard::key::Named::Backspace),
        }
    }
}

mod format {
    use super::*;

    pub fn button_at(button: mouse::Button, at: Option<&Target>) -> String {
        let button = self::button(button);

        if let Some(at) = at {
            if button.is_empty() {
                at.to_string()
            } else {
                format!("{} {}", button, at)
            }
        } else {
            button.to_owned()
        }
    }

    pub fn button(button: mouse::Button) -> &'static str {
        match button {
            mouse::Button::Left => "",
            mouse::Button::Right => "right",
            mouse::Button::Middle => "middle",
            mouse::Button::Back => "back",
            mouse::Button::Forward => "forward",
            mouse::Button::Other(_) => "other",
        }
    }

    pub fn point(point: Point) -> String {
        format!("({:.2}, {:.2})", point.x, point.y)
    }

    pub fn key(key: Key) -> &'static str {
        match key {
            Key::Enter => "enter",
            Key::Escape => "escape",
            Key::Tab => "tab",
            Key::Backspace => "backspace",
        }
    }

    pub fn string(text: &str) -> String {
        format!("\"{}\"", text.escape_default())
    }
}

/// A testing assertion.
///
/// Expectations are instructions that verify the current state of
/// the user interface of an application.
#[derive(Debug, Clone, PartialEq)]
pub enum Expectation {
    /// Expect some element to contain some text.
    Text(String),
}

impl fmt::Display for Expectation {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Expectation::Text(text) => {
                write!(f, "expect {}", format::string(text))
            }
        }
    }
}

pub use parser::Error as ParseError;

mod parser {
    use super::*;

    use nom::branch::alt;
    use nom::bytes::complete::tag;
    use nom::bytes::{is_not, take_while_m_n};
    use nom::character::complete::{char, multispace0, multispace1};
    use nom::combinator::{map, map_opt, map_res, opt, success, value, verify};
    use nom::error::ParseError;
    use nom::multi::fold;
    use nom::number::float;
    use nom::sequence::{delimited, preceded, separated_pair};
    use nom::{Finish, IResult, Parser};

    /// A parsing error.
    #[derive(Debug, Clone, thiserror::Error)]
    #[error("parse error: {0}")]
    pub struct Error(nom::error::Error<String>);

    pub fn run(input: &str) -> Result<Instruction, Error> {
        match instruction.parse_complete(input).finish() {
            Ok((_rest, instruction)) => Ok(instruction),
            Err(error) => Err(Error(error.cloned())),
        }
    }

    fn instruction(input: &str) -> IResult<&str, Instruction> {
        alt((
            map(interaction, Instruction::Interact),
            map(expectation, Instruction::Expect),
        ))
        .parse(input)
    }

    fn interaction(input: &str) -> IResult<&str, Interaction> {
        alt((
            map(mouse, Interaction::Mouse),
            map(keyboard, Interaction::Keyboard),
        ))
        .parse(input)
    }

    fn mouse(input: &str) -> IResult<&str, Mouse> {
        let mouse_move = preceded(tag("move "), target).map(Mouse::Move);

        alt((mouse_move, mouse_click, mouse_press, mouse_release)).parse(input)
    }

    fn mouse_click(input: &str) -> IResult<&str, Mouse> {
        let (input, _) = tag("click ")(input)?;
        let (input, (button, target)) = mouse_button_at(input)?;

        Ok((input, Mouse::Click { button, target }))
    }

    fn mouse_press(input: &str) -> IResult<&str, Mouse> {
        let (input, _) = tag("press ")(input)?;
        let (input, (button, target)) = mouse_button_at(input)?;

        Ok((input, Mouse::Press { button, target }))
    }

    fn mouse_release(input: &str) -> IResult<&str, Mouse> {
        let (input, _) = tag("release ")(input)?;
        let (input, (button, target)) = mouse_button_at(input)?;

        Ok((input, Mouse::Release { button, target }))
    }

    fn mouse_button_at(input: &str) -> IResult<&str, (mouse::Button, Option<Target>)> {
        let (input, button) = mouse_button(input)?;
        let (input, at) = opt(target).parse(input)?;

        Ok((input, (button, at)))
    }

    fn target(input: &str) -> IResult<&str, Target> {
        alt((string.map(Target::Text), point.map(Target::Point))).parse(input)
    }

    fn mouse_button(input: &str) -> IResult<&str, mouse::Button> {
        alt((
            tag("right").map(|_| mouse::Button::Right),
            success(mouse::Button::Left),
        ))
        .parse(input)
    }

    fn keyboard(input: &str) -> IResult<&str, Keyboard> {
        alt((
            map(preceded(tag("type "), string), Keyboard::Typewrite),
            map(preceded(tag("type "), key), Keyboard::Type),
        ))
        .parse(input)
    }

    fn expectation(input: &str) -> IResult<&str, Expectation> {
        map(preceded(tag("expect "), string), |text| {
            Expectation::Text(text)
        })
        .parse(input)
    }

    fn key(input: &str) -> IResult<&str, Key> {
        alt((
            map(tag("enter"), |_| Key::Enter),
            map(tag("escape"), |_| Key::Escape),
            map(tag("tab"), |_| Key::Tab),
            map(tag("backspace"), |_| Key::Backspace),
        ))
        .parse(input)
    }

    fn point(input: &str) -> IResult<&str, Point> {
        let comma = whitespace(char(','));

        map(
            delimited(
                char('('),
                separated_pair(float(), comma, float()),
                char(')'),
            ),
            |(x, y)| Point { x, y },
        )
        .parse(input)
    }

    pub fn whitespace<'a, O, E: ParseError<&'a str>, F>(
        inner: F,
    ) -> impl Parser<&'a str, Output = O, Error = E>
    where
        F: Parser<&'a str, Output = O, Error = E>,
    {
        delimited(multispace0, inner, multispace0)
    }

    // Taken from https://github.com/rust-bakery/nom/blob/51c3c4e44fa78a8a09b413419372b97b2cc2a787/examples/string.rs
    //
    // Copyright (c) 2014-2019 Geoffroy Couprie
    //
    // Permission is hereby granted, free of charge, to any person obtaining
    // a copy of this software and associated documentation files (the
    // "Software"), to deal in the Software without restriction, including
    // without limitation the rights to use, copy, modify, merge, publish,
    // distribute, sublicense, and/or sell copies of the Software, and to
    // permit persons to whom the Software is furnished to do so, subject to
    // the following conditions:
    //
    // The above copyright notice and this permission notice shall be
    // included in all copies or substantial portions of the Software.
    //
    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
    // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
    // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
    // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
    // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
    // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    fn string(input: &str) -> IResult<&str, String> {
        #[derive(Debug, Clone, Copy)]
        enum Fragment<'a> {
            Literal(&'a str),
            EscapedChar(char),
            EscapedWS,
        }

        fn fragment(input: &str) -> IResult<&str, Fragment<'_>> {
            alt((
                map(string_literal, Fragment::Literal),
                map(escaped_char, Fragment::EscapedChar),
                value(Fragment::EscapedWS, escaped_whitespace),
            ))
            .parse(input)
        }

        fn string_literal<'a, E: ParseError<&'a str>>(
            input: &'a str,
        ) -> IResult<&'a str, &'a str, E> {
            let not_quote_slash = is_not("\"\\");

            verify(not_quote_slash, |s: &str| !s.is_empty()).parse(input)
        }

        fn unicode(input: &str) -> IResult<&str, char> {
            let parse_hex = take_while_m_n(1, 6, |c: char| c.is_ascii_hexdigit());

            let parse_delimited_hex =
                preceded(char('u'), delimited(char('{'), parse_hex, char('}')));

            let parse_u32 = map_res(parse_delimited_hex, move |hex| u32::from_str_radix(hex, 16));

            map_opt(parse_u32, std::char::from_u32).parse(input)
        }

        fn escaped_char(input: &str) -> IResult<&str, char> {
            preceded(
                char('\\'),
                alt((
                    unicode,
                    value('\n', char('n')),
                    value('\r', char('r')),
                    value('\t', char('t')),
                    value('\u{08}', char('b')),
                    value('\u{0C}', char('f')),
                    value('\\', char('\\')),
                    value('/', char('/')),
                    value('"', char('"')),
                )),
            )
            .parse(input)
        }

        fn escaped_whitespace(input: &str) -> IResult<&str, &str> {
            preceded(char('\\'), multispace1).parse(input)
        }

        let build_string = fold(0.., fragment, String::new, |mut string, fragment| {
            match fragment {
                Fragment::Literal(s) => string.push_str(s),
                Fragment::EscapedChar(c) => string.push(c),
                Fragment::EscapedWS => {}
            }
            string
        });

        delimited(char('"'), build_string, char('"')).parse(input)
    }
}