| // Licensed to the Software Freedom Conservancy (SFC) under one | |
| // or more contributor license agreements. See the NOTICE file | |
| // distributed with this work for additional information | |
| // regarding copyright ownership. The SFC licenses this file | |
| // to you under the Apache License, Version 2.0 (the | |
| // "License"); you may not use this file except in compliance | |
| // with the License. You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, | |
| // software distributed under the License is distributed on an | |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| // KIND, either express or implied. See the License for the | |
| // specific language governing permissions and limitations | |
| // under the License. | |
| use assert_cmd::Command; | |
| use assert_cmd::assert::AssertResult; | |
| use is_executable::is_executable; | |
| use selenium_manager::DASH_DASH_VERSION; | |
| use selenium_manager::files::path_to_string; | |
| use selenium_manager::logger::JsonOutput; | |
| use selenium_manager::shell; | |
| use selenium_manager::shell::run_shell_command; | |
| use std::borrow::BorrowMut; | |
| use std::env::consts::ARCH; | |
| use std::env::consts::OS; | |
| use std::path::{Path, PathBuf}; | |
| #[allow(dead_code)] | |
| pub fn get_selenium_manager() -> Command { | |
| let mut path = PathBuf::from(env!("CARGO_BIN_EXE_selenium-manager")); | |
| if !path.is_absolute() { | |
| path = std::env::current_dir() | |
| .expect("Unable to get current directory") | |
| .join(path); | |
| } | |
| if path.exists() { | |
| return Command::new(path); | |
| } | |
| if cfg!(windows) { | |
| let exe_path = path.with_extension("exe"); | |
| if exe_path.exists() { | |
| return Command::new(exe_path); | |
| } | |
| } | |
| panic!("Binary not found {}", path_to_string(&path)); | |
| } | |
| #[allow(dead_code)] | |
| pub fn assert_driver(cmd: &mut Command) { | |
| let stdout = get_stdout(cmd); | |
| let json: JsonOutput = serde_json::from_str(&stdout).unwrap(); | |
| let driver_path = Path::new(&json.result.driver_path); | |
| assert!(driver_path.exists()); | |
| assert!(is_executable(driver_path)); | |
| } | |
| #[allow(dead_code)] | |
| pub fn assert_browser(cmd: &mut Command) { | |
| let stdout = &cmd.unwrap().stdout; | |
| let output = std::str::from_utf8(stdout).unwrap(); | |
| let json: JsonOutput = serde_json::from_str(output).unwrap(); | |
| let browser_path = Path::new(&json.result.browser_path); | |
| assert!(browser_path.exists()); | |
| assert!(is_executable(browser_path)); | |
| } | |
| #[allow(dead_code)] | |
| pub fn get_driver_path(cmd: &mut Command) -> String { | |
| let stdout = &cmd.unwrap().stdout; | |
| let output = std::str::from_utf8(stdout).unwrap(); | |
| let json: JsonOutput = serde_json::from_str(output).unwrap(); | |
| path_to_string(Path::new(&json.result.driver_path)) | |
| } | |
| #[allow(dead_code)] | |
| pub fn exec_driver(cmd: &mut Command) -> String { | |
| let cmd_mut = cmd.borrow_mut(); | |
| let driver_path = get_driver_path(cmd_mut); | |
| let driver_version_command = | |
| shell::Command::new(&driver_path, vec![String::from(DASH_DASH_VERSION)]); | |
| let output = run_shell_command(driver_version_command).unwrap(); | |
| println!("**** EXEC DRIVER: {}", output); | |
| output | |
| } | |
| #[allow(dead_code)] | |
| pub fn get_stdout(cmd: &mut Command) -> String { | |
| let stdout = &cmd.unwrap().stdout; | |
| let output = std::str::from_utf8(stdout).unwrap(); | |
| println!("{}", output); | |
| output.to_string() | |
| } | |
| #[allow(dead_code)] | |
| pub fn get_stderr(cmd: &mut Command) -> String { | |
| let stderr = &cmd.unwrap().stderr; | |
| let err_output = std::str::from_utf8(stderr).unwrap(); | |
| println!("stderr: {}", err_output); | |
| err_output.to_string() | |
| } | |
| #[allow(dead_code)] | |
| pub fn assert_output( | |
| cmd: &mut Command, | |
| assert_result: AssertResult, | |
| expected_output: Vec<&str>, | |
| error_code: i32, | |
| ) { | |
| if assert_result.is_ok() { | |
| let stdout = &cmd.unwrap().stdout; | |
| let output = std::str::from_utf8(stdout).unwrap(); | |
| expected_output | |
| .iter() | |
| .for_each(|o| assert!(output.contains(o))); | |
| } else { | |
| assert!( | |
| assert_result | |
| .err() | |
| .unwrap() | |
| .to_string() | |
| .contains(&error_code.to_string()) | |
| ); | |
| } | |
| } | |
| #[allow(dead_code)] | |
| pub fn is_linux_arm64() -> bool { | |
| OS == "linux" && ARCH == "aarch64" | |
| } |