webdriverbidi 0.2.2

WebDriver BiDi client implementation in Rust.
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

use serde::{Deserialize, Serialize};

use crate::error::CommandError;
use crate::session::WebDriverBiDiSession;

/// Send a command to the WebDriver BiDi session and processes the result.
pub async fn send_command<C, R>(
    session: &mut WebDriverBiDiSession,
    command: C,
) -> Result<R, CommandError>
where
    C: Serialize,
    R: for<'de> Deserialize<'de>,
{
    match session.send_command::<C, R>(command).await {
        Ok(rslt) => {
            // debug!("Command with id: {} succeeded", command_id); // Log success
            Ok(rslt)
        }
        Err(e) => {
            // error!("Command with id: {} failed: {:?}", command_id, e); // Log error
            Err(e)
        }
    }
}

/// Macro to define a WebDriver BiDi command.
///
/// This macro generates a struct representing the command, an implementation block
/// to create a new instance of the command, and an asynchronous function to send
/// the command to the WebDriver BiDi session.
///
/// # Parameters
///
/// - `$cmd_name`: The name of the command struct to be generated.
/// - `$cmd_type`: The type of the command parameters.
/// - `$params_type`: The type of the parameters passed to the command.
/// - `$fn_name`: The name of the function to send the command.
/// - `$result_type`: The type of the result returned by the command.
#[macro_export]
macro_rules! define_command {
    ($cmd_name:ident, $cmd_type:ty, $params_type:ty, $fn_name:ident, $result_type:ty) => {
        #[derive(Debug, Serialize, Deserialize)]
        struct $cmd_name {
            id: u64,
            #[serde(flatten)]
            params: $cmd_type,
        }

        impl $cmd_name {
            fn new(params: $params_type) -> Self {
                let id = id::get_next_id();
                // debug!("Creating {} with id: {}", $cmd_str, id);
                let params = <$cmd_type>::new(params);
                Self { id, params }
            }
        }

        pub async fn $fn_name(
            session: &mut WebDriverBiDiSession,
            params: $params_type,
        ) -> Result<$result_type, CommandError> {
            let cmd = $cmd_name::new(params);
            utils::send_command(session, cmd).await
        }
    };
}