selenium_webdriver 0.1.7

A crate to interact with the selenium server and write automated UI scripts and tests
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

///Utility struct for session capabilities defining the proxy settings
/// 
/// For more details please see https://www.w3.org/TR/webdriver/#proxy
pub struct Proxy{
    pub(crate) proxy_string: String
}
impl Proxy{
    pub fn new()->Self{
        Proxy{
            proxy_string: String::from("{"),
        }
    }
    ///Indicates the type of proxy configuration.
    pub fn set_proxy_type(&mut self, proxy_type: ProxyType)->&mut Self{
        let text = match proxy_type{
            ProxyType::Pac=>r#""proxyType":"pac"}"#,
            ProxyType::System=>r#""proxyType":"system"}"#,
            ProxyType::Manual=>r#""proxyType":"manual"}"#,
            ProxyType::Direct=>r#""proxyType":"direct"}"#,
            ProxyType::Autodetect=>r#""proxyType":"autodetect"}"#
        };
        construct_the_str(&mut self.proxy_string,text);
        self
    }
    ///Defines the URL for a proxy auto-config file if proxyType is equal to "pac".
    pub fn set_proxy_autoconfig_url(&mut self,url: &str)->&mut Self{
        let text =format!(r#""proxyAutoconfigUrl":"{}"}}"#,url);
        construct_the_str(&mut self.proxy_string, &text);
        self
    }
    ///Defines the proxy host for FTP traffic when the proxyType is "manual".
    pub fn set_ftp_proxy(&mut self,host_and_port:&str)->&mut Self{
        let text =format!(r#""ftpProxy":"{}"}}"#,host_and_port);
        construct_the_str(&mut self.proxy_string,&text);
        self
    }
    ///Defines the proxy host for HTTP traffic when the proxyType is "manual".
    pub fn set_http_proxy(&mut self,host_and_port:&str)->&mut Self{
        let text =format!(r#""httpProxy":"{}"}}"#,host_and_port);
        construct_the_str(&mut self.proxy_string,&text);
        self
    }
    ///Lists the address for which the proxy should be bypassed when the proxyType is "manual".
    pub fn set_no_proxy(&mut self, exceptions: Vec<&str>)->&mut Self{
        let v2s = from_vec_to_str(exceptions);
        let text =format!(r#""noProxy":{}}}"#,v2s);
        construct_the_str(&mut self.proxy_string,&text);
        self
    }
    ///Defines the proxy host for encrypted TLS traffic when the proxyType is "manual".
    pub fn set_ssl_proxy(&mut self,host_and_port:&str)->&mut Self{
        let text =format!(r#""sslProxy":"{}"}}"#,host_and_port);
        construct_the_str(&mut self.proxy_string,&text);
        self
    }
    ///Defines the proxy host for a SOCKS proxy when the proxyType is "manual".
    pub fn set_socks_proxy(&mut self,host_and_port:&str)->&mut Self{
        let text =format!(r#""socksProxy":"{}"}}"#,host_and_port);
        construct_the_str(&mut self.proxy_string,&text);
        self
    }
    ///Defines the SOCKS proxy version when the proxyType is "manual".
    pub fn set_socks_version(&mut self,version: u8)->&mut Self{
        let text = format!(r#""socksVersion":{}}}"#,version);
        construct_the_str(&mut self.proxy_string,&text);
        self
    }

}

pub enum ProxyType{
    Pac,
    Direct,
    Autodetect,
    System,
    Manual
}

fn from_vec_to_str(vec: Vec<&str>)->String{
    if vec.len() == 0 {return String::from("[]");}
    let mut string_args = String::from("[");
    for st in vec{
        string_args.push('"');
        string_args.push_str(st);
        string_args.push('"');
        string_args.push(',');
    }
    string_args.pop();
    string_args.push(']');
    string_args
}
fn construct_the_str(st:&mut String,text:&str){
    let len = st.len();
    if (*st).as_bytes()[len-1] == '}' as u8{
        st.pop();
        st.push(',');
        st.push_str(text);
    }else{
        st.push_str(text);
    }
}

mod prox_t{
    use super::*;

    #[test]
    fn prox_const() {
        let mut prox = Proxy::new();
        prox.set_proxy_type(ProxyType::Pac)
        .set_proxy_autoconfig_url("http://my.com")
        .set_socks_version(220)
        .set_no_proxy(vec!["one","two"])
        .set_ftp_proxy("host:port")
        .set_http_proxy("host:port")
        .set_ssl_proxy("host:port")
        .set_socks_proxy("host:port");
        let mut st = prox.proxy_string.clone();
        st.pop();
        let ch = st.pop().unwrap();
        assert!(prox.proxy_string.contains("socksVersion")&&ch!=',');
    }
}